• 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.
# AWS Systems Manager Run Command
À l'aide Run Command d'un outil AWS Systems Manager, vous pouvez gérer à distance et en toute sécurité la configuration de vos nœuds gérés. Un *nœud géré* est une instance Amazon Elastic Compute Cloud (Amazon EC2) ou une instance non EC2 machine de votre environnement [hybride et multicloud](operating-systems-and-machine-types.md#supported-machine-types) qui a été configurée pour Systems Manager. Run Commandvous permet d'automatiser les tâches administratives courantes et d'effectuer des modifications de configuration ponctuelles à grande échelle. Vous pouvez utiliser Run Command from the AWS Management Console, AWS Command Line Interface the (AWS CLI) ou le AWS SDKs. AWS Tools for Windows PowerShellRun Commandest offert sans frais supplémentaires. Pour vos premiers pas dans Run Command, ouvrez [Systems Manager console](https://console.aws.amazon.com//systems-manager/run-command). Dans le panneau de navigation, sélectionnez **Run Command**.
Les administrateurs ont recours à la fonctionnalité Run Command pour installer ou amorcer des applications, créer un pipeline de déploiement, capturer des fichiers journaux lorsqu'une instance est mise hors service à partir d'un groupe Auto Scaling, joindre des instances à un domaine Windows et bien plus.
L’API Run Command suit un modèle de cohérence à terme en raison de la nature distribuée du système de support de l’API. Cela signifie que le résultat d’une commande API que vous exécutez et qui affecte vos ressources peut ne pas être immédiatement visible par toutes les commandes ultérieures que vous exécutez. Vous devez garder cela à l’esprit lorsque vous exécutez une commande API qui suit immédiatement une commande API précédente.
**Démarrage**
Le tableau suivant comporte des informations pour vous aider à vous familiariser avec Run Command.
****
| Rubrique | Détails |
| --- | --- |
| [Configuration de nœuds gérés pour AWS Systems Manager](systems-manager-setting-up-nodes.md) | Vérifiez que vous avez satisfait aux exigences de configuration pour vos instances Amazon Elastic Compute Cloud (Amazon EC2) et celles qui ne sont pas EC2 des machines dans un environnement [hybride et multicloud](operating-systems-and-machine-types.md#supported-machine-types). |
| [Gestion des nœuds dans les environnements hybrides et multicloud avec Systems Manager](systems-manager-hybrid-multicloud.md) | (Facultatif) Enregistrez les serveurs locaux et VMs avec lesquels vous AWS pourrez les gérer à l'aide Run Command de. |
| [Gestion des appareils de périphérie avec Systems Manager](systems-manager-setting-up-edge-devices.md) | (Facultatif) Configurez les appareils de périphérie pour pouvoir les gérer à l'aide de Run Command. |
| [Exécution de commandes sur des nœuds gérés](running-commands.md) | Découvrez comment exécuter une commande ciblant un ou plusieurs nœuds gérés à l'aide de la AWS Management Console. |
| [Procédures Run Command](run-command-walkthroughs.md) | Apprenez à exécuter des commandes à l'aide des outils pour Windows PowerShell ou du AWS CLI. |
**EventBridge soutien**
Cet outil Systems Manager est pris en charge à la fois en tant que type d'*événement* et en tant que type de *cible* dans EventBridge les règles Amazon. Pour plus d’informations, consultez [Surveillance des événements de Systems Manager avec Amazon EventBridge](monitoring-eventbridge-events.md) et [Référence : modèles et types d' EventBridge événements Amazon pour Systems Manager](reference-eventbridge-events.md).
**Plus d'informations**
+ [À distance Run Command sur une EC2 instance (didacticiel de 10 minutes)](https://aws.amazon.com/getting-started/hands-on/remotely-run-commands-ec2-instance-systems-manager/)
+ [Service Quotas Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) de la *Référence générale d'Amazon Web Services*
+ [AWS Systems Manager API Reference](https://docs.aws.amazon.com/systems-manager/latest/APIReference/)
**Topics**
+ [Configuration de Run Command](run-command-setting-up.md)
+ [Exécution de commandes sur des nœuds gérés](running-commands.md)
+ [Utilisation des codes de sortie dans les commandes](run-command-handle-exit-status.md)
+ [Comprendre les états des commandes](monitor-commands.md)
+ [Procédures Run Command](run-command-walkthroughs.md)
+ [Résolution des problèmes liés à Run Command de Systems Manager](troubleshooting-remote-commands.md)
# Configuration de Run Command
Avant de pouvoir gérer les nœuds à l'aide Run Command d'un outil AWS Systems Manager, configurez une politique Gestion des identités et des accès AWS (IAM) pour tout utilisateur qui exécutera des commandes. Si vous utilisez des clés de condition globales pour l’action `SendCommand` dans vos politiques IAM, vous devez inclure la clé de condition `aws:ViaAWSService` et définir la valeur booléenne sur `true`. Voici un exemple.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": [
"vpce-1234567890abcdef0"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
Vous devez également configurer vos nœuds pour Systems Manager. Pour de plus amples informations, veuillez consulter [Configuration de nœuds gérés pour AWS Systems Manager](systems-manager-setting-up-nodes.md).
Nous vous recommandons d'effectuer les tâches de configuration facultatives suivantes afin de minimiser le niveau de sécurité et la day-to-day gestion de vos nœuds gérés.
Surveillez les exécutions de commandes à l'aide d'Amazon EventBridge
Vous pouvez l'utiliser EventBridge pour enregistrer les modifications de l'état d'exécution des commandes. Vous pouvez créer une règle qui s'exécute à chaque changement de statut ou lorsqu'un ou plusieurs statuts spécifiques sont activés. Vous pouvez également spécifier Run Command comme action cible lorsqu'un EventBridge événement se produit. Pour de plus amples informations, veuillez consulter [Configuration EventBridge pour les événements de Systems Manager](monitoring-systems-manager-events.md).
Surveillez les exécutions de commandes à l'aide d'Amazon CloudWatch Logs
Vous pouvez configurer Run Command pour envoyer régulièrement toutes les sorties de commande et tous les journaux d'erreurs à un groupe de CloudWatch journaux Amazon. Vous pouvez surveiller ces journaux de sortie quasiment en temps réel, rechercher des phrases, valeurs ou modèles spécifiques, et créer des alarmes en fonction de la recherche. Pour de plus amples informations, veuillez consulter [Configuration d'Amazon CloudWatch Logs pour Run Command](sysman-rc-setting-up-cwlogs.md).
Restriction de l'accès Run Command à des nœuds gérés spécifiques
Vous pouvez limiter la capacité d'un utilisateur à exécuter des commandes sur des nœuds gérés en utilisant Gestion des identités et des accès AWS (IAM). Plus précisément, vous pouvez créer une politique IAM avec une condition selon laquelle l'utilisateur ne peut exécuter de commandes que sur les nœuds gérés présentant des balises spécifiques. Pour de plus amples informations, veuillez consulter [Restriction de l'accès Run Command en fonction des balises](#tag-based-access).
## Restriction de l'accès Run Command en fonction des balises
Cette section explique comment restreindre la capacité d'un utilisateur à exécuter des commandes sur des nœuds gérés en spécifiant une condition de balise dans une politique IAM. Les nœuds gérés incluent EC2 les instances Amazon et EC2 les non-nœuds d'un environnement [hybride et multicloud](operating-systems-and-machine-types.md#supported-machine-types) configurés pour Systems Manager. Bien que les informations ne soient pas présentées de manière explicite, vous pouvez également restreindre l'accès aux AWS IoT Greengrass principaux appareils gérés. Pour commencer, vous devez baliser vos appareils AWS IoT Greengrass . Pour plus d'informations, consultez [Baliser vos ressources AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) dans le *Guide du développeur AWS IoT Greengrass Version 2 *.
Vous pouvez restreindre l'exécution de commandes à des nœuds gérés spécifiques en créant une politique IAM qui comporte une condition selon laquelle l'utilisateur ne peut exécuter de commandes que sur les nœuds comportant des balises spécifiques. Dans l'exemple suivant, l'utilisateur est autorisé à utiliser Run Command (`Effect: Allow, Action: ssm:SendCommand`) en utilisant n'importe quel document SSM (`Resource: arn:aws:ssm:*:*:document/*`) sur n'importe quel nœud (`Resource: arn:aws:ec2:*:*:instance/*`) à condition que le nœud soit un Finance WebServer (`ssm:resourceTag/Finance: WebServer`). Si l'utilisateur envoie une commande à un nœud non balisé ou qui possède une balise autre que `Finance: WebServer`, les résultats d'exécution indiquent `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:*:*:document/*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ec2:*:*:instance/*"
],
"Condition":{
"StringLike":{
"ssm:resourceTag/Finance":[
"WebServers"
]
}
}
}
]
}
```
------
Vous pouvez créer des politiques IAM qui permettent à un utilisateur d'exécuter des commandes sur des nœuds gérés balisés à l'aide de plusieurs balises. La politique suivante permet à l'utilisateur d'exécuter des commandes sur des nœuds gérés dotés de deux balises. Si un utilisateur envoie une commande à un nœud non balisé à l'aide de ces deux balises, les résultats d'exécution indiquent `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
],
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Vous pouvez également créer des politiques IAM qui permettent à un utilisateur d'exécuter des commandes sur plusieurs groupes de nœuds gérés balisés. L'exemple de politique suivante permet à l'utilisateur d'exécuter des commandes sur un des deux groupes de nœuds balisés, ou les deux.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Pour plus d'informations sur la création de politiques IAM, consultez [Politiques gérées et politiques en ligne](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html) dans le *Guide de l'utilisateur IAM*. Pour plus d'informations sur le balisage des nœuds gérés, consultez [Tag Editor](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html) dans le *Guide de l'utilisateur Groupes de ressources AWS *.
# Exécution de commandes sur des nœuds gérés
Cette section comprend des informations sur le mode d'envoi de commandes depuis la console AWS Systems Manager vers des nœuds gérés. Cette section inclut également des informations sur l'annulation d'une commande.
Notez que si votre nœud est configuré avec l’option de montage `noexec` pour le répertoire var, Run Command ne pourra pas exécuter correctement les commandes.
**Important**
Lorsque vous envoyez une commande à l'aide de Run Command, n'incluez pas d'informations sensibles formatées en texte brut, comme des mots de passe, des données de configuration ou d'autres secrets. Toutes les activités de l'API Systems Manager sur votre compte sont enregistrées dans un compartiment S3 pour les AWS CloudTrail journaux. Cela signifie que tout utilisateur ayant accès à ce compartiment S3 peut consulter les valeurs en texte brut de ces secrets. Pour cette raison, nous vous recommandons de créer et d'utiliser des paramètres `SecureString` pour chiffrer les données sensibles que vous utilisez dans le cadre de vos opérations Systems Manager.
Pour de plus amples informations, veuillez consulter [Restriction de l'accès aux paramètres Parameter Store à l'aide des stratégies IAM](sysman-paramstore-access.md).
**Conservation de l'historique d'exécution**
L'historique de chaque commande est disponible pour une durée maximale de 30 jours. En outre, vous pouvez stocker une copie de tous les fichiers journaux dans Amazon Simple Storage Service ou disposer d’un journal de suivi d’audit de tous les appels d’API dans AWS CloudTrail.
**Informations connexes**
Pour plus d’informations sur l’envoi de commandes avec d’autres outils, consultez les rubriques suivantes :
+ [Procédure pas à pas : utilisez le AWS Tools for Windows PowerShell avec Run Command](walkthrough-powershell.md)ou les exemples présentés dans la [AWS Systems Manager section de la référence des Outils AWS pour PowerShell applets](https://docs.aws.amazon.com/powershell/latest/reference/items/AWS_Systems_Manager_cmdlets.html) de commande.
+ [Procédure pas à pas : utilisez le AWS CLI avec Run Command](walkthrough-cli.md) ou les exemples de la [Référence de la CLI SSM](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
**Topics**
+ [Exécution des commande à partir de la console](running-commands-console.md)
+ [Exécution de commandes à l'aide d'une version de document spécifique](run-command-version.md)
+ [Exécuter des commandes à grande échelle](send-commands-multiple.md)
+ [Annulation d'une commande](cancel-run-command.md)
# Exécution des commande à partir de la console
Vous pouvez utiliser Run Command un outil dans AWS Systems Manager, depuis le AWS Management Console pour configurer les nœuds gérés sans avoir à vous y connecter. Cette rubrique comprend un exemple qui montre comment [mettre à jour SSM Agent](run-command-tutorial-update-software.md#rc-console-agentexample) sur un nœud géré à l'aide de la fonctionnalité Run Command.
**Avant de commencer**
Avant d'envoyer une commande avec Run Command, vérifiez que vos nœuds gérés respectent la [configuration requise](systems-manager-setting-up-nodes.md) de Systems Manager.
**Pour envoyer une commande à l'aide de la fonctionnalité Run Command**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, sélectionnez **Run Command**.
1. Sélectionnez **Run Command (Exécuter la commande)**.
1. Dans la liste **Command document (Document de commande)**, sélectionnez un document Systems Manager.
1. Dans la section **Command parameters (Paramètres de la commande)**, indiquez des valeurs pour les paramètres requis.
1. Dans la section **Targets (Cibles)**, sélectionnez les nœuds gérés sur lesquels vous souhaitez exécuter cette opération en spécifiant des balises, en sélectionnant des instances ou des appareils de périphérie manuellement ou en spécifiant un groupe de ressources.
**Astuce**
Si, contrairement à vos attentes, un nœud géré ne figure pas dans la liste, consultez [Résolution des problèmes de disponibilité des nœuds gérés](fleet-manager-troubleshooting-managed-nodes.md) pour obtenir des conseils de dépannage.
1. Pour **Autres paramètres** :
+ Pour **Comment (Commentaire)**, saisissez des informations à propos de cette commande.
+ Pour **Délai (secondes)**, précisez le nombre de secondes durant lesquelles le système doit attendre avant de mettre en échec l'exécution de la commande globale.
1. Pour **Rate control (Contrôle de débit)** :
+ Dans **Concurrency (Simultanéité)**, spécifiez un nombre ou un pourcentage de nœuds gérés sur lesquels exécuter simultanément la commande.
**Note**
Si vous avez sélectionné des cibles en spécifiant des balises appliquées aux nœuds gérés ou en spécifiant AWS des groupes de ressources, et que vous n'êtes pas certain du nombre de nœuds gérés ciblés, limitez le nombre de cibles pouvant exécuter le document en même temps en spécifiant un pourcentage.
+ Dans **Error threshold (Seuil d'erreur)**, indiquez quand arrêter l'exécution de la commande sur les autres nœuds gérés après l'échec de celle-ci sur un certain nombre ou un certain pourcentage de nœuds. Si, par exemple, vous spécifiez trois erreurs, Systems Manager cesse d'envoyer la commande à la réception de la quatrième erreur. Les nœuds gérés sur lesquels la commande est toujours en cours de traitement peuvent également envoyer des erreurs.
1. (Facultatif) Choisissez une CloudWatch alarme à appliquer à votre commande de surveillance. Pour associer une CloudWatch alarme à votre commande, le principal IAM qui exécute la commande doit être autorisé à effectuer l'`iam:createServiceLinkedRole`action. Pour plus d'informations sur les CloudWatch alarmes, consultez la section [Utilisation des CloudWatch alarmes Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). Notez que l'activation de votre alarme empêche l'exécution des appels de commande en attente.
1. (Facultatif) Pour **Output options (Options de sortie)**, pour enregistrer la sortie de la commande dans un fichier, cochez la case **Write command output to an S3 bucket (Écrire la sortie de commande vers un compartiment S3)**. Saisissez les noms de compartiment et de préfixe (dossier) dans les zones.
**Note**
Les autorisations S3 qui permettent d'écrire les données dans un compartiment S3 sont celles du profil d'instance (pour les EC2 instances) ou du rôle de service IAM (machines activées de manière hybride) attribué à l'instance, et non celles de l'utilisateur IAM effectuant cette tâche. Pour plus d’informations, consultez les sections [Configurer des autorisations d’instance requises pour Systems Manager](setup-instance-permissions.md) et [Créer un rôle de service IAM pour un environnement hybride](hybrid-multicloud-service-role.md). En outre, si le compartiment S3 spécifié se trouve sur un autre Compte AWS, assurez-vous que le profil d'instance ou la fonction de service IAM associé au nœud géré dispose des autorisations nécessaires pour écrire dans ce compartiment.
1. Dans la section **SNS notifications (Notifications SNS)**, si vous souhaitez envoyer des notifications sur le statut d'exécution des commandes, cochez la case **Enable SNS notifications (Activer les notifications SNS)**.
Pour plus d'informations sur la configuration des notifications Amazon SNS pour Run Command, consultez [Surveillance des changements d'état du Systems Manager à l'aide des notifications Amazon SNS](monitoring-sns-notifications.md).
1. Cliquez sur **Exécuter**.
Pour plus d'informations sur l'annulation d'une commande, consultez [Annulation d'une commande](cancel-run-command.md).
## Réexécution des commandes
Systems Manager comprend deux options pour vous aider à réexécuter une commande à partir de la page **Run Command** (Exécuter la commande) de la console Systems Manager.
+ **Réexécuter** : ce bouton vous permet d'exécuter la même commande sans y apporter de modifications.
+ **Copier vers nouveau** : ce bouton copie les paramètres d'une commande dans une nouvelle commande et vous donne la possibilité de modifier ces paramètres avant de l'exécuter.
**Pour réexécuter une commande**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, sélectionnez **Run Command**.
1. Sélectionnez une commande à réexécuter. Vous pouvez réexécuter une commande immédiatement après l'avoir exécutée à partir de la page de détails de la commande. Vous pouvez également choisir une commande que vous avez précédemment exécutée dans l'onglet **Command history (Historique des commandes)**.
1. Sélectionnez **Réexécuter** pour exécuter la même commande sans modifications, ou sélectionnez **Copier vers nouveau** pour modifier les paramètres de la commande avant de l'exécuter.
# Exécution de commandes à l'aide d'une version de document spécifique
Vous pouvez utiliser le paramètre document-version pour spécifier la version d'un document AWS Systems Manager à utiliser lors de l'exécution de la commande. Vous pouvez spécifier l'une des options suivantes pour ce paramètre :
+ \$1DEFAULT
+ \$1LATEST
+ Version number
Appliquez la procédure suivante pour exécuter une commande à l'aide du paramètre document-version.
------
#### [ Linux ]
**Pour exécuter des commandes AWS CLI à l'aide du**
1. Installez et configurez le AWS Command Line Interface (AWS CLI), si ce n'est pas déjà fait.
Pour de plus amples informations, consultez [Installation ou mise à jour de la version la plus récente de l' AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Répertorier tous les documents disponibles
Cette commande répertorie tous les documents disponibles pour votre compte en fonction des autorisations Gestion des identités et des accès AWS (IAM).
```
aws ssm list-documents
```
1. Utilisez la commande suivante pour afficher les différentes versions d'un document. Remplacez *document name* par vos propres informations.
```
aws ssm list-document-versions \
--name "document name"
```
1. Exécutez la commande suivante pour exécuter une commande qui utilise une version de document SSM. Remplacez chaque *example resource placeholder* par vos propres informations.
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--parameters commands="echo Hello" \
--instance-ids instance-ID \
--document-version '$LATEST'
```
------
#### [ Windows ]
**Pour exécuter des commandes à l'aide AWS CLI des machines Windows locales**
1. Installez et configurez le AWS Command Line Interface (AWS CLI), si ce n'est pas déjà fait.
Pour de plus amples informations, consultez [Installation ou mise à jour de la version la plus récente de l' AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Répertorier tous les documents disponibles
Cette commande répertorie tous les documents disponibles pour votre compte en fonction des autorisations Gestion des identités et des accès AWS (IAM).
```
aws ssm list-documents
```
1. Utilisez la commande suivante pour afficher les différentes versions d'un document. Remplacez *document name* par vos propres informations.
```
aws ssm list-document-versions ^
--name "document name"
```
1. Exécutez la commande suivante pour exécuter une commande qui utilise une version de document SSM. Remplacez chaque *example resource placeholder* par vos propres informations.
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--parameters commands="echo Hello" ^
--instance-ids instance-ID ^
--document-version "$LATEST"
```
------
#### [ PowerShell ]
**Pour exécuter des commandes à l'aide des outils pour PowerShell**
1. Installez et configurez les Outils AWS pour PowerShell (Outils pour Windows PowerShell), si ce n'est pas déjà fait.
Pour plus d'informations, consultez [Installation d' Outils AWS pour PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Répertorier tous les documents disponibles
Cette commande répertorie tous les documents disponibles pour votre compte en fonction des autorisations Gestion des identités et des accès AWS (IAM).
```
Get-SSMDocumentList
```
1. Utilisez la commande suivante pour afficher les différentes versions d'un document. Remplacez *document name* par vos propres informations.
```
Get-SSMDocumentVersionList `
-Name "document name"
```
1. Exécutez la commande suivante pour exécuter une commande qui utilise une version de document SSM. Remplacez chaque *example resource placeholder* par vos propres informations.
```
Send-SSMCommand `
-DocumentName "AWS-RunShellScript" `
-Parameter @{commands = "echo helloWorld"} `
-InstanceIds "instance-ID" `
-DocumentVersion $LATEST
```
------
# Exécuter des commandes à grande échelle
Vous pouvez utiliser Run Command un outil dans AWS Systems Manager, pour exécuter des commandes sur un parc de nœuds gérés en utilisant le`targets`. Le paramètre `targets` accepte une combinaison `Key,Value` basée sur les balises que vous avez spécifiées pour vos nœuds gérés. Lorsque vous exécutez la commande, le système recherche les fichiers et tente d'exécuter la commande sur tous les nœuds gérés qui correspondent aux balises spécifiées. Pour plus d'informations sur le balisage des instances gérées, consultez la section [Marquage de vos AWS ressources dans le Guide de l'utilisateur des AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tag-editor.html) *ressources de balisage*. Pour plus d'informations sur le balisage de vos appareils IoT gérés, consultez la section [Marquer vos AWS IoT Greengrass Version 2 ressources](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) dans le *guide du AWS IoT Greengrass Version 2 développeur*.
Vous pouvez également utiliser le `targets` paramètre pour cibler une liste de nœuds gérés spécifiques IDs, comme décrit dans la section suivante.
Pour contrôler l'exécution d'une commande sur des centaines de milliers de nœuds gérés, la fonctionnalité Run Command inclut également des paramètres pour limiter le nombre de nœuds gérés pouvant traiter simultanément une demande et le nombre d'erreurs pouvant être émises par une commande avant que la commande ne prenne fin.
**Topics**
+ [Ciblage de plusieurs nœuds gérés](#send-commands-targeting)
+ [Utilisation des contrôles de taux](#send-commands-rate)
## Ciblage de plusieurs nœuds gérés
Vous pouvez exécuter une commande et cibler les nœuds gérés en spécifiant des balises, AWS des noms de groupes de ressources ou des nœuds gérés IDs.
Les exemples suivants montrent le format de commande lors Run Command de l'utilisation de from the AWS Command Line Interface (AWS CLI ). Remplacez chaque *example resource placeholder* par vos propres informations. Les exemples de commandes de cette section sont tronqués à l'aide de `[...]`.
**Exemple 1 : ciblage de balises**
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:tag-name,Values=tag-value \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:tag-name,Values=tag-value ^
[...]
```
------
**Exemple 2 : Cibler un groupe de AWS ressources par son nom**
Vous pouvez spécifier au maximum un nom de groupe de ressources par commande. Lorsque vous créez un groupe de ressources, nous vous recommandons d'inclure `AWS::SSM:ManagedInstance` et `AWS::EC2::Instance` comme types de ressource dans vos critères de regroupement.
**Note**
Pour envoyer des commandes qui ciblent un groupe de ressources, vous devez avoir obtenu des autorisations Gestion des identités et des accès AWS (IAM) pour répertorier ou afficher les ressources appartenant à ce groupe. Pour plus d'informations, consultez [Configuration d'autorisations](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) dans le *Guide de l'utilisateur Groupes de ressources AWS *.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:Name,Values=resource-group-name \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:Name,Values=resource-group-name ^
[...]
```
------
**Exemple 3 : Cibler un groupe de AWS ressources par type de ressource**
Vous pouvez spécifier au maximum cinq types de groupe de ressources par commande. Lorsque vous créez un groupe de ressources, nous vous recommandons d'inclure `AWS::SSM:ManagedInstance` et `AWS::EC2::Instance` comme types de ressource dans vos critères de regroupement.
**Note**
Pour pouvoir envoyer des commandes qui ciblent un groupe de ressources, vous devez avoir reçu des autorisations IAM pour répertorier, ou afficher, les ressources qui appartiennent à ce groupe. Pour plus d'informations, consultez [Configuration d'autorisations](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) dans le *Guide de l'utilisateur Groupes de ressources AWS *.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 ^
[...]
```
------
**Exemple 4 : instance de ciblage IDs**
Les exemples suivants montrent comment cibler les nœuds gérés à l'aide de la clé `instanceids` avec le paramètre `targets`. Vous pouvez utiliser cette clé pour cibler les AWS IoT Greengrass principaux appareils gérés, car un mi- est attribué à chaque appareil*ID\$1number*. Vous pouvez voir un appareil IDs dansFleet Manager, un outil dans AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 ^
[...]
```
------
Si vous avez balisé des nœuds gérés pour différents environnements à l'aide d'une `Key` nommée `Environment` et des `Values` de `Development`, `Test`, `Pre-production` et `Production`, vous pourrez donc envoyer une commande à tous les nœuds gérés dans *l'un* de ces environnements à l'aide du paramètre `targets` avec la syntaxe suivante.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
------
Vous pouvez cibler des nœuds gérés supplémentaires dans d'autres environnements en ajoutant un élément à la liste `Values`. Séparez les éléments avec des virgules.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development,Test,Pre-production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development,Test,Pre-production ^
[...]
```
------
**Variation** : affiner vos cibles à l'aide de plusieurs critères `Key`
Vous pouvez affiner le nombre de cibles pour votre commande en incluant plusieurs critères `Key`. Si vous incluez plusieurs critères `Key`, le système cible les nœuds gérés qui répondent à *tous* les critères. La commande suivante cible tous les nœuds gérés balisés pour le service financier *et* balisés pour le rôle de serveur de base de données.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database ^
[...]
```
------
**Variation** : utilisation de plusieurs critères `Key` et `Value`
En reprenant l'exemple précédent, vous pouvez cibler plusieurs services et plusieurs rôles de serveur en incluant des éléments supplémentaires dans les critères `Values`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
**Variation** : ciblage de nœuds gérés balisés à l'aide de plusieurs critères `Values`
Si vous avez balisé des nœuds gérés pour différents environnements à l'aide d'une `Key` nommée `Department` et `Values` de `Sales` et `Finance`, vous pouvez envoyer une commande à tous les nœuds gérés dans l'un de ces environnements à l'aide du paramètre `targets` avec la syntaxe suivante.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Sales,Finance \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Sales,Finance ^
[...]
```
------
Vous pouvez spécifier un maximum de cinq clés et cinq valeurs pour chaque clé.
Si une clé de balise (le nom de la balise) ou une valeur de balise inclut des espaces, placez la clé ou la valeur de balise entre guillemets, comme illustré dans les exemples suivants.
**Exemple** : espaces dans la balise `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:OS,Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:OS,Values="Windows Server 2016" ^
[...]
```
------
**Exemple** : espaces dans la clé `tag` et dans `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key="tag:Operating System",Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key="tag:Operating System",Values="Windows Server 2016" ^
[...]
```
------
**Exemple** : espaces dans un élément d'une liste de `Values`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" ^
[...]
```
------
## Utilisation des contrôles de taux
Vous pouvez contrôler le taux d'envoi des commandes aux nœuds gérés d'un groupe à l'aide des* contrôles de concurrence* et des *contrôles d'erreur*.
**Topics**
+ [Utilisation de contrôles d'accès simultanés](#send-commands-velocity)
+ [Utilisation de contrôles d'erreur](#send-commands-maxerrors)
### Utilisation de contrôles d'accès simultanés
Le contrôle de nombre de nœuds gérés exécutant une commande simultanément est possible à l'aide du `max-concurrency` paramètre des options ( **Simultanéité** de la page **Exécuter une commande ** ). Vous pouvez spécifier un nombre absolu de nœuds géré, par exemple, **10**, ou un pourcentage de l'ensemble de la cible, par exemple, **10%**. Le système de mise en file d'attente transmet la commande à un seul nœud et attend jusqu'à ce que le système reconnaisse l'appel initial avant d'envoyer la commande à deux autres nœuds. Le système envoie de façon exponentielle des commandes à plusieurs nœuds jusqu'à ce que la valeur `max-concurrency` soit atteinte. La valeur par défaut de `max-concurrency` est 50. Les exemples suivants vous montrent comment spécifier des valeurs pour le paramètre `max-concurrency` :
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10 \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10% \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10 ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10% ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
### Utilisation de contrôles d'erreur
Vous pouvez également contrôler l'exécution d'une commande sur des centaines ou des milliers de nœuds gérés en définissant une limite d'erreurs à l'aide des paramètres `max-errors` (champ **Error threshold (Seuil d'erreur)** de la page **Exécuter une commande**). Le paramètre spécifie le nombre d'erreurs autorisées avant que le système cesse d'envoyer la commande d'autres nœuds gérés. Vous pouvez spécifier un nombre absolu d'erreurs (par exemple, **10**) ou un pourcentage de l'ensemble de la cible (par exemple, **10%**). Si, par exemple, vous spécifiez **3**, le système cesse d'envoyer la commande à la réception de la quatrième erreur. Si vous spécifiez **0**, le système cesse d'envoyer la commande à des nœuds gérés supplémentaires une fois que le premier résultat d'erreur est renvoyé. Si vous envoyez une commande à 50 nœuds gérés et que vous définissez `max-errors` avec la valeur **10%**, le système arrête d'envoyer la commande aux nœuds gérés supplémentaires à la réception de la sixième erreur.
Les appels qui exécutent déjà une commande lorsque `max-errors` est atteint sont autorisés à se terminer, mais certains de ces appels pourraient également échouer. Si vous devez vous assurer que le nombre d'appels ayant échoué ne dépassera pas la valeur de `max-errors`, définissez `max-concurrency` sur **1** pour que les appels soit exécutés un par un. La valeur par défaut pour max-errors est 0. Les exemples suivants vous montrent comment spécifier des valeurs pour le paramètre `max-errors` :
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-errors 10 \
--targets Key=tag:Database,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-errors 10% \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 1 \
--max-errors 1 \
--targets Key=tag:Environment,Values=Production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10 ^
--targets Key=tag:Database,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10% ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 1 ^
--max-errors 1 ^
--targets Key=tag:Environment,Values=Production ^
[...]
```
------
# Annulation d'une commande
Vous pouvez tenter d'annuler une commande tant que le service est associé à l'état Pending (En attente) ou Executing (En cours d'exécution). Toutefois, même si une commande est encore associée à l'un de ces états, nous ne pouvons pas garantir qu'elle sera annulée et que le processus sous-jacent sera arrêté.
**Pour annuler une commande via la console**
1. Ouvrez la console AWS Systems Manager à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, sélectionnez **Run Command**.
1. Sélectionnez l'appel de commande que vous souhaitez annuler.
1. Sélectionnez **Annuler la commande**.
**Pour annuler une commande à l'aide de l'AWS CLI**
Exécutez la commande suivante. Remplacez chaque *example resource placeholder* (espace réservé pour les ressources) avec vos propres informations.
------
#### [ Linux & macOS ]
```
aws ssm cancel-command \
--command-id "command-ID" \
--instance-ids "instance-ID"
```
------
#### [ Windows ]
```
aws ssm cancel-command ^
--command-id "command-ID" ^
--instance-ids "instance-ID"
```
------
Pour de plus amples informations sur le statut d'une commande annulée, veuillez consulter [Comprendre les états des commandes](monitor-commands.md).
# Utilisation des codes de sortie dans les commandes
Dans certains cas, vous devrez peut-être gérer la façon dont vos commandes sont gérées à l'aide de codes de sortie.
## Spécifier les codes de sortie dans les commandes
À l’aide de Run Command, un outil d’AWS Systems Manager, vous pouvez spécifier des codes de sortie pour déterminer la manière dont les commandes sont gérées. Par défaut, le code de sortie de la dernière commande exécutée dans un script est signalé comme le code de sortie pour l'ensemble du script. Par exemple, prenons un script qui contient trois commandes. La première échoue, mais les suivantes sont réalisées avec succès. Compte tenu du succès de la commande finale, l'état de l'exécution est signalé comme `succeeded`.
**Scripts shell**
Pour faire échouer la totalité du script lors du premier échec de la commande, vous pouvez inclure une instruction conditionnelle shell pour quitter le script si une commande précédant la dernière échoue. Utilisez pas l'approche suivante.
```
if [ $? != 0 ]
then
exit
fi
```
Dans l'exemple suivant, la totalité du script échoue si la première commande échoue.
```
cd /test
if [ $? != 0 ]
then
echo "Failed"
exit 1
fi
date
```
**Scripts PowerShell**
PowerShell exige que vous appeliez explicitement `exit` dans vos scripts pour que Run Command capture correctement le code de sortie.
```
if ($?) {}
else {exit }
exit
```
Voici un exemple :
```
cd C:\
if ($?) {echo "Success"}
else {exit 1}
date
```
# Gestion des redémarrages lors de l'exécution de commandes
Si vous utilisez Run Command un outil pour exécuter des AWS Systems Manager scripts qui redémarrent des nœuds gérés, nous vous recommandons de spécifier un code de sortie dans votre script. Si vous essayez de redémarrer un nœud à partir d'un script à l'aide d'un autre mécanisme, l'état d'exécution des scripts peut ne pas être mis à jour correctement, même si le redémarrage est la dernière étape dans votre script. Pour les nœuds gérés Windows, spécifiez `exit 3010` dans votre script. Pour les nœuds gérés Linux et macOS, spécifiez `exit 194`. Le code de sortie indique à AWS Systems Manager l'agent (SSM Agent) de redémarrer le nœud géré, puis de redémarrer le script une fois le redémarrage terminé. Avant de commencer le redémarrage, SSM Agent informe le service Systems Manager dans le cloud que les communications seront interrompues pendant le redémarrage du serveur.
**Note**
Le script de redémarrage ne peut pas faire partie d'un plugin `aws:runDocument`. Si un document contient le script de redémarrage et qu'un autre document tente d'exécuter ce document via le plugin `aws:runDocument`, SSM Agent renvoie une erreur.
**Création de scripts idempotents**
Lorsque vous développez des scripts qui redémarrent les nœuds gérés, rendez les scripts idempotents de sorte que l'exécution du script continue là où elle s'était arrêtée après le redémarrage. Les scripts idempotents gèrent l'état et valident si l'action a été exécutée ou non. Cela permet d'éviter qu'une étape soit exécutée plusieurs fois alors qu'elle est destinée à être exécutée une seule fois.
Voici un exemple de script idempotent qui redémarre le nœud géré plusieurs fois.
```
$name = Get current computer name
If ($name –ne $desiredName)
{
Rename computer
exit 3010
}
$domain = Get current domain name
If ($domain –ne $desiredDomain)
{
Join domain
exit 3010
}
If (desired package not installed)
{
Install package
exit 3010
}
```
**Exemples**
Les échantillons de script suivants utilisent des codes de sortie pour redémarrer les nœuds gérés. L'exemple sur Linux installe les mises à jour de package sur Amazon Linux, puis redémarre le nœud. L’exemple Windows Server installe l’application Telnet-Client au niveau du nœud, puis le redémarre.
------
#### [ Amazon Linux 2 ]
```
#!/bin/bash
yum -y update
needs-restarting -r
if [ $? -eq 1 ]
then
exit 194
else
exit 0
fi
```
------
#### [ Windows ]
```
$telnet = Get-WindowsFeature -Name Telnet-Client
if (-not $telnet.Installed)
{
# Install Telnet and then send a reboot request to SSM Agent.
Install-WindowsFeature -Name "Telnet-Client"
exit 3010
}
```
------
# Comprendre les états des commandes
Run Command, un outil dans AWS Systems Manager, fournit des informations d'état détaillées sur les différents états rencontrés par une commande pendant le traitement et pour chaque nœud géré qui a traité la commande. Vous pouvez surveiller les statuts de commande à l'aide des méthodes suivantes :
+ Cliquez sur l'icône **Refresh** (Actualiser) dans l'onglet **Commands** (Commandes) de l'interface de la console Run Command.
+ Appelez [les commandes de liste](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-commands.html) ou [list-command-invocations](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-command-invocations.html)utilisez le AWS Command Line Interface ()AWS CLI. Ou appelez [Get- SSMCommand](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommand.html) ou [Get- SSMCommand Invocation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommandInvocation.html) en utilisant AWS Tools for Windows PowerShell.
+ Configurez Amazon EventBridge pour qu'il réponde à un état ou à un changement de statut.
+ Configurez Amazon Simple Notification Service (Amazon SNS) de sorte à envoyer des notifications pour tous les changements de statut ou pour des statuts spécifiques, comme `Failed` ou `TimedOut`.
## État Run Command
La fonctionnalité Run Command génère des rapports avec des détails de statut pour trois domaines : plug-ins, appels et statut de commande général. Un *plug-in* est un bloc d'exécution de code qui est défini dans le document SSM de votre commande. Pour de plus amples informations sur les plug-ins, consultez [Référence de plug-in de document Command](documents-command-ssm-plugin-reference.md).
Lorsque vous envoyez une commande à plusieurs nœuds gérés en même temps, chaque copie de la commande qui cible chaque nœud correspond à une *invocation de commande*. Par exemple, si vous utilisez le document `AWS-RunShellScript` et que vous envoyez une commande `ifconfig` à 20 instances Linux, cette commande aura 20 appels. Chaque invocation de commande signale le statut individuellement. Les plug-ins d'une invocation de commande donné communiquent aussi le statut individuellement.
Enfin, la fonctionnalité Run Command inclut un statut de commande regroupé pour tous les plug-ins et les appels. Le statut de commande regroupé peut être différent du statut signalé par plug-ins ou appels, comme indiqué dans les tableaux suivants.
**Note**
Si vous exécutez des commandes sur un grand nombre de nœuds gérés à l'aide des paramètres `max-concurrency` ou `max-errors`, le statut de commande reflète les limites imposées par ces paramètres, comme décrit dans les tableaux suivants. Pour obtenir plus d'informations sur ces paramètres, consultez [Exécuter des commandes à grande échelle](send-commands-multiple.md).
**Statut détaillé pour des plug-ins et des appels de commande**
| Statut | Détails |
| --- | --- |
| En attente | La commande n'a pas encore été envoyée au nœud géré ou n'a pas été reçue par l'SSM Agent. Si la commande n'est pas reçue par l'agent avant le délai prévu, qui est égal à la somme du paramètre Timeout (seconds) (Délai d'expiration (secondes)) et le paramètre Execution timeout (Délai d'exécution), le statut passe à Delivery Timed Out. |
| InProgress | Systems Manager tente d'envoyer la commande au nœud géré, ou la commande a été reçue par l'SSM Agent et a commencé à s'exécuter sur l'instance. Selon le résultat de tous les plug-ins de commande, le statut passe à Success, Failed, Delivery Timed Out ou Execution Timed Out. Exception : si l'agent n'est pas en cours d'exécution ou n'est pas disponible sur le nœud, le statut de la commande reste sur In Progress jusqu'à ce que l'agent soit à nouveau disponible ou que la limite du délai d'exécution soit atteinte. Le statut est ensuite remplacé par un état de mise hors service. |
| Delayed (Retardé) | Le système tente d'envoyer la commande au nœud géré, mais n'a pas réussi. Le système réessaie. |
| Réussite | Ce statut est renvoyé dans diverses conditions. Ce statut ne signifie pas que la commande a été effectuée sur le nœud. Par exemple, la commande peut être reçue par SSM Agent le nœud géré et renvoyer un code de sortie égal à zéro si vous PowerShell ExecutionPolicy empêchez l'exécution de la commande. Il s’agit d’un statut de terminal. Les conditions qui font qu’une commande renvoie un statut Success sont les suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/systems-manager/latest/userguide/monitor-commands.html) Les mêmes conditions s’appliquent lorsque vous ciblez des groupes de ressources. Pour résoudre les erreurs ou obtenir plus d'informations sur l'exécution des commandes, envoyez une commande qui gère les erreurs ou les exceptions en retournant les codes de sortie appropriés (codes de sortie autre que zéro pour un échec de la commande). |
| DeliveryTimedOut | La commande n'a pas été fournie au nœud géré avant l'expiration du délai total. Les dépassements de délai totaux ne sont pas comptabilisés dans la limite max-errors de la commande parent, mais ils permettent de savoir si l'état de la commande parent est Success, Incomplete ou Delivery Timed Out. Il s’agit d’un statut de terminal. |
| ExecutionTimedOut | L'automatisation de la commande a démarré sur le nœud géré, mais l'exécution de la commande ne s'est pas terminée avant l'expiration du délai d'exécution. Les expirations de délais d'exécution sont considérés comme des échecs, ce qui enverra une réponse nulle et Systems Manager quittera sortira de la tentative d'exécution de l'automatisation des commandes et signalera échec comme état. |
| Échec | La commande n'a pas réussi sur le nœud géré. Pour un plugin, cela signifie que le code de résultat n'était pas zéro. Pour une invocation de commande, cela signifie que le code de résultat pour un ou plusieurs plugins n'était pas zéro. Les échecs d'invocation sont comptabilisés dans la limite max-errors de la commande parent. Il s’agit d’un statut de terminal. |
| Annulée | La commande a été annulée avant de se terminer. Il s'agit d'un état final. |
| Undeliverable (Non livrable) | La commande ne peut pas être délivrée au nœud géré. Le nœud peut ne pas exister ou ne peut pas répondre. Les appels ne pouvant pas être remis ne sont pas comptabilisés dans la limite max-errors de la commande parent, mais ils permettent de déterminer si le statut de la commande parent est Success ou Incomplete. Par exemple, si tous les appels d'une commande ont le statut Undeliverable, le statut de la commande renvoyé est Failed. Toutefois, si une commande comporte 5 appels, dont 4 renvoient le statut Undeliverable et 1 renvoie le statut Success, le statut de la commande parent est Success. Il s'agit d'un état final. |
| Terminated (Résilié) | La commande parent atteint sa limite max-errors et les appels de commande suivants ont été annulés par le système. Il s’agit d’un statut de terminal. |
| InvalidPlatform | La commande a été envoyée à un nœud géré qui ne correspondait pas aux plateformes requises spécifiées par le document choisi. Invalid Platform ne compte pas dans la limite maximale d'erreurs de la commande parent, mais permet de savoir si le statut de la commande parent est Success (Réussite) ou Failed (Échec). Par exemple, si tous les appels d'une commande ont le statut Invalid Platform, le statut de la commande renvoyé est Failed. Toutefois, si une commande comporte 5 appels, dont 4 renvoient le statut Invalid Platform et 1 renvoie le statut Success, le statut de la commande parent est Success. Il s’agit d’un statut de terminal. |
| AccessDenied | L'utilisateur ou le rôle Gestion des identités et des accès AWS (IAM) à l'origine de la commande n'a pas accès au nœud géré ciblé. Access Deniedn'est pas prise en compte dans la max-errors limite de la commande parent, mais elle contribue à déterminer si le statut de la commande parent est Success ouFailed. Par exemple, si tous les appels d'une commande ont le statut Access Denied, le statut de la commande renvoyé est Failed. Toutefois, si une commande comporte 5 appels, dont 4 renvoient le statut Access Denied et 1 renvoie le statut Success, le statut de la commande parent est Success. Il s'agit d'un état final. |
**Statut détaillé d'une commande**
| Statut | Détails |
| --- | --- |
| En attente | La commande n'a pas encore été reçue par un agent sur un nœud géré. |
| InProgress | La commande a été envoyée au moins à un nœud géré, mais n'a pas atteint un état final sur tous les nœuds. |
| Delayed (Retardé) | Le système tente d'envoyer la commande au nœud, mais n'a pas réussi. Le système réessaie. |
| Réussite | La commande a été reçue par SSM Agent sur l'ensemble des nœuds gérés spécifiés ou ciblés et a retourné un code de sortie de zéro. L'ensemble des invocations de commande a atteint un état de mise hors service, et la valeur de max-errors n'a pas été atteinte. Ce statut ne signifie pas que la commande a été effectuée avec succès sur l'ensemble des nœuds gérés spécifiés ou ciblés. Il s'agit d'un état final. Pour résoudre les erreurs ou obtenir plus d'informations sur l'exécution des commandes, envoyez une commande qui gère les erreurs ou les exceptions en retournant les codes de sortie appropriés (codes de sortie autre que zéro pour un échec de la commande). |
| DeliveryTimedOut | La commande n'a pas été fournie au nœud géré avant l'expiration du délai total. La valeur de max-errors ou d'autres appels de commande affichent le statut Delivery Timed Out. Il s'agit d'un état final. |
| Échec | La commande n'a pas réussi sur le nœud géré. La valeur de `max-errors` ou d'autres appels de commande affichent le statut `Failed`. Il s'agit d'un état final. |
| Incomplete (Incomplet) | La commande a été tentée sur tous les nœuds gérés et un ou plusieurs appels n'ont pas la valeur Success. Toutefois, le nombre d'appels en échec n'est pas suffisant pour que le statut soit Failed. Il s’agit d’un statut de terminal. |
| Annulée | La commande a été annulée avant de se terminer. Il s’agit d’un statut de terminal. |
| RateExceeded | Le nombre de nœuds gérés ciblée par la commande a dépassé la quota du compte pour les appels en attente. Le système a annulé la commande avant de l'exécuter sur un nœud. Il s’agit d’un statut de terminal. |
| AccessDenied | L'utilisateur ou le rôle qui initie la commande n'a pas accès au groupe de ressources ciblé. AccessDenied n'est pas pris en compte dans la limite max-errors de la commande parent, mais contribue à déterminer si le statut de la commande parent est Success ou Failed. (Par exemple, si tous les appels d'une commande ont le statut AccessDenied, alors le statut de la commande retourné est Failed. Toutefois, si une commande comporte 5 appels, dont 4 renvoient le statut AccessDenied et 1 renvoie le statut Success, le statut de la commande parent est Success.) Il s'agit d'un état final. |
| No Instances In Tag (Aucune instance dans la balise) | La valeur ou le groupe de ressources de la paire de clés de balise ciblés par la commande ne correspondent à aucun nœud géré. Il s'agit d'un état final. |
## Présentation des valeurs de délai des commandes
Systems Manager applique les valeurs de délai suivantes lors de l'exécution des commandes.
**Total Timeout (Délai total)**
Dans la console Systems Manager, vous spécifiez la valeur du délai d'expiration dans le champ **Timeout (seconds) (Délai d'expiration (secondes))**. Une fois qu'une commande est envoyée, Run Command vérifie si la commande a expiré ou non. Si une commande atteint la limite d'expiration de la commande (délai total), son statut devient `DeliveryTimedOut` pour tous les appels ayant le statut `InProgress`, `Pending` ou `Delayed`.
![\[Champ Timeout (seconds) (Délai d'expiration [secondes]) dans la console Systems Manager\]](http://docs.aws.amazon.com/fr_fr/systems-manager/latest/userguide/images/run-command-delivery-time-out-time-out-seconds.png)
Sur un plan plus technique, le délai d'expiration total (**Timeout (seconds) (Délai d'expiration (secondes))**) est une combinaison de deux valeurs de délai d'expiration, comme indiqué ici :
`Total timeout = "Timeout(seconds)" from the console + "timeoutSeconds": "{{ executionTimeout }}" from your SSM document`
Par exemple, la valeur par défaut de **Timeout (seconds) (Délai d'expiration (secondes))** dans la console Systems Manager est de 600 secondes. Si vous exécutez une commande en utilisant le document SSM `AWS-RunShellScript`, la valeur par défaut de **« timeoutSeconds » : « \$1\$1executionTimeout\$1\$1 »** est de 3600 secondes, comme indiqué dans l'exemple de document suivant :
```
"executionTimeout": {
"type": "String",
"default": "3600",
"runtimeConfig": {
"aws:runShellScript": {
"properties": [
{
"timeoutSeconds": "{{ executionTimeout }}"
```
Cela signifie que la commande s'exécute pendant 4 200 secondes (70 minutes) avant que le système ne définisse l'état de la commande sur `DeliveryTimedOut`.
**Execution Timeout (Délai d'exécution)**
Dans la console Systems Manager, vous spécifiez la valeur du délai d'exécution dans le champ **Execution Timeout (Délai d'exécution)** s'il est disponible. Les documents SSM ne nécessitent pas tous que vous spécifiiez un délai d'exécution. Le champ **Execution Timeout** (Délai d'exécution) n'est affiché que lorsqu'un paramètre d'entrée correspondant a été défini dans le document SSM. Si un délai est spécifié, la commande doit être exécutée dans ce délai.
**Note**
Run Command s'appuie sur la réponse terminale du document SSM Agent pour déterminer si la commande a été remise ou non à l'agent. SSM Agent doit envoyer un signal `ExecutionTimedOut` pour qu'une invocation ou une commande soient marquées comme `ExecutionTimedOut`.
![\[Champ Execution Timeout (Délai d'exécution) de la console Systems Manager\]](http://docs.aws.amazon.com/fr_fr/systems-manager/latest/userguide/images/run-command-execution-timeout-console.png)
**Default Execution Timeout (Délai d'exécution par défaut)**
Si un document SSM ne nécessite pas que vous spécifiiez explicitement une valeur de délai d'exécution, Systems Manager applique le délai d'exécution par défaut codé en dur.
**Signalement des délais d'expiration par Systems Manager**
Si Systems Manager reçoit une réponse `execution timeout` de l'SSM Agent sur une cible, Systems Manager marque l'invocation de commande comme `executionTimeout`.
Si Run Command ne reçoit pas de réponse terminale de document en provenance de l'SSM Agent, l'invocation de la commande est marquée comme `deliveryTimeout`.
Afin de déterminer le statut du délai sur une cible, l'SSM Agent combine tous les paramètres et le contenu du document SSM pour calculer `executionTimeout`. Lorsque l'SSM Agent détermine que le délai d'exécution d'une commande a expiré, il envoie `executionTimeout` au service.
La valeur par défaut pour **Timeout (seconds) (Délai d'expiration (secondes))** est de 3 600 secondes. La valeur par défaut pour **Execution timeout (Délai d'exécution)** est également de 3 600 secondes. Par conséquent, le délai d'attente total par défaut pour une commande est de 7 200 secondes.
**Note**
L'SSM Agent traite `executionTimeout` différemment selon le type de document SSM et la version du document.
# Procédures Run Command
Les procédures de cette section vous montrent comment exécuter des commandes avec Run Command, un outil d’AWS Systems Manager, ou AWS Command Line Interface (AWS CLI)/AWS Tools for Windows PowerShell.
**Topics**
+ [Mise à jour du logiciel à l'aide de Run Command](run-command-tutorial-update-software.md)
+ [Procédure pas à pas : utilisez le AWS CLI avec Run Command](walkthrough-cli.md)
+ [Procédure pas à pas : utilisez le AWS Tools for Windows PowerShell avec Run Command](walkthrough-powershell.md)
Vous pouvez également consulter des exemples de commandes dans les références suivantes.
+ [Référence de AWS CLI Systems Manager](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
+ [AWS Tools for Windows PowerShell - AWS Systems Manager](https://docs.aws.amazon.com/powershell/latest/reference/items/SimpleSystemsManagement_cmdlets.html)
# Mise à jour du logiciel à l'aide de Run Command
Les procédures suivantes décrivent comment mettre à jour le logiciel sur vos nœuds gérés.
## Mise à jour de SSM Agent à l'aide de Run Command
La procédure suivante décrit comment mettre à jour l'SSM Agent en cours d'exécution sur vos nœuds gérés. Vous pouvez mettre à jour à l'aide de la dernière version de l'SSM Agent ou d'une version plus ancienne. Lorsque vous exécutez la commande, le système télécharge la version depuis AWS, l'installe, puis désinstalle la version qui existait avant l'exécution de la commande. Si une erreur se produit au cours de ce processus, le système revient à la version du serveur avant l'exécution de la commande et le statut de cette dernière indique qu'elle a échoué.
**Note**
Si une instance exécute macOS version 13.0 (Ventura) ou ultérieure, elle doit disposer de l’SSM Agent version 3.1.941.0 ou supérieure pour exécuter le document AWS-UpdateSSMAgent. Si l'instance exécute une version de l'SSM Agent publiée avant la version 3.1.941.0, vous pouvez mettre à jour votre SSM Agent pour exécuter le document AWS-UpdateSSMAgent en exécutant les commandes `brew update` et `brew upgrade amazon-ssm-agent`.
Pour recevoir des notifications concernant les mises à jour de SSM Agent, inscrivez‑vous sur la page [SSM Agent Release Notes](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) du site Web de GitHub.
**Pour mettre à jour l'SSM Agent en utilisant Run Command**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, sélectionnez **Run Command**.
1. Sélectionnez **Run Command (Exécuter la commande)**.
1. In the **Command document (Document de commande)**, sélectionnez **`AWS-UpdateSSMAgent`**.
1. Dans la section **Paramètres de la commande**, indiquez des valeurs pour les paramètres suivants, si vous le souhaitez :
1. (Facultatif) Pour **Version**, saisissez la version de l'SSM Agent à installer. Vous pouvez installer des [versions plus anciennes](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) de l'agent. Si vous ne spécifiez pas de version, le service installe la dernière version.
1. (Facultatif) Pour **Allow Downgrade (Autoriser le retour à la version précédente)**, sélectionnez **true** pour installer une version antérieure de l'SSM Agent. Si vous sélectionnez cette option, spécifiez le numéro de version [antérieure](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md). Sélectionnez **false** pour installer uniquement la dernière version du service.
1. Dans la section **Targets (Cibles)**, sélectionnez les nœuds gérés sur lesquels vous souhaitez exécuter cette opération en spécifiant des balises, en sélectionnant des instances ou des appareils de périphérie manuellement ou en spécifiant un groupe de ressources.
**Astuce**
Si, contrairement à vos attentes, un nœud géré ne figure pas dans la liste, consultez [Résolution des problèmes de disponibilité des nœuds gérés](fleet-manager-troubleshooting-managed-nodes.md) pour obtenir des conseils de dépannage.
1. Pour **Autres paramètres** :
+ Pour **Comment (Commentaire)**, saisissez des informations à propos de cette commande.
+ Pour **Délai (secondes)**, précisez le nombre de secondes durant lesquelles le système doit attendre avant de mettre en échec l'exécution de la commande globale.
1. Pour **Rate control (Contrôle de débit)** :
+ Dans **Concurrency (Simultanéité)**, spécifiez un nombre ou un pourcentage de nœuds gérés sur lesquels exécuter simultanément la commande.
**Note**
Si vous avez sélectionné des cibles en spécifiant des balises appliquées aux nœuds gérés ou en spécifiant AWS des groupes de ressources, et que vous n'êtes pas certain du nombre de nœuds gérés ciblés, limitez le nombre de cibles pouvant exécuter le document en même temps en spécifiant un pourcentage.
+ Dans **Error threshold (Seuil d'erreur)**, indiquez quand arrêter l'exécution de la commande sur les autres nœuds gérés après l'échec de celle-ci sur un certain nombre ou un certain pourcentage de nœuds. Si, par exemple, vous spécifiez trois erreurs, Systems Manager cesse d'envoyer la commande à la réception de la quatrième erreur. Les nœuds gérés sur lesquels la commande est toujours en cours de traitement peuvent également envoyer des erreurs.
1. (Facultatif) Pour **Output options (Options de sortie)**, pour enregistrer la sortie de la commande dans un fichier, cochez la case **Write command output to an S3 bucket (Écrire la sortie de commande vers un compartiment S3)**. Saisissez les noms de compartiment et de préfixe (dossier) dans les zones.
**Note**
Les autorisations S3 qui accordent la possibilité d'écrire les données dans un compartiment S3 sont celles du profil d'instance (pour les instances EC2) ou de la fonction du service IAM (pour les machines activées par un système hybride) attribués à l'instance, et non celles de l'utilisateur IAM qui effectue cette tâche. Pour plus d’informations, consultez les sections [Configurer des autorisations d’instance requises pour Systems Manager](setup-instance-permissions.md) et [Créer un rôle de service IAM pour un environnement hybride](hybrid-multicloud-service-role.md). En outre, si le compartiment S3 spécifié se trouve sur un autre Compte AWS, assurez-vous que le profil d'instance ou la fonction de service IAM associé au nœud géré dispose des autorisations nécessaires pour écrire dans ce compartiment.
1. Dans la section **SNS notifications (Notifications SNS)**, si vous souhaitez envoyer des notifications sur le statut d'exécution des commandes, cochez la case **Enable SNS notifications (Activer les notifications SNS)**.
Pour plus d'informations sur la configuration des notifications Amazon SNS pour Run Command, consultez [Surveillance des changements d'état du Systems Manager à l'aide des notifications Amazon SNS](monitoring-sns-notifications.md).
1. Cliquez sur **Exécuter**.
## Mise à jour PowerShell en utilisant Run Command
La procédure suivante décrit comment effectuer une mise à jour PowerShell vers la version 5.1 sur vos nœuds gérés Windows Server 2012 et 2012 R2. Le script fourni dans cette procédure télécharge la mise à jour de Windows Management Framework (WMF) version 5.1 et démarre l'installation de la mise à jour. Le nœud redémarre au cours de ce processus, comme l'exige l'installation de WMF 5.1. Le téléchargement et l'installation de la mise à jour prennent environ cinq minutes.
**Pour effectuer une mise à jour PowerShell avec Run Command**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, sélectionnez **Run Command**.
1. Sélectionnez **Run Command (Exécuter la commande)**.
1. In the **Command document (Document de commande)**, sélectionnez **`AWS-RunPowerShellScript`**.
1. Dans la section **Commands (Commandes)**, collez les commandes suivantes pour votre système d'exploitation.
------
#### [ Windows Server 2012 R2 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839516" -OutFile "Win8.1AndW2K12R2-KB3191564-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('Win8.1AndW2K12R2-KB3191564-x64.msu', '/quiet')
```
------
#### [ Windows Server 2012 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839513" -OutFile "W2K12-KB3191565-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('W2K12-KB3191565-x64.msu', '/quiet')
```
------
1. Dans la section **Targets (Cibles)**, sélectionnez les nœuds gérés sur lesquels vous souhaitez exécuter cette opération en spécifiant des balises, en sélectionnant des instances ou des appareils de périphérie manuellement ou en spécifiant un groupe de ressources.
**Astuce**
Si, contrairement à vos attentes, un nœud géré ne figure pas dans la liste, consultez [Résolution des problèmes de disponibilité des nœuds gérés](fleet-manager-troubleshooting-managed-nodes.md) pour obtenir des conseils de dépannage.
1. Pour **Autres paramètres** :
+ Pour **Comment (Commentaire)**, saisissez des informations à propos de cette commande.
+ Pour **Délai (secondes)**, précisez le nombre de secondes durant lesquelles le système doit attendre avant de mettre en échec l'exécution de la commande globale.
1. Pour **Rate control (Contrôle de débit)** :
+ Dans **Concurrency (Simultanéité)**, spécifiez un nombre ou un pourcentage de nœuds gérés sur lesquels exécuter simultanément la commande.
**Note**
Si vous avez sélectionné des cibles en spécifiant des balises appliquées aux nœuds gérés ou en spécifiant AWS des groupes de ressources, et que vous n'êtes pas certain du nombre de nœuds gérés ciblés, limitez le nombre de cibles pouvant exécuter le document en même temps en spécifiant un pourcentage.
+ Dans **Error threshold (Seuil d'erreur)**, indiquez quand arrêter l'exécution de la commande sur les autres nœuds gérés après l'échec de celle-ci sur un certain nombre ou un certain pourcentage de nœuds. Si, par exemple, vous spécifiez trois erreurs, Systems Manager cesse d'envoyer la commande à la réception de la quatrième erreur. Les nœuds gérés sur lesquels la commande est toujours en cours de traitement peuvent également envoyer des erreurs.
1. (Facultatif) Pour **Output options (Options de sortie)**, pour enregistrer la sortie de la commande dans un fichier, cochez la case **Write command output to an S3 bucket (Écrire la sortie de commande vers un compartiment S3)**. Saisissez les noms de compartiment et de préfixe (dossier) dans les zones.
**Note**
Les autorisations S3 qui accordent la possibilité d'écrire les données dans un compartiment S3 sont celles du profil d'instance (pour les instances EC2) ou de la fonction du service IAM (pour les machines activées par un système hybride) attribués à l'instance, et non celles de l'utilisateur IAM qui effectue cette tâche. Pour plus d’informations, consultez les sections [Configurer des autorisations d’instance requises pour Systems Manager](setup-instance-permissions.md) et [Créer un rôle de service IAM pour un environnement hybride](hybrid-multicloud-service-role.md). En outre, si le compartiment S3 spécifié se trouve sur un autre Compte AWS, assurez-vous que le profil d'instance ou la fonction de service IAM associé au nœud géré dispose des autorisations nécessaires pour écrire dans ce compartiment.
1. Dans la section **SNS notifications (Notifications SNS)**, si vous souhaitez envoyer des notifications sur le statut d'exécution des commandes, cochez la case **Enable SNS notifications (Activer les notifications SNS)**.
Pour plus d'informations sur la configuration des notifications Amazon SNS pour Run Command, consultez [Surveillance des changements d'état du Systems Manager à l'aide des notifications Amazon SNS](monitoring-sns-notifications.md).
1. Cliquez sur **Exécuter**.
Une fois que le nœud géré a redémarré et que l'installation de la mise à jour est terminée, connectez-vous à votre nœud pour confirmer que la mise à niveau vers la version 5.1 a été effectuée PowerShell avec succès. Pour vérifier la version de PowerShell sur votre nœud, ouvrez PowerShell et entrez`$PSVersionTable`. La valeur `PSVersion` dans le tableau de sortie affiche 5.1 si la mise à niveau a réussi.
Si la valeur `PSVersion` est différente de 5.1, par exemple 3.0 ou 4.0, consultez les journaux **Setup (Configuration)** dans Event Viewer, sous **Windows Logs (Journaux Windows)**. Ces journaux indiquent la raison de l'échec de la mise à jour.
# Procédure pas à pas : utilisez le AWS CLI avec Run Command
L'exemple de procédure pas à pas suivant vous montre comment utiliser le AWS Command Line Interface (AWS CLI) pour afficher des informations sur les commandes et leurs paramètres, comment exécuter des commandes et comment afficher le statut de ces commandes.
**Important**
Seuls les administrateurs fiables devraient être autorisés à utiliser les documents AWS Systems Manager préconfigurés présentés dans cette rubrique. Les commandes ou scripts spécifiés dans des documents Systems Manager sont exécutés avec des autorisations administratives sur vos nœuds gérés. Si un utilisateur a l'autorisation d'exécuter l'un des documents Systems Manager prédéfinis (tout document qui commence par `AWS-`), cet utilisateur dispose d'un accès administrateur au nœud. Pour tous les autres utilisateurs, vous devez créer des documents restrictifs et les partager avec des utilisateurs spécifiques.
**Topics**
+ [Étape 1 : Démarrage](#walkthrough-cli-settings)
+ [Étape 2 : Exécuter des scripts shell pour afficher les détails des ressources](#walkthrough-cli-run-scripts)
+ [Étape 3 : Envoyer des commandes simples à l'aide du document `AWS-RunShellScript`](#walkthrough-cli-example-1)
+ [Étape 4 : Exécuter un script Python simple en utilisant Run Command](#walkthrough-cli-example-2)
+ [Étape 5 : exécutez un script Bash avec Run Command](#walkthrough-cli-example-3)
## Étape 1 : Démarrage
Vous devez disposer de autorisations administrateur sur les nœuds gérés que vous souhaitez configurer ou vous devez bénéficier de l'autorisation appropriée dans Gestion des identités et des accès AWS (IAM). Notez également que cet exemple utilise la région USA Est (Ohio) (us-east-2). Run Commandest disponible dans les [points de terminaison du service Systems Manager Régions AWS](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) répertoriés dans le *Référence générale d'Amazon Web Services*. Pour de plus amples informations, veuillez consulter [Configuration de nœuds gérés pour AWS Systems Manager](systems-manager-setting-up-nodes.md).
**Pour exécuter des commandes à l'aide du AWS CLI**
1. Installez et configurez le AWS Command Line Interface (AWS CLI), si ce n'est pas déjà fait.
Pour de plus amples informations, consultez [Installation ou mise à jour de la version la plus récente de l' AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Répertoriez tous les documents disponibles.
Cette commande répertorie tous les documents disponibles pour votre compte en fonction des autorisations IAM.
```
aws ssm list-documents
```
1. Vérifier qu'un nœud géré est prêt à recevoir les commandes.
La sortie de la commande suivante indique si les nœuds gérés sont en ligne.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--output text --query "InstanceInformationList[*]"
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--output text --query "InstanceInformationList[*]"
```
------
1. Exécutez la commande suivante pour afficher les détails sur un nœud géré spécifique.
**Note**
Pour exécuter les commandes de cette procédure pas à pas, remplacez l'instance et la commande IDs. Pour les appareils AWS IoT Greengrass principaux gérés, utilisez le mi- par *ID\$1number* exemple ID. L'ID de commande est renvoyé en réponse à **send-command**. IDs Les instances sont disponibles auprès Fleet Manager d'un outil dans AWS Systems Manager...
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
## Étape 2 : Exécuter des scripts shell pour afficher les détails des ressources
Run Command et le document `AWS-RunShellScript` vous permettent d'exécuter n'importe quel script ou commande sur un nœud géré comme si vous vous étiez connecté localement.
**Afficher la description et les paramètres disponibles**
Exécutez la commande suivante pour afficher la description du document JSON Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "[Document.Name,Document.Description]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "[Document.Name,Document.Description]"
```
------
Utilisez la commande suivante afin d'afficher les paramètres disponibles et les détails les concernant.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "Document.Parameters[*]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "Document.Parameters[*]"
```
------
## Étape 3 : Envoyer des commandes simples à l'aide du document `AWS-RunShellScript`
Utilisez la commande suivante afin d'obtenir des informations IP pour un nœud géré Linux.
Si vous ciblez un nœud géré Windows Server, remplacez `document-name` par `AWS-RunPowerShellScript` et `command` depuis `ifconfig` par `ipconfig`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "IP config" \
--parameters commands=ifconfig \
--output text
```
------
#### [ Windows ]
```
aws ssm send-command ^
--instance-ids "instance-ID" ^
--document-name "AWS-RunShellScript" ^
--comment "IP config" ^
--parameters commands=ifconfig ^
--output text
```
------
**Obtenir des informations sur la commande avec des données de réponse**
La commande suivante utilise l'ID de commande qui a été retourné par la commande précédente afin d'obtenir les détails et les données de réponse de l'exécution de la commande. Le système renvoie les données de réponse si la commande a été exécutée. Si l'exécution de la commande indique `"Pending"` ou `"InProgress"`, vous devrez l'exécuter à nouveau pour consulter les données de réponse.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id $sh-command-id \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id $sh-command-id ^
--details
```
------
**Identification de l'utilisateur**
La commande suivante affiche l'utilisateur par défaut qui exécute les commandes.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux managed node" \
--parameters commands=whoami \
--output text \
--query "Command.CommandId")
```
------
**Obtenir le statut de la commande**
La commande suivante utilise l'ID de commande afin d'obtenir le statut de l'exécution de la commande sur le nœud géré. Cet exemple utilise l'ID de commande qui a été renvoyé lors de la commande précédente.
------
#### [ Linux & macOS ]
```
aws ssm list-commands \
--command-id "command-ID"
```
------
#### [ Windows ]
```
aws ssm list-commands ^
--command-id "command-ID"
```
------
**Obtenir les détails de la commande**
La commande suivante utilise l'ID de la commande précédente afin d'obtenir le statut de l'exécution de la commande par nœud géré.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id "command-ID" ^
--details
```
------
**Obtention d'informations sur la commande avec des données de réponse pour un nœud géré**
La commande suivante renvoie la sortie de la demande `aws ssm send-command` initiale pour un nœud géré spécifique.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--instance-id instance-ID \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--instance-id instance-ID ^
--command-id "command-ID" ^
--details
```
------
**Afficher la version Python**
La commande suivante retourne la version de Python exécutée sur un nœud.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters commands='python -V' \
--output text --query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Étape 4 : Exécuter un script Python simple en utilisant Run Command
La commande suivante exécute un simple script Python « Hello World » à l'aide de Run Command.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters '{"commands":["#!/usr/bin/python","print \"Hello World from python\""]}' \
--output text \
--query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Étape 5 : exécutez un script Bash avec Run Command
Les exemples de cette section montrent l'exécution du script bash suivant avec Run Command.
Pour obtenir des exemples d'utilisation de Run Command pour exécuter des scripts stockés dans des emplacements distants, consultez [Exécution de scripts à partir d'Amazon S3](integration-s3.md) et [Exécution de scripts depuis GitHub](integration-remote-scripts.md).
```
#!/bin/bash
yum -y update
yum install -y ruby
cd /home/ec2-user
curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
```
Ce script installe l' AWS CodeDeploy agent sur les instances Amazon Linux et Red Hat Enterprise Linux (RHEL), comme décrit dans la section [Créer une instance Amazon EC2 CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-ec2-create.html) pour dans *AWS CodeDeploy le guide de l'*utilisateur.
Le script installe l' CodeDeploy agent à partir d'un compartiment S3 AWS géré dans la région USA Est (Ohio) (us-east-2),. `aws-codedeploy-us-east-2`
**Exécuter un script bash dans une commande AWS CLI **
L'exemple suivant montre comment inclure le script bash dans une commande CLI en utilisant l'option `--parameters`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets '[{"Key":"InstanceIds","Values":["instance-id"]}]' \
--parameters '{"commands":["#!/bin/bash","yum -y update","yum install -y ruby","cd /home/ec2-user","curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install","chmod +x ./install","./install auto"]}'
```
------
**Exécuter un script bash dans un fichier JSON**
Dans l'exemple suivant, le contenu du script bash est stocké dans un fichier JSON, et le fichier est inclus dans la commande en utilisant l'option `--cli-input-json`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets "Key=InstanceIds,Values=instance-id" \
--cli-input-json file://installCodeDeployAgent.json
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--targets "Key=InstanceIds,Values=instance-id" ^
--cli-input-json file://installCodeDeployAgent.json
```
------
L'exemple suivant montre le contenu du fichier `installCodeDeployAgent.json` référencé.
```
{
"Parameters": {
"commands": [
"#!/bin/bash",
"yum -y update",
"yum install -y ruby",
"cd /home/ec2-user",
"curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install",
"chmod +x ./install",
"./install auto"
]
}
}
```
# Procédure pas à pas : utilisez le AWS Tools for Windows PowerShell avec Run Command
Les exemples suivants montrent comment utiliser le AWS Tools for Windows PowerShell pour afficher des informations sur les commandes et leurs paramètres, comment exécuter des commandes et comment afficher le statut de ces commandes. Cette procédure inclut un exemple pour chaque document AWS Systems Manager prédéfini.
**Important**
Seuls les administrateurs de confiance doivent être autorisés à utiliser les documents préconfigurés Systems Manager illustrés dans cette rubrique. Les commandes ou scripts spécifiés dans des documents Systems Manager sont exécutés avec une autorisation administrative sur vos nœuds gérés. Si un utilisateur est autorisé à exécuter l'un des documents prédéfinis de Systems Manager (tout document commençant par AWS), il dispose également d'un accès administrateur au nœud. Pour tous les autres utilisateurs, vous devez créer des documents restrictifs et les partager avec des utilisateurs spécifiques.
**Topics**
+ [Configuration des paramètres AWS Tools for Windows PowerShell de session](#walkthrough-powershell-settings)
+ [Répertorier tous les documents disponibles](#walkthrough-powershell-all-documents)
+ [Exécuter PowerShell des commandes ou des scripts](#walkthrough-powershell-run-script)
+ [Installer une application en utilisant le document `AWS-InstallApplication`](#walkthrough-powershell-install-application)
+ [Installation d'un PowerShell module à l'aide du document `AWS-InstallPowerShellModule` JSON](#walkthrough-powershell-install-module)
+ [Association d'un nœud géré à un domaine en utilisant le document JSON `AWS-JoinDirectoryServiceDomain`](#walkthrough-powershell-domain-join)
+ [Envoyez les métriques Windows à Amazon CloudWatch Logs à l'aide du `AWS-ConfigureCloudWatch` document](#walkthrough-powershell-windows-metrics)
+ [Activer ou désactiver la mise à jour automatique de Windows en utilisant le document `AWS-ConfigureWindowsUpdate`](#walkthrough-powershell-enable-windows-update)
+ [Gérer les mises à jour Windows à l'aide de la fonctionnalité Run Command](#walkthough-powershell-windows-updates)
## Configuration des paramètres AWS Tools for Windows PowerShell de session
**Spécifier vos informations d'identification**
Ouvrez **Outils pour Windows PowerShell** sur votre ordinateur local et exécutez la commande suivante pour spécifier vos informations d'identification. Vous devez disposer des autorisations d'administrateur sur les nœuds gérés que vous souhaitez configurer ou vous devez avoir obtenu les autorisations appropriées dans Gestion des identités et des accès AWS (IAM). Pour de plus amples informations, veuillez consulter [Configuration de nœuds gérés pour AWS Systems Manager](systems-manager-setting-up-nodes.md).
```
Set-AWSCredentials –AccessKey key-name –SecretKey key-name
```
**Définir une valeur par défaut Région AWS**
Exécutez la commande suivante pour définir la région de votre PowerShell session. L'exemple utilise la région USA Est (Ohio) (us-east-2). Run Commandest disponible dans les [points de terminaison du service Systems Manager Régions AWS](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) répertoriés dans le *Référence générale d'Amazon Web Services*.
```
Set-DefaultAWSRegion `
-Region us-east-2
```
## Répertorier tous les documents disponibles
Cette commande répertorie les documents disponibles pour votre compte.
```
Get-SSMDocumentList
```
## Exécuter PowerShell des commandes ou des scripts
Run Command et le document `AWS-RunPowerShell` vous permettent d'exécuter n'importe quel script ou commande sur un nœud géré comme si vous vous étiez connecté localement. Vous pouvez émettre des commandes ou saisir un chemin d'accès à un script local pour exécuter la commande.
**Note**
Pour plus d'informations sur le redémarrage des nœuds gérés lors de l'utilisation de Run Command pour appeler des scripts, consultez [Gestion des redémarrages lors de l'exécution de commandes](send-commands-reboot.md).
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript" | Select -ExpandProperty Parameters
```
### Envoyer une commande en utilisant le document `AWS-RunPowerShellScript`
La commande suivante permet d'afficher le contenu du répertoire `"C:\Users"` et celui du répertoire `"C:\"` sur deux nœuds gérés.
```
$runPSCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1", "instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'=@('dir C:\Users', 'dir C:\')}
```
**Obtenir les détails de la demande de commande**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande sur les deux nœuds gérés. Cet exemple utilise l'`CommandId` qui a été renvoyé lors de la commande précédente.
```
Get-SSMCommand `
-CommandId $runPSCommand.CommandId
```
Dans cet exemple, le statut de la commande peut être Success, Pending ou InProgress.
**Obtention d'informations sur la commande par nœud géré**
La commande suivante utilise l'`CommandId` de la commande précédente afin d'obtenir le statut de l'exécution de la commande par nœud géré.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId
```
**Obtention d'informations sur la commande avec des données de réponse pour un nœud géré**
La commande suivante renvoie la sortie de la commande `Send-SSMCommand` initiale pour un nœud géré spécifique.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Annuler une commande
La commande suivante annule le `Send-SSMCommand` pour le document `AWS-RunPowerShellScript`.
```
$cancelCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1","instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'='Start-Sleep –Seconds 120; dir C:\'}
Stop-SSMCommand -CommandId $cancelCommand.CommandId
```
**Vérifier le statut de commande**
La commande suivante vérifie le statut de la commande `Cancel`.
```
Get-SSMCommand `
-CommandId $cancelCommand.CommandId
```
## Installer une application en utilisant le document `AWS-InstallApplication`
En utilisant Run Command et le document `AWS-InstallApplication`, vous pouvez installer, réparer ou désinstaller des applications sur des nœuds gérés. Cette commande a besoin d'un chemin d'accès ou d'une adresse pour un MSI.
**Note**
Pour plus d'informations sur le redémarrage des nœuds gérés lors de l'utilisation de Run Command pour appeler des scripts, consultez [Gestion des redémarrages lors de l'exécution de commandes](send-commands-reboot.md).
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication" | Select -ExpandProperty Parameters
```
### Envoyer une commande en utilisant le document `AWS-InstallApplication`
La commande suivante installe une version de Python sur votre nœud géré en mode sans surveillance et consigne la sortie dans un fichier texte local sur votre lecteur `C:`.
```
$installAppCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallApplication" `
-Parameter @{'source'='https://www.python.org/ftp/python/2.7.9/python-2.7.9.msi'; 'parameters'='/norestart /quiet /log c:\pythoninstall.txt'}
```
**Obtention d'informations sur la commande par nœud géré**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true
```
**Obtention d'informations sur la commande avec des données de réponse pour un nœud géré**
La commande suivante retourne les résultats de l'installation Python.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
## Installation d'un PowerShell module à l'aide du document `AWS-InstallPowerShellModule` JSON
Vous pouvez l'utiliser Run Command pour installer PowerShell des modules sur des nœuds gérés. Pour plus d'informations sur les PowerShell modules, consultez la section [ PowerShell Modules Windows](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_modules?view=powershell-6).
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule" | Select -ExpandProperty Parameters
```
### Installation d'un PowerShell module
La commande suivante télécharge le fichier EZOut .zip, l'installe, puis exécute une commande supplémentaire pour installer le lecteur XPS. Enfin, la sortie de cette commande est chargée dans un compartiment S3 nommé « amzn-s3-demo-bucket ».
```
$installPSCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallPowerShellModule" `
-Parameter @{'source'='https://gallery.technet.microsoft.com/EZOut-33ae0fb7/file/110351/1/EZOut.zip';'commands'=@('Add-WindowsFeature -name XPS-Viewer -restart')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obtention d'informations sur la commande par nœud géré**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true
```
**Obtention d'informations sur la commande avec des données de réponse pour le nœud géré**
La commande suivante renvoie la sortie de la commande `Send-SSMCommand` d'origine pour le `CommandId` spécifique.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Association d'un nœud géré à un domaine en utilisant le document JSON `AWS-JoinDirectoryServiceDomain`
En utilisantRun Command, vous pouvez rapidement joindre un nœud géré à un AWS Directory Service domaine. Avant d'exécuter cette commande, [créez un répertoire](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html). Nous vous recommandons également d'en découvrir plus sur l' Directory Service. Pour plus d'informations, consultez le [Guide d'administration AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/).
Vous pouvez uniquement associer un nœud géré à un domaine. Vous ne pouvez pas supprimer de nœud d'un domaine.
**Note**
Pour plus d'informations sur les nœuds gérés lors de l'utilisation de Run Command pour appeler des scripts, consultez [Gestion des redémarrages lors de l'exécution de commandes](send-commands-reboot.md).
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain" | Select -ExpandProperty Parameters
```
### Association d'un nœud géré à un domaine
La commande suivante joint un nœud géré au Directory Service domaine donné et télécharge toute sortie générée dans l'exemple de bucket Amazon Simple Storage Service (Amazon S3).
```
$domainJoinCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-JoinDirectoryServiceDomain" `
-Parameter @{'directoryId'='d-example01'; 'directoryName'='ssm.example.com'; 'dnsIpAddresses'=@('192.168.10.195', '192.168.20.97')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obtention d'informations sur la commande par nœud géré**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true
```
**Obtention d'informations sur la commande avec des données de réponse pour le nœud géré**
Cette commande renvoie la sortie du `Send-SSMCommand` initial pour le `CommandId` spécifique.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Envoyez les métriques Windows à Amazon CloudWatch Logs à l'aide du `AWS-ConfigureCloudWatch` document
Vous pouvez envoyer Windows Server des messages dans les journaux de l'application, du système, de la sécurité et du suivi des événements pour Windows (ETW) à Amazon CloudWatch Logs. Lorsque vous activez la journalisation pour la première fois, Systems Manager envoie tous les journaux générés en une minute à partir du moment où vous avez commencé à charger les journaux pour les applications, le système, la sécurité et le suivi d'événements. Les journaux générés avant ce moment ne sont pas inclus. Si vous désactivez la journalisation, puis que vous la réactivez, Systems Manager envoie les journaux à partir du moment où la journalisation a été désactivée. Pour tous les fichiers journaux personnalisés et les journaux IIS (Internet Information Services), Systems Manager lit les fichiers journaux depuis le début. En outre, Systems Manager peut également envoyer les données des compteurs de performance à CloudWatch Logs.
Si vous avez précédemment activé CloudWatch l'intégration dans EC2 Config, les paramètres de Systems Manager remplacent tous les paramètres stockés localement sur le nœud géré dans le `C:\Program Files\Amazon\EC2ConfigService\Settings\AWS.EC2.Windows.CloudWatch.json` fichier. Pour plus d'informations sur l'utilisation de EC2 Config pour gérer les compteurs de performance et les journaux sur un seul nœud géré, consultez la section [Collecte de métriques et de journaux à partir d'instances Amazon EC2 et de serveurs sur site avec CloudWatch l'agent dans le guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) de l'utilisateur *Amazon CloudWatch *.
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch" | Select -ExpandProperty Parameters
```
### Envoyez les journaux des applications à CloudWatch
La commande suivante configure le nœud géré et déplace les journaux des applications Windows vers CloudWatch.
```
$cloudWatchCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"ApplicationEventLog", "FullName":"AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"LogName":"Application", "Levels":"7"}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch", "Parameters":{"Region":"region", "LogGroup":"my-log-group", "LogStream":"instance-id"}}], "Flows":{"Flows":["ApplicationEventLog,CloudWatch"]}}}'}
```
**Obtention d'informations sur la commande par nœud géré**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true
```
**Obtention d'informations sur la commande avec des données de réponse pour un nœud géré**
La commande suivante renvoie les résultats de la CloudWatch configuration Amazon.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Envoyer des compteurs de performance à CloudWatch l'utilisation du document `AWS-ConfigureCloudWatch`
La commande de démonstration suivante télécharge les compteurs de performance vers. CloudWatch Pour plus d'informations, consultez le *[guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
```
$cloudWatchMetricsCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"PerformanceCounter", "FullName":"AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"CategoryName":"Memory", "CounterName":"Available MBytes", "InstanceName":"", "MetricName":"AvailableMemory", "Unit":"Megabytes","DimensionName":"", "DimensionValue":""}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"AccessKey":"", "SecretKey":"","Region":"region", "NameSpace":"Windows-Default"}}], "Flows":{"Flows":["PerformanceCounter,CloudWatch"]}}}'}
```
## Activer ou désactiver la mise à jour automatique de Windows en utilisant le document `AWS-ConfigureWindowsUpdate`
Run Command et le document `AWS-ConfigureWindowsUpdate` vous permettent d'activer et de désactiver les mises à jour Windows automatiques sur vos nœuds gérés Windows Server. Cette commande configure l'agent de mise à jour Windows pour télécharger et installer les mises à jour Windows à la date et à l'heure que vous spécifiez. Si une mise à jour requiert un redémarrage, le nœud géré redémarre automatiquement 15 minutes après l'installation des mises à jour. Cette commande vous permet également de configurer la mise à jour Windows de façon à rechercher les mises à jour sans les installer. Le document `AWS-ConfigureWindowsUpdate` est officiellement pris en charge sur Windows Server 2012 et versions ultérieures.
**Afficher la description et les paramètres disponibles**
```
Get-SSMDocumentDescription `
–Name "AWS-ConfigureWindowsUpdate"
```
**Afficher des informations supplémentaires sur les paramètres**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureWindowsUpdate" | Select -ExpandProperty Parameters
```
### Activer la mise à jour automatique de Windows
La commande suivante configure les mises à jour Windows de façon à ce qu'elles soient téléchargées et installées automatiquement tous les jours à 22 h.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='InstallUpdatesAutomatically'; 'scheduledInstallDay'='Daily'; 'scheduledInstallTime'='22:00'}
```
**Afficher le statut de la commande afin d'activer les mises à jour automatiques Windows**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande pour activer les mises à jour automatiques Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
### Désactiver la mise à jour automatique de Windows
La commande suivante diminue le niveau de notification des mises à jour Windows afin que le système recherche les mises à jour, mais ne mette pas à jour le nœud géré automatiquement.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='NeverCheckForUpdates'}
```
**Afficher le statut de la commande afin de désactiver les mises à jour automatiques Windows**
La commande suivante utilise l'`CommandId` afin d'obtenir le statut de l'exécution de la commande pour activer les mises à jour automatiques Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
## Gérer les mises à jour Windows à l'aide de la fonctionnalité Run Command
Run Command et le document `AWS-InstallWindowsUpdates` vous permettent de gérer les mises à jour pour les nœuds gérés Windows Server. Cette commande recherche ou installe les mises à jour manquantes sur vos nœuds gérés et, éventuellement, provoque un redémarrage après l'installation. Vous pouvez également spécifier les classifications et les niveaux de sévérité appropriés pour les mises à jour à installer dans votre environnement.
**Note**
Pour plus d'informations sur le redémarrage des nœuds gérés lors de l'utilisation de Run Command pour appeler des scripts, consultez [Gestion des redémarrages lors de l'exécution de commandes](send-commands-reboot.md).
Les exemples suivants décrivent comment exécuter les tâches de gestion des mises à jour Windows spécifiées.
### Rechercher toutes les mises à jour Windows manquantes
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Scan'}
```
### Installer des mises à jour Windows spécifiques
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'IncludeKbs'='kb-ID-1,kb-ID-2,kb-ID-3';'AllowReboot'='True'}
```
### Installer les mises à jour Windows importantes manquantes
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'SeverityLevels'='Important';'AllowReboot'='True'}
```
### Installer les mises à jour Windows manquantes avec des exclusions spécifiques
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'ExcludeKbs'='kb-ID-1,kb-ID-2';'AllowReboot'='True'}
```
# Résolution des problèmes liés à Run Command de Systems Manager
Run Command, un outil dans AWS Systems Manager, fournit des informations sur le statut de chaque exécution de commande. Pour de plus amples informations sur les détails de l'état des commande, veuillez consulter [Comprendre les états des commandes](monitor-commands.md). Vous pouvez également utiliser les informations de cette rubrique pour aider à la résolution les problèmes rencontrés avec la fonctionnalité Run Command.
**Topics**
+ [Certains de mes nœuds gérés sont manquants](#where-are-instances)
+ [Une étape de mon script a échoué, mais l'état global est « réussi »](#ts-exit-codes)
+ [SSM Agent ne fonctionne pas correctement](#ts-ssmagent-linux)
## Certains de mes nœuds gérés sont manquants
Dans la page **Exécuter une commande**, une fois que vous avez choisi un document SSM à exécuter et que vous avez sélectionné **Sélection manuelle des instances** dans la section **Cibles**, la liste des nœuds gérés sur lesquels vous pouvez choisir d'exécuter la commande s'affiche.
Si, contrairement à vos attentes, un nœud géré ne figure pas dans la liste, consultez [Résolution des problèmes de disponibilité des nœuds gérés](fleet-manager-troubleshooting-managed-nodes.md) pour obtenir des conseils de dépannage.
Après avoir créé, activé, redémarré ou redémarré un nœud géré, installé Run Command sur un nœud ou attaché un profil d'instance Gestion des identités et des accès AWS (IAM) à un nœud, l'ajout du nœud géré à la liste peut prendre quelques minutes.
## Une étape de mon script a échoué, mais l'état global est « réussi »
Vous pouvez utiliser Run Command pour définir la manière dont les codes de sortie sont gérés par vos scripts. Par défaut, le code de sortie de la dernière commande exécutée dans un script est signalé comme le code de sortie pour l'ensemble du script. Vous pouvez néanmoins inclure une instruction conditionnelle pour quitter le script si une commande précédant la dernière échoue. Pour plus d'informations et d'exemples, consultez [Spécifier les codes de sortie dans les commandes](run-command-handle-exit-status.md#command-exit-codes).
## SSM Agent ne fonctionne pas correctement
Si vous rencontrez des problèmes pour exécuter des commandes avec la fonctionnalité Run Command, cela peut venir de l'SSM Agent. Pour obtenir des informations sur la recherche de problèmes avec SSM Agent, veuillez consulter [Résolution des problèmes de SSM Agent](troubleshooting-ssm-agent.md).