Introduction

Hey there, Everone! 👋 Ready to take your Bicep skills up a notch? Great! Today, we’re going to chat about something super cool in Azure Bicep: variables. Don’t worry if that sounds fancy - I promise it’s easier than you think🌟

Remember when we talked about how Azure Bicep makes deploying Azure resources a breeze? And And how parameters let us customize our deployments without messing with the main code? Well, variables are like the next step in making our Bicep code even more awesome.

Think of variables as reusable labels for pieces of information in your Bicep template. For example, let’s say you’re setting up a web app, and you need to use the name “myAwesomeWebApp” in several places - for the app service, the app service plan, and maybe even a related storage account. Instead of typing out “myAwesomeWebApp” every single time (and risking typos!), you can create a variable like this:

1

var webAppName = 'myAwesomeWebApp'

Now, whenever you need to use that name, you just use webAppName. If you later decide to change the name of your web app, you only need to update it in one place - where you defined the variable. Neat, right?

In this article, we’re going to explore:

• What exactly variables are in Azure Bicep (no computer science degree required, I promise!)
• How to create and use these handy little helpers in your code

By the time we’re done, you’ll be using variables like a pro, making your Bicep code cleaner and easier to manage. So, grab your favorite drink ☕️, get comfy, and let’s dive into the world of Azure Bicep variables🚀.

What are Variables in Azure Bicep?

Let’s talk about what variables are in Azure Bicep and why they’re so useful.

In simple terms, a variable in Azure Bicep is a named container that holds a value. You can think of it as a label for a piece of information that you want to use multiple times in your template.

Here’s a basic example of how to declare a variable in Bicep:

1

var storageName = 'mystorageaccount'

In this case, storageName is our variable, and 'mystorageaccount' is the value it holds.

Now, let’s see how we can use this variable in a Bicep template:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var storageName = 'mystorageaccount'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: storageName
  location: 'eastus'
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

In this example, we’re using the storageName variable to set the name of our storage account resource.

But why use a variable instead of just writing the name directly? Here’s where the power of variables becomes clear.

Imagine we decide to change the name of our storage account from ‘mystorageaccount’ to ‘mynewstorageaccount’. Without variables, we would have to manually search through our entire Bicep file and update every occurrence of the old name. In a larger, more complex Bicep template, this process can quickly become time-consuming and prone to errors.

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

1

var storageName = 'mynewstorageaccount'

And just like that, the change will automatically be applied everywhere we use the storageName variable in our template. This saves us time and reduces the risk of mistakes that could occur if we accidentally missed updating the name in one place.

Using variables in this way offers several benefits:

1. It makes our code easier to read and understand.
2. It helps us avoid typos and inconsistencies.
3. It allows us to make changes quickly and confidently.
4. It makes our templates more maintainable, especially as they grow in complexity.

As you start working with more complex Azure resources and larger templates, you’ll find that variables become an invaluable tool in keeping your Bicep code clean, efficient, and easy to manage.

Variables vs Parameters in Azure Bicep: When to Use What? 🤔

Now that we understand what variables are, let’s take a moment to compare them with their cousins: parameters. Both are important in Azure Bicep, but they serve different purposes. Let’s break it down:

Parameters: The Customizable Inputs 🎛️

Parameters are like inputs to your Bicep template. They allow you to pass in values from outside when you deploy your template. This makes your template flexible and reusable.

Example of a parameter:

1

param location string = 'eastus'

Variables: The Internal Helpers 🧰

Variables, as we’ve learned, are defined and used entirely within your Bicep template. They help you organize and reuse values inside your template.

Example of a variable:

1

var storageName = 'mystorageaccount'

When to Use Parameters:

1. When you want to allow the value to be changed at deployment time.
2. For values that might differ between environments (dev, test, prod).
3. When you want to make your template more reusable across different projects or scenarios.

When to Use Variables:

1. For values that are used multiple times within your template.
2. When you want to calculate or construct a value based on other variables or parameters.
3. To improve readability by giving meaningful names to complex expressions.

A Simple Comparison:

Let’s look at a small example that uses both:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

param environment string = 'dev'
param location string = 'eastus'

var storageName = 'storage${environment}'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

In this example:

• environment and location are parameters. They can be different each time you deploy the template.
• storageName is a variable. It’s constructed using the environment parameter, but it’s defined within the template.

By using parameters for environment and location, you can easily deploy this template to different environments or regions without changing the template itself. The storageName variable helps construct a consistent naming pattern based on the environment.

Remember, the choice between parameters and variables often comes down to whether you need the flexibility to change the value from outside the template (use a parameter) or if it’s an internal value that helps organize your template (use a variable).

As you work more with Bicep, you’ll get a feel for when to use each. Don’t worry if it’s not always clear cut – sometimes you might start with a variable and later realize it would be better as a parameter, or vice versa. That’s all part of the learning process! 😊

Declaring Variables in Azure Bicep

Now that we understand what variables are and how they differ from parameters, let’s dive into how to declare them in our Bicep 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 storageName with the value ‘mystorageaccount’, you would write:

1

var storageName = 'mystorageaccount'

Simple, right? 😄

Now, let’s talk about the different types of values you can assign to your variables. Azure Bicep supports various data types, including:

• string: A sequence of characters, enclosed in single quotes (') or double quotes ("). Example: var greeting = 'Hello, Azure Bicep!'

• int: A whole number, without any quotes. Example: var maxRetries = 5

• bool: A boolean value, either true or false, without any quotes. Example: var isProduction = false

• array: A collection of values, enclosed in square brackets ([]), with elements separated by commas. Example: var allowedRegions = ['eastus', 'westus', 'northeurope']

• object: A collection of key-value pairs, enclosed in curly braces ({}), with elements separated by commas. Example: var tags = { environment: 'dev', project: 'bicep-learning' }

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

1
2
3
4
5
6
7
8

var location = 'eastus'
var instanceCount = 3
var enableLogging = true
var allowedPorts = [80, 443, 3389]
var vmSettings = {
  size: 'Standard_D2s_v3'
  osDiskType: 'Premium_LRS'
}

As you can see, declaring variables in Azure Bicep is pretty straightforward! You can use any of these data types to store and reference values within your Bicep templates, making your code more organized and easier to manage.

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 and maintainable. Get ready to put your new knowledge to work! 💪

Using Variables in Azure Bicep

Now that we know how to declare variables, let’s see how to use them in our Bicep templates! 🛠️

Basic Usage

Here’s a simple example of how to use a variable:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var storageName = 'mystorageaccount'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: storageName  // Using the variable here
  location: 'eastus'
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

In this example, we use the storageName variable to set the name of our storage account resource. The final name of the storage account will be ‘mystorageaccount’.

Combining Variables

Variables become even more powerful when you start combining them. Let’s look at an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var baseNamePrefix = 'myproject'
var environment = 'dev'
var storageNameSuffix = '01'

var storageName = '${baseNamePrefix}${environment}${storageNameSuffix}'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: storageName  // This will be 'myprojectdev01'
  location: 'eastus'
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

Here, we’re building our storage account name by combining several variables. The final storageName will be ‘myprojectdev01’. This approach gives us flexibility in naming our resources while maintaining consistency.

Using Variables with Conditionals

Variables can also be used in conditional expressions. Here’s an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

param environment string = 'dev'

var isProd = environment == 'prod'
var storageSku = isProd ? 'Standard_GRS' : 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: 'mystorageaccount'
  location: 'eastus'
  kind: 'StorageV2'
  sku: {
    name: storageSku  // This will be 'Standard_GRS' for prod, 'Standard_LRS' for others
  }
}

In this example, we’re using a variable to determine the SKU of our storage account based on the environment.

Let’s break down that conditional expression:

• isProd = environment == 'prod': This checks if the environment is ‘prod’ and stores true or false in isProd.
• storageSku = isProd ? 'Standard_GRS' : 'Standard_LRS': This is a conditional expression. It’s like asking a question:
  • If isProd is true, use ‘Standard_GRS’
  • If isProd is false, use ‘Standard_LRS’

So, if environment is ‘prod’, storageSku will be ‘Standard_GRS’. For any other value of environment, it will be ‘Standard_LRS’.

This is a bit of an advanced technique, but it’s good to know about for when you start creating more complex templates!

Variables in Loops

Variables can also be super helpful when working with loops in Bicep. Here’s a simple example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var regions = [
  'eastus'
  'westus2'
  'northeurope'
]

resource storageAccounts 'Microsoft.Storage/storageAccounts@2021-06-01' = [for region in regions: {
  name: 'mystorage${region}'
  location: region
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}]

In this example, we’re using a variable to store an array of regions, and then using that in a loop to create a storage account in each region. The final names of the storage accounts will be:

• ‘mystorageeastus’
• ‘mystoragewestus2’
• ‘mystoragenortheurope’

This loop is saying “for each region in our regions variable, create a storage account”. It’s a powerful way to create multiple similar resources without repeating code.

Remember, the power of variables lies in their reusability and ability to make your code more readable and maintainable. As you work more with Bicep, you’ll discover many creative ways to use variables to simplify your templates and make them more flexible.

In the next section, we’ll look at some best practices for using variables in your Bicep templates. Get ready to level up your Bicep skills even further! 🚀

Best Practices for Using Variables in Azure Bicep

Now that you’re familiar with how to declare and use variables in Azure Bicep, let’s look at some best practices to help you write clean, efficient, and maintainable code.

1. Use Descriptive Names Give your variables clear, descriptive names that indicate their purpose. For example, instead of var n = 'mystorageaccount', use var storageName = 'mystorageaccount'.

2. Use camelCase for Variable Names In Bicep, the convention is to use camelCase for variable names. For example: var resourceGroupName, var locationName.

3. Group Related Variables If you have multiple related variables, consider grouping them together in your code. This makes your template easier to read and maintain.

   1 2 3 4 5

   var storageSettings = { name: 'mystorageaccount' sku: 'Standard_LRS' kind: 'StorageV2' }

4. Use Variables for Repeated Values If you find yourself using the same value multiple times in your template, consider making it a variable. This makes it easier to update the value in the future if needed.

5. Leverage Variables for Complex Expressions If you have a complex expression that you need to use multiple times, consider storing it in a variable. This can make your code more readable and easier to maintain.

   1 2	var isProduction = environment == 'prod' var storageSku = isProduction ? 'Standard_GRS' : 'Standard_LRS'

6. Comment Your Variables For complex variables or those with non-obvious purposes, add a comment explaining what the variable is for. This will help others (and future you) understand your code.

   1 2	// Define the allowed regions for resource deployment var allowedRegions = ['eastus', 'westus2', 'northeurope']

7. Don’t Overuse Variables While variables are useful, don’t create a variable for every single value in your template. Use them when they provide clarity, reduce repetition, or simplify complex expressions.

Remember, the goal of using variables is to make your Bicep templates more readable, maintainable, and less prone to errors. As you write more Bicep code, you’ll develop a sense for when and how to best use variables in your templates.

In the next section, we’ll look at some common pitfalls to avoid when working with variables in Azure Bicep.

Conclusion

Congratulations! 🎉 You’ve now mastered the basics of using variables in Azure Bicep. Let’s quickly recap what we’ve learned:

• Variables in Bicep are reusable containers for values within your template.
• They help make your code more readable, maintainable, and less prone to errors.
• You can use variables for simple values, complex expressions, and even in loops and conditions.
• Following best practices like using descriptive names and grouping related variables can greatly improve your Bicep templates.

Remember, the key to becoming proficient with variables (and Bicep in general) is practice. Don’t be afraid to experiment with different ways of using variables in your templates. As you work more with Bicep, you’ll develop an intuition for when and how to best use variables to make your infrastructure-as-code more efficient and easier to manage.

Next Steps

Now that you’re comfortable with variables, you’re ready to take the next step in your Azure Bicep journey! Here’s what’s coming up:

Explore Azure Bicep Modules: In our next article, we’ll dive into Bicep modules, which allow you to organize and reuse parts of your Bicep code. This powerful feature builds on your knowledge of variables and parameters, taking your Bicep skills to the next level.

Keep practicing with variables in your Bicep templates, and get ready to learn about modules in our upcoming article. See you there! 👋