• O AWS Systems Manager CloudWatch Dashboard não estará mais disponível a partir de 30 de abril de 2026. Os clientes podem continuar usando o console do Amazon CloudWatch para visualizar, criar e gerenciar os painéis do Amazon CloudWatch exatamente como fazem hoje. Para obter mais informações, consulte a [documentação do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
# Experiência de design visual para runbooks de automação
O AWS Systems Manager Automation fornece uma experiência de design visual de baixo código que ajuda você a criar runbooks de automação. A experiência de design visual fornece uma interface simples de arrastar e soltar com a opção de adição do seu próprio código para que você possa criar e editar runbooks mais facilmente. Com a experiência de design visual, você pode fazer o seguinte:
+ Controlar instruções condicionais.
+ Controlar como a entrada e a saída são filtradas ou transformadas para cada ação.
+ Configurar o tratamento de erros.
+ Criar protótipos de novos runbooks.
+ Usar seus protótipos de runbooks como ponto de partida para o desenvolvimento local com o AWS Toolkit for Visual Studio Code.
Ao criar ou editar um runbook, você pode acessar a experiência de design visual no [console do Automation](https://console.aws.amazon.com/systems-manager/automation/home?region=us-east-1#/). À medida que você cria um runbook, a experiência de design visual valida seu trabalho e gera código automaticamente. Você pode revisar o código gerado ou exportá-lo para desenvolvimento local. Ao terminar, você pode salvar seu runbook, executá-lo e examinar os resultados no console do Systems Manager Automation.
**Topics**
+ [Visão geral da interface](visual-designer-interface-overview.md)
+ [Usar a experiência de design visual](visual-designer-use.md)
+ [Configurar entradas e saídas](visual-designer-action-inputs-outputs.md)
+ [Tratamento de erros com a experiência de design visual](visual-designer-error-handling.md)
+ [Tutorial: criar um runbook usando a experiência de design visual](visual-designer-tutorial.md)
# Visão geral da interface de experiência de design visual
A experiência de design visual do Systems Manager Automation é um designer de fluxo de trabalho visual de baixo código que ajuda você a criar runbooks de automação.
Conheça a experiência de design visual com uma visão geral dos componentes da interface:
![\[Componentes da experiência de design visual\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_overview.png)
+ O navegador **Ações** contém as guias **Ações**, **APIs da AWS** e **Runbooks**.
+ A *tela* é onde você arrasta e solta ações no gráfico do fluxo de trabalho, altera a ordem das ações e seleciona ações para configurar ou visualizar.
+ O painel **Formulário** é onde você pode visualizar e editar as propriedades de qualquer ação selecionada na tela. Selecione a opção **Conteúdo** para visualizar o YAML ou o JSON do seu runbook, com a ação atualmente selecionada destacada.
Os links de **Informações** abrem um painel com informações contextuais quando você precisa de ajuda. Esses painéis também incluem links para tópicos relacionados na documentação do Systems Manager Automation.
## Navegador Ações
No navegador **Ações**, é possível selecionar ações para arrastar e soltar no gráfico do fluxo de trabalho. Você pode pesquisar todas as ações usando o campo de pesquisa na parte superior do navegador **Ações**. O navegador **Ações** contém as seguintes guias:
+ A guia **Ações** fornece uma lista de ações de automação que você pode arrastar e soltar no gráfico do fluxo de trabalho do seu runbook na tela.
+ A guia **APIs da AWS** fornece uma lista de APIs da AWS que você pode arrastar e soltar no gráfico do fluxo de trabalho do seu runbook na tela.
+ A guia **Runbooks** fornece vários runbooks prontos para uso e reutilizáveis como blocos de construção que você pode usar em uma variedade de casos de uso. Por exemplo, você pode usar runbooks para realizar tarefas comuns de remediação em instâncias do Amazon EC2 em seu fluxo de trabalho sem precisar recriar as mesmas ações.
![\[Experiência de design visual: navegador Ações\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_actions_multi_view.png)
## Canvas
Depois de escolher uma ação para adicionar à sua automação, arraste-a para a tela e solte-a no gráfico do fluxo de trabalho. Você também pode arrastar e soltar ações para movê-las para lugares diferentes no fluxo de trabalho do seu runbook. Se o seu fluxo de trabalho for complexo, talvez não seja possível visualizar tudo no painel da tela. Use os controles na parte superior da tela para aumentar ou diminuir o zoom. Para visualizar diferentes partes de um fluxo de trabalho, é possível arrastar o gráfico do fluxo de trabalho na tela.
Arraste uma ação do navegador **Ações** e solte-a no gráfico do fluxo de trabalho do seu runbook. Uma linha mostra onde ela será colocada no fluxo de trabalho. Para alterar a ordem de uma ação, é possível arrastá-la para um local diferente no seu fluxo de trabalho. A nova ação foi adicionada ao seu fluxo de trabalho e seu código é gerado automaticamente.
![\[Experiência de design visual: Tela\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_canvas.png)
## Formulário
Após adicionar uma ação ao seu fluxo de trabalho do runbook, você pode configurá-la para atender ao seu caso de uso. Escolha a ação que você deseja configurar e você verá seus parâmetros e opções no painel **Formulário**. Você também pode ver o código YAML ou JSON escolhendo a opção **Conteúdo**. O código associado à ação que você selecionou é destacado.
![\[Experiência de design visual: painel Formulário\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_form.png)
![\[Experiência de design visual: painel Conteúdo\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_content.png)
## Atalhos de teclado
A experiência de design visual é compatível com os atalhos de teclado mostrados na tabela a seguir.
| Atalho de teclado | Função |
| --- | --- |
| Ctrl\$1Z | Desfazer a operação mais recente. |
| Ctrl\$1Shift\$1Z | Refazer a operação mais recente. |
| Alt\$1C | Centralizar o fluxo de trabalho na tela. |
| Backspace | Remover todos os estados selecionados. |
| Delete | Remover todos os estados selecionados. |
| Ctrl\$1D | Duplicar o estado selecionado. |
# Usar a experiência de design visual
Aprenda a criar, editar e executar fluxos de trabalho do runbook usando a experiência de design visual. Depois que seu fluxo de trabalho estiver pronto, você poderá salvá-lo ou exportá-lo. Você também pode usar a experiência de design visual para prototipagem rápida.
## Criar um runbook
1. Faça login no [console do Systems Manager Automation](https://console.aws.amazon.com/systems-manager/automation/home?region=us-east-1#/).
1. Escolha **Criar runbook**.
1. Na caixa **Nome**, insira um nome para o runbook, por exemplo, `MyNewRunbook`.
1. Ao lado do botão **Design** e **Código**, selecione o ícone de lápis e insira um nome para o seu runbook.
Agora você pode criar um fluxo de trabalho para seu novo runbook.
## Desenvolver um runbook
Para criar um fluxo de trabalho de runbook usando a experiência de design visual, arraste uma ação de automação do navegador **Ações** para a tela, colocando-a onde desejar no fluxo de trabalho do seu runbook. Você também pode reordenar as ações em seu fluxo de trabalho arrastando-as para um local diferente. Quando você arrasta uma ação para a tela, uma linha aparece nos locais em que é possível soltar a ação no fluxo de trabalho. Após uma ação ser colocada na tela, seu código é gerado automaticamente e adicionado ao conteúdo do seu runbook.
Se você souber o nome da ação que deseja adicionar, use a caixa de pesquisa na parte superior do navegador **Ações** para encontrá-la.
Depois de soltar uma ação na tela, configure-a usando o painel **Formulário** à direita. Esse painel contém as guias **Geral**, **Entradas**, **Saídas** e **Configuração** para cada ação de automação ou ação de API que você coloca na tela. Por exemplo, a guia **Geral** consiste nas seguintes seções:
+ O **Nome da etapa** identifica a etapa. Especifique um valor exclusivo para o nome da etapa.
+ A **Descrição** ajuda você a descrever o que a ação está fazendo no fluxo de trabalho do seu runbook.
A guia **Entradas** contém campos que variam com base na ação. Por exemplo, a ação de automação `aws:executeScript` consiste nas seguintes seções:
+ O **Runtime** é a linguagem que será usada para executar o script fornecido.
+ O **Manipulador** é o nome da sua função. É necessário garantir que a função definida no manipulador tenha dois parâmetros: `events` e `context`. O runtime do PowerShell não é compatível com este parâmetro.
+ O **Script** é um script incorporado que você deseja executar durante o fluxo de trabalho.
+ (Opcional) O **Anexo** é para scripts autônomos ou arquivos.zip que podem ser invocados pela ação. Esse parâmetro é obrigatório para runbooks JSON.
A guia **Saídas** ajuda a especificar os valores que você deseja gerar de uma ação. Você pode referenciar valores de saída em ações posteriores do seu fluxo de trabalho ou gerar resultados de ações para fins de registro. Nem todas as ações terão uma guia **Saídas** porque nem todas as ações oferecem suporte a saídas. Por exemplo, a ação `aws:pause` não aceita saídas. Para ações que oferecem suporte a saídas, a guia **Saídas** consiste nas seguintes seções:
+ O **Nome** é o nome a ser usado para o valor de saída. Você pode referenciar saídas em ações posteriores do seu fluxo de trabalho.
+ O **Seletor** é uma string de expressão JSONPath que começa com `"$."` e é usada para selecionar um ou mais componentes em um elemento JSON.
+ O **Tipo** é o tipo de dados para o valor de saída. Por exemplo, o tipo de dados `String` ou `Integer`.
A guia **Configuração** contém propriedades e opções que todas as ações de automação podem usar. A ação consiste nas seguintes seções:
+ A propriedade **Máximo de tentativas** é o número tentativas de executar uma ação em caso de falha.
+ A propriedade **Tempo limite em segundos** especifica o valor do tempo limite para uma ação.
+ A propriedade **É crítica** determina se a falha na ação interrompe toda a automação.
+ A propriedade **Próxima etapa** determina qual ação a automação executará em seguida no runbook.
+ A propriedade **Em falha** determina qual ação a automação executará em seguida no runbook se a ação falhar.
+ A propriedade **Em cancelamento** determina qual ação a automação executará em seguida no runbook se a ação for cancelada por um usuário.
Para excluir uma ação, você pode usar o backspace, a barra de ferramentas acima da tela ou clicar com o botão direito do mouse e escolher **Excluir ação**.
À medida que seu fluxo de trabalho cresce, ele pode não caber na tela. Para ajudar a ajustar o fluxo de trabalho à tela, tente uma das opções a seguir:
+ Use os controles nos painéis laterais para redimensionar ou fechar os painéis.
+ Use a barra de ferramentas na parte superior da tela para ampliar ou reduzir o gráfico do fluxo de trabalho.
## Atualizar seu runbook
Você pode atualizar um fluxo de trabalho de runbook existente criando uma nova versão do seu runbook. As atualizações em seus runbooks podem ser feitas usando a experiência de design visual ou editando o código diretamente. Para atualizar um runbook existente, use o procedimento a seguir:
1. Faça login no [console do Systems Manager Automation](https://console.aws.amazon.com/systems-manager/automation/home?region=us-east-1#/).
1. Escolha o runbook que deseja atualizar.
1. Escolha **Create new version (Criar nova versão)**.
1. A experiência de design visual tem dois painéis: um painel de código e um painel de fluxo de trabalho visual. Escolha **Design** no painel de fluxo de trabalho visual para editar seu fluxo de trabalho com a experiência de design visual. Ao concluir, escolha **Criar nova versão** para salvar as alterações e sair.
1. (Opcional) Use o painel de código para editar o conteúdo do runbook em YAML ou JSON.
## Exportar seu runbook
Para exportar o código YAML ou JSON do fluxo de trabalho do seu runbook e também um gráfico do seu fluxo de trabalho, use o procedimento a seguir:
1. Escolha seu runbook no console **Documentos**.
1. Escolha **Create new version (Criar nova versão)**.
1. No menu suspenso **Ações**, escolha se você deseja exportar o gráfico ou o runbook, além do formato preferido.
# Configurar entradas e saídas para suas ações
Cada ação de automação responde com base na entrada recebida. Na maioria dos casos, você envia a saída para as ações subsequentes. Na experiência de design visual, é possível configurar os dados de entrada e saída de uma ação nas guias **Entradas** e **Saídas** do painel **Formulário**.
Para obter informações detalhadas sobre como definir e usar a saída para ações de automação, consulte [Uso de saídas de ações como entradas](automation-action-outputs-inputs.md).
## Forneça dados de entrada para uma ação
Cada ação de automação tem uma ou mais entradas para as quais você deve fornecer um valor. O valor que você fornece para a entrada de uma ação é determinado pelo tipo e formato de dados aceitos pela ação. Por exemplo, as ações `aws:sleep` exigem um valor de string formatado em ISO 8601 para a entrada `Duration`.
Geralmente, você usa ações no fluxo de trabalho do seu runbook que retornam a saída que você deseja usar em ações subsequentes. É importante garantir que seus valores de entrada estejam corretos para evitar erros no fluxo de trabalho do seu runbook. Os valores de entrada também são importantes porque determinam se a ação retorna a saída esperada. Por exemplo, ao usar a ação `aws:executeAwsApi`, você quer ter certeza de que está fornecendo o valor certo para a operação da API.
## Definir dados de saída para uma ação
Algumas ações de automação retornam a saída após realizar suas operações definidas. As ações que retornam uma saída têm saídas predefinidas ou permitem que você mesmo as defina. Por exemplo, a ação `aws:createImage` tem saídas predefinidas que retornam um `ImageId` e `ImageState`. Comparativamente, com a ação `aws:executeAwsApi`, você pode definir as saídas que deseja da operação de API especificada. Como resultado, você pode retornar um ou mais valores de uma única operação de API para usar em ações subsequentes.
Definir suas próprias saídas para uma ação de automação exige que você especifique um nome da saída, o tipo de dados e o valor da saída. Para continuar usando a ação `aws:executeAwsApi` como exemplo, digamos que você esteja chamando a operação da API `DescribeInstances` do Amazon EC2. Neste exemplo, você deseja retornar, ou gerar como saída, o `State` de uma instância do Amazon EC2 e ramificar o fluxo de trabalho do seu runbook com base na saída. Você escolhe nomear a saída **InstanceState** e usar o tipo de dados **String**.
O processo para definir o valor real da saída é diferente dependendo da ação. Por exemplo, se você estiver usando a ação `aws:executeScript`, deverá usar instruções `return` em suas funções para fornecer dados às saídas. Com outras ações como `aws:executeAwsApi`, `aws:waitForAwsResourceProperty` e `aws:assertAwsResourceProperty`, um `Selector` é necessário. O `Selector`, ou `PropertySelector` como algumas ações se referem a ele, é uma string JSONPath usada para processar a resposta JSON de uma operação de API. É importante entender como o objeto de resposta JSON de uma operação de API é estruturado para que você possa selecionar o valor correto para sua saída. Usando a operação de API `DescribeInstances` mencionada anteriormente, veja o exemplo de resposta JSON a seguir:
```
{
"reservationSet": {
"item": {
"reservationId": "r-1234567890abcdef0",
"ownerId": 123456789012,
"groupSet": "",
"instancesSet": {
"item": {
"instanceId": "i-1234567890abcdef0",
"imageId": "ami-bff32ccc",
"instanceState": {
"code": 16,
"name": "running"
},
"privateDnsName": "ip-192-168-1-88.eu-west-1.compute.internal",
"dnsName": "ec2-54-194-252-215.eu-west-1.compute.amazonaws.com",
"reason": "",
"keyName": "my_keypair",
"amiLaunchIndex": 0,
"productCodes": "",
"instanceType": "t2.micro",
"launchTime": "2018-05-08T16:46:19.000Z",
"placement": {
"availabilityZone": "eu-west-1c",
"groupName": "",
"tenancy": "default"
},
"monitoring": {
"state": "disabled"
},
"subnetId": "subnet-56f5f000",
"vpcId": "vpc-11112222",
"privateIpAddress": "192.168.1.88",
"ipAddress": "54.194.252.215",
"sourceDestCheck": true,
"groupSet": {
"item": {
"groupId": "sg-e4076000",
"groupName": "SecurityGroup1"
}
},
"architecture": "x86_64",
"rootDeviceType": "ebs",
"rootDeviceName": "/dev/xvda",
"blockDeviceMapping": {
"item": {
"deviceName": "/dev/xvda",
"ebs": {
"volumeId": "vol-1234567890abcdef0",
"status": "attached",
"attachTime": "2015-12-22T10:44:09.000Z",
"deleteOnTermination": true
}
}
},
"virtualizationType": "hvm",
"clientToken": "xMcwG14507example",
"tagSet": {
"item": {
"key": "Name",
"value": "Server_1"
}
},
"hypervisor": "xen",
"networkInterfaceSet": {
"item": {
"networkInterfaceId": "eni-551ba000",
"subnetId": "subnet-56f5f000",
"vpcId": "vpc-11112222",
"description": "Primary network interface",
"ownerId": 123456789012,
"status": "in-use",
"macAddress": "02:dd:2c:5e:01:69",
"privateIpAddress": "192.168.1.88",
"privateDnsName": "ip-192-168-1-88.eu-west-1.compute.internal",
"sourceDestCheck": true,
"groupSet": {
"item": {
"groupId": "sg-e4076000",
"groupName": "SecurityGroup1"
}
},
"attachment": {
"attachmentId": "eni-attach-39697adc",
"deviceIndex": 0,
"status": "attached",
"attachTime": "2018-05-08T16:46:19.000Z",
"deleteOnTermination": true
},
"association": {
"publicIp": "54.194.252.215",
"publicDnsName": "ec2-54-194-252-215.eu-west-1.compute.amazonaws.com",
"ipOwnerId": "amazon"
},
"privateIpAddressesSet": {
"item": {
"privateIpAddress": "192.168.1.88",
"privateDnsName": "ip-192-168-1-88.eu-west-1.compute.internal",
"primary": true,
"association": {
"publicIp": "54.194.252.215",
"publicDnsName": "ec2-54-194-252-215.eu-west-1.compute.amazonaws.com",
"ipOwnerId": "amazon"
}
}
},
"ipv6AddressesSet": {
"item": {
"ipv6Address": "2001:db8:1234:1a2b::123"
}
}
}
},
"iamInstanceProfile": {
"arn": "arn:aws:iam::123456789012:instance-profile/AdminRole",
"id": "ABCAJEDNCAA64SSD123AB"
},
"ebsOptimized": false,
"cpuOptions": {
"coreCount": 1,
"threadsPerCore": 1
}
}
}
}
}
}
```
No objeto de resposta JSON, a instância `State` está aninhada em um objeto `Instances` que está aninhado no objeto `Reservations`. Para retornar o valor da instância `State`, use a seguinte string para `Selector` para que o valor possa ser usado em nossa saída: **\$1.Reservations[0].Instances[0].State.Name**.
Para referenciar um valor de saída em ações subsequentes do fluxo de trabalho do seu runbook, o seguinte formato é usado: `{{ StepName.NameOfOutput }}`. Por exemplo, **\$1\$1 GetInstanceState.InstanceState \$1\$1**. Na experiência de design visual, é possível escolher valores de saída para usar em ações subsequentes utilizando o menu suspenso para a entrada. Ao usar saídas em ações subsequentes, o tipo de dados da saída deve corresponder ao tipo de dados da entrada. Neste exemplo, a saída `InstanceState` é uma `String`. Portanto, para usar o valor na entrada de uma ação subsequente, a entrada deve aceitar uma `String`.
# Tratamento de erros com a experiência de design visual
Por padrão, quando uma ação relata um erro, o Automation interrompe totalmente o fluxo de trabalho do runbook. Isso ocorre porque o valor padrão da propriedade `onFailure` em todas as ações é `Abort`. É possível configurar a forma como a automação lida com erros no fluxo de trabalho do seu runbook. Mesmo que você tenha configurado o tratamento de erros, alguns erros ainda podem causar uma falha na automação. Para obter mais informações, consulte [Solução de problemas do Systems Manager Automation](automation-troubleshooting.md). Na experiência de design visual, você configura o tratamento de erros no painel **Configuração**.
![\[Opções de tratamento de erros\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_error_handling.png)
## Repetir a ação em caso de erro
Para repetir uma ação em caso de erro, especifique um valor para a propriedade **Máximo de tentativas**. O valor padrão é 1. Se o valor for maior que 1, a etapa não será considerada como em falha até que todas as novas tentativas tenham falhado.
## Tempo limite
Você pode configurar um tempo limite para as ações para definir o número máximo de segundos que sua ação pode ser executada antes que ela falhe. Para configurar um tempo limite, insira o número de segundos que sua ação deve esperar antes que a ação falhe na propriedade **Tempo limite em segundos**. Se o tempo limite for atingido e o valor de `Max attempts` for maior que 1, a etapa não será considerada expirada até que todas as novas tentativas tenham sido feitas.
## Ações com falha
Por padrão, quando uma ação falha, o Automation interrompe totalmente o fluxo de trabalho do runbook. Você pode modificar esse comportamento especificando um valor alternativo para a propriedade **Em falha** das ações em seu runbook. Se desejar que o fluxo de trabalho continue na próxima etapa do runbook, escolha **Continuar**. Se desejar que o fluxo de trabalho pule para outra etapa subsequente no runbook, escolha **Etapa** e insira o nome da etapa.
## Ações canceladas
Por padrão, quando uma ação é cancelada por um usuário, o Automation interrompe totalmente o fluxo de trabalho do runbook. Você pode modificar esse comportamento especificando um valor alternativo para a propriedade **Em cancelamento** das ações em seu runbook. Se desejar que o fluxo de trabalho pule para outra etapa subsequente no runbook, escolha **Etapa** e insira o nome da etapa.
## Ações críticas
Você pode designar uma ação como *crítica*, o que significa que ela determina o status geral dos relatórios de sua automação. Se uma etapa com essa designação falhar, o Automation relatará o status final como `Failed`, independentemente do sucesso de outras ações. Para configurar uma ação como crítica, mantenha o valor padrão como **Verdadeiro** para a propriedade **É crítica**.
## Enceramento de ações
A propriedade **É o fim** interrompe automação no final de determinada ação. O valor padrão da propriedade é `false`. Se você configurar essa propriedade para uma ação, a automação será interrompida se a ação for bem-sucedida ou falhar. Essa propriedade é mais frequentemente usada com ações `aws:branch` para lidar com valores de entrada inesperados ou indefinidos. O exemplo a seguir mostra um runbook que espera um estado de instância de `running`, `stopping` ou `stopped`. Se uma instância estiver em um estado diferente, a automação será encerrada.
![\[A experiência de design visual é o exemplo final\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_is_end_example.png)
# Tutorial: criar um runbook usando a experiência de design visual
Neste tutorial, você aprenderá o básico de como trabalhar com a experiência de design visual fornecida pelo Systems Manager Automation. Na experiência de design visual, é possível criar um runbook que usa várias ações. Você usará o recurso de arrastar e soltar para organizar as ações na tela. Você também pesquisará, selecionará e configurará essas ações. Em seguida, você poderá visualizar o código YAML gerado automaticamente para o fluxo de trabalho do seu runbook, sair da experiência de design visual, executar o runbook e revisar os detalhes da execução.
Este tutorial também mostra como atualizar o runbook e visualizar a nova versão. No final do tutorial, você executa uma etapa de limpeza e exclui seu runbook.
Após concluir este tutorial, você saberá como usar a experiência de design visual para criar um runbook. Você também aprenderá a atualizar, executar e excluir seu runbook.
**nota**
Antes de começar este tutorial, certifique-se de concluir a [Configurar a automação](automation-setup.md).
**Topics**
+ [Etapa 1: navegue até a experiência de design visual](#navigate-console)
+ [Etapa 2: criar um fluxo de trabalho](#create-workflow)
+ [Etapa 3: analisar o código gerado automaticamente](#view-generated-code)
+ [Etapa 4: executar seu novo runbook](#use-tutorial-runbook)
+ [Etapa 5: limpar](#cleanup-tutorial-runbook)
## Etapa 1: navegue até a experiência de design visual
1. Faça login no [console do Systems Manager Automation](https://console.aws.amazon.com/systems-manager/automation/home?region=us-east-1#/).
1. Escolha **Criar runbook de automação**.
## Etapa 2: criar um fluxo de trabalho
Na experiência de design visual, um fluxo de trabalho é uma representação gráfica do seu runbook na tela. É possível usar a experiência de design visual para definir, configurar e examinar as ações individuais do seu runbook.
**Para criar um fluxo de trabalho**
1. Ao lado do botão **Design** e **Código**, selecione o ícone de lápis e insira um nome para o seu runbook. Para este tutorial, insira **VisualDesignExperienceTutorial**.
![\[Experiência de design visual: dê um nome ao seu runbook\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_tutorial_name.png)
1. Na seção **Atributos do documento** do painel **Formulário**, expanda a lista suspensa **Parâmetros de entrada** e selecione **Adicionar um parâmetro**.
1. No campo **Nome do parâmetro**, insira **InstanceId**.
1. No menu suspenso **Tipo**, escolha **AWS::EC2::Instance**.
1. Selecione o botão **Obrigatório**.
![\[Crie um parâmetro para seu runbook\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_actions_tutorial_parameter.png)
1. No navegador **APIs da AWS**, insira **DescribeInstances** na barra de pesquisa.
1. Arraste uma ação **Amazon EC2 – DescribeInstances** para a tela vazia.
1. Em **Nome da etapa**, insira um valor. Para este tutorial, use o nome **GetInstanceState**.
![\[Escolha uma ação de API de descrição de instâncias do Amazon EC2.\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_tutorial_api_action.png)
1. Expanda a lista suspensa **Entradas adicionais** e, no campo **Nome da entrada**, insira **InstanceIds**.
1. Escolha a guia **Entradas**.
1. No campo **Valor de entrada**, escolha a entrada do documento **InstanceId**. Isso faz referência ao valor do parâmetro de entrada criado por você no início do procedimento. Como a entrada **InstanceIDs** da ação `DescribeInstances` aceita valores `StringList`, é necessário colocar a entrada **InstanceID** entre colchetes. O YAML para o **Valor de entrada** deve corresponder ao seguinte: **['\$1\$1 InstanceId \$1\$1']**.
1. Na guia **Saídas**, selecione **Adicionar uma saída** e insira **InstanceState** no campo **Nome**.
1. No campo **Seletor**, insira **\$1.Reservations[0].Instances[0].State.Name**.
1. **No menu suspenso **Tipo**, escolha String**.
1. Arraste uma ação de **Ramificação** do navegador **Ações** e solte-a abaixo da etapa **`GetInstanceState`**.
1. Em **Nome da etapa**, insira um valor. Neste tutorial, use o nome `BranchOnInstanceState`.
Para definir a lógica de ramificação, faça o seguinte:
1. Escolha o estado **`Branch`** na tela. Em seguida, em **Entradas** e **Escolhas**, selecione o ícone de lápis para editar a **Regra \$11**.
1. Escolha **Adicionar condições**.
1. Na caixa de diálogo **Condições para a regra \$11**, escolha a saída da etapa **GetInstanceState.InstanceState** no menu suspenso **Variável**.
1. Em **Operador**, escolha **é igual a**.
1. Em **Valor**, escolha **String** na lista suspensa. Insira **stopped**.
![\[Defina uma condição para uma ação de ramificação.\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_tutorial_condition.png)
1. Selecione **Salvar condições**.
1. Escolha **Adicionar nova regra de escolha**.
1. Escolha **Adicionar condições** para a **Regra \$12**.
1. Na caixa de diálogo **Condições para a regra \$12**, escolha a saída da etapa **GetInstanceState.InstanceState** no menu suspenso **Variável**.
1. Em **Operador**, escolha **é igual a**.
1. Em **Valor**, escolha **String** na lista suspensa. Insira **stopping**.
1. Selecione **Salvar condições**.
1. Escolha **Adicionar nova regra de escolha**.
1. Para a **Regra \$13**, escolha **Adicionar condições**.
1. Na caixa de diálogo **Condições para a regra \$13**, escolha a saída da etapa **GetInstanceState.InstanceState** no menu suspenso **Variável**.
1. Em **Operador**, escolha **é igual a**.
1. Em **Valor**, escolha **String** na lista suspensa. Insira **running**.
1. Selecione **Salvar condições**.
1. Na **Regra padrão**, escolha **Ir para o final** em **Etapa padrão**.
1. Arraste a ação **Alterar um estado de instância** para a caixa vazia **Arraste a ação aqui** sob a condição **\$1\$1GetInstanceState.InstanceState\$1\$1 == "stopped"**.
1. Em **Nome da etapa**, insira **StartInstance**.
1. Na guia **Entradas**, em **IDs de instância**, escolha o valor de entrada do documento **InstanceId** no menu suspenso.
1. Para **Estado desejado**, especifique **`running`**.
1. Arraste a ação **Aguardar recurso da AWS** para a caixa vazia **Arraste a ação aqui** sob a condição **\$1\$1 GetInstanceState.InstanceState \$1\$1 == "stopping"**.
1. Em **Nome da etapa**, insira um valor. Neste tutorial, use o nome `WaitForInstanceStop`.
1. No campo **Serviço**, escolha **Amazon EC2**.
1. No campo **API**, escolha **DescribeInstances**.
1. No campo **Seletor de propriedades**, insira **\$1.Reservations[0].Instances[0].State.Name**.
1. Para o parâmetro **Valores desejados**, insira **`["stopped"]`**.
1. Na guia **Configuração** da ação **WaitForInstanceStop**, escolha **StartInstance** no menu suspenso **Próxima etapa**.
1. Arraste a ação **Executar comando em instâncias** para a caixa vazia **Arraste a ação aqui** sob a condição **\$1\$1GetInstanceState.InstanceState\$1\$1 == "running"**.
1. Em **Nome da etapa**, insira **SayHello**.
1. Na guia **Entradas**, insira **AWS-RunShellScript** para o parâmetro **Nome do documento**.
1. Para **InstanceIds**, escolha o valor de entrada do documento **InstanceId** no menu suspenso.
1. Expanda o menu suspenso **Entradas adicionais** e, no menu suspenso **Nome da entrada**, escolha **Parâmetros**.
1. No campo **Valore de entrada**, insira **`{"commands": "echo 'Hello World'"}`**.
1. Revise o runbook concluído na tela e selecione **Criar runbook** para salvar o runbook do tutorial.
![\[Analisar e criar o runbook.\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/visual_designer_tutorial_complete.png)
## Etapa 3: analisar o código gerado automaticamente
Conforme você arrasta e solta ações do navegador **Ações** na tela, a experiência de design visual compõe automaticamente o conteúdo YAML ou JSON do seu runbook em tempo real. Você pode visualizar e editar esse código. Para visualizar o código gerado automaticamente, selecione **Código** na opção **Design** e **Código**.
## Etapa 4: executar seu novo runbook
Após criar seu runbook, você poderá executar a automação.
**Para executar seu novo runbook de automação**
1. Abra o console AWS Systems Manager em [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. No painel de navegação, selecione **Automation** e **Execute automation (Executar automação)**.
1. Na lista **Automation document** (Documento do Automation), escolha um runbook. Escolha uma ou mais opções no painel **Document categories** (Categorias de documentos) para filtrar documentos SSM de acordo com sua finalidade. Para visualizar um runbook que você tenha, escolha a guia **Owned by me** (De minha propriedade). Para visualizar um runbook compartilhado com sua conta, escolha a guia **Shared with me** (Compartilhado comigo). Para visualizar todos os runbooks, escolha a guia **All documents** (Todos os documentos).
**nota**
Você pode visualizar informações sobre um runbook, selecionando o nome dele.
1. Na seção **Document details** (Detalhes do documento), verifique se **Document version** (Versão do documento) está definida como a versão que você quer executar. O sistema inclui as seguintes opções de versão:
+ **Versão padrão no runtime**: escolha essa opção se o runbook do Automation for atualizado periodicamente e uma nova versão padrão for atribuída.
+ **Versão mais recente no runtime**: escolha essa opção se o runbook do Automation for atualizado periodicamente e se você quiser executar a versão mais recente.
+ **1 (padrão):** escolha esta opção para executar a primeira versão do documento, que é a versão padrão.
1. Escolha **Próximo**.
1. Na página **Executar runbook de automação**, escolha **Execução simples**.
1. Na seção **Input parameters (Parâmetros de entrada)**, especifique as entradas necessárias. Opcionalmente, você pode escolher uma função de serviço do IAM na lista **AutomationAssumeRole**.
1. (Opcional) Escolha um alarme do Amazon CloudWatch a fim de aplicar à sua automação para monitoramento. Para anexar um alarme do CloudWatch à sua automação, a entidade principal do IAM que inicia a automação deve ter permissão para a ação `iam:createServiceLinkedRole`. Para obter mais informações sobre alarmes do CloudWatch, consulte [Usar alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). A automação será interrompida se o alarme for ativado. Se você usar o AWS CloudTrail, você verá a chamada de API em sua trilha.
1. Clique em **Executar**.
## Etapa 5: limpar
**Para excluir seu runbook**
1. Abra o console AWS Systems Manager em [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. No painel de navegação, escolha **Documents**.
1. Selecione a guia **Pertencente a mim**.
1. Localize o runbook **VisualDesignExperienceTutorial**.
1. Selecione o botão na página do cartão do documento e escolha **Excluir documento** no menu suspenso **Ações**.