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, bem como os padrões e as práticas recomendadas com o design do runbook. Você pode encontrar todos os detalhes sobre o acesso a runbooks e a módulos da comunidade em Galerias de runbook e 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. Quando o runbook tiver sido criado, você pode editá-lo usando informações contidas em:

• Editar runbooks de texto na Automação do Azure
• Aprender sobre os principais conceitos de Fluxo de Trabalho do PowerShell para runbooks de Automação
• Gerenciar pacotes do Python 2 no Automação do Azure
• Gerenciar pacotes do Python 3 (versão prévia) na Automação do Azure

Criar um runbook no portal do Azure

1. Entre no portal do Azure.
2. Pesquise e escolha Contas de Automação.
3. Na página Contas de Automação, escolha sua conta de Automação na lista.
4. Na Conta de automação, selecione Runbooks em Automação de Processos para abrir a lista de runbooks.
5. Clique em Criar um runbook.
   1. Nomeie o runbook.
   2. Na lista suspensa Tipo de runbook, selecione o tipo. O nome do runbook precisa começar com uma letra e pode conter letras, números, sublinhados e traços
   3. Selecione a Versão do runtime
   4. Insira uma Descrição aplicável
6. 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 parâmetro Type 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 do PowerShell ou do Fluxo de Trabalho do PowerShell (.ps1), um runbook gráfico (.graphrunbook) ou um script Python 2 ou Python 3 (.py) para criar seu runbook. Você especifica o tipo de runbook que é criado durante a importação, levando em consideração os aspectos a seguir.

• Você pode importar um arquivo .ps1 que não contém um fluxo de trabalho em um runbook do PowerShell ou em um runbook do Fluxo de Trabalho do PowerShell. Se você importá-lo para um runbook do 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 que contenha um Fluxo de Trabalho do PowerShell em um runbook do Fluxo de Trabalho do PowerShell. Se o arquivo contiver vários fluxos de trabalho do PowerShell, a importação falhará. Você deve salvar cada fluxo de trabalho em seu próprio arquivo e importá-los separadamente.

• Não importe um arquivo .ps1 que contenha um fluxo de trabalho do PowerShell para um runbook do PowerShell, pois o mecanismo de script do PowerShell não pode reconhecê-lo.

• Importe somente 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.

1. No portal do Azure, procure e selecione Contas de Automação.
2. Na página Contas de Automação, selecione sua conta de Automação na lista.
3. Na Conta de automação, selecione Runbooks em Automação de Processos para abrir a lista de runbooks.
4. Clique em Importar um runbook. Você pode selecionar uma das seguintes opções:
   1. Procurar arquivo – Seleciona um arquivo do computador local.
   2. Procurar na Galeria – Você pode procurar e selecionar um runbook existente na galeria.
5. Selecione o arquivo .
6. Se o campo Nome estiver ativado, você poderá alterar o nome do runbook. O nome deve começar com uma letra e pode conter letras, números, sublinhados e traços.
7. O Tipo de runbook é populado automaticamente, mas você pode alterá-lo depois de considerar as restrições aplicáveis.
8. A Versão do runtime é populada automaticamente ou você pode escolhê-la na lista suspensa.
9. Clique em Importar. O novo runbook aparece na lista de runbooks da conta de automação.
10. É necessário publicar o runbook antes de executá-lo.

Importar um runbook com o PowerShell

Use o cmdlet Import-AzAutomationRunbook para importar um arquivo de script como um rascunho do runbook. Se o runbook já existir, a importação falhará a menos que você use o parâmetro Force 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 seu runbook criar um recurso, o script deverá 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 log de atividades

Você pode recuperar detalhes do runbook, como a pessoa ou conta que iniciou um runbook, no Log de atividades da conta da Automação. O exemplo a seguir do PowerShell 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 de natureza modular, com lógica que pode ser reutilizada e reiniciada facilmente. O acompanhamento do progresso em um runbook garante que a lógica do runbook seja executada corretamente se houver problemas.

Você pode acompanhar o progresso do runbook usando uma fonte externa, como contas de armazenamento, um banco de dados ou arquivos compartilhados. Crie lógica no seu runbook para verificar primeiro 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 de forma estranha se estiverem sendo 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 pelo sistema, deixe o código no estado em que se encontra. Se você preferir usar uma identidade gerenciada atribuída pelo usuário, então:

1. Na linha 5, remova $AzureContext = (Connect-AzAccount -Identity).context,
2. Substitua-o por $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context e
3. Insira a ID do cliente.

Lidar com erros transitórios em um script dependente de tempo

Seus runbooks devem ser robustos e capazes de lidar com erros, incluindo erros transitórios que podem causar a reinicialização ou falha. Se um runbook falhar, a automação do Azure tentará novamente.

Se seu runbook normalmente for 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 horários específicos.

Repetir lógica no runbook para evitar falhas transitórias

Os runbooks geralmente fazem chamadas para sistemas remotos, como o Azure via 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 ficam vulneráveis a erros de runtime. Para criar resiliência nos runbooks, você deve implementar a lógica de repetição ao fazer as chamadas para que os runbooks possam lidar com um problema transitório sem falha.

Para obter mais informações, consulte Padrão de repetição e Diretrizes gerais de repetição e REST.

Exemplo 1: se o 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

Ao chamar Invoke-AzureRmResourceAction, você poderá 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)

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 runtime. Crie uma função que implementa a lógica de repetição para 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, passe cada chamada remota para a função como

ResilientRemoteCall { Get-AzVm } ou

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

Como trabalhar com várias assinaturas

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 pelo sistema, deixe o código no estado em que se encontra. Se você preferir usar uma identidade gerenciada atribuída pelo usuário, então:

1. Na linha 5, remova $AzureContext = (Connect-AzAccount -Identity).context,
2. Substitua-o por $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context e
3. Insira a ID do cliente.

Trabalhar com um script personalizado

Para usar um script personalizado:

1. Criar uma conta de Automação.
2. Implantar a função do Hybrid Runbook Worker.
3. Se estiver em um computador Linux, você precisa de privilégio elevado. Se conecte para desativar as verificações de assinatura.

Testar um runbook

Quando você testa um runbook, a Versão de rascunho é executada e as ações que ela realiza são concluídas. Nenhum histórico de trabalho é criado, mas os fluxos de saída e aviso e erro são exibidos no painel Saída de teste. As mensagens para o fluxo detalhado serão exibidas no painel Saída somente se a variável VerbosePreference for definida para Continue.

Mesmo que a versão de Rascunho esteja em execução, o runbook ainda será executado normalmente e executará qualquer ação nos recursos do ambiente. Por esse motivo, você deve testar apenas runbooks nos recursos de não produção.

O procedimento para testar cada tipo de runbook é o mesmo. Não há nenhuma diferença entre testar o editor de texto e o editor gráfico no portal do Azure.

1. Abra a versão de Rascunho do runbook no editor de texto ou no editor gráfico.
2. Clique em Testar para abrir a página de Teste.
3. Se o runbook tiver parâmetros, eles serão listados no painel à esquerda, onde você pode fornecer valores a serem usados para o teste.
4. Se você quiser executar o teste em um Hybrid Runbook Worker, altere Configurações da Execução para Hybrid Worker e selecione o nome do grupo de destino. Caso contrário, mantenha o padrão Azure para executar o teste na nuvem.
5. Clique em Iniciar para iniciar o teste.
6. Você pode usar os botões no painel Saída para interromper ou suspender um Fluxo de Trabalho do PowerShell ou um runbook gráfico enquanto está sendo testado. Quando você suspende o runbook, ele conclui a atividade atual antes de ser suspenso. Após o runbook ser suspenso, você pode interrompê-lo ou reiniciá-lo.
7. Inspecione a saída do runbook no painel Saída.

Publicar um runbook

Quando você criar ou importar um novo runbook, deverá publicá-lo antes de poder executá-lo. Cada runbook na Automação do Azure tem uma versão de Rascunho e uma versão Publicada. Somente a versão Publicada está disponível para ser executada, e somente a versão de Rascunho pode ser editada. A versão Publicada não é afetada pelas alterações feitas na 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

1. No portal do Azure, procure e selecione Contas de Automação.
2. Na página Contas de Automação, selecione sua conta de Automação na lista.
3. Abra o runbook em sua conta de Automação.
4. Clique em Editar.
5. Clique em Publicar e em 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 o runbook tiver sido publicado, você poderá agendá-lo para a operação:

1. No portal do Azure, procure e selecione Contas de Automação.
2. Na página Contas de Automação, selecione sua conta de Automação na lista.
3. Selecione o runbook na lista de runbooks.
4. Selecione Agendamentos em Recursos.
5. Selecione Adicionar um agendamento.
6. No painel Agendar Runbook, selecione Vincular um agendamento ao runbook.
7. Escolha Criar um agendamento no painel Agendamento.
8. Insira um nome, uma descrição e outros parâmetros no painel Novo agendamento.
9. Depois que o agendamento for criado, realce-o e clique em OK. Agora ele deve estar vinculado ao seu runbook.
10. Procure um email na 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, certifique-se de que as seguintes condições sejam atendidas:

• Os runbooks a serem restaurados foram excluídos nos últimos 29 dias.
• A conta da Automação para esse runbook existe.
• A permissão de função Colaborador da Automação foi concedida à identidade gerenciada atribuída pelo sistema da conta de Automação.

Script do PowerShell

• Execute o script do PowerShell como um trabalho em sua conta da Automação para restaurar os runbooks excluídos.
• Baixe o script do PowerShell no GitHub. Como alternativa, você pode importar o script do PowerShell chamado Restaurar runbook da Automação da Galeria de Runbooks. Forneça o nome do runbook que deve ser restaurado e execute-o como um trabalho na Automação do Azure para restaurar os runbooks excluídos.
• Baixe o script no GitHub ou importe o script do PowerShell chamado Listar runbook da Automação excluído da Galeria de Runbooks, para identificar os nomes dos runbooks excluídos nos últimos 29 dias.

Obter status de trabalho

Exibir status no portal do Azure

Detalhes do tratamento de trabalhos 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 da Automação. À direita, você pode ver um resumo de todos os trabalhos do runbook em Estatísticas de Trabalho.

O resumo exibe a contagem e a representação gráfica do status do trabalho para todos os trabalhos executados.

Clicar no bloco apresenta a página Trabalhos, que contém uma lista resumida de todos os trabalhos executados. Esta página mostra o status, o nome do runbook, a hora de início e o tempo de conclusão de cada trabalho.

Você pode filtrar a lista de trabalhos selecionando Filtrar trabalhos. Filtre um runbook específico, status do trabalho ou uma opção na lista suspensa e forneça o intervalo de tempo para a pesquisa.

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 da Automação e selecionando Trabalhos. Essa ação apresenta a página Trabalhos. A partir daqui, você pode clicar em um registro de trabalho para exibir 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-AzAutomationRunbook, 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 exemplo de runbook e exibe seu status, os valores fornecidos para os parâmetros de 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óximas etapas

• Para consultas de exemplo, confira Consultas de exemplo para logs de trabalho e fluxos de trabalho
• Para obter detalhes sobre o gerenciamento de runbooks, confira Execução de runbooks na Automação do Azure.
• Para preparar um runbook do PowerShell, confira Editar runbooks textuais na Automação do Azure.
• Para solucionar problemas com a execução do runbook, confira Solução de problemas de runbook.