• 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).
# AWS Systems Manager Run Command
Usando o Run Command, uma ferramenta do AWS Systems Manager, é possível gerenciar remotamente e de forma segura a configuração de nós gerenciados. O *nó gerenciado* é qualquer instância do Amazon Elastic Compute Cloud (Amazon EC2) ou máquina que não é do EC2 em seu ambiente [híbrido e multinuvem](operating-systems-and-machine-types.md#supported-machine-types), que tenha sido configurada para o Systems Manager. O Run Command permite automatizar tarefas administrativas comuns e executar alterações de configuração únicas em escala. Você pode usar o Run Command a partir do Console de gerenciamento da AWS, da AWS Command Line Interface (AWS CLI), do AWS Tools for Windows PowerShell ou dos AWS SDKs. O Run Command é oferecido sem custo adicional. Para começar a usar o Run Command, abra o [Systems Manager console](https://console.aws.amazon.com//systems-manager/run-command) (Console do gerenciador de sistemas). No painel de navegação, escolha **Run Command**.
Os administradores usam o Run Command para instalar ou fazer bootstrap de aplicações, criar um pipeline de implantação, capturar arquivos de log quando uma instância for removida de um grupo do Auto Scaling, integrar instâncias a um domínio do Windows e muito mais.
A API Run Command segue um modelo de consistência eventual devido à natureza distribuída do sistema que respalda a API. Isso significa que o resultado de um comando da API que for executado e que afete seus recursos poderá não estar imediatamente visível para todos os comandos subsequentes que forem executados. Você deve ter isso em mente ao executar um comando de API que segue imediatamente um comando de API anterior.
**Conceitos básicos**
A tabela a seguir inclui informações para ajudá-lo a começar a trabalhar com o Run Command.
****
| Tópico | Detalhes |
| --- | --- |
| [Configurar nós gerenciados para o AWS Systems Manager](systems-manager-setting-up-nodes.md) | Verifique se você concluiu os requisitos de configuração para instâncias do Amazon Elastic Compute Cloud (Amazon EC2) e máquinas que não são do EC2 em um ambiente [híbrido e multinuvem](operating-systems-and-machine-types.md#supported-machine-types). |
| [Gerenciar nós em ambientes híbridos e multinuvem com o Systems Manager](systems-manager-hybrid-multicloud.md) | (Opcional) Registre servidores on-premises e VMs na AWS para que possa gerenciá-los usando o Run Command. |
| [Gerenciar dispositivos de borda com o Systems Manager](systems-manager-setting-up-edge-devices.md) | (Opcional) Configure dispositivos de borda para que você possa gerenciá-los usando Run Command. |
| [Execução de comandos em nós gerenciados](running-commands.md) | Saiba como executar um comando destinado a um ou mais nós gerenciados usando o Console de gerenciamento da AWS. |
| [Demonstrações do Run Command](run-command-walkthroughs.md) | Saiba como executar comandos usando as Tools for Windows PowerShell ou a AWS CLI. |
**Suporte ao EventBridge**
Essa ferramenta do Systems Manager é compatível com um tipo *evento* e um tipo *destino* nas regras do Amazon EventBridge. Para obter informações, consulte [Monitorar eventos do Systems Manager com o Amazon EventBridge](monitoring-eventbridge-events.md) e [Referência: padrões e tipos de eventos do Amazon EventBridge para o Systems Manager](reference-eventbridge-events.md).
**Mais informações**
+ [Executar o Run Command remotamente em uma instância do EC2 (tutorial de 10 minutos)](https://aws.amazon.com/getting-started/hands-on/remotely-run-commands-ec2-instance-systems-manager/)
+ [Systems Manager service quotas](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) no *Referência geral da Amazon Web Services*
+ [AWS Systems Manager Referência de API](https://docs.aws.amazon.com/systems-manager/latest/APIReference/)
**Topics**
+ [Configurar o Run Command](run-command-setting-up.md)
+ [Execução de comandos em nós gerenciados](running-commands.md)
+ [Uso de códigos de saída em comandos](run-command-handle-exit-status.md)
+ [Noções básicas sobre status de comando](monitor-commands.md)
+ [Demonstrações do Run Command](run-command-walkthroughs.md)
+ [Solução de problemas do Run Commando do Systems Manager](troubleshooting-remote-commands.md)
# Configurar o Run Command
Antes de gerenciar nós usando o Run Command, uma ferramenta do AWS Systems Manager, configure uma política do AWS Identity and Access Management (IAM) para os usuários que executarão comandos. Se você usar alguma chave de condição global para a ação `SendCommand` em suas políticas do IAM, deverá incluir a chave de condição `aws:ViaAWSService` e definir o valor booleano como `true`. Veja um exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": [
"vpce-1234567890abcdef0"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
Você também deve configurar os nós para o Systems Manager. Para obter mais informações, consulte [Configurar nós gerenciados para o AWS Systems Manager](systems-manager-setting-up-nodes.md).
Recomendamos concluir as tarefas de configuração opcionais a seguir para ajudar a minimizar o procedimento de segurança e o gerenciamento diário de seus nós gerenciados.
Monitorar execuções de comandos usando o Amazon EventBridge
É possível usar o EventBridge para registrar em log alterações no status da execução do comando. Você pode criar uma regra que será executada sempre que houver uma transição de estado ou quando houver uma transição para um ou mais estados que sejam de interesse. Você pode também especificar o Run Command como ação de destino quando ocorre um evento do EventBridge. Para obter mais informações, consulte [Configurar o EventBridge para eventos do Systems Manager](monitoring-systems-manager-events.md).
Monitorar execuções de comandos usando o Amazon CloudWatch Logs
É possível configurar o Run Command para enviar periodicamente todos os logs de erros e saída de comandos para um grupo de logs do Amazon CloudWatch. É possível monitorar esses logs de saída quase em tempo real, pesquisar valores, frases específicas ou padrões e criar alarmes com base na pesquisa. Para obter mais informações, consulte [Configurar o Amazon CloudWatch Logs para Run Command](sysman-rc-setting-up-cwlogs.md).
Restringir o acesso do Run Command a nós gerenciados específicos
Você pode restringir a capacidade de um usuário executar comandos em nós gerenciados usando o AWS Identity and Access Management (IAM). Especificamente, é possível criar uma política do IAM com uma condição em que o usuário poderá somente executar comandos em nós gerenciados que são marcados com etiquetas específicas. Para obter mais informações, consulte [Restringir o acesso ao Run Command com base em etiquetas](#tag-based-access).
## Restringir o acesso ao Run Command com base em etiquetas
Esta seção descreve como restringir a capacidade de um usuário executar comandos em nós gerenciados especificando uma condição de etiqueta em uma política do IAM. Os nós gerenciados incluem instâncias do Amazon EC2 e nós que não são do EC2 em um ambiente [híbrido e multinuvem](operating-systems-and-machine-types.md#supported-machine-types) configurado para o Systems Manager. Embora as informações não sejam apresentadas explicitamente, você também pode restringir o acesso a dispositivos principais do AWS IoT Greengrass gerenciados. Para começar, você deve marcar com etiquetas os dispositivos do AWS IoT Greengrass. Para obter mais informações, consulte [Marcar recursos do AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) no *Guia do desenvolvedor do AWS IoT Greengrass Version 2*.
É possível restringir a execução de comandos a nós gerenciados específicos ao criar uma política do IAM que inclua uma condição em que o usuário poderá somente executar comandos em nós que estiverem marcados com etiquetas específicas. No exemplo a seguir, o usuário tem permissão para usar o Run Command (`Effect: Allow, Action: ssm:SendCommand`) usando qualquer documento do SSM (`Resource: arn:aws:ssm:*:*:document/*`) em qualquer nó (`Resource: arn:aws:ec2:*:*:instance/*`) com a condição de que o nó seja um Finance WebServer (`ssm:resourceTag/Finance: WebServer`). Se o usuário enviar um comando para um nó que não esteja marcado ou que possui qualquer outra etiqueta que não seja `Finance: WebServer`, os resultados da execução mostrarão `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:*:*:document/*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ec2:*:*:instance/*"
],
"Condition":{
"StringLike":{
"ssm:resourceTag/Finance":[
"WebServers"
]
}
}
}
]
}
```
------
Você pode criar políticas do IAM que permitem que um usuário execute comandos em nós gerenciados que são marcados com várias etiquetas. A política a seguir permite que o usuário execute comandos em nós gerenciados que têm duas etiquetas. Se um usuário enviar um comando para um nó que não esteja marcado com ambas as etiquetas, os resultados da execução mostrarão `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
],
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Você também pode criar políticas do IAM que permitem que um usuário execute comandos em vários grupos de nós gerenciados marcados. A política de exemplo a seguir permite que o usuário execute comandos em um grupo de nós com etiquetas ou em ambos os grupos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Para obter mais informações sobre como criar políticas do IAM, consulte [Políticas gerenciadas e em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html) no *Guia do usuário do IAM*. Para obter mais informações sobre como marcar nós gerenciados, consulte [Editor de etiquetas](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html) no *Guia do usuário do AWS Resource Groups*.
# Execução de comandos em nós gerenciados
Esta seção inclui informações sobre como enviar comandos do console AWS Systems Managerpara nós gerenciados. Ela também inclui informações sobre como cancelar um comando.
Observe que se seu nó estiver configurado com a opção de montagem `noexec` para o diretório, o Run Command não conseguirá executar comandos com sucesso.
**Importante**
Ao enviar um comando usando o Run Command, não inclua informações confidenciais formatadas como texto sem formatação, como senhas, dados de configuração ou outros segredos. Todas as atividades de API do Systems Manager em sua conta são registradas em um bucket do S3 para logs do AWS CloudTrail. Isso significa que qualquer usuário com acesso ao bucket do S3 poderá visualizar os valores de texto simples desses segredos. Por esse motivo, recomendamos a criação e o uso de parâmetros `SecureString` para criptografar os dados sigilosos que você usa nas operações do Systems Manager.
Para obter mais informações, consulte [Restringir o acesso a parâmetros do Parameter Store usando políticas do IAM](sysman-paramstore-access.md).
**Retenção do histórico de execução**
O histórico de cada comando está disponível por até 30 dias. Além disso, você pode armazenar uma cópia de todos os arquivos de log no Amazon Simple Storage Service ou ter uma trilha de auditoria de todas as chamadas de API em AWS CloudTrail.
**Informações relacionadas**
Para obter informações sobre como enviar comandos usando outras ferramentas, consulte os seguintes tópicos:
+ [Demonstração: Usar a AWS Tools for Windows PowerShell com o Run Command](walkthrough-powershell.md) ou os exemplos na [seção AWS Systems Manager da Referência do Cmdlet Ferramentas da AWS para PowerShell](https://docs.aws.amazon.com/powershell/latest/reference/items/AWS_Systems_Manager_cmdlets.html).
+ [Demonstração: Usar a AWS CLI com o Run Command](walkthrough-cli.md) ou os exemplos na [Referência da CLI do SSM](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
**Topics**
+ [Executar comandos no console](running-commands-console.md)
+ [Execução de comandos usando uma versão específica de documento](run-command-version.md)
+ [Execução de comandos em escala](send-commands-multiple.md)
+ [Cancelar um comando](cancel-run-command.md)
# Executar comandos no console
Você pode usar o Run Command, uma ferramentado AWS Systems Manager no Console de gerenciamento da AWS, para configurar os nós gerenciados sem precisar fazer login neles. Este tópico inclui um exemplo que mostra como [atualizar o SSM Agent](run-command-tutorial-update-software.md#rc-console-agentexample) em um nó gerenciado usando o Run Command.
**Antes de começar**
Antes de enviar um comando usando o Run Command, verifique se os nós gerenciados atendem a todo os [requisitos de configuração](systems-manager-setting-up-nodes.md) do Systems Manager.
**Para enviar um comando usando o Run Command**
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 **Run Command**.
1. Selecione **Run command**.
1. Na lista **Command document** (Documento de comando), escolha um documento do Systems Manager.
1. Na seção **Command parameters**, especifique valores para os parâmetros necessários.
1. Na seção **Targets** (Destinos), escolha os nós gerenciados nos quais você quer executar essa operação, especificando as etiquetas, selecionando as instâncias ou dispositivos de borda manualmente ou especificando um grupo de recursos.
**dica**
Se um nó gerenciado que você espera ver não estiver listado, consulte [Solução de problemas de disponibilidade do nó gerenciado](fleet-manager-troubleshooting-managed-nodes.md) para obter dicas de solução de problemas.
1. Para **Other parameters (Outros parâmetros)**:
+ Em **Comment** (Comentário), digite as informações sobre esse comando.
+ Em **Timeout (seconds) (Tempo limite [segundos])**, especifique o número de segundos para o sistema aguardar até a falha de execução do comando total.
1. Para **Rate control** (Controle de taxa):
+ Em **Concurrency** (Concorrência), especifique um número ou uma porcentagem de nós gerenciados nos quais executar o comando ao mesmo tempo.
**nota**
Se você selecionou destinos especificando tags aplicadas a instâncias a nós gerenciados ou especificando grupos de recursos da AWS, e não tiver certeza de quantas instâncias são direcionadas, restrinja o número de instâncias que poderão executar o documento ao mesmo tempo, especificando uma porcentagem.
+ Em **Error threshold** (Limite de erro), especifique quando parar de executar o comando em outros nós depois de falhar em alguns ou em uma porcentagem de nós. Por exemplo, se você especificar três erros, o Systems Manager deixará de enviar o comando quando o 4° erro for recebido. Os nós gerenciados que continuam processando o comando também podem enviar erros.
1. (Opcional) Escolha um alarme do CloudWatch para aplicar ao seu comando para monitoramento. Para anexar um alarme do CloudWatch ao seu comando, a entidade principal do IAM que executa o comando 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, se o alarme for ativado, quaisquer invocações de comando pendentes não serão executadas.
1. (Opcional) Em **Output options (Opções de saída)**, para salvar a saída do comando em um arquivo, selecione a caixa **Write command output to an S3 bucket (Gravar saída do comando em um bucket do S3)**. Digite os nomes de bucket e prefixo (pastas) nas caixas de texto.
**nota**
As permissões do S3 que concedem a possibilidade de gravar os dados em um bucket do S3 são as do perfil de instância (para instâncias do EC2) ou perfil de serviço do IAM (máquinas ativadas para ambientes híbridos) atribuído à instância, e não as do usuário do IAM que realiza essa tarefa. Para obter mais informações, consulte [Configurar permissões de instância obrigatórias para o Systems Manager](setup-instance-permissions.md) ou [Criar um perfil de serviço do IAM para um ambiente híbrido](hybrid-multicloud-service-role.md). Além disso, se o bucket do S3 especificado estiver em uma conta da Conta da AWS diferente, verifique se o perfil da instância ou a função de serviço do IAM associado ao nó gerenciado tenha as permissões necessárias para gravar nesse bucket.
1. Na seção **SNS notifications** (Notificações do SNS), se quiser enviar notificações sobre o status da execução do comando, marque a caixa de seleção **Enable SNS notifications** (Habilitar notificações do SNS).
Para obter mais informações sobre a configuração de notificações do Amazon SNS para o Run Command, consulte [Monitorar alterações de status do Systems Manager usando as notificações do Amazon SNS](monitoring-sns-notifications.md).
1. Escolha **Executar**.
Para obter informações sobre como cancelar um comando, consulte [Cancelar um comando](cancel-run-command.md).
## Executar comandos novamente
O Systems Manager inclui duas opções para ajudar você a executar novamente um comando na página **Run Command** no console do Systems Manager.
+ **Rerun** (Reexecutar): este botão permite que você execute o mesmo comando sem fazer alterações nele.
+ **Copy to new (Copiar para novo)**: este botão copia as configurações de um comando para um novo comando e dá a você a opção de editar essas configurações antes de executá-lo.
**Como executar novamente um comando**
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 **Run Command**.
1. Escolha um comando a ser reexecutado. É possível executar novamente um comando imediatamente após sua execução na página de detalhes do comando. Ou, é possível escolher um comando que você executou anteriormente na guia **Command history** (Histórico de comandos).
1. Escolha **Rerun (Executar novamente)** para executar o mesmo comando sem alterações ou escolha **Copy to new (Copiar para novo)** para editar as configurações do comando antes de executá-lo.
# Execução de comandos usando uma versão específica de documento
Você pode usar o parâmetro de versão de documento para especificar qual versão de um documento do AWS Systems Manager usar quando o comando for executado. Você pode especificar uma das seguintes opções para este parâmetro:
+ \$1DEFAULT
+ \$1LATEST
+ Número da versão
Execute o procedimento a seguir para executar um comando usando o parâmetro de versão do documento.
------
#### [ Linux ]
**Como executar comandos usando a AWS CLI em máquinas Linux locais**
1. Instale e configure a AWS Command Line Interface (AWS CLI), 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).
1. Listar todos os documentos disponíveis
Esse comando lista todos os documentos disponíveis para sua conta com base em permissões do AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Execute o comando a seguir para visualizar as diferentes versões de um documento. Substitua *nome do documento* pelas próprias informações.
```
aws ssm list-document-versions \
--name "document name"
```
1. Execute o comando a seguir para executar um comando que use uma versão do documento do SSM. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--parameters commands="echo Hello" \
--instance-ids instance-ID \
--document-version '$LATEST'
```
------
#### [ Windows ]
**Como executar comandos usando a AWS CLI em computadores Windows locais**
1. Instale e configure a AWS Command Line Interface (AWS CLI), 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).
1. Listar todos os documentos disponíveis
Esse comando lista todos os documentos disponíveis para sua conta com base em permissões do AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Execute o comando a seguir para visualizar as diferentes versões de um documento. Substitua *nome do documento* pelas próprias informações.
```
aws ssm list-document-versions ^
--name "document name"
```
1. Execute o comando a seguir para executar um comando que use uma versão do documento do SSM. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--parameters commands="echo Hello" ^
--instance-ids instance-ID ^
--document-version "$LATEST"
```
------
#### [ PowerShell ]
**Para executar comandos usando as Tools for PowerShell**
1. Instale e configure o Ferramentas da AWS para PowerShell (Ferramentas para Windows PowerShell), caso ainda não o tenha feito.
Para obter informações, consulte [Instalar o Ferramentas da AWS para PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Listar todos os documentos disponíveis
Esse comando lista todos os documentos disponíveis para sua conta com base em permissões do AWS Identity and Access Management (IAM).
```
Get-SSMDocumentList
```
1. Execute o comando a seguir para visualizar as diferentes versões de um documento. Substitua *nome do documento* pelas próprias informações.
```
Get-SSMDocumentVersionList `
-Name "document name"
```
1. Execute o comando a seguir para executar um comando que use uma versão do documento do SSM. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
```
Send-SSMCommand `
-DocumentName "AWS-RunShellScript" `
-Parameter @{commands = "echo helloWorld"} `
-InstanceIds "instance-ID" `
-DocumentVersion $LATEST
```
------
# Execução de comandos em escala
É possível usar o Run Command, uma ferramenta do AWS Systems Manager, para executar comandos em uma frota de nós gerenciados usando `targets`. O parâmetro `targets` aceita uma combinação `Key,Value` baseada em etiquetas que você especificou para seus nós gerenciados. Quando você executa o comando, o sistema localiza e tenta executar o comando em todos os nós gerenciados que correspondem às etiquetas especificadas. Para obter mais informações sobre como etiquetar instâncias gerenciadas, consulte [Tagging your AWS resources](https://docs.aws.amazon.com/tag-editor/latest/userguide/tag-editor.html) no *Guia do usuário de recursos de marcação da AWS*. Para obter informações sobre como marcar os dispositivos IoT gerenciados, consulte [Marcar com etiqueta os recursos do AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) no *Guia do desenvolvedor do AWS IoT Greengrass Version 2*.
Você também pode usar o parâmetro `targets` para direcionar uma lista de IDs de nós gerenciados específicos, conforme descrito na próxima seção.
Para controlar como os comandos são executados em centenas ou milhares de nós gerenciados, o Run Command também inclui parâmetros para restringir quantos nós podem processar simultaneamente uma solicitação e quantos erros podem ser gerados por um comando antes que ele seja cancelado.
**Topics**
+ [Selecionar vários nós gerenciados como destino](#send-commands-targeting)
+ [Usar controles de taxa](#send-commands-rate)
## Selecionar vários nós gerenciados como destino
Você pode executar um comando e os nós gerenciados de destino especificando etiquetas, nomes de grupos de recursos da AWS ou IDs dos nós gerenciados.
Os exemplos a seguir mostram o formato do comando ao usar o Run Command do AWS Command Line Interface (AWS CLI). Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações. Os comandos de exemplo nesta seção são truncados usando `[...]`.
**Exemplo 1: direcionar tags**
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:tag-name,Values=tag-value \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:tag-name,Values=tag-value ^
[...]
```
------
**Exemplo 2: direcionar um grupo de recursos da AWS por nome**
Você pode especificar um máximo de um nome de grupo de recursos por comando. Ao criar um grupo de recursos, recomendamos incluir `AWS::SSM:ManagedInstance` e `AWS::EC2::Instance` como tipos de recurso em seus critérios de agrupamento.
**nota**
Para enviar comandos que têm um grupo de recursos como destino, você deverá ter recebido permissões do AWS Identity and Access Management (IAM) para listar ou visualizar os recursos que pertencem a esse grupo. Para obter mais informações, consulte [Configurar permissões](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) no *Guia do usuário do AWS Resource Groups*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:Name,Values=resource-group-name \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:Name,Values=resource-group-name ^
[...]
```
------
**Exemplo 3: direcionar um grupo de recursos da AWS por tipo de recurso**
Você pode especificar um máximo de cinco tipos de grupo de recursos por comando. Ao criar um grupo de recursos, recomendamos incluir `AWS::SSM:ManagedInstance` e `AWS::EC2::Instance` como tipos de recurso em seus critérios de agrupamento.
**nota**
Para enviar comandos que têm um grupo de recursos como destino, você deverá ter recebido permissões do IAM para listar ou visualizar os recursos que pertencem a esse grupo. Para obter mais informações, consulte [Configurar permissões](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) no *Guia do usuário do AWS Resource Groups*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 ^
[...]
```
------
**Exemplo 4: IDs de instâncias como destino**
Os exemplos a seguir mostram como direcionar os nós gerenciados usando a chave `instanceids` com o parâmetro `targets`. Você pode usar essa chave para utilizar os dispositivos principais do AWS IoT Greengrass porque cada dispositivo recebe um mi-*ID\$1number*. É possível visualizar os IDs de dispositivos no Fleet Manager, uma ferramenta do AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 ^
[...]
```
------
Se você marcou nós gerenciados para diferentes ambientes usando uma `Key` chamada `Environment` e `Values` de `Development`, `Test`, `Pre-production` e `Production`, poderá enviar um comando para todas os nós gerenciados em *um* desses ambientes usando o parâmetro `targets` com a sintaxe a seguir.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
------
Você pode ter nós gerenciados adicionais como destino em outros ambientes, adicionando à lista `Values`. Separe itens usando vírgulas.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development,Test,Pre-production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development,Test,Pre-production ^
[...]
```
------
**Variação**: refinar os destinos usando vários critérios `Key`
É possível refinar o número de destinos para o seu comando incluindo vários critérios para `Key`. Se você incluir mais de um critério para `Key`, o sistema usará os nós gerenciados que atenderem a *todos* os critérios. O seguinte comando direciona todos os nós gerenciados marcados para o Departamento de finanças *e* marcados para a função de servidor de banco de dados.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database ^
[...]
```
------
**Variação**: usar vários critérios `Key` e `Value`
Expandindo o exemplo anterior, você pode direcionar vários departamentos e várias funções de servidor, incluindo itens adicionais nos critérios `Values`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
**Variação**: definir nós gerenciados marcados como destino usando vários critérios `Values`
Se você marcou nós gerenciados para diferentes ambientes usando uma `Key` chamada `Department` e `Values` de `Sales` e `Finance`, poderá enviar um comando para todas os nós em um desses ambientes usando o parâmetro `targets` com a sintaxe a seguir.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Sales,Finance \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Sales,Finance ^
[...]
```
------
É possível especificar um máximo de cinco chaves e cinco valores para cada chave.
Se uma chave de etiqueta (o nome da etiqueta) ou um valor de etiqueta incluir espaços, você deverá incluir a chave ou o valor da etiqueta entre aspas, conforme mostrado nos exemplos a seguir.
**Exemplo**: espaços na tag `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:OS,Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:OS,Values="Windows Server 2016" ^
[...]
```
------
**Exemplo**: espaços na chave `tag` e em `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key="tag:Operating System",Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key="tag:Operating System",Values="Windows Server 2016" ^
[...]
```
------
**Exemplo**: espaços em um item em uma lista de `Values`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" ^
[...]
```
------
## Usar controles de taxa
Você pode controlar a taxa na qual os comandos são enviados para nós gerenciados em um grupo usando *controles de simultaneidade* e *controles de erro*.
**Topics**
+ [Usar controles de simultaneidade](#send-commands-velocity)
+ [Usar controles de erro](#send-commands-maxerrors)
### Usar controles de simultaneidade
Você pode controlar quantos nós gerenciados executam o comando ao mesmo tempo usando o parâmetro `max-concurrency` (as opções **Concurrency** [Simultaneidade] na página **Run a command** [Executar um comando]). Você pode especificar um número absoluto de nós gerenciados, por exemplo, **10** ou uma porcentagem do conjunto de destino, por exemplo, **10%**. O sistema de enfileiramento entrega o comando a um único nó e aguarda até que o sistema reconheça a invocação inicial antes de enviar o comando para mais dois nós. O sistema envia de forma exponencial comandos para mais nós até que o valor seja atingido `max-concurrency`. O padrão para o valor `max-concurrency` é 50. Os exemplos a seguir mostram como especificar valores para o parâmetro `max-concurrency`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10 \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10% \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10 ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10% ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
### Usar controles de erro
Você também pode controlar a execução de um comando para centenas ou milhares de nós gerenciados definindo um limite de erro usando os parâmetros `max-errors` no campo **Error threshold** (Limitação de erros) na página **Run a command** (Executar um comando). O parâmetro especifica quantos erros são permitidos antes que o sistema pare de enviar o comando para nós gerenciados adicionais. Você pode especificar um número absoluto de erros (por exemplo, **10**) ou uma porcentagem do conjunto de destino (por exemplo, **10%**). Se você especificar **3**, por exemplo, o sistema deixará de enviar o comando quando o quarto erro for recebido. Se você especificar **0**, o sistema deixará de enviar o comando para nós adicionais depois que o primeiro resultado de erro for retornado. Se você enviar um comando para 50 nós gerenciados e definir `max-errors` como **10%**, o sistema deixará de enviar o comando para nós adicionais quando o sexto erro for recebido.
As invocações que já estão executando um comando quando `max-errors` é atingido podem ser concluídas, mas algumas dessas invocações também podem falhar. Para garantir que não haverá mais do que `max-errors` invocações com falha, defina `max-concurrency` como **1** para que as invocações prossigam uma por vez. O padrão para o máximo de erros é 0. Os exemplos a seguir mostram como especificar valores para o parâmetro `max-errors`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-errors 10 \
--targets Key=tag:Database,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-errors 10% \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 1 \
--max-errors 1 \
--targets Key=tag:Environment,Values=Production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10 ^
--targets Key=tag:Database,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10% ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 1 ^
--max-errors 1 ^
--targets Key=tag:Environment,Values=Production ^
[...]
```
------
# Cancelar um comando
Você pode tentar cancelar um comando desde que o serviço mostre que ele está em um estado pendente ou em execução. No entanto, mesmo que um comando ainda esteja em um desses estados, não poderemos garantir que o comando será cancelado e o processo subjacente será interrompido.
**Para cancelar um comando usando o console**
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 **Run Command**.
1. Selecione a invocação do comando que você deseja cancelar.
1. Escolha **Cancel command (Cancelar comando)**.
**Para cancelar um comando usando a AWS CLI**
Execute o seguinte comando . Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm cancel-command \
--command-id "command-ID" \
--instance-ids "instance-ID"
```
------
#### [ Windows ]
```
aws ssm cancel-command ^
--command-id "command-ID" ^
--instance-ids "instance-ID"
```
------
Para obter informações sobre o status de um comando cancelado, consulte [Noções básicas sobre status de comando](monitor-commands.md).
# Uso de códigos de saída em comandos
Em alguns casos, pode ser necessário gerenciar a forma como lidar com seus comandos com o uso de códigos de saída.
## Especifique códigos de saída nos comandos
Usando o Run Command, uma ferramenta do AWS Systems Manager, é possível especificar códigos de saída para determinar como os comandos são tratados. Por padrão, o código de saída do último comando executado em um script é relatado como o código de saída de todo o script. Por exemplo, você tem um script que contém três comandos. O primeiro falha, mas os seguintes são bem-sucedidos. Como o comando final foi bem-sucedido, o status da execução é relatado como `succeeded`.
**Scripts de shell**
Para falhar todo o script na primeira falha do comando, você pode incluir uma instrução condicional shell para sair do script se algum comando antes do final falhar. Use a abordagem a seguir.
```
if [ $? != 0 ]
then
exit
fi
```
No exemplo a seguir, o script inteiro falhará se o primeiro comando falhar.
```
cd /test
if [ $? != 0 ]
then
echo "Failed"
exit 1
fi
date
```
**Scripts PowerShell**
O PowerShell requer que você chame `exit` explicitamente em seus scripts para o Run Command capturar com êxito o código de saída.
```
if ($?) {}
else {exit }
exit
```
Exemplo:
```
cd C:\
if ($?) {echo "Success"}
else {exit 1}
date
```
# Tratamento de reinicializações ao executar comandos
Se você usar o Run Command, uma ferramenta do AWS Systems Manager, para executar scripts que reinicializam os nós gerenciados, recomendamos especificar um código de saída em seu script. Se você tentar reiniciar um nó em um script usando algum outro mecanismo, a execução do script status pode não ser atualizada corretamente, mesmo se a reinicialização for a última etapa em seu script. Para os nós gerenciados do Windows, especifique `exit 3010` em seu script. Para instâncias gerenciadas do Linux e do macOS especifique a `exit 194`. O código de saída instrui o Agente do AWS Systems Manager (SSM Agent) para reinicializar o nó gerenciado e reinicia o script depois que a reinicialização for concluída. Antes de iniciar a reinicialização, o SSM Agent informa o serviço do Systems Manager na nuvem que a comunicação será interrompida durante a reinicialização do servidor.
**nota**
O script de reinicialização não pode fazer parte de um plugin `aws:runDocument`. Se um documento contiver o script de reinicialização e outro documento tentar executar esse documento por meio do plugin `aws:runDocument`, o SSM Agent causará um erro.
**Criar script idempotente**
Ao desenvolver scripts que reinicializam nós gerenciados, torne os scripts idempotentes para que a execução do script continue de onde parou depois da reinicialização. Scripts impotentes gerenciam o estado e validam se a ação foi realizada ou não. Isso evita que uma etapa seja executada várias vezes quando ela deve ser executada apenas uma vez.
Veja a seguir um exemplo de um script idempotente que reinicializa o nó diversas vezes.
```
$name = Get current computer name
If ($name –ne $desiredName)
{
Rename computer
exit 3010
}
$domain = Get current domain name
If ($domain –ne $desiredDomain)
{
Join domain
exit 3010
}
If (desired package not installed)
{
Install package
exit 3010
}
```
**Exemplos**
O script a seguir usa exemplos de códigos de saída para reiniciar nós gerenciados. O exemplo instala atualizações de pacote Linux no Amazon Linux e, em seguida, reinicia o nó. O exemplo do Windows Server instala a aplicação Telnet-Client em seu nó e, em seguida, o reinicia.
------
#### [ Amazon Linux 2 ]
```
#!/bin/bash
yum -y update
needs-restarting -r
if [ $? -eq 1 ]
then
exit 194
else
exit 0
fi
```
------
#### [ Windows ]
```
$telnet = Get-WindowsFeature -Name Telnet-Client
if (-not $telnet.Installed)
{
# Install Telnet and then send a reboot request to SSM Agent.
Install-WindowsFeature -Name "Telnet-Client"
exit 3010
}
```
------
# Noções básicas sobre status de comando
O Run Command, uma ferramenta do AWS Systems Manager, relata informações detalhadas de status sobre os estados diferentes pelos quais um comando passa durante o processamento e para cada nó gerenciado que processou o comando. Você pode monitorar o status de comandos usando os seguintes métodos:
+ Escolha o ícone **Refresh** (Atualizar) na guia **Commands** (Comandos) na interface do console Run Command.
+ Chame [list-commands](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-commands.html) ou [list-command-invocations](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-command-invocations.html) usando a AWS Command Line Interface (AWS CLI) Ou chame [Get-SSMCommand](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommand.html) ou [Get-SSMCommandInvocation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommandInvocation.html) usando o AWS Tools for Windows PowerShell.
+ Configure o Amazon EventBridge para responder a alterações de estado ou status.
+ Configure o Amazon Simple Notification Service (Amazon SNS) para enviar notificações para todas as alterações de status ou para status específicos, como `Failed` ou `TimedOut`.
## Run CommandStatus de
Run CommandO relata detalhes de status para três áreas: plug-ins, invocações e um status de comando geral. Um *plugin* é um bloco de execução de código definido no documento do SSM do comando. Para obter mais informações sobre plug-ins, consulte [Referência de plug-ins de documentos de comando](documents-command-ssm-plugin-reference.md).
Quando você envia um comando para vários nós gerenciados ao mesmo tempo, cada cópia do comando que é dirigida a cada nó é uma *invocação de comando*. Por exemplo, se você usar o documento `AWS-RunShellScript` e enviar um comando `ifconfig` para 20 instâncias Linux, esse comando terá 20 invocações. Cada invocação de comando comunica individualmente o status. Os plug-ins para uma determinada invocação de comando também comunicam individualmente o status.
Por fim, o Run Command inclui um status de comando agregado para todos os plug-ins e invocações. O status do comando agregado pode ser diferente do status relatado por plug-ins ou invocações, conforme observado nas tabelas a seguir.
**nota**
Se você executar comandos para vários nós gerenciados usando os parâmetros `max-concurrency` ou `max-errors`, o status do comando refletirá os limites impostos por esses parâmetros, conforme descrito nas tabelas a seguir. Para mais informações sobre esses parâmetros, consulte [Execução de comandos em escala](send-commands-multiple.md).
**Status detalhado para plug-ins de comandos e invocações**
| Status | Detalhes |
| --- | --- |
| Pendente | O comando ainda não foi enviado para o nó gerenciado ou não foi recebido pelo SSM Agent. Se o comando não for recebido pelo agente antes do período de tempo que igual à soma dos parâmetros Timeout (seconds) (Tempo limite (segundos) e Execution timeout (Tempo limite de execução), o status será alterado para Delivery Timed Out. |
| InProgress | O Systems Manager está tentando enviar o comando para o nó gerenciado ou o comando foi recebido pelo SSM Agent e começou a ser executado na instância. Dependendo do resultado de todos os plugins de comando, o status mudará para Success, Failed Delivery Timed Out ou Execution Timed Out. Exceção: se o agente não estiver em execução ou disponível em um nó, o status do comando permanecerá em In Progress até que o agente esteja disponível novamente ou até que o limite de runtime seja atingido. O status mudará para um estado terminal. |
| Atrasado | O sistema tentou enviar o comando para o nó gerenciado, mas não foi bem-sucedido. O sistema tenta novamente. |
| Bem-sucedida | Este status é retornado sob várias condições. Esse status não significa que o comando foi processado nesse nó. Por exemplo, o comando pode ser recebido pelo SSM Agent no nó gerenciado e retornar um código de saída zero porque o PowerShell ExecutionPolicy impediu a execução do comando. Este é um estado terminal. As condições que resultam em um comando retornando um status Success são: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/monitor-commands.html) As mesmas condições se aplicam ao segmentar grupos de recursos. Para solucionar erros ou obter mais informações sobre a execução de comandos, envie um comando que manipule erros ou exceções retornando códigos de saída apropriados (códigos de saída diferentes de zero para falhas de comando). |
| DeliveryTimedOut | O comando não foi entregue ao nó gerenciado antes do tempo limite total expirado. Os tempos limite totais não contam para o limite de max-errors do comando pai, mas contribuem para determinar se o status do comando pai é Success, Incomplete ou Delivery Timed Out. Este é um estado terminal. |
| ExecutionTimedOut | A automação do comando foi iniciada no nó gerenciado, mas o comando não foi concluído antes do tempo limite de execução expirar. Os tempos limite de execução contam como uma falha, que enviará uma resposta diferente de zero e o Systems Manager encerrará a tentativa de executar a automação de comando e relatará um status de falha. |
| Failed | O comando não foi bem-sucedido em seu nó gerenciado. Para um plugin, isso indica que o código do resultado não foi zero. Para uma invocação de comando, isso indica que o código de resultado para um ou mais plug-ins não foi zero. Falhas de invocação contam para o limite max-errors do comando pai. Este é um estado terminal. |
| Cancelado | O comando foi cancelado antes de ser concluído. Este é um estado terminal. |
| Não é possível entregar | O comando não pode ser entregue ao nó gerenciado. O nó pode não existir ou pode não estar respondendo. Invocações não entregues não contam para o limite de max-errors do comando pai, mas não contribuem para determinar se o status do comando pai é Success ou Incomplete. Por exemplo, se todas as invocações em um comando tiverem o status Undeliverable, o status do comando retornado será Failed. No entanto, se um comando tiver cinco invocações, quatro das quais retornarem o status Undeliverable e uma retornar o status Success, o status do comando pai será Success. Este é um estado terminal. |
| Terminated (Encerrado) | O comando pai excedeu o limite de max-errors e as invocações de comando subsequentes foram canceladas pelo sistema. Este é um estado terminal. |
| InvalidPlatform | O comando foi enviado a um nó gerenciado que não correspondeu às plataformas necessárias especificadas pelo documento escolhido. O Invalid Platform não é considerado para o limite máximo de erros do comando pai, mas contribui para determinar se o status do comando pai é Success (Êxito) ou Failed (Falha). Por exemplo, se todas as invocações em um comando tiverem o status Invalid Platform, o status do comando retornado será Failed. No entanto, se um comando tiver cinco invocações, quatro das quais retornarem o status Invalid Platform e uma retornar o status Success, o status do comando pai será Success. Este é um estado terminal. |
| AccessDenied | O usuário ou a função do AWS Identity and Access Management (IAM) que inicia o comando não tem acesso ao nó gerenciado de destino. O Access Denied não é considerado no limite max-errors do comando pai, mas contribuirá se o status do comando pai for Success ou Failed. Por exemplo, se todas as invocações em um comando tiverem o status Access Denied, o status do comando retornado será Failed. No entanto, se um comando tiver cinco invocações, quatro das quais retornarem o status Access Denied e uma retornar o status Success, o status do comando pai será Success. Este é um estado terminal. |
**Status detalhado de um comando**
| Status | Detalhes |
| --- | --- |
| Pendente | O comando ainda não foi recebido por um agente em um nó gerenciado. |
| InProgress | O comando foi enviado para pelo menos um nó gerenciado, mas não chegou a um estado final em todos os nós. |
| Atrasado | O sistema tentou enviar o comando para o nó, mas não foi bem-sucedido. O sistema tenta novamente. |
| Bem-sucedida | O comando foi recebido pelo SSM Agent em todos nós gerenciados especificados ou definidos como destino e retornou um código de saída igual a zero. Todas as invocações de comando atingiram um estado terminal e o valor de max-errors não foi alcançado. Esse status não significa que o comando foi processado com sucesso em todos os nós gerenciados especificados ou de destino. Este é um estado terminal. Para solucionar erros ou obter mais informações sobre a execução de comandos, envie um comando que manipule erros ou exceções retornando códigos de saída apropriados (códigos de saída diferentes de zero para falhas de comando). |
| DeliveryTimedOut | O comando não foi entregue ao nó gerenciado antes do tempo limite total expirado. O valor de max-errors ou mais invocações de comandos mostram um status de Delivery Timed Out. Este é um estado terminal. |
| Failed | O comando não foi bem-sucedido em seu nó gerenciado. O valor de `max-errors` ou mais invocações de comandos mostram um status de `Failed`. Este é um estado terminal. |
| Incompleto | O comando foi tentado em todos os nós gerenciados, e uma ou mais das invocações não tem um valor de Success. No entanto, não houve um número suficiente de invocações com falha para que o status fosse Failed. Este é um estado terminal. |
| Cancelado | O comando foi cancelado antes de ser concluído. Este é um estado terminal. |
| RateExceeded | O número de nós gerenciados visados pelo comando excedeu o limite da conta para invocações pendentes. O sistema cancelou o comando antes de executá-lo em qualquer nó. Este é um estado terminal. |
| AccessDenied | O usuário ou o perfil que inicia o comando não tem acesso ao grupo de recursos de destino. O AccessDenied não é contabilizado em relação ao limite max-errors do comando pai, mas contribuirá se o status do comando pai for Success ou Failed. (Por exemplo, se todas as invocações em um comando tiverem o status AccessDenied, então o status do comando retornado será Failed. No entanto, se um comando tiver cinco invocações, quatro das quais retornarem o status AccessDenied e uma retornou o status Success, então o status do comando pai será Success.) Este é um estado terminal. |
| Nenhuma instância na tag | O valor do par de chaves da etiqueta ou o grupo de recursos visado pelo comando não corresponde a nenhum nó gerenciado. Este é um estado terminal. |
## Noções básicas sobre valores de tempo limite de comandos
O Systems Manager impõe os seguintes valores de tempo limite ao executar comandos.
**Tempo limite total**
No console do Systems Manager, especifique o valor do tempo limite de entrega no campo **Timeout (seconds)** (Tempo limite [segundos]). Depois que um comando é enviado, o Run Command verifica se o comando expirou ou não. Se um comando atingir o limite de expiração do comando (tempo limite total), ele altera o status para`DeliveryTimedOut`para todas as invocações que têm o status`InProgress`,`Pending`ou`Delayed`.
![\[O campo Timeout (seconds) (Tempo limite (segundos)) no console do Systems Manager\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/run-command-delivery-time-out-time-out-seconds.png)
Em um nível mais técnico, o **Timeout (seconds)** (Tempo limite [segundos]) total é uma combinação de dois valores de tempo limite, como mostrado aqui:
`Total timeout = "Timeout(seconds)" from the console + "timeoutSeconds": "{{ executionTimeout }}" from your SSM document`
Por exemplo, o valor padrão de **Timeout (seconds)** (Tempo limite em segundos) no console do Systems Manager é de 600 segundos. Se você executar um comando usando o comando`AWS-RunShellScript`Documento do SSM, o valor padrão de**“TimeoutSeconds”: “\$1\$1executionTimeout\$1\$1”**é 3600 segundos, como mostrado na seguinte amostra de documento:
```
"executionTimeout": {
"type": "String",
"default": "3600",
"runtimeConfig": {
"aws:runShellScript": {
"properties": [
{
"timeoutSeconds": "{{ executionTimeout }}"
```
Isso significa que o comando é executado por 4.200 segundos (70 minutos) antes que o sistema defina o status do comando como `DeliveryTimedOut`.
**Tempo limite de execução**
No console do Systems Manager, especifique o valor do tempo limite de execução no campo **Execution Timeout** (Tempo limite de execução), se disponível. Nem todos os documentos do SSM exigem especificar um tempo limite de execução. O campo **Execution Timeout** (Tempo limite de execução) é exibido somente quando um parâmetro de entrada correspondente foi definido no documento SSM. Se especificado, o comando deve ser concluído dentro desse período.
**nota**
O Run Command depende da resposta do terminal SSM Agent para determinar se o comando foi entregue ou não ao agente. O SSM Agent deve enviar um sinal do `ExecutionTimedOut` para uma invocação ou comando a ser marcado como `ExecutionTimedOut`.
![\[O campo Execution Timeout (Tempo limite de execução) no console do Systems Manager\]](http://docs.aws.amazon.com/pt_br/systems-manager/latest/userguide/images/run-command-execution-timeout-console.png)
**Tempo limite de execução padrão**
Se um documento do SSM do não exigir especificar explicitamente um valor de tempo limite de execução, o Systems Manager vai impor o tempo limite de execução padrão codificado.
**Como o Systems Manager relata os tempos limite**
Se o Systems Manager receber uma resposta `execution timeout` do SSM Agent em um destino, o Systems Manager marcará a invocação do comando como `executionTimeout`.
SeRun Commandnão recebe uma resposta de terminal de documento deSSM Agent, a invocação do comando é marcada como`deliveryTimeout`.
Para determinar o status de tempo limite em um destino, o SSM Agent combina todos os parâmetros e o conteúdo do documento do SSM para o qual será calculado `executionTimeout`. Quando o SSM Agent determinar que um comando expirou, ele enviará `executionTimeout` para o serviço.
O padrão para**Tempo limite (segundos)**é de 3600 segundos. O padrão para**Tempo limite de execução**também é 3600 segundos. Portanto, o tempo limite padrão total para um comando é 7200 segundos.
**nota**
O SSM Agent processa `executionTimeout` de forma diferente dependendo do tipo de documento do SSM e da versão do documento.
# Demonstrações do Run Command
As demonstrações nesta seção mostram como executar comandos com o Run Command, uma ferramenta do AWS Systems Manager, usando a AWS Command Line Interface (AWS CLI) ou o AWS Tools for Windows PowerShell.
**Topics**
+ [Atualização de softwares usando Run Command](run-command-tutorial-update-software.md)
+ [Demonstração: Usar a AWS CLI com o Run Command](walkthrough-cli.md)
+ [Demonstração: Usar a AWS Tools for Windows PowerShell com o Run Command](walkthrough-powershell.md)
Você também pode ver comandos de exemplo nas seguintes referências.
+ [Systems Manager (Gerenciador de sistemas)AWS CLIReferência do](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
+ [AWS Tools for Windows PowerShell - AWS Systems Manager](https://docs.aws.amazon.com/powershell/latest/reference/items/SimpleSystemsManagement_cmdlets.html)
# Atualização de softwares usando Run Command
O procedimento a seguir descreve como atualizar softwares em seus nós gerenciados.
## Atualização do SSM Agent por meio de Run Command
O procedimento a seguir descreve como atualizar o SSM Agent em execução em seus nós gerenciados. Você pode atualizar para a versão mais recente do SSM Agent ou fazer downgrade para uma versão mais antiga. Quando você executa o comando, o sistema faz download da versão da AWS, instala essa versão e desinstala a versão que existia antes do comando ser executado. Se ocorrer um erro durante esse processo, o sistema retornará à versão no servidor antes de o comando ser executado, e o status do comando mostrará que o comando falhou.
**nota**
Se uma instância estiver sendo executada no macOS versão 13.0 (Ventura) ou posterior, a instância deverá ter o SSM Agent versão 3.1.941.0 ou superior para executar o documento AWS-UpdateSSMAgent. Se a instância estiver executando uma versão do SSM Agent lançada antes da 3.1.941.0, você poderá atualizar o SSM Agent para executar o documento AWS-UpdateSSMAgentexecutando os comandos `brew upgrade amazon-ssm-agent` e `brew update`.
Para receber notificações sobre atualizações do SSM Agent, inscreva-se na página [Notas de versão do SSM Agent](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) no GitHub.
**Para atualizar o SSM Agent usando o Run Command**
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 **Run Command**.
1. Selecione **Run command**.
1. Na lista **Command document** (Documento do comando), escolha **`AWS-UpdateSSMAgent`**.
1. Na seção **Command parameters**, especifique valores para os parâmetros a seguir, se desejar:
1. (Opcional) Em **Version** (Versão), digite a versão do SSM Agent a ser instalada. Você pode instalar [versões antigas](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) do agente. Se você não especificar uma versão, o serviço instalará a versão mais recente.
1. (Opcional) Para **Allow Downgrade (Permitir downgrade)**, escolha **true** para instalar uma versão anterior do SSM Agent. Se você escolher essa opção, especifique o número da versão [antiga](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md). Escolha **false** para instalar apenas a versão mais recente do serviço.
1. Na seção **Targets** (Destinos), escolha os nós gerenciados nos quais você quer executar essa operação, especificando as etiquetas, selecionando as instâncias ou dispositivos de borda manualmente ou especificando um grupo de recursos.
**dica**
Se um nó gerenciado que você espera ver não estiver listado, consulte [Solução de problemas de disponibilidade do nó gerenciado](fleet-manager-troubleshooting-managed-nodes.md) para obter dicas de solução de problemas.
1. Para **Other parameters (Outros parâmetros)**:
+ Em **Comment** (Comentário), digite as informações sobre esse comando.
+ Em **Timeout (seconds) (Tempo limite [segundos])**, especifique o número de segundos para o sistema aguardar até a falha de execução do comando total.
1. Para **Rate control** (Controle de taxa):
+ Em **Concurrency** (Concorrência), especifique um número ou uma porcentagem de nós gerenciados nos quais executar o comando ao mesmo tempo.
**nota**
Se você selecionou destinos especificando tags aplicadas a instâncias a nós gerenciados ou especificando grupos de recursos da AWS, e não tiver certeza de quantas instâncias são direcionadas, restrinja o número de instâncias que poderão executar o documento ao mesmo tempo, especificando uma porcentagem.
+ Em **Error threshold** (Limite de erro), especifique quando parar de executar o comando em outros nós depois de falhar em alguns ou em uma porcentagem de nós. Por exemplo, se você especificar três erros, o Systems Manager deixará de enviar o comando quando o 4° erro for recebido. Os nós gerenciados que continuam processando o comando também podem enviar erros.
1. (Opcional) Em **Output options (Opções de saída)**, para salvar a saída do comando em um arquivo, selecione a caixa **Write command output to an S3 bucket (Gravar saída do comando em um bucket do S3)**. Digite os nomes de bucket e prefixo (pastas) nas caixas de texto.
**nota**
As permissões do S3 que concedem a possibilidade de gravar os dados em um bucket do S3 são as do perfil de instância (para instâncias do EC2) ou perfil de serviço do IAM (máquinas ativadas para ambientes híbridos) atribuído à instância, e não as do usuário do IAM que realiza essa tarefa. Para obter mais informações, consulte [Configurar permissões de instância obrigatórias para o Systems Manager](setup-instance-permissions.md) ou [Criar um perfil de serviço do IAM para um ambiente híbrido](hybrid-multicloud-service-role.md). Além disso, se o bucket do S3 especificado estiver em uma conta da Conta da AWS diferente, verifique se o perfil da instância ou a função de serviço do IAM associado ao nó gerenciado tenha as permissões necessárias para gravar nesse bucket.
1. Na seção **SNS notifications** (Notificações do SNS), se quiser enviar notificações sobre o status da execução do comando, marque a caixa de seleção **Enable SNS notifications** (Habilitar notificações do SNS).
Para obter mais informações sobre a configuração de notificações do Amazon SNS para o Run Command, consulte [Monitorar alterações de status do Systems Manager usando as notificações do Amazon SNS](monitoring-sns-notifications.md).
1. Escolha **Executar**.
## Atualização da PowerShell por meio de Run Command
O procedimento a seguir descreve como atualizar o PowerShell para a versão 5.1 em seus nós gerenciados do Windows Server 2012 e 2012 R2. O script fornecido neste procedimento transfere a actualização do Windows Management Framework (WMF) versão 5.1 e inicia a instalação da actualização. Os nós são reinicializados durante esse processo porque isso é necessário ao instalar o WMF 5.1. O download e a instalação da atualização demoram aproximadamente cinco minutos para serem concluídos.
**Para atualizar o PowerShell usando Run Command**
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 **Run Command**.
1. Selecione **Run command**.
1. Na lista **Command document** (Documento do comando), escolha **`AWS-RunPowerShellScript`**.
1. No**Comandos**Colar os comandos a seguir para o sistema operacional.
------
#### [ Windows Server 2012 R2 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839516" -OutFile "Win8.1AndW2K12R2-KB3191564-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('Win8.1AndW2K12R2-KB3191564-x64.msu', '/quiet')
```
------
#### [ Windows Server 2012 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839513" -OutFile "W2K12-KB3191565-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('W2K12-KB3191565-x64.msu', '/quiet')
```
------
1. Na seção **Targets** (Destinos), escolha os nós gerenciados nos quais você quer executar essa operação, especificando as etiquetas, selecionando as instâncias ou dispositivos de borda manualmente ou especificando um grupo de recursos.
**dica**
Se um nó gerenciado que você espera ver não estiver listado, consulte [Solução de problemas de disponibilidade do nó gerenciado](fleet-manager-troubleshooting-managed-nodes.md) para obter dicas de solução de problemas.
1. Para **Other parameters (Outros parâmetros)**:
+ Em **Comment** (Comentário), digite as informações sobre esse comando.
+ Em **Timeout (seconds) (Tempo limite [segundos])**, especifique o número de segundos para o sistema aguardar até a falha de execução do comando total.
1. Para **Rate control** (Controle de taxa):
+ Em **Concurrency** (Concorrência), especifique um número ou uma porcentagem de nós gerenciados nos quais executar o comando ao mesmo tempo.
**nota**
Se você selecionou destinos especificando tags aplicadas a instâncias a nós gerenciados ou especificando grupos de recursos da AWS, e não tiver certeza de quantas instâncias são direcionadas, restrinja o número de instâncias que poderão executar o documento ao mesmo tempo, especificando uma porcentagem.
+ Em **Error threshold** (Limite de erro), especifique quando parar de executar o comando em outros nós depois de falhar em alguns ou em uma porcentagem de nós. Por exemplo, se você especificar três erros, o Systems Manager deixará de enviar o comando quando o 4° erro for recebido. Os nós gerenciados que continuam processando o comando também podem enviar erros.
1. (Opcional) Em **Output options (Opções de saída)**, para salvar a saída do comando em um arquivo, selecione a caixa **Write command output to an S3 bucket (Gravar saída do comando em um bucket do S3)**. Digite os nomes de bucket e prefixo (pastas) nas caixas de texto.
**nota**
As permissões do S3 que concedem a possibilidade de gravar os dados em um bucket do S3 são as do perfil de instância (para instâncias do EC2) ou perfil de serviço do IAM (máquinas ativadas para ambientes híbridos) atribuído à instância, e não as do usuário do IAM que realiza essa tarefa. Para obter mais informações, consulte [Configurar permissões de instância obrigatórias para o Systems Manager](setup-instance-permissions.md) ou [Criar um perfil de serviço do IAM para um ambiente híbrido](hybrid-multicloud-service-role.md). Além disso, se o bucket do S3 especificado estiver em uma conta da Conta da AWS diferente, verifique se o perfil da instância ou a função de serviço do IAM associado ao nó gerenciado tenha as permissões necessárias para gravar nesse bucket.
1. Na seção **SNS notifications** (Notificações do SNS), se quiser enviar notificações sobre o status da execução do comando, marque a caixa de seleção **Enable SNS notifications** (Habilitar notificações do SNS).
Para obter mais informações sobre a configuração de notificações do Amazon SNS para o Run Command, consulte [Monitorar alterações de status do Systems Manager usando as notificações do Amazon SNS](monitoring-sns-notifications.md).
1. Escolha **Executar**.
Depois que a reinicialização do nó gerenciado e a instalação da atualização estiver concluída, conecte-se ao nó para confirmar se o PowerShell foi atualizado com êxito para a versão 5.1. Para conferir a versão do PowerShell em seu nó, abra o PowerShell e digite `$PSVersionTable`. O`PSVersion`na tabela de saída mostra 5.1 se a atualização foi bem-sucedida.
Se o `PSVersion` for diferente de 5.1, por exemplo 3.0 ou 4.0, consulte os logs de **Configuração** no Visualizador de eventos em **Logs do Windows**. Esses logs indicam por que a instalação da atualização falhou.
# Demonstração: Usar a AWS CLI com o Run Command
A demonstração de exemplo a seguir mostra como usar a AWS Command Line Interface (AWS CLI) para ver informações sobre comandos e parâmetros de comando, como executar comandos e como visualizar o status desses comandos.
**Importante**
Apenas administradores confiáveis devem ter permissão para usar os documentos pré-configurados do AWS Systems Manager mostrados neste tópico. Os comandos ou scripts especificados em documentos do Systems Manager são executados com permissões administrativas em seus nós. Se um usuário tiver permissão para executar qualquer um dos documentos do Systems Manager predefinidos (qualquer documento que comece com `AWS-`), ele também terá acesso de administrador ao nó. Para todos os outros usuários, você deve criar documentos restritivos e compartilhá-los com usuários específicos.
**Topics**
+ [Etapa 1: Conceitos básicos](#walkthrough-cli-settings)
+ [Etapa 2: Executar scripts de shell para exibir detalhes de recursos](#walkthrough-cli-run-scripts)
+ [Etapa 3: Enviar comandos simples usando o documento `AWS-RunShellScript`](#walkthrough-cli-example-1)
+ [Etapa 4: Executar um script Python simples usando o Run Command](#walkthrough-cli-example-2)
+ [Etapa 5: Rodar um script Bash usando Run Command](#walkthrough-cli-example-3)
## Etapa 1: Conceitos básicos
Você deve ter permissões de administrador sobre o nó gerenciado que deseja configurar ou deve ter recebido a permissão apropriada no AWS Identity and Access Management (IAM). Veja também que o exemplo usa região Leste dos EUA (Ohio) (us-east-2). O Run Command está disponível nas Regiões da AWS listadas em [Systems Manager service endpoints](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) no *Referência geral da Amazon Web Services*. Para obter mais informações, consulte [Configurar nós gerenciados para o AWS Systems Manager](systems-manager-setting-up-nodes.md).
**Para executar comandos usando a AWS CLI**
1. Instale e configure a AWS Command Line Interface (AWS CLI), 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).
1. Liste todos os documentos disponíveis.
Esse comando lista todos os documentos disponíveis para sua conta com base em permissões do IAM.
```
aws ssm list-documents
```
1. Verifique se um nó está pronto para receber comandos.
A saída do comando a seguir mostra se os nós gerenciados estão online.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--output text --query "InstanceInformationList[*]"
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--output text --query "InstanceInformationList[*]"
```
------
1. Execute o comando a seguir para ver detalhes sobre um nó gerenciado específico.
**nota**
Para executar os comandos nessa demonstração, substitua os IDs de instância e comando. Para os dispositivos gerenciados principais do AWS IoT Greengrass, use o mi-*ID\$1number* para o ID da instância. O ID do comando é retornado como uma resposta ao **send-command**. Os IDs de instância estão disponíveis no Fleet Manager, uma ferramenta do AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
## Etapa 2: Executar scripts de shell para exibir detalhes de recursos
Por meio do Run Command e do documento `AWS-RunShellScript`, você pode executar qualquer comando ou script em um nó gerenciado, como se estivesse conectado localmente.
**Veja a descrição e os parâmetros disponíveis**
Use o seguinte comando para visualizar uma descrição do documento JSON do Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "[Document.Name,Document.Description]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "[Document.Name,Document.Description]"
```
------
Use o comando a seguir para visualizar os parâmetros e detalhes disponíveis sobre esses parâmetros.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "Document.Parameters[*]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "Document.Parameters[*]"
```
------
## Etapa 3: Enviar comandos simples usando o documento `AWS-RunShellScript`
Execute o comando a seguir para obter informações de IP para um nó do Linux.
Se você estiver segmentando um nó gerenciado do Windows Server, altere o `document-name` para `AWS-RunPowerShellScript` e altere o `command` de `ifconfig` para `ipconfig`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "IP config" \
--parameters commands=ifconfig \
--output text
```
------
#### [ Windows ]
```
aws ssm send-command ^
--instance-ids "instance-ID" ^
--document-name "AWS-RunShellScript" ^
--comment "IP config" ^
--parameters commands=ifconfig ^
--output text
```
------
**Obter informações de comando com dados de resposta**
O comando a seguir usa o ID de Comando que foi retornado do comando anterior para obter os detalhes e os dados de resposta da execução do comando. O sistema retorna os dados da resposta se o comando for concluído. Se a execução do comando mostrar `"Pending"` ou `"InProgress"`, execute esse comando novamente para ver os dados de resposta.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id $sh-command-id \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id $sh-command-id ^
--details
```
------
**Identificar usuário**
O comando a seguir exibe o usuário padrão que executa os comandos.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux managed node" \
--parameters commands=whoami \
--output text \
--query "Command.CommandId")
```
------
**Obter status do comando**
O comando a seguir usa o ID de Comando para obter o status da execução do comando em nós gerenciados. Este exemplo usa o ID de comando que foi retornado no comando anterior.
------
#### [ Linux & macOS ]
```
aws ssm list-commands \
--command-id "command-ID"
```
------
#### [ Windows ]
```
aws ssm list-commands ^
--command-id "command-ID"
```
------
**Obter detalhes do comando**
O comando a seguir usa o ID do comando anterior para obter o status da execução do comando por nó gerenciado.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id "command-ID" ^
--details
```
------
**Obter informações de comando com dados de resposta para um nó gerenciado específico**
O comando a seguir retorna a saída da solicitação `aws ssm send-command` original para um nó específico.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--instance-id instance-ID \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--instance-id instance-ID ^
--command-id "command-ID" ^
--details
```
------
**Exibir versão do Python**
O comando a seguir retorna a versão do Python em execução em um nó.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters commands='python -V' \
--output text --query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Etapa 4: Executar um script Python simples usando o Run Command
O comando a seguir executa um script simples Python “Hello World” usando o Run Command.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters '{"commands":["#!/usr/bin/python","print \"Hello World from python\""]}' \
--output text \
--query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Etapa 5: Rodar um script Bash usando Run Command
Os exemplos nesta seção demonstram como executar o seguinte script bash usando Run Command.
Para obter exemplos de uso do Run Command para executar scripts armazenados em locais remotos, consulte [Executar scripts no Amazon S3](integration-s3.md) e [Executar scripts do GitHub](integration-remote-scripts.md).
```
#!/bin/bash
yum -y update
yum install -y ruby
cd /home/ec2-user
curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
```
Este script instala o agente do AWS CodeDeploy no Amazon Linux e no Red Hat Enterprise Linux (RHEL), como descrito em [Criar uma instância do Amazon EC2 para CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-ec2-create.html) no *Guia do usuário do AWS CodeDeploy*.
O script instala o agente CodeDeploy de um bucket do S3 gerenciado pela AWS na região Leste dos EUA (Ohio) (us-east-2), `aws-codedeploy-us-east-2`.
**Execute um script bash em umAWS CLIComando da**
O exemplo a seguir demonstra como incluir o script bash em um comando da CLI usando o comando`--parameters`opção.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets '[{"Key":"InstanceIds","Values":["instance-id"]}]' \
--parameters '{"commands":["#!/bin/bash","yum -y update","yum install -y ruby","cd /home/ec2-user","curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install","chmod +x ./install","./install auto"]}'
```
------
**Executar um script bash em um arquivo JSON**
No exemplo a seguir, o conteúdo do script bash é armazenado em um arquivo JSON e o arquivo é incluído no comando usando o`--cli-input-json`opção.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets "Key=InstanceIds,Values=instance-id" \
--cli-input-json file://installCodeDeployAgent.json
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--targets "Key=InstanceIds,Values=instance-id" ^
--cli-input-json file://installCodeDeployAgent.json
```
------
O conteúdo do arquivo `installCodeDeployAgent.json` mencionado é mostrado no exemplo a seguir.
```
{
"Parameters": {
"commands": [
"#!/bin/bash",
"yum -y update",
"yum install -y ruby",
"cd /home/ec2-user",
"curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install",
"chmod +x ./install",
"./install auto"
]
}
}
```
# Demonstração: Usar a AWS Tools for Windows PowerShell com o Run Command
Os exemplos a seguir mostram como usar o AWS Tools for Windows PowerShell para ver informações sobre comandos e parâmetros de comandos, como executar comandos e como visualizar o status desses comandos. Essa demonstração inclui um exemplo para cada um dos documentos do AWS Systems Manager predefinidos.
**Importante**
Apenas administradores confiáveis devem ter permissão para usar os documentos pré-configurados do Systems Manager mostrados neste tópico. Os comandos ou scripts especificados em documentos do Systems Manager são executados com permissão administrativa em seus nós gerenciados. Se um usuário tiver permissão para executar qualquer um dos documentos do Systems Manager predefinidos (qualquer documento que comece com AWS), ele também terá acesso de administrador ao nó. Para todos os outros usuários, você deve criar documentos restritivos e compartilhá-los com usuários específicos.
**Topics**
+ [Definir configurações de sessão do AWS Tools for Windows PowerShell](#walkthrough-powershell-settings)
+ [Listar todos os documentos disponíveis](#walkthrough-powershell-all-documents)
+ [Executar comandos ou scripts do PowerShell](#walkthrough-powershell-run-script)
+ [Instalar uma aplicação usando o documento `AWS-InstallApplication`](#walkthrough-powershell-install-application)
+ [Instalar um módulo do PowerShell usando a`AWS-InstallPowerShellModule`Documento JSON](#walkthrough-powershell-install-module)
+ [Integrar um nó gerenciado a um domínio usando o documento JSON `AWS-JoinDirectoryServiceDomain`](#walkthrough-powershell-domain-join)
+ [Enviar métricas do Windows ao Amazon CloudWatch Logs usando o documento `AWS-ConfigureCloudWatch`](#walkthrough-powershell-windows-metrics)
+ [Ative ou desative a atualização automática do Windows usando o`AWS-ConfigureWindowsUpdate`document](#walkthrough-powershell-enable-windows-update)
+ [Gerenciar atualizações do Windows usando o Run Command](#walkthough-powershell-windows-updates)
## Definir configurações de sessão do AWS Tools for Windows PowerShell
**Especificar suas credenciais**
Abra as **Tools for Windows PowerShell** no computador local e execute o comando a seguir para especificar suas credenciais. Você deve ter permissões de administrador sobre os nós gerenciados que deseja configurar ou deve ter recebido a permissão apropriada no AWS Identity and Access Management (IAM). Para obter mais informações, consulte [Configurar nós gerenciados para o AWS Systems Manager](systems-manager-setting-up-nodes.md).
```
Set-AWSCredentials –AccessKey key-name –SecretKey key-name
```
**Definir uma padrão Região da AWS**
Execute o comando a seguir para definir a região da sua sessão do PowerShell. O exemplo usa região Leste dos EUA (Ohio) (us-east-2). O Run Command está disponível nas Regiões da AWS listadas em [Systems Manager service endpoints](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) no *Referência geral da Amazon Web Services*.
```
Set-DefaultAWSRegion `
-Region us-east-2
```
## Listar todos os documentos disponíveis
Esse comando lista todos os documentos disponíveis para a sua conta.
```
Get-SSMDocumentList
```
## Executar comandos ou scripts do PowerShell
Por meio do Run Command e do documento `AWS-RunPowerShell`, você pode executar qualquer comando ou script em um nó gerenciado, como se estivesse conectado localmente. Você pode emitir comandos ou inserir um caminho para um script local para executar o comando.
**nota**
Para obter informações sobre a reinicialização de nós gerenciados ao usar o Run Command para chamar scripts, consulte [Tratamento de reinicializações ao executar comandos](send-commands-reboot.md).
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript" | Select -ExpandProperty Parameters
```
### Enviar um comando usando o documento `AWS-RunPowerShellScript`
O comando a seguir mostra o conteúdo do diretório `"C:\Users"` e o conteúdo do diretório `"C:\"` em dois nós.
```
$runPSCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1", "instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'=@('dir C:\Users', 'dir C:\')}
```
**Obter detalhes da solicitação de comando**
O comando a seguir usa o `CommandId` para obter o status da execução do comando em ambos os nós. Este exemplo usa o `CommandId` que foi retornado no comando anterior.
```
Get-SSMCommand `
-CommandId $runPSCommand.CommandId
```
O status do comando neste exemplo pode ser Success, Pending ou InProgress.
**Obter informações de comando por nó gerenciado**
O comando a seguir usa o `CommandId` do comando anterior para obter o status da execução do comando por nó gerenciado.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId
```
**Obter informações de comando com dados de resposta para um nó gerenciado específico**
O comando a seguir retorna a saída da solicitação `Send-SSMCommand` original para um nó gerenciado específico.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Cancelar um comando
O comando a seguir cancela o `Send-SSMCommand` para o documento `AWS-RunPowerShellScript`.
```
$cancelCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1","instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'='Start-Sleep –Seconds 120; dir C:\'}
Stop-SSMCommand -CommandId $cancelCommand.CommandId
```
**Verificar o status do comando**
O comando a seguir verifica o status do comando `Cancel`.
```
Get-SSMCommand `
-CommandId $cancelCommand.CommandId
```
## Instalar uma aplicação usando o documento `AWS-InstallApplication`
Usando o Run Command e o documento `AWS-InstallApplication`, é possível instalar, reparar ou desinstalar aplicações em nós gerenciados. O comando requer o caminho ou endereço para um MSI.
**nota**
Para obter informações sobre a reinicialização de nós gerenciados ao usar o Run Command para chamar scripts, consulte [Tratamento de reinicializações ao executar comandos](send-commands-reboot.md).
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication" | Select -ExpandProperty Parameters
```
### Enviar um comando usando o documento `AWS-InstallApplication`
O comando a seguir instala uma versão do Python em seu nó gerenciado no modo autônomo e registra a saída em um arquivo de texto local na sua unidade `C:`.
```
$installAppCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallApplication" `
-Parameter @{'source'='https://www.python.org/ftp/python/2.7.9/python-2.7.9.msi'; 'parameters'='/norestart /quiet /log c:\pythoninstall.txt'}
```
**Obter informações de comando por nó gerenciado**
O comando a seguir usa o `CommandId` para obter o status da execução do comando.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true
```
**Obter informações de comando com dados de resposta para um nó gerenciado específico**
O comando a seguir retorna os resultados da instalação do Python.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
## Instalar um módulo do PowerShell usando a`AWS-InstallPowerShellModule`Documento JSON
Você pode usar o Run Command para instalar módulos do PowerShell em nós gerenciados. Para obter mais informações sobre os módulos PowerShell, consulte [Módulos do Windows PowerShell](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_modules?view=powershell-6).
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule" | Select -ExpandProperty Parameters
```
### Instalar um módulo PowerShell
O comando a seguir faz download do arquivo EZOut.zip, instala o arquivo e depois executa um comando adicional para instalar o visualizador XPS. Por fim, a saída desse comando é carregada em um bucket do S3 chamado "amzn-s3-demo-bucket".
```
$installPSCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallPowerShellModule" `
-Parameter @{'source'='https://gallery.technet.microsoft.com/EZOut-33ae0fb7/file/110351/1/EZOut.zip';'commands'=@('Add-WindowsFeature -name XPS-Viewer -restart')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obter informações de comando por nó gerenciado**
O comando a seguir usa o `CommandId` para obter o status da execução do comando.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true
```
**Obter informações de comando com dados de resposta para o nó gerenciado**
O comando a seguir retorna a saída do `Send-SSMCommand` original para o `CommandId` específico.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Integrar um nó gerenciado a um domínio usando o documento JSON `AWS-JoinDirectoryServiceDomain`
Por meio do Run Command, você pode unir rapidamente um nó gerenciado a um domínio do AWS Directory Service. Antes de executar esse comando, você deverá [criar um diretório](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html). Recomendamos também que conheça mais sobre o Directory Service. Para obter mais informações, consulte o [Guia do Administrador do AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/).
Você só pode unir um nó gerenciado a um domínio. Não é possível remover um nó de um domínio.
**nota**
Para obter informações sobre nós gerenciados ao usar o Run Command para chamar scripts, consulte [Tratamento de reinicializações ao executar comandos](send-commands-reboot.md).
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain" | Select -ExpandProperty Parameters
```
### Integrar um nó gerenciado a um domínio
O comando a seguir integra um nó gerenciado a um domínio Directory Service determinado e carrega qualquer saída gerada no exemplo do bucket do Amazon Simple Storage Service (Amazon S3).
```
$domainJoinCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-JoinDirectoryServiceDomain" `
-Parameter @{'directoryId'='d-example01'; 'directoryName'='ssm.example.com'; 'dnsIpAddresses'=@('192.168.10.195', '192.168.20.97')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obter informações de comando por nó gerenciado**
O comando a seguir usa o `CommandId` para obter o status da execução do comando.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true
```
**Obter informações de comando com dados de resposta para o nó gerenciado**
Este comando retorna a saída do `Send-SSMCommand` original para o `CommandId` específico.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Enviar métricas do Windows ao Amazon CloudWatch Logs usando o documento `AWS-ConfigureCloudWatch`
Você pode enviar mensagens do Windows Server nos logs do aplicativo, do sistema e do Rastreamento de Eventos para Windows (ETW) para o Amazon CloudWatch Logs. Quando você permite o registro pela primeira vez, o Systems Manager envia todos os logs gerados no prazo de um (1) minuto a partir do momento em que você inicia o upload de logs para a aplicação, o sistema, a segurança e os logs do ETW. Logs ocorridos antes dessa hora não são incluídos. Se você desativar o registro em log e depois reabilitá-lo, o Systems Manager enviará logs do ponto em que ele parou. Para todos os arquivos de log personalizados e logs do IIS (Serviços de Informações da Internet), o Systems Manager lê os arquivos de log desde o início. Além disso, o Systems Manager também pode enviar dados do contador de performance para o CloudWatch Logs.
Se você habilitou anteriormente a integração do CloudWatch no EC2Config, as configurações do Systems Manager substituirão todas as configurações armazenadas localmente em seu nó gerenciado no arquivo `C:\Program Files\Amazon\EC2ConfigService\Settings\AWS.EC2.Windows.CloudWatch.json`. Para obter mais informações sobre como usar o EC2Config para gerenciar o contador e os logs de performance em um único nó gerenciado, consulte [Coletar métricas e logs de instâncias do Amazon EC2 em servidores on-premises com o agente do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) no *Guia do usuário do Amazon CloudWatch*.
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch" | Select -ExpandProperty Parameters
```
### Enviar logs de aplicativo ao CloudWatch
O comando a seguir configura o nó gerenciado e move logs de aplicações do Windows para o CloudWatch.
```
$cloudWatchCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"ApplicationEventLog", "FullName":"AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"LogName":"Application", "Levels":"7"}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch", "Parameters":{"Region":"region", "LogGroup":"my-log-group", "LogStream":"instance-id"}}], "Flows":{"Flows":["ApplicationEventLog,CloudWatch"]}}}'}
```
**Obter informações de comando por nó gerenciado**
O comando a seguir usa o `CommandId` para obter o status da execução do comando.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true
```
**Obter informações de comando com dados de resposta para um nó gerenciado específico**
O comando a seguir retorna os resultados da configuração do Amazon CloudWatch.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Enviar contadores de performance ao CloudWatch usando o documento `AWS-ConfigureCloudWatch`
O comando de demonstração a seguir faz upload de contadores de performance para o CloudWatch. Para obter mais informações, consulte o *[Guia do usuário do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
```
$cloudWatchMetricsCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"PerformanceCounter", "FullName":"AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"CategoryName":"Memory", "CounterName":"Available MBytes", "InstanceName":"", "MetricName":"AvailableMemory", "Unit":"Megabytes","DimensionName":"", "DimensionValue":""}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"AccessKey":"", "SecretKey":"","Region":"region", "NameSpace":"Windows-Default"}}], "Flows":{"Flows":["PerformanceCounter,CloudWatch"]}}}'}
```
## Ative ou desative a atualização automática do Windows usando o`AWS-ConfigureWindowsUpdate`document
Usando o Run Command e o documento `AWS-ConfigureWindowsUpdate`, é possível ativar ou desativar as atualizações automáticas do Windows em seus nós gerenciados do Windows Server. Esse comando configura o agente de atualização do Windows para baixar e instalar atualizações do Windows na data e hora no dia e hora que você especificar. Se uma atualização exigir uma reinicialização, o nó gerenciado reiniciará automaticamente 15 minutos após a instalação das atualizações. Com esse comando, você também pode configurar o Windows Update para verificar atualizações, mas não pode instalá-las. O documento `AWS-ConfigureWindowsUpdate` é oficialmente compatível com as versões Windows Server 2012 e posteriores.
**Veja a descrição e os parâmetros disponíveis**
```
Get-SSMDocumentDescription `
–Name "AWS-ConfigureWindowsUpdate"
```
**Veja mais informações sobre parâmetros**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureWindowsUpdate" | Select -ExpandProperty Parameters
```
### Ativar a atualização automática do Windows
O comando a seguir configura o Windows Update para baixar e instalar atualizações diariamente às 22h.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='InstallUpdatesAutomatically'; 'scheduledInstallDay'='Daily'; 'scheduledInstallTime'='22:00'}
```
**Visualizar o status do comando para permitir atualizações automáticas do Windows**
O comando a seguir usa o `CommandId` para obter o status da execução do comando para ativar a Atualização Automática do Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
### Desativar a atualização automática do Windows
O seguinte comando reduz o nível de notificação do Windows Update para que o sistema verifique se há atualizações, mas não atualiza automaticamente o nó gerenciado.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='NeverCheckForUpdates'}
```
**Visualizar o status do comando para desativar a atualização automática do Windows**
O comando a seguir usa o `CommandId` para obter o status da execução do comando para ativar a Atualização Automática do Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
## Gerenciar atualizações do Windows usando o Run Command
Usando o Run Command e do documento `AWS-InstallWindowsUpdates`, você pode gerenciar atualizações dos nós gerenciados do Windows Server. Esse comando verifica ou instala atualizações ausentes em nós gerenciados e, opcionalmente, reinicializa após a instalação. Você também pode especificar as classificações e os níveis de severidade adequados para as atualizações a serem instaladas no ambiente.
**nota**
Para obter informações sobre a reinicialização de nós gerenciados ao usar o Run Command para chamar scripts, consulte [Tratamento de reinicializações ao executar comandos](send-commands-reboot.md).
Os exemplos a seguir demonstram como realizar as tarefas de gerenciamento do Windows Update especificadas.
### Procurar todas as atualizações do Windows ausentes
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Scan'}
```
### Instalar atualizações específicas do Windows
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'IncludeKbs'='kb-ID-1,kb-ID-2,kb-ID-3';'AllowReboot'='True'}
```
### Instalar atualizações importantes do Windows ausentes
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'SeverityLevels'='Important';'AllowReboot'='True'}
```
### Instalar atualizações do Windows ausentes com exclusões específicas
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'ExcludeKbs'='kb-ID-1,kb-ID-2';'AllowReboot'='True'}
```
# Solução de problemas do Run Commando do Systems Manager
O Run Command, uma ferramenta do AWS Systems Manager, fornece detalhes de status com cada execução do comando. Para obter mais informações sobre os detalhes dos status de comando, consulte [Noções básicas sobre status de comando](monitor-commands.md). Você também pode usar as informações neste tópico para ajudar a solucionar problemas com a Run Command.
**Topics**
+ [Alguns dos meus nós gerenciados estão ausentes](#where-are-instances)
+ [Uma etapa no meu script falhou, mas o status geral é "bem-sucedido".](#ts-exit-codes)
+ [SSM AgentO não está sendo executado corretamente](#ts-ssmagent-linux)
## Alguns dos meus nós gerenciados estão ausentes
Na página **Run a command**(Executar um comando), depois de escolher um documento do SSM para executar e selecionar **Manually selecting instances** (Selecionar instâncias manualmente) na seção **Targets** (Destinos), é exibida uma lista de nós gerenciados que você pode escolher para a execução do comando.
Se um nó gerenciado que você espera ver não estiver listado, consulte [Solução de problemas de disponibilidade do nó gerenciado](fleet-manager-troubleshooting-managed-nodes.md) para obter dicas de solução de problemas.
Depois de criar, ativar, reinicializar ou reiniciar um nó gerenciado, instale o Run Command em um nó ou anexe um perfil da instância do IAM do AWS Identity and Access Management a um nó. Esse nó poderá levar alguns minutos para aparecer na lista.
## Uma etapa no meu script falhou, mas o status geral é "bem-sucedido".
Com o Run Command, é possível definir como seus scripts manipulam os códigos de saída. Por padrão, o código de saída do último comando executado em um script é relatado como o código de saída de todo o script. No entanto, você pode incluir uma instrução condicional para sair do script se algum comando antes do final falhar. Para obter informações e exemplos, consulte [Especifique códigos de saída nos comandos](run-command-handle-exit-status.md#command-exit-codes).
## SSM AgentO não está sendo executado corretamente
Se você tiver problemas ao executar comandos usando o Run Command, isso significa que pode haver um problema com o SSM Agent. Para obter informações sobre como investigar problemas com o SSM Agent, consulte [Solução de problemas do SSM Agent](troubleshooting-ssm-agent.md).