Usare un avviso per attivare un runbook di Automazione di Azure

È possibile usare Monitoraggio di Azure per monitorare metriche e log di livello base per la maggior parte dei servizi in Azure. È possibile chiamare i runbook di Automazione di Azure usando gruppi di azioni per automatizzare attività in base ad avvisi. Questo articolo illustra come configurare ed eseguire un runbook usando gli avvisi.

Prerequisiti

• Un account Automazione di Azure con almeno un'identità gestita assegnata all'utente. Per altre informazioni, vedere Uso di un'identità gestita assegnata dall'utente per un account Automazione di Azure.
• Moduli Az: Az.Accounts e Az.Compute importati nell'account di Automazione. Per altre informazioni, vedere Importazione di moduli Az.
• Una macchina virtuale di Azure.
• Il modulo Azure Az PowerShell installato nel computer. Installare o aggiornare, vedere Come installare il modulo Azure Az PowerShell.
• Familiarità generale con i runbook di automazione.

Tipi di avviso

È possibile usare i runbook di automazione con tre tipi di avviso:

• Avvisi comuni
• Avvisi dei log attività
• Avvisi di metriche quasi in tempo reale

Quando un avviso chiama un runbook, la chiamata effettiva è una richiesta HTTP POST al webhook. Il corpo della richiesta POST contiene un oggetto in formato JSON con proprietà utili relative all'avviso. La tabella seguente elenca i collegamenti allo schema del payload per ogni tipo di avviso:

Poiché i dati forniti da ogni tipo di avviso sono diversi, ogni tipo di avviso deve essere gestito in modo diverso. Nella sezione seguente viene illustrato come creare un runbook per gestire i diversi tipi di avvisi.

Assegnare le autorizzazioni alle identità gestite

Assegnare le autorizzazioni all'identità gestita appropriata per consentire l'arresto di una macchina virtuale. Il runbook può usare l'identità gestita assegnata dal sistema dell'account di Automazione o un'identità gestita assegnata dall'utente. Vengono forniti passaggi per assegnare le autorizzazioni a ogni identità. I passaggi seguenti usano PowerShell. Se si preferisce usare il portale, vedere Assegnare ruoli di Azure tramite il portale di Azure.

1. Accedere ad Azure in modo interattivo usando il cmdlet Connect-AzAccount e seguire le istruzioni:

   # Sign in to your Azure subscription
   $sub = Get-AzSubscription -ErrorAction SilentlyContinue
   if(-not($sub))
   {
       Connect-AzAccount
   }
   
   # If you have multiple subscriptions, set the one to use
   # Select-AzSubscription -SubscriptionId <SUBSCRIPTIONID>
   

2. Specificare un valore appropriato per le variabili seguenti e quindi eseguire lo script.

   $resourceGroup = "resourceGroup"
   $automationAccount = "AutomationAccount"
   $userAssignedManagedIdentity = "userAssignedManagedIdentity"
   

3. Usare il cmdlet di PowerShell New-AzRoleAssignment per assegnare un ruolo all’identità gestita assegnata dal sistema.

   $SAMI = (Get-AzAutomationAccount -ResourceGroupName $resourceGroup -Name $automationAccount).Identity.PrincipalId
   New-AzRoleAssignment `
       -ObjectId $SAMI `
       -ResourceGroupName $resourceGroup `
       -RoleDefinitionName "DevTest Labs User"
   

4. Assegnare un ruolo a un’identità gestita assegnata dall’utente.

   $UAMI = (Get-AzUserAssignedIdentity -ResourceGroupName $resourceGroup -Name $userAssignedManagedIdentity)
   New-AzRoleAssignment `
       -ObjectId $UAMI.PrincipalId `
       -ResourceGroupName $resourceGroup `
       -RoleDefinitionName "DevTest Labs User"
   

5. Per l’identità gestita assegnata dal sistema, visualizzare ClientId e registrare il valore per un uso successivo.

   $UAMI.ClientId
   

Creare un runbook per gestire gli avvisi

Per usare l'Automazione di Azure con gli avvisi, è necessario un runbook che gestisca il payload JSON dell'avviso passato al runbook. Il seguente runbook di esempio deve essere chiamato da un avviso di Azure.

Come descritto nella sezione precedente, ogni tipo di avviso ha uno schema diverso. Lo script accetta i dati del webhook da un avviso nel parametro di input runbook WebhookData. Lo script valuta quindi il payload JSON per determinare il tipo di avviso usato.

Questo esempio usa un avviso da una macchina virtuale (VM) di Azure. Estrae i dati della VM dal payload, in particolare dalla risorsa di destinazione dell'avviso attivato, e quindi usa tali informazioni per arrestare la VM. La connessione deve essere configurata nell'account di Automazione in cui è eseguito il runbook. Quando si usano gli avvisi per attivare i runbook, è importante controllare lo stato dell'avviso nel runbook che viene attivato. Il runbook viene attivato ogni volta che lo stato dell'avviso cambia. Gli avvisi hanno più stati; i due più comuni sono Attivato e Risolto. Cercare lo stato nella logica del runbook per assicurarsi che il runbook non venga eseguito più volte. L'esempio in questo articolo illustra come cercare solo gli avvisi con stato Attivato.

Il runbook usa l'identità gestita assegnata dal sistema dell'account di Automazione per eseguire l'autenticazione con Azure per eseguire l'azione di gestione per la VM. Il runbook può essere facilmente modificato per usare un'identità gestita assegnata dall'utente.

Usare questo esempio per creare un runbook denominato Stop AzureVmInResponsetoVMAlert. È possibile modificare lo script di PowerShell e usarlo con molte risorse diverse.

1. Accedere al portale di Azure e passare all'account di Automazione.

2. In Automazione processi selezionare Runbook.

3. Selezionare +Crea un runbook.

   1. Assegnare un nome al runbook Stop-AzureVmInResponsetoVMAlert.
   2. Nell'elenco a discesa Tipo di runbook, selezionare PowerShell.
   3. Seleziona Crea.

4. Nell'editor dei runbook incollare il codice seguente:

   [OutputType("PSAzureOperationResponse")]
   param
   (
       [Parameter (Mandatory=$false)]
       [object] $WebhookData
   )
   $ErrorActionPreference = "stop"
   
   if ($WebhookData)
   {
       # Get the data object from WebhookData
       $WebhookBody = (ConvertFrom-Json -InputObject $WebhookData.RequestBody)
   
       # Get the info needed to identify the VM (depends on the payload schema)
       $schemaId = $WebhookBody.schemaId
       Write-Verbose "schemaId: $schemaId" -Verbose
       if ($schemaId -eq "azureMonitorCommonAlertSchema") {
           # This is the common Metric Alert schema (released March 2019)
           $Essentials = [object] ($WebhookBody.data).essentials
           # Get the first target only as this script doesn't handle multiple
           $alertTargetIdArray = (($Essentials.alertTargetIds)[0]).Split("/")
           $SubId = ($alertTargetIdArray)[2]
           $ResourceGroupName = ($alertTargetIdArray)[4]
           $ResourceType = ($alertTargetIdArray)[6] + "/" + ($alertTargetIdArray)[7]
           $ResourceName = ($alertTargetIdArray)[-1]
           $status = $Essentials.monitorCondition
       }
       elseif ($schemaId -eq "AzureMonitorMetricAlert") {
           # This is the near-real-time Metric Alert schema
           $AlertContext = [object] ($WebhookBody.data).context
           $SubId = $AlertContext.subscriptionId
           $ResourceGroupName = $AlertContext.resourceGroupName
           $ResourceType = $AlertContext.resourceType
           $ResourceName = $AlertContext.resourceName
           $status = ($WebhookBody.data).status
       }
       elseif ($schemaId -eq "Microsoft.Insights/activityLogs") {
           # This is the Activity Log Alert schema
           $AlertContext = [object] (($WebhookBody.data).context).activityLog
           $SubId = $AlertContext.subscriptionId
           $ResourceGroupName = $AlertContext.resourceGroupName
           $ResourceType = $AlertContext.resourceType
           $ResourceName = (($AlertContext.resourceId).Split("/"))[-1]
           $status = ($WebhookBody.data).status
       }
       elseif ($schemaId -eq $null) {
           # This is the original Metric Alert schema
           $AlertContext = [object] $WebhookBody.context
           $SubId = $AlertContext.subscriptionId
           $ResourceGroupName = $AlertContext.resourceGroupName
           $ResourceType = $AlertContext.resourceType
           $ResourceName = $AlertContext.resourceName
           $status = $WebhookBody.status
       }
       else {
           # Schema not supported
           Write-Error "The alert data schema - $schemaId - is not supported."
       }
   
       Write-Verbose "status: $status" -Verbose
       if (($status -eq "Activated") -or ($status -eq "Fired"))
       {
           Write-Verbose "resourceType: $ResourceType" -Verbose
           Write-Verbose "resourceName: $ResourceName" -Verbose
           Write-Verbose "resourceGroupName: $ResourceGroupName" -Verbose
           Write-Verbose "subscriptionId: $SubId" -Verbose
   
           # Determine code path depending on the resourceType
           if ($ResourceType -eq "Microsoft.Compute/virtualMachines")
           {
               # This is an Resource Manager VM
               Write-Verbose "This is an Resource Manager VM." -Verbose
   
               # Ensures you do not inherit an AzContext in your runbook
               Disable-AzContextAutosave -Scope Process
   
               # Connect to Azure with system-assigned managed identity
               $AzureContext = (Connect-AzAccount -Identity).context
   
               # set and store context
               $AzureContext = Set-AzContext -SubscriptionName $AzureContext.Subscription -DefaultProfile $AzureContext
   
               # Stop the Resource Manager VM
               Write-Verbose "Stopping the VM - $ResourceName - in resource group - $ResourceGroupName -" -Verbose
               Stop-AzVM -Name $ResourceName -ResourceGroupName $ResourceGroupName -DefaultProfile $AzureContext -Force
               # [OutputType(PSAzureOperationResponse")]
           }
           else {
               # ResourceType not supported
               Write-Error "$ResourceType is not a supported resource type for this runbook."
           }
       }
       else {
           # The alert status was not 'Activated' or 'Fired' so no action taken
           Write-Verbose ("No action taken. Alert status: " + $status) -Verbose
       }
   }
   else {
       # Error
       Write-Error "This runbook is meant to be started from an Azure alert webhook only."
   }
   

5. Se si vuole che il runbook venga eseguito con l'identità gestita assegnata dal sistema, lasciare invariato il codice. Se si preferisce usare un'identità gestita assegnata dall'utente, procedere come illustrato di seguito:

   1. Dalla riga 78 rimuovere $AzureContext = (Connect-AzAccount -Identity).context,
   2. Sostituirlo con $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context e
   3. Immettere l'ID client ottenuto in precedenza.

6. Selezionare Salva, Pubblica e quindi Sì quando richiesto.

7. Chiudere la pagina Runbook per tornare alla pagina Account di automazione.

Creare l'avviso

Gli avvisi usano i gruppi di azioni, ovvero raccolte di azioni attivate dall'avviso. I runbook sono solo una delle molte azioni disponibili con i gruppi di azioni.

1. Nell'account di Automazione, selezionare Avvisi in Monitoraggio.

2. Selezionare + Nuova regola di avviso per aprire la pagina Crea regola di avviso.

   

3. In Ambito, selezionare Modifica risorsa.

4. Nella pagina Seleziona una risorsa, selezionare Macchine virtuali nell'elenco a discesa Filtra per tipo di risorsa.

5. Selezionare la casella accanto alle macchine virtuali da monitorare. Selezionare quindi Fine per tornare alla pagina Crea regola di avviso.

6. In Condizione, selezionare Aggiungi condizione.

7. Nella pagina Seleziona un segnale, immettere Percentage CPU nella casella di testo di ricerca e quindi selezionare Percentuale CPU dai risultati.

8. Nella pagina Configura la logica del segnale, in Valore soglia immettere un valore iniziale basso a scopo di test, ad esempio 5. Dopo essersi accertati che l'avviso funziona come previsto, è possibile tornare indietro e aggiornare questo valore. Selezionare quindi Fine per tornare alla pagina Crea regola di avviso.

   

9. In Azioni, selezionare Aggiungi gruppo di azioni e quindi + Crea gruppo di azioni.

   

10. Nella pagina Crea gruppo di azioni:

    1. Nella scheda Informazioni di base, specificare un Nome gruppo di azioni e un Nome visualizzato.

    2. Nella scheda Azioni, nella casella di testo Nome immettere un nome. Nell'elenco a discesa Tipo di azione, selezionare Runbook di automazione per aprire la pagina Configura runbook.

       1. Per l'elemento Origine runbook, selezionare utente.

       2. Nell'elenco a discesa Sottoscrizione, selezionare la sottoscrizione.

       3. Nell'elenco a discesa Account di automazione, selezionare l'account di Automazione.

       4. Nell'elenco a discesa Runbook, selezionare Stop-AzureVmInResponsetoVMAlert.

       5. Dall'elemento Abilita lo schema di avviso comune, Selezionare Sì.

       6. Selezionare OK per tornare alla pagina Crea gruppo di azioni.

          

    3. Selezionare Rivedi + Crea e quindi Crea per tornare alla pagina Crea regola di avviso.

11. In Dettagli regola di avviso, per la casella di testo Nome regola di avviso.

12. Selezionare Crea regola di avviso. È possibile usare questo gruppo di azione negli avvisi dei log attività e negli avvisi near real-time che vengono creati.

Verifica

Assicurarsi che la VM sia in esecuzione. Passare al runbook Stop-AzureVmInResponsetoVMAlert e controllare l'elenco Processi recenti da popolare. Una volta visualizzato un processo completato, selezionare il processo ed esaminare l'output. Controllare anche se la VM è stata arrestata.

Operazioni di gestione comuni delle VM di Azure

Automazione di Azure fornisce script per operazioni di gestione comuni delle VM di Azure, ad esempio riavvio VM, arresto VM, eliminazione di VM, scenari di aumento re riduzione nella raccolta di runbook. Gli script sono disponibili anche nel repository GitHub di Automazione di Azure e possono essere usati anche come indicato nei passaggi precedenti.

Passaggi successivi

• Per le diverse modalità di avvio di un runbook, vedere Avviare un runbook.
• Per creare un avviso del log attività, vedere Creare avvisi del log attività.
• Per informazioni su come creare un avviso near real-time, vedere Creare una regola di avviso nel portale di Azure.