ARM Templates and Bicep

What it is

Templates let you describe the resources you want in a file and have Azure create them. The same file gives the same result every time, which makes deployments repeatable and reviewable.

Two formats exist. An ARM template is JSON. Bicep is a simpler language that compiles to an ARM template. The exam asks you to read one, change it, deploy it and convert between them.

How it works

ARM template structure

An ARM template is a JSON file with these main sections.

Resources can depend on each other. dependsOn states an order, and Azure also infers dependencies when one resource refers to another.

Bicep

Bicep is a declarative language with less punctuation than JSON. It supports the same features.

param location string = resourceGroup().location

resource sa 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: 'stcontoso001'
  location: location
  sku: { name: 'Standard_LRS' }
  kind: 'StorageV2'
}

output storageId string = sa.id

• param declares an input, var a calculated value and output a returned value.
• resource declares a resource, with a symbolic name, the type and API version.
• module calls another Bicep file so that you can reuse it.
• targetScope sets the scope of the deployment.

Values can come from a parameter file, either JSON or .bicepparam, so the same template serves several environments.

Deploying

A template can be deployed to a resource group, a subscription, a management group or a tenant.

az deployment group create --resource-group rg-app --template-file main.bicep --parameters location=westeurope
New-AzResourceGroupDeployment -ResourceGroupName rg-app -TemplateFile main.bicep
az deployment group what-if --resource-group rg-app --template-file main.bicep

The what-if command previews the changes without making them.

Deployment modes

Exporting and converting

You can export a resource group, or a past deployment, as an ARM template from the portal. The export is a starting point and may need cleaning up.

az bicep decompile --file main.json
az bicep build --file main.bicep

decompile converts an ARM template to Bicep on a best effort basis. build converts a Bicep file to an ARM template.

Parameters in a template

A parameter file keeps the values separate from the template, so one template serves test and production.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": { "location": { "value": "westeurope" } }
}

Useful template functions

Checking and troubleshooting a deployment

Before deploying, validate the template and run what-if. After a failed deployment, open the deployment history on the resource group, or use the CLI.

az deployment group show --resource-group rg-app --name main
az deployment operation group list --resource-group rg-app --name main

The operations list shows which resource failed and why. Remember that the Activity log records the same errors.

Reusing templates

A Bicep module is a file that another file calls, so that a common pattern such as a storage account is written once. For ARM JSON the same idea is a linked template. Both keep large deployments manageable.

How the exam asks about this

• "Deploy the same environment repeatedly." An ARM template or Bicep file.
• "Remove anything not in the file." Complete mode.
• "Preview what a deployment will change." what-if.
• "Convert a template into Bicep." az bicep decompile.
• "Export what already exists." Export template from the resource group.