Hantera runbooks i Azure Automation

Du kan lägga till en runbook i Azure Automation genom att antingen skapa en ny eller importera en befintlig från en fil eller Runbook-galleriet. Den här artikeln innehåller information om hur du hanterar en runbook och rekommenderade mönster och metodtips med Runbook-design. Du hittar all information om åtkomst till community-runbooks och moduler i Runbook- och modulgallerier för Azure Automation.

Skapa en runbook

Skapa en ny runbook i Azure Automation med hjälp av Azure Portal eller PowerShell. När runbooken har skapats kan du redigera den med hjälp av information i:

Skapa en runbook i Azure Portal

  1. Logga in på Azure Portal.
  2. Sök efter och välj Automation-konton.
  3. På sidan Automation-konton väljer du ditt Automation-konto i listan.
  4. Från Automation-kontot väljer du Runbooks under Processautomatisering för att öppna listan över runbooks.
  5. Klicka på Skapa en runbook.
    1. Ge runbooken ett namn.
    2. Från listrutan Runbook-typ . Välj dess typ. Runbooknamnet måste börja med en bokstav och kan innehålla bokstäver, siffror, understreck och bindestreck
    3. Välj körningsversion
    4. Ange tillämplig beskrivning
  6. Skapa runbooken genom att klicka på Skapa.

Skapa en runbook med PowerShell

Använd cmdleten New-AzAutomationRunbook för att skapa en tom runbook. Använd parametern Type för att ange en av de runbook-typer som definierats för New-AzAutomationRunbook.

I följande exempel visas hur du skapar en ny tom runbook.

$params = @{
    AutomationAccountName = 'MyAutomationAccount'
    Name                  = 'NewRunbook'
    ResourceGroupName     = 'MyResourceGroup'
    Type                  = 'PowerShell'
}
New-AzAutomationRunbook @params

Importera en runbook

Du kan importera ett PowerShell- eller PowerShell-arbetsflödesskript (.ps1), en grafisk runbook (.graphrunbook) eller ett Python 2- eller Python 3-skript (.py) för att skapa en egen runbook. Du anger vilken typ av runbook som skapas under importen, med hänsyn till följande överväganden.

  • Du kan importera en .ps1 fil som inte innehåller ett arbetsflöde till antingen en PowerShell-runbook eller en PowerShell Workflow-runbook. Om du importerar den till en PowerShell Workflow-runbook konverteras den till ett arbetsflöde. I det här fallet inkluderas kommentarer i runbooken för att beskriva de ändringar som gjorts.

  • Du kan bara importera en .ps1 fil som innehåller ett PowerShell-arbetsflöde till en PowerShell Workflow-runbook. Om filen innehåller flera PowerShell-arbetsflöden misslyckas importen. Du måste spara varje arbetsflöde i en egen fil och importera vart och ett separat.

  • Importera inte en .ps1 fil som innehåller ett PowerShell-arbetsflöde till en PowerShell-runbook, eftersom PowerShell-skriptmotorn inte kan identifiera den.

  • Importera endast en .graphrunbook-fil till en ny grafisk runbook.

Importera en runbook från Azure Portal

Du kan använda följande procedur för att importera en skriptfil till Azure Automation.

Anteckning

Du kan bara importera en .ps1 fil till en PowerShell Workflow-runbook med hjälp av portalen.

  1. I Azure Portal söker du efter och väljer Automation-konton.
  2. På sidan Automation-konton väljer du ditt Automation-konto i listan.
  3. Från Automation-kontot väljer du Runbooks under Processautomatisering för att öppna listan över runbooks.
  4. Klicka på Importera en runbook. Du kan välja något av följande alternativ:
    1. Bläddra efter fil – väljer en fil från den lokala datorn.
    2. Bläddra från galleriet – Du kan bläddra och välja en befintlig runbook från galleriet.
  5. Välj filen.
  6. Om fältet Namn är aktiverat kan du ändra runbook-namnet. Namnet måste börja med en bokstav och kan innehålla bokstäver, siffror, understreck och bindestreck.
  7. Runbook-typen fylls i automatiskt, men du kan ändra typen när du har tagit hänsyn till tillämpliga begränsningar.
  8. Körningsversionen fylls antingen i automatiskt eller väljer versionen från listrutan.
  9. Klicka på Importera. Den nya runbooken visas i listan över runbooks för Automation-kontot.
  10. Du måste publicera runbooken innan du kan köra den.

Anteckning

När du har importerat en grafisk runbook kan du konvertera den till en annan typ. Du kan dock inte konvertera en grafisk runbook till en text runbook.

Importera en runbook med PowerShell

Använd cmdleten Import-AzAutomationRunbook för att importera en skriptfil som en utkast-runbook. Om runbooken redan finns misslyckas importen om du inte använder parametern Force med cmdleten .

I följande exempel visas hur du importerar en skriptfil till en runbook.

$params = @{
    AutomationAccountName = 'MyAutomationAccount'
    Name                  = 'Sample_TestRunbook'
    ResourceGroupName     = 'MyResourceGroup'
    Type                  = 'PowerShell'
    Path                  = 'C:\Runbooks\Sample_TestRunbook.ps1'
}
Import-AzAutomationRunbook @params

Hantera resurser

Om din runbook skapar en resurs bör skriptet kontrollera om resursen redan finns innan du försöker skapa den. Här är ett grundläggande exempel.

$vmName = 'WindowsVM1'
$rgName = 'MyResourceGroup'
$myCred = Get-AutomationPSCredential 'MyCredential'

$vmExists = Get-AzResource -Name $vmName -ResourceGroupName $rgName
if (-not $vmExists) {
    Write-Output "VM $vmName does not exist, creating"
    New-AzVM -Name $vmName -ResourceGroupName $rgName -Credential $myCred
} else {
    Write-Output "VM $vmName already exists, skipping"
}

Hämta information från aktivitetsloggen

Du kan hämta runbook-information, till exempel den person eller det konto som startade en runbook, från aktivitetsloggen för Automation-kontot. I följande PowerShell-exempel visas den senaste användaren som körde den angivna runbooken.

$rgName = 'MyResourceGroup'
$accountName = 'MyAutomationAccount'
$runbookName = 'MyRunbook'
$startTime = (Get-Date).AddDays(-1)

$params = @{
    ResourceGroupName = $rgName
    StartTime         = $startTime
}
$JobActivityLogs = (Get-AzLog @params).Where( { $_.Authorization.Action -eq 'Microsoft.Automation/automationAccounts/jobs/write' })

$JobInfo = @{}
foreach ($log in $JobActivityLogs) {
    # Get job resource
    $JobResource = Get-AzResource -ResourceId $log.ResourceId

    if ($null -eq $JobInfo[$log.SubmissionTimestamp] -and $JobResource.Properties.Runbook.Name -eq $runbookName) {
        # Get runbook
        $jobParams = @{
            ResourceGroupName     = $rgName
            AutomationAccountName = $accountName
            Id                    = $JobResource.Properties.JobId
        }
        $Runbook = Get-AzAutomationJob @jobParams | Where-Object RunbookName -EQ $runbookName

        # Add job information to hashtable
        $JobInfo.Add($log.SubmissionTimestamp, @($Runbook.RunbookName, $Log.Caller, $JobResource.Properties.jobId))
    }
}
$JobInfo.GetEnumerator() | Sort-Object Key -Descending | Select-Object -First 1

Spåra förlopp

Det är en bra idé att skapa runbooks som är modulära till sin natur, med logik som enkelt kan återanvändas och startas om. Spårning av förloppet i en runbook säkerställer att Runbook-logiken körs korrekt om det uppstår problem.

Du kan spåra förloppet för en runbook med hjälp av en extern källa, till exempel ett lagringskonto, en databas eller delade filer. Skapa logik i din runbook för att först kontrollera tillståndet för den senaste åtgärden som vidtogs. Baserat på resultatet av kontrollen kan logiken sedan antingen hoppa över eller fortsätta specifika uppgifter i runbooken.

Förhindra samtidiga jobb

Vissa runbooks beter sig konstigt om de körs över flera jobb samtidigt. I det här fallet är det viktigt att en runbook implementerar logik för att avgöra om det redan finns ett jobb som körs. Här är ett grundläggande exempel.

# 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

# Check for already running or new runbooks
$runbookName = "runbookName"
$resourceGroupName = "resourceGroupName"
$automationAccountName = "automationAccountName"

$jobs = Get-AzAutomationJob -ResourceGroupName $resourceGroupName `
    -AutomationAccountName $automationAccountName `
    -RunbookName $runbookName `
    -DefaultProfile $AzureContext

# Check to see if it is already running
$runningCount = ($jobs.Where( { $_.Status -eq 'Running' })).count

if (($jobs.Status -contains 'Running' -and $runningCount -gt 1 ) -or ($jobs.Status -eq 'New')) {
    # Exit code
    Write-Output "Runbook $runbookName is already running"
    exit 1
} else {
    # Insert Your code here
    Write-Output "Runbook $runbookName is not running"
}

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 5 tar du bort $AzureContext = (Connect-AzAccount -Identity).context,
  2. Ersätt den med $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context, och
  3. Ange klient-ID.

Hantera tillfälliga fel i ett tidsberoende skript

Dina runbooks måste vara robusta och kunna hantera fel, inklusive tillfälliga fel som kan orsaka att de startas om eller misslyckas. Om en runbook misslyckas Azure Automation försöker igen.

Om din runbook normalt körs inom en tidsbegränsning måste skriptet implementera logik för att kontrollera körningstiden. Den här kontrollen säkerställer att åtgärder som start, avstängning eller utskalning endast körs under specifika tider.

Anteckning

Den lokala tiden i Sandbox-processen i Azure är inställd på UTC. Beräkningar för datum och tid i dina runbooks måste ta hänsyn till detta.

Omprövningslogik i runbook för att undvika tillfälliga fel

Runbooks gör ofta anrop till fjärrsystem som Azure via ARM, Azure Resource Graph, SQL-tjänster och andra webbtjänster. När systemet som runbooks anropar är upptaget, tillfälligt otillgängligt eller implementerar begränsning under belastning är anropen sårbara för körningsfel. För att skapa återhämtning i runbooks måste du implementera omprövningslogik när du gör anropen så att runbooks kan hantera ett tillfälligt problem utan att misslyckas.

Mer information finns i Återförsöksmönster och Allmänna RIKTLINJER för REST och återförsök.

Exempel 1: Om din runbook bara gör ett eller två anrop

$searchServiceURL = "https://$searchServiceName.search.windows.net"
$resource = Get-AzureRmResource -ResourceType "Microsoft.Search/searchServices" -ResourceGroupName $searchResourceGroupName -ResourceName  $searchServiceName -ApiVersion 2015-08-19
$searchAPIKey = (Invoke-AzureRmResourceAction -Action listAdminKeys -ResourceId $resource.ResourceId -ApiVersion 2015-08-19 -Force).PrimaryKey

När du anropar Invoke-AzureRmResourceActionkan du se tillfälliga fel. I ett sådant scenario rekommenderar vi att du implementerar följande grundläggande mönster runt anropet till cmdleten.

$searchServiceURL = "https://$searchServiceName.search.windows.net"
$resource = Get-AzureRmResource -ResourceType "Microsoft.Search/searchServices" -ResourceGroupName $searchResourceGroupName -ResourceName  $searchServiceName -ApiVersion 2015-08-19

    # Adding in a retry
    $Stoploop = $false
    $Retrycount = 0
 
    do {
        try   {
               $searchAPIKey = (Invoke-AzureRmResourceAction -Action listAdminKeys -ResourceId $resource.ResourceId -ApiVersion 2015-08-19 -Force).PrimaryKey
               write-verbose "Invoke-AzureRmResourceAction on $resource.ResourceId completed"
               $Stoploop = $true
              }
        catch {
               if ($Retrycount -gt 3)
                 {
                  Write-verbose "Could not Invoke-AzureRmResourceAction on $resource.ResourceId after 3 retrys."
                  $Stoploop = $true
                 }
               else  
                 {
                  Write-verbose "Could not Invoke-AzureRmResourceAction on $resource.ResourceId retrying in 30 seconds..."
                  Start-Sleep -Seconds 30
                  $Retrycount = $Retrycount + 1
                 }
               }
        }
    While ($Stoploop -eq $false)

Anteckning

Försöket att försöka anropa igen är upp till tre gånger i viloläge i 30 sekunder varje gång.

Exempel 2: Om runbooken gör frekventa fjärranrop

Om runbooken gör frekventa fjärranrop kan det uppstå tillfälliga körningsproblem. Skapa en funktion som implementerar logiken för återförsök för varje anrop som görs och skicka det anrop som ska göras som ett skriptblock att köra.

Function ResilientRemoteCall {

         param(
               $scriptblock
               )
        
         $Stoploop = $false
         $Retrycount = 0
 
         do {
             try   {
                    Invoke-Command -scriptblock $scriptblock 
                    write-verbose "Invoked $scriptblock completed"
                    $Stoploop = $true
                   }
             catch {
                    if ($Retrycount -gt 3)
                      {
                       Write-verbose "Invoked $scriptblock failed 3 times and we will not try again."
                       $Stoploop = $true
                      }
                    else  
                      {
                       Write-verbose "Invoked $scriptblock failed  retrying in 30 seconds..."
                       Start-Sleep -Seconds 30
                       $Retrycount = $Retrycount + 1
                      }
                    }
             }
         While ($Stoploop -eq $false)
}

Du kan sedan skicka varje fjärranrop till funktionen som

ResilientRemoteCall { Get-AzVm }
Eller

ResilientRemoteCall { $searchAPIKey = (Invoke-AzureRmResourceAction -Action listAdminKeys -ResourceId $resource.ResourceId -ApiVersion 2015-08-19 -Force).PrimaryKey}

Arbeta med flera prenumerationer

Din runbook måste kunna fungera med prenumerationer. Om du till exempel vill hantera flera prenumerationer använder runbooken cmdleten Disable-AzContextAutosave . Den här cmdleten säkerställer att autentiseringskontexten inte hämtas från en annan runbook som körs i samma sandbox-miljö.

# 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

$childRunbookName = 'childRunbookDemo'
$resourceGroupName = "resourceGroupName"
$automationAccountName = "automationAccountName"

$startParams = @{
    ResourceGroupName     = $resourceGroupName
    AutomationAccountName = $automationAccountName
    Name                  = $childRunbookName
    DefaultProfile        = $AzureContext
}
Start-AzAutomationRunbook @startParams

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 5 tar du bort $AzureContext = (Connect-AzAccount -Identity).context,
  2. Ersätt den med $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context, och
  3. Ange klient-ID.

Arbeta med ett anpassat skript

Anteckning

Du kan normalt inte köra anpassade skript och runbooks på värden med en Log Analytics-agent installerad.

Så här använder du ett anpassat skript:

  1. Skapa ett Automation-konto.
  2. Distribuera rollen Hybrid Runbook Worker .
  3. Om du är på en Linux-dator behöver du utökade privilegier. Logga in för att inaktivera signaturkontroller.

Testa en Runbook

När du testar en runbook körs utkastversionen och alla åtgärder som utförs slutförs. Ingen jobbhistorik skapas, men utdata - och varnings- och felströmmarna visas i fönstret Testa utdata . Meddelanden till den utförliga strömmen visas endast i fönstret Utdata om variabeln VerbosePreference är inställd på Continue.

Även om utkastversionen körs körs runbooken fortfarande normalt och utför alla åtgärder mot resurser i miljön. Därför bör du bara testa runbooks på icke-produktionsresurser.

Anteckning

Alla runbook-körningsåtgärder loggas i aktivitetsloggen för automationskontot med åtgärdsnamnet Skapa ett Azure Automation jobb. Runbook-körning i ett testfönster där utkastversionen av runbooken körs loggas dock i aktivitetsloggarna med åtgärdsnamnet Skriv ett Azure Automation runbook-utkast. Välj fliken Åtgärd och JSON för att se omfånget som slutar med .. /runbooks/(runbook name)/draft/testjob.

Proceduren för att testa varje typ av runbook är densamma. Det är ingen skillnad i testning mellan textredigeraren och den grafiska redigeraren i Azure Portal.

  1. Öppna utkastversionen av runbooken i antingen textredigeraren eller den grafiska redigeraren.
  2. Klicka på Test för att öppna sidan Test .
  3. Om runbooken har parametrar visas de i den vänstra rutan, där du kan ange värden som ska användas för testet.
  4. Om du vill köra testet på en Hybrid Runbook Worker ändrar du Kör inställningar till Hybrid Worker och väljer namnet på målgruppen. Annars behåller du Standard Azure för att köra testet i molnet.
  5. Klicka på Starta för att starta testet.
  6. Du kan använda knapparna under fönstret Utdata för att stoppa eller pausa ett PowerShell-arbetsflöde eller en grafisk runbook när den testas. När du pausar runbooken slutförs den aktuella aktiviteten innan den pausas. När runbooken har pausats kan du stoppa den eller starta om den.
  7. Granska utdata från runbooken i fönstret Utdata .

Publicera en runbook

När du skapar eller importerar en ny runbook måste du publicera den innan du kan köra den. Varje runbook i Azure Automation har en utkastversion och en publicerad version. Det är bara den Publicerade versionen som kan köras och bara Utkastet som kan redigeras. Den Publicerade versionen påverkas inte av ändringar i Utkastet. När utkastversionen ska göras tillgänglig publicerar du den och skriver över den aktuella publicerade versionen med utkastversionen.

Publicera en runbook i Azure Portal

  1. I Azure Portal söker du efter och väljer Automation-konton.
  2. På sidan Automation-konton väljer du ditt Automation-konto i listan.
  3. Öppna runbooken i ditt Automation-konto.
  4. Klicka på Redigera.
  5. Klicka på Publicera och välj sedan Ja som svar på verifieringsmeddelandet.

Publicera en runbook med PowerShell

Använd cmdleten Publish-AzAutomationRunbook för att publicera din runbook.

$accountName = "MyAutomationAccount"
$runbookName = "Sample_TestRunbook"
$rgName = "MyResourceGroup"

$publishParams = @{
    AutomationAccountName = $accountName
    ResourceGroupName     = $rgName
    Name                  = $runbookName
}
Publish-AzAutomationRunbook @publishParams

Schemalägg en runbook i Azure Portal

När runbooken har publicerats kan du schemalägga den för åtgärd:

  1. I Azure Portal söker du efter och väljer Automation-konton.
  2. På sidan Automation-konton väljer du ditt Automation-konto i listan.
  3. Välj runbooken i din lista över runbooks.
  4. Välj Scheman under Resurser.
  5. Välj Lägg till ett schema.
  6. I fönstret Schemalägg Runbook väljer du Länka ett schema till din runbook.
  7. Välj Skapa ett nytt schema i fönstret Schema .
  8. Ange ett namn, en beskrivning och andra parametrar i fönstret Nytt schema .
  9. När schemat har skapats markerar du det och klickar på OK. Den bör nu länkas till din runbook.
  10. Leta efter ett e-postmeddelande i postlådan för att meddela dig om runbook-statusen.

Hämta jobbstatus

Visa statusar i Azure Portal

Information om jobbhantering i Azure Automation finns i Jobb. När du är redo att se dina runbook-jobb kan du använda Azure Portal och komma åt ditt Automation-konto. Till höger kan du se en sammanfattning av alla runbook-jobb i Jobbstatistik.

Panelen Jobbstatistik

Sammanfattningen visar ett antal och en grafisk representation av jobbstatusen för varje jobb som körs.

När du klickar på panelen visas sidan Jobb, som innehåller en sammanfattad lista över alla jobb som körs. Den här sidan visar status, runbooknamn, starttid och slutförandetid för varje jobb.

Skärmbild av sidan Jobb.

Du kan filtrera listan med jobb genom att välja Filterjobb. Filtrera på en specifik runbook, jobbstatus eller ett val från listrutan och ange tidsintervallet för sökningen.

Filtrera jobbstatus

Du kan också visa jobbsammanfattningsinformation för en specifik runbook genom att välja den runbooken på sidan Runbooks i ditt Automation-konto och sedan välja Jobb. Den här åtgärden visar sidan Jobb. Härifrån kan du klicka på en jobbpost för att visa dess information och utdata.

Skärmbild av sidan Jobb med knappen Fel markerad.

Hämta jobbstatusar med PowerShell

Använd cmdleten Get-AzAutomationJob för att hämta jobben som skapats för en runbook och information om ett visst jobb. Om du startar en runbook med returnerar Start-AzAutomationRunbookden det resulterande jobbet. Använd Get-AzAutomationJobOutput för att hämta jobbutdata.

I följande exempel hämtas det sista jobbet för en exempel-runbook och dess status visas, värdena för runbookparametrarna och jobbutdata.

$getJobParams = @{
    AutomationAccountName = 'MyAutomationAccount'
    ResourceGroupName     = 'MyResourceGroup'
    Runbookname           = 'Test-Runbook'
}
$job = (Get-AzAutomationJob @getJobParams | Sort-Object LastModifiedDate -Desc)[0]
$job | Select-Object JobId, Status, JobParameters

$getOutputParams = @{
    AutomationAccountName = 'MyAutomationAccount'
    ResourceGroupName     = 'MyResourceGroup'
    Id                    = $job.JobId
    Stream                = 'Output'
}
Get-AzAutomationJobOutput @getOutputParams

I följande exempel hämtas utdata för ett visst jobb och varje post returneras. Om det finns ett undantag för en av posterna skriver skriptet undantaget i stället för värdet. Det här beteendet är användbart eftersom undantag kan ge ytterligare information som kanske inte loggas normalt under utdata.

$params = @{
    AutomationAccountName = 'MyAutomationAccount'
    ResourceGroupName     = 'MyResourceGroup'
    Stream                = 'Any'
}
$output = Get-AzAutomationJobOutput @params

foreach ($item in $output) {
    $jobOutParams = @{
        AutomationAccountName = 'MyAutomationAccount'
        ResourceGroupName     = 'MyResourceGroup'
        Id                    = $item.StreamRecordId
    }
    $fullRecord = Get-AzAutomationJobOutputRecord @jobOutParams

    if ($fullRecord.Type -eq 'Error') {
        $fullRecord.Value.Exception
    } else {
        $fullRecord.Value
    }
}

Nästa steg