Azure Bicep explained in detail

Azure Bicep is a powerful and modern domain-specific language (DSL) designed to simplify the process of defining Azure resources and automating their deployment using Infrastructure as Code (IaC) principles.

It serves as an abstraction layer over Azure Resource Manager (ARM) templates, providing a simpler, more concise, and more readable syntax for Azure deployments.

While ARM templates are the traditional way to define resources in Azure, Bicep allows users to define their infrastructure in a cleaner and more maintainable way, without losing the flexibility and power of ARM templates.

In this extended version, we will dive deep into Azure Bicep's core concepts, its advantages over ARM templates, how to write and deploy Bicep templates, and its integration with the broader Azure ecosystem.

What Is Azure Bicep?

Azure Bicep is a declarative language for describing the configuration of Azure resources.

It allows you to write infrastructure-as-code templates that are more readable, less error-prone, and maintainable compared to the equivalent JSON-based ARM templates.

While Bicep files are easier to write, the beauty of the tool is that it compiles down to ARM templates, which are natively supported by Azure’s Resource Manager for deployment.

Bicep was introduced to address the following pain points of using ARM templates:

Verbose Syntax

ARM templates are written in JSON, which is highly verbose and lacks features like variable interpolation, leading to bloated templates.

Error-prone Manual Configuration

ARM templates often require repeating patterns and nested blocks, leading to human error and harder-to-maintain configurations.

Lack of Modularity

While ARM templates allow reuse via nested templates, Bicep makes it easier to create reusable modules and integrate them into larger deployments.

Bicep provides the same functionality as ARM templates but in a simplified, more intuitive syntax, without compromising on its power.

Key Features And Benefits Of Azure Bicep

1. Declarative Syntax

Just like ARM templates, Bicep is declarative.

You describe what you want in your Azure environment (the resources and configurations), and Azure handles how those resources will be deployed.

This is in contrast to imperative programming, where you specify the exact steps to create and configure resources.

2. Simplified and More Readable Syntax

Bicep provides a more concise and human-readable syntax compared to JSON.

This makes it easier for developers, DevOps engineers, and even beginners to work with infrastructure-as-code.

Example of a storage account definition in Bicep

xxxxxxxxxx
8
1
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = {
2
  name: 'mystorageacct'
3
  location: 'East US'
4
  sku: {
5
    name: 'Standard_LRS'
6
  }
7
  kind: 'StorageV2'
8
}

Equivalent ARM template (JSON)

xxxxxxxxxx
18
1
{
2
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
3
  "contentVersion": "1.0.0.0",
4
  "resources": [
5
    {
6
      "type": "Microsoft.Storage/storageAccounts",
7
      "apiVersion": "2021-04-01",
8
      "location": "East US",
9
      "properties": {
10
        "sku": {
11
          "name": "Standard_LRS"
12
        },
13
        "kind": "StorageV2"
14
      },
15
      "name": "mystorageacct"
16
    }
17
  ]
18
}

3. Modularity and Reusability

Bicep enables the creation of modules, which allow you to group and reuse sections of code in your infrastructure templates.

This improves the maintainability of your code and allows for more modular and organized deployments, especially for larger or more complex environments.

Example of a module in Bicep

xxxxxxxxxx
7
1
module storageModule './storageAccount.bicep' = {
2
  name: 'storageModule'
3
  params: {
4
    storageAccountName: 'myStorageAccount'
5
    location: 'East US'
6
  }
7
}

In this example, storageAccount.bicep can be reused in multiple places with different parameters.

4. No State Management Required

Unlike other IaC tools like Terraform, Bicep does not require state file management.

Azure’s Resource Manager manages the state of the resources you deploy, meaning you don’t need to worry about syncing, locking, or storing state files separately.

5. Integration with Azure Tools

Bicep integrates seamlessly with Azure CLI, Azure PowerShell, Azure DevOps, and GitHub Actions for continuous integration/continuous deployment (CI/CD).

This makes Bicep ideal for managing the deployment and maintenance of Azure resources in automated workflows.

6. Native Azure Compatibility

Bicep compiles directly to ARM templates, which means it is fully compatible with Azure’s Resource Manager.

If you have experience with ARM templates, Bicep will feel very familiar, as it leverages the full set of Azure features, including RBAC, Policies, Azure Monitor, and Azure Security Center.

7. Tooling Support

Bicep provides tooling support through Visual Studio Code extensions.

Features include

• Syntax highlighting

• Code completion and intelligent suggestions

• Linting for errors

• Inline documentation for resource types and parameters

Core Concepts In Azure Bicep

Azure Bicep uses several key concepts that are essential for defining and deploying Azure resources effectively:

1. Resources

In Bicep, resources represent the Azure services you want to deploy.

Resources are declared using the resource keyword, followed by the resource type, version, and properties.

Example of a resource declaration for a Storage Account

xxxxxxxxxx
8
1
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = {
2
  name: 'mystorageacct'
3
  location: 'East US'
4
  sku: {
5
    name: 'Standard_LRS'
6
  }
7
  kind: 'StorageV2'
8
}

2. Parameters

Parameters allow you to make your templates dynamic and reusable.

These are inputs that can be passed when deploying the Bicep file.

Example of parameters in Bicep

xxxxxxxxxx
2
1
param location string = 'East US'
2
param storageAccountName string

Parameters can also have default values and allowed values to restrict the possible inputs.

3. Variables

Variables are used to store values for reuse within the template.

They simplify the code and help avoid repetition, especially for complex expressions.

Example of variables in Bicep

xxxxxxxxxx
1
1
var storageAccountId = resourceId('Microsoft.Storage/storageAccounts', storageAccountName)

4. Outputs

Outputs define values that are returned after the deployment.

These can be useful for sharing resource information (such as resource IDs or URLs) between different templates or for use in further processes.

Example of an output in Bicep

xxxxxxxxxx
1
1
output storageAccountId string = storageAccount.id

5. Loops and Conditions

Bicep supports loops and conditions to allow the dynamic generation of resources.

For example, you can use a loop to create multiple virtual machines or use a condition to create a resource only if a certain condition is met.

Example of a loop in Bicep

xxxxxxxxxx
12
1
resource myVm 'Microsoft.Compute/virtualMachines@2021-03-01' = [for i in range(0, 3): {
2
  name: 'vm${i}'
3
  location: 'East US'
4
  properties: {
5
    hardwareProfile: {
6
      vmSize: 'Standard_B1s'
7
    }
8
    osProfile: {
9
      computerName: 'vm${i}'
10
    }
11
  }
12
}]

How Azure Bicep Works

1. Writing a Bicep Template

Write your infrastructure code using Bicep syntax, which is easier to read and write than traditional JSON-based ARM templates.

2. Compiling Bicep to ARM Template

Once you write the Bicep template, it is compiled into an ARM template (JSON format).

This is done automatically by the Bicep CLI, and it is a seamless process.

3. Deploying with Azure Tools

After the Bicep template is compiled, it can be deployed using Azure CLI, Azure PowerShell, or as part of a CI/CD pipeline in Azure DevOps or GitHub Actions.

How To Use Azure Bicep

1. Install the Bicep CLI

To start using Bicep, you first need to install the Bicep CLI.

Install via Azure CLI:

xxxxxxxxxx
1
1
az bicep install

To verify the installation:

xxxxxxxxxx
1
1
bicep --version

2. Write a Simple Bicep Template

Example of deploying a storage account in Bicep:

xxxxxxxxxx
15
1
param location string = 'East US'
2
param storageAccountName string
3

4

5
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = {
6
  name: storageAccountName
7
  location: location
8
  sku: {
9
    name: 'Standard_LRS'
10
  }
11
  kind: 'StorageV2'
12
}
13

14

15
output storageAccountId string = storageAccount.id

3. Compile Bicep to ARM Template

To convert your Bicep template into an ARM template (JSON format), use the following command:

xxxxxxxxxx
1
1
bicep build myTemplate.bicep

This will generate a myTemplate.json file.

4. Deploy the Bicep Template

To deploy the Bicep template, use Azure CLI:

xxxxxxxxxx
1
1
az deployment group create --resource-group myResourceGroup --template-file myTemplate.bicep

This will trigger the deployment of resources defined in the Bicep template.

Best Practices For Using Azure Bicep

1. Modularize Templates

Break down large templates into smaller, reusable modules.

This promotes code reuse and keeps the templates easier to manage.

2. Parameterize the Template

Use parameters to make your templates flexible and reusable in different environments (dev, test, production).

You can define parameters for regions, resource names, or any other value.

3. Leverage Outputs

Use outputs to pass information from one deployment to another or to integrate with other automation processes.

4. Version Control

Store your Bicep files in a version control system like Git.

This enables better collaboration and tracking of changes to your infrastructure.

5. Validate the Bicep Template

Always validate your Bicep template before deployment to ensure there are no syntax or logical errors.

xxxxxxxxxx
1
1
bicep build myTemplate.bicep --no-restore

Conclusion

Azure Bicep is an excellent tool for simplifying the deployment of Azure resources with a cleaner, more readable, and developer-friendly syntax compared to traditional ARM templates.

By embracing infrastructure as code (IaC) principles, Bicep enables easier automation, better maintainability, and more efficient cloud management.

Whether you're a developer, DevOps engineer, or someone managing large-scale Azure environments, Bicep provides an intuitive and robust way to define and deploy resources.

It helps streamline your workflows and integrates well with Azure's native tools and services, making it a compelling choice for anyone looking to automate and scale their Azure resources.

By leveraging the power of modularization, parameters, and outputs, you can take full advantage of Bicep's capabilities to build maintainable, reusable, and scalable infrastructure on Azure.