• Le AWS Systems Manager CloudWatch tableau de bord ne sera plus disponible après le 30 avril 2026. Les clients peuvent continuer à utiliser CloudWatch la console Amazon pour consulter, créer et gérer leurs CloudWatch tableaux de bord Amazon, comme ils le font aujourd'hui. Pour plus d'informations, consultez la [documentation Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriels : Créez et gérez des fenêtres de maintenance à l'aide du AWS CLI
Cette section inclut des didacticiels qui vous aident à apprendre à utiliser l' AWS Command Line Interface (AWS CLI) pour effectuer les opérations suivantes :
+ Créer et configurer une fenêtre de maintenance
+ Afficher des informations concernant une fenêtre de maintenance
+ Afficher des informations sur les tâches des fenêtres de maintenance et l'exécution des tâches
+ Mettre à jour une fenêtre de maintenance
+ Supprimer une fenêtre de maintenance
**Gardez une trace des ressources IDs**
Au fur et à mesure que vous effectuez les tâches de ces AWS CLI didacticiels, suivez les ressources IDs générées par les commandes que vous exécutez. Vous utilisez un grand nombre de ceux-ci comme entrées pour les commandes ultérieures. Par exemple, lors de la création de la fenêtre de maintenance, le système vous fournit un ID de fenêtre de maintenance dans le format suivant :
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
Notez les éléments suivants générés par le système, IDs car les didacticiels de cette section les utilisent :
+ `WindowId`
+ `WindowTargetId`
+ `WindowTaskId`
+ `WindowExecutionId`
+ `TaskExecutionId`
+ `InvocationId`
+ `ExecutionId`
Vous avez également besoin de l’ID de l’instance EC2 que vous prévoyez d’utiliser dans les tutoriels. Par exemple : `i-02573cafcfEXAMPLE`
**Topics**
+ [Tutoriel : Création et configuration d'une fenêtre de maintenance à l'aide du AWS CLI](maintenance-windows-cli-tutorials-create.md)
+ [Tutoriel : Afficher les informations relatives aux fenêtres de maintenance à l'aide du AWS CLI](maintenance-windows-cli-tutorials-describe.md)
+ [Tutoriel : Afficher les informations relatives aux tâches et à leur exécution à l'aide du AWS CLI](mw-cli-tutorial-task-info.md)
+ [Tutoriel : Mettre à jour une fenêtre de maintenance à l'aide du AWS CLI](maintenance-windows-cli-tutorials-update.md)
+ [Tutoriel : Supprimer une fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-delete-mw.md)
# Tutoriel : Création et configuration d'une fenêtre de maintenance à l'aide du AWS CLI
Ce didacticiel explique comment utiliser le AWS Command Line Interface (AWS CLI) pour créer et configurer une fenêtre de maintenance, ses cibles et ses tâches. Le parcours principal tout au long de ce didacticiel se compose d'étapes simples. Vous pouvez créer une fenêtre de maintenance simple, identifier une cible unique et configurer une tâche simple pour la fenêtre de maintenance à exécuter. Au fil du parcours, nous fournissons des informations que vous pouvez utiliser pour essayer des scénarios plus complexes.
Au fur et à mesure que vous suivez les étapes de ce didacticiel, remplacez les valeurs en *red* italique par vos propres options et. IDs Par exemple, remplacez l'ID de fenêtre de maintenance *mw-0c50858d01EXAMPLE* et l'ID d'instance *i-02573cafcfEXAMPLE* par IDs des ressources que vous créez.
**Topics**
+ [Étape 1 : Créez la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-create-mw.md)
+ [Étape 2 : Enregistrez un nœud cible dans la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-targets.md)
+ [Étape 3 : enregistrer une tâche dans la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-tasks.md)
# Étape 1 : Créez la fenêtre de maintenance à l'aide du AWS CLI
Au cours de cette étape, vous allez créer une fenêtre de maintenance et spécifier ses options de base, tels que le nom, la planification et la durée. Dans les étapes ultérieures, vous choisirez l'instance qu'elle met à jour et la tâche qu'elle exécute.
Dans notre exemple, vous allez créer une fenêtre de maintenance qui s'exécute toutes les cinq minutes. Normalement, vous n'exécutez pas une fenêtre de maintenance aussi fréquemment. Toutefois, cette fréquence vous permet de voir rapidement les résultats de votre didacticiel. Nous allons vous montrer comment passer à un taux moins fréquent après que la tâche a été exécutée avec succès.
**Note**
Pour obtenir une explication des relations entre les différentes options liées à la planification pour les fenêtres de maintenance, consultez [Options de planification de la fenêtre de maintenance et de période active](maintenance-windows-schedule-options.md).
Pour de plus amples informations sur l'utilisation de l'option `--schedule`, consultez [Référence : Expressions Cron et Rate pour Systems Manager](reference-cron-and-rate-expressions.md).
**Pour créer une fenêtre de maintenance à l'aide du AWS CLI**
1. Ouvrez le AWS Command Line Interface (AWS CLI) et exécutez la commande suivante sur votre machine locale pour créer une fenêtre de maintenance qui effectue les opérations suivantes :
+ S'exécute toutes les cinq minutes pendant un maximum de deux heures (si nécessaire).
+ Empêche le démarrage de nouvelles tâches dans l'heure qui suit la fin de l'opération de fenêtre de maintenance.
+ Autorise les cibles non associées (instances que vous n'avez pas enregistrées avec la fenêtre de maintenance).
+ Indique par l'utilisation de balises personnalisées que son créateur a l'intention de l'utiliser dans un didacticiel.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
1. Maintenant, exécutez la commande suivante pour afficher les informations détaillées sur les fenêtres de maintenance de votre compte.
```
aws ssm describe-maintenance-windows
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowIdentities":[
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 1,
"NextExecutionTime": "2019-05-11T16:46:16.991Z"
}
]
}
```
Passez au [Étape 2 : Enregistrez un nœud cible dans la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-targets.md).
# Étape 2 : Enregistrez un nœud cible dans la fenêtre de maintenance à l'aide du AWS CLI
Au cours de cette étape, vous allez enregistrer une cible avec votre nouvelle fenêtre de maintenance. Dans ce cas, vous devez spécifier le nœud à mettre à jour pendant l'exécution de la fenêtre de maintenance.
Pour un exemple d'enregistrement de plusieurs nœuds à la fois à l'aide d'un nœud IDs, des exemples d'utilisation de balises pour identifier plusieurs nœuds et des exemples de spécification de groupes de ressources en tant que cibles, consultez[Exemples : Enregistrement de cibles avec une fenêtre de maintenance](mw-cli-tutorial-targets-examples.md).
**Note**
Vous devez déjà avoir créé une instance Amazon Elastic Compute Cloud (Amazon EC2) à utiliser dans cette étape, comme décrit dans les [Prérequis du didacticiel Maintenance Windows](maintenance-windows-tutorials.md).
**Pour enregistrer un nœud cible avec une fenêtre de maintenance à l'aide du AWS CLI**
1. Exécutez la commande suivante sur votre machine locale. Remplacez chaque *example resource placeholder* par vos propres informations.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowTargetId":"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Maintenant, exécutez la commande suivante sur votre machine locale pour afficher les détails relatifs à la cible de votre fenêtre de maintenance.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
]
}
]
}
```
Passez au [Étape 3 : enregistrer une tâche dans la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-tasks.md).
# Exemples : Enregistrement de cibles avec une fenêtre de maintenance
Vous pouvez enregistrer un nœud individuel comme cible à l'aide de son ID de nœud, comme démontré dans [Étape 2 : Enregistrez un nœud cible dans la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-targets.md). Vous pouvez également enregistrer un ou plusieurs nœuds comme cibles à l'aide des commandes présentées sur cette page.
En général, deux méthodes permettent d'identifier les nœuds à utiliser comme cibles de fenêtre de maintenance : spécifier des nœuds individuels ou utiliser des balises de ressources. La méthode de balises de ressources offre davantage d'options, comme illustré dans les exemples 2 à 3.
Vous pouvez également spécifier un ou plusieurs groupes de ressources en tant que cible d'une fenêtre de maintenance. Un groupe de ressources peut inclure des nœuds et de nombreux autres types de AWS ressources prises en charge. Les exemples 4 et 5 ci-après montrent comment ajouter des groupes de ressources à vos cibles de fenêtre de maintenance.
**Note**
Si une seule tâche de fenêtre de maintenance est enregistrée avec plusieurs cibles, ses appels de tâches se produisent en séquence et non en parallèle. Si votre tâche doit s'exécuter sur plusieurs cibles simultanément, enregistrez une tâche pour chaque cible individuellement et attribuez à chaque tâche le même niveau de priorité.
Pour plus d'informations sur la création et la gestion des groupes de ressources, consultez [Que sont les groupes de ressources ?](https://docs.aws.amazon.com/ARG/latest/userguide/resource-groups.html) dans le *Guide de l'utilisateur Groupes de ressources AWS * et [Groupes de ressources et balisage pour AWS](https://aws.amazon.com/blogs/aws/resource-groups-and-tagging/) dans *AWS News Blog*.
Pour plus d'informations sur les quotas pour Maintenance Windows un outil AWS Systems Manager, outre ceux spécifiés dans les exemples suivants, consultez la section [Quotas de service Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) dans le *Référence générale d'Amazon Web Services*.
## Exemple 1 : enregistrer plusieurs cibles à l'aide d'un nœud IDs
Exécutez la commande suivante sur le format de votre machine locale pour enregistrer plusieurs nœuds en tant que cibles à l'aide de leur nœud IDs. Remplacez chaque *example resource placeholder* par vos propres informations.
------
#### [ 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
```
------
**Utilisation recommandée** : particulièrement utile lorsque vous enregistrez pour la première fois un groupe unique de nœuds auprès d'une fenêtre de maintenance et qu'ils ne *partagent pas* de balise de nœud commune.
**Quotas :** vous pouvez spécifier un maximum de 50 nœuds pour chaque cible de fenêtre de maintenance.
## Exemple 2 : Enregistrement de cibles à l'aide des balises de ressources appliquées aux nœuds
Exécutez la commande suivante sur votre machine locale pour enregistrer les nœuds qui sont déjà balisés avec une paire clé-valeur que vous avez attribuée. Remplacez chaque *example resource placeholder* par vos propres informations.
------
#### [ 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"
```
------
**Utilisation recommandée** : particulièrement utile lorsque vous enregistrez pour la première fois un groupe unique de nœuds auprès d'une fenêtre de maintenance et qu'ils *partagent* une balise de nœud commune.
**Quotas :** vous pouvez spécifier jusqu'à cinq paires clé-valeur au total pour chaque cible. Si vous spécifiez plusieurs paires clé-valeur, un nœud doit être balisé avec *toutes* les clés et valeurs de balise que vous décidez d'inclure dans le groupe cible.
**Note**
Vous pouvez baliser un groupe de noeuds avec la clé de balise : `Patch Group`ou`PatchGroup` et attribuer les noeuds d'une valeur de clé commune, comme `my-patch-group`. (Utilisez `PatchGroup`, sans espace, si vous avez [autorisé les balises dans les métadonnées d’instance EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#allow-access-to-tags-in-IMDS).) Patch Manager, un outil de Systems Manager, évalue la clé `Patch Group` ou `PatchGroup` sur les nœuds afin d’aider à déterminer le référentiel de correctifs applicable à ces nœuds. Si votre tâche exécutera le document SSM `AWS-RunPatchBaseline` (ou le document SSM `AWS-ApplyPatchBaseline` hérité), spécifiez la même paire clé-valeur `Patch Group` ou `PatchGroup` lors de l'enregistrement des cibles avec une fenêtre de maintenance. Par exemple : `--target "Key=tag:PatchGroup,Values=my-patch-group`. Cela vous permet d'utiliser une fenêtre de maintenance pour mettre à jour les correctifs d'un groupe de nœuds qui sont déjà associés au même référentiel de correctifs. Pour de plus amples informations, veuillez consulter [Groupes de correctifs](patch-manager-patch-groups.md).
## Exemple 3 : Enregistrement de cibles à l'aide d'un groupe de clés de balise (sans valeurs de balise)
Exécutez la commande suivante sur votre machine locale pour enregistrer les nœuds qui disposent tous d'une ou plusieurs clés de balise, indépendamment de leurs valeurs de clé. Remplacez chaque *example resource placeholder* par vos propres informations.
------
#### [ 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"
```
------
**Utilisation recommandée :** utile lorsque vous souhaitez cibler des nœuds en spécifiant plusieurs *clés* de balise (sans leurs valeurs) plutôt qu'une seule clé de balise ou une paire clé-valeur de balise.
**Quotas :** vous pouvez spécifier jusqu'à cinq clés de balise au total pour chaque cible. Si vous spécifiez plusieurs clés de balise, un nœud doit être balisé avec *toutes* les clés de balise que vous décidez d'inclure dans le groupe cible.
## Exemple 4 : Enregistrement de cibles à l'aide d'un nom de groupe de ressources
Exécutez la commande suivante sur votre machine locale pour enregistrer un groupe de ressources spécifié, quel que soit le type des ressources que celui-ci contient. Remplacez *mw-0c50858d01EXAMPLE* par vos propres informations. Si les tâches que vous attribuez à la fenêtre de maintenance n'agissent pas sur un type de ressource inclus dans le groupe de ressources, le système peut signaler une erreur. Les tâches pour lesquelles un type de ressource pris en charge est trouvé continuent de s'exécuter malgré ces erreurs.
------
#### [ 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"
```
------
**Utilisation recommandée** : Utile lorsque vous souhaitez spécifier rapidement un groupe de ressources en tant que cible sans évaluer si tous ses types de ressource seront ciblés par une fenêtre de maintenance, ou lorsque vous savez que le groupe de ressources contient uniquement les types de ressource sur lesquelles vos tâches exécutent des actions.
**Quotas :** Vous pouvez spécifier un seul groupe de ressources comme cible.
## Exemple 5 : Enregistrement de cibles en filtrant des types de ressource dans un groupe de ressources
Exécutez la commande suivante sur votre machine locale pour enregistrer uniquement certains types de ressource qui appartiennent à un groupe de ressources que vous spécifiez. Remplacez *mw-0c50858d01EXAMPLE* par vos propres informations. Avec cette option, même si vous ajoutez une tâche pour un type de ressource qui appartient au groupe de ressources, la tâche ne s'exécute pas si vous n'avez pas ajouté explicitement ce type de ressource au filtre.
------
#### [ 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"
```
------
**Usage recommandé** : Utile lorsque vous souhaitez conserver un contrôle strict sur les types de AWS ressources sur lesquels votre fenêtre de maintenance peut exécuter des actions, ou lorsque votre groupe de ressources contient un grand nombre de types de ressources et que vous souhaitez éviter de signaler des erreurs inutiles dans les journaux de vos fenêtres de maintenance.
**Quotas :** Vous pouvez spécifier un seul groupe de ressources comme cible.
# Étape 3 : enregistrer une tâche dans la fenêtre de maintenance à l'aide du AWS CLI
Dans cette étape du didacticiel, vous enregistrez une AWS Systems Manager Run Command tâche qui exécute la `df` commande sur votre instance Amazon Elastic Compute Cloud (Amazon EC2) pour Linux. Les résultats de cette commande Linux standard montrent la quantité d'espace disponible et la quantité d'espace utilisée sur le système de fichiers du disque de votre instance.
-ou-
Si vous ciblez une instance Amazon EC2 pour Windows Server au lieu de Linux, remplacez **df** dans la commande suivante par **ipconfig**. Le résultat de cette commande répertorie les détails relatifs à l'adresse IP, le masque de sous-réseau et la passerelle par défaut pour les adaptateurs sur l'instance cible.
Lorsque vous êtes prêt à enregistrer d'autres types de tâches ou à utiliser plusieurs des options Systems Manager Run Command disponibles, consultez [Exemples : Enregistrement de tâches avec une fenêtre de maintenance](mw-cli-register-tasks-examples.md). Là, nous fournissons plus d'informations sur les quatre types de tâches, et certaines de leurs principales options, pour vous aider à planifier des scénarios concrets plus vastes.
**Pour enregistrer une tâche avec une fenêtre de maintenance**
1. Exécutez la commande suivante sur votre machine locale. Remplacez chaque *example resource placeholder* par vos propres informations. La version à exécuter à partir d'une machine Windows locale inclut les caractères d'échappement (« / ») dont vous avez besoin pour exécuter la commande à partir de votre outil de ligne de commande.
------
#### [ 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\"]}}}
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE"
}
```
1. Maintenant, exécutez la commande suivante pour afficher les détails relatifs à la tâche de fenêtre de maintenance que vous avez créée.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id mw-0c50858d01EXAMPLE
```
------
1. Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Attendez que la tâche ait eu le temps d'être exécutée, conformément à la planification que vous avez spécifiée dans [Étape 1 : Créez la fenêtre de maintenance à l'aide du AWS CLI](mw-cli-tutorial-create-mw.md). Par exemple, si vous avez spécifié **--schedule "rate(5 minutes)"**, attendez cinq minutes. Ensuite, exécutez la commande suivante pour afficher des informations sur toutes les exécutions qui se sont produites pour cette tâche.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id mw-0c50858d01EXAMPLE
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
]
}
```
**Astuce**
Une fois que la tâche s'est terminée avec succès, vous pouvez diminuer la fréquence à laquelle la fenêtre de maintenance s'exécute. Par exemple, exécutez la commande suivante pour réduire la fréquence à une fois par semaine. Remplacez *mw-0c50858d01EXAMPLE* par vos propres informations.
```
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)"
```
Pour de plus amples informations sur la planification des fenêtres de maintenance, veuillez consulter [Référence : Expressions Cron et Rate pour Systems Manager](reference-cron-and-rate-expressions.md) et [Options de planification de la fenêtre de maintenance et de période active](maintenance-windows-schedule-options.md).
Pour plus d'informations sur l'utilisation du AWS Command Line Interface (AWS CLI) pour modifier une fenêtre de maintenance, consultez[Tutoriel : Mettre à jour une fenêtre de maintenance à l'aide du AWS CLI](maintenance-windows-cli-tutorials-update.md).
Pour vous entraîner à exécuter AWS CLI des commandes afin d'obtenir plus de détails sur votre tâche de fenêtre de maintenance et ses exécutions, passez à[Tutoriel : Afficher les informations relatives aux tâches et à leur exécution à l'aide du AWS CLI](mw-cli-tutorial-task-info.md).
**Accès à la sortie des commandes du tutoriel**
L'utilisation du pour afficher le *résultat* de la Run Command commande associée AWS CLI à l'exécution des tâches de votre fenêtre de maintenance n'entre pas dans le cadre de ce didacticiel.
Vous pouvez toutefois consulter ces données à l'aide du AWS CLI. (Vous pouvez également afficher la sortie dans la console Systems Manager ou dans un fichier journal stocké dans un compartiment Amazon Simple Storage Service [Amazon S3], si vous avez configuré la fenêtre de maintenance afin qu'elle stocke la sortie de commande à cet endroit.) Vous constaterez que la sortie de la commande **df** sur une instance EC2 pour Linux est similaire à ce qui suit.
```
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% /
```
La sortie de la commande **ipconfig** sur une instance EC2 pour Windows Server est similaire à ce qui suit :
```
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 . :
```
# Exemples : Enregistrement de tâches avec une fenêtre de maintenance
Vous pouvez enregistrer une tâche dansRun Command, un outil dans AWS Systems Manager, avec une fenêtre de maintenance à l'aide du AWS Command Line Interface (AWS CLI), comme illustré dans [Enregistrer des tâches dans la fenêtre de maintenance](mw-cli-tutorial-tasks.md). Vous pouvez également enregistrer des tâches pour les flux de travail, les AWS Lambda fonctions et les AWS Step Functions tâches de Systems Manager Automation, comme expliqué plus loin dans cette rubrique.
**Note**
Spécifiez une ou plusieurs cibles pour des tâches de fenêtre de maintenance de type Run Command. En fonction de la tâche, les cibles sont facultatives pour les autres types de tâches de la fenêtre de maintenance (Automation AWS Lambda, et AWS Step Functions). Pour de plus amples informations sur l'exécution de tâches qui ne spécifient pas de cibles, consultez [Enregistrement de tâches de fenêtre de maintenance sans cibles](maintenance-windows-targetless-tasks.md).
Dans cette rubrique, nous donnons des exemples d'utilisation de la commande AWS Command Line Interface (AWS CLI) `register-task-with-maintenance-window` pour enregistrer chacun des quatre types de tâches pris en charge avec une fenêtre de maintenance. Les exemples sont uniquement fournis à titre de démonstration. Mais vous pouvez les modifier afin de créer des commandes réelles d'enregistrement des tâches.
**Utilisation de l'cli-input-json option --**
Afin de mieux gérer vos options de tâches, vous pouvez utiliser l'option de commande `--cli-input-json`, avec les valeurs d'options référencées dans un fichier JSON.
Pour utiliser l'exemple de contenu de fichier JSON que nous fournissons dans les exemples suivants, effectuez les opérations suivantes sur votre machine locale :
1. Créez un fichier portant un nom comme `MyRunCommandTask.json`, `MyAutomationTask.json` ou tout autre nom de votre choix.
1. Copiez le contenu de notre exemple JSON dans le fichier.
1. Modifiez le contenu du fichier pour l'enregistrement de vos tâches, puis enregistrez le fichier.
1. Dans le répertoire où vous avez stocké le fichier, exécutez la commande suivante. Remplacez le nom de votre fichier par*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
```
------
**Pseudo paramètres dans les tâches de la fenêtre de maintenance**
Dans certains exemples, nous utilisons des *pseudo-paramètres* comme méthode pour transmettre des informations d'ID à vos tâches. Par exemple, il `{{TARGET_ID}}` `{{RESOURCE_ID}}` peut être utilisé pour transmettre IDs des AWS ressources aux tâches Automation, Lambda et Step Functions. Pour plus d'informations sur les pseudo-paramètres dans les contenus `--task-invocation-parameters`, consultez [Utiliser des pseudo paramètres lors de l’enregistrement des tâches de la fenêtre de maintenance](maintenance-window-tasks-pseudo-parameters.md).
**Plus d'informations**
+ [Options de paramètres pour la commande 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) dans la *référence de commande de l'AWS CLI *
+ [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html) dans la *Référence d'API AWS Systems Manager *
## Exemples d'enregistrement de tâches
Les sections suivantes fournissent un exemple de AWS CLI commande pour enregistrer un type de tâche pris en charge et un exemple JSON qui peut être utilisé avec l'`--cli-input-json`option.
### Enregistrer une tâche Systems Manager Run Command
Les exemples suivants montrent comment enregistrer des tâches Systems Manager Run Command avec une fenêtre de maintenance à l'aide de l' 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\"]}}}"
```
------
**Contenu JSON à utiliser avec l'option de fichier `--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
}
}
}
```
### Enregistrer une tâche Systems Manager Automation
Les exemples suivants montrent comment enregistrer des tâches Automation Systems Manager avec une fenêtre de maintenance à l'aide de l' AWS CLI :
**AWS CLI commande :**
------
#### [ 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"
```
------
**Contenu JSON à utiliser avec l'option de fichier `--cli-input-json` :**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"TaskArn": "AWS-PatchInstanceWithRollback",
"TaskType": "AUTOMATION","TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "1",
"Parameters": {
"instanceId": [
"{{RESOURCE_ID}}"
]
}
}
}
}
```
### Enregistrer une AWS Lambda tâche
Les exemples suivants montrent comment enregistrer des tâches de fonctions Lambda avec une fenêtre de maintenance à l'aide de la AWS CLI.
Pour ces exemples, l'utilisateur qui a créé la fonction Lambda l'a nommée `SSMrestart-my-instances` et a créé deux paramètres appelés `instanceId` et `targetType`.
**Important**
La politique IAM pour Maintenance Windows exige que vous donniez un préfixe `SSM` à la fonction Lambda (ou alias). Avant de procéder à l'enregistrement de ce type de tâche, mettez à jour son nom AWS Lambda pour inclure`SSM`. Par exemple, si votre nom de fonction Lambda est `MyLambdaFunction`, remplacez-le par `SSMMyLambdaFunction`.
**AWS CLI commande :**
------
#### [ Linux & macOS ]
**Important**
Si vous utilisez la version 2 du AWS CLI, vous devez inclure l'option `--cli-binary-format raw-in-base64-out` dans la commande suivante si votre charge utile Lambda n'est pas codée en base64. L'option `cli_binary_format` n'est disponible que dans la version 2. Pour plus d'informations à ce sujet et sur d'autres paramètres de AWS CLI `config` fichier, consultez la section [Paramètres de `config` fichiers pris en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) dans le *Guide de AWS Command Line Interface l'utilisateur*.
```
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 ]
**Important**
Si vous utilisez la version 2 du AWS CLI, vous devez inclure l'option `--cli-binary-format raw-in-base64-out` dans la commande suivante si votre charge utile Lambda n'est pas codée en base64. L'option `cli_binary_format` n'est disponible que dans la version 2. Pour plus d'informations à ce sujet et sur d'autres paramètres de AWS CLI `config` fichier, consultez la section [Paramètres de `config` fichiers pris en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) dans le *Guide de AWS Command Line Interface l'utilisateur*.
```
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\"}}'
```
------
**Contenu JSON à utiliser avec l'option de fichier `--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
}
```
### Enregistrer une tâche Step Functions
Les exemples suivants montrent comment enregistrer des tâches de machine d'état Step Functions avec une fenêtre de maintenance à l'aide de la AWS CLI.
**Note**
Les tâches de fenêtre de maintenance prennent uniquement en charge les flux de travail de machine d’état Standard Step Functions. Elles ne prennent pas en charge les flux de travail de machine d’état Express. Pour plus d’informations sur les types de flux de travail de machine d’état, consultez [Flux de travail Standard vs. Express](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) dans le *Guide du développeur AWS Step Functions *.
Pour ces exemples, l'utilisateur qui a créé la machine d'état Step Functions à créé une machine d'état nommée `SSMMyStateMachine` avec un paramètre appelé `instanceId`.
**Important**
La politique Gestion des identités et des accès AWS (IAM) pour Maintenance Windows exige que vous préfixiez les noms des machines d'état Step Functions par. `SSM` Avant de procéder à l'enregistrement de ce type de tâche, vous devez mettre à jour son nom dans AWS Step Functions pour inclure `SSM`. Par exemple, si le nom de votre machine d'état est `MyStateMachine`, remplacez-le par `SSMMyStateMachine`.
**AWS CLI commande :**
------
#### [ 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"
```
------
**Contenu JSON à utiliser avec l'option de fichier `--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
}
```
# Options de paramètres pour la commande register-task-with-maintenance -windows
La commande **register-task-with-maintenance-window** fournit plusieurs options pour configurer une tâche en fonction de vos besoins. Certaines sont requises, certaines sont facultatives et d'autres s'appliquent à un seul type de tâche de fenêtre de maintenance.
Cette rubrique fournit des informations sur certaines de ces options pour vous aider à utiliser les exemples de cette section du didacticiel. Pour plus d'informations sur les autres options de commande, consultez **[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)** dans la *Référence Command AWS CLI *.
**Option de commande : `--task-arn`**
L'option `--task-arn` est utilisée pour spécifier la ressource sur laquelle la tâche opère. La valeur que vous spécifiez dépend du type de tâche que vous enregistrez, comme décrit dans le tableau suivant.
**TaskArn formats pour les tâches de la fenêtre de maintenance**
| Type de tâche de fenêtre de maintenance | TaskArn valeur |
| --- | --- |
| **`RUN_COMMAND`** et ** `AUTOMATION`** | `TaskArn` correspond au nom ou à l'Amazon Resource Name (ARN) du nom du document SSM. Par exemple : `AWS-RunBatchShellScript` -ou- `arn:aws:ssm:region:111122223333:document/My-Document`. |
| **`LAMBDA`** | `TaskArn` est le nom de fonction ou l'ARN. Par exemple : `SSMMy-Lambda-Function` -ou- `arn:aws:lambda:region:111122223333:function:SSMMyLambdaFunction`. La politique IAM pour Maintenance Windows exige que vous donniez un préfixe `SSM` à la fonction Lambda (ou alias). Avant de procéder à l'enregistrement de ce type de tâche, mettez à jour son nom AWS Lambda pour inclure`SSM`. Par exemple, si votre nom de fonction Lambda est `MyLambdaFunction`, remplacez-le par `SSMMyLambdaFunction`. |
| **`STEP_FUNCTIONS`** | `TaskArn` est l'ARN de la machine d'état. Par exemple : `arn:aws:states:us-east-2:111122223333:stateMachine:SSMMyStateMachine`. La politique IAM pour les fenêtres de maintenance exige que vous donniez un préfixe aux noms de machines d'état Step Functions avec `SSM`. Avant d'enregistrer ce type de tâche, vous devez mettre à jour son nom dans AWS Step Functions pour inclure `SSM`. Par exemple, si le nom de votre machine d'état est `MyStateMachine`, remplacez-le par `SSMMyStateMachine`. |
**Option de commande : `--service-role-arn`**
Le rôle AWS Systems Manager à assumer lors de l'exécution de la tâche de fenêtre de maintenance.
Pour de plus amples informations, consultez [Configuration de Maintenance Windows](setting-up-maintenance-windows.md).
**Option de commande : `--task-invocation-parameters`**
L'option `--task-invocation-parameters` permet de spécifier les paramètres qui sont spécifiques à chacun des quatre types de tâches. Les paramètres pris en charge pour chacun des quatre types de tâches sont décrits dans le tableau suivant.
**Note**
Pour plus d'informations sur l'utilisation des pseudo-paramètres dans le contenu `--task-invocation-parameters`, comme \$1\$1TARGET\$1ID\$1\$1, consultez [Utiliser des pseudo paramètres lors de l’enregistrement des tâches de la fenêtre de maintenance](maintenance-window-tasks-pseudo-parameters.md).
Options de paramètres d’invocation de tâches pour les tâches de fenêtres de maintenance
| Type de tâche de fenêtre de maintenance | Paramètres disponibles | Exemple |
| --- | --- | --- |
| **`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}}"
}
} |
# Tutoriel : Afficher les informations relatives aux fenêtres de maintenance à l'aide du AWS CLI
Ce didacticiel inclut des commandes pour vous aider à mettre à jour ou obtenir les informations sur vos fenêtres de maintenance, tâches, exécutions et appels. Les exemples sont organisés par commande pour montrer comment utiliser les options de commande afin de filtrer le type de détail que vous souhaitez afficher.
Au fur et à mesure que vous suivez les étapes de ce didacticiel, remplacez les valeurs en *red* italique par vos propres options et. IDs Par exemple, remplacez l'ID de fenêtre de maintenance *mw-0c50858d01EXAMPLE* et l'ID d'instance *i-02573cafcfEXAMPLE* par IDs des ressources que vous créez.
Pour plus d'informations sur l'installation et la configuration du AWS Command Line Interface (AWS CLI), voir [Installation, mise à jour et désinstallation du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [Configuration du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
**Topics**
+ [Exemples pour « describe-maintenance-windows »](#mw-cli-tutorials-describe-maintenance-windows)
+ [Exemples pour « describe-maintenance-window-targets »](#mw-cli-tutorials-describe-maintenance-window-targets)
+ [Exemples pour « describe-maintenance-window-tasks »](#mw-cli-tutorials-describe-maintenance-window-tasks)
+ [Exemples pour « describe-maintenance-windows-for -target »](#mw-cli-tutorials-describe-maintenance-windows-for-target)
+ [Exemples pour « describe-maintenance-window-executions »](#mw-cli-tutorials-describe-maintenance-window-executions)
+ [Exemples pour « describe-maintenance-window-schedule »](#mw-cli-tutorials-describe-maintenance-window-schedule)
## Exemples pour « describe-maintenance-windows »
**Répertoriez toutes les fenêtres de maintenance de votre Compte AWS**
Exécutez la commande suivante.
```
aws ssm describe-maintenance-windows
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
},
]
}
```
**Affichage de toutes les fenêtres de maintenance activées**
Exécutez la commande suivante.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=true"
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
},
]
}
```
**Affichage de toutes les fenêtres de maintenance désactivées**
Exécutez la commande suivante.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=false"
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowIdentities": [
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
**Répertorier toutes les fenêtres de maintenance dont les noms commencent par un préfixe donné**
Exécutez la commande suivante.
```
aws ssm describe-maintenance-windows --filters "Key=Name,Values=My"
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"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
}
]
}
```
## Exemples pour « describe-maintenance-window-targets »
**Affichage des cibles d'une fenêtre de maintenance correspondant à une valeur d'Information d'un propriétaire spécifique**
Exécutez la commande suivante.
------
#### [ 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"
```
------
**Note**
Les clés de filtres prises en charge sont `Type`, `WindowTargetId` et `OwnerInformation`.
Le système renvoie des informations similaires à ce qui suit :
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "tag:Name",
"Values": [
"Production"
]
}
],
"OwnerInformation": "CostCenter1",
"Name": "Target1"
}
]
}
```
## Exemples pour « describe-maintenance-window-tasks »
**Afficher toutes les tâches enregistrées qui appellent le document de commande SSM `AWS-RunPowerShellScript`**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
]
}
]
}
```
**Afficher toutes les tâches enregistrées qui ont une priorité égale à « 3 »**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
]
}
]
}
```
**Afficher toutes les tâches enregistrées qui ont une priorité égale à « 1 » et qui utilisent la fonctionnalité Run Command**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
]
}
```
## Exemples pour « describe-maintenance-windows-for -target »
**Répertorier les informations relatives aux cibles ou tâches de fenêtre de maintenance associées à un nœud spécifique**
Exécutez la commande suivante.
------
#### [ 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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window"
}
]
}
```
## Exemples pour « describe-maintenance-window-executions »
**Répertorier toutes les tâches exécutées avant une date donnée**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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
}
]
}
```
**Répertorier toutes les tâches exécutées après une date donnée**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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
}
]
}
```
## Exemples pour « describe-maintenance-window-schedule »
**Afficher les dix exécutions de fenêtre de maintenance planifiées suivantes pour un nœud particulier**
Exécutez la commande suivante.
------
#### [ 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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
```
**Afficher le calendrier des fenêtres de maintenance pour les nœuds balisés avec une paire clé-valeur donnée**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
```
**Afficher les heures de début des quatre prochaines exécutions d'une fenêtre de maintenance**
Exécutez la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
]
}
]
}
```
# Tutoriel : Afficher les informations relatives aux tâches et à leur exécution à l'aide du AWS CLI
Ce didacticiel explique comment utiliser le AWS Command Line Interface (AWS CLI) pour afficher les détails des tâches de votre fenêtre de maintenance terminées.
Si vous passez directement à ce didacticiel à partir de [Tutoriel : Création et configuration d'une fenêtre de maintenance à l'aide du AWS CLI](maintenance-windows-cli-tutorials-create.md), assurez-vous d'avoir laissé assez de temps à votre fenêtre de maintenance pour qu'elle s'exécute au moins une fois afin de pouvoir afficher ses résultats d'exécution.
Au fur et à mesure que vous suivez les étapes de ce didacticiel, remplacez les valeurs en *red* italique par vos propres options et. IDs Par exemple, remplacez l'ID de fenêtre de maintenance *mw-0c50858d01EXAMPLE* et l'ID d'instance *i-02573cafcfEXAMPLE* par IDs des ressources que vous créez.
**Pour afficher des informations sur les tâches et leur exécution à l'aide du AWS CLI**
1. Exécutez la commande suivante pour afficher la liste des exécutions de tâche pour une fenêtre de maintenance spécifique.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour obtenir des informations sur une exécution de tâche d'une fenêtre de maintenance.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskIds": [
"c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
],
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
```
1. Exécutez la commande suivante pour afficher les tâches exécutées dans le cadre de l'exécution d'une fenêtre de maintenance.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour obtenir les détails d'une exécution de tâche.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour obtenir les appels de tâche spécifiques exécutés pendant une exécution de tâche.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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
}
]
}
```
# Tutoriel : Mettre à jour une fenêtre de maintenance à l'aide du AWS CLI
Ce didacticiel explique comment utiliser le AWS Command Line Interface (AWS CLI) pour mettre à jour une fenêtre de maintenance. Il vous montre également comment mettre à jour différents types de tâches, y compris celles pour AWS Systems Manager Run Command et Automation AWS Lambda, et AWS Step Functions.
Les exemples de cette section utilisent les actions Systems Manager suivantes pour la mise à jour d'une fenêtre de maintenance :
+ [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)
Pour des informations sur l'utilisation de la console Systems Manager afin de mettre à jour une fenêtre de maintenance, consultez [Mise à jour ou suppression des ressources de fenêtre de maintenance à l’aide de la console](sysman-maintenance-update.md).
Au fur et à mesure que vous suivez les étapes de ce didacticiel, remplacez les valeurs en *red* italique par vos propres options et. IDs Par exemple, remplacez l'ID de fenêtre de maintenance *mw-0c50858d01EXAMPLE* et l'ID d'instance *i-02573cafcfEXAMPLE* par IDs des ressources que vous créez.
**Pour mettre à jour une fenêtre de maintenance à l'aide du AWS CLI**
1. Ouvrez le AWS CLI et exécutez la commande suivante pour mettre à jour une cible afin d'inclure un nom et une description.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour utiliser l'option `replace` afin de supprimer le champ de description et d'ajouter une cible supplémentaire. Le champ de description est supprimé, car la mise à jour ne l'inclut pas (valeur nulle). Veillez à spécifier un nœud supplémentaire configuré pour être utilisé avec 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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE",
"i-0471e04240EXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target"
}
```
1. L'option `start-date` vous permet de retarder l'activation d'une fenêtre de maintenance jusqu'à une date ultérieure spécifiée. L'option `end-date` vous permet de définir une date et une heure futures après lesquelles la fenêtre de maintenance ne s'exécutera plus. Spécifiez les options au format ISO-8601 étendu.
Exécutez la commande suivante pour spécifier une plage de dates et d'heures pour les exécutions de fenêtre de maintenance régulièrement planifiées.
------
#### [ 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. Exécutez la commande suivante pour mettre à jour une tâche Run Command.
**Astuce**
Si votre cible est une instance Amazon Elastic Compute Cloud (Amazon EC2) pour Windows Server, changez `df` à `ipconfig`, et `AWS-RunShellScript` à `AWS-RunPowerShellScript` dans la commande suivante.
------
#### [ 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Adaptez et exécutez la commande suivante pour mettre à jour une tâche 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Si vous mettez à jour une tâche Step Functions, adaptez et exécutez la commande suivante pour la mettre à jour 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"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour annuler l'enregistrement d'une cible depuis une fenêtre de maintenance. Cet exemple utilise le paramètre `safe` pour déterminer si la cible est référencée par toute tâche et si il est donc sécurisé d'annuler son enregistrement.
------
#### [ 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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
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. Exécutez la commande suivante pour annuler l'enregistrement d'une cible depuis une fenêtre de maintenance même si la cible est référencée par une tâche. Vous pouvez forcer l'opération d'annulation d'enregistrement à l'aide du paramètre `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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Exécutez la commande suivante pour mettre à jour une tâche Run Command. Cet exemple utilise un paramètre Systems Manager Parameter Store appelé `UpdateLevel`, qui est formaté comme suit : '`{{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}}'}}"
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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. Exécutez la commande suivante pour mettre à jour une tâche Automation afin qu'elle spécifie les paramètres `WINDOW_ID` et `WINDOW_TASK_ID` pour le paramètre `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
```
------
Le système renvoie des informations similaires à ce qui suit :
```
{
"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"
}
```
# Tutoriel : Supprimer une fenêtre de maintenance à l'aide du AWS CLI
Pour supprimer une fenêtre de maintenance que vous avez créée dans ces didacticiels, exécutez la commande suivante.
```
aws ssm delete-maintenance-window --window-id "mw-0c50858d01EXAMPLE"
```
Le système renvoie des informations similaires à ce qui suit :
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```