Hantera runbooks i Azure Automation

  • Artikel

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 Gallery. 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-portalen eller PowerShell. När runbooken har skapats kan du redigera den med hjälp av information i:

Skapa en runbook i Azure-portalen

  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 Process Automation för att öppna listan över runbooks.
  5. Klicka på Skapa en runbook.
    1. Ge runbooken namnet.
    2. Från listrutan Runbook-typ. Välj dess typ. Runbook-namnet 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-arbetsflödesrunbook. 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 var och en 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-portalen

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

Kommentar

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

  1. I Azure-portalen 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 Process Automation 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 i listrutan.
  9. Klicka på Importera. Den nya runbook visas i listan med runbooks för automationskontot.
  10. Du måste publicera runbook innan du kan köra det.

Kommentar

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. Följande PowerShell-exempel innehåller den sista 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 dina runbooks som 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 åtgärden som vidtogs. Baserat på resultatet av kontrollen kan logiken 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

# Ranking all the active jobs
$activeJobs = $jobs | where {$_.status -eq 'Running' -or $_.status -eq 'Queued' -or $_.status -eq 'New' -or $_.status -eq 'Activating' -or $_.status -eq 'Resuming'} | Sort-Object -Property CreationTime 
$jobRanking = @() 
$rank = 0 
ForEach($activeJob in $activeJobs) 
{         
    $rank = $rank + 1 
    $activeJob | Add-Member -MemberType NoteProperty -Name jobRanking -Value $rank -Force 
    $jobRanking += $activeJob 
}
    
$AutomationJobId = $PSPrivateMetadata.JobId.Guid 
$currentJob = $activeJobs | where {$_.JobId -eq $AutomationJobId} 
$currentJobRank = $currentJob.jobRanking 

# Only allow the Job with Rank = 1 to start processing. 
If($currentJobRank -ne "1") 
{ 
    Write-Output "$(Get-Date -Format yyyy-MM-dd-hh-mm-ss.ffff) Concurrency check failed as Current Job Ranking is not 1 but $($currentJobRank) therefore exiting..." 
    Exit 
} Else
{
    Write-Output "$(Get-Date -Format yyyy-MM-dd-hh-mm-ss.ffff) Concurrency check passed. Start processing.." 
}

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:t.

Kommentar

För PowerShell 7.2-hybridjobb gör du ändringar på rad 28. Ersätt $PSPrivateMetadata.JobId.Guid med $env:PSPrivateMetaData

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 försöker Azure Automation igen.

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

Kommentar

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

Logik för återförsök i runbook för att undvika tillfälliga fel

Runbooks anropar ofta 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. Om du vill skapa återhämtning i runbooks måste du implementera logik för återförsök 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 REST- och återförsöksriktlinjer.

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 observera 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)

Kommentar

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 i som ett skriptblock som ska köras.

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. 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 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:t.

Arbeta med ett anpassat skript

Kommentar

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 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ömmar 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.

Kommentar

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 mellan att testa med textredigeraren eller 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, så visas de i den vänstra rutan, där du kan ange de värden som ska användas i 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 påbörja 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. Endast den publicerade versionen är tillgänglig för körning och endast utkastversionen kan redigeras. Den publicerade versionen påverkas inte av ändringar i utkastversionen. 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-portalen

  1. I Azure-portalen 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 din runbook har publicerats kan du schemalägga den för åtgärd:

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

Återställa borttagen runbook

Du kan återställa en borttagen runbook via PowerShell-skript. Om du vill återställa en runbook kontrollerar du att följande villkor uppfylls:

  • De runbooks som ska återställas har tagits bort under de senaste 29 dagarna.
  • Automation-kontot för den runbooken finns.
  • Rollbehörigheten Automation-deltagare beviljas till den systemtilldelade hanterade identiteten för Automation-kontot.

PowerShell-skript

  • Kör PowerShell-skriptet som ett jobb i ditt Automation-konto för att återställa de borttagna runbooksna.
  • Ladda ned PowerShell-skriptet från GitHub. Du kan också importera PowerShell-skriptet med namnet Restore Automation runbook från Runbook Gallery. Ange namnet på den runbook som ska återställas och kör den som ett jobb i Azure Automation för att återställa borttagna runbooks.
  • Ladda ned skriptet från GitHub eller importera PowerShell-skriptet med namnet List Deleted Automation Runbook från Runbook Gallery för att identifiera namnen på de runbooks som har tagits bort under de senaste 29 dagarna.

Hämta jobbstatusar

Visa statusar i Azure-portalen

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

Job Statistics tile

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.

Screenshot of the Jobs page.

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

Filter job status

Du kan också visa jobbsammanfattningsinformation för en specifik runbook genom att välja den runbooken från 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.

Screenshot of the Jobs page with the Errors button highlighted.

Hämta jobbstatusar med Hjälp av 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, 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 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