What is Azure Bicep?

Azure Bicep is a domain-specific language (DSL) for deploying Azure resources, serving as a simpler, more concise alternative to Azure Resource Manager (ARM) templates.

Bicep provides a more developer-friendly syntax, making it easier to define and deploy Azure resources, while still leveraging the power and features of the Azure Resource Manager (ARM) engine.

Bicep is designed to improve the experience of working with Infrastructure as Code (IaC) in Azure.

While ARM templates are written in JSON and can be verbose and complex, Bicep allows users to define the same infrastructure using a cleaner, more readable syntax.

It compiles down to ARM templates (JSON) behind the scenes, ensuring compatibility with Azure's deployment engine.

Why Use Azure Bicep?

Azure Bicep offers several advantages over traditional ARM templates:

1. Simplicity and Readability:

Bicep simplifies the syntax compared to JSON-based ARM templates.

The result is cleaner, more readable code that is easier for developers and DevOps teams to write, understand, and maintain.

2. Declarative Infrastructure as Code (IaC):

Like ARM templates, Bicep is declarative in nature, meaning you define what resources you want and their configurations, and the Azure Resource Manager takes care of the rest.

You don’t need to worry about the how of resource creation and management.

3. No State Management Required:

Unlike some IaC tools like Terraform, Bicep does not require managing state files.

Azure handles the tracking and state management of the resources you deploy, making Bicep a more streamlined option.

4. Built on ARM:

Bicep is compiled down to ARM templates behind the scenes.

This ensures that all the features and capabilities available in ARM templates are also available in Bicep, including the use of Azure Policies, role-based access control (RBAC), and other Azure-specific features.

5. Supports Advanced Features:

Bicep supports modules, loops, and conditions, which allow you to write reusable and dynamic templates.

6. Integration with Azure CLI and Azure PowerShell:

Bicep is tightly integrated with Azure CLI and Azure PowerShell.

It’s designed to be used seamlessly in Azure’s automation and deployment pipelines.

Core Concepts of Azure Bicep

Before we dive into examples, let’s go over the core concepts of Azure Bicep:

1. Resources:

Resources in Bicep are defined using the resource keyword, much like in ARM templates.

These represent the Azure services (e.g., Virtual Machines, Storage Accounts, etc.) that you want to deploy.

Example of a Bicep resource definition:

xxxxxxxxxx
8
1
resource myStorageAccount '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 define dynamic values that can be passed into the Bicep template during deployment.

This makes the template more flexible and reusable.

Example of parameters in Bicep:

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

3. Variables:

Variables in Bicep are used to store values that are evaluated once and can be reused throughout the template.

They simplify code by avoiding repetitive definitions.

Example of variables in Bicep:

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

4. Outputs:

Outputs in Bicep are values that are returned after the deployment.

These values can be anything from resource IDs to specific attributes or even computed results.

Example of outputs in Bicep:

xxxxxxxxxx
1
1
output storageAccountId string = myStorageAccount.id

5. Modules:

Modules allow you to reuse common pieces of infrastructure code, enabling you to manage large deployments efficiently.

A Bicep module is a separate file that contains Bicep code and can be called from other Bicep files.

Example of a module in Bicep:

xxxxxxxxxx
6
1
module storageModule './storageAccount.bicep' = {
2
  name: 'storageModule'
3
  params: {
4
    storageAccountName: 'myStorage'
5
  }
6
}

6. Loops and Conditions:

Bicep supports loops (like for loops) and conditions to control the creation of resources based on certain criteria.

These features help you write dynamic templates based on inputs.

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 Bicep Code:

Bicep is a higher-level abstraction over ARM templates, meaning you write the Bicep code, which is easier to understand and maintain than its equivalent ARM JSON templates.

2. Compilation to ARM Templates:

Bicep code is compiled into ARM templates.

The Bicep CLI or Azure tools do this behind the scenes, so you don’t need to worry about the underlying complexity of ARM JSON.

3. Deployment:

Once compiled, the ARM template can be deployed using Azure CLI, Azure PowerShell, or through the Azure Portal.

4. Tooling Support:

Bicep has tooling support for editors like Visual Studio Code, with extensions that provide syntax highlighting, code completion, and validation.

Advantages of Using Azure Bicep

1. Simpler Syntax:

Bicep simplifies the syntax of ARM templates by eliminating JSON’s verbosity and reducing the need for repetitive code (such as defining resource types and versions in every resource).

This makes it much more readable.

2. Improved Developer Experience:

Bicep’s syntax is similar to popular programming languages, making it easier for developers familiar with languages like JavaScript or C# to adopt.

It also includes features like syntax validation and autocomplete when using compatible IDEs like Visual Studio Code.

3. Better Error Handling:

Bicep provides better error messages, which makes debugging easier than working with raw ARM templates.

This helps you pinpoint issues faster when something goes wrong during the deployment.

4. Modularization:

Bicep supports modules, which allows you to break down your infrastructure as code into reusable, manageable pieces.

This is especially useful for complex applications or large-scale deployments.

5. No State Management:

Unlike other IaC tools (e.g., Terraform), Bicep does not require manual state file management.

Azure itself handles the state of resources, simplifying the deployment and management process.

6. No Learning Curve for ARM Users:

Since Bicep compiles down to ARM templates, there is no need to relearn the ARM syntax or features.

All existing features of ARM are supported by Bicep, ensuring full compatibility with Azure's cloud resources.

7. Native Integration with Azure:

Bicep integrates seamlessly with Azure deployment tools like Azure CLI, Azure PowerShell, and Azure DevOps pipelines.

Bicep files are directly supported by Azure’s deployment processes, so there's no additional configuration required.

How to Use Azure Bicep

1. Install the Bicep CLI

To get started with Bicep, you'll need to install the Bicep CLI.

This can be done via several methods, including through the Azure CLI or by downloading the installer directly.

Using Azure CLI:

xxxxxxxxxx
1
1
az bicep install

To verify the installation:

xxxxxxxxxx
1
1
bicep --version

2. Writing a Bicep Template

Here's a simple Bicep example that deploys a Storage Account.

​x
1
param location string = 'East US'
2
param storageAccountName string
3

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

13
output storageAccountId string = storageAccount.id

3. Compile Bicep to ARM Template

To compile a Bicep file (template.bicep) to an ARM template:

xxxxxxxxxx
1
1
bicep build template.bicep

This generates a template.json file, which is the ARM template equivalent.

4. Deploy the Bicep Template

You can deploy the Bicep file directly using the Azure CLI:

xxxxxxxxxx
3
1
az deployment group create \
2
--resource-group MyResourceGroup \
3
--template-file template.bicep

Conclusion

Azure Bicep is a modern, efficient, and user-friendly alternative to traditional JSON-based ARM templates.

It enables Azure users to define their infrastructure with a simpler, cleaner syntax while retaining all the capabilities of ARM templates.

By using Bicep, you can improve readability, reduce errors, and streamline the process of deploying Azure resources in a declarative way.

The key benefits of using Bicep include easier syntax, improved developer experience, and seamless integration with Azure's native tools and services.

Whether you're building simple or complex deployments, Azure Bicep provides a great solution for Infrastructure as Code in Azure.