Bicep as ARM simplification in Azure - Step-by-Step Execution

Process Flow - Bicep as ARM simplification

Write Bicep code

↓

Bicep CLI compiles to ARM JSON

↓

ARM Template JSON deployed to Azure

↓

Azure resources created/updated

↓

Deployment result returned

Bicep code is written simply, then compiled into ARM JSON templates, which Azure deploys to create or update resources.

Execution Sample

Azure

param location string = 'eastus'
resource storage 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: 'mystorageaccount'
  location: location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

This Bicep code defines a storage account resource with parameters and properties, which compiles to ARM JSON for deployment.

Process Table

Step	Action	Input	Output	Notes
1	Write Bicep code	Bicep syntax with param and resource	Bicep file (.bicep)	User defines parameters and resources simply
2	Compile Bicep	Bicep file	ARM JSON template	Bicep CLI converts to ARM JSON format
3	Deploy ARM template	ARM JSON template	Azure deployment operation	Azure Resource Manager processes template
4	Create/Update resources	Deployment operation	Azure resources provisioned	Resources like storage account created
5	Return deployment result	Deployment status	Success or failure message	User sees deployment outcome

💡 Deployment completes when Azure finishes creating or updating resources.

Status Tracker

Variable	Start	After Compile	After Deploy	Final
location	'eastus'	'eastus'	'eastus'	'eastus'
storage resource	undefined	ARM JSON resource object	Provisioning started	Provisioned in Azure

Key Moments - 3 Insights

Why do we write Bicep code instead of ARM JSON directly?

Bicep code is simpler and easier to read than ARM JSON. The execution_table row 2 shows Bicep compiling to ARM JSON automatically, so you don't write complex JSON by hand.

What happens after compiling Bicep to ARM JSON?

After compiling (row 2), the ARM JSON is deployed to Azure (row 3), which then creates or updates resources (row 4). The compile step does not deploy, it only prepares the template.

Can I change parameters after deployment?

Parameters like 'location' are set before deployment (row 1). To change them, you update the Bicep code or parameters and redeploy, triggering a new deployment cycle.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output of step 2?

A Bicep code file

B ARM JSON template

C Azure deployment operation

D Provisioned Azure resources

💡 Hint

Check the 'Output' column for step 2 in the execution_table.

At which step does Azure start creating resources?

A Step 4

B Step 2

C Step 3

D Step 1

💡 Hint

Look at the 'Action' and 'Notes' columns in the execution_table for when resources are provisioned.

If you change the 'location' parameter in Bicep, which variable_tracker column shows the updated value after deployment?

A Start

B After Compile

C Final

D After Deploy

💡 Hint

Check the 'location' row in variable_tracker to see where the final deployed value appears.

Concept Snapshot

Bicep simplifies ARM templates by using concise syntax.
Write Bicep code with parameters and resources.
Compile Bicep to ARM JSON using CLI.
Deploy ARM JSON to Azure to create resources.
Bicep improves readability and maintainability.

Full Transcript

Bicep is a simpler way to write Azure infrastructure code compared to ARM JSON. You write Bicep code with parameters and resource definitions. Then, you use the Bicep CLI to compile this code into an ARM JSON template. This ARM template is what Azure understands for deployment. When you deploy the ARM template, Azure Resource Manager creates or updates the resources defined, such as storage accounts. The process ends when deployment completes successfully or with an error. Variables like parameters keep their values through compile and deploy steps. Bicep helps avoid writing complex JSON by hand and makes infrastructure as code easier to manage.

Practice

1. What is the main purpose of Bicep in Azure infrastructure management?

easy

A. To monitor Azure resources in real-time

B. To replace Azure CLI commands

C. To create virtual machines automatically

D. To simplify writing and managing Azure resource templates

Solution

1. Step 1: Understand Bicep's role

   Bicep is designed to simplify the process of writing infrastructure as code for Azure by providing a cleaner syntax than raw ARM templates.

2. Step 2: Compare with other options

   Options A, B, and C describe other Azure tools or features, not Bicep's main purpose.

3. Final Answer:

   To simplify writing and managing Azure resource templates -> Option D

4. Quick Check:

   Bicep simplifies Azure templates = D [OK]

Hint: Bicep makes Azure templates easier to write and read [OK]

Common Mistakes:

• Confusing Bicep with Azure CLI
• Thinking Bicep creates resources automatically
• Assuming Bicep monitors resources

2. Which of the following is the correct way to declare a string parameter named location in a Bicep file?

easy

A. param location string

B. parameter location = 'string'

C. var location string

D. resource location string

Solution

1. Step 1: Recall Bicep parameter syntax

   In Bicep, parameters are declared using the keyword param followed by the name and type, e.g., param location string.

2. Step 2: Eliminate incorrect options

   parameter location = 'string' uses incorrect syntax; var location string uses var which is for variables, not parameters; resource location string uses resource which is for resources.

3. Final Answer:

   param location string -> Option A

4. Quick Check:

   Parameter declaration = param name type [OK]

Hint: Use 'param' keyword for parameters in Bicep [OK]

Common Mistakes:

• Using 'var' instead of 'param' for parameters
• Confusing resource declaration with parameter
• Incorrect assignment syntax for parameters

3. Given this Bicep snippet:

param storageAccountName string = 'mystorage'
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = {
  name: storageAccountName
  location: 'eastus'
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

What will be the name of the deployed storage account?

medium

A. mystorage

B. storageAccountName

C. Standard_LRS

D. eastus

Solution

1. Step 1: Identify the parameter value

   The parameter storageAccountName is set to the string 'mystorage'.

2. Step 2: Check resource name assignment

   The resource's name property uses the parameter storageAccountName, so the deployed storage account will be named 'mystorage'.

3. Final Answer:

   mystorage -> Option A

4. Quick Check:

   Resource name = parameter value 'mystorage' [OK]

Hint: Resource name uses parameter value directly [OK]

Common Mistakes:

• Confusing parameter name with its value
• Choosing SKU or location as name
• Assuming default resource name

4. You wrote this Bicep code:

param location string
var location = 'westus'
resource vm 'Microsoft.Compute/virtualMachines@2022-03-01' = {
  name: 'myVM'
  location: location
}

What is the error in this code?

medium

A. Missing SKU property in the resource

B. Resource name must be a parameter, not a string

C. Variable and parameter have the same name causing conflict

D. Location property cannot be a variable

Solution

1. Step 1: Identify naming conflict

   Both a parameter and a variable are named location, which causes a conflict in Bicep because names must be unique in the same scope.

2. Step 2: Check other options

   Resource name can be a string literal; SKU is not mandatory for all resources; location can be a variable if no conflict exists.

3. Final Answer:

   Variable and parameter have the same name causing conflict -> Option C

4. Quick Check:

   Duplicate names cause errors in Bicep [OK]

Hint: Avoid using same name for param and var [OK]

Common Mistakes:

• Thinking resource name must be a parameter
• Assuming SKU is always required
• Believing location cannot be variable

5. You want to deploy two storage accounts in different locations using Bicep. Which approach correctly uses a loop to create these resources?

hard

A. param locations string = 'eastus,westus'
resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = {
name: 'storage'
location: locations
kind: 'StorageV2'
sku: { name: 'Standard_LRS' }
}

B. var locations = ['eastus', 'westus']
resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = [for loc in locations: {
name: 'storage${loc}'
location: loc
kind: 'StorageV2'
sku: { name: 'Standard_LRS' }
}]

C. var locations = ['eastus', 'westus']
resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = {
name: 'storage'
location: locations
kind: 'StorageV2'
sku: { name: 'Standard_LRS' }
}

D. param locations array = ['eastus', 'westus']
resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = for loc in locations {
name: 'storage'
location: loc
kind: 'StorageV2'
sku: { name: 'Standard_LRS' }
}

Solution

1. Step 1: Understand Bicep loop syntax

   Bicep uses array loops with the syntax [for item in array: { ... }] to create multiple resources.

2. Step 2: Analyze each option

   var locations = ['eastus', 'westus'] resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = [for loc in locations: { name: 'storage${loc}' location: loc kind: 'StorageV2' sku: { name: 'Standard_LRS' } }] correctly uses a variable array and a loop to create multiple storage accounts with unique names and locations. Options B and C misuse the location property by assigning an array directly. param locations array = ['eastus', 'westus'] resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = for loc in locations { name: 'storage' location: loc kind: 'StorageV2' sku: { name: 'Standard_LRS' } } has incorrect loop syntax missing square brackets.

3. Final Answer:

   var locations = ['eastus', 'westus'] resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-04-01' = [for loc in locations: { name: 'storage${loc}' location: loc kind: 'StorageV2' sku: { name: 'Standard_LRS' } }] -> Option B

4. Quick Check:

   Bicep loops use [for item in array: {...}] [OK]

Hint: Use [for item in array: {...}] for resource loops [OK]

Common Mistakes:

• Assigning array directly to location property
• Incorrect loop syntax without brackets
• Using string instead of array for multiple locations