Greetings, everyone! This blog post marks the beginning of a series dedicated to exploring how YAML can be effectively utilized in conjunction with Bicep for deploying resources on Azure. This is the first part of a series. Here, we'll start with the basics of YAML and Bicep and learn how they work together to help us with resource provisioning on Azure.
💬 Why YAML, and What Are the Options?
After our introduction to this series, you might be wondering, Why YAML? YAML, which stands for YAML Ain't Markup Language, is a human-readable data serialization standard. It is used in a variety of programming and IT contexts, but why is it so important for Azure resource deployment, particularly with Bicep? Before we dive deeper into why YAML is a great choice, let's look at the alternatives available in ARM templates or Bicep:
🧑💻 Bicep Parameters (.biceparam)
Bicep — a domain-specific language for deploying Azure resources — allows you to define parameters within its own syntax. Whenever you need to pass configuration details to a Bicep file you can use a .biceparam file. Here is an example of a .biceparam file:
using './main.bicep'
param resourceGroups = {
'rg-01': {
prefix: 'app01'
location: 'westeurope'
tags: {
environment: 'dev'
}
}
'rg-02': {
prefix: 'app01'
location: 'northeurope'
tags: {
environment: 'prod'
}
}
}
🧑💻 ARM Template Parameters (.parameters.json):
ARM templates, which are technically JSON files, can also be used to define parameters. Here is an example of a .parameters.json file:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"resourceGroups": {
"value": {
// Object for resource group 01
"rg-01": {
"prefix": "app01",
"location": "westeurope",
"tags": {
"environment": "dev"
}
},
// Object for resource group 02
"rg-02": {
"prefix": "app01",
"location": "northeurope",
"tags": {
"environment": "prod"
}
}
}
}
}
}
💬 YAML as a Parameter Object in Bicep Deployments
Here’s where the YAML comes into play. Unlike the more structured JSON, YAML offers a more straightforward and more human-readable format. You can use YAML files as parameter objects for Bicep deployments, making the process more intuitive and efficient.
resourceGroups:
rg-01:
prefix: app01
location: westeurope
tags:
environment: dev
rg-02:
prefix: app01
location: northeurope
tags:
environment: prod
As you can see, YAML is a more human-readable and intuitive format in comparison to JSON. It is also more flexible and easier to work with, making it a great choice for Bicep deployments. YAML is not only about readability but also about flexibility. Its ability to handle complex configurations in a simpler way makes it a preferred choice for many developers working with cloud resources. Now that we've understood the why and the what, it's time to explore the how. we're going to take a closer look at a practical application of YAML in Azure resource deployment using Bicep.
First, let's understand the basics of YAML and the Bicep, and how they help us set up resources in Azure. Bicep has features like functions and expressions, which are really handy. For example, there are file functions in Bicep that let us read YAML files. This means we can use YAML files as an external file and iterate it as a parameter in our Bicep file. This is a great way to use YAML files as driver files for our Bicep deployments. By doing this, we can go through our setup steps more easily, making the whole process of setting up resources in Azure smoother and better.
Imagine you have a YAML file that contains the details of your resource groups, and you want to use this file as a parameter in your Bicep file. You can use the file function in Bicep to read the YAML file and iterate it as a parameter in your Bicep file. Here is the YAML file:
resourceGroups:
rg-01:
prefix: app01
location: westeurope
tags:
environment: dev
rg-02:
prefix: app01
location: northeurope
tags:
environment: prod
In this YAML file, we've listed the details of our resource groups, like app01 for development and app02 for testing, each with its own set of tags. The beauty of this setup is how Bicep can effortlessly read this file. We can simply use Bicep to iterate over these resource group details, treating the YAML file as a complex object that feeds directly into our deployment template.
The function we are going to come across is now loadYamlContent function. Here is an example usage of it in Bicep file:
targetScope = 'subscription'
var resourceGroups = loadYamlContent('./resourceGroups.yaml')
output yamlResourceGroups object = resourceGroups
loadYamlContent function reads the YAML file and returns the content as an object. The file is loaded when the Bicep file is compiled to the YAML template. There is a catch here, the file can't be passed as a parameter to the Bicep file.
Now, let’s take a look at what the output of the loadYamlContent function – yamlResourceGroups – looks like. This output is exactly what we need for our next steps:
"resourceGroups": {
"type": "Array",
"value": [
{
"location": "westeurope",
"name": "app01",
"tags": {
"environment": "dev",
"project": "project01"
}
},
{
"location": "northeurope",
"name": "app02",
"tags": {
"environment": "dev"
}
}
]
}
This output sets the stage for what we'll be tackling in the next post. We will utilize the YAML content to create resource groups using Bicep. This approach will showcase the practical application of YAML in Azure resource management and demonstrate the power and flexibility of combining these tools.
Stay tuned for the next part of our series, where we bring the YAML content into action and create resource groups in the Bicep, bringing our deployment life. See you in the next post!