6.1 Implement ARM templates

Author ARM templates; create ARM templates to deploy ARM Resource Providers resources; deploy templates with PowerShell, CLI, and REST API

Azure Resource Manager (ARM) gir oss muligheten til å kunne opprette ressurser basert på noe de kaller ARM Templates. Dette er metode som benytter "Infrastructure as Code", altså en metode hvor infrastrukturen er definert som kode. Den er deklarativ (bryr oss ikke om hvordan, bare om hva vi ønsker), og Idempotent (vi kan opprette den så mange ganger vi ønsker, uten det påvirker resultatet). ARM Template er altså fasiten på hvilke ressurser vi ønsker og hvordan de henger sammen. Så lenge Template er lik kan vi kjøre den så mange ganger vi ønsker uten at resultatet endrer seg.

Det hele handler om å definere ressursene (nettverk, lagring, virtuelle maskiner, operativsystemer etc.) i en konfigurasjonsfil som er basert på JSON (.json). Deretter finnes det ulike metoder for å sende denne konfigurasjonsfilen til Azure som tar over ansvaret med å lage infrastrukturen slik du har definert i JSON-filen.

6.1.1 Author ARM templates

Så hvordan skriver man skrive ARM Templates? Hvis man skal benytte seg av ARM Templates er det viktig å forstå hvordan strukturen og syntaksen fungerer: https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-authoring-templates

6.1.1.1 Struktur på JSON

Det første er strukturen på JSON-filen. Den består av seks verdier, hvor fire av dem er blokker med kode.

{
    "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "",
    "parameters": {  },
    "variables": {  },
    "resources": [  ],
    "outputs": {  }
}

$schema: Plassering til JSON schema som beskriver versjonen av Template-språket. Her bør man bare benytte default Schema fra Microsoft sine dokumentasjonssider.

contentVersion: Versjon av Template vi skriver, som f.eks 1.0.0.0. Denne kan bidra til å hjelpe oss å finne om vi benytter riktig versjon. Gjør det lettere å ha versjonskontroll på det faktisk miljøet og Template vi ønsker å rulle ut.

parameters: Verdier som blir poppet opp når du faktisk kjører selve Deployment. Det kan være vi ønsker brukerinput for enkelte verdier eller skille mellom ulike miljøer og da er det fint å benytte parameters.

"parameters": {
    "<parameter-name>" : {
        "type" : "<type-of-parameter-value>",
        "defaultValue": "<default-value-of-parameter>",
        "allowedValues": [ "<array-of-allowed-values>" ],
        "minValue": <minimum-value-for-int>,
        "maxValue": <maximum-value-for-int>,
        "minLength": <minimum-length-for-string-or-array>,
        "maxLength": <maximum-length-for-string-or-array-parameters>,
        "metadata": {
            "description": "<description-of-the parameter>" 
        }
    }
}

variables: Verdier som blir lagret som variabler under Deployment. Skaper stor gjenbrukbarhet og fleksibilitet innenfor JSON-filen.

"variables": {
    "<variable-name>": "<variable-value>",
    "<variable-name>": { 
        <variable-complex-type-value> 
    }
}

resources: Det er i denne blokken vi definerer hvilke ressurser som skal bli kjørt opp i Azure innenfor en Resource Group. Det er faktisk her vi skal beskrive hvilke komponenter/ressurser vi skal ha i en Resource Group, og derfor blir det ofte komplekse blokker med kode. Det som er viktig er å sjekke ut Referansen til den ressursen du trenger: https://docs.microsoft.com/en-us/azure/templates


"resources": [
  {
      "condition": "<boolean-value-whether-to-deploy>",
      "apiVersion": "<api-version-of-resource>",
      "type": "<resource-provider-namespace/resource-type-name>",
      "name": "<name-of-the-resource>",
      "location": "<location-of-resource>",
      "tags": {
          "<tag-name1>": "<tag-value1>",
          "<tag-name2>": "<tag-value2>"
      },
      "comments": "<your-reference-notes>",
      "copy": {
          "name": "<name-of-copy-loop>",
          "count": "<number-of-iterations>",
          "mode": "<serial-or-parallel>",
          "batchSize": "<number-to-deploy-serially>"
      },
      "dependsOn": [
          "<array-of-related-resource-names>"
      ],
      "properties": {
          "<settings-for-the-resource>",
          "copy": [
              {
                  "name": ,
                  "count": ,
                  "input": {}
              }
          ]
      },
      "resources": [
          "<array-of-child-resources>"
      ]
  }
]

outputs: Verdier som blir returnert etter Deployment er ferdig.

"outputs": {
    "<outputName>" : {
        "type" : "<type-of-output-value>",
        "value": "<output-value-expression>"
    }
}

6.1.1.2 Expressions and functions

ARM Templates støtter en rekke funksjoner som blir kjørt under Deployment. Dette skaper en mye større fleksibilitet. Det betyr at vi kan kalle funksjoner som kan hjelpe oss til diverse operasjoner som f.eks generere Strings ([concat()]), hente ut verdier (resourceid()) eller manipulerer data [split()]. Nedenfor er et eksempel på en Output som benytter funksjoner for å gi bedre tilbakemelding.

"outputs": {
    "siteUri" : {
        "type" : "string",
        "value": "[concat('http://',reference(resourceId('Microsoft.Web/sites', parameters('siteName'))).hostNames[0])]"
    }
}

Azure Resource Manager template functions: https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-template-functions

6.1.2 Create ARM templates to deploy ARM Resource Providers resources

Det er ikke alltid like moro å skrive en ARM Template fra bunn. Derfor finnes det en rekke verktøy som kan hjelpe oss med komme i gang.

Visual Studio Code med ARM Template Extension: Gir oss muligheten til å kunne få syntaks i en anerkjent cross-platform editor. Har Git-integrasjon, slik vi kan ha versjonskontroll på koden. https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-vscode-extension
Azure Portal: Vi kan opprette ressurser i Azure-portalen, deretter eksportere ARM Templates fra dette.
ARM Template Visualizer:: "Drop-and-Drag"-metode for å opprette ressurser og se sammenhenger. Deretter kan vi hente ARM Template. http://armviz.io

Jeg har opprettet min egen ARM Template, hvor jeg har skilt ut parameter-filen i en egen JSON-fil. Som man kan se er azuredeploy.json filen som inneholder alle ressurser, variabler og output, mens azuredeploy.parameters.json inneholder bare parametere.

En tilsvarende kan struktur på ARM Template hentes her: https://github.com/Azure/azure-quickstart-templates/tree/master/101-vm-simple-windows

Hvis vi analyserer denne vil vi kunne se at vi "prater" til mange forskjellige Providers. Azure Resource Manager er bygget opp slik at den innholder mange ulike Provider som har kontroll på de ulike ressurstypene som eksisterer i Azure. https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-supported-services

Som vi kan se må jeg benytte Microsoft.Storage for å opprette StorageAccount.

  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "name": "[variables('StorageAccountName')]",
      "apiVersion": "2015-05-01-preview",
      "location": "[parameters('location')]",
      "properties": {
        "accountType": "[parameters('storageAccountType')]"
      }
    },

Eller jeg bruker Microsoft.Network for å opprette et virtuelt nettverk i Azure.

    {
      "apiVersion": "2015-05-01-preview",
      "type": "Microsoft.Network/virtualNetworks",
      "name": "[variables('virtualNetworkName')]",
      "location": "[parameters('location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "[variables('vnetAddressPrefix')]"
          ]
        },

Create and deploy your first Azure Resource Manager template: https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-create-first-template

6.1.3 Deploy templates with PowerShell, CLI, and REST API

Når vi er ferdig med å skrive ARM Templates, kan vi sørge for at disse blir sendt til Azure på flere metoder. PowerShell, CLI eller REST API.

6.1.3.1 PowerShell

Før man setter i gang må vi ha utvidelsen til PowerShell. Sjekk ut: Komme i gang med Azure PowerShell

Dette krevet at vi er koblet opp mot en Azure Subscription, og vi kan velge å peke mot en lokal JSON-fil eller Remote JSON-fil (f.eks en publisert JSON som ligger på et Git-Repository). Kommandoen som gjør magien er: New-AzureRmResourceGroupDeployment. I dette tilfellet har jeg opprettet ARM Template (azuredeploy.json) og ARM Template Parameter-fil (azuredeploy.parameters.json).

# Logger inn til min Subscription
Login-AzureRmAccount

# Lager variabler
$Prefix = "MASTECH"
$DeployName = "$Prefix-ARMDEPLOY"
$ResourceGroupName = "$Prefix-RG01"
$LocationName = "North Europe"

# Refererer til JSON som ligger på GitLab (Viktig at denne er Public og tilgjengelig)
$TemplateFile          = "E:\Git-Repos\70-533\azuredeploy.json"
$TemplateParameterFile = "E:\Git-Repos\70-533\azuredeploy.parameters.json"

# Oppretter en ny Resource Group
New-AzureRmResourceGroup –Name $ResourceGroupName –Location $LocationName

# Starter en ARM Deployment
New-AzureRmResourceGroupDeployment -Name $DeployName -ResourceGroupName $ResourceGroupName -TemplateUri $TemplateFile -TemplateParameterFile $TemplateParameterFile -Verbose

Når vi starter Script blir vi først spurt om å logge opp mot en Azure Subscription, deretter starter Azure å bygge ressursene vi har definert i JSON.

Så hva skjer om jeg kjører samme Script én gang til, uten å ha endrer innholdet i JSON-filene. Det som skjer er at den bare sjekker at "State" er lik JSON, og returnerer raskt at ressursene var slik de skal være.

Vi kan se i Azure-portalen at ressursene ble slik jeg forventet:

Deploy resources with Resource Manager templates and Azure PowerShell: https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-template-deploy

6.1.3.2 Azure CLI

Før man setter i gang må vi ha utvidelsen til Azure CLI. Sjekk ut: Komme i gang med Azure CLI

Når vi har koblet oss opp mot Azure Subscription med Azure CLI 2.0, er vi klare for å kjøre kommandoene som trengs. Dette er nesten helt likt som med PowerShell, bare at syntaks er annerledes. Litt viktig at vi spesifiserer @ før parameter-filen.

az group deployment create --name MASTECH-ARMDEPLOY --resource-group MASTECH-RG01 --template-file E:\Git-Repos\70-533\azuredeploy.json --parameters @E:\Git-Repos\70-533\azuredeploy.parameters.json