Execução de runbook na Automação do AzureRunbook execution in Azure Automation

Quando você inicia um runbook na Automação do Azure, um trabalho é criado.When you start a runbook in Azure Automation, a job is created. Um trabalho é uma instância única de execução de um runbook.A job is a single execution instance of a runbook. Um trabalhador da Automação do Azure é atribuído para executar cada tarefa.An Azure Automation worker is assigned to run each job. Enquanto os trabalhadores são compartilhados por muitas contas do Azure, os trabalhos de diferentes contas de automação ficam isolados uns dos outros.While workers are shared by many Azure accounts, jobs from different Automation accounts are isolated from one another. Você não tem controle sobre qual trabalhador atende a solicitação do seu trabalho.You don't have control over which worker services the request for your job. Um único runbook pode ter muitos trabalhos em execução ao mesmo tempo.A single runbook can have many jobs running at one time. O ambiente de execução para trabalhos da mesma conta de Automação do Azure pode ser reutilizado.The execution environment for jobs from the same Automation Account may be reused. Quanto mais trabalhos você executar ao mesmo tempo, mais frequentemente eles poderão ser enviados à mesma área restrita.The more jobs you run at the same time, the more often they can be dispatched to the same sandbox. Trabalhos em execução no mesmo processo de área restrita podem afetar uns aos outros, sendo um exemplo a execução do cmdlet Disconnect-AzureRMAccount.Jobs running in the same sandbox process can affect each other, one example is running the Disconnect-AzureRMAccount cmdlet. Executar este cmdlet desconectaria cada trabalho de runbook no processo de área restrita compartilhado.Running this cmdlet would disconnect each runbook job in the shared sandbox process. Quando você exibe a lista de runbooks no Portal do Azure, ela lista o status de todos os trabalhos iniciados para cada 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. Você pode exibir a lista de trabalhos para cada runbook para acompanhar o status de cada um.You can view the list of jobs for each runbook to track the status of each. Os logs de trabalho são armazenados por 30 dias, no máximo.Job logs are stored for a max of 30 days. Para obter uma descrição das diferentes opções de status de trabalho, confira Status de trabalho.For a description of the different job statuses Job Statuses.

Observação

Se você estiver interessado em exibir ou excluir os dados pessoais, consulte Solicitações do Azure Data Subject para o artigo do GDPR.If you’re interested in viewing or deleting personal data, please see the Azure Data Subject Requests for the GDPR article. Se você estiver buscando informações gerais sobre o GDPR, confira a Seção do GDPR do portal de Confiança do Serviço.If you’re looking for general info about GDPR, see the GDPR section of the Service Trust portal.

O diagrama a seguir mostra o ciclo de vida de um trabalho de runbook para runbooks do PowerShell, runbooks gráficos e runbooks de fluxo de trabalho do PowerShell.The following diagram shows the lifecycle of a runbook job for PowerShell runbooks, Graphical runbooks and PowerShell Workflow runbooks.

Status de trabalho - Fluxo de trabalho do PowerShell

Os trabalhos têm acesso aos recursos do Azure fazendo uma conexão à sua assinatura do Azure.Your jobs have access to your Azure resources by making a connection to your Azure subscription. Eles só têm acesso aos recursos no seu data center se estes puderem ser acessados da nuvem pública.They only have access to resources in your data center if those resources are accessible from the public cloud.

Onde executar seus runbooksWhere to run your runbooks

Os runbooks na Automação do Azure podem ser executados em uma área restrita no Azure ou em um Hybrid Runbook Worker.Runbooks in Azure Automation can run on either a sandbox in Azure or a Hybrid Runbook Worker. Uma área restrita é um ambiente compartilhado no Azure que pode ser usado por vários trabalhos.A sandbox is a shared environment in Azure that can be used by multiple jobs. Os trabalhos que usam a mesma área restrita são restringidos pelas limitações de recurso da área restrita.Jobs using the same sandbox are bound by the resource limitations of the sandbox. Hybrid Runbook Workers podem executar runbooks diretamente no computador que está hospedando a função e em relação aos recursos no ambiente para gerenciar esses recursos locais.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 são armazenados e gerenciados na Automação do Azure e, em seguida, entregues a um ou mais computadores atribuídos.Runbooks are stored and managed in Azure Automation and then delivered to one or more assigned computers. A maioria dos runbooks facilmente podem ser executados em áreas restritas do Azure.Most runbooks can easily be run in the Azure sandboxes. Há cenários específicos em que pode ser recomendada a escolha de um Hybrid Runbook ao invés de uma área restrita do Azure para execução do seu runbook.There are specific scenarios where choosing a Hybrid Runbook over an Azure sandbox to execute your runbook may be recommended. Veja a seguinte tabela com uma lista de alguns exemplos de cenário:See the following table for a list of some example scenarios:

TarefaTask Melhor opçãoBest Choice ObservaçõesNotes
Integração com serviços do AzureIntegrate with Azure resources Área restrita do AzureAzure Sandbox Com hospedagem no Azure, a autenticação é mais simples.Hosted in azure, authentication is simpler. Se você está usando o Hybrid Runbook Worker em uma VM do Azure, é possível usar identidades gerenciadas para recursos do AzureIf you are using a Hybrid Runbook Worker on an Azure VM, you can use managed identities for Azure resources
Desempenho ideal para gerenciar recursos do AzureOptimal performance to manage azure resources Área restrita do AzureAzure Sandbox Script é executado no mesmo ambiente, que por sua vez, tem menos latênciaScript is run in the same environment, which in turn has less latency
Redução de custos operacionaisMinimize operational costs Área restrita do AzureAzure Sandbox Não há sobrecarga de computação, nem a necessidade de uma VMThere is no compute overhead, no need for a VM
Script de execução prolongadaLong running script Hybrid Runbook WorkerHybrid Runbook Worker Áreas restritas do Azure têm limitação de recursosAzure sandboxes have limitation on resources
Interação com serviços locaisInteract with Local services Hybrid Runbook WorkerHybrid Runbook Worker Pode ter acesso diretamente ao computador hostCan have access directly to host machine
Exigência de software de terceiros e executáveisRequire 3rd party software and executables Hybrid Runbook WorkerHybrid Runbook Worker Você gerencia o SO e pode instalar softwareYou manage the OS and can install software
Monitoramento de um arquivo ou uma pasta com um runbookMonitor a file or folder with a runbook Hybrid Runbook WorkerHybrid Runbook Worker Use uma tarefa do Inspetor em um Hybrid Runbook WorkerUse a Watcher task on a Hybrid Runbook worker
O script usa muitos recursosResource intensive script Hybrid Runbook WorkerHybrid Runbook Worker Áreas restritas do Azure têm limitação de recursosAzure sandboxes have limitation on resources
Uso de módulos com requisitos específicosUsing modules with specific requirements Hybrid Runbook WorkerHybrid Runbook Worker Alguns exemplos incluem:Some examples are:
WinSCP: dependência de winscp.exeWinSCP - dependency on winscp.exe
IISAdministration: necessidade de que o IIS seja desabilitadoIISAdministration - Needs IIS to be enabled
Instalação do módulo que requer o instaladorInstall module that requires installer Hybrid Runbook WorkerHybrid Runbook Worker Módulos para a área restrita devem ser pode ser copiadosModules for sandbox must be copiable
Uso de runbooks ou módulos que exigem o .NET Framework diferente da versão 4.7.2Using runbooks or modules that require .NET Framework different from 4.7.2 Hybrid Runbook WorkerHybrid Runbook Worker Áreas restritas da Automação têm o .NET Framework 4.7.2 e não há maneira de atualizá-loAutomation sandboxes have .NET Framework 4.7.2, and there is no way to upgrade it
Scripts que exigem elevaçãoScripts that require elevation Hybrid Runbook WorkerHybrid Runbook Worker As áreas restritas não permitir a elevação.Sandboxes do not allow elevation. Para resolver isso, use um Hybrid Runbook Worker e você pode desativar o UAC e usar Invoke-Command quando executar o comando que exige elevaçãoTo solve this, use a Hybrid Runbook Worker and you can turn off UAC and use Invoke-Command when running the command that requires elevation
Scripts que exigem acesso ao WMIScripts that require access to WMI Hybrid Runbook WorkerHybrid Runbook Worker Trabalhos executados em áreas de segurança na nuvem não tem acesso ao WMIJobs running in sandboxes in the cloud do not have access to the WMI

Comportamento do runbookRunbook behavior

Os runbooks são executados com base na lógica que é definida dentro deles.Runbooks execute based on the logic that is defined inside them. Se um runbook é interrompido, ele é reiniciado no início.If a runbook is interrupted, the runbook restarts at the beginning. Esse comportamento exige que os runbooks sejam escritos de maneira a permitir a reinicialização em caso de problemas transitórios.This behavior requires runbooks to be written in a way where they support being restarted if there were transient issues.

Trabalhos do PowerShell iniciados a partir de um Runbook foi executado no Azure área restrita não podem ser executadas no modo de linguagem completa.PowerShell jobs started from a Runbook ran in an Azure sandbox may not run in the Full language mode. Para saber mais sobre os modos de linguagem do PowerShell, consulte modos de linguagem do PowerShell.To learn more about PowerShell language modes, see PowerShell language modes. Para obter detalhes adicionais sobre como interagir com os trabalhos na automação do Azure, consulte recuperando o status do trabalho com o PowerShellFor additional details on how to interact with jobs in Azure Automation, see Retrieving job status with PowerShell

Criar recursosCreating resources

Se o seu script cria recursos, você deve verificar se o recurso já existe antes de tentar criá-lo novamente.If your script creates resources, you should check to see if the resource already exists before attempting to create it again. Um exemplo básico é mostrado no seguinte exemplo: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"
    }

Scripts dependentes de tempoTime dependant scripts

É preciso ponderar cuidadosamente ao criar runbooks.Careful consideration should be made when authoring runbooks. Como mencionado anteriormente, os runbooks precisam ser criados de maneira que sejam robustos e possam tratar de erros transitórios que podem fazer com que o runbook reinicie ou falhe.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. Se um runbook falhar, ela será repetida.If a runbook fails, it is retried. Se um runbook normalmente é executado dentro de uma restrição de tempo, a lógica para verificar o tempo de execução deve ser implementado no runbook para garantir operações como início, desligadas ou escalar horizontalmente são executados somente durante horários específicos.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.

Observação

A hora local em que o processo de área restrita do Azure é definida como hora UTC.The local time on the Azure sandbox process is set to UTC time. Cálculos de data e hora em seus runbooks precisam levar isso em consideração.Calculations for date and time in your runbooks need to take this into consideration.

Acompanhar o progressoTracking progress

Uma boa prática é criar runbooks para que sejam modulares por natureza.It is a good practice to author runbooks to be modular in nature. Isso significa estruturar a lógica no runbook de modo que ele possa ser reutilizado e reiniciado facilmente.This means structuring the logic in the runbook such that it can be reused and restarted easily. Acompanhar o progresso em um runbook é uma boa maneira de garantir que a lógica em um runbook execute corretamente se houver problemas.Tracking progress in a runbook is a good way to ensure that the logic in a runbook executes correctly if there were issues. Algumas maneiras possíveis de acompanhar o progresso do runbook é usar uma fonte externa, como contas de armazenamento, um banco de dados ou arquivos compartilhados.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. Acompanhando o estado externamente, você pode criar lógica em seu runbook para primeiro verificar o estado da última ação que levou o runbook.By tracking the state externally, you can create logic in your runbook to first check the state of the last action the runbook took. Em seguida, com base em resultados, ignorar ou continuar tarefas específicas no runbook.Then based off the results, either skip or continue specific tasks in the runbook.

Evitar trabalhos simultâneosPrevent concurrent jobs

Alguns runbooks podem se comportar de forma estranha se estiverem sendo executados em vários trabalhos ao mesmo tempo.Some runbooks may behave strangely if they are running across multiple jobs at the same time. Nesse caso, é importante implementar a lógica para verificar se um runbook já tem um trabalho em execução.In this case, it's important to implement logic to check to see if a runbook already has a running job. Um exemplo básico de como você pode reproduzir esse comportamento é mostrado no seguinte exemplo: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
}

Trabalhando com várias assinaturasWorking with multiple subscriptions

Quando se cria runbooks que lidam com várias assinaturas, o runbook precisa usar o Disable-AzureRmContextAutosave cmdlet para garantir que seu contexto de autenticação não é recuperado de outro runbook que pode ser em execução na mesma área de segurança.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. Em seguida, você precisa usar o -AzureRmContext parâmetro no seu AzureRM cmdlets e passá-lo em seu contexto adequado.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

Tratamento de exceçõesHandling exceptions

Ao criar scripts, é importante ser capaz de lidar com exceções e falhas potenciais de intermitentes.When authoring scripts, it is important to be able to handle exceptions and potential intermittent failures. A seguir está algumas maneiras diferentes para lidar com problemas de intermitentes com seus runbooks ou exceções:The following are some different ways to handle exceptions or intermittent issues with your runbooks:

$ErrorActionPreference$ErrorActionPreference

O $ErrorActionPreference variável de preferência determina como o PowerShell responde a um erro não fatal.The $ErrorActionPreference preference variable determines how PowerShell responds to a non-terminating error. Erros de finalização não são afetados por $ErrorActionPreference, eles sempre encerra.Terminating errors are not affected by $ErrorActionPreference, they always terminate. Usando $ErrorActionPreference, como um erro não fatal normalmente PathNotFound do Get-ChildItem cmdlet irá parar o runbook de ser concluída.By using $ErrorActionPreference, a normally non-terminating error like PathNotFound from the Get-ChildItem cmdlet will stop the runbook from completing. O exemplo a seguir mostra o uso $ErrorActionPreference.The following example shows using $ErrorActionPreference. O último Write-Output linha nunca será executado conforme o script será interrompido.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"

Try-Catch FinallyTry Catch Finally

Try Catch é usado em scripts do PowerShell para ajudá-lo a lidar com erros de finalização.Try Catch is used in PowerShell scripts to help you handle terminating errors. Usando Try Catch, você pode capturar exceções específicas ou exceções gerais.By using Try Catch, you can catch specific exceptions or general exceptions. A instrução Catch deve ser usada para rastrear erros ou para tentar tratar o erro.The Catch statement should be used to track errors or used to try to handle the error. O exemplo a seguir tenta baixar um arquivo que não existe.The following example tries to download a file that does not exist. Ele captura o System.Net.WebException exceção, se houver outra exceção, o último valor é retornado.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."
}

ThrowThrow

Lançar pode ser usado para gerar um erro de encerramento.Throw can be used to generate a terminating error. Isso pode ser útil ao definir sua própria lógica em um runbook.This can be useful when defining your own logic in a runbook. Se um determinado critério for atendido que deve interromper o script, você pode usar throw para interromper o script.If a certain criteria is met that should stop the script, you can use throw to stop the script. A exemplo a seguir mostra um parâmetro de função necessário por meio da máquina throw.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
}

Usar executáveis ou chamar processosUsing executables or calling processes

Runbooks executados em áreas restritas do Azure não dão suporte a processos de chamada (por exemplo, um .exe ou subprocess.call).Runbooks run in Azure sandboxes do not support calling processes (such as an .exe or subprocess.call). Isso ocorre porque as áreas restritas do Azure são processos compartilhados que são executados em contêineres, que podem não ter acesso a todas as APIs subjacentes.This is because Azure sandboxes are shared processes run in containers, which may not have access to all the underlying APIs. Para cenários em que são necessários softwares de terceiros ou a chamada de subprocessos, é recomendável executar o runbook em um 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.

Características de dispositivo e aplicativoDevice and application characteristics

Trabalhos de runbook executados em áreas restritas do Azure não tem acesso a quaisquer características de dispositivo ou aplicativo.Runbook jobs run in Azure sandboxes do not have access to any device or application characteristics. A API mais comuns usada para métricas de desempenho de consulta no Windows é o WMI.The most common API used to query performance metrics on Windows is WMI. Algumas dessas métricas comuns são o uso da memória e CPU.Some of these common metrics are memory and CPU usage. No entanto, não importa qual API é usada.However, it does not matter what API is used. Trabalhos em execução na nuvem não tem acesso à implementação Microsoft da Web com base em WBEM (Enterprise Management), que é criado sobre o Common informações de CIM (modelo), que são os padrões do setor para definir as características de dispositivo e aplicativo.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.

Status de trabalhoJob statuses

A tabela a seguir descreve os diferentes status possíveis para um trabalho.The following table describes the different statuses that are possible for a job. O PowerShell tem dois tipos de erros, erros de finalização e sem finalização.PowerShell has two types of errors, terminating and non-terminating errors. Erros de finalização definem o status do runbook como Falhou, caso ocorram.Terminating errors set the runbook status to Failed if they occur. Erros sem finalização permitem que o script continue mesmo depois de ocorrerem.Non-terminating errors allow the script to continue even after they occur. Um exemplo de um erro sem finalização é usar o cmdlet Get-ChildItem com um caminho que não existe.An example of a non-terminating error is using the Get-ChildItem cmdlet with a path that doesn't exist. O PowerShell vê que o caminho não existe, gera um erro e continua até a próxima pasta.PowerShell sees that the path doesn't exist, throws an error, and continues to the next folder. Esse erro não definiria o status do runbook como Falhou e poderia ser marcado como Concluído.This error wouldn't set the runbook status to Failed and could be marked as Completed. Para forçar um runbook a parar se houver um erro sem finalização, você pode usar -ErrorAction Stop no cmdlet.To force a runbook to stop on a non-terminating error, you can use -ErrorAction Stop on the cmdlet.

StatusStatus DESCRIÇÃODescription
ConcluídoCompleted Operação concluída com sucesso.The job completed successfully.
Com falhaFailed Para runbooks gráficos e de fluxo de trabalho do PowerShell, o runbook falhou ao compilar.For Graphical and PowerShell Workflow runbooks, the runbook failed to compile. Para runbooks de Script do PowerShell, o runbook falhou ao iniciar ou o trabalho sofreu uma exceção.For PowerShell Script runbooks, the runbook failed to start or the job had an exception.
Erro, aguardando recursosFailed, waiting for resources O trabalho falhou porque atingiu o limite de fração justa três vezes e iniciou do mesmo ponto de verificação ou desde o início do runbook em cada uma das vezes.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.
Em filaQueued O trabalho está aguardando recursos de um trabalho do Automation ficar disponível para que ele possa ser iniciado.The job is waiting for resources on an Automation worker to come available so that it can be started.
IniciandoStarting O trabalho foi atribuído a um trabalhador e o sistema está iniciando-o.The job has been assigned to a worker, and the system is starting it.
ContinuandoResuming O sistema está retomando o trabalho depois que ele ter sido suspenso.The system is resuming the job after it was suspended.
ExecutandoRunning O trabalho está em execução.The job is running.
Executando, aguardando recursosRunning, waiting for resources O trabalho foi descarregado, pois atingiu o limite de fração justa .The job has been unloaded because it reached the fair share limit. Ele será retomado em breve do seu último ponto de verificação.It resumes shortly from its last checkpoint.
ParadoStopped O trabalho foi interrompido pelo usuário antes de ser concluído.The job was stopped by the user before it was completed.
ParandoStopping O sistema está parando o trabalho.The system is stopping the job.
SuspensoSuspended O trabalho foi suspenso pelo usuário, pelo sistema ou por um comando no runbook.The job was suspended by the user, by the system, or by a command in the runbook. Se um runbook não tiver um ponto de verificação, ele começará desde o início do runbook.If a runbook doesn't have a checkpoint, it starts from the beginning of the runbook. Se ele tiver um ponto de verificação, poderá iniciar novamente e retomar no último ponto de verificação.If it has a checkpoint, it can start again and resume from its last checkpoint. O runbook só é suspenso pelo sistema quando ocorre uma exceção.The runbook is only suspended by the system when an exception occurs. Por padrão, ErrorActionPreference é definido como Continuar o que significa que o trabalho continua a ser executado no caso de um erro.By default, ErrorActionPreference is set to Continue, meaning that the job keeps running on an error. Se essa variável de preferência for definida como Parar, o trabalho será suspenso no caso de um erro.If this preference variable is set to Stop, then the job suspends on an error. Aplica-se a somente runbooks gráficos e de fluxo de trabalho do PowerShell.Applies to Graphical and PowerShell Workflow runbooks only.
SuspensãoSuspending O sistema está tentando suspender o trabalho por solicitação do usuário.The system is trying to suspend the job at the request of the user. O runbook precisa atingir seu próximo ponto de verificação antes de poder ser suspenso.The runbook must reach its next checkpoint before it can be suspended. Se já passou de seu último ponto de verificação, ele será concluído antes de ser suspenso.If it already passed its last checkpoint, then it completes before it can be suspended. Aplica-se a somente runbooks gráficos e de fluxo de trabalho do PowerShell.Applies to Graphical and PowerShell Workflow runbooks only.

Exibindo o status do trabalho no portal do AzureViewing job status from the Azure portal

Você pode exibir um status resumido de todos os trabalhos do runbook ou analisar os detalhes de um trabalho específico do runbook no portal do Azure.You can view a summarized status of all runbook jobs or drill into details of a specific runbook job in the Azure portal. Você também pode configurar a integração com o seu espaço de trabalho do Log Analytics a fim de encaminhar fluxos de trabalho e status do trabalho do runbook.You can also configure integration with your Log Analytics workspace to forward runbook job status and job streams. Para obter mais informações sobre a integração com os logs do Azure Monitor, consulte encaminhar status do trabalho e fluxos de trabalho de automação para logs do Azure Monitor.For more information about integrating with Azure Monitor logs, see Forward job status and job streams from Automation to Azure Monitor logs.

Resumo dos trabalhos de runbook da AutomaçãoAutomation runbook jobs summary

À direita da conta de Automação selecionada, é possível ver um resumo de todos os trabalhos de runbook no bloco Estatísticas de Trabalho.On the right of your selected Automation account, you can see a summary of all the runbook jobs under Job Statistics tile.

Bloco Estatísticas de Trabalho

Esse bloco exibe a contagem e a representação gráfica do status do trabalho para todos os trabalhos executados.This tile displays a count and graphical representation of the job status for all jobs executed.

Clicar no bloco apresenta a página Trabalhos, que contém uma lista resumida de todos os trabalhos executados.Clicking the tile presents the Jobs page, which includes a summarized list of all jobs executed. Esta página mostra o status, os horários de início e os horários de término.This page shows the status, start times, and completion times.

Página Trabalhos da conta de automação

Você pode filtrar a lista de trabalhos selecionando Filtrar trabalhos e filtrar em um runbook específico, status de trabalho ou lista suspensa pelo intervalo de hora dentro do qual pesquisar.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.

Filtrar por status do Trabalho

Como alternativa, você pode exibir detalhes de resumo do trabalho para um runbook específico selecionando esse runbook na página Runbooks da sua conta de Automação e selecionando o bloco Trabalhos.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. Essa ação apresenta a página Trabalhos e, nela, é possível clicar no registro do trabalho para exibir seus detalhes e seu resultado.This action presents the Jobs page, and from there you can click the job record to view its detail and output.

Página Trabalhos da conta de automação

Resumo do trabalhoJob Summary

Você pode exibir uma lista de todos os trabalhos que foram criados para um determinado runbook e o status mais recente deles.You can view a list of all the jobs that have been created for a particular runbook and their most recent status. Você pode filtrar essa lista pelo status do trabalho e o intervalo de datas para a última alteração no trabalho.You can filter this list by job status and the range of dates for the last change to the job. Para exibir as informações detalhadas e o resultado, clique no nome de um trabalho.To view its detailed information and output, click the name of a job. A exibição detalhada do trabalho inclui os valores para os parâmetros de runbook que foram fornecidos para esse trabalho.The detailed view of the job includes the values for the runbook parameters that were provided to that job.

Você pode usar as etapas a seguir para exibir os trabalhos de um runbook.You can use the following steps to view the jobs for a runbook.

  1. No Portal do Azure, selecione Automação e, em seguida, selecione no nome de uma Conta de automação.In the Azure portal, select Automation and then select the name of an Automation account.
  2. No hub, selecione Runbooks e, em seguida, na página Runbooks, selecione um runbook da lista.From the hub, select Runbooks and then on the Runbooks page select a runbook from the list.
  3. Na página do runbook selecionado, clique no bloco Trabalhos.On the page for the selected runbook, click the Jobs tile.
  4. Clique em um dos trabalhos na lista e, na página de detalhes do trabalho do runbook, você pode exibir seus detalhes e resultados.Click one of the jobs in the list and on the runbook job details page you can view its detail and output.

Recuperando o status do trabalho usando o PowerShellRetrieving job status using PowerShell

Você pode usar o Get-AzureRmAutomationJob para recuperar os trabalhos criados para um runbook e os detalhes de um trabalho específico.You can use the Get-AzureRmAutomationJob to retrieve the jobs created for a runbook and the details of a particular job. Se você iniciar um runbook com o PowerShell usando Start-AzureRmAutomationRunbook, ele retornará o trabalho resultante.If you start a runbook with PowerShell using Start-AzureRmAutomationRunbook, then it returns the resulting job. Use Get-AzureRmAutomationJobOutput para obter a saída de um trabalho.Use Get-AzureRmAutomationJobOutput to get a job’s output.

Os comandos de exemplo a seguir recuperam o último trabalho para um exemplo de runbook e exibe seu status, os valores fornecidos para os parâmetros de runbook e a saída do trabalho.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

O exemplo a seguir recupera a saída de um trabalho específico e retorna cada registro.The following sample retrieves the output for a specific job, and returns each record. No caso de que houve uma exceção para um dos registros, a exceção é gravada em vez do valor.In the case that there was an exception for one of the records, the exception is written out instead of the value. Esse comportamento é útil como exceções podem fornecer informações adicionais que não podem ser registradas normalmente durante a saída.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
    }
}

Obter detalhes do log de atividadesGet details from Activity log

Outros detalhes, como o usuário ou conta que iniciou o runbook, podem ser recuperados do log de atividades da conta de automação.Other details such as the person or account that started the runbook can be retrieved from the Activity log for the automation account. O exemplo do PowerShell a seguir fornece o último usuário a executar o runbook em questão: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

fração justaFair share

Para compartilhar recursos entre todos os runbooks na nuvem, a automação do Azure temporariamente descarrega ou interrompe qualquer trabalho que foi executado por mais de três horas.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. Os trabalhos para runbooks com base em PowerShell e runbooks Python são interrompidos e não são reiniciados, e o status do trabalho é mostrado como Parado.Jobs for PowerShell-based runbooks and Python runbooks are stopped and not restarted, and the job status shows Stopped.

Para tarefas de execução prolongada, é recomendável usar um Hybrid Runbook Worker.For long running tasks, it's recommended to use a Hybrid Runbook Worker. Os Hybrid Runbook Workers não são limitados por fração justa e não limitam o tempo de execução de um runbook.Hybrid Runbook Workers aren't limited by fair share, and don't have a limitation on how long a runbook can execute. Os outros limites do trabalho se aplicam a áreas restritas do Azure e ao Hybrid Runbook Workers.The other job limits apply to both Azure sandboxes and Hybrid Runbook Workers. Enquanto o Hybrid Runbook Workers não são limitados pelo limite de fração justa de 3 horas, runbooks executados nesses computadores devem ser desenvolvidos para oferecer suporte a comportamentos de reinicialização de problemas de infraestrutura local inesperada.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.

Outra opção é otimizar o runbook usando runbooks filho.Another option is to optimize the runbook by using child runbooks. Se o runbook percorre continuamente a mesma função em diversos recursos, como uma operação de banco de dados em vários bancos de dados, você pode mover essa função para um runbook filho e chamá-la com o cmdlet 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. Cada um desses runbooks filho é executado em paralelo em processos separados.Each of these child runbooks executes in parallel in separate processes. Esse comportamento reduz a quantidade total de tempo para o runbook pai concluir.This behavior decreases the total amount of time for the parent runbook to complete. Você pode usar o Get-AzureRmAutomationJob cmdlet em seu runbook para verificar o status do trabalho para cada filho, se houver operações que executar após a conclusão do runbook filho.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.

Próximas etapasNext steps