Hantera runbooks i Azure Automation

Du kan lägga till en runbook 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 att komma åt 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 informationen i:

• Redigera text-runbook i Azure Automation
• Lär dig viktiga powershell-arbetsflödesbegrepp för Automation-runbooks
• Hantera Python 2-paket i Azure Automation
• Hantera Python 3-paket (förhandsversion) i Azure Automation

Skapa en runbook i Azure Portal

1. Logga in på Azure-portalen.
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. I listrutan Runbook-typ. Välj dess typ. Runbook-namnet måste börja med en bokstav och får innehålla bokstäver, siffror, understreck och bindestreck
   3. Välj körningsversion
   4. Ange en 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 Type parametern 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 Workflow-skript (.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 som inte innehåller något 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 ingår kommentarer i runbooken för att beskriva de ändringar som gjorts.

• Du kan bara importera en .ps1som 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 dem separat.

• Importera inte en .ps1som innehåller ett PowerShell-arbetsflöde till en PowerShell-runbookeftersom 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.

1. I Azure Portal 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 galleri – 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 runbookens namn. Namnet måste börja med en bokstav och får 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 i 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.

Importera en runbook med PowerShell

Använd cmdleten Import-AzAutomationRunbook för att importera en skriptfil som ett utkast till en runbook. Om runbooken redan finns misslyckas importen såvida du inte använder Force parametern 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 enresurs 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ör 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 dina runbooks så att de är modulära till sin natur, med logik som enkelt kan återanvändas och startas om. Genom att spåra förloppet i en runbook ser du till att runbook-logiken körs korrekt om det finns 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 vidtagna åtgärden. Baserat på resultatet av kontrollen kan logiken antingen hoppa över eller fortsätta med 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 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 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 göra att de startas om eller misslyckas. Om en runbook misslyckas Azure Automation försöker den på nytt.

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.

Arbeta med flera prenumerationer

Din runbook måste kunna arbeta med prenumerationer. För att till exempel 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 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 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

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

1. Skapa ett Automation-konto.
2. Distribuera Hybrid Runbook Worker rollen.
3. Om du använder 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 den utför slutförs. Ingen jobbhistorik skapas, men utdata- och varnings- och felströmmarna visas i fönstret Testa utdata. Meddelanden till den utförliga dataströmmen visas bara i fönstret Utdata om variabeln VerbosePreference har angetts till 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.

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

1. Öppna Utkastversionen av runbooken i textredigeraren eller i den grafiska redigeraren.
2. Klicka på Test för att öppna testsidan.
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 medan 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 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 din runbook har publicerats kan du schemalägga den för drift:

1. I Azure Portal 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 listan ö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 vara länkad till din runbook.
10. Leta efter ett e-postmeddelande i postlådan för att meddela dig om runbook-statusen.

Hämta jobbstatusar

Visa statusar i Azure Portal

Information om jobbhantering i Azure Automation finns i Jobb. När du är redo att se dina Runbook-jobb använder du Azure Portal och får åtkomst till ditt Automation-konto. Till höger kan du se en sammanfattning av alla Runbook-jobb i Jobbstatistik.

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

Om 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.

Du kan filtrera listan över jobb genom att välja Filtrera jobb. Filtrera på en specifik runbook, jobbstatus eller ett val i listrutan och ange ett intervall för sökningen.

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 information och utdata.

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 Start-AzAutomationRunbook , returneras det resulterande jobbet. Använd Get-AzAutomationJobOutput för att hämta jobbutdata.

I följande exempel hämtar det sista jobbet för en exempel-runbook och visar dess status, de värden som anges för runbook-parametrarna 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 specifikt jobb och returnerar varje post. 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

• Mer information om runbookhantering finns i Runbook-körning i Azure Automation.
• Information om hur du förbereder en PowerShell-runbook finns i Redigera textbaserade runbooks i Azure Automation.
• Information om hur du felsöker problem med runbook-körning finns i Felsöka runbook-problem.