Anteprima le modifiche allo stack di distribuzione usando il what-if

Prima di creare o aggiornare uno stack di deployment Azure, visualizza in anteprima le modifiche che lo stack apporta utilizzando l'operazione what-if. L'operazione ipotetica non apporta alcuna modifica alle risorse esistenti. Invece, prevede i cambiamenti che avvengono se applichi lo stack con il template e i parametri specificati. Poiché uno stack di distribuzione gestisce un insieme di risorse come un'unica unità, visualizzare in anteprima le modifiche usando what-if è particolarmente utile. Puoi confermare quali risorse sono state create, aggiornate o lasciate invariate. Puoi anche catturare le risorse che diventano non gestite (staccate o cancellate) prima di applicare la modifica.

Simulazione per distribuzioni Bicep

L'operazione what-if è una funzione dei template di Azure Resource Manager che anteprima le modifiche apportate da una distribuzione prima che tu le applichi. È disponibile per le distribuzioni standard di Bicep e per gli stack di distribuzione. Per una descrizione completa di come funziona l'operazione, dei tipi di modifiche che segnala e delle relative limitazioni, consulta Visualizzare in anteprima le modifiche di distribuzione di Bicep usando what-if. Il resto di questo articolo si concentra sull'uso di what-if con gli stack di distribuzione.

In che modo i risultati della simulazione dello stack differiscono dalla simulazione di distribuzione

Se si sta passando dalle distribuzioni agli stack di distribuzione, la differenza più importante riguarda la posizione in cui risiede il risultato.

Per una distribuzione standard, la simulazione è un'operazione. Lo esegui, Azure restituisce le modifiche previste e dopo non viene memorizzato nulla.

Per uno stack di distribuzione, la simulazione crea una risorsa di risultato simulazione. Il risultato è una risorsa Azure autonoma di tipo Microsoft.Resources/deploymentStacksWhatIfResults che nomini tu stesso, e che fa riferimento allo stack con cui è stata valutata invece di essere un'operazione su quello stack. Poiché il risultato è una risorsa a sé stante, puoi recuperarla, condividere il suo ID risorsa ed eliminarla in seguito.

Caratteristica Distribuzione simulazione Simulazione dello stack di distribuzione
Form Un'operazione che restituisce un risultato Una risorsa che crei tu
Name Non nominato Fornisci un nome
Tipo di risorsa Non applicabile Microsoft.Resources/deploymentStacksWhatIfResults
Collegamento allo stack Non applicabile properties.deploymentStackResourceId fa riferimento allo stack
Persistenza Non memorizzato Memorizzata per l'intervallo di ritenzione che hai impostato

Un risultato ha un ID risorsa in questa forma:

/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/Microsoft.Resources/deploymentStacksWhatIfResults/{what-if-result-name}

Lo stack che hai valutato non deve necessariamente esistere ancora. Se non lo fa, what-if riporta lo stack stesso come una nuova risorsa, il che ti permette di visualizzare in anteprima la prima esecuzione di uno stack prima di crearlo.

Limitations

La funzionalità what-if per gli stack di distribuzione condivide le limitazioni di base di what-if delle distribuzioni di modelli di Azure Resource Manager, incluse quelle relative all'accuratezza dei risultati per determinati tipi di risorse e proprietà. Rivedi sempre attentamente i cambiamenti previsti prima di applicare uno stack, soprattutto quando actionOnUnmanage è impostato su un'opzione di eliminazione.

  • La riduzione del rumore non elimina tutte le differenze. Il "What if" filtra molte differenze comuni che non sono cambiamenti reali, ma non le filtra tutte. Per maggiori informazioni, vedi Riduzione del rumore nei risultati what-if dello stack di distribuzione.
  • Un ambito può contenere fino a 800 risultati di simulazione what-if. Questo limite è separato dai limiti sulle distribuzioni e sugli stack di distribuzione, quindi eseguire il what-if non consuma la cronologia delle distribuzioni per l'ambito. I risultati vengono cancellati automaticamente quando il loro intervallo di conservazione scade. Per maggiori informazioni, consulta Recupera ed elimina i risultati memorizzati.

Come funziona il what-if con gli stack di distribuzione

Quando esegui what-if su uno stack di deployment, l'operazione valuta il template rispetto allo stato attuale delle risorse gestite dallo stack e segnala ogni risorsa come uno dei seguenti tipi di modifica:

Tipo di modifica Description
Creare La risorsa non esiste e viene creata.
Modifica La risorsa esiste e alcune proprietà cambiano.
NoChange La risorsa esiste e non viene modificata.
Elimina Si applica quando actionOnUnmanage è impostato su cancellazione. La risorsa viene rimossa dalla pila ed eliminata.
Scollega Si applica quando actionOnUnmanage è impostato per disconnettersi. La risorsa viene rimossa dalla gestione dello stack ma non viene eliminata da Azure.
Unsupported La risorsa non è compatibile con l'analisi what-if.

Annotazioni

Quando il fornitore di risorse ignora una proprietà di sola lettura (ad esempio, sku.tier impostata per corrispondere sku.name a alcuni tipi di risorse), what-if riporta quella proprietà come NoEffect. Alcuni client visualizzano NoEffect come NoChange. Questa differenza riguarda solo il display e non influisce sulle modifiche applicate dallo stack.

What-if fa emergere anche risorse che sono staccate dallo stack (non più gestite) in base al comportamento actionOnUnmanage , così puoi confermare che nessuna risorsa gestita viene rimossa involontariamente.

Riduzione del rumore

What-if confronta il tuo template con lo stato attuale delle risorse gestite dallo stack, e non ogni differenza che trova è un cambiamento che la distribuzione del template potrebbe effettivamente apportare. I provider di risorse aggiungono e normalizzano valori dopo che una risorsa è stata distribuita, quindi una proprietà può differire dal tuo template anche quando nulla di significativo è cambiato. Queste differenze sono rumore.

Gli stack di deployment filtrano il rumore per te. Quando distribuisci o aggiorni uno stack, Azure valuta il what-if per lo stack in quel momento e mantiene il risultato come baseline. Quando esegui il what-if contro lo stack in seguito, qualsiasi proprietà invariata tra quella baseline e la valutazione corrente viene rimossa dal risultato. La riduzione del rumore è abilitata in tutte le regioni.

Poiché Azure registra la baseline quando distribuisci lo stack, la riduzione del rumore si applica agli stack che hai creato o aggiornato il 13 agosto 2026 o in data successiva. Se da allora non hai distribuito o aggiornato uno stack, i risultati what-if includono comunque rumore. Distribuisci o aggiorna lo stack una volta per stabilire la baseline.

Annotazioni

La riduzione del rumore elimina molte differenze comuni, ma non le elimina tutte. Rivedere i cambiamenti segnalati invece di presumere che ogni differenza sia un cambiamento reale.

Per informazioni sull'origine del rumore, su ciò che viene rimosso dal filtro e su ciò che non viene rimosso, vedere Riduzione del rumore nei risultati what-if dello stack di distribuzione.

Usa il what-if per indagare la deriva di configurazione

La deriva di configurazione si verifica quando lo stato attuale di una risorsa differisce dalla configurazione prevista nel tuo template e nei parametri. Poiché la riduzione del rumore filtra le differenze già presenti all'ultima implementazione dello stack, un'esecuzione successiva di what-if con lo stesso template, parametri e impostazioni dello stack segnala modifiche fatte fuori dallo stack dopo quella implementazione, come modifiche nel portale Azure o tramite uno script. Ogni differenza riportata mostra la modifica che la riapplicazione dello stack comporterebbe per ripristinare la configurazione prevista.

What-if è un controllo in un momento preciso, non un monitoraggio continuo della deriva. Riporta cosa differisce, ma non chi o cosa ha apportato la modifica. Per trovare la fonte di una modifica, usa il registro delle attività o le modifiche delle risorse in Azure Resource Graph.

Prima di iniziare

  • Conserva il file Bicep o il template ARM e i valori dei parametri che rappresentano la configurazione prevista.
  • Selezionare lo stesso stack di distribuzione e lo stesso ambito che gestiscono le risorse.
  • Usare le stesse impostazioni di actionOnUnmanage e di rifiuto della configurazione prevista dello stack. Cambiare questi input può modificare il risultato what-if.
  • Assicurati che lo stack abbia una baseline, il che significa che l'hai creato o aggiornato il 13 agosto 2026 o in data successiva. Senza una baseline, il risultato include anche rumore. Aggiornare lo stack stabilisce una baseline, ma può anche annullare la deriva di configurazione esistente, quindi occorre prima rivedere un risultato di simulazione. Per altre informazioni, consultare Definizione della baseline.
  • Assicurati di avere il permesso di leggere lo stack e le risorse che gestisce, e il permesso di creare il risultato what-if, che è l'azione Microsoft.Resources/deploymentStacksWhatIfResults/write. Se la richiesta what-if usa impostazioni di rifiuto, è necessaria anche l'azione Microsoft.Resources/deploymentStacks/manageDenySetting/action.

Controlla la deriva

  1. Esegui what-if contro lo stack usando lo stesso template, parametri e impostazioni dello stack. Il seguente esempio verifica uno stack di gruppo risorse:

    az stack-whatif group create \
  --name "<what-if-result-name>" \
  --resource-group "<resource-group-name>" \
  --stack-id "<deployment-stack-resource-id>" \
  --template-file "main.bicep" \
  --parameters "@main.parameters.json" \
  --action-on-unmanage "detachAll" \
  --deny-settings-mode "none" \
  --retention-interval "PT3H"

    L'esempio utilizza detachAll e none come segnaposto. Usare le impostazioni di actionOnUnmanage e di rifiuto che corrispondono alla configurazione prevista dello stack.

  2. Rivedi i cambiamenti a livello di proprietà nell'output dei comandi. Per rivedere il risultato memorizzato in seguito, includi le modifiche a livello di proprietà quando lo recuperi:

    az stack-whatif group show \
  --name "<what-if-result-name>" \
  --resource-group "<resource-group-name>" \
  --with-property-changes true

Interpretare i risultati

L'esempio seguente mostra un risultato per uno stack dopo che sono state apportate modifiche al di fuori dello stack. In un gruppo di sicurezza di rete gestito, venivano modificati una porta e un valore di tag e veniva aggiunto un tag. Un secondo gruppo di sicurezza di rete gestito fu eliminato.

Changes to Managed Resources:

Azure
  ~ /subscriptions/<subscription-id>/resourceGroups/demo-rg/providers/Microsoft.Network/networkSecurityGroups/examplensg [2024-05-01]
    = Management Status: "managed"
    = Deny Status: "none"
    ~ properties.securityRules:
      ~ 0:
        ~ properties.destinationPortRange: "8443" => "443"
    ~ tags.env: "drifted" => "test"
    - tags.owner: "portal"
  + /subscriptions/<subscription-id>/resourceGroups/demo-rg/providers/Microsoft.Network/networkSecurityGroups/examplensg2 [2024-05-01]
    = Management Status: "managed"
    = Deny Status: "none"

Ogni modifica descrive cosa comporterebbe la riapplicazione dello stack:

  • Modificare (~) su una proprietà impostata dal tuo template significa che il valore attuale differisce dal tuo template. Il valore prima => è il valore attuale, e il valore successivo è il valore nel tuo template.
  • Eliminare (-) su una proprietà o un elemento dell'array significa che la risorsa ha un valore che il tuo template non definisce e che non era presente quando hai distribuito lo stack l'ultima volta, come un tag o una regola aggiunta fuori dallo stack.
  • Create (+) su una risorsa che lo stack già gestisce significa che la risorsa non esiste più, ad esempio perché è stata eliminata al di fuori dello stack.
  • NoChange (=) significa che what-if non ha trovato differenze nelle proprietà valutate.
  • Eliminare o scollegare una risorsa di solito riflette il tuo template o l'impostazione actionOnUnmanage piuttosto che drift. Rivedi il template e le impostazioni dello stack.
  • Non supportato, Ignora o un messaggio diagnostico significano che la simulazione non potrebbe valutare completamente quella parte dello stack, quindi il risultato non mostra se ha subito la deriva.

Dopo aver confermato una differenza, aggiorna lo stack per ripristinare la configurazione prevista, oppure aggiorna il template e i parametri per mantenere la modifica.

Importante

Conferma una differenza segnalata rispetto alla risorsa live prima di correggerla. Non tutte le differenze derivano da un cambiamento fatto al di fuori dello stack. Ad esempio, un fornitore di risorse può modificare un valore predefinito in una versione API più recente e le espressioni che la simulazione non è in grado di valutare, come reference(), le funzioni non deterministiche e i valori protetti, possono apparire come modifiche. What-if può anche non rilevare alcune modifiche: non valuta i tipi di risorse non supportati e i limiti di espansione o l'interruzione anticipata possono escludere delle risorse dal risultato. Per maggiori informazioni, vedi Cosa la riduzione del rumore non elimina e Espressioni non valutate.

Esegui il what-if prima di creare o aggiornare uno stack

Esegui il comando what-if per anteprima i cambiamenti senza applicarli. Identifica lo stack di destinazione tramite il relativo ID risorsa: usa --stack-id in interfaccia della riga di comando di Azure o -StackResourceId in Azure PowerShell. --name (interfaccia della riga di comando di Azure) o -Name (Azure PowerShell) è il valore che specifica il nome del risultato what-if archiviato e l'operazione conserva tale risultato per il periodo di conservazione specificato, in modo da poterlo recuperare in seguito.

L'intervallo di ritenzione utilizza il formato di durata ISO 8601 e deve essere compreso tra PT1H (un'ora) e PT3H (tre ore). Azure elimina automaticamente il risultato quando l'intervallo di ritenzione scade.

Di default, what-if, verifica anche che tu abbia il permesso di scrivere ogni risorsa nel template. Per eseguire il what-if con permessi di sola lettura, ad esempio da un'identità di pipeline che ha Reader, imposta il livello di validazione su ProviderNoRbac con --validation-level ProviderNoRbac in interfaccia della riga di comando di Azure o -ValidationLevel ProviderNoRbac in Azure PowerShell. Quel livello controlla invece i permessi di lettura.

Per anteprima le modifiche di uno stack di gruppo risorse, usa il seguente comando:

az stack-whatif group create \
  --name "<what-if-result-name>" \
  --resource-group "<resource-group-name>" \
  --stack-id "<deployment-stack-resource-id>" \
  --template-file "<bicep-file-name>" \
  --action-on-unmanage "detachAll" \
  --deny-settings-mode "none" \
  --retention-interval "PT3H"

Per visualizzare in anteprima le modifiche di uno stack in abbonamento, usa il seguente comando:

az stack-whatif sub create \
  --name "<what-if-result-name>" \
  --location "<location>" \
  --stack-id "<deployment-stack-resource-id>" \
  --template-file "<bicep-file-name>" \
  --action-on-unmanage "detachAll" \
  --deny-settings-mode "none" \
  --retention-interval "PT3H"

Per anteprima le modifiche di uno stack di gruppo di gestione, usa il seguente comando:

az stack-whatif mg create \
  --name "<what-if-result-name>" \
  --management-group-id "<management-group-id>" \
  --location "<location>" \
  --stack-id "<deployment-stack-resource-id>" \
  --template-file "<bicep-file-name>" \
  --action-on-unmanage "detachAll" \
  --deny-settings-mode "none" \
  --retention-interval "PT3H"

Per anticipare l'effetto di un aggiornamento su uno stack esistente, esegui lo stesso comando what-if e passa l'ID risorsa di quello stack. In Azure PowerShell puoi anche usare i corrispondenti Set-Az*DeploymentStackWhatIfResult cmdlet.

Recupero ed elimina i risultati memorizzati

Poiché ogni risultato what-if è una risorsa a sé stante, puoi elencare, recuperare ed eliminare i risultati in qualsiasi ambito. Un ambito è limitato a 800 risultati what-if. Azure elimina automaticamente i risultati quando il loro intervallo di ritenzione termina. Puoi cancellare un risultato prima di allora quando non ne hai più bisogno.

# List the what-if results in a resource group
az stack-whatif group list --resource-group "<resource-group-name>"

# Get a single result
az stack-whatif group show --name "<what-if-result-name>" --resource-group "<resource-group-name>"

# Get a single result by resource ID
az stack-whatif group show --id "<what-if-result-resource-id>"

# Delete a result
az stack-whatif group delete --name "<what-if-result-name>" --resource-group "<resource-group-name>" --yes

Utilizzo az stack-whatif sub e az stack-whatif mg per ambiti di abbonamento e gruppi di gestione.

Ottieni modifiche a livello di risorsa o proprietà

Un risultato what-if contiene cambiamenti a due livelli di dettaglio: quali risorse cambiano e quali proprietà individuali cambiano su quelle risorse.

Quando si crea una risultato della simulazione, l'output include le modifiche a livello di proprietà. Quando recuperi un risultato memorizzato, l'output include solo le modifiche a livello di risorsa. Per includere le modifiche a livello di proprietà quando recuperi un risultato, usa --with-property-changes interfaccia della riga di comando di Azure o -WithPropertyChanges Azure PowerShell.

az stack-whatif group show \
  --name "<what-if-result-name>" \
  --resource-group "<resource-group-name>" \
  --with-property-changes true

Recuperare un risultato senza l'opzione riporta che la risorsa cambia, ma non cosa cambia su di essa:

Azure
  ~ /subscriptions/<subscription-id>/resourceGroups/demo-rg/providers/Microsoft.Storage/storageAccounts/examplestorage
    ~ Management Status: "notManaged" => "managed"
    = Deny Status: "none"

Se si ottiene lo stesso risultato con l'opzione, vengono aggiunte le singole modifiche alle proprietà:

Azure
  ~ /subscriptions/<subscription-id>/resourceGroups/demo-rg/providers/Microsoft.Storage/storageAccounts/examplestorage [2023-01-01]
    ~ Management Status: "notManaged" => "managed"
    = Deny Status: "none"
    ~ sku.name: "Standard_LRS" => "Standard_GRS"
    - tags.myTag: "myValue"
    + tags.env: "demo"

L'opzione si applica quando recuperi un singolo risultato. L'elenco dei risultati non riporta le modifiche alle proprietà.

Conferma prima di fare domanda

Usa il 'what-if' come fase di conferma nelle sessioni interattive e nelle pipeline:

  • In modo interattivo, esegui il comando what-if, rivedi i cambiamenti previsti e poi esegui il comando stack create per applicarli.
  • Nell'automazione, acquisisci il risultato dell'analisi what-if e subordina la fase di applicazione alla revisione o all'approvazione. Questo passaggio è prezioso per gli stack perché un aggiornamento può staccare o cancellare risorse a seconda dell'impostazione actionOnUnmanage .
  • Ultimo aggiornamento: