Delve into the Azure Bicep

Delve into the Azure Bicep

Bicep is a domain-specific language (DSL) developed by Microsoft to simplify and improve the authoring of Azure Resource Manager (ARM) templates. It is a declarative language designed to provide a more readable, concise, and manageable way of deploying resources in Microsoft Azure, while still compiling down to standard ARM JSON templates that Azure understands.

Bicep provides a higher-level abstraction over the raw JSON syntax of ARM templates, making it easier to work with and maintain, especially for large and complex deployments. It is essentially a simplified syntax for creating Azure infrastructure as code (IaC) that compiles to ARM templates, and is fully supported by Azure and integrated with Azure DevOps and Visual Studio Code.

Key Features of Bicep

Simplified Syntax: Bicep removes the verbosity of JSON, reducing the complexity of writing and maintaining templates.

Example of ARM Template (JSON):

xxxxxxxxxx
19
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.Network/virtualNetworks",
7
      "apiVersion": "2020-05-01",
8
      "location": "eastus",
9
      "name": "myVnet",
10
      "properties": {
11
        "addressSpace": {
12
          "addressPrefixes": [
13
            "10.0.0.0/16"
14
          ]
15
        }
16
      }
17
    }
18
  ]
19
}

Example of Bicep Template:

xxxxxxxxxx
11
1
resource vnet 'Microsoft.Network/virtualNetworks@2020-05-01' = {
2
  name: 'myVnet'
3
  location: 'eastus'
4
  properties: {
5
    addressSpace: {
6
      addressPrefixes: [
7
        '10.0.0.0/16'
8
      ]
9
    }
10
  }
11
}

Here are some of the benefits of using 'bicep'.

1. More Readable and Concise: Bicep syntax is less verbose compared to JSON. It removes the need for many of the metadata fields, such as "$schema", contentVersion, and apiVersion.

2. No More JSON: Bicep eliminates the need to write cumbersome JSON code with complex object structures, which often leads to errors.

3. Full ARM Template Compatibility: Every valid Bicep file can be compiled into a standard ARM template (JSON), and can be used in Azure deployments. All Azure resources available in ARM are also available in Bicep, and you can define custom resources in Bicep just like you would in ARM.

4. Modular and Reusable: Bicep supports modules to enable reusable components, which can help in modularizing complex deployments into smaller, maintainable parts. Modules in Bicep are essentially separate .bicep files that can be included in the main Bicep file.

5. Integrated with Azure and Tools: Bicep is natively supported by Azure CLI, Azure PowerShell, and Azure DevOps. Visual Studio Code offers Bicep extension support, providing features like syntax highlighting, auto-completion, error checking, and intellisense.

6. First-Class Support for Parameters and Outputs: Like ARM templates, Bicep supports parameters, variables, and outputs for flexible and dynamic deployments.

7. No State: Bicep is not a stateful language like Terraform; it simply compiles to ARM templates, and you must rely on Azure Resource Manager’s state management to track your infrastructure state.

How Does Bicep Work?

Bicep files are compiled into JSON ARM templates using the Bicep CLI. This compilation process ensures that Bicep's simplicity doesn't sacrifice its capability to deploy resources in Azure, as the output is a fully-fledged ARM template.

Example Workflow:

1. Write a Bicep Template:

You write a Bicep file that describes the Azure resources you want to deploy.

2. Compile Bicep to ARM JSON:

Use the Bicep CLI to compile the .bicep file into an ARM template (.json).

Example CLI Command:

xxxxxxxxxx
1
1
bicep build main.bicep

This command generates a corresponding main.json ARM template that can be deployed.

3. Deploy the ARM Template:

Once the .bicep file is compiled into a .json ARM template, you can deploy it using Azure CLI, PowerShell, or other Azure tools.

Example CLI Command to Deploy:

xxxxxxxxxx
3
1
az deployment group create \
2
--resource-group myResourceGroup \
3
--template-file main.json

Bicep vs ARM Templates

Example: Using Bicep

Bicep Template for a Virtual Network (vNet):

Here’s an example of how you would define a Virtual Network (vNet) in Bicep:

xxxxxxxxxx
11
1
resource vnet 'Microsoft.Network/virtualNetworks@2020-05-01' = {
2
  name: 'myVnet'
3
  location: 'eastus'
4
  properties: {
5
    addressSpace: {
6
      addressPrefixes: [
7
        '10.0.0.0/16'
8
      ]
9
    }
10
  }
11
}

Adding Parameters in Bicep:

xxxxxxxxxx
13
1
param vnetName string = 'myVnet'
2
param location string = 'eastus'
3
resource vnet 'Microsoft.Network/virtualNetworks@2020-05-01' = {
4
  name: vnetName
5
  location: location
6
  properties: {
7
    addressSpace: {
8
      addressPrefixes: [
9
        '10.0.0.0/16'
10
      ]
11
    }
12
  }
13
}

Deploying a Bicep Template:

1. After writing the Bicep template, you can compile it to an ARM template using the Bicep CLI:

xxxxxxxxxx
1
1
bicep build myTemplate.bicep

2. Then, deploy it to Azure:

xxxxxxxxxx
3
1
az deployment group create \
2
--resource-group myResourceGroup \
3
--template-file myTemplate.json

Advantages of Bicep

1. Simplicity and Readability: Bicep templates are easier to read and write compared to the verbose JSON syntax of ARM templates, which makes managing Azure infrastructure simpler.

2. Faster Development: The Bicep syntax is concise, which allows you to write less code to define the same resources as in ARM templates, thus reducing development time.

3. Azure Integration: Bicep is fully supported by Azure CLI, PowerShell, Visual Studio Code (via the Bicep extension), and Azure DevOps, offering a great developer experience.

4. Interoperability: Since Bicep compiles directly to ARM templates, you can use it in any scenario where you would typically use ARM templates.

5. First-Class Modularity: Bicep's native module support allows you to structure your infrastructure as reusable and maintainable components.

Summary

Bicep is an essential tool for Azure developers, simplifying the process of managing and deploying Azure resources by providing a cleaner, more concise syntax than traditional ARM JSON templates. It provides a natural evolution from ARM templates, making infrastructure as code more accessible while maintaining full compatibility with the robust Azure resource deployment model.

By using Bicep, you can reduce the complexity of your deployment templates and improve the maintainability of your infrastructure, all while continuing to leverage Azure's powerful ARM deployment engine.