ARM template parameters and variables in Azure - Deep Dive

Overview - ARM template parameters and variables

What is it?

ARM template parameters and variables are parts of Azure Resource Manager templates that help customize and simplify cloud resource deployment. Parameters let you provide input values when deploying, like names or sizes, making templates reusable. Variables store values calculated or reused inside the template to avoid repetition and keep it organized. Together, they make templates flexible and easier to manage.

Why it matters

Without parameters and variables, every deployment would need a new template for each scenario, causing duplication and errors. They solve the problem of reusing templates for different environments or settings by allowing input customization and internal value reuse. This saves time, reduces mistakes, and helps teams deploy cloud resources consistently and efficiently.

Where it fits

Before learning parameters and variables, you should understand basic ARM template structure and JSON format. After mastering them, you can learn about template functions, outputs, and linked templates to build more complex deployments.

Mental Model

Core Idea

Parameters are like questions you answer before deployment, and variables are notes you make inside the template to avoid repeating yourself.

Think of it like...

Imagine baking cookies with a recipe: parameters are the choices you make before baking, like cookie size or flavor, and variables are the steps or ingredients you write down once to use multiple times without rewriting.

┌───────────────┐       ┌───────────────┐
│  Parameters   │──────▶│  User Inputs  │
└───────────────┘       └───────────────┘
         │                      ▲
         ▼                      │
┌───────────────┐       ┌───────────────┐
│  Variables    │──────▶│  Internal Use │
└───────────────┘       └───────────────┘
         │                      ▲
         ▼                      │
      ┌─────────────────────────────┐
      │      ARM Template Logic      │
      └─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding ARM Template Basics

Concept: Learn what an ARM template is and its basic JSON structure.

An ARM template is a JSON file that defines Azure resources to deploy. It has sections like 'parameters', 'variables', 'resources', and 'outputs'. The 'parameters' section is where you define inputs to customize deployments. The 'variables' section holds values used inside the template to avoid repeating the same data.

Result

You can identify where parameters and variables fit in an ARM template and understand their purpose.

Knowing the template structure is essential before adding parameters and variables, as they live inside this structure.

2

Foundation

Defining Parameters in ARM Templates

Concept: Parameters let you ask for input values when deploying a template.

Parameters are defined in the 'parameters' section with a name, type (like string, int), and optional default value. For example, a parameter named 'vmSize' can let you choose the size of a virtual machine during deployment. This makes the template reusable for different needs without changing the code.

Result

You can write a parameter definition and understand how it allows input customization.

Parameters turn static templates into flexible blueprints by letting users provide values at deployment time.

3

Intermediate

Using Variables to Simplify Templates

🤔Before reading on: do you think variables can accept input from users like parameters? Commit to your answer.

Concept: Variables store values inside the template to reuse and simplify expressions.

Variables are defined in the 'variables' section and hold values calculated or repeated multiple times. For example, you can create a variable that combines a resource name prefix with a parameter value. Variables cannot be changed by users during deployment; they are internal helpers.

Result

You can create variables to avoid repeating complex expressions and keep templates clean.

Understanding that variables are internal constants helps separate user inputs from template logic.

4

Intermediate

Referencing Parameters and Variables

🤔Before reading on: do you think parameters and variables are referenced the same way inside the template? Commit to your answer.

Concept: Learn how to use parameters and variables inside resource definitions and expressions.

To use a parameter, write: [parameters('parameterName')]. To use a variable, write: [variables('variableName')]. For example, to set a VM size, you might write "vmSize": "[parameters('vmSize')]". This syntax tells Azure to replace these placeholders with actual values during deployment.

Result

You can correctly reference parameters and variables in your template expressions.

Knowing the distinct syntax for parameters and variables prevents deployment errors and confusion.

5

Intermediate

Combining Parameters and Variables for Flexibility

🤔Before reading on: do you think variables can use parameters inside their definitions? Commit to your answer.

Concept: Variables can use parameters to build dynamic values inside the template.

You can define a variable that depends on a parameter, like combining a prefix with a user input. For example, a variable 'storageAccountName' can be "[concat('stor', parameters('env'))]". This lets you build names or settings dynamically based on inputs.

Result

You can create variables that adapt based on parameter values, increasing template flexibility.

Understanding this dependency allows building smarter templates that adjust automatically to inputs.

6

Advanced

Best Practices for Parameters and Variables

🤔Before reading on: do you think it's better to hardcode values or use parameters and variables for all settings? Commit to your answer.

Concept: Learn how to organize parameters and variables for maintainability and clarity.

Use parameters for values that change between deployments, like names or sizes. Use variables for values derived from parameters or repeated multiple times. Provide default values for parameters when possible. Group related parameters logically and document them. Avoid overusing variables for simple values to keep templates readable.

Result

You can design templates that are easy to update, reuse, and understand.

Following best practices prevents confusion and errors in complex deployments.

7

Expert

Advanced Variable Expressions and Parameter Validation

🤔Before reading on: do you think ARM templates support complex logic inside variables or parameter validation? Commit to your answer.

Concept: Explore complex expressions in variables and parameter validation features.

Variables can use functions like concat, toLower, substring, and conditionals to build complex values. Parameters support validation rules like allowed values, min/max length, and regex patterns to ensure correct inputs. For example, you can restrict a parameter to specific VM sizes or validate a string format. These features improve template robustness and user experience.

Result

You can write templates that enforce input correctness and generate dynamic values safely.

Knowing these advanced features helps prevent deployment failures and enforces standards automatically.

Under the Hood

When deploying an ARM template, Azure Resource Manager reads the JSON file and processes parameters first by asking the user or using defaults. Then it evaluates variables by running their expressions, often using parameter values. These evaluated values replace references in resource definitions. Finally, Azure creates or updates resources based on the resolved template. This process ensures inputs and internal values are combined correctly before deployment.

Why designed this way?

Parameters and variables separate user input from internal logic, making templates reusable and maintainable. Early ARM templates lacked this separation, causing duplication and errors. Introducing parameters and variables allowed templates to be flexible blueprints rather than fixed scripts. This design balances user customization with internal consistency.

┌───────────────┐
│  ARM Template │
│   (JSON)      │
└──────┬────────┘
       │
       ▼
┌───────────────┐       ┌───────────────┐
│ Parameters    │──────▶│ User Inputs   │
└───────────────┘       └───────────────┘
       │
       ▼
┌───────────────┐
│ Variables     │
│ (Expressions) │
└───────────────┘
       │
       ▼
┌─────────────────────────────┐
│ Template Evaluation Engine   │
│ (Replaces references)       │
└──────────────┬──────────────┘
               │
               ▼
       ┌───────────────┐
       │ Azure Resource │
       │ Deployment    │
       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think variables can be set by users during deployment? Commit to yes or no.

Common Belief: Variables are just like parameters and can be set by users when deploying.

Reality: Variables are internal to the template and cannot be changed by users; only parameters accept user input.

Why it matters: Confusing variables with parameters can lead to failed deployments or unexpected behavior because users try to set values that are fixed inside the template.

Quick: Do you think parameters must always have default values? Commit to yes or no.

Common Belief: All parameters need default values to work properly.

Reality: Parameters can be required without defaults, forcing users to provide values during deployment.

Why it matters: Assuming defaults are mandatory can cause missing input errors or force unnecessary defaults that reduce template flexibility.

Quick: Do you think variables can reference other variables? Commit to yes or no.

Common Belief: Variables cannot use other variables inside their definitions.

Reality: Variables can reference other variables, allowing building complex expressions step-by-step.

Why it matters: Not knowing this limits template design and leads to repetitive or complicated expressions.

Quick: Do you think parameters and variables are interchangeable in resource definitions? Commit to yes or no.

Common Belief: You can use parameters and variables interchangeably anywhere in the template.

Reality: Parameters and variables have different syntax and roles; parameters get user input, variables hold internal values. Using them incorrectly causes deployment errors.

Why it matters: Misusing them leads to confusing errors and wasted debugging time.

Expert Zone

1

Variables are evaluated once at deployment start, so they cannot depend on runtime resource states or outputs.

2

Parameter validation rules are enforced before deployment starts, preventing invalid configurations early.

3

Using variables to build resource names ensures consistency and avoids naming conflicts across resources.

When NOT to use

Avoid overusing variables for simple static values; hardcoding is sometimes clearer. For dynamic runtime values, use outputs or linked templates instead. If you need user input that changes during deployment, use parameters or deployment scripts rather than variables.

Production Patterns

In production, templates use parameters for environment-specific settings (like dev, test, prod). Variables build resource names and combine parameters for consistent naming. Validation rules enforce standards. Complex templates split into linked templates with shared parameters and variables for modularity.

Connections

Terraform Variables and Inputs

Similar pattern of separating user inputs and internal values in infrastructure as code.

Understanding ARM parameters and variables helps grasp Terraform's input variables and locals, showing a common approach in cloud automation.

Function Parameters and Local Variables in Programming

Parameters and variables in ARM templates mirror function parameters and local variables in code.

Knowing programming concepts clarifies how ARM templates separate external inputs from internal reusable values.

Recipe Ingredients and Steps in Cooking

Parameters are like choosing ingredients before cooking; variables are like preparing mixtures or sauces used multiple times.

This cross-domain link shows how planning inputs and reusing preparations optimize complex processes.

Common Pitfalls

#1 Trying to set a variable value during deployment.

Wrong approach:

"variables": { "vmSize": "Standard_DS1_v2" }, // expecting user to change this

Correct approach:

"parameters": { "vmSize": { "type": "string", "defaultValue": "Standard_DS1_v2" } }

Root cause:

Misunderstanding that variables are fixed inside the template and only parameters accept user input.

#2 Referencing parameters without the correct syntax.

Wrong approach:

"vmSize": "vmSize",

Correct approach:

"vmSize": "[parameters('vmSize')]"

Root cause:

Not using the ARM template expression syntax to access parameter values.

#3 Defining variables that depend on undefined parameters.

Wrong approach:

"variables": { "storageName": "[concat('stor', parameters('environment'))]" } // but 'environment' parameter missing

Correct approach:

"parameters": { "environment": { "type": "string" } }, "variables": { "storageName": "[concat('stor', parameters('environment'))]" }

Root cause:

Forgetting to define all parameters used inside variables causes deployment failures.

Key Takeaways

Parameters let users customize ARM template deployments by providing input values.

Variables store internal values and expressions to simplify and reuse data inside templates.

Parameters and variables have distinct roles and syntax; mixing them causes errors.

Using parameters and variables properly makes templates flexible, reusable, and easier to maintain.

Advanced features like parameter validation and complex variable expressions improve template robustness.