Verwalten von Runbooks in Azure Automation

Sie können Azure Automation ein Runbook hinzufügen, indem Sie entweder ein neues Runbook erstellen oder ein vorhandenes Runbook aus einer Datei oder aus dem Runbookkatalog importieren. Dieser Artikel enthält Informationen zum Verwalten eines Runbooks sowie empfohlene Muster und bewährte Methoden für den Runbookentwurf. Einzelheiten zum Zugreifen auf Communityrunbooks und -module finden Sie in Runbook- und Modulkataloge für Azure Automation.

Erstellen eines Runbooks

Erstellen Sie ein neues Runbook in Azure Automation über das Azure-Portal oder die PowerShell. Nachdem das Runbook erstellt wurde, können Sie es mithilfe der folgenden Informationen bearbeiten:

• Bearbeiten von Textrunbooks in Azure Automation
• Grundlagen der wichtigsten PowerShell-Workflowkonzepte für Automation-Runbooks
• Verwalten von Python 2-Paketen in Azure Automation
• Verwalten von Python 3-Paketen (Vorschau) in Azure Automation

Erstellen eines Runbooks im Azure-Portal

1. Melden Sie sich beim Azure-Portal an.
2. Suchen Sie nach Automation-Konten, und wählen Sie diese Option aus.
3. Wählen Sie auf der Seite Automation-Konten in der entsprechenden Liste Ihr Automation-Konto aus.
4. Wählen Sie im Automation-Konto unterProzessautomatisierung die Option Runbooks aus, um die Liste der Runbooks zu öffnen.
5. Klicken Sie auf Runbook erstellen.
   1. Benennen Sie das Runbook.
   2. In der Dropdownliste Runbooktyp: Wählen Sie den Typ aus. Der Name des Runbooks muss mit einem Buchstaben beginnen und darf Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten.
   3. Wählen Sie die Runtimeversion aus.
   4. Geben Sie eine anwendbare Beschreibung ein.
6. Klicken Sie auf Erstellen, um das Runbook zu erstellen.

Erstellen eines Runbooks mit PowerShell

Verwenden Sie das Cmdlet New-AzAutomationRunbook, um ein leeres Runbook zu erstellen. Verwenden Sie den Parameter Type, um einen der für New-AzAutomationRunbook definierten Runbooktypen anzugeben.

Das folgenden Beispiel zeigt, wie Sie ein neues leeres Runbook erstellen.

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

Importieren eines Runbooks

Sie können ein PowerShell- oder PowerShell-Workflowskript (.ps1), ein grafisches Runbook (.graphrunbook) oder ein Python 2- oder Python 3-Skript (.py) importieren, um ein eigenes Runbook zu erstellen. Geben Sie den Runbook-Typ an, der beim Import erstellt wird. Berücksichtigen Sie dabei die folgenden Aspekte.

• Eine .ps1-Datei ohne Workflow kann in ein PowerShell-Runbook oder PowerShell-Workflow-Runbook importiert werden. Wenn Sie sie in ein PowerShell-Workflow-Runbook importieren, wird sie in einen Workflow konvertiert. In diesem Fall sind im Runbook Kommentare enthalten, um die vorgenommenen Änderungen zu beschreiben.

• Eine .ps1-Datei mit einem PowerShell-Workflow kann nur in ein PowerShell-Workflow-Runbook importiert werden. Wenn die Datei mehrere PowerShell-Workflows enthält, schlägt der Import fehl. Sie müssen jeden Workflow in einer eigenen Datei speichern und einzeln importieren.

• Eine .ps1-Datei mit einem PowerShell-Workflow darf nicht in ein PowerShell-Runbook importiert werden, da sie von der PowerShell-Skript-Engine nicht erkannt werden kann.

• Importieren Sie eine .graphrunbook-Datei nur in ein neues grafisches Runbook.

Importieren eines Runbooks im Azure-Portal

Mit dem folgenden Verfahren können eine Skriptdatei in Azure Automation importieren.

1. Suchen Sie im Azure-Portal nach Automation-Konten und wählen Sie diese Option aus.
2. Wählen Sie auf der Seite Automation-Konten in der entsprechenden Liste Ihr Automation-Konto aus.
3. Wählen Sie im Automation-Konto unterProzessautomatisierung die Option Runbooks aus, um die Liste der Runbooks zu öffnen.
4. Klicken Sie auf Runbook importieren. Sie können eine der folgenden Optionen auswählen:
   1. Nach Datei suchen: Wählt eine Datei auf Ihrem lokalen Computer aus.
   2. Aus Katalog durchsuchen: Sie können ein vorhandenes Runbook im Katalog suchen und auswählen.
5. Wählen Sie die Datei aus.
6. Wenn das Feld Name aktiviert ist, haben Sie die Möglichkeit, den Namen des Runbooks zu ändern. Der Name muss mit einem Buchstaben beginnen und darf Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten.
7. Der Runbooktyp wird automatisch ausgefüllt, Sie können den Typ jedoch unter Berücksichtigung der geltenden Einschränkungen ändern.
8. Die Runtimeversion wird entweder automatisch ausgefüllt, oder Sie wählen die Version aus der Dropdownliste aus.
9. Klicken Sie auf Importieren. Das neue Runbook wird in der Liste der Runbooks für das Automation-Konto angezeigt.
10. Sie müssen das Runbook veröffentlichen, bevor Sie es ausführen können.

Importieren eines Runbooks mit PowerShell

Verwenden Sie das Cmdlet Import-AzAutomationRunbook, um eine Skriptdatei als Entwurf eines Runbooks zu importieren. Wenn das Runbook bereits vorhanden ist, tritt beim Import ein Fehler auf, sofern Sie nicht den Parameter Force mit dem Cmdlet verwenden.

Das folgende Beispiel zeigt, wie Sie eine Skriptdatei in ein Runbook importieren.

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

Behandeln von Ressourcen

Wenn Ihr Runbook eine Ressource erstellt, sollte das Skript prüfen, ob die Ressource bereits vorhanden ist, bevor versucht wird, sie erneut zu erstellen. Hier ist ein einfaches Beispiel.

$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"
}

Abrufen von Details aus dem Aktivitätsprotokoll

Sie können aus dem Aktivitätsprotokoll des Automation-Kontos Runbookdetails abrufen, z. B. die Person oder das Konto, die bzw. das das Runbook gestartet hat. Das folgende PowerShell-Beispiel gibt den letzten Benutzer an, der das angegebene Runbook ausgeführt hat.

$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

Nachverfolgen des Status

Es empfiehlt sich, Runbooks so zu schreiben, dass sie modular aufgebaut sind und eine Logik aufweisen, die problemlos wiederverwendet und neu gestartet werden kann. Über die Nachverfolgung des Verlaufs in einem Runbook können Sie sicherstellen, dass die Runbooklogik ordnungsgemäß ausgeführt wird, falls Probleme auftreten.

Sie können den Fortschritt eines Runbooks mithilfe einer externen Quelle verfolgen, wie z. B. einem Speicherkonto, einer Datenbank oder gemeinsam genutzten Dateien. Erstellen Sie die Logik in Ihrem Runbook, um zunächst den Zustand der letzten Aktion zu überprüfen. Dann kann die Logik auf Grundlage der Ergebnisse der Überprüfung bestimmte Aufgaben im Runbook entweder überspringen oder fortsetzen.

Gleichzeitige Aufträge verhindern

Einige Runbooks verhalten sich möglicherweise merkwürdig, wenn sie in mehreren Aufträgen gleichzeitig ausgeführt werden. In diesem Fall ist es wichtig, dass ein Runbook Logik implementiert, um festzustellen, ob bereits ein laufender Auftrag vorhanden ist. Hier ist ein einfaches Beispiel.

# 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.." 
} 

Wenn Sie möchten, dass das Runbook mit der systemseitig zugewiesenen verwalteten Identität ausgeführt wird, lassen Sie den Code unverändert. Wenn Sie lieber eine benutzerseitig zugewiesene verwaltete Identität verwenden möchten, gehen Sie wie folgt vor:

1. Entfernen Sie $AzureContext = (Connect-AzAccount -Identity).context aus Zeile 5.
2. Fügen Sie stattdessen $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context ein.
3. Geben Sie die Client-ID ein.

Behandeln vorübergehender Fehler in einem zeitabhängigen Skript

Ihre Runbooks müssen zuverlässig sein und mit Fehlern – einschließlich vorübergehenden – umgehen können, die zu einem Neustart oder Ausfall führen können. Wenn ein Runbook ausfällt, versucht Azure Automation die erneute Ausführung.

Wenn Ihr Runbook normalerweise innerhalb einer bestimmten Zeitspanne ausgeführt wird, lassen Sie die Implementierungslogik des Skripts die Ausführungszeit überprüfen. Diese Überprüfung stellt sicher, dass Vorgänge wie Starten, Herunterfahren oder Aufskalieren nur zu bestimmten Zeiten erfolgen.

Wiederholungslogik in einem Runbook zum Vermeiden vorübergehender Fehler

Runbooks senden häufig Aufrufe über ARM, Azure Resource Graph, SQL-Dienste und andere Webdienste an Remotesysteme wie Azure. Wenn das System, das die Runbooks aufrufen, ausgelastet bzw. vorübergehend nicht verfügbar ist oder die Drosselung unter Last implementiert, sind die Aufrufe anfällig für Laufzeitfehler. Um für Resilienz in den Runbooks zu sorgen, müssen Sie beim Ausführen der Aufrufe eine Wiederholungslogik implementieren, damit die Runbooks ein vorübergehendes Problem ohne Fehler bewältigen können.

Weitere Informationen finden Sie unter Wiederholungsmuster und Allgemeine REST- und Wiederholungsrichtlinien.

Beispiel 1: Wenn Ihr Runbook nur ein oder zwei Aufrufe ausführt

$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

Wenn Sie Invoke-AzureRmResourceAction aufrufen, können vorübergehende Fehler auftreten. In diesem Szenario wird empfohlen, das folgende grundlegende Muster um den Aufruf des Cmdlets zu implementieren.

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

Beispiel 2: Wenn das Runbook häufig Remoteaufrufe ausführt

Wenn das Runbook häufig Remoteaufrufe ausführt, können vorübergehende Laufzeitprobleme auftreten. Erstellen Sie eine Funktion, die die Wiederholungslogik für jeden Aufruf implementiert, der ausgeführt wird, und übergeben Sie den auszuführenden Aufruf als Skriptblock zur Ausführung.

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

Anschließend können Sie jeden Remoteaufruf in der Funktion als
übergeben.

ResilientRemoteCall { Get-AzVm }
oder

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

Verwenden mehrerer Abonnements

Ihr Runbook muss in der Lage sein, mit Abonnements zu arbeiten. Für den Umgang mit mehreren Abonnements verwendet Ihr Runbook z. B. das Cmdlet Disable-AzContextAutosave. Mit diesem Cmdlet wird sichergestellt, dass der Authentifizierungskontext nicht von einem anderen Runbook abgerufen wird, das in derselben Sandbox ausgeführt wird.

# 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

Wenn Sie möchten, dass das Runbook mit der systemseitig zugewiesenen verwalteten Identität ausgeführt wird, lassen Sie den Code unverändert. Wenn Sie lieber eine benutzerseitig zugewiesene verwaltete Identität verwenden möchten, gehen Sie wie folgt vor:

1. Entfernen Sie $AzureContext = (Connect-AzAccount -Identity).context aus Zeile 5.
2. Fügen Sie stattdessen $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context ein.
3. Geben Sie die Client-ID ein.

Verwenden eines benutzerdefinierten Skripts

So verwenden Sie ein benutzerdefiniertes Skript

1. Erstellen Sie ein Automation-Konto.
2. Stellen Sie eine Hybrid Runbook Worker-Rolle bereit.
3. Auf einem Linux-Computer benötigen Sie dazu erhöhte Berechtigungen. Melden Sie sich an, um Signaturüberprüfungen zu deaktivieren.

Testen eines Runbooks

Wenn Sie ein Runbook testen, wird die Entwurfsversion ausgeführt, und alle darin ausgeführten Aktionen werden abgeschlossen. Es wird kein Auftragsverlauf erstellt. Allerdings werden die Datenströme Ausgabe sowie Warnung und Fehler im Bereich Testausgabe angezeigt. Nachrichten an den ausführlichen Datenstrom werden nur dann im Ausgabebereich, wenn die Variable VerbosePreference auf Continue festgelegt ist.

Auch wenn die Entwurfsversion ausgeführt wird, wird das Runbook trotzdem normal ausgeführt, und alle Aktionen werden auf die Ressourcen in der Umgebung angewendet. Aus diesem Grund sollten Sie Runbooks nur auf Ressourcen testen, die sich nicht in der Produktionsumgebung befinden.

Die Vorgehensweise zum Testen der einzelnen Typen von Runbooks ist identisch. Es besteht kein Unterschied zwischen Tests mit dem Text-Editor und dem grafischen Editor im Azure-Portal.

1. Öffnen Sie die Entwurfsversion des Runbooks entweder im Text-Editor oder grafischen Editor.
2. Klicken Sie auf Testen, um die Testseite zu öffnen.
3. Wenn das Runbook über Parameter verfügt, werden diese im linken Bereich aufgeführt. Dort können Sie die für den Test zu verwendenden Werte angeben.
4. Wenn Sie den Test auf einem Hybrid Runbook Worker ausführen möchten, ändern Sie die Testlaufeinstellungen in Hybrid Worker, und wählen Sie den Namen der Zielgruppe aus. Andernfalls behalten Sie den Standardwert Azure bei, um den Test in der Cloud auszuführen.
5. Klicken Sie auf Starten, um den Test zu starten.
6. Mithilfe der Schaltflächen im Bereich Ausgabe können Sie während des Tests ein PowerShell-Workflow- oder graphisches Runbook zu beenden oder anzuhalten. Wenn Sie das Runbook anhalten, wird die aktuelle Aktivität vor der Unterbrechung abgeschlossen. Nachdem das Runbook angehalten wurde, können Sie es beenden oder erneut starten.
7. Untersuchen Sie die Ausgabe des Runbooks im Bereich Ausgabe.

Veröffentlichen eines Runbooks

Wenn Sie ein neues Runbooks erstellen oder importieren, müssen Sie es veröffentlichen, bevor Sie es ausführen können. Jedes Runbook in Azure Automation umfasst eine Entwurfsversion und eine veröffentlichte Version. Nur die veröffentlichte Version kann ausgeführt werden, und nur die Entwurfsversion kann bearbeitet werden. Die veröffentlichte Version bleibt von Änderungen an der Entwurfsversion unberührt. Wenn die Entwurfsversion zur Verfügung gestellt werden soll, können Sie sie veröffentlichen, wodurch die Entwurfsversion die aktuell veröffentlichte Version überschreibt.

Veröffentlichen eines Runbooks im Azure-Portal

1. Suchen Sie im Azure-Portal nach Automation-Konten und wählen Sie diese Option aus.
2. Wählen Sie auf der Seite Automation-Konten in der entsprechenden Liste Ihr Automation-Konto aus.
3. Öffnen Sie das Runbook in Ihrem Automation-Konto.
4. Klicken Sie auf Bearbeiten.
5. Klicken Sie auf Veröffentlichen, und wählen Sie dann als Antwort in der Bestätigungsmeldung die Option Ja aus.

Veröffentlichen eines Runbooks mithilfe von PowerShell

Verwenden Sie das Cmdlet Publish-AzAutomationRunbook, um Ihr Runbook zu veröffentlichen.

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

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

Erstellen eines Zeitplans für ein Runbook im Azure-Portal

Nachdem Ihr Runbook veröffentlicht wurde, können Sie einen Zeitplan für seinen Betrieb erstellen:

1. Suchen Sie im Azure-Portal nach Automation-Konten und wählen Sie diese Option aus.
2. Wählen Sie auf der Seite Automation-Konten in der entsprechenden Liste Ihr Automation-Konto aus.
3. Wählen Sie das Runbook aus der Liste der Runbooks aus.
4. Wählen Sie unter Ressourcen die Option Zeitpläne aus.
5. Wählen Sie Zeitplan hinzufügen aus.
6. Wählen Sie im Bereich Runbook planen die Option Zeitplan mit Runbook verknüpfen aus.
7. Wählen Sie im Bereich Zeitplan die Option Neuen Zeitplan erstellen aus.
8. Geben Sie im Bereich Neuer Zeitplan einen Namen, eine Beschreibung und andere Parameter ein.
9. Nachdem der Zeitplan erstellt wurde, markieren Sie ihn, und klicken Sie auf OK. Er sollte jetzt mit Ihrem Runbook verknüpft sein.
10. Suchen Sie in Ihrem Postfach nach einer E-Mail, die Sie über den Status des Runbooks informiert.

Wiederherstellen gelöschter Runbooks

Sie können ein gelöschtes Runbook über PowerShell-Skripts wiederherstellen. Um ein Runbook wiederherzustellen, stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind:

• Die Runbooks, die wiederhergestellt werden sollen, wurden in den letzten 29 Tagen gelöscht.
• Das Automation-Konto für dieses Runbook ist vorhanden.
• Die Rollenberechtigung Automation-Mitwirkender wird der systemseitig zugewiesenen verwalteten Identität des Automation-Kontos gewährt.

PowerShell-Skript

• Führen Sie das PowerShell-Skript als Auftrag in Ihrem Automation-Konto aus, um die gelöschten Runbooks wiederherzustellen.
• Laden Sie das PowerShell-Skript von GitHub herunter. Alternativ können Sie das PowerShell-Skript mit dem Namen Restore Automation Runbook aus dem Runbookkatalog importieren. Geben Sie den Namen des Runbooks an, das wiederhergestellt werden soll, und führen Sie es als Auftrag in Azure Automation aus, um die gelöschten Runbooks wiederherzustellen.
• Laden Sie das Skript von GitHub herunter, oder importieren Sie das PowerShell-Skript mit dem Namen List Deleted Automation Runbook aus dem Runbookkatalog, um die Namen der Runbooks zu identifizieren, die in den letzten 29 Tagen gelöscht wurden.

Abrufen des Auftragsstatus

Anzeigen von Status im Azure-Portal

Details zur Auftragsbehandlung in Azure Automation werden in Aufträgen bereitgestellt. Wenn Sie Ihre Runbookaufträge anzeigen möchten, greifen Sie im Azure-Portal auf Ihr Automation-Konto zu. Auf der rechten Seite wird unter Auftragsstatistik eine Zusammenfassung aller Runbookaufträge angezeigt.

In der Zusammenfassung wird die Anzahl aller ausgeführten Aufträge neben einer grafischen Darstellung des Auftragsstatus angezeigt.

Wenn Sie auf die Kachel klicken, wird die Seite „Aufträge“ angezeigt, die eine Liste mit einer Zusammenfassung aller ausgeführten Aufträge enthält. Auf dieser Seite werden der Status, Runbookname sowie die Start- und Abschlusszeit jedes Auftrags angezeigt.

Sie können die Auftragsliste filtern, indem Sie Aufträge filtern auswählen. Filtern Sie anhand eines bestimmten Runbooks, eines Auftragsstatus oder einer Option in der Dropdownliste, und geben Sie die Zeitspanne für die Suche an.

Alternativ können Sie für ein bestimmtes Runbook eine Auftragszusammenfassung anzeigen, indem Sie in Ihrem Automation-Konto zuerst auf der Seite „Runbooks“ das Runbook und dann Aufträge auswählen. Mit dieser Aktion wird die Seite „Aufträge“ angezeigt. Wenn Sie dort auf einen Auftragsdatensatz klicken, werden die zugehörigen Details und Ausgaben angezeigt.

Abrufen des Auftragsstatus mithilfe von PowerShell

Verwenden Sie das Cmdlet Get-AzureAutomationJob, um die für ein Runbook erstellten Aufträge und die Details zu einem bestimmten Auftrag anzuzeigen. Wenn Sie ein Runbook mit Start-AzAutomationRunbook starten, wird der entsprechende Auftrag zurückgegeben. Verwenden Sie Get-AzAutomationJobOutput, um die Auftragsausgabe abzurufen.

Die folgenden Beispielbefehle rufen den letzten Auftrag für ein Beispielrunbook ab und zeigen seinen Status, die für die Runbookparameter bereitgestellten Werte und die Auftragsausgabe an.

$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

Das folgende Beispiel ruft die Ausgabe für einen bestimmten Auftrag ab und gibt die einzelnen Datensätze zurück. Wenn es eine Ausnahme für einen der Datensätze gibt, gibt das Skript die Ausnahme anstelle des Werts aus. Dieses Verhalten ist hilfreich, da Ausnahmen zusätzliche Informationen liefern können, die bei der Ausgabe normalerweise nicht protokolliert werden.

$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ächste Schritte

• Beispielabfragen finden Sie unter Beispielabfragen für Auftragsprotokolle und Auftragsstreams.
• Einzelheiten zur Runbookverwaltung finden Sie unter Ausführen von Runbooks in Azure Automation.
• Informationen zum Vorbereiten eines PowerShell-Runbooks finden Sie unter Bearbeiten von Textrunbooks in Azure Automation.
• Informationen zum Behandeln von Problemen bei der Runbookausführung finden Sie unter Beheben von Runbookproblemen.