Använda en avisering för att utlösa en Azure Automation runbook

Du kan använda Azure Monitor för att övervaka mått och loggar på basnivå för de flesta tjänster i Azure. Du kan anropa Azure Automation runbooks med hjälp av åtgärdsgrupper för att automatisera uppgifter baserat på aviseringar. Den här artikeln visar hur du konfigurerar och kör en runbook med hjälp av aviseringar.

Förutsättningar

• Ett Azure Automation-konto med minst en användar tilldelad hanterad identitet. Mer information finns i Använda en användar tilldelad hanterad identitet för ett Azure Automation konto.
• Az-moduler: Az.Accounts och Az.Compute importerades till Automation-kontot. Mer information finns i Importera Az-moduler.
• En virtuell Azure-dator.
• Azure Az PowerShell-modulen som är installerad på datorn. Information om hur du installerar eller uppgraderar finns i Installera Azure Az PowerShell-modulen.
• Allmän kunskap om Automation-runbooks.

Aviseringstyper

Du kan använda Automation-runbooks med tre aviseringstyper:

• Vanliga aviseringar
• Aktivitetsloggaviseringar
• Måttaviseringar nästan i realtid

När en avisering anropar en runbook är det faktiska anropet en HTTP POST-begäran till webhooken. Brödtexten i POST-begäran innehåller ett JSON-formaterat objekt som har användbara egenskaper som är relaterade till aviseringen. I följande tabell visas länkar till nyttolastschemat för varje aviseringstyp:

Eftersom de data som tillhandahålls av varje typ av avisering är olika hanteras varje aviseringstyp på olika sätt. I nästa avsnitt får du lära dig hur du skapar en runbook för att hantera olika typer av aviseringar.

Tilldela behörigheter till hanterade identiteter

Tilldela behörigheter till lämplig hanterad identitet så att den kan stoppa en virtuell dator. Runbooken kan använda antingen Automation-kontots system tilldelade hanterade identitet eller en användar tilldelad hanterad identitet. Steg finns för att tilldela behörigheter till varje identitet. Stegen nedan använder PowerShell. Om du föredrar att använda portalen kan du gå till Tilldela Azure-roller med hjälp av Azure Portal.

1. Logga in på Azure interaktivt med hjälp Anslut-AzAccount-cmdleten och följ instruktionerna.

   # 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. Ange ett lämpligt värde för variablerna nedan och kör sedan skriptet.

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

3. Använd PowerShell-cmdleten New-AzRoleAssignment för att tilldela en roll till den systemtilldelade hanterade identiteten.

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

4. Tilldela en roll till en användar tilldelad hanterad identitet.

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

5. För den system tilldelade hanterade identiteten visar ClientId och registrerar du värdet för senare användning.

   $UAMI.ClientId
   

Skapa en runbook för att hantera aviseringar

Om du vill använda Automation med aviseringar behöver du en runbook som hanterar JSON-aviseringsnyttolasten som skickas till runbooken. Följande exempel-runbook måste anropas från en Azure-avisering.

Enligt beskrivningen i föregående avsnitt har varje typ av avisering ett annat schema. Skriptet tar webhook-data från en avisering i WebhookData indataparametern för runbook. Skriptet utvärderar sedan JSON-nyttolasten för att avgöra vilken aviseringstyp som används.

I det här exemplet används en avisering från en virtuell Azure-dator (VM). Den hämtar vm-data från nyttolasten och använder sedan informationen för att stoppa den virtuella datorn. Anslutningen måste konfigureras i Automation-kontot där runbooken körs. När du använder aviseringar för att utlösa runbooks är det viktigt att kontrollera aviseringsstatusen i den runbook som utlöses. Runbook utlöses varje gång aviseringen ändrar status. Aviseringar har flera tillstånd, där de två vanligaste är Aktiverade och Lösta. Kontrollera statusen i din Runbook-logik för att se till att runbooken inte körs mer än en gång. Exemplet i den här artikeln visar hur du söker efter aviseringar med endast tillståndet Aktiverad.

Runbooken använder den system tilldelade hanterade identiteten för Automation-kontot för att autentisera med Azure för att utföra hanteringsåtgärden mot den virtuella datorn. Runbooken kan enkelt ändras så att den använder en användar tilldelad hanterad identitet.

Använd det här exemplet för att skapa en runbook med namnet Stop-AzureVmInResponsetoVMAlert. Du kan ändra PowerShell-skriptet och använda det med många olika resurser.

1. Logga in på Azure Portaloch gå till ditt Automation-konto.

2. Under Processautomatisering väljer du Runbooks.

3. Välj + Skapa en runbook.

   1. Ge runbooken namnet Stop-AzureVmInResponsetoVMAlert .
   2. Välj PowerShell i listrutan Typ av runbook.
   3. Välj Skapa.

4. Klistra in följande kod i runbook-redigeraren:

   [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. Om du vill att runbooken ska köras med den system tilldelade hanterade identiteten lämnar du koden som den är. Om du föredrar att använda en användar tilldelad hanterad identitet gör du följande:

   1. Från rad 78 tar du bort $AzureContext = (Connect-AzAccount -Identity).context ,
   2. Ersätt den med $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context , och
   3. Ange det klient-ID som du fick tidigare.

6. Välj Spara, Publicera och sedan Ja när du tillfrågas.

7. Stäng runbooksidan för att återgå till sidan Automation-konto.

Skapa aviseringen

Aviseringar använder åtgärdsgrupper, som är samlingar med åtgärder som utlöses av aviseringen. Runbooks är bara en av de många åtgärder som du kan använda med åtgärdsgrupper.

1. I ditt Automation-konto går du till Övervakning och väljer Aviseringar.

2. Välj + Ny aviseringsregel för att öppna sidan Skapa aviseringsregel.

   

3. Under Omfång väljer du Redigera resurs.

4. På sidan Välj en resurs går du till listrutan Filtrera efter resurstyp och väljer Virtuella datorer.

5. Markera kryssrutan bredvid de virtuella datorer som du vill övervaka. Välj sedan Klar för att återgå till sidan Skapa aviseringsregel.

6. Under Villkor väljer du Lägg till villkor.

7. På sidan Välj en signal anger du i Percentage CPU sökrutan och väljer sedan Processorprocentandel i resultatet.

8. På sidan Konfigurera signallogik under Tröskelvärde anger du ett initialt lågt värde i testsyfte, till exempel 5 . Du kan gå tillbaka och uppdatera det här värdet när du har bekräftat att aviseringen fungerar som förväntat. Välj sedan Klar för att återgå till sidan Skapa aviseringsregel.

   

9. Under Åtgärder väljer du Lägg till åtgärdsgrupper och sedan +Skapa åtgärdsgrupp.

   

10. På sidan Skapa åtgärdsgrupp:

    1. På fliken Grundläggande anger du ett namn på åtgärdsgruppen och visningsnamnet.

    2. Ange ett namn i textrutan Namn på fliken Åtgärder. I listrutan Åtgärdstyp väljer du sedan Automation Runbook för att öppna sidan Konfigurera runbook.

       1. För Runbook-källobjektet väljer du Användare.

       2. I listrutan Prenumeration väljer du din prenumeration.

       3. I listrutan Automation-konto väljer du ditt Automation-konto.

       4. I listrutan Runbook väljer du Stop-AzureVmInResponsetoVMAlert.

       5. För objektet Aktivera gemensamt aviseringsschema väljer du Ja.

       6. Välj OK för att återgå till sidan Skapa åtgärdsgrupp.

          

    3. Välj Granska + skapa och sedan Skapa för att återgå till sidan Skapa aviseringsregel.

11. Under Aviseringsregelinformation för textrutan Aviseringsregelnamn.

12. Välj Skapa varningsregel. Du kan använda åtgärdsgruppen i aktivitetsloggaviseringar och aviseringar i nära realtid som du skapar.

Verifiering

Kontrollera att den virtuella datorn körs. Gå till runbooken Stop-AzureVmInResponsetoVMAlert och titta efter listan Senaste jobb att fylla i. När ett slutfört jobb visas väljer du jobbet och granskar utdata. Kontrollera också om den virtuella datorn har stoppats.

Nästa steg

• Om du vill identifiera olika sätt att starta en runbook kan du gå till Starta en runbook.
• Information om hur du skapar en aktivitetsloggavisering finns i Skapa aktivitetsloggaviseringar.
• Information om hur du skapar en avisering nästan i realtid finns i Skapa en aviseringsregel i Azure Portal.