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ändartilldelad hanterad identitet. Mer information finns i Använda en användartilldelad hanterad identitet för ett Azure Automation-konto.
• Az-moduler: Az.Accounts och Az.Compute importeras 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.
• En allmän förtrogenhet med Automation-runbooks.

Aviseringstyper

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

• Vanliga aviseringar
• Aktivitetsloggaviseringar
• Måttaviseringar nära 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 systemtilldelade hanterade identitet eller en användartilldelad hanterad identitet. Steg tillhandahålls för att tilldela behörigheter till varje identitet. Stegen nedan använder PowerShell. Om du föredrar att använda portalen kan du läsa Tilldela Azure-roller med hjälp av Azure Portal.

1. Logga in på Azure interaktivt med hjälp av cmdleten Connect-AzAccount och följ anvisningarna.

   # 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ändartilldelad hanterad identitet.

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

5. För den systemtilldelade 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 webhooksdata från en avisering i runbook-indataparametern WebhookData . Sedan utvärderar skriptet 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 extraherar vm-data från nyttolasten, särskilt från målresursen för den utlösta aviseringen, och använder sedan den informationen för att stoppa den virtuella datorn. Anslutningen måste konfigureras i automationskontot där runbooken körs. När du använder aviseringar för att utlösa runbooks är det viktigt att kontrollera aviseringsstatusen i runbooken som utlöses. Runbooken utlöses varje gång aviseringen ändras. Aviseringar har flera tillstånd, där de två vanligaste är Aktiverade och Lösta. Kontrollera om det finns tillstånd i runbook-logiken 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 tillståndet Aktiverad.

Runbooken använder den systemtilldelade 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 för att använda en användartilldelad hanterad identitet.

Använd det här exemplet om du vill 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 Portal och gå till ditt Automation-konto.

2. Under Processautomatisering väljer du Runbooks.

3. Välj + Skapa en runbook.

   1. Ge runbooken Stop-AzureVmInResponsetoVMAlertnamnet .
   2. I listrutan Runbook-typ väljer du PowerShell.
   3. Välj Skapa.

4. I Runbook-redigeraren klistrar du in följande kod:

   [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 systemtilldelade hanterade identiteten lämnar du koden som den är. Om du föredrar att använda en användartilldelad hanterad identitet:

   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 hämtade tidigare.

6. Välj Spara, Publicera och sedan Ja när du uppmanas att göra det.

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

Skapa aviseringen

Aviseringar använder åtgärdsgrupper, som är samlingar av å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 Percentage CPU i söktextrutan och väljer sedan Procent cpu från resultaten.

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 åtgärdsgruppnamn och visningsnamn.

    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 det vanliga aviseringsschemat 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 Information om aviseringsregeln för textrutan Aviseringsregelnamn .

12. Välj Skapa aviseringsregel. Du kan använda åtgärdsgruppen i aktivitetsloggaviseringar och nästan realtidsaviseringar som du skapar.

Verifiering

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

Vanliga hanteringsåtgärder för virtuella Azure-datorer

Azure Automation tillhandahåller skript för vanliga hanteringsåtgärder för virtuella Azure-datorer som omstart av virtuell dator, stoppa virtuell dator, ta bort virtuell dator, skala upp och ned scenarier i Runbook-galleriet. Skripten finns också på Azure Automation GitHub-lagringsplatsen Du kan också använda dessa skript enligt ovanstående steg.

Nästa steg

• Läs mer om hur du skapar budget och associerar den med Automation Runbook.
• Upptäck olika sätt att starta en runbook i Starta en runbook.
• Skapa en aktivitetsloggavisering, se Skapa aktivitetsloggaviseringar.
• Lär dig hur du skapar en nästan realtidsavisering i Skapa en aviseringsregel i Azure Portal.