Azure Fundamentals · Les

ARM-templates schrijven

Bouw in JSON een geparametriseerde ARM-template om een storage-account en VM te implementeren en gebruik templatefuncties en variabelen om templates herbruikbaar te maken.

Les 2 van 413 stappen

ARM-templates schrijven is een gratis Azure Fundamentals-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Azure Fundamentals. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Azure Fundamentals bevat in totaal 4 lessen.

Waarom ARM-sjablonen gebruiken?

Met ARM-sjablonen kun je Azure-infrastructuur als code definiëren in JSON-indeling. Hierdoor kun je herhaalbare, consistente implementaties uitvoeren en de sjablonen samen met je toepassingscode onder versiebeheer plaatsen. Sjablonen zijn idempotent: als je dezelfde sjabloon meerdere keren uitvoert, krijg je hetzelfde resultaat. Daardoor kun je ze veilig opnieuw toepassen na wijzigingen.

Sjabloonbasis en schema

Elke ARM-sjabloon begint met een eigenschap $schema die verwijst naar de URL van het sjabloonschema, gevolgd door een tekenreeks contentVersion. Het schema vertelt de Azure-portal en editoruitbreidingen hoe ze je sjabloon moeten valideren en IntelliSense moeten bieden. De vijf hoofdsecties die volgen zijn parameters, variables, functions, resources en outputs.

{
  '$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#',
  'contentVersion': '1.0.0.0',
  'parameters': {},
  'variables': {},
  'functions': [],
  'resources': [],
  'outputs': {}
}

Parameters definiëren

Met parameters maak je sjablonen herbruikbaar door tijdens de implementatie invoerwaarden te accepteren. Elke parameter heeft een type (string, int, bool, object, array, secureString), een optionele defaultValue en optionele allowedValues voor validatie. Als je secureString voor wachtwoorden gebruikt, wordt de waarde nooit vastgelegd in de implementatiegeschiedenis.

"parameters": {
  "storageAccountName": {
    "type": "string",
    "minLength": 3,
    "maxLength": 24,
    "metadata": { "description": "Globally unique storage account name" }
  },
  "sku": {
    "type": "string",
    "defaultValue": "Standard_LRS",
    "allowedValues": ["Standard_LRS", "Standard_GRS", "Premium_LRS"]
  }
}

Variabelen gebruiken voor berekende waarden

Variabelen slaan waarden op die zijn berekend op basis van parameters of sjabloonfuncties. Zo verminder je herhaling en worden sjablonen eenvoudiger te onderhouden. Variabelen worden één keer geëvalueerd en in de sectie resources overal verwezen met de expressie [variables('name')]. Een veelgebruikt patroon is het opbouwen van een resourcenaam door een parameter samen te voegen met een uniek achtervoegsel.

"variables": {
  "uniqueStorageName": "[concat(parameters('storageAccountName'), uniqueString(resourceGroup().id))]",
  "location": "[resourceGroup().location]"
}

Resources definiëren

De array resources vormt het hart van een ARM-sjabloon. Elk element beschrijft één Azure-resource met verplichte velden: type, apiVersion, name en location. Met apiVersion leg je de schemaversie van de resourceprovider vast. Gebruik altijd een recente stabiele versie om toegang te hebben tot de nieuwste functies en verouderde eigenschappen te vermijden.

"resources": [
  {
    "type": "Microsoft.Storage/storageAccounts",
    "apiVersion": "2023-01-01",
    "name": "[variables('uniqueStorageName')]",
    "location": "[variables('location')]",
    "sku": { "name": "[parameters('sku')]" },
    "kind": "StorageV2",
    "properties": {
      "supportsHttpsTrafficOnly": true,
      "minimumTlsVersion": "TLS1_2"
    }
  }
]

Sjabloonfuncties en expressies

Expressies in ARM-sjablonen staan tussen vierkante haakjes [...] en ondersteunen ingebouwde functies voor tekenreeksen, arrays, objecten en resource-id's. Veelgebruikte functies zijn concat(), resourceGroup(), resourceId(), uniqueString() en parameters(). ARM evalueert deze functies tijdens de implementatie aan de serverzijde, niet lokaal.

// Reference a resource ID inside a template
"subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'myVNet', 'mySubnet')]"

// Build a unique, deterministic name
"name": "[concat('storage', uniqueString(resourceGroup().id))]"

// Conditionally include a resource
"condition": "[equals(parameters('deployStorage'), true)]"

Uitvoerwaarden retourneren

In de sectie outputs definieer je waarden die ARM na een geslaagde implementatie retourneert. Uitvoerwaarden zijn essentieel voor het koppelen van sjablonen: je implementeert een netwerksjabloon en retourneert de resource-id van het subnet, waarna je die als parameter doorgeeft aan een VM-sjabloon. Uitvoerwaarden kunnen naar elke expressie verwijzen, waaronder resource-eigenschappen uit de implementatie.

"outputs": {
  "storageAccountName": {
    "type": "string",
    "value": "[variables('uniqueStorageName')]"
  },
  "blobEndpoint": {
    "type": "string",
    "value": "[reference(variables('uniqueStorageName')).primaryEndpoints.blob]"
  }
}

Gekoppelde en geneste sjablonen

Voor complexe architecturen ondersteunt ARM gekoppelde sjablonen (verwijzingen naar externe URL's van sjablonen) en geneste sjablonen (een sjabloon die in de resourcearray is opgenomen met het type Microsoft.Resources/deployments). Zo kun je een grote infrastructuurimplementatie opsplitsen in modulaire, herbruikbare onderdelen, terwijl één orkestratiesjabloon het toegangspunt blijft.

{
  "type": "Microsoft.Resources/deployments",
  "apiVersion": "2021-04-01",
  "name": "networkDeploy",
  "properties": {
    "mode": "Incremental",
    "templateLink": {
      "uri": "https://raw.githubusercontent.com/contoso/templates/main/network.json",
      "contentVersion": "1.0.0.0"
    },
    "parameters": {
      "vnetName": { "value": "[parameters('vnetName')]" }
    }
  }
}

Parameterbestanden

In plaats van parameters op de opdrachtregel door te geven, kun je ze opslaan in een afzonderlijk parameterbestand: een JSON-bestand met een object parameters dat naam-waardeparen bevat. Parameterbestanden kunnen omgevingsspecifiek zijn (bijvoorbeeld dev.parameters.json en prod.parameters.json) en aan bronbeheer worden toegevoegd. Gevoelige waarden blijven daarbij in verwijzingen naar Azure Key Vault staan in plaats van als tekst.

// dev.parameters.json
{
  '$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#',
  'contentVersion': '1.0.0.0',
  'parameters': {
    'storageAccountName': { 'value': 'devstorageacct' },
    'sku': { 'value': 'Standard_LRS' }
  }
}

// Deploy with parameters file
// az deployment group create -g MyRG -f azuredeploy.json -p dev.parameters.json

Sjablonen implementeren en valideren

Gebruik de Azure CLI-opdracht az deployment group create om een sjabloon in een resourcegroep te implementeren. Voer vóór een implementatie naar productie az deployment group validate uit om schema- en logische fouten te vinden, en az deployment group what-if om een voorbeeld van de resourcewijzigingen te bekijken. Deze drie opdrachten vormen samen een veilige implementatiepijplijn: valideren, voorbeeld bekijken, implementeren.

# Step 1: Validate the template syntax
az deployment group validate \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

# Step 2: Preview changes
az deployment group what-if \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

# Step 3: Deploy
az deployment group create \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

Aanbevolen werkwijzen voor ARM-sjablonen

Volg deze aanbevolen werkwijzen voor ARM-sjablonen: gebruik parameters voor omgevingsspecifieke waarden, gebruik variabelen om herhaling te voorkomen, leg API-versies vast op stabiele versies, gebruik secureString voor wachtwoorden, voeg metagegevensbeschrijvingen toe aan parameters en splits grote sjablonen op in gekoppelde modules. Sla sjablonen op in een Git-opslagplaats en implementeer ze via een CI/CD-pijplijn voor controleerbaarheid.

Korte controle

Test je begrip van de concepten uit Microsoft Azure Fundamentals (AZ-900) in deze les.

Samenvatting van de les

In deze les heb je geleerd dat ARM-sjablonen JSON-documenten zijn die Azure-infrastructuur declaratief definiëren, dat parameters en variabelen sjablonen herbruikbaar en onderhoudbaar maken en dat de werkstroom valideren, what-if, implementeren veilige, herhaalbare implementaties mogelijk maakt. Hierna leer je Bicep kennen, een moderne abstractielaag boven ARM JSON.

Gratis beginnen

Leer Azure Fundamentals met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “ARM-templates schrijven” gratis?

Ja — de volledige tekst van “ARM-templates schrijven” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Azure Fundamentals wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Azure Fundamentals bevat in totaal 4 lessen.

Wat leer ik in “ARM-templates schrijven”?

Bouw in JSON een geparametriseerde ARM-template om een storage-account en VM te implementeren en gebruik templatefuncties en variabelen om templates herbruikbaar te maken. Je oefent met Azure Fundamentals door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Azure Fundamentals te beginnen?

Ervaring vooraf is niet nodig. Azure Fundamentals op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “ARM-templates schrijven”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Azure Fundamentals?

Ja. Elke les over Azure Fundamentals bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Hoe Azure Resource Manager werkt
  2. ARM-templates schrijven
  3. Bicep: moderne Azure IaC
  4. Terraform op Azure
← Terug naar Azure Fundamentals