Azure Fundamentals · Lektion

ARM-Vorlagen schreiben

Erstellen Sie eine parametrisierte ARM-Vorlage in JSON, um ein Storage-Konto und eine VM bereitzustellen, und verwenden Sie Vorlagenfunktionen und Variablen, damit sich Vorlagen wiederverwenden lassen.

Lektion 2 von 413 Schritte

ARM-Vorlagen schreiben ist eine kostenlose Azure Fundamentals-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Azure Fundamentals-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Azure Fundamentals-Kurs umfasst insgesamt 4 Lektionen.

Warum ARM-Vorlagen verwenden?

Mit ARM-Vorlagen können Sie die Azure-Infrastruktur im JSON-Format als Code definieren. Dadurch werden wiederholbare und konsistente Bereitstellungen möglich, die zusammen mit Ihrem Anwendungscode versioniert werden können. Vorlagen sind idempotent — bei mehrfacher Ausführung derselben Vorlage wird dasselbe Ergebnis erzeugt. Dadurch können sie nach Änderungen sicher erneut angewendet werden.

Vorlagengerüst und Schema

Jede ARM-Vorlage beginnt mit einer $schema-Eigenschaft, die auf die URL des Vorlagenschemas verweist, gefolgt von einer contentVersion-Zeichenfolge. Das Schema teilt dem Azure-Portal und den Editor-Erweiterungen mit, wie die Vorlage validiert und IntelliSense dafür bereitgestellt wird. Die fünf folgenden Hauptabschnitte sind parameters, variables, functions, resources und outputs.

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

Parameter definieren

Parameter machen Vorlagen wiederverwendbar, indem sie Eingaben zum Zeitpunkt der Bereitstellung akzeptieren. Jeder Parameter hat einen type (string, int, bool, object, array, secureString), einen optionalen defaultValue und optionale allowedValues zur Validierung. Wenn Sie secureString für Kennwörter verwenden, wird sichergestellt, dass der Wert niemals im Bereitstellungsverlauf protokolliert wird.

"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"]
  }
}

Variablen für berechnete Werte verwenden

Variablen speichern Werte, die aus Parametern oder Vorlagenfunktionen berechnet werden. Dadurch vermeiden sie Wiederholungen und erleichtern die Wartung von Vorlagen. Variablen werden einmal ausgewertet und im gesamten Abschnitt resources mithilfe des Ausdrucks [variables('name')] referenziert. Ein häufig verwendetes Muster besteht darin, einen Ressourcennamen durch die Verkettung eines Parameters mit einem eindeutigen Suffix zu erstellen.

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

Ressourcen definieren

Das Array resources bildet das Herzstück einer ARM-Vorlage. Jedes Element beschreibt eine Azure-Ressource mit den erforderlichen Feldern type, apiVersion, name und location. apiVersion legt die Schemaversion des Ressourcenanbieters fest — verwenden Sie immer eine aktuelle stabile Version, um auf die neuesten Funktionen zugreifen zu können und veraltete Eigenschaften zu vermeiden.

"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"
    }
  }
]

Vorlagenfunktionen und Ausdrücke

Ausdrücke in ARM-Vorlagen stehen in eckigen Klammern [...] und unterstützen integrierte Funktionen für Zeichenfolgen, Arrays, Objekte und Ressourcen-IDs. Zu den häufig verwendeten Funktionen gehören concat(), resourceGroup(), resourceId(), uniqueString() und parameters(). Diese Funktionen werden zum Zeitpunkt der Bereitstellung serverseitig von ARM ausgewertet, nicht lokal.

// 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)]"

Outputs: Werte zurückgeben

Der Abschnitt outputs definiert Werte, die ARM nach einer erfolgreichen Bereitstellung zurückgibt. Outputs sind für das Verknüpfen von Vorlagen unverzichtbar: Sie stellen eine Netzwerkvorlage bereit und geben die Ressourcen-ID des Subnetzes aus, die Sie anschließend als Parameter an eine VM-Vorlage übergeben. Outputs können auf jeden Ausdruck verweisen, einschließlich Ressourceneigenschaften aus der Bereitstellung.

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

Verknüpfte und geschachtelte Vorlagen

Für komplexe Architekturen unterstützt ARM verknüpfte Vorlagen (mit Verweisen auf externe Vorlagen-URLs) und geschachtelte Vorlagen (eine Vorlage, die mithilfe des Typs Microsoft.Resources/deployments in das Array resources eingebettet wird). So können Sie eine umfangreiche Infrastrukturbereitstellung in modulare, wiederverwendbare Bestandteile aufteilen und gleichzeitig eine einzige Orchestrierungsvorlage als Einstiegspunkt beibehalten.

{
  "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')]" }
    }
  }
}

Parameterdateien

Statt Parameter in der Befehlszeile zu übergeben, können Sie sie in einer separaten Parameterdatei speichern — einer JSON-Datei mit einem parameters-Objekt, das Name-Wert-Paare enthält. Parameterdateien können umgebungsspezifisch sein (z. B. dev.parameters.json, prod.parameters.json) und in der Quellcodeverwaltung gespeichert werden. Sensible Werte bleiben dabei in Verweisen auf Azure Key Vault und nicht im Klartext.

// 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

Vorlagen bereitstellen und validieren

Verwenden Sie den Azure-CLI-Befehl az deployment group create, um eine Vorlage in einer Ressourcengruppe bereitzustellen. Führen Sie vor der Bereitstellung in der Produktion az deployment group validate aus, um Schema- und Logikfehler zu erkennen, und az deployment group what-if, um eine Vorschau der Ressourcenänderungen anzuzeigen. Diese drei Befehle bilden eine sichere Bereitstellungspipeline: validieren, Vorschau anzeigen, bereitstellen.

# 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

Bewährte Methoden für ARM-Vorlagen

Befolgen Sie diese bewährten Methoden für ARM-Vorlagen: Verwenden Sie Parameter für umgebungsspezifische Werte, verwenden Sie Variablen, um Wiederholungen zu vermeiden, fixieren Sie API-Versionen auf stabile Versionen, verwenden Sie secureString für Kennwörter, fügen Sie Metadatenbeschreibungen hinzu und teilen Sie umfangreiche Vorlagen in verknüpfte Module auf. Speichern Sie Vorlagen in einem Git-Repository und stellen Sie sie über eine CI/CD-Pipeline bereit, um eine nachvollziehbare Prüfung zu ermöglichen.

Kurze Überprüfung

Testen Sie Ihr Verständnis der Konzepte von Microsoft Azure Fundamentals (AZ-900) aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: ARM-Vorlagen sind JSON-Dokumente, die die Azure-Infrastruktur deklarativ definieren, Parameter und Variablen machen Vorlagen wiederverwendbar und wartbar, und der Ablauf validieren, what-if, bereitstellen ermöglicht sichere und wiederholbare Bereitstellungen. Als Nächstes beschäftigen wir uns mit Bicep, einer modernen Abstraktion über ARM-JSON.

Kostenlos starten

Lerne Azure Fundamentals mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „ARM-Vorlagen schreiben“ kostenlos?

Ja — der vollständige Text von „ARM-Vorlagen schreiben“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Azure Fundamentals-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Azure Fundamentals-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „ARM-Vorlagen schreiben“?

Erstellen Sie eine parametrisierte ARM-Vorlage in JSON, um ein Storage-Konto und eine VM bereitzustellen, und verwenden Sie Vorlagenfunktionen und Variablen, damit sich Vorlagen wiederverwenden lasse… Du übst Azure Fundamentals mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Azure Fundamentals zu starten?

Keine Vorkenntnisse erforderlich. Azure Fundamentals auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „ARM-Vorlagen schreiben“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Azure Fundamentals-Lektion Code schreiben und ausführen?

Ja. Jede Azure Fundamentals-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. So funktioniert Azure Resource Manager
  2. ARM-Vorlagen schreiben
  3. Bicep: Moderne IaC für Azure
  4. Terraform in Azure
← Zurück zu Azure Fundamentals