• 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).
# Executar operações automatizadas em escala
Com o AWS Systems Manager Automation, você pode executar automações em uma frota de recursos da AWS usando *destinos*. Além disso, você pode controlar a implantação da automação em toda a frota, especificando um valor de simultaneidade e um erro limite. Os recursos de simultaneidade e limite de erros são coletivamente chamados de *controles de taxa*. O valor de simultaneidade determina quantos recursos são permitidos para executar a automação simultaneamente. O Automation também fornece um modo de simultaneidade adaptativa que você pode optar por participar. A simultaneidade adaptativa dimensiona automaticamente sua cota de automação de 100 automações em execução simultânea até 500. Um limite de erro determina quantas automações podem falhar antes do Systems Manager parar de enviar a automação para outros recursos.
Para obter mais informações sobre simultaneidade e limites de erro, consulte [Automações de controle em grande escala](running-automations-scale-controls.md). Para obter mais informações sobre destinos, consulte [Mapeamento de destino para uma automação](running-automations-map-targets.md).
Os procedimentos a seguir descrevem como ativar a simultaneidade adaptativa e como executar uma automação com destinos e controles de taxa usando o console do Systems Manager e a AWS Command Line Interface (AWS CLI).
## Executar uma automação com destinos e controles de taxa (console)
O procedimento a seguir descreve como usar o console do Systems Manager para executar uma automação com destinos e controles de taxa.
**Para executar uma automação com destinos e controles de taxa**
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 seção **Execution Mode (Modo de execução)**, escolha **Rate Control (Controle de taxa)**. Você deve usar esse modo ou **Multi-account and Region (Várias contas e regiões)** se quiser usar destinos e controles de taxa.
1. Na seção **Targets** (Destinos), escolha como você quer definir os destinos dos recursos da AWS em que você deseja executar o Automation. Essas opções são obrigatórias.
1. Use a lista **Parameter (Parâmetro)** para escolher um parâmetro. Os itens na lista **Parameter** (Parâmetro) são determinados pelos parâmetros no runbook do Automation que você selecionou no início deste procedimento. Ao escolher um parâmetro, você define o tipo de recurso em que o fluxo de trabalho da Automação é executado.
1. Use a lista **Targets (Destinos)** para escolher como você deseja definir o destino dos recursos.
1. Se você optar por definir o destino dos recursos usando valores de parâmetro, insira o valor do parâmetro para aquele escolhido na seção **Input parameters** (Parâmetros de entrada).
1. Se você escolher definir o destino dos recursos usando o AWS Resource Groups, escolha o nome do grupo na lista **Resource Group (Grupo de recursos)**.
1. Se você optar por definir o destino dos recursos usando tags, insira a chave de tag e (opcionalmente) o valor da tag nos campos fornecidos. Escolha **Adicionar**.
1. Se você quiser executar um runbook do Automation em todas as instâncias nas Conta da AWS e Região da AWS atuais, escolha **All instances** (Todas as instâncias).
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**.
**nota**
Pode ser que não seja necessário escolher algumas das opções na seção **Input parameters** (Parâmetros de entrada). Isso ocorre porque você definiu o destino dos recursos usando tags ou um grupo de recursos. Por exemplo, se você escolheu o runbook `AWS-RestartEC2Instance`, você não precisará especificar ou escolher IDs de instância na seção **Input parameters** (Parâmetros de entrada). A execução do Automation localiza as instâncias para reiniciar usando as tags ou grupos de recursos que você especificou.
1. Use as opções na seção **Rate control** (Controle de taxa) para restringir o número de recursos da AWS que podem executar o Automation dentro de cada par conta-região.
Na seção **Concurrency** (Simultaneidade), escolha uma opção:
+ Escolha **Targets (Destinos)** para inserir um número absoluto de destinos que podem executar o fluxo de trabalho de Automação simultaneamente.
+ Escolha **Percentage (Porcentagem)** para inserir uma porcentagem do conjunto de destino que pode executar o fluxo de trabalho de Automação simultaneamente.
1. Na seção **Error threshold (Limite de erro)**, escolha uma opção:
+ Escolha **errors (erros)** para inserir um número absoluto de erros permitidos antes que a Automação deixe de enviar o fluxo de trabalho para outros recursos.
+ Escolha **percentage (porcentagem)** para inserir uma porcentagem de erros permitidos antes que a Automação deixe de enviar o fluxo de trabalho para outros recursos.
1. (Opcional) Escolha um alarme do 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). Observe que 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**.
Para visualizar automações iniciadas pela automação do controle de taxa, no painel de navegação, escolha Automation (Automação) e depois selecione **Show child automations** (Mostrar automações filho).
Depois que uma execução de automação for concluída, você pode executá-la novamente com os mesmos parâmetros ou com parâmetros modificados. Para obter mais informações, consulte [Executar novamente as execuções de automação](automation-rerun-executions.md).
## Executar uma automação com destinos e controles de taxa (linha de comando)
O procedimento a seguir descreve como usar a AWS CLI (no Linux ou no Windows) ou o Ferramentas da AWS para PowerShell para executar uma automação com destinos e controles de taxa.
**Para executar uma automação com destinos e controles de taxa**
1. Instale e configure a AWS CLI ou o Ferramentas da AWS para PowerShell, caso ainda não o tenha feito.
Para obter informações, consulte [Instalar ou atualizar a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [Instalar o Ferramentas da AWS para PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Execute o comando a seguir para visualizar uma lista de documentos.
------
#### [ Linux & macOS ]
```
aws ssm list-documents
```
------
#### [ Windows ]
```
aws ssm list-documents
```
------
#### [ PowerShell ]
```
Get-SSMDocumentList
```
------
Anote o nome do runbook que você quer usar.
1. Execute o comando a seguir para visualizar os detalhes sobre o runbook. Substitua o *runbook name* (nome do runbook) pelo nome do runbook cujos detalhes deseja visualizar. Além disso, anote o nome de um parâmetro (por exemplo, `InstanceId`) que deseja usar para a opção `--target-parameter-name`. Esse parâmetro determina o tipo de recurso em que a automação é executada.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name runbook name
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name runbook name
```
------
#### [ PowerShell ]
```
Get-SSMDocumentDescription `
-Name runbook name
```
------
1. Crie um comando que use as opções de destino e controle de taxa que você deseja executar. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
*Definir destino usando tags*
------
#### [ Linux & macOS ]
```
aws ssm start-automation-execution \
--document-name runbook name \
--targets Key=tag:key name,Values=value \
--target-parameter-name parameter name \
--parameters "input parameter name=input parameter value,input parameter 2 name=input parameter 2 value" \
--max-concurrency 10 \
--max-errors 25%
```
------
#### [ Windows ]
```
aws ssm start-automation-execution ^
--document-name runbook name ^
--targets Key=tag:key name,Values=value ^
--target-parameter-name parameter name ^
--parameters "input parameter name=input parameter value,input parameter 2 name=input parameter 2 value" ^
--max-concurrency 10 ^
--max-errors 25%
```
------
#### [ PowerShell ]
```
$Targets = New-Object Amazon.SimpleSystemsManagement.Model.Target
$Targets.Key = "tag:key name"
$Targets.Values = "value"
Start-SSMAutomationExecution `
DocumentName "runbook name" `
-Targets $Targets `
-TargetParameterName "parameter name" `
-Parameter @{"input parameter name"="input parameter value";"input parameter 2 name"="input parameter 2 value"} `
-MaxConcurrency "10" `
-MaxError "25%"
```
------
*Definir destino usando valores de parâmetro*
------
#### [ Linux & macOS ]
```
aws ssm start-automation-execution \
--document-name runbook name \
--targets Key=ParameterValues,Values=value,value 2,value 3 \
--target-parameter-name parameter name \
--parameters "input parameter name=input parameter value" \
--max-concurrency 10 \
--max-errors 25%
```
------
#### [ Windows ]
```
aws ssm start-automation-execution ^
--document-name runbook name ^
--targets Key=ParameterValues,Values=value,value 2,value 3 ^
--target-parameter-name parameter name ^
--parameters "input parameter name=input parameter value" ^
--max-concurrency 10 ^
--max-errors 25%
```
------
#### [ PowerShell ]
```
$Targets = New-Object Amazon.SimpleSystemsManagement.Model.Target
$Targets.Key = "ParameterValues"
$Targets.Values = "value","value 2","value 3"
Start-SSMAutomationExecution `
-DocumentName "runbook name" `
-Targets $Targets `
-TargetParameterName "parameter name" `
-Parameter @{"input parameter name"="input parameter value"} `
-MaxConcurrency "10" `
-MaxError "25%"
```
------
*Definir destino usando AWS Resource Groups*
------
#### [ Linux & macOS ]
```
aws ssm start-automation-execution \
--document-name runbook name \
--targets Key=ResourceGroup,Values=Resource group nname \
--target-parameter-name parameter name \
--parameters "input parameter name=input parameter value" \
--max-concurrency 10 \
--max-errors 25%
```
------
#### [ Windows ]
```
aws ssm start-automation-execution ^
--document-name runbook name ^
--targets Key=ResourceGroup,Values=Resource group name ^
--target-parameter-name parameter name ^
--parameters "input parameter name=input parameter value" ^
--max-concurrency 10 ^
--max-errors 25%
```
------
#### [ PowerShell ]
```
$Targets = New-Object Amazon.SimpleSystemsManagement.Model.Target
$Targets.Key = "ResourceGroup"
$Targets.Values = "Resource group name"
Start-SSMAutomationExecution `
-DocumentName "runbook name" `
-Targets $Targets `
-TargetParameterName "parameter name" `
-Parameter @{"input parameter name"="input parameter value"} `
-MaxConcurrency "10" `
-MaxError "25%"
```
------
*Direcionar todas as instâncias do Amazon EC2 na Conta da AWS e na Região da AWS atuais*
------
#### [ Linux & macOS ]
```
aws ssm start-automation-execution \
--document-name runbook name \
--targets "Key=AWS::EC2::Instance,Values=*" \
--target-parameter-name instanceId \
--parameters "input parameter name=input parameter value" \
--max-concurrency 10 \
--max-errors 25%
```
------
#### [ Windows ]
```
aws ssm start-automation-execution ^
--document-name runbook name ^
--targets Key=AWS::EC2::Instance,Values=* ^
--target-parameter-name instanceId ^
--parameters "input parameter name=input parameter value" ^
--max-concurrency 10 ^
--max-errors 25%
```
------
#### [ PowerShell ]
```
$Targets = New-Object Amazon.SimpleSystemsManagement.Model.Target
$Targets.Key = "AWS::EC2::Instance"
$Targets.Values = "*"
Start-SSMAutomationExecution `
-DocumentName "runbook name" `
-Targets $Targets `
-TargetParameterName "instanceId" `
-Parameter @{"input parameter name"="input parameter value"} `
-MaxConcurrency "10" `
-MaxError "25%"
```
------
O comando retorna um ID de execução. Copie esse ID para a área de transferência. Você pode usar esse ID para visualizar o status da automação.
------
#### [ Linux & macOS ]
```
{
"AutomationExecutionId": "a4a3c0e9-7efd-462a-8594-01234EXAMPLE"
}
```
------
#### [ Windows ]
```
{
"AutomationExecutionId": "a4a3c0e9-7efd-462a-8594-01234EXAMPLE"
}
```
------
#### [ PowerShell ]
```
a4a3c0e9-7efd-462a-8594-01234EXAMPLE
```
------
1. Execute o comando a seguir para visualizar a automação. Substitua cada *automation execution ID* (ID de execução de automação) por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm describe-automation-executions \
--filter Key=ExecutionId,Values=automation execution ID
```
------
#### [ Windows ]
```
aws ssm describe-automation-executions ^
--filter Key=ExecutionId,Values=automation execution ID
```
------
#### [ PowerShell ]
```
Get-SSMAutomationExecutionList | `
Where {$_.AutomationExecutionId -eq "automation execution ID"}
```
------
1. Para visualizar detalhes sobre o andamento da automação, execute o comando a seguir. Substitua cada *automation execution ID* (ID de execução de automação) por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm get-automation-execution \
--automation-execution-id automation execution ID
```
------
#### [ Windows ]
```
aws ssm get-automation-execution ^
--automation-execution-id automation execution ID
```
------
#### [ PowerShell ]
```
Get-SSMAutomationExecution `
-AutomationExecutionId automation execution ID
```
------
O sistema retorna informações como estas.
------
#### [ Linux & macOS ]
```
{
"AutomationExecution": {
"StepExecutionsTruncated": false,
"AutomationExecutionStatus": "Success",
"MaxConcurrency": "1",
"Parameters": {},
"MaxErrors": "1",
"Outputs": {},
"DocumentName": "AWS-StopEC2Instance",
"AutomationExecutionId": "a4a3c0e9-7efd-462a-8594-01234EXAMPLE",
"ResolvedTargets": {
"ParameterValues": [
"i-02573cafcfEXAMPLE"
],
"Truncated": false
},
"ExecutionEndTime": 1564681619.915,
"Targets": [
{
"Values": [
"DEV"
],
"Key": "tag:ENV"
}
],
"DocumentVersion": "1",
"ExecutionStartTime": 1564681576.09,
"ExecutedBy": "arn:aws:sts::123456789012:assumed-role/Administrator/Admin",
"StepExecutions": [
{
"Inputs": {
"InstanceId": "i-02573cafcfEXAMPLE"
},
"Outputs": {},
"StepName": "i-02573cafcfEXAMPLE",
"ExecutionEndTime": 1564681619.093,
"StepExecutionId": "86c7b811-3896-4b78-b897-01234EXAMPLE",
"ExecutionStartTime": 1564681576.836,
"Action": "aws:executeAutomation",
"StepStatus": "Success"
}
],
"TargetParameterName": "InstanceId",
"Mode": "Auto"
}
}
```
------
#### [ Windows ]
```
{
"AutomationExecution": {
"StepExecutionsTruncated": false,
"AutomationExecutionStatus": "Success",
"MaxConcurrency": "1",
"Parameters": {},
"MaxErrors": "1",
"Outputs": {},
"DocumentName": "AWS-StopEC2Instance",
"AutomationExecutionId": "a4a3c0e9-7efd-462a-8594-01234EXAMPLE",
"ResolvedTargets": {
"ParameterValues": [
"i-02573cafcfEXAMPLE"
],
"Truncated": false
},
"ExecutionEndTime": 1564681619.915,
"Targets": [
{
"Values": [
"DEV"
],
"Key": "tag:ENV"
}
],
"DocumentVersion": "1",
"ExecutionStartTime": 1564681576.09,
"ExecutedBy": "arn:aws:sts::123456789012:assumed-role/Administrator/Admin",
"StepExecutions": [
{
"Inputs": {
"InstanceId": "i-02573cafcfEXAMPLE"
},
"Outputs": {},
"StepName": "i-02573cafcfEXAMPLE",
"ExecutionEndTime": 1564681619.093,
"StepExecutionId": "86c7b811-3896-4b78-b897-01234EXAMPLE",
"ExecutionStartTime": 1564681576.836,
"Action": "aws:executeAutomation",
"StepStatus": "Success"
}
],
"TargetParameterName": "InstanceId",
"Mode": "Auto"
}
}
```
------
#### [ PowerShell ]
```
AutomationExecutionId : a4a3c0e9-7efd-462a-8594-01234EXAMPLE
AutomationExecutionStatus : Success
CurrentAction :
CurrentStepName :
DocumentName : AWS-StopEC2Instance
DocumentVersion : 1
ExecutedBy : arn:aws:sts::123456789012:assumed-role/Administrator/Admin
ExecutionEndTime : 8/1/2019 5:46:59 PM
ExecutionStartTime : 8/1/2019 5:46:16 PM
FailureMessage :
MaxConcurrency : 1
MaxErrors : 1
Mode : Auto
Outputs : {}
Parameters : {}
ParentAutomationExecutionId :
ProgressCounters :
ResolvedTargets : Amazon.SimpleSystemsManagement.Model.ResolvedTargets
StepExecutions : {i-02573cafcfEXAMPLE}
StepExecutionsTruncated : False
Target :
TargetLocations : {}
TargetMaps : {}
TargetParameterName : InstanceId
Targets : {tag:Name}
```
------
**nota**
Você pode também monitorar o status da automação no console. Na lista de **execuções do Automation**, escolha a execução que você acabou de processar e depois escolha a guia **Execution steps** (Etapas da execução). Esta guia mostra o status das ações de automação.
# Mapeamento de destino para uma automação
Use o parâmetro `Targets` para definir rapidamente quais recursos serão usados como destino por uma automação. Por exemplo, se você quiser executar uma automação que reinicia suas instâncias gerenciadas, em vez de selecionar manualmente dezenas de IDs de instância no console ou digitá-los em um comando, especifique as instâncias de destino especificando as tags do Amazon Elastic Compute Cloud (Amazon EC2) com o parâmetro `Targets`.
Quando você executa uma automação que usa um destino, o AWS Systems Manager cria uma automação filho para cada destino. Por exemplo, se você definir o destino dos volumes do Amazon Elastic Block Store (Amazon EBS) especificando tags, e essas tags forem resolvidas para 100 volumes do Amazon EBS, o Systems Manager criará 100 automações filho. A automação pai é concluída quando todas as automações filho alcançam um estado final.
**nota**
Quaisquer `input parameters` especificados em runtime (na seção **Input parameters** (parâmetros de entrada) do console ou usando a opção `parameters` na linha de comando) serão automaticamente processados por todas as automações filho.
Você pode definir recursos como o destino para uma automação usando tags, grupos de recursos e valores de parâmetros. Além disso, você pode usar a opção `TargetMaps` para definir o destino de vários valores de parâmetro na linha de comando ou em um arquivo. A seção a seguir descreve cada uma dessas opções de destino em mais detalhes.
## Definir uma etiqueta como destino
É possível especificar uma única etiqueta como o destino de uma automação. Muitos recursos da AWS oferecem suporte a tags, incluindo instâncias do Amazon Elastic Compute Cloud (Amazon EC2) e Amazon Relational Database Service (Amazon RDS), volumes e snapshots do Amazon Elastic Block Store (Amazon EBS), grupos de recursos e buckets do Amazon Simple Storage Service (Amazon S3), entre outros. É possível executar rapidamente a automação nos recursos da AWS definindo uma etiqueta como destino. Uma etiqueta é um par de chave-valor, como Operating\$1System:Linux ou Department:Finance. Se você atribuir um nome específico a um recurso, você também pode usar a palavra "Name" como chave, e o nome do recurso como valor.
Quando você especifica uma tag como o destino para uma automação, você também deve especificar um parâmetro de destino. O parâmetro de destino usa a opção `TargetParameterName`. Ao escolher um parâmetro de destino, você define o tipo de recurso no qual a automação é executada. O parâmetro de destino especificado com a tag deve ser um parâmetro válido definido no runbook. Por exemplo, para ter dezenas de instâncias do EC2 como destino usando tags, escolha o parâmetro de destino `InstanceId`. Ao escolher este parâmetro, você define as *instâncias* como o tipo de recurso para a automação. Ao criar um runbook personalizado, é necessário especificar o **Tipo de destino** como `/AWS::EC2::Instance` para garantir que somente instâncias sejam usadas. Caso contrário, todos os recursos com a mesma etiqueta serão direcionados. Ao definir instâncias como destino usando uma etiqueta, é possível incluir instâncias encerradas.
A captura de tela a seguir usa o runbook `AWS-DetachEBSVolume`. O parâmetro de destino lógico é `VolumeId`.
![\[Usar uma etiqueta como destino para o Systems Manager Automation\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/automation-rate-control-tags-1-new.png)
O runbook `AWS-DetachEBSVolume` também inclui uma propriedade especial chamada **Target type** (Tipo de destino), que é definida como `/AWS::EC2::Volume`. Isso significa que, se o par de tag e chave `Finance:TestEnv` retornar diferentes tipos de recursos (por exemplo, instâncias do EC2, volumes do Amazon EBS e snapshots do Amazon EBS), apenas os volumes do Amazon EBS serão usados.
**Importante**
Os nomes dos parâmetros de destino diferenciam maiúsculas de minúsculas. Se você executar automações usando a AWS Command Line Interface (AWS CLI) ou AWS Tools for Windows PowerShell, insira o nome do parâmetro de destino exatamente como ele é definido no runbook. Se não fizer isso, o sistema retornará um erro `InvalidAutomationExecutionParametersException`. Você pode usar a operação de API [DescribeDocument](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DescribeDocument.html) para ver informações sobre os parâmetros de destino disponíveis em um runbook específico. Veja a seguir um exemplo de comando da AWS CLI que fornece informações sobre o documento `AWS-DeleteSnapshot`.
```
aws ssm describe-document \
--name AWS-DeleteSnapshot
```
Aqui estão alguns exemplos de comandos da AWS CLI que definem recursos como destino usando etiquetas.
**Exemplo 1: definir uma etiqueta como destino usando um par de chave-valor para reiniciar instâncias do Amazon EC**
Este exemplo reinicia todas as instâncias do Amazon EC2 que estiverem marcadas com uma chave *Department* e um valor *HumanResources*. O parâmetro de destino usa o parâmetro *InstanceId* do runbook. O exemplo usa um parâmetro adicional para executar a automação usando uma função de serviço do Automation (também chamado de *função assumida*).
```
aws ssm start-automation-execution \
--document-name AWS-RestartEC2Instance \
--targets Key=tag:Department,Values=HumanResources \
--target-parameter-name InstanceId \
--parameters "AutomationAssumeRole=arn:aws:iam::111122223333:role/AutomationServiceRole"
```
**Exemplo 2: definir uma etiqueta como destino usando um par de chave-valor para excluir snapshots do Amazon EBS**
O exemplo a seguir usa o runbook `AWS-DeleteSnapshot` para excluir todos os snapshots com uma chave de *Nome* e um valor de *January2018Backups*. O parâmetro de destino usa o parâmetro *VolumeId*.
```
aws ssm start-automation-execution \
--document-name AWS-DeleteSnapshot \
--targets Key=tag:Name,Values=January2018Backups \
--target-parameter-name VolumeId
```
## como destino AWS Resource Groups
É possível especificar um único grupo de recursos da AWS como o destino de uma automação. O Systems Manager cria uma automação filho para cada objeto no grupo de recursos de destino.
Por exemplo, digamos que um de seus grupos de recursos tenha o nome de PatchedAMIs. Esse grupo de recursos inclui uma lista de 25 Amazon Machine Images (AMIs) do Windows que recebem patches rotineiramente. Se você executar uma automação que use o runbook `AWS-CreateManagedWindowsInstance` e tenha como destino esse grupo de recursos, o Systems Manager criará uma automação filho para cada uma das 25 AMIs. Isso significa que, ao especificar o grupo de recursos PatchedAMIs, a automação cria 25 instâncias em uma lista de corrigidas pelos patches AMIs. A automação pai é concluída quando todas as automações filho finalizam o processamento ou alcançam um estado final.
O comando da AWS CLI a seguir se aplica ao exemplo do grupo de recursos PatchAMIs. O comando usa o parâmetro *Amild* para a opção `--target-parameter-name`. O comando não inclui um parâmetro adicional que define qual tipo de instância criar a partir de cada AMI. O runbook `AWS-CreateManagedWindowsInstance` usa como padrão o tipo de instância t2.medium. Esse comando criaria 25 instâncias t2.medium do Amazon EC2 para o Windows Server.
```
aws ssm start-automation-execution \
--document-name AWS-CreateManagedWindowsInstance \
--targets Key=ResourceGroup,Values=PatchedAMIs \
--target-parameter-name AmiId
```
O exemplo de console a seguir usa um grupo de recursos chamado t2-micro-instances.
![\[Selecionar um grupo de recursos da AWS como destino com uma automação do Systems Manager\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/automation-rate-control-resource-groups-new.png)
## Direcionar valores de parâmetro
Você também pode direcionar um valor de parâmetro. Insira `ParameterValues` como chave e, em seguida, insira o valor do recurso específico em que você deseja que a automação seja executada. Se você especificar vários valores, o Systems Manager executará uma automação secundária em cada valor especificado.
Por exemplo, digamos que o runbook inclui um parâmetro **InstanceID**. Se você direcionar os valores do parâmetro **InstanceID** ao executar o Automation, o Systems Manager executará uma automação filho para cada valor especificado para o ID da instância. A automação pai é concluída quando a automação conclui a execução de cada instância especificada, ou se a automação falha. Você pode direcionar um máximo de 50 valores de parâmetro.
O exemplo a seguir usa o runbook `AWS-CreateImage`. O nome do parâmetro de destino especificado é *InstanceId*. A chave usa *ParameterValues*. Os valores são dois IDs de instâncias do Amazon EC2. Esse comando cria uma automação para cada instância, que produz uma AMI em cada instância.
```
aws ssm start-automation-execution
--document-name AWS-CreateImage \
--target-parameter-name InstanceId \
--targets Key=ParameterValues,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE
```
**nota**
`AutomationAssumeRole` não é um parâmetro válido. Não escolha esse item ao executar fluxos automações que direcionam um valor de parâmetro.
### Direcionar mapas de valores de parâmetros
A opção `TargetMaps` expande sua capacidade de direcionar `ParameterValues`. Você pode inserir um conjunto de valores de parâmetro usando `TargetMaps` na linha de comando. Você pode especificar um máximo de 50 valores de parâmetro na linha de comando. Se quiser executar comandos que especificam mais de 50 valores de parâmetro, você poderá inserir os valores em um arquivo JSON. Você pode, então, chamar o arquivo da linha de comando.
**nota**
A opção `TargetMaps` não tem suporte no console.
Use o formato a seguir para especificar vários valores de parâmetro usando a opção `TargetMaps` em um comando. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
aws ssm start-automation-execution \
--document-name runbook name \
--target-maps “parameter=value, parameter 2=value, parameter 3=value” “parameter 4=value, parameter 5=value, parameter 6=value”
```
Se você deseja inserir mais de 50 valores de parâmetro para a opção `TargetMaps`, especifique os valores em um arquivo usando o seguinte formato JSON. Usar um arquivo JSON também melhora a legibilidade ao fornecer vários valores de parâmetro.
```
[
{“parameter”: "value", “parameter 2”: "value", “parameter 3”: "value"},
{“parameter 4”: "value", “parameter 5”: "value", "parameter 6": "value"}
]
```
Salve o arquivo com a extensão .json. Você pode chamar o arquivo usando o seguinte comando: Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
aws ssm start-automation-execution \
--document-name runbook name \
–-parameters input parameters \
--target-maps path to file/file name.json
```
Você também pode baixar o arquivo de um bucket do Amazon Simple Storage Service (Amazon S3), desde que tenha permissão para ler dados do bucket. Use o seguinte formato de comando: Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
aws ssm start-automation-execution \
--document-name runbook name \
--target-maps http://amzn-s3-demo-bucket.s3.amazonaws.com/file_name.json
```
Este é um cenário de exemplo para ajudar você a compreender a opção `TargetMaps`. Nesse cenário, um usuário deseja criar instâncias do Amazon EC2 de diferentes tipos em diferentes AMIs. Para executar essa tarefa, o usuário cria um runbook chamado AMI\$1Testing. Este runbook define dois parâmetros de entrada: `instanceType` e `imageId`.
```
{
"description": "AMI Testing",
"schemaVersion": "0.3",
"assumeRole": "{{assumeRole}}",
"parameters": {
"assumeRole": {
"type": "String",
"description": "Role under which to run the automation",
"default": ""
},
"instanceType": {
"type": "String",
"description": "Type of EC2 Instance to launch for this test"
},
"imageId": {
"type": "String",
"description": "Source AMI id from which to run instance"
}
},
"mainSteps": [
{
"name": "runInstances",
"action": "aws:runInstances",
"maxAttempts": 1,
"onFailure": "Abort",
"inputs": {
"ImageId": "{{imageId}}",
"InstanceType": "{{instanceType}}",
"MinInstanceCount": 1,
"MaxInstanceCount": 1
}
}
],
"outputs": [
"runInstances.InstanceIds"
]
}
```
O usuário especifica os seguintes valores de parâmetro de destino em um arquivo chamado `AMI_instance_types.json`.
```
[
{
"instanceType" : ["t2.micro"],
"imageId" : ["ami-b70554c8"]
},
{
"instanceType" : ["t2.small"],
"imageId" : ["ami-b70554c8"]
},
{
"instanceType" : ["t2.medium"],
"imageId" : ["ami-cfe4b2b0"]
},
{
"instanceType" : ["t2.medium"],
"imageId" : ["ami-cfe4b2b0"]
},
{
"instanceType" : ["t2.medium"],
"imageId" : ["ami-cfe4b2b0"]
}
]
```
O usuário pode executar a automação e criar as cinco instâncias do EC2 definidas em `AMI_instance_types.json`, executando o seguinte comando:
```
aws ssm start-automation-execution \
--document-name AMI_Testing \
--target-parameter-name imageId \
--target-maps file:///home/TestUser/workspace/runinstances/AMI_instance_types.json
```
## Direcionar todas as instâncias do Amazon EC2
É possível executar uma automação em todas as instâncias do Amazon EC2 na Conta da AWS e na Região da AWS atuais ao escolher **Todas as instâncias** na lista **Destinos**. Por exemplo, se você quiser reiniciar todas as instâncias do Amazon EC2 em sua Conta da AWS e nas Região da AWS atuais, escolha o runbook `AWS-RestartEC2Instance` e selecione **Todas as instâncias** na lista **Destinos**.
![\[Segmentação de todas as instâncias do Amazon EC2 para um runbook\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/automation-rate-control-target-all-instances.png)
Depois de escolher **All instances** (Todas as instâncias), o Systems Manager preenche o campo **Instância** com um asterisco (\$1) e torna o campo indisponível para alterações (o campo ficará esmaecido). O Systems Manager também torna o campo **InstanceId** em **Input parameters** (Parâmetros de entrada) indisponível para alterações. Tornar esses campos indisponíveis para alterações será o comportamento esperado se você optar por direcionar todas as instâncias.
# Automações de controle em grande escala
Você pode controlar a implantação de uma automação em uma frota de recursos da AWS, especificando um valor de simultaneidade e um limite de erro. Simultaneidade e limite de erro são coletivamente chamados de *controles de taxa*.
**Simultaneidade**
Use a simultaneidade para especificar quantos recursos podem executar uma automação simultaneamente. A simultaneidade ajuda a limitar o impacto ou o tempo de inatividade em seus recursos ao processar uma automação. Você pode especificar um número absoluto de recursos, por exemplo, 20 ou uma porcentagem do conjunto de destino, por exemplo, 10%.
O sistema de fila fornece a automação a um único recurso e aguarda até que a invocação inicial seja concluída antes de enviar a automação para mais dois recursos. O sistema envia a automação de forma exponencial para mais recursos até que o valor de simultaneidade seja atingido.
**Limites de erro**
Um limite de erro permite que você especifique quantas automações podem falhar antes que o AWS Systems Manager pare de enviá-las para outros recursos. Você pode especificar um número absoluto de erros, como 10, ou uma porcentagem do conjunto de destino, como 10%.
Se você especificar um número absoluto de 3 erros, por exemplo, o sistema deixará de executar a automação quando o quarto erro for recebido. Se você especificar 0, o sistema deixará de executar a automação em destinos adicionais depois que o primeiro resultado do erro for retornado.
Se você enviar uma automação para 50 instâncias, por exemplo, e definir o limite de erro como 10%, o sistema deixará de enviar o comando para instâncias adicionais quando o quinto erro for recebido. As invocações que já estiverem executando uma automação, quando um limite de erro for atingido, poderão ser concluídas, mas algumas dessas automações também podem falhar. Se você precisar garantir que não haverá mais erros do que o número especificado para o limite de erro, defina o valor de **Concurrency** (Simultaneidade) como 1 para que as automações prossigam uma de cada vez.