Parameters help to create generic and customizable templates. Parameters are defined in templates where the values are provided by the user as arguments as part of deployment. This encourages the use of the same template for multiple different environments such as development, test, production, and other types of environments. Multiple parameters can be defined in a template. Let's look at a sample parameter definition containing two parameters - firstParameter and secondParameter. The first parameter is of string type and can hold any one of two allowed values. The default value is FirstValue and has maxLength and minLength as validators. Metadata helps in adding additional context and information. Description is added as part of the firstParameter metadata. Similarly, secondParameter is of int type with validators on acceptable values, minimum values, and maximum values:

"parameters": { 
        "firstParameter": { 
            "type": "string", 
            "allowedValues": [ 
                "FirstValue", 
                "SecondValue" 
            ], 
            "defaultValue": "FirstValue", 
            "maxLength": 20, 
            "minLength": 10, 
            "metadata": { 
                "description": "My first parameter" 
            } 
        }, 
        "secondParameter": {  
            "type": "int", 
            "allowedValues": [ 
                10, 
                20 
            ], 
            "defaultValue": 10, 
            "maxValue": 20, 
            "minValue": 10, 
            "metadata": { 
                "description": "My second parameter" 
            } 
        } 
    } 

Templates provide attributes for defining parameters as shown in code. The explanation of these attributes are mentioned in the following table:

Variables are similar to parameters but the values are defined internally, within the template itself, and are not provided externally by a user. The value of a variable is part of the variable declaration itself. Variables are declared once and should be unique within a template. They can be placed anywhere within a template where a JSON string is expected. They make templates dynamic, manageable, and changes can be done to it easily. The value of a variable is substituted during deployment at all places it's used in the template. Variables are of JSON object data type. Let's look at a sample definition of a variable as shown here:

"firstVariable": { 
            "networkName": "FirstNetwork", 
            "subnets": [ 
                { 
                    "subnetName": "FrontEnd", 
                    "subnetIPRange": "10.0.0.0/24" 
                }, 
                {  
                    "subnetName": "BackEnd", 
                    "subnetIPRange": "10.0.1.0/24" 
                } 
            ] 
        } 

Resources are array types that can hold multiple resource declarations. Arrays in JSON are represented by square brackets [] and objects by wriggly brackets {}. Each resource is an object declaring its desired configuration. Each resource has two types of properties - properties that provide information to ARM about the name, type, version, and location of the resource and properties that configure the resource itself. The mandatory properties of a resource are as follows:

Each resource has its specific configuration requirements and they will differ from one resource to another. These configurations configure the resource and its inner working. Let's look at how to define resources in a template. There are two resource declarations in the resources section of the template.

The first resource instance is named storageaccount provisioned at the West Europe Azure region based on the resource provider, Microsoft.Storage and resource type, storageAccounts and its version is 2015-06-15.

"resources": [ 
        { 
            "type": "Microsoft.Storage/storageAccounts", 
            "name": "storageaccount", 
            "apiVersion": "2015-06-15", 
            "location": "West Europe", 
            "properties": { 
                "accountType": "Standard_LRS" 
            } 
        }, 
        {  
            "apiVersion": "2015-05-01-preview", 
            "type": "Microsoft.Network/publicIPAddresses", 
            "name": "myPublicIPAddress", 
            "location": "West Europe", 
            "properties": { 
                "publicIPAllocationMethod": "Static", 
                "dnsSettings": { 
                    "domainNameLabel": "mypublicipaddress" 
                } 
            } 
        } 
    ] 

The first resource instance is named myPublicIPAddress provisioned at the West Europe Azure region based on the resource provider, Microsoft.Network and resource type, publicIPAddresses and its version is 2015-05-01-preview. Both the resources have a properties element which describes the resource-specific configurations. The StorageAccounts resource type has dependency on the accountType property which defines whether the storage account should be Locally redundant, Zone redundant, Geo redundant or Read-access Geo redundant. Similarly, PublicIpAddresses resource type has dependency on the allocation method which can be dynamic or static. dnsSettings provides a DNS name to the public IP address.

Outputs represents the return values from templates as the result of executing or deploying them. The outputs section can be customized to contain multiple objects, each returning values. Each object in the outputs section has two properties - the type of return value and the value of return type. type refers to data types which we saw in the previous section and value refers to the actual data or object returned by the template. The output section is executed and returns a value only if the template was executed and deployed successfully. Let's look at how to define outputs in a template:

"outputs": { 
        "myOutput": { 
            "type": "string", 
            "value": "Resource Group deployed successfully !!" 
        } 
    } 

In the code listing, a single output; myOutput is defined. It is of string type and will return the text on successful execution of the template.

ARM extends JSON by adding additional features in terms of expressions and functions. These are not available in JSON out-of-the-box and Microsoft added them to make templates dynamic and customizable. Expressions and functions are evaluated at deployment and they help in adding scripting language semantics to templates. Expressions are defined using square brackets and can appear anywhere a JSON string is expected in a template. The return value from an expression is always in JSON format.

There are numerous functions provided by ARM templates and can be categorized into string functions, numeric functions, array functions, deployment functions, and resource functions.

In this book, we will use Visual Studio 2015 for authoring ARM templates. See the following steps for creating a template:

Templates can be deployed to a resource group in multiple ways, prominent among them are:

This book uses PowerShell and the Azure Resource Manager module for deploying ARM templates to resource groups. We will look into steps for using PowerShell for deployment of templates when we discuss PowerShell in detail in the next section.