• 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).
# Tutorials: Create and manage maintenance windows using the AWS CLI
Esta seção inclui tutoriais que ensinarão como usar a AWS Command Line Interface (AWS CLI) para fazer o seguinte:
+ Criar e configurar uma janela de manutenção
+ Visualizar informações sobre uma janela de manutenção
+ Visualizar informações sobre tarefas de janelas de manutenção e execuções de tarefas
+ Atualizar uma janela de manutenção
+ Excluir uma janela de manutenção
**Acompanhar os IDs de recursos**
À medida que as tarefas nestes tutoriais da AWS CLI forem concluídas, acompanhe os IDs de recursos gerados pelos comandos executados. Muitos deles são usados como entrada para comandos subsequentes. Por exemplo, ao criar a janela de manutenção, o sistema fornece um ID de janela de manutenção no formato a seguir.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
Anote os seguintes IDs gerados pelo sistema, pois são usados pelos tutoriais desta seção:
+ `WindowId`
+ `WindowTargetId`
+ `WindowTaskId`
+ `WindowExecutionId`
+ `TaskExecutionId`
+ `InvocationId`
+ `ExecutionId`
Você também precisa do ID da instância do EC2 que planeja usar nos tutoriais. Por exemplo: `i-02573cafcfEXAMPLE`
**Topics**
+ [Tutorial: Criar e configurar uma janela de manutenção usando a AWS CLI](maintenance-windows-cli-tutorials-create.md)
+ [Tutorial: Visualizar informações sobre janelas de manutençãousando a AWS CLI](maintenance-windows-cli-tutorials-describe.md)
+ [Tutorial: Visualizar informações sobre tarefas e execuções de tarefas usando a AWS CLI](mw-cli-tutorial-task-info.md)
+ [Tutorial: Atualizar uma janela de manutenção usando a AWS CLI](maintenance-windows-cli-tutorials-update.md)
+ [Tutorial: Excluir uma janela de manutenção usando a AWS CLI](mw-cli-tutorial-delete-mw.md)
# Tutorial: Criar e configurar uma janela de manutenção usando a AWS CLI
Este tutorial demonstra como usar a AWS Command Line Interface (AWS CLI) para criar e configurar uma janela de manutenção, seus destinos e suas tarefas. O caminho principal do tutorial consiste em etapas simples. Crie uma única janela de manutenção, identifique um único destino e configure uma tarefa simples para a execução da janela de manutenção. Durante o processo, forneceremos informações que poderão ser usadas para testar cenários mais complicados.
Ao seguir as etapas neste tutorial, substitua os valores em texto itálico *vermelho* por suas próprias opções e IDs. Por exemplo, substitua o ID da janela de manutenção *mw-0c50858d01EXAMPLE* e o ID da instância*i-02573cafcfEXAMPLE* pelos IDs de recursos criados.
**Topics**
+ [Etapa 1: Criar a janela de manutenção usando a AWS CLI](mw-cli-tutorial-create-mw.md)
+ [Etapa 2: Registrar um nó de destino na janela de manutenção usando a AWS CLI](mw-cli-tutorial-targets.md)
+ [Etapa 3: Registrar uma tarefa na janela de manutenção usando a AWS CLI](mw-cli-tutorial-tasks.md)
# Etapa 1: Criar a janela de manutenção usando a AWS CLI
Nesta etapa, crie uma janela de manutenção e especifique suas opções básicas, como nome, programação e duração. Nas etapas posteriores, você escolherá a instância que ela atualiza e a tarefa que ela executa.
No nosso exemplo, você criará uma janela de manutenção que é executada a cada cinco minutos. Normalmente, uma janela de manutenção não seria executada com essa frequência. No entanto, essa taxa permite visualizar os resultados do tutorial rapidamente. Mostraremos como alterar para uma taxa menos frequente após a execução bem-sucedida da tarefa.
**nota**
Para obter uma explicação de como as várias opções relacionadas à programação de janelas de manutenção se relacionam entre si, consulte [Opções de programação da janela de manutenção e do período ativo](maintenance-windows-schedule-options.md).
Para obter mais informações sobre como trabalhar com a opção `--schedule`, consulte [Referência: Expressões cron e rate para o Systems Manager](reference-cron-and-rate-expressions.md).
**Para criar uma janela de manutenção usando a AWS CLI**
1. Abra a AWS Command Line Interface (AWS CLI) e execute o seguinte comando na máquina local para criar uma janela de manutenção que faz o seguinte:
+ Executa a cada cinco minutos durante até duas horas (conforme necessário).
+ Impede que novas tarefas iniciem a menos de uma hora do final da operação da janela de manutenção.
+ Permite destinos não associados (instâncias que não foram registradas na janela de manutenção).
+ Indica, por meio do uso de tags personalizadas, que seu criador pretende usá-la em um tutorial.
------
#### [ Linux & macOS ]
```
aws ssm create-maintenance-window \
--name "My-First-Maintenance-Window" \
--schedule "rate(5 minutes)" \
--duration 2 \
--cutoff 1 \
--allow-unassociated-targets \
--tags "Key=Purpose,Value=Tutorial"
```
------
#### [ Windows ]
```
aws ssm create-maintenance-window ^
--name "My-First-Maintenance-Window" ^
--schedule "rate(5 minutes)" ^
--duration 2 ^
--cutoff 1 ^
--allow-unassociated-targets ^
--tags "Key"="Purpose","Value"="Tutorial"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
1. Agora, execute o comando a seguir para ver detalhes sobre esta e quaisquer outras janelas de manutenção que já estejam na sua conta.
```
aws ssm describe-maintenance-windows
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities":[
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 1,
"NextExecutionTime": "2019-05-11T16:46:16.991Z"
}
]
}
```
Avance para [Etapa 2: Registrar um nó de destino na janela de manutenção usando a AWS CLI](mw-cli-tutorial-targets.md).
# Etapa 2: Registrar um nó de destino na janela de manutenção usando a AWS CLI
Nesta etapa, você registra um destino com sua nova janela de manutenção. Nesse caso, você especifica qual nó deverá ser atualizado quando a janela de manutenção for executada.
Para obter um exemplo de como registrar mais de um nó por vez usando IDs de nós, exemplos de como usar tags para identificar vários nós e exemplos de como especificar grupos de recursos como destinos, consulte [Exemplos: Registrar destinos em uma janela de manutenção](mw-cli-tutorial-targets-examples.md).
**nota**
Você já deve ter criado uma instância do Amazon Elastic Compute Cloud (Amazon EC2) para usar nesta etapa, conforme descrito no [ tutorial de pré-requisitos do Maintenance Windows](maintenance-windows-tutorials.md).
**Para registrar um nó de destino em uma janela de manutenção usando a AWS CLI**
1. Execute o seguinte comando na máquina local. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowTargetId":"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Agora execute o seguinte comando na máquina local para visualizar detalhes sobre o destino da janela de manutenção.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
]
}
]
}
```
Avance para [Etapa 3: Registrar uma tarefa na janela de manutenção usando a AWS CLI](mw-cli-tutorial-tasks.md).
# Exemplos: Registrar destinos em uma janela de manutenção
Você pode registrar um único nó como destino usando o ID do nó, conforme demonstrado em [Etapa 2: Registrar um nó de destino na janela de manutenção usando a AWS CLI](mw-cli-tutorial-targets.md). Você também pode registrar um ou mais nós como destinos usando os formatos de comando nesta página.
Em geral, existem dois métodos para identificar os nós que você deseja usar como destinos da janela de manutenção: especificando nós individuais e usando tags de recurso. O método de tags de recurso fornece mais opções, conforme mostrado nos exemplos 2 e 3.
Você também pode especificar um ou mais grupos de recursos como o destino de uma janela de manutenção. Um grupo de recursos pode incluir nós e muitos outros tipos de recursos compatíveis da AWS. Os exemplos 4 e 5 seguintes demonstram como adicionar grupos de recursos aos destinos da janela de manutenção.
**nota**
Se uma única tarefa da janela de manutenção for registrada com vários destinos, suas chamadas de tarefa ocorrerão sequencialmente e não em paralelo. Se a tarefa precisar ser executada em vários destinos ao mesmo tempo, registre uma tarefa para cada destino individualmente e atribua a cada uma o mesmo nível de prioridade.
Para obter mais informações sobre como criar e gerenciar grupos de recursos, consulte [O que são grupos de recursos?](https://docs.aws.amazon.com/ARG/latest/userguide/resource-groups.html) no *Guia do usuário do AWS Resource Groups* e [Grupos de recursos e marcação para a AWS](https://aws.amazon.com/blogs/aws/resource-groups-and-tagging/) no *Blog de notícias da AWS*.
Para obter informações sobre cotas para o Maintenance Windows, uma ferramenta do AWS Systems Manager, além das especificadas nos exemplos a seguir, consulte [Cotas de serviço do Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) no *Referência geral da Amazon Web Services*.
## Exemplo 1: Registrar vários destinos usando IDs do nó
Execute o seguinte comando no formato da máquina local para registrar vários nós como destinos usando os IDs de nós deles: Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE
```
------
**Uso recomendado**: muito útil para registrar um grupo exclusivo de nós em qualquer janela de manutenção pela primeira vez e quando eles *não* compartilham uma tag de nó comum.
**Cotas:** você pode especificar um total de até 50 nós para cada destino de janela de manutenção.
## Exemplo 2: Registrar destinos usando tags de recursos aplicadas aos nós
Execute o seguinte comando na máquina local para registrar nós que já estejam marcados com um par de chave/valor atribuído por você: Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag:Region,Values=East"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag:Region,Values=East"
```
------
**Uso recomendado**: muito útil para registrar um grupo exclusivo de nós em qualquer janela de manutenção pela primeira vez e quando eles *compartilham* uma tag de nó comum.
**Cotas:** você pode especificar até cinco pares de chave-valor para cada destino. Se você especificar mais de um par de chave-valor, um nó deverá ser marcado com *todas* as chaves e valores de tag especificados para inclusão no grupo de destino.
**nota**
Você pode marcar um grupo de nós com a chave de tag `Patch Group` ou `PatchGroup` e atribuir aos nós um valor de chave comum, como `my-patch-group`. (Você deve usar `PatchGroup`, sem espaço, se tiver [tags permitidas nos metadados da instância do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#allow-access-to-tags-in-IMDS).) O Patch Manager, uma ferramenta do Systems Manager, avalia a chave `Patch Group` ou `PatchGroup` nos nós para ajudar a determinar qual a lista de referência de patches se aplica a eles. Se a sua tarefa executar o documento SSM `AWS-RunPatchBaseline` (ou o documento SSM legado `AWS-ApplyPatchBaseline`), você poderá especificar o mesmo par de chave/valor `Patch Group` ou `PatchGroup` ao registrar destinos com uma janela de manutenção. Por exemplo: `--target "Key=tag:PatchGroup,Values=my-patch-group`. Isso permite que você use uma janela de manutenção para atualizar patches em um grupo de nós que já esteja associado à mesma lista de referência de patches. Para obter mais informações, consulte [Grupos de patches](patch-manager-patch-groups.md).
## Exemplo 3: Registrar destinos usando um grupo de chaves de tag (sem valores de tag)
Execute o seguinte comando na máquina local para registrar nós que tenham uma ou mais chaves de tags atribuídas, independentemente de seus valores de chave. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
**Uso recomendado**: útil quando você quiser marcar nós como destino especificando várias *chaves* de tag (sem seus valores) em vez de apenas uma tag-chave ou um par chave-valor de tag.
**Cotas:** você pode especificar até um total de cinco chaves de tag para cada destino. Se você especificar mais de uma chave de tag, um nó deverá ser marcado com *todas* as chaves de tags especificadas para inclusão no grupo de destino.
## Exemplo 4: Registrar destinos usando o nome de grupo de recursos
Execute o seguinte comando na máquina local para registrar um grupo de recursos especificado, independentemente do tipo de recurso que ele contém. Substitua *mw-0c50858d01EXAMPLE* pelas suas próprias informações. Se as tarefas que você atribui à janela de manutenção não atuarem em um tipo de recurso incluído nesse grupo de recursos, o sistema poderá relatar um erro. As tarefas para as quais um tipo de recurso compatível é encontrado continuam a ser executadas apesar desses erros.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
**Uso recomendado**: útil quando você deseja especificar rapidamente um grupo de recursos como destino sem avaliar se todos os tipos de recurso serão direcionados por uma janela de manutenção, ou quando você sabe que o grupo de recursos contém apenas os tipos de recurso nos quais as tarefas executam ações.
**Cotas:** você pode especificar apenas um grupo de recursos como destino.
## Exemplo 5: Registrar destinos filtrando tipos de recurso em um grupo de recursos
Execute o seguinte comando na máquina local para registrar somente certos tipos de recursos que pertencem a um grupo de recursos que você especificar. Substitua *mw-0c50858d01EXAMPLE* pelas suas próprias informações. Com essa opção, mesmo que você adicione uma tarefa para um tipo de recurso que pertence ao grupo de recursos, a tarefa não será executada se você ainda não tiver adicionado explicitamente o tipo de recurso ao filtro.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup" \
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup" ^
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
**Uso recomendado**: útil quando você quiser manter um controle rígido sobre os tipos de recurso da AWS nos quais sua janela de manutenção pode executar ações, ou quando o grupo de recursos contiver um grande número de tipos de recurso e você quiser evitar relatórios de erro desnecessários nos logs da janela de manutenção.
**Cotas:** você pode especificar apenas um grupo de recursos como destino.
# Etapa 3: Registrar uma tarefa na janela de manutenção usando a AWS CLI
Nesta etapa do tutorial, você registra uma tarefa do AWS Systems Manager Run Command que executa o `df` na instância do Amazon Elastic Compute Cloud (Amazon EC2) para Linux. Os resultados desse comando padrão do Linux mostram a quantidade de espaço livre e a quantidade usada no sistema de arquivos do disco de sua instância.
- ou -
Se você estiver direcionando uma instância do Amazon EC2 para Windows Server em vez de para Linux, substitua o **df** no comando a seguir por **ipconfig**. A saída desse comando lista detalhes sobre o endereço IP, a máscara de sub-rede e o gateway padrão para adaptadores na instância de destino.
Quando você estiver pronto para registrar outros tipos de tarefa ou usar mais opções do Run Command disponíveis no Systems Manager, consulte [Exemplos: Registrar tarefas em uma janela de manutenção](mw-cli-register-tasks-examples.md). Lá fornecemos mais informações sobre os quatro tipos de tarefa e algumas das suas opções mais importante, para ajudar você a se planejar para cenários reais mais abrangentes.
**Como registrar uma tarefa em uma janela de manutenção**
1. Execute o seguinte comando na máquina local. Substitua cada *espaço reservado para recurso de exemplo* por suas próprias informações. A versão que será executada a partir de uma máquina Windows local inclui os caracteres de escape ("/") necessários para executar o comando em sua ferramenta de linha de comando.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 \
--priority 10 \
--targets "Key=InstanceIds,Values=i-0471e04240EXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 ^
--priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters={\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}
```
------
O sistema retorna informações semelhantes às seguintes:
```
{
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE"
}
```
1. Agora, execute o seguinte comando para visualizar detalhes sobre a tarefa de janela de manutenção criada:
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id mw-0c50858d01EXAMPLE
```
------
1. O sistema retorna informações semelhantes às seguintes.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 10,
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
}
]
}
```
1. Aguarde o runtime da tarefa, com base na programação especificada em [Etapa 1: Criar a janela de manutenção usando a AWS CLI](mw-cli-tutorial-create-mw.md). Por exemplo, se você tiver especificado **--schedule "rate(5 minutes)"**, aguarde cinco minutos. Depois, execute o seguinte comando para visualizar informações sobre todas as execuções que ocorreram para essa tarefa.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id mw-0c50858d01EXAMPLE
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
]
}
```
**dica**
Depois que a tarefa for executada com êxito, reduza a taxa de execução da janela de manutenção. Por exemplo, execute o comando a seguir para reduzir a frequência para uma vez por semana. Substitua *mw-0c50858d01EXAMPLE* pelas suas próprias informações.
```
aws ssm update-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--schedule "rate(7 days)"
```
```
aws ssm update-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--schedule "rate(7 days)"
```
Para obter informações sobre como gerenciar programações da janela de manutenção, consulte [Referência: Expressões cron e rate para o Systems Manager](reference-cron-and-rate-expressions.md) e [Opções de programação da janela de manutenção e do período ativo](maintenance-windows-schedule-options.md).
Para obter informações sobre como usar a AWS Command Line Interface (AWS CLI) para modificar uma janela de manutenção, consulte [Tutorial: Atualizar uma janela de manutenção usando a AWS CLI](maintenance-windows-cli-tutorials-update.md).
Para praticar a execução de comandos da AWS CLI a fim de visualizar mais detalhes sobre sua tarefa de janela de manutenção e suas execuções, continue em [Tutorial: Visualizar informações sobre tarefas e execuções de tarefas usando a AWS CLI](mw-cli-tutorial-task-info.md).
**Acesso à saída do comando do tutorial**
Está além do escopo deste tutorial usar a AWS CLI para visualizar a *saída* do comando do Run Command associado às suas execuções da tarefa de janela de manutenção.
No entanto, esses dados podem ser visualizados usando a AWS CLI. (Você também pode visualizar a saída no console do Systems Manager ou em um arquivo de log armazenado em um bucket do Amazon Simple Storage Service (Amazon S3), caso tenha configurado a janela de manutenção para armazenar a saída do comando nele.) Observe que a saída do comando **df** em uma instância do EC2 para Linux é semelhante à seguinte:
```
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 485716 0 485716 0% /dev
tmpfs 503624 0 503624 0% /dev/shm
tmpfs 503624 328 503296 1% /run
tmpfs 503624 0 503624 0% /sys/fs/cgroup
/dev/xvda1 8376300 1464160 6912140 18% /
```
A saída do comando **ipconfig** em uma instância do EC2 para Windows Server é semelhante à seguinte:
```
Windows IP Configuration
Ethernet adapter Ethernet 2:
Connection-specific DNS Suffix . : example.com
IPv4 Address. . . . . . . . . . . : 10.24.34.0/23
Subnet Mask . . . . . . . . . . . : 255.255.255.255
Default Gateway . . . . . . . . . : 0.0.0.0
Ethernet adapter Ethernet:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . : abc1.wa.example.net
Wireless LAN adapter Local Area Connection* 1:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
Wireless LAN adapter Wi-Fi:
Connection-specific DNS Suffix . :
Link-local IPv6 Address . . . . . : fe80::100b:c234:66d6:d24f%4
IPv4 Address. . . . . . . . . . . : 192.0.2.0
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Default Gateway . . . . . . . . . : 192.0.2.0
Ethernet adapter Bluetooth Network Connection:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
```
# Exemplos: Registrar tarefas em uma janela de manutenção
Você pode registrar uma tarefa no Run Command, uma ferramenta do AWS Systems Manager, com uma janela de manutenção usando o AWS Command Line Interface (AWS CLI), conforme demonstrado em [Registre tarefas com a janela de manutenção](mw-cli-tutorial-tasks.md). Você também pode registrar tarefas para fluxos de trabalho do Systems Manager Automation, funções do AWS Lambda, e tarefas do AWS Step Functions, conforme demonstrado abaixo, neste tópico.
**nota**
Especifique um ou mais destinos para as tarefas da janela de manutenção do tipo Run Command. Dependendo da tarefa, os destinos serão opcionais para outros tipos de tarefas da janela de manutenção (Automation, AWS Lambda e AWS Step Functions). Para obter mais informações sobre como executar tarefas que não especificam destinos, consulte [Registrar tarefas da janela de manutenção sem destinos](maintenance-windows-targetless-tasks.md).
Neste tópico, fornecemos exemplos de como usar o comando AWS Command Line Interface (AWS CLI) da `register-task-with-maintenance-window` para registrar cada um dos quatro tipos de tarefa compatíveis em uma janela de manutenção. Os exemplos são apenas para demonstração, mas você pode modificá-los para criar comandos de registro de tarefa funcionais.
**Uso da opção --cli-input-json**
Para gerenciar melhor suas opções de tarefas, use a opção de comando `--cli-input-json`, com valores de opção referenciados em um arquivo JSON.
Para usar o conteúdo do arquivo JSON de exemplo fornecido nos exemplos a seguir, faça o seguinte em sua máquina local:
1. Crie um arquivo com um nome, como `MyRunCommandTask.json`, `MyAutomationTask.json` ou outro nome de sua preferência.
1. Copie o conteúdo do nosso exemplo de JSON no arquivo.
1. Modifique o conteúdo do arquivo para o registro de sua tarefa e salve o arquivo.
1. No mesmo diretório em que armazenou o arquivo, execute o seguinte comando. Substitua o nome do arquivo por *MyFile.json*.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--cli-input-json file://MyFile.json
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--cli-input-json file://MyFile.json
```
------
**Pseudoparâmetros em tarefas da janela de manutenção**
Em alguns exemplos, usamos *pseudoparâmetros* como método para enviar informações de ID às tarefas. Por exemplo, `{{TARGET_ID}}` e `{{RESOURCE_ID}}` podem ser usados para passar os IDs dos recursos da AWS somente para tarefas do Automation, do Lambda e do Step Functions. Para obter mais informações sobre pseudoparâmetros em conteúdo `--task-invocation-parameters`, consulte [Usar pseudoparâmetros ao registrar tarefas da janela de manutenção](maintenance-window-tasks-pseudo-parameters.md).
**Mais informações**
+ [Opções de parâmetros para o comando register-task-with-maintenance-windows](mw-cli-task-options.md).
+ [https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html) na *AWS CLI Command Reference*
+ [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html) na *Referência de API do AWS Systems Manager*
## Exemplos de registro de tarefas
As seções a seguir fornecem um exemplo de comando da AWS CLI para registrar um tipo de tarefa compatível e um exemplo de JSON que pode ser usado com a opção `--cli-input-json`.
### Registre uma tarefa Run Command do Systems Manager
Os exemplos a seguir demonstram como registrar tarefas Run Command do Systems Manager em uma janela de manutenção usando a AWS CLI:
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 --priority 10 \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 --priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters "{\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}"
```
------
**Conteúdo JSON para uso com a opção de arquivo `--cli-input-json`:**
```
{
"TaskType": "RUN_COMMAND",
"WindowId": "mw-0c50858d01EXAMPLE",
"Description": "My Run Command task to update SSM Agent on an instance",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Priority": 10,
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-UpdateSSMAgent",
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A TaskInvocationParameters test comment",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"All"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"TimeoutSeconds": 3600
}
}
}
```
### Registre uma tarefa do Systems Manager Automation
Os exemplos a seguir demonstram como registrar tarefas do Systems Manager Automation em uma janela de manutenção usando a AWS CLI:
**AWS CLI comando:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--task-arn "AWS-RestartEC2Instance" \
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole \
--task-type AUTOMATION \
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{RESOURCE_ID}}'}}" \
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" \
--description "Automation task to restart EC2 instances"
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--task-arn "AWS-RestartEC2Instance" ^
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole ^
--task-type AUTOMATION ^
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{TARGET_ID}}'}}" ^
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" ^
--description "Automation task to restart EC2 instances"
```
------
**Conteúdo JSON para uso com a opção de arquivo `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"TaskArn": "AWS-PatchInstanceWithRollback",
"TaskType": "AUTOMATION","TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "1",
"Parameters": {
"instanceId": [
"{{RESOURCE_ID}}"
]
}
}
}
}
```
### Registrar uma tarefa do AWS Lambda
Os exemplos a seguir demonstram como registrar tarefas de função do Lambda em uma janela de manutenção usando a : AWS CLI.
Para esses exemplos, o usuário que criou a função do Lambda a nomeou como `SSMrestart-my-instances` e criou dois parâmetros chamados `instanceId` e `targetType`.
**Importante**
A política do Maintenance Windows para IAM requer a adição do prefixo `SSM` aos nomes das funções Lambda (ou alias) . Antes de prosseguir com o registro desse tipo de tarefa, atualize o nome no AWS Lambda para incluir `SSM`. Por exemplo, se o nome da função Lambda for `MyLambdaFunction`, altere-o para `SSMMyLambdaFunction`.
**AWS CLI comando:**
------
#### [ Linux & macOS ]
**Importante**
Se você estiver usando a versão 2 do AWS CLI, inclua a opção `--cli-binary-format raw-in-base64-out` no comando a seguir se sua carga útil do Lambda não for codificada em base64. A opção `cli_binary_format` está disponível apenas na versão 2. Para obter informações sobre essa e outras configurações do arquivo AWS CLI `config`, consulte [Configurações de arquivo `config` compatíveis](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) no *Manual do usuário do AWS Command Line Interface*.
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" \
--description "A description for my LAMBDA example task" --task-type "LAMBDA" \
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}","Qualifier": "$LATEST"}}'
```
------
#### [ PowerShell ]
**Importante**
Se você estiver usando a versão 2 do AWS CLI, inclua a opção `--cli-binary-format raw-in-base64-out` no comando a seguir se sua carga útil do Lambda não for codificada em base64. A opção `cli_binary_format` está disponível apenas na versão 2. Para obter informações sobre essa e outras configurações do arquivo AWS CLI `config`, consulte [Configurações de arquivo `config` compatíveis](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) no *Manual do usuário do AWS Command Line Interface*.
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" `
--description "A description for my LAMBDA example task" --task-type "LAMBDA" `
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" `
--task-invocation-parameters '{\"Lambda\":{\"Payload\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\",\\\"targetType\\\":\\\"{{TARGET_TYPE}}\\\"}\",\"Qualifier\": \"$LATEST\"}}'
```
------
**Conteúdo JSON para uso com a opção de arquivo `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_RestartMyInstances",
"TaskType": "LAMBDA",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"instanceId\": \"{{RESOURCE_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
},
"Name": "My-Lambda-Task",
"Description": "A description for my LAMBDA task",
"Priority": 5
}
```
### Registre uma tarefa do Step Functions
Os exemplos a seguir demonstram como registrar tarefas da máquina de estado do Step Functions em uma janela de manutenção usando a : AWS CLI.
**nota**
As tarefas da janela de manutenção oferecem suporte somente aos fluxos de trabalho da máquina de estado Step Functions Standard. Elas não oferecem suporte a fluxos de trabalho de máquinas de estado Express. Para obter informações sobre os tipos de fluxo de trabalho da máquina de estado, consulte [Fluxos de trabalho Standard vs. Express](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) no *Guia do desenvolvedor do AWS Step Functions*.
Para esses exemplos, o usuário que criou a máquina de estado do Step Functions criou uma máquina de estado chamada `SSMMyStateMachine` com um parâmetro chamado `instanceId`.
**Importante**
A política do AWS Identity and Access Management (IAM) para a Maintenance Windows requer o uso do prefixo Step Functions nos nomes das máquinas de estado do `SSM`. Antes de prosseguir com o registro desse tipo de tarefa, é necessário atualizar o nome no AWS Step Functions a fim de incluir `SSM`. Por exemplo, se o nome da máquina de estado for `MyStateMachine`, altere para `SSMMyStateMachine`.
**AWS CLI comando:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE \
--task-type STEP_FUNCTIONS \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}", "Name":"{{INVOCATION_ID}}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
#### [ PowerShell ]
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE `
--task-type STEP_FUNCTIONS `
--task-invocation-parameters '{\"StepFunctions\":{\"Input\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\"}\", \"Name\":\"{{INVOCATION_ID}}\"}}' `
--priority 0 --max-concurrency 10 --max-errors 5 `
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
**Conteúdo JSON para uso com a opção de arquivo `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_MyStateMachine",
"TaskType": "STEP_FUNCTIONS",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"instanceId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
},
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task",
"Priority": 5
}
```
# Opções de parâmetros para o comando register-task-with-maintenance-windows
O comando **register-task-with-maintenance-window** fornece várias opções para configurar uma tarefa de acordo com as suas necessidades. Algumas são necessárias, algumas são opcionais, outras se aplicam somente a um único tipo de tarefa de janela de manutenção.
Este tópico fornece informações sobre algumas dessas opções para ajudar você a trabalhar com exemplos nesta seção do tutorial. Para obter mais informações sobre as opções de comando, consulte **[https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html)** na *Referência de comandos do AWS CLI*.
**Opção de comando: `--task-arn`**
A opção `--task-arn` é usada para especificar o recurso no qual a tarefa é executada. O valor especificado depende do tipo de tarefa que você estiver registrando, conforme descrito na tabela a seguir.
**Formatos de TaskArn para tarefas de janela de manutenção**
| Tipo de tarefa de janela de manutenção | Valor de TaskArn |
| --- | --- |
| **`RUN_COMMAND`** e ** `AUTOMATION`** | `TaskArn`O é o nome do documento SSM ou o Amazon Resource Name (ARN). Por exemplo: `AWS-RunBatchShellScript` - ou - `arn:aws:ssm:region:111122223333:document/My-Document`. |
| **`LAMBDA`** | `TaskArn` é o nome ou o ARN da função. Por exemplo: `SSMMy-Lambda-Function` - ou - `arn:aws:lambda:region:111122223333:function:SSMMyLambdaFunction`. A política do Maintenance Windows para IAM requer a adição do prefixo `SSM` aos nomes das funções Lambda (ou alias) . Antes de prosseguir com o registro desse tipo de tarefa, atualize o nome no AWS Lambda para incluir `SSM`. Por exemplo, se o nome da função Lambda for `MyLambdaFunction`, altere-o para `SSMMyLambdaFunction`. |
| **`STEP_FUNCTIONS`** | `TaskArn` é o ARN da máquina de estado. Por exemplo: `arn:aws:states:us-east-2:111122223333:stateMachine:SSMMyStateMachine`. A política do IAM para as janelas de manutenção requer o uso do prefixo Step Functions nos nomes das máquinas de estado com o `SSM`. Antes de registrar esse tipo de tarefa, é necessário atualizar o nome no AWS Step Functions a fim de incluir `SSM`. Por exemplo, se o nome da máquina de estado for `MyStateMachine`, altere para `SSMMyStateMachine`. |
**Opção de comando: `--service-role-arn`**
A função a ser assumida pelo AWS Systems Manager ao executar a tarefa de janela de manutenção.
Para obter mais informações, consulte . [Configurar o Maintenance Windows](setting-up-maintenance-windows.md)
**Opção de comando: `--task-invocation-parameters`**
A opção `--task-invocation-parameters` é usada para especificar os parâmetros que são exclusivos para cada um dos quatro tipos de tarefa. Os parâmetros compatíveis com cada um dos quatro tipos de tarefa estão descritos na tabela a seguir.
**nota**
Para obter informações sobre como usar pseudoparâmetros em conteúdo `--task-invocation-parameters`, como \$1\$1TARGET\$1ID\$1\$1, consulte [Usar pseudoparâmetros ao registrar tarefas da janela de manutenção](maintenance-window-tasks-pseudo-parameters.md).
Opções de parâmetros de invocação de tarefas para tarefas de janela de manutenção
| Tipo de tarefa de janela de manutenção | Parâmetros disponíveis | Exemplo |
| --- | --- | --- |
| **`RUN_COMMAND`** | `Comment` `DocumentHash` `DocumentHashType` `NotificationConfig` `OutputS3BucketName` `OutPutS3KeyPrefix` `Parameters` `ServiceRoleArn` `TimeoutSeconds` | "TaskInvocationParameters": {
"RunCommand": {
"Comment": "My Run Command task comment",
"DocumentHash": "6554ed3d--truncated--5EXAMPLE",
"DocumentHashType": "Sha256",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"FAILURE"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"Parameters": {
"commands": [
"Get-ChildItem$env: temp-Recurse|Remove-Item-Recurse-force"
]
},
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"TimeoutSeconds": 3600
}
} |
| **`AUTOMATION`** | `DocumentVersion` `Parameters` | "TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "3",
"Parameters": {
"instanceid": [
"{{TARGET_ID}}"
]
}
}
} |
| **`LAMBDA`** | `ClientContext` `Payload` `Qualifier` | "TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"targetId\": \"{{TARGET_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
} |
| **`STEP_FUNCTIONS`** | `Input` `Name` | "TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"targetId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
} |
# Tutorial: Visualizar informações sobre janelas de manutençãousando a AWS CLI
Esta seção inclui comandos para ajudar você a atualizar ou obter informações sobre suas janelas de manutenção, tarefas, execuções e invocações. Os exemplos são organizados por comando para demonstrar como usar as opções de comando para filtrar para o tipo de detalhes que você deseja ver.
Ao seguir as etapas neste tutorial, substitua os valores em texto itálico *vermelho* por suas próprias opções e IDs. Por exemplo, substitua o ID da janela de manutenção *mw-0c50858d01EXAMPLE* e o ID da instância*i-02573cafcfEXAMPLE* pelos IDs de recursos criados.
Para obter informações sobre como definir e configurar o AWS Command Line Interface (AWS CLI), consulte [Instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
**Topics**
+ [Exemplos para "describe-maintenance-windows"](#mw-cli-tutorials-describe-maintenance-windows)
+ [Exemplos para "describe-maintenance-window-targets"](#mw-cli-tutorials-describe-maintenance-window-targets)
+ [Exemplos para "describe-maintenance-window-tasks"](#mw-cli-tutorials-describe-maintenance-window-tasks)
+ [Exemplos para "describe-maintenance-windows-for-target"](#mw-cli-tutorials-describe-maintenance-windows-for-target)
+ [Exemplos para "describe-maintenance-window-executions"](#mw-cli-tutorials-describe-maintenance-window-executions)
+ [Exemplos para "describe-maintenance-window-schedule"](#mw-cli-tutorials-describe-maintenance-window-schedule)
## Exemplos para "describe-maintenance-windows"
**Liste todas as janelas de manutenção em sua conta da Conta da AWS**
Execute o comando a seguir.
```
aws ssm describe-maintenance-windows
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Listar todas as janelas de manutenção habilitadas**
Execute o comando a seguir.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=true"
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Listar todas as janelas de manutenção desabilitadas**
Execute o comando a seguir.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=false"
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities": [
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
**Listar todas as janelas de manutenção com nomes que começam com um determinado prefixo**
Execute o comando a seguir.
```
aws ssm describe-maintenance-windows --filters "Key=Name,Values=My"
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"Enabled": true,
"Duration": 4,
"Cutoff": 1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
## Exemplos para "describe-maintenance-window-targets"
**Exibir os destinos para uma janela de manutenção correspondentes ao valor das informações de um proprietário específico**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-6e5c9d4b7cEXAMPLE" \
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-6e5c9d4b7cEXAMPLE" ^
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
**nota**
As chaves de filtro compatíveis são `Type`, `WindowTargetId` e `OwnerInformation`.
O sistema retorna informações semelhantes às seguintes.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "tag:Name",
"Values": [
"Production"
]
}
],
"OwnerInformation": "CostCenter1",
"Name": "Target1"
}
]
}
```
## Exemplos para "describe-maintenance-window-tasks"
**Mostre todas as tarefas registradas que invocam o documento de comando d do SSM `AWS-RunPowerShellScript`**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"Tasks":[
{
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
},
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"ipconfig"
]
}
},
"Priority":1,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"WINDOW_TARGET"
}
]
}
]
}
```
**Mostrar todas as tarefas registradas que têm uma prioridade de "3"**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=Priority,Values=3"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=Priority,Values=3"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"Tasks":[
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
}
]
}
```
**Mostrar todas as tarefas registradas que têm uma prioridade de "1" e usam Run Command**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "8a5c4629-31b0-4edd-8aea-33698EXAMPLE",
"TaskArn": "AWS-UpdateSSMAgent",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-0471e04240EXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Description": "My Run Command task to update SSM Agent on an instance"
}
]
}
```
## Exemplos para "describe-maintenance-windows-for-target"
**Listar informações sobre os destinos da janela de manutenção ou as tarefas associadas a um nó específico.**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-windows-for-target \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-windows-for-target ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--max-results 10
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window"
}
]
}
```
## Exemplos para "describe-maintenance-window-executions"
**Listar todas as tarefas executadas antes de uma determinada data**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
**Listar todas as tarefas executadas depois de uma determinada data**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
## Exemplos para "describe-maintenance-window-schedule"
**Exiba as próximas dez execuções da janela de manutenção programadas para um nó específico**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" ^
--max-results 10
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-18T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-25T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-01T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-08T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-15T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-22T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-29T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-06T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-07-13T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-20T23:35:24.902Z"
}
],
"NextToken": "AAEABUXdceT92FvtKld/dGHELj5Mi+GKW/EXAMPLE"
}
```
**Exiba a programação da janela de manutenção para nós marcados com um determinado par de chave/valor**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=tag:prod,Values=rhel7"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=tag:prod,Values=rhel7"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-20T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-21T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-22T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-23T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-24T05:34:56-07:00"
}
],
"NextToken": "AAEABccwSXqQRGKiTZ1yzGELR6cxW4W/EXAMPLE"
}
```
**Exibir os horários de início da próximas quatro execuções de uma janela de manutenção**
Execute o comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--window-id "mw-0c50858d01EXAMPLE" \
--max-results "4"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--window-id "mw-0c50858d01EXAMPLE" ^
--max-results "4"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowSchedule": [
{
"ScheduledWindowExecutions": [
{
"ExecutionTime": "2019-10-04T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-11T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-18T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-25T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
}
]
}
]
}
```
# Tutorial: Visualizar informações sobre tarefas e execuções de tarefas usando a AWS CLI
Este tutorial demonstra como usar a AWS Command Line Interface (AWS CLI) para visualizar detalhes sobre as tarefas concluídas da janela de manutenção.
Se você estiver continuando diretamente do [Tutorial: Criar e configurar uma janela de manutenção usando a AWS CLI](maintenance-windows-cli-tutorials-create.md), reserve tempo suficiente para que a sua janela de manutenção seja executada pelo menos uma vez, para ver os resultados dessa execução.
Ao seguir as etapas neste tutorial, substitua os valores em texto itálico *vermelho* por suas próprias opções e IDs. Por exemplo, substitua o ID da janela de manutenção *mw-0c50858d01EXAMPLE* e o ID da instância*i-02573cafcfEXAMPLE* pelos IDs de recursos criados.
**Para visualiar informações sobre tarefas e execuções de tarefas usando a AWS CLI**
1. Execute o comando a seguir para visualizar uma lista de execuções de tarefas para uma janela de manutenção específica.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StatusDetails": "No tasks to execute.",
"StartTime": 1557593193.309,
"EndTime": 1557593193.334
}
]
}
```
1. Execute o comando a seguir para obter informações sobre uma execução de tarefa da janela de manutenção.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskIds": [
"c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
],
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
```
1. Execute o comando a seguir para listar as tarefas executadas como parte de uma execução da janela de manutenção.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-tasks \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-tasks ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutionTaskIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57,
"TaskArn": "AWS-RunShellScript",
"TaskType": "RUN_COMMAND"
}
]
}
```
1. Execute o seguinte comando para obter os detalhes de uma execução de tarefa.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution-task \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution-task ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"TaskArn": "AWS-RunShellScript",
"ServiceRole": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"Type": "RUN_COMMAND",
"TaskParameters": [
{
"aws:InstanceId": {
"Values": [
"i-02573cafcfEXAMPLE"
]
},
"commands": {
"Values": [
"df"
]
}
}
],
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57
}
```
1. Execute o seguinte comando para obter as invocações de tarefas específicas realizadas para uma execução de tarefa.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-task-invocations \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-task-invocations ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowExecutionTaskInvocationIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"InvocationId": "c336d2ab-09de-44ba-8f6a-6136cEXAMPLE",
"ExecutionId": "76a5a04f-caf6-490c-b448-92c02EXAMPLE",
"TaskType": "RUN_COMMAND",
"Parameters": "{\"documentName\":\"AWS-RunShellScript\",\"instanceIds\":[\"i-02573cafcfEXAMPLE\"],\"maxConcurrency\":\"1\",\"maxErrors\":\"1\",\"parameters\":{\"commands\":[\"df\"]}}",
"Status": "SUCCESS",
"StatusDetails": "Success",
"StartTime": 1557593493.222,
"EndTime": 1557593498.466
}
]
}
```
# Tutorial: Atualizar uma janela de manutenção usando a AWS CLI
Este tutorial demonstra como usar a AWS Command Line Interface (AWS CLI) para atualizar uma janela de manutenção. Ele também mostra como atualizar diferentes tipos de tarefas, incluindo aquelas do AWS Systems Manager Run Command e Automation, do AWS Lambda e do AWS Step Functions.
Os exemplos nesta seção usam as seguintes ações do Systems Manager para atualizar uma janela de manutenção.
+ [UpdateMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindow.html)
+ [UpdateMaintenanceWindowTarget](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTarget.html)
+ [UpdateMaintenanceWindowTask](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTask.html)
+ [DeregisterTargetFromMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DeregisterTargetFromMaintenanceWindow.html)
Para obter informações sobre como usar o console do Systems Manager para atualizar uma janela de manutenção, consulte [Atualize ou exclua recursos da janela de manutenção usando o console](sysman-maintenance-update.md).
Ao seguir as etapas neste tutorial, substitua os valores em texto itálico *vermelho* por suas próprias opções e IDs. Por exemplo, substitua o ID da janela de manutenção *mw-0c50858d01EXAMPLE* e o ID da instância*i-02573cafcfEXAMPLE* pelos IDs de recursos criados.
**Para atualizar uma janela de manutenção usando a AWS CLI**
1. Abra o AWS CLI e execute o seguinte comando para atualizar um destino de forma a incluir um nome e uma descrição.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--name "My-Maintenance-Window-Target" \
--description "Description for my maintenance window target"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--description "Description for my maintenance window target"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target",
"Description": "Description for my maintenance window target"
}
```
1. Execute o seguinte comando para usar a opção `replace` a fim de remover o campo de descrição e adicionar outro destino. O campo de descrição é removido, pois a atualização não inclui o campo (um valor nulo). Especifique um nó adicional que tenha sido configurado para uso com o Systems Manager:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" \
--name "My-Maintenance-Window-Target" \
--replace
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--replace
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE",
"i-0471e04240EXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target"
}
```
1. A opção `start-date` permite atrasar a ativação de uma janela de manutenção até uma data futura determinada. A opção `end-date` permite que você defina uma data e hora no futuro após a qual a janela de manutenção não será mais executada. Especifique as opções no formato estendido ISO-8601.
Execute o comando a seguir para especificar um intervalo de data e hora para execuções de janela de manutenção programadas regularmente:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--start-date "2020-10-01T10:10:10Z" \
--end-date "2020-11-01T10:10:10Z"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--start-date "2020-10-01T10:10:10Z" ^
--end-date "2020-11-01T10:10:10Z"
```
------
1. Execute o comando a seguir para atualizar uma tarefa do Run Command.
**dica**
Se seu destino for uma instância do Amazon Elastic Compute Cloud (Amazon EC2) para o Windows Server, altere `df` para `ipconfig`, e `AWS-RunShellScript` para `AWS-RunPowerShellScript` no comando a seguir.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "AWS-RunShellScript" \
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" \
--priority 1 --max-concurrency 10 --max-errors 4 \
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "AWS-RunShellScript" ^
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" ^
--priority 1 --max-concurrency 10 --max-errors 4 ^
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "Revising my Run Command task",
"Parameters": {
"commands": [
"df"
]
}
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "4",
"Name": "My-Task-Name",
"Description": "A description for my Run Command task"
}
```
1. Adapte e execute o comando a seguir para atualizar uma tarefa do Lambda.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id mw-0c50858d01EXAMPLE \
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' \
--priority 1 --max-concurrency 10 --max-errors 5 \
--name "New-Lambda-Task-Name" \
--description "A description for my Lambda task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id mw-0c50858d01EXAMPLE ^
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn --task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' ^
--priority 1 --max-concurrency 10 --max-errors 5 ^
--name "New-Lambda-Task-Name" ^
--description "A description for my Lambda task"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
],
"TaskArn": "arn:aws:lambda:us-east-2:111122223333:function:SSMTestLambda",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Lambda": {
"Payload": "e30="
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "New-Lambda-Task-Name",
"Description": "A description for my Lambda task"
}
```
1. Se você estiver atualizando uma tarefa do Step Functions, adapte e execute o seguinte comando para atualizar os task-invocation-parameters:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" \
--description "A description for my Step Functions task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' ^
--priority 0 --max-concurrency 10 --max-errors 5 ^
--name "My-Step-Functions-Task" ^
--description "A description for my Step Functions task"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "arn:aws:states:us-east-2:111122223333:execution:SSMStepFunctionTest",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{\"instanceId\":\"{{RESOURCE_ID}}\"}"
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task"
}
```
1. Execute o comando a seguir para cancelar o registro de um destino de uma janela de manutenção. Este exemplo usa o parâmetro `safe` para determinar se o destino é referenciado por qualquer tarefa e, portanto, seguro para ter o registro cancelado.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--safe
```
------
O sistema retorna informações semelhantes às seguintes.
```
An error occurred (TargetInUseException) when calling the DeregisterTargetFromMaintenanceWindow operation:
This Target cannot be deregistered because it is still referenced in Task: 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE
```
1. Execute o comando a seguir para cancelar o registro de um destino de uma janela de manutenção, mesmo que o destino seja referenciado por uma tarefa. Você pode forçar a operação de cancelamento de registro usando o parâmetro `no-safe`.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--no-safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--no-safe
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Execute o comando a seguir para atualizar uma tarefa do Run Command. Este exemplo usa um parâmetro Parameter Store do Systems Manager chamado `UpdateLevel`, que é formatado da seguinte maneira: '`{{ssm:UpdateLevel}}`'
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A comment for my task update",
"Parameters": {
"UpdateLevel": [
"{{ssm:UpdateLevel}}"
]
}
}
},
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1"
}
```
1. Execute o seguinte comando para atualizar uma tarefa do Automation para especificar os parâmetros `WINDOW_ID` e `WINDOW_TASK_ID` para o parâmetro `task-invocation-parameters`:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE \
--task-arn "AutoTestDoc" \
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole \
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" \
--priority 3 --max-concurrency 10 --max-errors 5
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE ^
--task-arn "AutoTestDoc" ^
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole ^
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" ^
--priority 3 --max-concurrency 10 --max-errors 5
```
------
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AutoTestDoc",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Automation": {
"Parameters": {
"multi": [
"{{WINDOW_TASK_ID}}"
],
"single": [
"{{WINDOW_ID}}"
]
}
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Automation-Task",
"Description": "A description for my Automation task"
}
```
# Tutorial: Excluir uma janela de manutenção usando a AWS CLI
Para excluir uma janela de manutenção que você criou nesses tutoriais, execute o seguinte comando:
```
aws ssm delete-maintenance-window --window-id "mw-0c50858d01EXAMPLE"
```
O sistema retorna informações semelhantes às seguintes.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```