Introduction

Welcome back, everyone! In our journey through the world of Azure Bicep, we’ve covered the basics and explored the power of parameters. Today, we’ll dive into another essential concept that will take your Bicep skills to the next level: variables. 🌟

In the previous articles, we learned how Azure Bicep simplifies the process of deploying Azure resources using a declarative language that’s more concise and readable than ARM templates. We also discovered how parameters make our Bicep code more reusable and maintainable by allowing us to customize deployments without modifying the code itself.

Now, imagine having a way to store and reuse values within your Bicep code, making it even more streamlined and efficient. That’s where variables come into play! 🎭

Variables are a fundamental concept in most programming languages and Infrastructure as Code (IaC) tools, and Azure Bicep is no exception. They allow you to assign a value to a name and reference that name throughout your code, making it easier to read, understand, and maintain.

In this article, we’ll explore:

• What variables are in the context of Azure Bicep 🔍
• How to declare and use variables in your Bicep code 📝

By the end of this article, you’ll have a solid grasp of how variables work in Azure Bicep and how they can help you write cleaner, more maintainable code. So, let’s get started on this exciting new chapter in our Azure Bicep journey! 🚀.

What are Variables in Azure Bicep?

Now that we’ve set the stage, let’s dive into the nitty-gritty of variables in Azure Bicep. 🏊‍♂️

In the simplest terms, a variable in Azure Bicep is a named container that holds a value. You can think of it as a box 📦 with a label on it. You put a value inside the box and refer to it by its label whenever you need to use that value in your code.

But wait, isn’t that similar to parameters? 🤔 While both variables and parameters are used to store values, there’s a key difference:

• Parameters are used to pass values into your Bicep code from the outside, such as when you deploy your resources using Azure CLI or PowerShell.
• Variables, on the other hand, are used to store and reuse values within your Bicep code itself.

Let’s take a look at a simple example to illustrate this concept:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

param location string = 'eastus'
var appServicePlanName = 'myAppServicePlan'

resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: appServicePlanName
  location: location
  sku: {
    name: 'F1'
    capacity: 1
  }
}

In this example, location is a parameter that allows you to specify the Azure region when deploying your resources. appServicePlanName, on the other hand, is a variable that holds the name of the App Service Plan resource. The value of appServicePlanName is used in the name property of the appServicePlan resource.

By using a variable for the App Service Plan name, we can easily update it in one place if needed, and the change will be reflected throughout our Bicep code. This makes our code more maintainable and less prone to errors.

Imagine if we decided to change the name of our App Service Plan from myAppServicePlan to myNewAppServicePlan. Without variables, we would have to manually search through our entire Bicep file and update every occurrence of the old name. In our small example, this might not seem like a big deal, but in a larger, more complex Bicep template, this process can quickly become cumbersome and error-prone. 😓

With variables, we can simply update the value of appServicePlanName in one place:

1

var appServicePlanName = 'myNewAppServicePlan'

And voila! 🪄 The change will automatically be propagated to every place where we reference the appServicePlanName variable in our code. This not only saves us time and effort but also reduces the risk of introducing errors by accidentally missing an occurrence of the old name.

As you can see, variables are a powerful tool in your Azure Bicep toolbox. They help you write code that is easier to read, understand, and maintain, especially as your templates grow in size and complexity. 📈

In the next section, we’ll take a closer look at how to declare variables in Azure Bicep and explore the different data types available to you. 🔍 Get ready to level up your Bicep skills! 💪

Declaring Variable in Azure Bicep

Now that we understand the importance of variables in Azure Bicep, let’s dive into how to declare them in our code. 📝

Declaring a variable in Azure Bicep is straightforward. You start with the keyword var, followed by the variable name, an equals sign (=), and the value you want to assign to the variable. Here’s the general syntax:

1

var variableName = value

For example, to declare a variable named appServicePlanName with the value 'myAppServicePlan', you would write:

1

var appServicePlanName = 'myAppServicePlan'

Easy, right? 😄

Now, let’s talk about the different data types you can use for your variables. Just like in other programming languages, Azure Bicep supports various data types, including:

• string: A sequence of characters, enclosed in single quotes (') or double quotes ("). Example: var myString = 'Hello, Azure Bicep!'
• int: A whole number, without any quotes. Example: var myInt = 42
• bool: A boolean value, either true or false, without any quotes. Example: var myBool = true
• array: A collection of values, enclosed in square brackets ([]), with elements separated by commas. Example: var myArray = [1, 2, 3, 4, 5]
• object: A collection of key-value pairs, enclosed in curly braces ({}), with elements separated by commas. Example: var myObject = { key1: 'value1', key2: 'value2' }

Here are a few more examples of declaring variables with different data types:

1
2
3
4
5
6
7
8
9

var location = 'eastus'
var appServicePlanSkuName = 'F1'
var appServicePlanSkuCapacity = 1
var isProduction = false
var tags = ['env', 'dev', 'project', 'myapp']
var appSettings = {
  APPINSIGHTS_INSTRUMENTATIONKEY: 'your_instrumentation_key'
  MYSQL_DATABASE: 'your_database_name'
}

As you can see, declaring variables in Azure Bicep is a breeze! 🍃 You can use any of the supported data types to store and reference values within your Bicep templates.

In the next section, we’ll explore how to use these variables in your Azure Bicep code and see some real-world examples of how they can make your templates more readable, reusable, and maintainable. 💡

Get ready to put your newfound knowledge of variables to work! 💪

Using Variables in Azure Bicep

Alright, now that we know how to declare variables in Azure Bicep, let’s put them to work! 💪 In this section, we’ll explore how to reference variables in your Bicep code and see some examples of how they can make your templates more concise and easier to maintain.

Referencing a variable in Azure Bicep is as simple as using its name wherever you want to use its value. Here’s an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var appServicePlanName = 'myAppServicePlan'

resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: appServicePlanName
  location: 'eastus'
  sku: {
    name: 'F1'
    capacity: 1
  }
}

In this example, we reference the appServicePlanName variable in the name property of the appServicePlan resource. When Azure Bicep compiles this template, it will replace appServicePlanName with its value, 'myAppServicePlan'.

But that’s just the tip of the iceberg! 🧊 Variables can be used in many places throughout your Bicep templates, such as:

• Resource names and properties
• Output values
• Expressions and functions
• Loops and conditions (which we’ll cover in a future article)

Using variables can help you simplify expressions, avoid repetition, and make your code more maintainable.

Conclusion 🎉

In this article, we’ve introduced the concept of variables in Azure Bicep. We’ve covered what variables are, how they differ from parameters, and how to declare and use them in your Bicep templates.

Variables are a powerful tool in your Azure Bicep toolbox, helping you write code that is easier to read, understand, and maintain. They allow you to store and reuse values within your Bicep code, making your templates more efficient and less error-prone.

In part two of this series, we’ll dive deeper into best practices for using variables, explore advanced use cases, and walk through a hands-on example of refactoring a Bicep template to leverage the power of variables.

See you soon, and happy coding! 👨‍💻👩‍💻