ARM template structure in Azure - Deep Dive

Overview - ARM template structure

What is it?

An ARM template is a file that describes the resources you want to create in Microsoft Azure. It uses JSON format to list resources like virtual machines, storage accounts, and networks. The template defines what to build, how to configure it, and how resources connect. This helps automate and repeat cloud setups easily.

Why it matters

Without ARM templates, setting up cloud resources would be manual, slow, and error-prone. ARM templates solve this by letting you define your infrastructure as code, so you can deploy the same setup consistently anytime. This saves time, reduces mistakes, and makes managing cloud resources reliable and scalable.

Where it fits

Before learning ARM templates, you should understand basic cloud concepts like virtual machines and storage. After mastering ARM templates, you can explore advanced automation tools like Azure DevOps or Terraform for more complex deployments.

Mental Model

Core Idea

An ARM template is a detailed recipe written in JSON that tells Azure exactly what cloud resources to create and how to connect them.

Think of it like...

It's like a cooking recipe that lists ingredients and steps to bake a cake; the ARM template lists cloud resources and how to set them up.

┌─────────────────────────────┐
│        ARM Template         │
├─────────────┬───────────────┤
│ Parameters  │ User inputs   │
├─────────────┼───────────────┤
│ Variables   │ Internal values│
├─────────────┼───────────────┤
│ Resources   │ What to build │
├─────────────┼───────────────┤
│ Outputs     │ What to return│
└─────────────┴───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding JSON format basics

Concept: ARM templates use JSON, a simple text format to organize data in key-value pairs.

JSON looks like this: { "key": "value" }. It uses braces { } to group data and square brackets [ ] for lists. ARM templates are JSON files that follow a specific structure.

Result

You can read and write ARM templates as JSON files that computers understand.

Knowing JSON basics is essential because ARM templates are just JSON files with special keys and structure.

2

Foundation

Core sections of an ARM template

Concept: An ARM template has four main parts: parameters, variables, resources, and outputs.

Parameters let users provide input values. Variables store reusable values inside the template. Resources define what Azure services to create. Outputs return information after deployment.

Result

You can identify and understand the purpose of each section in an ARM template.

Recognizing these parts helps you organize your template clearly and makes it easier to customize and reuse.

3

Intermediate

Defining resources with properties

🤔Before reading on: do you think resource properties are optional or required? Commit to your answer.

Concept: Each resource in the template must specify its type, name, API version, location, and properties.

For example, a storage account resource includes its type "Microsoft.Storage/storageAccounts", a unique name, location like "eastus", and properties such as account kind and SKU. These details tell Azure exactly what to create.

Result

You can write resource definitions that Azure uses to build cloud services.

Understanding resource properties ensures your deployments are precise and meet your needs.

4

Intermediate

Using parameters and variables effectively

🤔Before reading on: do you think variables can be changed by users during deployment? Commit to your answer.

Concept: Parameters accept user input at deployment time; variables are fixed inside the template for reuse.

Parameters might ask for a VM size or admin username. Variables can combine values or store repeated strings. This separation keeps templates flexible and clean.

Result

You can create templates that adapt to different scenarios without rewriting code.

Knowing the difference between parameters and variables helps you build reusable and customizable templates.

5

Intermediate

Outputs to share deployment results

Concept: Outputs let your template return useful information after deployment, like resource IDs or connection strings.

For example, after creating a virtual machine, you can output its IP address. This helps other tools or users know how to connect to the new resource.

Result

You can extract and use important data from your deployments automatically.

Outputs make your templates more interactive and integrate better with other systems.

6

Advanced

Template expressions and functions

🤔Before reading on: do you think ARM template functions can only handle simple math or also complex logic? Commit to your answer.

Concept: ARM templates support expressions and built-in functions to compute values dynamically during deployment.

Functions like concat(), resourceId(), and uniqueString() let you build names, reference other resources, or generate unique values. Expressions use these functions inside parameters, variables, or resource properties.

Result

You can create smarter templates that adjust values automatically based on inputs or environment.

Mastering expressions unlocks powerful automation and reduces manual errors.

7

Expert

Nested and linked templates for modular design

🤔Before reading on: do you think nested templates run independently or as part of the main deployment? Commit to your answer.

Concept: You can split large deployments into smaller templates that call each other, improving organization and reuse.

Nested templates are embedded inside a main template, while linked templates are separate files referenced by URL. This modular approach helps manage complex infrastructures and enables parallel deployments.

Result

You can build scalable, maintainable deployments that grow with your needs.

Understanding modular templates is key to managing real-world cloud environments efficiently.

Under the Hood

When you deploy an ARM template, Azure Resource Manager reads the JSON file, processes parameters and variables, evaluates expressions, and creates or updates resources in the specified order. It tracks the deployment state and ensures dependencies are respected. If any step fails, it can roll back changes to keep your environment consistent.

Why designed this way?

ARM templates were designed to provide a declarative, repeatable way to manage cloud resources. JSON was chosen for its simplicity and wide support. The structure separates inputs, logic, and resources to make templates clear and reusable. This design balances flexibility with ease of automation.

┌───────────────┐
│ ARM Template  │
│ (JSON file)   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Azure Resource│
│ Manager (ARM) │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Deployment    │
│ Engine        │
│ - Parses JSON │
│ - Evaluates   │
│   expressions │
│ - Creates    │
│   resources   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Azure Cloud   │
│ Resources     │
│ (VMs, Storage)│
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think ARM templates can only create resources, not update or delete them? Commit to yes or no.

Common Belief: ARM templates only create new resources and cannot modify or remove existing ones.

Reality: ARM templates can create, update, or delete resources to match the declared state in the template.

Why it matters: Believing this limits your use of ARM templates and leads to manual cleanup or inconsistent environments.

Quick: Do you think parameters and variables serve the same purpose? Commit to yes or no.

Common Belief: Parameters and variables are interchangeable ways to store values in ARM templates.

Reality: Parameters accept user input at deployment time; variables are fixed inside the template and cannot be changed by users.

Why it matters: Confusing these causes templates to be less flexible or harder to maintain.

Quick: Do you think ARM templates can include loops or conditional logic? Commit to yes or no.

Common Belief: ARM templates cannot handle loops or conditions; they are static JSON files.

Reality: ARM templates support loops and conditions using functions like copy and if to create dynamic resource sets.

Why it matters: Not knowing this limits your ability to automate complex deployments efficiently.

Quick: Do you think nested templates run independently from the main template? Commit to yes or no.

Common Belief: Nested templates are separate deployments and do not depend on the main template.

Reality: Nested templates run as part of the main deployment and share parameters and outputs.

Why it matters: Misunderstanding this can cause deployment failures or unexpected resource states.

Expert Zone

1

ARM templates use a declarative approach, so the order of resources is determined by dependencies, not the order in the file.

2

Expressions in ARM templates are evaluated at deployment time, not before, allowing dynamic adaptation to the environment.

3

Linked templates can be stored in different locations like GitHub or Azure Storage, enabling centralized management of infrastructure code.

When NOT to use

ARM templates are less suitable for multi-cloud environments or when you need imperative scripting logic. In such cases, tools like Terraform or Pulumi offer more flexibility and cross-cloud support.

Production Patterns

In production, ARM templates are often combined with Azure DevOps pipelines for continuous integration and deployment. Modular templates with nested or linked structures are used to manage large infrastructures. Parameters files separate environment-specific values for dev, test, and prod.

Connections

Infrastructure as Code (IaC)

ARM templates are a specific implementation of IaC for Azure.

Understanding ARM templates helps grasp the broader IaC principle of managing infrastructure through code, enabling automation and version control.

Declarative Programming

ARM templates use a declarative style, describing what to build, not how.

Knowing declarative programming clarifies why ARM templates focus on desired state rather than step-by-step instructions.

Recipe Writing in Cooking

Both involve listing ingredients and steps to produce a consistent result.

Recognizing this connection highlights the importance of clear, repeatable instructions in both cooking and cloud deployments.

Common Pitfalls

#1 Hardcoding values instead of using parameters

Wrong approach:

{
"parameters": {},
"variables": {},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"name": "mystorageaccount",
"location": "eastus",
"properties": {}
}
]
}

Correct approach:

{
"parameters": {
"storageAccountName": {
"type": "string"
}
},
"variables": {},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"name": "[parameters('storageAccountName')]",
"location": "eastus",
"properties": {}
}
]
}

Root cause:

Not using parameters reduces template flexibility and reusability across environments.

#2 Ignoring resource dependencies causing deployment errors

Wrong approach:

{
"resources": [
{
"type": "Microsoft.Network/virtualNetworks",
"name": "myVnet",
"location": "eastus"
},
{
"type": "Microsoft.Network/networkInterfaces",
"name": "myNic",
"location": "eastus"
}
]
}

Correct approach:

{
"resources": [
{
"type": "Microsoft.Network/virtualNetworks",
"name": "myVnet",
"location": "eastus"
},
{
"type": "Microsoft.Network/networkInterfaces",
"name": "myNic",
"location": "eastus",
"dependsOn": ["[resourceId('Microsoft.Network/virtualNetworks', 'myVnet')]" ]
}
]
}

Root cause:

Not specifying dependencies leads to deployment order issues and failures.

#3 Using outdated API versions for resources

Wrong approach:

"type": "Microsoft.Compute/virtualMachines",
"apiVersion": "2017-03-30"

Correct approach:

"type": "Microsoft.Compute/virtualMachines",
"apiVersion": "2023-03-01"

Root cause:

Using old API versions can cause missing features or deployment errors.

Key Takeaways

ARM templates are JSON files that declare what Azure resources to create and how to configure them.

They separate user inputs (parameters), reusable values (variables), resource definitions, and outputs for clarity and flexibility.

Expressions and functions let templates adapt dynamically during deployment.

Modular templates using nested or linked files help manage complex infrastructures efficiently.

Understanding ARM templates enables reliable, repeatable, and automated cloud deployments.