Gerenciar runbooks na Automação do Azure
Você pode adicionar um runbook à Automação do Azure criando um novo ou importando um existente de um arquivo ou da Galeria de Runbooks. Este artigo fornece informações para gerenciar um runbook e padrões recomendados e práticas recomendadas com design de runbook. Você pode encontrar todos os detalhes de acesso a runbooks e módulos da comunidade em Runbook e galerias de módulos para a Automação do Azure.
Criar um runbook
Crie um novo runbook na Automação do Azure usando o portal do Azure ou o PowerShell. Uma vez que o runbook tenha sido criado, você pode editá-lo usando informações em:
- Editar runbook textual na Automação do Azure
- Aprenda os principais conceitos de fluxo de trabalho do PowerShell para runbooks de automação
- Gerir pacotes Python 2 na Automatização do Azure
- Gerenciar pacotes Python 3 (visualização) na Automação do Azure
Criar um runbook no portal do Azure
- Inicie sessão no portal do Azure.
- Procure e selecione Contas de Automatização.
- Na página Contas de Automatização, selecione a sua conta de Automatização a partir da lista de contas de Automatização.
- Na conta Automação, selecione Runbooks em Process Automation para abrir a lista de runbooks.
- Clique em Criar um runbook.
- Nomeie o runbook.
- Na lista suspensa Tipo de runbook. Selecione seu tipo. O nome do runbook deve começar com uma letra e pode conter letras, números, sublinhados e traços
- Selecione a versão do Runtime
- Insira a descrição aplicável
- Clique em Criar para criar o runbook.
Criar um runbook com o PowerShell
Use o cmdlet New-AzAutomationRunbook para criar um runbook vazio. Use o Type parâmetro para especificar um dos tipos de runbook definidos para New-AzAutomationRunbook.
O exemplo a seguir mostra como criar um novo runbook vazio.
$params = @{
AutomationAccountName = 'MyAutomationAccount'
Name = 'NewRunbook'
ResourceGroupName = 'MyResourceGroup'
Type = 'PowerShell'
}
New-AzAutomationRunbook @params
Importar um runbook
Você pode importar um script PowerShell ou PowerShell Workflow (.ps1), um runbook gráfico (.graphrunbook) ou um script Python 2 ou Python 3 (.py) para criar seu próprio runbook. Você especifica o tipo de runbook que é criado durante a importação, levando em consideração as seguintes considerações.
Você pode importar um arquivo .ps1 que não contenha um fluxo de trabalho para um runbook do PowerShell ou um runbook do Fluxo de Trabalho do PowerShell. Se você importá-lo para um runbook de fluxo de trabalho do PowerShell, ele será convertido em um fluxo de trabalho. Nesse caso, os comentários são incluídos no runbook para descrever as alterações feitas.
Você pode importar apenas um arquivo .ps1 contendo um Fluxo de Trabalho do PowerShell para um runbook do Fluxo de Trabalho do PowerShell. Se o arquivo contiver vários fluxos de trabalho do PowerShell, a importação falhará. Você precisa salvar cada fluxo de trabalho em seu próprio arquivo e importar cada um separadamente.
Não importe um arquivo .ps1 contendo um Fluxo de Trabalho do PowerShell para um runbook do PowerShell, pois o mecanismo de script do PowerShell não pode reconhecê-lo.
Importe apenas um arquivo .graphrunbook para um novo runbook gráfico.
Importar um runbook do portal do Azure
Você pode usar o procedimento a seguir para importar um arquivo de script para a Automação do Azure.
Nota
Você só pode importar um arquivo .ps1 para um runbook de fluxo de trabalho do PowerShell usando o portal.
- Na portal do Azure, procure e selecione Contas de Automatização.
- Na página Contas de Automatização, selecione a sua conta de Automatização a partir da lista de contas de Automatização.
- Na conta Automação, selecione Runbooks em Process Automation para abrir a lista de runbooks.
- Clique em Importar um runbook. Você pode selecionar uma das seguintes opções:
- Procurar arquivo - seleciona um arquivo de sua máquina local.
- Navegar a partir da Galeria - Você pode navegar e selecionar um runbook existente na galeria.
- Selecione o arquivo.
- Se o campo Nome estiver habilitado, você terá a opção de alterar o nome do runbook. O nome deve começar com uma letra e pode conter letras, números, sublinhados e traços.
- O tipo Runbook é preenchido automaticamente, mas você pode alterar o tipo depois de levar em conta as restrições aplicáveis.
- A versão do Runtime é preenchida automaticamente ou escolhe a versão na lista suspensa.
- Clique em Importar. O novo runbook aparece na lista de runbooks para a conta Automatização.
- Tem de publicar o runbook antes de o poder executar.
Nota
Depois de importar um runbook gráfico, você pode convertê-lo em outro tipo. No entanto, não é possível converter um runbook gráfico em um runbook textual.
Importar um runbook com o PowerShell
Use o cmdlet Import-AzAutomationRunbook para importar um arquivo de script como um runbook de rascunho. Se o runbook já existir, a importação falhará, a menos que você use o Force parâmetro com o cmdlet.
O exemplo a seguir mostra como importar um arquivo de script para um runbook.
$params = @{
AutomationAccountName = 'MyAutomationAccount'
Name = 'Sample_TestRunbook'
ResourceGroupName = 'MyResourceGroup'
Type = 'PowerShell'
Path = 'C:\Runbooks\Sample_TestRunbook.ps1'
}
Import-AzAutomationRunbook @params
Lidar com recursos
Se o runbook criar um recurso, o script deve verificar se o recurso já existe antes de tentar criá-lo. Aqui está um exemplo básico.
$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"
}
Recuperar detalhes do registro de atividades
Você pode recuperar detalhes do runbook, como a pessoa ou conta que iniciou um runbook, no log de atividades da conta de automação. O exemplo do PowerShell a seguir fornece o último usuário a executar o runbook especificado.
$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
Controlar o progresso
É uma boa prática criar seus runbooks para serem modulares por natureza, com lógica que pode ser reutilizada e reiniciada facilmente. Acompanhar o progresso em um runbook garante que a lógica do runbook seja executada corretamente se houver problemas.
Você pode acompanhar o progresso de um runbook usando uma fonte externa, como uma conta de armazenamento, um banco de dados ou arquivos compartilhados. Crie lógica em seu runbook para primeiro verificar o estado da última ação executada. Em seguida, com base nos resultados da verificação, a lógica pode ignorar ou continuar tarefas específicas no runbook.
Evitar trabalhos simultâneos
Alguns runbooks se comportam estranhamente se forem executados em vários trabalhos ao mesmo tempo. Nesse caso, é importante que um runbook implemente a lógica para determinar se já existe um trabalho em execução. Aqui está um exemplo básico.
# 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.."
}
Se você quiser que o runbook seja executado com a identidade gerenciada atribuída ao sistema, deixe o código como está. Se preferir usar uma identidade gerenciada atribuída pelo usuário, então:
- Da linha 5, retire,
$AzureContext = (Connect-AzAccount -Identity).context - Substitua-o por
$AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context, e - Insira a ID do cliente.
Nota
Para trabalhos híbridos do PowerShell 7.2, faça alterações na linha 28. Substituir $PSPrivateMetadata.JobId.Guid por $env:PSPrivateMetaData.
Manipular erros transitórios em um script dependente do tempo
Seus runbooks devem ser robustos e capazes de lidar com erros, incluindo erros transitórios que podem fazer com que eles sejam reiniciados ou falhem. Se um runbook falhar, a Automação do Azure tentará novamente.
Se o seu runbook normalmente é executado dentro de uma restrição de tempo, faça com que o script implemente a lógica para verificar o tempo de execução. Essa verificação garante a execução de operações como inicialização, desligamento ou expansão somente durante momentos específicos.
Nota
A hora local no processo de sandbox do Azure é definida como UTC. Os cálculos de data e hora em seus runbooks devem levar esse fato em consideração.
Adicionar lógica de repetição no runbook para evitar falhas transitórias
Os runbooks geralmente fazem chamadas para sistemas remotos, como o Azure através de ARM, Azure Resource Graph, serviços SQL e outros serviços Web. Quando o sistema que os runbooks estão chamando está ocupado, temporariamente indisponível ou implementando a limitação sob carga, as chamadas são vulneráveis a ter erros de tempo de execução. Para criar resiliência nos runbooks, deve implementar a lógica de repetição ao fazer as chamadas para que os runbooks possam lidar com um problema transitório sem falhar.
Para obter mais informações, consulte Padrão de repetição e Diretrizes gerais de REST e repetição.
Exemplo 1: Se o seu runbook fizer apenas uma ou duas chamadas
$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
Quando você liga Invoke-AzureRmResourceActionpara o , você pode observar falhas transitórias. Nesse cenário, recomendamos que você implemente o seguinte padrão básico em torno da chamada para o cmdlet.
$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)
Nota
A tentativa de repetir a chamada é de até três vezes, dormindo por 30 segundos de cada vez.
Exemplo 2: Se o runbook estiver fazendo chamadas remotas frequentes
Se o runbook estiver fazendo chamadas remotas frequentes, ele poderá enfrentar problemas transitórios de tempo de execução. Crie uma função que implemente a lógica de repetição para cada chamada feita e passe a chamada a ser feita como um bloco de script a ser executado.
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)
}
Em seguida, você pode passar cada chamada remota para a função como
ResilientRemoteCall { Get-AzVm }
quer
ResilientRemoteCall { $searchAPIKey = (Invoke-AzureRmResourceAction -Action listAdminKeys -ResourceId $resource.ResourceId -ApiVersion 2015-08-19 -Force).PrimaryKey}
Trabalhar com várias subscrições
Seu runbook deve ser capaz de trabalhar com assinaturas. Por exemplo, para lidar com várias assinaturas, o runbook usa o cmdlet Disable-AzContextAutosave . Esse cmdlet garante que o contexto de autenticação não seja recuperado de outro runbook em execução na mesma área restrita.
# 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
Se você quiser que o runbook seja executado com a identidade gerenciada atribuída ao sistema, deixe o código como está. Se preferir usar uma identidade gerenciada atribuída pelo usuário, então:
- Da linha 5, retire,
$AzureContext = (Connect-AzAccount -Identity).context - Substitua-o por
$AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context, e - Insira a ID do cliente.
Trabalhar com um script personalizado
Nota
Normalmente, não é possível executar scripts e runbooks personalizados no host com um agente do Log Analytics instalado.
Para usar um script personalizado:
- Criar uma conta de Automatização.
- Implante a função Hybrid Runbook Worker .
- Se estiver em uma máquina Linux, você precisa de privilégios elevados. Inicie sessão para desativar as verificações de assinatura.
Testar um runbook
Quando você testa um runbook, a versão de rascunho é executada e todas as ações que ele executa são concluídas. Nenhum histórico de trabalho é criado, mas os fluxos de saída, aviso e erro são exibidos no painel Saída de teste. As mensagens para o fluxo detalhado são exibidas no painel Saída somente se a variável VerbosePreference estiver definida como Continue.
Mesmo que a versão de rascunho esteja sendo executada, o runbook ainda é executado normalmente e executa todas as ações contra recursos no ambiente. Por esse motivo, você só deve testar runbooks em recursos que não sejam de produção.
Nota
Todas as ações de execução do runbook são registradas no Log de Atividades da conta de automação com o nome da operação Criar um trabalho de Automação do Azure. No entanto, a execução do runbook em um painel de teste onde a versão de rascunho do runbook é executada seria registrada nos logs de atividade com o nome da operação Write an Azure Automation runbook draft. Selecione a guia Operação e JSON para ver o escopo terminando com .. /runbooks/(nome do runbook)/draft/testjob.
O procedimento para testar cada tipo de runbook é o mesmo. Não há diferença nos testes entre o editor de texto e o editor gráfico no portal do Azure.
- Abra a versão de rascunho do runbook no editor de texto ou no editor gráfico.
- Clique em Testar para abrir a página Teste.
- Se o runbook tiver parâmetros, estes estão listados no painel esquerdo, onde pode fornecer os valores a utilizar no teste.
- Se você quiser executar o teste em um Hybrid Runbook Worker, altere as Configurações de Execução para Hybrid Worker e selecione o nome do grupo de destino. Caso contrário, mantenha o Azure padrão para executar o teste na nuvem.
- Clique em Iniciar para iniciar o teste.
- Você pode usar os botões no painel Saída para parar ou suspender um Fluxo de Trabalho do PowerShell ou um runbook gráfico enquanto ele está sendo testado. Quando suspende o runbook, este conclui a atividade que estava em curso antes de ser suspenso. Uma vez que o runbook é suspenso, você pode pará-lo ou reiniciá-lo.
- Inspecione a saída do runbook no painel Saída .
Publicar um runbook
Quando cria ou importa um novo runbook, tem de publicá-lo antes de o poder executar. Cada runbook na Automação do Azure tem uma versão de rascunho e uma versão publicada. Apenas a versão publicada está disponível para ser executada e só a versão de rascunho pode ser editada. A versão publicada não é afetada por quaisquer alterações feitas à versão de rascunho. Quando a versão de rascunho deve ser disponibilizada, você a publica, substituindo a versão publicada atual pela versão de rascunho.
Publicar um runbook no portal do Azure
- Na portal do Azure, procure e selecione Contas de Automatização.
- Na página Contas de Automatização, selecione a sua conta de Automatização a partir da lista de contas de Automatização.
- Abra o runbook na sua conta de Automatização.
- Clique em Editar.
- Clique em Publicar e selecione Sim em resposta à mensagem de verificação.
Publicar um runbook usando o PowerShell
Use o cmdlet Publish-AzAutomationRunbook para publicar seu runbook.
$accountName = "MyAutomationAccount"
$runbookName = "Sample_TestRunbook"
$rgName = "MyResourceGroup"
$publishParams = @{
AutomationAccountName = $accountName
ResourceGroupName = $rgName
Name = $runbookName
}
Publish-AzAutomationRunbook @publishParams
Agendar um runbook no portal do Azure
Quando seu runbook tiver sido publicado, você poderá programá-lo para operação:
- Na portal do Azure, procure e selecione Contas de Automatização.
- Na página Contas de Automatização, selecione a sua conta de Automatização a partir da lista de contas de Automatização.
- Selecione o runbook na sua lista de runbooks.
- Selecione Agendas em Recursos.
- Selecione Adicionar uma agenda.
- No painel Agendar Runbook, selecione Vincular uma agenda ao seu runbook.
- Escolha Criar uma nova agenda no painel Agenda .
- Insira um nome, uma descrição e outros parâmetros no painel Nova agenda .
- Assim que a agenda for criada, destaque-a e clique em OK. Agora ele deve ser vinculado ao seu runbook.
- Procure um e-mail em sua caixa de correio para notificá-lo sobre o status do runbook.
Restaurar runbook excluído
Você pode recuperar um runbook excluído por meio de scripts do PowerShell. Para recuperar um runbook, verifique se as seguintes condições são atendidas:
- Os runbooks a serem restaurados foram excluídos nos últimos 29 dias.
- A conta de automação para esse runbook existe.
- A permissão da função Colaborador de Automação é concedida à identidade gerenciada atribuída ao Sistema da conta de Automação.
Script do PowerShell
- Execute o script do PowerShell como um trabalho em sua conta de automação para restaurar os runbooks excluídos.
- Baixe o script do PowerShell do GitHub. Como alternativa, você pode importar o script do PowerShell chamado Restore Automation runbook da Runbook Gallery. Forneça o nome do runbook a ser restaurado e execute-o como um trabalho na Automação do Azure para restaurar os runbooks excluídos.
- Baixe o script do GitHub ou importe o script do PowerShell chamado List Deleted Automation Runbook da Runbook Gallery para identificar os nomes dos runbooks que foram excluídos nos últimos 29 dias.
Obter status de trabalho
Exibir status no portal do Azure
Os detalhes da manipulação de tarefas na Automação do Azure são fornecidos em Trabalhos. Quando estiver pronto para ver seus trabalhos de runbook, use o portal do Azure e acesse sua conta de automação. À direita, você pode ver um resumo de todos os trabalhos runbook em Estatísticas de trabalho.
O resumo exibe uma contagem e representação gráfica do status do trabalho para cada trabalho executado.
Clicar no bloco apresenta a página Trabalhos, que inclui uma lista resumida de todos os trabalhos executados. Esta página mostra o status, o nome do runbook, a hora de início e a hora de conclusão de cada trabalho.
Você pode filtrar a lista de trabalhos selecionando Filtrar trabalhos. Filtre um runbook específico, o status do trabalho ou uma escolha na lista suspensa e forneça o intervalo de tempo para a pesquisa.
Como alternativa, você pode exibir os detalhes do resumo do trabalho para um runbook específico selecionando esse runbook na página Runbooks na sua conta de automação e, em seguida, selecionando Jobs. Esta ação apresenta a página Empregos. A partir daqui, você pode clicar em um registro de trabalho para visualizar seus detalhes e saída.
Recuperar status de trabalho usando o PowerShell
Use o cmdlet Get-AzAutomationJob para recuperar os trabalhos criados para um runbook e os detalhes de um trabalho específico. Se você iniciar um runbook usando Start-AzAutomationRunbooko , ele retornará o trabalho resultante. Use Get-AzAutomationJobOutput para recuperar a saída do trabalho.
O exemplo a seguir obtém o último trabalho para um runbook de exemplo e exibe seu status, os valores fornecidos para os parâmetros do runbook e a saída do trabalho.
$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
O exemplo a seguir recupera a saída de um trabalho específico e retorna cada registro. Se houver uma exceção para um dos registros, o script gravará a exceção em vez do valor. Esse comportamento é útil, pois as exceções podem fornecer informações adicionais que podem não ser registradas normalmente durante a saída.
$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
}
}
Próximos passos
- Para consultas de exemplo, consulte Consultas de exemplo para logs de trabalho e fluxos de trabalho
- Para saber detalhes do gerenciamento de runbook, consulte Execução de runbook na Automação do Azure.
- Para preparar um runbook do PowerShell, consulte Editar runbooks textuais na Automação do Azure.
- Para solucionar problemas com a execução do runbook, consulte Solucionar problemas do runbook.