0Pricing
Azure Fundamentals · Lezione

Scrittura di template ARM

Crei in JSON un template ARM parametrizzato per distribuire un account di archiviazione e una VM e usi funzioni e variabili del template per renderlo riutilizzabile.

Scrittura di template ARM è una lezione Azure Fundamentals gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Azure Fundamentals, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Azure Fundamentals include 4 lezioni in totale.

Perché usare i modelli ARM?

I modelli ARM consentono di definire l'infrastruttura Azure come codice in formato JSON. Questo permette di eseguire distribuzioni ripetibili e coerenti, con controllo della versione insieme al codice dell'applicazione. I modelli sono idempotenti: eseguire più volte lo stesso modello produce lo stesso risultato, rendendo sicuro applicarlo nuovamente dopo eventuali modifiche.

Struttura di base e schema del modello

Ogni modello ARM inizia con una proprietà $schema che punta all'URL dello schema del modello, seguita da una stringa contentVersion. Lo schema indica al portale Azure e alle estensioni dell'editor come convalidare il modello e fornire IntelliSense. Le cinque sezioni principali successive sono parameters, variables, functions, resources e outputs.

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

Definizione dei parametri

I parametri rendono riutilizzabili i modelli accettando input al momento della distribuzione. Ogni parametro ha un type (string, int, bool, object, array, secureString), un defaultValue facoltativo e allowedValues facoltativi per la convalida. L'uso di secureString per le password garantisce che il valore non venga mai registrato nella cronologia delle distribuzioni.

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

Uso delle variabili per i valori calcolati

Le variabili memorizzano valori calcolati a partire dai parametri o dalle funzioni del modello, riducendo le ripetizioni e semplificando la manutenzione dei modelli. Le variabili vengono valutate una volta e utilizzate in tutta la sezione resources tramite l'espressione [variables('name')]. Un modello comune consiste nel creare un nome di risorsa concatenando un parametro con un suffisso univoco.

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

Definizione delle risorse

L'array resources è il cuore di un modello ARM. Ogni elemento descrive una risorsa Azure con i campi obbligatori type, apiVersion, name e location. apiVersion fissa la versione dello schema del provider di risorse: utilizzate sempre una versione stabile recente per accedere alle funzionalità più recenti ed evitare proprietà deprecate.

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

Funzioni ed espressioni dei modelli

Le espressioni dei modelli ARM sono racchiuse tra parentesi quadre [...] e supportano funzioni integrate per stringhe, array, oggetti e ID delle risorse. Tra le funzioni comuni figurano concat(), resourceGroup(), resourceId(), uniqueString() e parameters(). ARM valuta queste funzioni lato server al momento della distribuzione, non localmente.

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

Output: restituzione dei valori

La sezione outputs definisce i valori che ARM restituisce dopo una distribuzione completata correttamente. Gli output sono essenziali per concatenare i modelli: potete distribuire un modello di rete e restituire l'ID risorsa della subnet, quindi passarlo come parametro a un modello di VM. Gli output possono fare riferimento a qualsiasi espressione, comprese le proprietà delle risorse della distribuzione.

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

Modelli collegati e annidati

Per le architetture complesse, ARM supporta i modelli collegati (che fanno riferimento a URL di modelli esterni) e i modelli annidati (che incorporano un modello nell'array resources usando il tipo Microsoft.Resources/deployments). In questo modo potete suddividere una distribuzione infrastrutturale di grandi dimensioni in componenti modulari e riutilizzabili, mantenendo un unico modello di orchestrazione come punto di ingresso.

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

File dei parametri

Anziché passare i parametri dalla riga di comando, memorizzateli in un file dei parametri separato: un file JSON con un oggetto parameters contenente coppie nome-valore. I file dei parametri possono essere specifici per l'ambiente (ad esempio, dev.parameters.json e prod.parameters.json) e salvati nel controllo del codice sorgente, mantenendo i valori sensibili nei riferimenti ad Azure Key Vault anziché in testo normale.

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

Distribuzione e convalida dei modelli

Utilizzate il comando dell'Azure CLI az deployment group create per distribuire un modello in un gruppo di risorse. Prima di distribuire in produzione, eseguite az deployment group validate per individuare errori di schema e di logica, quindi az deployment group what-if per visualizzare in anteprima le modifiche alle risorse. Questi tre comandi costituiscono una pipeline di distribuzione sicura: convalidare, visualizzare in anteprima, distribuire.

# 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

Procedure consigliate per i modelli ARM

Seguite queste procedure consigliate per i modelli ARM: utilizzate i parametri per i valori specifici dell'ambiente, utilizzate le variabili per evitare ripetizioni, fissate le versioni dell'API su versioni stabili, utilizzate secureString per le password, aggiungete descrizioni nei metadati dei parametri e suddividete i modelli di grandi dimensioni in moduli collegati. Salvate i modelli in un repository Git e distribuiteli tramite una pipeline CI/CD per garantire la tracciabilità.

Verifica rapida

Verificate la vostra comprensione dei concetti di Microsoft Azure Fundamentals (AZ-900) trattati in questa lezione.

Riepilogo della lezione

In questa lezione avete imparato che i modelli ARM sono documenti JSON che definiscono in modo dichiarativo l'infrastruttura Azure, che parametri e variabili rendono i modelli riutilizzabili e manutenibili e che il flusso di lavoro validate, what-if, deploy consente distribuzioni sicure e ripetibili. Nella prossima lezione esplorerete Bicep, un'astrazione moderna del formato JSON di ARM.

Domande Frequenti

La lezione «Scrittura di template ARM» è gratuita?

Sì — il testo completo di «Scrittura di template ARM» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Azure Fundamentals, passa a CoddyKit PRO. Il corso Azure Fundamentals include 4 lezioni in totale.

Cosa imparerò in «Scrittura di template ARM»?

Crei in JSON un template ARM parametrizzato per distribuire un account di archiviazione e una VM e usi funzioni e variabili del template per renderlo riutilizzabile. Eserciti Azure Fundamentals con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Azure Fundamentals?

Non è richiesta alcuna esperienza precedente. Azure Fundamentals su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Scrittura di template ARM»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Azure Fundamentals?

Sì. Ogni lezione Azure Fundamentals include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Come funziona Azure Resource Manager
  2. Scrittura di template ARM
  3. Bicep: IaC moderno per Azure
  4. Terraform su Azure
← Torna a Azure Fundamentals