0Pricing
Azure Fundamentals · Lezione

Bicep: IaC moderno per Azure

Apprenda la sintassi concisa di Bicep, un'astrazione fortemente tipizzata su ARM JSON, converta un template ARM esistente in Bicep e lo distribuisca con Azure CLI.

Bicep: IaC moderno per Azure è una lezione Azure Fundamentals gratuita su CoddyKit. Questa è la lezione 3 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.

Che cos'è Bicep e perché usarlo?

Bicep è un linguaggio specifico per dominio (DSL) sviluppato da Microsoft come alternativa concisa e fortemente tipizzata ai modelli ARM JSON. Bicep viene compilato nel formato ARM JSON standard, quindi utilizza lo stesso motore di distribuzione ARM e supporta tutti i tipi di risorsa Azure fin dal primo giorno. Bicep elimina gran parte del codice ripetitivo richiesto dal JSON puro e offre una migliore sicurezza dei tipi e un supporto IntelliSense.

Confronto della sintassi Bicep e ARM JSON

Lo stesso account di archiviazione che in un modello ARM richiede circa 25 righe di JSON ne richiede solo circa 8 in Bicep. Bicep elimina '$schema', contentVersion, il contenitore dell'array resources e la sintassi prolissa delle espressioni. I nomi e i tipi delle proprietà rimangono identici, poiché Bicep è un livello di astrazione diretto sopra ARM JSON: non esiste alcuna differenza a runtime.

// Bicep: deploy a storage account
param storageAccountName string
param location string = resourceGroup().location
param sku string = 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: sku
  }
  kind: 'StorageV2'
  properties: {
    supportsHttpsTrafficOnly: true
    minimumTlsVersion: 'TLS1_2'
  }
}

Parametri e decoratori in Bicep

I parametri Bicep utilizzano la sintassi concisa param name type = defaultValue. Potete applicare decoratori (preceduti da @) direttamente sopra un parametro per aggiungere vincoli come @minLength(), @maxLength(), @allowed() e @description(). Il decoratore @secure() contrassegna un parametro come sensibile ed è equivalente a secureString in ARM JSON.

@description('Globally unique name for the storage account')
@minLength(3)
@maxLength(24)
param storageAccountName string

@allowed(['Standard_LRS', 'Standard_GRS', 'Premium_LRS'])
param sku string = 'Standard_LRS'

@secure()
param adminPassword string

Variabili ed espressioni in Bicep

Le variabili Bicep vengono dichiarate con la parola chiave var e possono contenere qualsiasi espressione, inclusa l'interpolazione di stringhe tramite la sintassi '${value}'. L'interpolazione di stringhe è uno dei miglioramenti più leggibili rispetto ad ARM JSON: non sono più necessarie chiamate alla funzione concat(). Bicep supporta inoltre le espressioni condizionali tramite l'operatore ternario condition ? trueValue : falseValue.

param environment string = 'dev'
param baseName string = 'myapp'

var uniqueSuffix = uniqueString(resourceGroup().id)
var storageAccountName = '${baseName}${environment}${uniqueSuffix}'
var isProd = environment == 'prod'
var skuName = isProd ? 'Standard_GRS' : 'Standard_LRS'

Dichiarazioni delle risorse e nomi simbolici

In Bicep, a ogni risorsa viene assegnato un nome simbolico, ovvero un identificatore utilizzato per farvi riferimento nel modello. Il nome simbolico non coincide con il nome Azure della risorsa. Utilizzate i nomi simbolici per accedere alle proprietà delle risorse e stabilire dipendenze implicite facendo riferimento a una risorsa all'interno di un'altra; in questo modo non è necessario un array dependsOn esplicito.

resource vnet 'Microsoft.Network/virtualNetworks@2023-05-01' = {
  name: 'myVNet'
  location: location
  properties: {
    addressSpace: { addressPrefixes: ['10.0.0.0/16'] }
  }
}

// Implicit dependency via symbolic name reference
resource subnet 'Microsoft.Network/virtualNetworks/subnets@2023-05-01' = {
  parent: vnet  // Bicep knows to create vnet first
  name: 'mySubnet'
  properties: {
    addressPrefix: '10.0.1.0/24'
  }
}

Output in Bicep

Gli output di Bicep vengono dichiarati con la parola chiave output, seguita dal nome, dal tipo e dal valore dell'output. È possibile fare riferimento alle proprietà di una risorsa distribuita usando il nome simbolico e la notazione con il punto, molto più leggibile rispetto alla funzione reference() di ARM. Gli output sono essenziali per passare valori tra le chiamate ai moduli Bicep.

output storageAccountName string = storageAccount.name
output blobEndpoint string = storageAccount.properties.primaryEndpoints.blob
output storageAccountId string = storageAccount.id

Moduli Bicep

I moduli Bicep sono l'equivalente dei template collegati in formato JSON di ARM e consentono di suddividere l'infrastruttura in componenti riutilizzabili. Un modulo è semplicemente un altro file .bicep. È possibile farvi riferimento usando la parola chiave module, passare parametri e utilizzare i relativi output. I moduli possono anche essere pubblicati e utilizzati da un Azure Container Registry per il riutilizzo da parte dell'intero team.

// main.bicep — consuming a storage module
module storage './modules/storage.bicep' = {
  name: 'storageDeploy'
  params: {
    storageAccountName: 'myuniquestorage'
    location: location
    sku: 'Standard_LRS'
  }
}

// Reference module output in parent template
output blobUri string = storage.outputs.blobEndpoint

Conversione dei template ARM in Bicep

Se dispone già di template JSON ARM esistenti, la CLI di Bicep può decompilarli in Bicep usando bicep decompile. Il risultato potrebbe richiedere alcune operazioni manuali di pulizia, ma offre un eccellente punto di partenza. Microsoft mette inoltre a disposizione un playground online all'indirizzo aka.ms/bicepdemo, dove è possibile incollare JSON ARM e visualizzare in tempo reale l'equivalente in Bicep.

# Install the Bicep CLI (or use it via Azure CLI)
az bicep install
az bicep upgrade

# Decompile existing ARM JSON to Bicep
az bicep decompile --file azuredeploy.json
# Produces azuredeploy.bicep in the same directory

# Compile Bicep to ARM JSON (for inspection)
az bicep build --file main.bicep

Distribuzione di Bicep con Azure CLI

Azure CLI supporta direttamente i file Bicep: non è necessario compilarli manualmente in JSON ARM prima della distribuzione. Passi il percorso del file .bicep a az deployment group create con il flag --template-file; la CLI eseguirà la compilazione in modo trasparente. Gli stessi sottocomandi validate e what-if funzionano con i file Bicep esattamente come con il JSON ARM.

# Deploy a Bicep file directly
az deployment group create \
  --resource-group MyRG \
  --template-file main.bicep \
  --parameters storageAccountName=myprodstore environment=prod

# What-if preview with Bicep
az deployment group what-if \
  --resource-group MyRG \
  --template-file main.bicep \
  --parameters storageAccountName=myprodstore environment=prod

Cicli e condizioni in Bicep

Bicep supporta i cicli sulle risorse usando la sintassi for ... in per creare più istanze di una risorsa a partire da un parametro array, eliminando la duplicazione dovuta al copia-incolla. La parola chiave if abilita la distribuzione condizionale delle risorse: una risorsa viene inclusa solo quando una determinata condizione è vera. Entrambe le funzionalità vengono compilate rispettivamente nei costrutti ARM copy e condition.

// Loop: create multiple storage accounts
param storageNames array = ['alpha', 'beta', 'gamma']

resource stores 'Microsoft.Storage/storageAccounts@2023-01-01' = [for name in storageNames: {
  name: '${name}${uniqueString(resourceGroup().id)}'
  location: location
  sku: { name: 'Standard_LRS' }
  kind: 'StorageV2'
}]

// Condition: only deploy in prod
param deployKeyVault bool = false

resource kv 'Microsoft.KeyVault/vaults@2023-07-01' = if (deployKeyVault) {
  name: 'myKeyVault'
  location: location
  properties: { sku: { family: 'A', name: 'standard' }, tenantId: subscription().tenantId, accessPolicies: [] }
}

Strumenti e linting di Bicep

L'estensione Bicep per Visual Studio Code offre funzionalità avanzate di IntelliSense, controllo dei tipi ed evidenziazione degli errori inline durante la digitazione. La CLI di Bicep include un linter che verifica la presenza di violazioni delle best practice, ad esempio parametri inutilizzati, descrizioni mancanti e versioni API errate. Esegua az bicep lint --file main.bicep nella pipeline CI per individuare i problemi prima della distribuzione.

# Run the Bicep linter
az bicep lint --file main.bicep

# Format a Bicep file
az bicep format --file main.bicep

# Generate resource type documentation
az bicep generate-params --file main.bicep --output-format json

Verifica rapida

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

Riepilogo della lezione

In questa lezione ha imparato che Bicep è un'astrazione concisa e fortemente tipizzata sul JSON ARM, che viene compilata in template ARM standard; i moduli e i cicli consentono di scrivere codice d'infrastruttura riutilizzabile e DRY; inoltre, Azure CLI distribuisce direttamente i file Bicep supportando lo stesso flusso di lavoro validate/what-if/deploy. Prossimamente esploreremo Terraform in Azure.

Domande Frequenti

La lezione «Bicep: IaC moderno per Azure» è gratuita?

Sì — il testo completo di «Bicep: IaC moderno per Azure» è 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 «Bicep: IaC moderno per Azure»?

Apprenda la sintassi concisa di Bicep, un'astrazione fortemente tipizzata su ARM JSON, converta un template ARM esistente in Bicep e lo distribuisca con Azure CLI. 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 3 di 4.

Quanto tempo richiede la lezione «Bicep: IaC moderno per Azure»?

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