Runbook-körning i Azure AutomationRunbook execution in Azure Automation

När du startar en Runbook i Azure Automation skapas ett jobb.When you start a runbook in Azure Automation, a job is created. Ett jobb innebär ett utförande av en runbookinstans.A job is a single execution instance of a runbook. En Azure Automation arbetare tilldelas för att köra varje jobb.An Azure Automation worker is assigned to run each job. Medan arbets tagarna delas av många Azure-konton, är jobb från olika Automation-konton isolerade från varandra.While workers are shared by many Azure accounts, jobs from different Automation accounts are isolated from one another. Du har inte kontroll över vilka Worker-tjänster som begär ditt jobb.You don't have control over which worker services the request for your job. En enda Runbook kan ha många jobb på samma gång.A single runbook can have many jobs running at one time. Körnings miljön för jobb från samma Automation-konto kan återanvändas.The execution environment for jobs from the same Automation Account may be reused. Fler jobb som du kör samtidigt, desto oftare kan de skickas till samma sandbox.The more jobs you run at the same time, the more often they can be dispatched to the same sandbox. Jobb som körs i samma sand Box process kan påverka varandra, ett exempel är att Disconnect-AzureRMAccount köra cmdleten.Jobs running in the same sandbox process can affect each other, one example is running the Disconnect-AzureRMAccount cmdlet. Om du kör denna cmdlet kopplas varje Runbook-jobb bort i den delade sand Box processen.Running this cmdlet would disconnect each runbook job in the shared sandbox process. När du visar listan över Runbooks i Azure Portal visas status för alla jobb som har startats för varje Runbook.When you view the list of runbooks in the Azure portal, it lists the status of all jobs that were started for each runbook. Du kan visa listan över jobb för varje Runbook för att spåra status för varje.You can view the list of jobs for each runbook to track the status of each. Jobb loggar lagras i högst 30 dagar.Job logs are stored for a max of 30 days. En beskrivning av jobbstatus för olika jobb.For a description of the different job statuses Job Statuses.

Anteckning

I Azure-begäranden från registrerad person för GDPR finns det information om att visa eller ta bort personuppgifter.For information about viewing or deleting personal data, see Azure Data Subject Requests for the GDPR. Mer information om GDPR finns i GDPR-avsnittet på Service Trust Portal.For more information about GDPR, see the GDPR section of the Service Trust portal.

Följande diagram visar livs cykeln för ett Runbook-jobb för PowerShell-Runbooks, grafiska runbooks och PowerShell Workflow-Runbooks.The following diagram shows the lifecycle of a runbook job for PowerShell runbooks, Graphical runbooks and PowerShell Workflow runbooks.

Jobb status – PowerShell-arbetsflöde

Dina jobb har åtkomst till dina Azure-resurser genom att ansluta till din Azure-prenumeration.Your jobs have access to your Azure resources by making a connection to your Azure subscription. De har bara åtkomst till resurser i ditt data Center om resurserna är tillgängliga från det offentliga molnet.They only have access to resources in your data center if those resources are accessible from the public cloud.

Var du ska köra RunbooksWhere to run your runbooks

Runbooks i Azure Automation kan köras antingen i ett begränsat läge i Azure eller ett hybrid Runbook Worker.Runbooks in Azure Automation can run on either a sandbox in Azure or a Hybrid Runbook Worker. En sandbox är en delad miljö i Azure som kan användas av flera jobb.A sandbox is a shared environment in Azure that can be used by multiple jobs. Jobb som använder samma Sandbox är begränsade till resurs begränsningarna i sand boxen.Jobs using the same sandbox are bound by the resource limitations of the sandbox. Hybrid Runbook Worker kan köra Runbooks direkt på datorn som är värd för rollen och mot resurser i miljön för att hantera de lokala resurserna.Hybrid Runbook Workers can run runbooks directly on the computer that's hosting the role and against resources in the environment to manage those local resources. Runbooks lagras och hanteras i Azure Automation och levereras sedan till en eller flera tilldelade datorer.Runbooks are stored and managed in Azure Automation and then delivered to one or more assigned computers. De flesta Runbooks kan enkelt köras i sand boxen Azure.Most runbooks can easily be run in the Azure sandboxes. Det finns vissa scenarier där du kan välja en hybrid Runbook i ett Azure-sandbox för att köra din Runbook.There are specific scenarios where choosing a Hybrid Runbook over an Azure sandbox to execute your runbook may be recommended. I följande tabell finns en lista över några exempel scenarier:See the following table for a list of some example scenarios:

UppgiftTask Bästa valetBest Choice AnteckningarNotes
Integrera med Azure-resurserIntegrate with Azure resources Sand box för AzureAzure Sandbox Azure är värd för Azure och det är enklare att autentisera.Hosted in azure, authentication is simpler. Om du använder en Hybrid Runbook Worker på en virtuell Azure-dator kan du använda hanterade identiteter för Azure-resurserIf you are using a Hybrid Runbook Worker on an Azure VM, you can use managed identities for Azure resources
Optimala prestanda för att hantera Azure-resurserOptimal performance to manage azure resources Sand box för AzureAzure Sandbox Skriptet körs i samma miljö, vilket i sin tur har mindre latensScript is run in the same environment, which in turn has less latency
Minimera drifts kostnaderMinimize operational costs Sand box för AzureAzure Sandbox Det finns ingen beräknings omkostnader, inget behov av en virtuell datorThere is no compute overhead, no need for a VM
Tids krävande skriptLong running script Hybrid Runbook WorkerHybrid Runbook Worker Azure-sand lådor har begränsade resurserAzure sandboxes have limitation on resources
Interagera med lokala tjänsterInteract with Local services Hybrid Runbook WorkerHybrid Runbook Worker Kan ha åtkomst direkt till värd datornCan have access directly to host machine
Kräv program vara från tredje part och körbara filerRequire 3rd party software and executables Hybrid Runbook WorkerHybrid Runbook Worker Du hanterar operativ systemet och kan installera program varaYou manage the OS and can install software
Övervaka en fil eller mapp med en RunbookMonitor a file or folder with a runbook Hybrid Runbook WorkerHybrid Runbook Worker Använda en bevakare-uppgift i en hybrid Runbook WorkerUse a Watcher task on a Hybrid Runbook worker
Resurs intensivt skriptResource intensive script Hybrid Runbook WorkerHybrid Runbook Worker Azure-sand lådor har begränsade resurserAzure sandboxes have limitation on resources
Använda moduler med särskilda kravUsing modules with specific requirements Hybrid Runbook WorkerHybrid Runbook Worker Några exempel är:Some examples are:
WinSCP – beroende av WinSCP. exeWinSCP - dependency on winscp.exe
Administrationsmodul – kräver att IIS aktive rasIISAdministration - Needs IIS to be enabled
Installations modul som kräver installations programInstall module that requires installer Hybrid Runbook WorkerHybrid Runbook Worker Moduler för sandbox måste vara copiableModules for sandbox must be copiable
Använda Runbooks eller moduler som kräver .NET Framework skiljer sig från 4.7.2Using runbooks or modules that require .NET Framework different from 4.7.2 Hybrid Runbook WorkerHybrid Runbook Worker Automation-sandboxs har .NET Framework 4.7.2 och det finns inget sätt att uppgradera detAutomation sandboxes have .NET Framework 4.7.2, and there is no way to upgrade it
Skript som kräver höjningScripts that require elevation Hybrid Runbook WorkerHybrid Runbook Worker Sand boxen tillåter inte utökade privilegier.Sandboxes do not allow elevation. Lös detta genom att använda en hybrid Runbook Worker och du kan stänga av UAC och använda Invoke-Command när du kör kommandot som kräver utökade privilegierTo solve this, use a Hybrid Runbook Worker and you can turn off UAC and use Invoke-Command when running the command that requires elevation
Skript som kräver åtkomst till WMIScripts that require access to WMI Hybrid Runbook WorkerHybrid Runbook Worker Jobb som körs i begränsade lägen i molnet har inte åtkomst till WMIJobs running in sandboxes in the cloud do not have access to the WMI

Runbook-beteendeRunbook behavior

Runbooks körs baserat på den logik som definieras i dem.Runbooks execute based on the logic that is defined inside them. Om en Runbook avbryts startar runbooken om i början.If a runbook is interrupted, the runbook restarts at the beginning. Det här beteendet kräver att Runbooks skrivs på ett sätt där de har stöd för omstart om det finns tillfälliga problem.This behavior requires runbooks to be written in a way where they support being restarted if there were transient issues.

PowerShell-jobb som startats från en Runbook kördes i en Azure-sandbox kanske inte körs i det fullständiga språk läget.PowerShell jobs started from a Runbook ran in an Azure sandbox may not run in the Full language mode. Mer information om PowerShell-språklägen finns i PowerShell-språklägen.To learn more about PowerShell language modes, see PowerShell language modes. Mer information om hur du interagerar med jobb i Azure Automation finns i Hämta jobb status med PowerShellFor additional details on how to interact with jobs in Azure Automation, see Retrieving job status with PowerShell

Skapa resurserCreating resources

Om du skapar resurser i skriptet bör du kontrol lera om resursen redan finns innan du försöker skapa den igen.If your script creates resources, you should check to see if the resource already exists before attempting to create it again. Ett grundläggande exempel visas i följande exempel:A basic example is shown in the following example:

$vmName = "WindowsVM1"
$resourceGroupName = "myResourceGroup"
$myCred = Get-AutomationPSCredential "MyCredential"
$vmExists = Get-AzureRmResource -Name $vmName -ResourceGroupName $resourceGroupName

if(!$vmExists)
    {
    Write-Output "VM $vmName does not exists, creating"
    New-AzureRmVM -Name $vmName -ResourceGroupName $resourceGroupName -Credential $myCred
    }
else
    {
    Write-Output "VM $vmName already exists, skipping"
    }

Tids beroende skriptTime dependant scripts

Noga överväganden bör göras vid redigering av Runbooks.Careful consideration should be made when authoring runbooks. Som tidigare nämnts måste Runbooks skapas på ett sätt som är robust och kan hantera tillfälliga fel som kan orsaka att runbooken startas om eller Miss lyckas.As mentioned earlier, runbooks need to be authored in a way that they're robust and can handle transient errors that may cause the runbook to restart or fail. Om en Runbook Miss lyckas görs ett nytt försök.If a runbook fails, it is retried. Om en Runbook normalt körs inom en tids gräns, ska logiken för att kontrol lera körnings tiden implementeras i runbooken för att säkerställa att åtgärder som starta, Stäng ned eller skala ut körs bara under vissa tider.If a runbook normally runs within a time constraint, logic to check the execution time should be implemented in the runbook to ensure operations like start up, shut down or scale out are run only during specific times.

Anteckning

Den lokala tiden för Azures sand Box process är inställd på UTC-tid.The local time on the Azure sandbox process is set to UTC time. Beräkningar för datum och tid i dina Runbooks måste ta hänsyn till detta.Calculations for date and time in your runbooks need to take this into consideration.

Spårnings förloppTracking progress

Det är en bra idé att skapa Runbooks för att vara modulärt av natur.It is a good practice to author runbooks to be modular in nature. Det innebär att du strukturerar logiken i runbooken så att den kan återanvändas och startas om enkelt.This means structuring the logic in the runbook such that it can be reused and restarted easily. Att spåra förloppet i en Runbook är ett bra sätt att se till att logiken i en runbook körs på rätt sätt om det uppstår problem.Tracking progress in a runbook is a good way to ensure that the logic in a runbook executes correctly if there were issues. Några möjliga sätt att följa förloppet för runbooken är genom att använda en extern källa, till exempel lagrings konton, en databas eller delade filer.Some possible ways to track the progress of the runbook is by using an external source such as storage accounts, a database, or shared files. Genom att spåra statusen externt kan du skapa logik i din Runbook för att först kontrol lera status för den senaste åtgärden som Runbook vidtog.By tracking the state externally, you can create logic in your runbook to first check the state of the last action the runbook took. Sedan, baserat på resultaten, kan du antingen hoppa över eller fortsätta med vissa uppgifter i runbooken.Then based off the results, either skip or continue specific tasks in the runbook.

Förhindra samtidiga jobbPrevent concurrent jobs

Vissa Runbooks kan fungera konstigt om de körs över flera jobb samtidigt.Some runbooks may behave strangely if they are running across multiple jobs at the same time. I det här fallet är det viktigt att implementera logik för att kontrol lera om det redan finns ett jobb i Runbook som körs.In this case, it's important to implement logic to check to see if a runbook already has a running job. Ett grundläggande exempel på hur du kan göra detta visas i följande exempel:A basic example of how you may do this behavior is shown in the following example:

# Authenticate to Azure
$connection = Get-AutomationConnection -Name AzureRunAsConnection
Connect-AzureRmAccount -ServicePrincipal -Tenant $connection.TenantID `
-ApplicationID $connection.ApplicationID -CertificateThumbprint $connection.CertificateThumbprint

$AzureContext = Select-AzureRmSubscription -SubscriptionId $connection.SubscriptionID

# Check for already running or new runbooks
$runbookName = "<RunbookName>"
$rgName = "<ResourceGroupName>"
$aaName = "<AutomationAccountName>"
$jobs = Get-AzureRmAutomationJob -ResourceGroupName $rgName -AutomationAccountName $aaName -RunbookName $runbookName -AzureRmContext $AzureContext

# If then check to see if it is already running
$runningCount = ($jobs | ? {$_.Status -eq "Running"}).count

If (($jobs.status -contains "Running" -And $runningCount -gt 1 ) -Or ($jobs.Status -eq "New")) {
    # Exit code
    Write-Output "Runbook is already running"
    Exit 1
} else {
    # Insert Your code here
}

Arbeta med flera prenumerationerWorking with multiple subscriptions

När du redigerar Runbooks som hanterar flera prenumerationer måste din Runbook använda cmdleten disable-AzureRmContextAutosave för att säkerställa att din autentisering inte hämtas från en annan Runbook som kan köras i samma sandbox.When authoring runbooks that deal with multiple subscriptions, your runbook needs use the Disable-AzureRmContextAutosave cmdlet to ensure that your authentication context is not retrieved from another runbook that may be running in the same sandbox. Du måste sedan använda -AzureRmContext parametern på dina AzureRM cmdlets och skicka den till rätt kontext.You then need to use the -AzureRmContext parameter on your AzureRM cmdlets and pass it your proper context.

# Ensures you do not inherit an AzureRMContext in your runbook
Disable-AzureRmContextAutosave –Scope Process

$Conn = Get-AutomationConnection -Name AzureRunAsConnection
Connect-AzureRmAccount -ServicePrincipal `
-Tenant $Conn.TenantID `
-ApplicationID $Conn.ApplicationID `
-CertificateThumbprint $Conn.CertificateThumbprint

$context = Get-AzureRmContext

$ChildRunbookName = 'ChildRunbookDemo'
$AutomationAccountName = 'myAutomationAccount'
$ResourceGroupName = 'myResourceGroup'

Start-AzureRmAutomationRunbook `
    -ResourceGroupName $ResourceGroupName `
    -AutomationAccountName $AutomationAccountName `
    -Name $ChildRunbookName `
    -DefaultProfile $context

Hantering av undantagHandling exceptions

När du redigerar skript är det viktigt att kunna hantera undantag och potentiella tillfälliga fel.When authoring scripts, it is important to be able to handle exceptions and potential intermittent failures. Följande är några olika sätt att hantera undantag eller tillfälliga problem med dina runbooks:The following are some different ways to handle exceptions or intermittent issues with your runbooks:

$ErrorActionPreference$ErrorActionPreference

Variabeln $ErrorActionPreference inställning avgör hur PowerShell svarar på ett icke-avslutande fel.The $ErrorActionPreference preference variable determines how PowerShell responds to a non-terminating error. Avslutande fel påverkas inte av $ErrorActionPreference, de avslutas alltid.Terminating errors are not affected by $ErrorActionPreference, they always terminate. Genom att $ErrorActionPreferenceanvända kan ett vanligt icke-avslutande fel som PathNotFound från Get-ChildItem cmdleten stoppa Runbook från att slutföras.By using $ErrorActionPreference, a normally non-terminating error like PathNotFound from the Get-ChildItem cmdlet will stop the runbook from completing. Följande exempel visar hur du $ErrorActionPreferenceanvänder.The following example shows using $ErrorActionPreference. Den sista Write-Output raden körs aldrig när skriptet stoppas.The final Write-Output line will never execute as the script will stop.

$ErrorActionPreference = 'Stop'
Get-Childitem -path nofile.txt
Write-Output "This message will not show"

Prova att fånga finallyTry Catch Finally

Försök att fånga används i PowerShell-skript för att hjälpa dig att hantera fel.Try Catch is used in PowerShell scripts to help you handle terminating errors. Genom att använda try-catch kan du fånga upp vissa undantag eller allmänna undantag.By using Try Catch, you can catch specific exceptions or general exceptions. Catch-instruktionen ska användas för att spåra fel eller som används för att försöka hantera felet.The Catch statement should be used to track errors or used to try to handle the error. I följande exempel försöker hämta en fil som inte finns.The following example tries to download a file that does not exist. Det fångar System.Net.WebException undantaget, om det fanns ett annat undantag returneras det sista värdet.It catches the System.Net.WebException exception, if there was another exception the last value is returned.

try
{
   $wc = new-object System.Net.WebClient
   $wc.DownloadFile("http://www.contoso.com/MyDoc.doc")
}
catch [System.Net.WebException]
{
    "Unable to download MyDoc.doc from http://www.contoso.com."
}
catch
{
    "An error occurred that could not be resolved."
}

GenererasThrow

Throw kan användas för att generera ett avslutande fel.Throw can be used to generate a terminating error. Detta kan vara användbart när du definierar din egen logik i en Runbook.This can be useful when defining your own logic in a runbook. Om ett visst villkor uppfylls som stoppar skriptet kan du använda throw för att stoppa skriptet.If a certain criteria is met that should stop the script, you can use throw to stop the script. I följande exempel visas en funktions parameter för Machine som krävs throwmed hjälp av.The following example shows machine a function parameter required by using throw.

function Get-ContosoFiles
{
  param ($path = $(throw "The Path parameter is required."))
  Get-ChildItem -Path $path\*.txt -recurse
}

Använda körbara filer eller anropande processerUsing executables or calling processes

Runbooks som körs i Azure-sandbox stöder inte anrop av processer (till exempel en. exe eller under process. Call).Runbooks run in Azure sandboxes do not support calling processes (such as an .exe or subprocess.call). Detta beror på att Azure-sand lådor är delade processer som körs i behållare, som kanske inte har åtkomst till alla underliggande API: er.This is because Azure sandboxes are shared processes run in containers, which may not have access to all the underlying APIs. För scenarier där du behöver program vara från tredje part eller uppringning av under processer, rekommenderar vi att du kör runbooken på en hybrid Runbook Worker.For scenarios where you require 3rd party software or calling of sub processes, it is recommended you execute the runbook on a Hybrid Runbook Worker.

Egenskaper för enhet och programDevice and application characteristics

Runbook-jobb som körs i Azure-sandbox har inte åtkomst till några enhets-eller program egenskaper.Runbook jobs run in Azure sandboxes do not have access to any device or application characteristics. Det vanligaste API: et som används för att fråga prestanda värden i Windows är WMI.The most common API used to query performance metrics on Windows is WMI. Några av dessa vanliga mått är minne och CPU-användning.Some of these common metrics are memory and CPU usage. Men det spelar ingen roll vilket API som används.However, it does not matter what API is used. Jobb som körs i molnet har inte åtkomst till Microsofts implementering av webbaserad företags hantering (WBEM), som bygger på Common Information Model (CIM), som är bransch standarder för att definiera egenskaper för enheter och program.Jobs running in the cloud do not have access to the Microsoft implementation of Web Based Enterprise Management (WBEM), which is built on the Common Information Model (CIM), which are the industry standards for defining device and application characteristics.

Jobb statusJob statuses

Följande tabell beskriver de olika statuslägen som är möjliga för ett jobb.The following table describes the different statuses that are possible for a job. PowerShell har två typer av fel, avslutande och icke-avslutande fel.PowerShell has two types of errors, terminating and non-terminating errors. Om du avbryter fel anges Runbook- statusen till misslyckad om de inträffar.Terminating errors set the runbook status to Failed if they occur. Icke-avslutande fel tillåter att skriptet fortsätter även efter att det har inträffat.Non-terminating errors allow the script to continue even after they occur. Ett exempel på ett icke-avslutande fel är att Get-ChildItem använda cmdleten med en sökväg som inte finns.An example of a non-terminating error is using the Get-ChildItem cmdlet with a path that doesn't exist. PowerShell ser att sökvägen inte finns, genererar ett fel och fortsätter till nästa mapp.PowerShell sees that the path doesn't exist, throws an error, and continues to the next folder. Det här felet skulle inte ange Runbook-statusen Misslyckad och kan markeras som slutförd.This error wouldn't set the runbook status to Failed and could be marked as Completed. Om du vill tvinga en Runbook att stoppa vid ett icke-avslutande fel, kan du -ErrorAction Stop använda på-cmdleten.To force a runbook to stop on a non-terminating error, you can use -ErrorAction Stop on the cmdlet.

StatusStatus BeskrivningDescription
SlutförtCompleted Jobbet har slutförts.The job completed successfully.
MisslyckadFailed Runbook kunde inte kompileras för grafiska och PowerShell-arbetsflöden.For Graphical and PowerShell Workflow runbooks, the runbook failed to compile. För PowerShell-skript Runbookskunde Runbook inte starta eller så innehöll jobbet ett undantag.For PowerShell Script runbooks, the runbook failed to start or the job had an exception.
Misslyckades, väntar på resurserFailed, waiting for resources Jobbet misslyckades eftersom det nådde den verkliga delnings gränsen tre gånger och startade från samma kontroll punkt eller från början av runbooken varje gång.The job failed because it reached the fair share limit three times and started from the same checkpoint or from the start of the runbook each time.
I köQueued Jobbet väntar på att resurser från en Automation arbetare blir tillgängliga så det kan starta.The job is waiting for resources on an Automation worker to come available so that it can be started.
StartarStarting Jobbet har tilldelats en anställd och systemet startas.The job has been assigned to a worker, and the system is starting it.
ÅterupptarResuming Systemet återupptar jobbet när det har pausats.The system is resuming the job after it was suspended.
KörsRunning Jobbet körsThe job is running.
Körs, väntar på resurserRunning, waiting for resources Jobbet har inaktiverats på grund av att gränsen nåddes för den verkliga delningen .The job has been unloaded because it reached the fair share limit. Den återupptas strax från den senaste kontroll punkten.It resumes shortly from its last checkpoint.
StoppadStopped Jobbet stoppades av användaren innan det slutfördes.The job was stopped by the user before it was completed.
StopparStopping Jobbet stoppas av systemet.The system is stopping the job.
UppehållSuspended Jobbet pausades av användaren, av systemet, eller av ett kommando i runbook.The job was suspended by the user, by the system, or by a command in the runbook. Om en Runbook inte har en kontroll punkt börjar den från början av runbooken.If a runbook doesn't have a checkpoint, it starts from the beginning of the runbook. Om den har en kontroll punkt kan den startas igen och återupptas från den senaste kontroll punkten.If it has a checkpoint, it can start again and resume from its last checkpoint. Runbooken pausas bara av systemet när ett undantag inträffar.The runbook is only suspended by the system when an exception occurs. Som standard är Erroractionpreference satt inställd på att fortsätta, vilket innebär att jobbet fortsätter att köras vid ett fel.By default, ErrorActionPreference is set to Continue, meaning that the job keeps running on an error. Om den här preferens variabeln är inställd på Avbrytpausas jobbet vid ett fel.If this preference variable is set to Stop, then the job suspends on an error. Gäller endast för grafiska och PowerShell Workflow-Runbooks .Applies to Graphical and PowerShell Workflow runbooks only.
PausarSuspending Systemet försöker pausa jobbet på användarens begäran.The system is trying to suspend the job at the request of the user. Runbooken måste komma fram till nästa kontroll punkt innan den kan pausas.The runbook must reach its next checkpoint before it can be suspended. Om den redan har passerat den senaste kontroll punkten slutförs den innan den kan pausas.If it already passed its last checkpoint, then it completes before it can be suspended. Gäller endast för grafiska och PowerShell Workflow-Runbooks .Applies to Graphical and PowerShell Workflow runbooks only.

Visa jobb status från Azure PortalViewing job status from the Azure portal

Du kan visa en sammanfattnings status för alla Runbook-jobb eller öka detalj nivån för ett särskilt Runbook-jobb i Azure Portal.You can view a summarized status of all runbook jobs or drill into details of a specific runbook job in the Azure portal. Du kan också konfigurera integrering med din Log Analytics arbets yta för att vidarebefordra Runbook-jobbets status och jobb strömmar.You can also configure integration with your Log Analytics workspace to forward runbook job status and job streams. Mer information om hur du integrerar med Azure Monitor loggar finns i vidarebefordra jobb status och jobb strömmar från Automation till Azure Monitor loggar.For more information about integrating with Azure Monitor logs, see Forward job status and job streams from Automation to Azure Monitor logs.

Översikt över Automation Runbook-jobbAutomation runbook jobs summary

Till höger om det valda Automation-kontot kan du se en översikt över alla Runbook-jobb på panelen jobb statistik .On the right of your selected Automation account, you can see a summary of all the runbook jobs under Job Statistics tile.

Panel för jobb statistik

Den här panelen visar ett antal och en grafisk representation av jobb status för alla jobb som körs.This tile displays a count and graphical representation of the job status for all jobs executed.

Om du klickar på panelen visas jobb sidan som innehåller en sammanfattande lista över alla jobb som körs.Clicking the tile presents the Jobs page, which includes a summarized list of all jobs executed. Den här sidan visar status, start tider och slut för ande tider.This page shows the status, start times, and completion times.

Sidan jobb för Automation-konto

Du kan filtrera listan över jobb genom att välja filtrera jobb och filtrera på en angiven Runbook, jobb status eller i list rutan och tidsintervallet att söka inom.You can filter the list of jobs by selecting Filter jobs and filter on a specific runbook, job status, or from the drop-down list, and the time range to search within.

Filtrera jobb status

Du kan också Visa jobb sammanfattnings information för en angiven Runbook genom att välja denna Runbook från sidan Runbooks i ditt Automation-konto och sedan välja jobb panelen.Alternatively, you can view job summary details for a specific runbook by selecting that runbook from the Runbooks page in your Automation account, and then select the Jobs tile. Den här åtgärden visar jobb sidan och därifrån kan du klicka på jobb posten för att visa information och utdata.This action presents the Jobs page, and from there you can click the job record to view its detail and output.

Sidan jobb för Automation-konto

JobbsammanfattningJob Summary

Du kan visa en lista över alla jobb som har skapats för en viss Runbook och deras senaste status.You can view a list of all the jobs that have been created for a particular runbook and their most recent status. Du kan filtrera listan efter jobb status och datum intervallet för den senaste ändringen i jobbet.You can filter this list by job status and the range of dates for the last change to the job. Om du vill visa detaljerad information och utdata klickar du på namnet på ett jobb.To view its detailed information and output, click the name of a job. Jobbets detaljvy inkluderar värden för runbookparametrar som gavs av det jobbet.The detailed view of the job includes the values for the runbook parameters that were provided to that job.

Du kan använda följande steg för att se jobb för en runbook.You can use the following steps to view the jobs for a runbook.

  1. I Azure Portal väljer du Automation och väljer sedan namnet på ett Automation-konto.In the Azure portal, select Automation and then select the name of an Automation account.
  2. Från hubben väljer du Runbooks och på sidan Runbooks väljer du sedan en Runbook i listan.From the hub, select Runbooks and then on the Runbooks page select a runbook from the list.
  3. Klicka på panelen jobb på sidan för den valda Runbook-flödet.On the page for the selected runbook, click the Jobs tile.
  4. Klicka på ett av jobben i listan och på sidan information om Runbook-jobb kan du Visa information och utdata.Click one of the jobs in the list and on the runbook job details page you can view its detail and output.

Jobb status hämtas med PowerShellRetrieving job status using PowerShell

Du kan använda Get-AzureRmAutomationJob för att hämta jobb som skapats för en Runbook och information om ett visst jobb.You can use the Get-AzureRmAutomationJob to retrieve the jobs created for a runbook and the details of a particular job. Om du startar en Runbook med PowerShell med Start-AzureRmAutomationRunbook, returnerar den det resulterande jobbet.If you start a runbook with PowerShell using Start-AzureRmAutomationRunbook, then it returns the resulting job. Använd Get-AzureRmAutomationJobOutput för att hämta jobbets utdata.Use Get-AzureRmAutomationJobOutput to get a job’s output.

Följande exempel kommandon hämtar det senaste jobbet för en exempel-Runbook och visar dess status, de värden som har angetts för Runbook-parametrarna och utdata från jobbet.The following sample commands retrieve the last job for a sample runbook and display its status, the values provided for the runbook parameters, and the output from the job.

$job = (Get-AzureRmAutomationJob –AutomationAccountName "MyAutomationAccount" `
–RunbookName "Test-Runbook" -ResourceGroupName "ResourceGroup01" | sort LastModifiedDate –desc)[0]
$job.Status
$job.JobParameters
Get-AzureRmAutomationJobOutput -ResourceGroupName "ResourceGroup01" `
–AutomationAccountName "MyAutomationAcct" -Id $job.JobId –Stream Output

I följande exempel hämtas utdata för ett särskilt jobb och returnerar varje post.The following sample retrieves the output for a specific job, and returns each record. Om det uppstod ett undantag för en av posterna skrivs undantaget ut i stället för värdet.In the case that there was an exception for one of the records, the exception is written out instead of the value. Det här beteendet är användbart eftersom undantag kan ge ytterligare information, som kanske inte loggas normalt under utdata.This behavior is useful as exceptions can provide additional information, which may not be logged normally during output.

$output = Get-AzureRmAutomationJobOutput -AutomationAccountName <AutomationAccountName> -Id <jobID> -ResourceGroupName <ResourceGroupName> -Stream "Any"
foreach($item in $output)
{
    $fullRecord = Get-AzureRmAutomationJobOutputRecord -AutomationAccountName <AutomationAccountName> -ResourceGroupName <ResourceGroupName> -JobId <jobID> -Id $item.StreamRecordId
    if ($fullRecord.Type -eq "Error")
    {
        $fullRecord.Value.Exception
    }
    else
    {
    $fullRecord.Value
    }
}

Hämta information från aktivitets loggenGet details from Activity log

Andra uppgifter, till exempel den person eller det konto som startade runbooken, kan hämtas från aktivitets loggen för Automation-kontot.Other details such as the person or account that started the runbook can be retrieved from the Activity log for the automation account. Följande PowerShell-exempel ger den senaste användaren att köra runbooken i fråga:The following PowerShell example provides the last user to run the runbook in question:

$SubID = "00000000-0000-0000-0000-000000000000"
$AutomationResourceGroupName = "MyResourceGroup"
$AutomationAccountName = "MyAutomationAccount"
$RunbookName = "MyRunbook"
$StartTime = (Get-Date).AddDays(-1)
$JobActivityLogs = Get-AzureRmLog -ResourceGroupName $AutomationResourceGroupName -StartTime $StartTime `
                                | Where-Object {$_.Authorization.Action -eq "Microsoft.Automation/automationAccounts/jobs/write"}

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

    if ($JobInfo[$log.SubmissionTimestamp] -eq $null -and $JobResource.Properties.runbook.name -eq $RunbookName)
    {
        # Get runbook
        $Runbook = Get-AzureRmAutomationJob -ResourceGroupName $AutomationResourceGroupName -AutomationAccountName $AutomationAccountName `
                                            -Id $JobResource.Properties.jobId | ? {$_.RunbookName -eq $RunbookName}

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

Skälig delningFair share

Om du vill dela resurser mellan alla Runbooks i molnet Azure Automation du tillfälligt tar bort eller stoppar jobb som har körts i mer än tre timmar.To share resources among all runbooks in the cloud, Azure Automation temporarily unloads or stops any job that has run for more than three hours. Jobb för PowerShell-baserade Runbooks och python-Runbooks stoppas och startas inte om, och jobb status visas som stoppad.Jobs for PowerShell-based runbooks and Python runbooks are stopped and not restarted, and the job status shows Stopped.

För tids krävande uppgifter rekommenderar vi att du använder en hybrid Runbook Worker.For long running tasks, it's recommended to use a Hybrid Runbook Worker. Hybrid Runbook Worker begränsas inte av en rättvis resurs och har ingen begränsning för hur länge en Runbook kan köras.Hybrid Runbook Workers aren't limited by fair share, and don't have a limitation on how long a runbook can execute. De andra jobb gränserna gäller för både Azure-Sandbox och hybrid Runbook Worker.The other job limits apply to both Azure sandboxes and Hybrid Runbook Workers. Även om hybrid Runbook Worker inte begränsas av den högsta gränsen på 3 timmar, bör Runbooks som körs på dem utvecklas för att stödja omstarts beteenden från oväntade problem med lokal infrastruktur.While Hybrid Runbook Workers aren't limited by the 3 hour fair share limit, runbooks run on them should be developed to support restart behaviors from unexpected local infrastructure issues.

Ett annat alternativ är att optimera runbooken genom att använda underordnade Runbooks.Another option is to optimize the runbook by using child runbooks. Om din Runbook upprepas genom samma funktion på flera resurser, till exempel en databas åtgärd på flera databaser, kan du flytta den funktionen till en underordnad Runbook och anropa den med cmdleten Start-AzureRMAutomationRunbook .If your runbook loops through the same function on several resources, such as a database operation on several databases, you can move that function to a child runbook and call it with the Start-AzureRMAutomationRunbook cmdlet. Var och en av dessa underordnade Runbooks körs parallellt i separata processer.Each of these child runbooks executes in parallel in separate processes. Det här beteendet minskar den totala tiden som den överordnade runbooken slutförs.This behavior decreases the total amount of time for the parent runbook to complete. Du kan använda cmdleten Get-AzureRmAutomationJob i din Runbook för att kontrol lera jobb status för varje underordnat objekt om det finns åtgärder som utförs när den underordnade Runbook-flödet har slutförts.You can use the Get-AzureRmAutomationJob cmdlet in your runbook to check the job status for each child if there are operations that perform after the child runbook completes.

Nästa stegNext steps

  • Mer information om de olika metoder som kan användas för att starta en Runbook i Azure Automation finns i starta en Runbook i Azure AutomationTo learn more about the different methods that can be used to start a runbook in Azure Automation, see Starting a runbook in Azure Automation
  • Mer information om PowerShell, inklusive språk referens-och inlärnings moduler finns i PowerShell-dokumenten.For more information on PowerShell, including language reference and learning modules, refer to the PowerShell Docs.