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 IoT Device Management commandes
**Important**
Cette documentation décrit comment vous pouvez utiliser la [fonctionnalité de commandes dans AWS IoT Device Management](https://docs.aws.amazon.com/iot/latest/developerguide/iot-remote-command-concepts.html#command-iot-namespace). Pour plus d'informations sur l'utilisation de cette fonctionnalité AWS IoT FleetWise, consultez la section [Commandes à distance](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html).
Vous êtes seul responsable du déploiement des commandes d'une manière sûre et conforme aux lois applicables. Pour plus d'informations sur vos responsabilités, veuillez consulter les [conditions AWS de service relatives AWS IoT aux services](https://aws.amazon.com/service-terms/).
Utilisez AWS IoT Device Management les commandes pour envoyer une instruction depuis le cloud à un appareil connecté à AWS IoT. Les commandes ciblent un appareil à la fois et peuvent être utilisées pour des applications à faible latence et à haut débit, telles que la récupération des journaux côté appareil ou le lancement d'un changement d'état de l'appareil.
La *commande* est une ressource réutilisable gérée par AWS IoT Device Management. Il contient des configurations qui sont appliquées avant d'être publiées sur l'appareil. Vous pouvez prédéfinir un ensemble de commandes pour des cas d'utilisation spécifiques, tels que l'allumage d'une ampoule ou le déverrouillage d'une portière de véhicule.
La fonction AWS IoT Commandes vous permet de :
+ Créez des modèles de commandes réutilisables avec des charges utiles statiques ou dynamiques, puis exécutez-les sur des appareils spécifiques.
+ Appareils cibles enregistrés en tant qu' AWS IoT objets ou clients MQTT non enregistrés.
+ Exécutez plusieurs commandes simultanément sur le même appareil.
+ Activez les notifications d'événements et suivez l'état d'exécution au fur et à mesure que les appareils traitent les commandes.
Les rubriques suivantes expliquent comment créer des commandes, les envoyer à votre appareil et récupérer l'état signalé par l'appareil.
**Topics**
+ [Démarrage rapide](iot-commands-quickstart.md)
+ [Concepts et statut des commandes](iot-remote-command-concepts.md)
+ [Workflow de commandes de haut niveau](iot-remote-command-workflow.md)
+ [Création et gestion de commandes](iot-remote-command-create-manage.md)
+ [Démarrage et surveillance des exécutions de commandes](iot-remote-command-execution-start-monitor.md)
+ [Obsolescence d’une ressource de commande](iot-remote-command-deprecate.md)
# Démarrage rapide
Procédez comme suit pour envoyer votre première commande :
1. **Conditions préalables** : assurez-vous d'être intégré à IoT Core, à un appareil connecté à IoT Core, aux autorisations IAM pour les opérations de l'API Commands et à une bibliothèque cliente MQTT installée sur votre appareil.
1. **Créer une commande** : définissez une commande avec une charge utile statique ou un modèle de charge utile spécifiant les actions de l'appareil. Consultez [Création d'une ressource de commande](iot-remote-command-create-manage.md#iot-remote-command-create).
1. **Identifiez votre appareil** : enregistrez votre appareil en tant qu'objet IoT ou notez son identifiant client MQTT. Consultez [Considérations relatives à l'appareil cible](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1. **Configurer les autorisations** : configurez des politiques IAM permettant à votre appareil de recevoir des commandes et de publier des réponses.
1. **Abonnement aux sujets** : configurez votre appareil pour qu'il s'abonne aux sujets de demande et de réponse aux commandes. Consultez [Choisissez l'appareil cible pour vos commandes et abonnez-vous aux rubriques MQTT](iot-remote-command-workflow.md#command-choose-target).
1. **Exécuter la commande** : lancez l'exécution de la commande sur votre appareil cible. Consultez [Lancer l'exécution d'une commandeLancer l'exécution d'une commande (console)Lancer l'exécution d'une commande (AWS CLI)](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-start).
**Cas d’utilisation courants :**
+ *Diagnostic à distance* - Récupérez les journaux, exécutez des diagnostics, vérifiez l'état de santé de l'appareil
+ *Mises à jour de configuration* - Modifier les paramètres, mettre à jour les paramètres, activer les fonctionnalités
+ *Contrôle de l'appareil* -Lock/unlock, power on/off, changements de mode
# Concepts et statut des commandes
Utilisez AWS IoT les commandes pour envoyer des instructions depuis le cloud aux appareils connectés. Pour utiliser cette fonctionnalité :
1. Créez une commande avec une charge utile contenant les configurations requises pour s'exécuter sur le périphérique.
1. Spécifiez l'équipement cible qui recevra la charge utile et exécutera les actions.
1. Exécutez la commande sur le périphérique cible et récupérez les informations d'état. Pour résoudre les problèmes, consultez les CloudWatch journaux.
Pour de plus amples informations sur le contournement, veuillez consulter [Workflow de commandes de haut niveau](iot-remote-command-workflow.md).
**Topics**
+ [Concepts clés des commandes](#iot-command-concepts)
+ [États de commande](#iot-command-states)
+ [Statut d’exécution de la commande](#iot-command-execution-status)
## Concepts clés des commandes
Les concepts clés suivants vous aident à comprendre la fonctionnalité Commandes. Les termes sont utilisés de manière cohérente dans cette documentation :
+ *Commande* : modèle réutilisable définissant les instructions de l'appareil
+ *Exécution* : instance d'une commande exécutée sur un appareil
+ *Nom de l'objet* : identifiant des appareils enregistrés dans le registre de l'IoT
+ *ID client : identifiant* MQTT pour les appareils non enregistrés
+ *Charge utile* : données d'instructions envoyées aux appareils
+ *Sujet* - Canal MQTT pour la communication de commandes
**Commandes**
Les commandes sont des instructions envoyées depuis le cloud à vos appareils IoT sous forme de messages MQTT. Après avoir reçu la charge utile, les appareils traitent les instructions et prennent les mesures correspondantes, telles que la modification des paramètres de configuration, la transmission des relevés des capteurs ou le téléchargement des journaux. Les appareils renvoient ensuite les résultats dans le cloud, ce qui permet une surveillance et un contrôle à distance.
**Namespace**
Lorsque vous créez une commande, spécifiez son espace de noms. Pour AWS IoT Device Management les commandes, utilisez l'espace de `AWS-IoT` noms par défaut et fournissez une charge utile ou un modèle de charge utile. Pour AWS IoT FleetWise les commandes, utilisez l'espace de `AWS-IoT-FleetWise` noms. Pour plus d'informations, consultez la section [Commandes à distance](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html) dans le *Guide du AWS IoT FleetWise développeur*.
**Charge utile**
Lorsque vous créez une commande, fournissez une charge utile statique qui définit les actions que le périphérique doit effectuer. La charge utile peut utiliser n'importe quel format pris en charge. Pour garantir que les appareils interprètent correctement la charge utile, nous vous recommandons de spécifier le type de format de charge utile. Les appareils utilisant le MQTT5 protocole peuvent suivre la norme MQTT pour identifier le format. Les indicateurs de format pour JSON ou CBOR sont disponibles dans la rubrique de demande de commandes.
**Modèle de charge utile**
Un modèle de charge utile définit une charge utile de commande avec des espaces réservés qui génèrent différentes charges utiles au moment de l'exécution en fonction des valeurs de paramètres que vous fournissez. Par exemple, au lieu de créer des charges utiles distinctes pour différentes valeurs de température, créez un modèle avec un espace réservé à la température et spécifiez la valeur lors de l'exécution. Cela élimine le maintien de plusieurs charges utiles similaires.
**Appareil cible**
Pour exécuter une commande, spécifiez une machine cible en utilisant son nom d'objet (pour les appareils enregistrés avec AWS IoT) ou son ID client MQTT (pour les appareils non enregistrés). L'ID client est un identifiant unique défini dans le [MQTT](mqtt.md) protocole utilisé pour connecter les appareils à AWS IoT. Pour en savoir plus, consultez [Considérations relatives à l'appareil cible](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
**Rubriques relatives aux commandes**
Avant d'exécuter une commande, les appareils doivent s'abonner à la rubrique de demande de commandes. Lorsque vous exécutez une commande, la charge utile est envoyée à l'appareil sur ce sujet. Après l'exécution, les appareils publient les résultats et l'état dans la rubrique de réponse aux commandes. Pour de plus amples informations, veuillez consulter [Rubriques relatives aux commandes](reserved-topics.md#reserved-topics-commands).
**Exécution de commandes**
Une exécution est une instance d'une commande exécutée sur un équipement cible. Lorsque vous lancez une exécution, la charge utile est transmise à l'appareil et un identifiant d'exécution unique est généré. L'appareil exécute la commande et indique la progression à AWS IoT. La logique côté appareil détermine le comportement d'exécution et les rapports d'état relatifs aux sujets réservés.
### Conditions de valeur des paramètres
Lorsque vous créez des commandes avec des modèles de charge utile, définissez des conditions de valeur pour valider les valeurs des paramètres avant leur exécution. Les conditions de valeur garantissent que les paramètres répondent aux exigences, empêchant ainsi les exécutions non valides.
**Opérateurs pris en charge par [CommandParameterValue](https://docs.aws.amazon.com//iot/latest/apireference/API_CommandParameterValue.html)type**
**Types numériques (INTEGER, LONG, DOUBLE, UNSIGNEDLONG)**
+ `EQUALS`- La valeur doit être égale au nombre spécifié
+ `NOT_EQUALS`- La valeur ne doit pas être égale au nombre spécifié
+ `GREATER_THAN`- La valeur doit être supérieure au nombre spécifié
+ `GREATER_THAN_EQUALS`- La valeur doit être supérieure ou égale au nombre spécifié
+ `LESS_THAN`- La valeur doit être inférieure au nombre spécifié
+ `LESS_THAN_EQUALS`- La valeur doit être inférieure ou égale au nombre spécifié
+ `IN_RANGE`- La valeur doit être comprise dans la plage spécifiée (inclus)
+ `NOT_IN_RANGE`- La valeur doit être en dehors de la plage spécifiée (inclus)
+ `IN_SET`- La valeur doit correspondre à l'un des nombres spécifiés
+ `NOT_IN_SET`- La valeur ne doit correspondre à aucun des nombres spécifiés
**Type de chaîne (STRING)**
+ `EQUALS`- La valeur doit être égale à la chaîne spécifiée
+ `NOT_EQUALS`- La valeur ne doit pas être égale à la chaîne spécifiée
+ `IN_SET`- La valeur doit correspondre à l'une des chaînes spécifiées
+ `NOT_IN_SET`- La valeur ne doit correspondre à aucune des chaînes spécifiées
**Type booléen**
+ Les conditions de valeur ne sont pas prises en charge
**Type binaire**
+ Les conditions de valeur ne sont pas prises en charge
**Exemple : commande de contrôle de température**
```
{
"commandId": "SetTemperature",
"namespace": "AWS-IoT",
"payloadTemplate": "{\"temperature\": \"${aws:iot:commandexecution::parameter:temperature}\"}",
"parameters": [
{
"name": "temperature",
"type": "INTEGER",
"valueConditions": [
{
"comparisonOperator": "IN_RANGE",
"operand": {
"numberRange": {
"min": "60",
"max": "80"
}
}
}
]
}
]
}
```
Dans cet exemple, le `temperature` paramètre doit être compris entre 60 et 80 (inclus). Les demandes d'exécution dont les valeurs se situent en dehors de cette plage échouent à la validation.
**Note**
Les conditions de valeur sont évaluées lors de l'appel de l'[StartCommandExecution API](https://docs.aws.amazon.com//iot/latest/apireference/API_iot-jobs-data_StartCommandExecution.html). Les validations échouées renvoient une erreur et empêchent la création de l'exécution.
### Priorité et évaluation des valeurs des paramètres
Lorsque vous lancez des exécutions de commandes avec des modèles de charge utile, les valeurs des paramètres sont résolues selon la priorité suivante :
1. **Paramètres de la demande d'exécution** - Les valeurs fournies dans la `StartCommandExecution` demande ont la priorité la plus élevée
1. **Valeurs par défaut des commandes** - Si aucun paramètre n'est fourni dans la demande d'exécution, c'est celui du paramètre qui `defaultValue` est utilisé
1. **Aucune valeur** - Si aucune valeur n'est fournie, l'exécution échoue en tant que paramètre requis pour générer la demande d'exécution
Les conditions de valeur sont évaluées sur la base de la valeur finale du paramètre dérivée ci-dessus sur la priorité et avant la création de l'exécution. Si la validation échoue, la demande d'exécution renvoie une erreur.
**Exemple : SetTemperature commande avec `defaultValue`**
```
{
"parameters": [
{
"name": "temperature",
"type": "INTEGER",
"defaultValue": {"I": 72},
"valueConditions": [
{
"comparisonOperator": "IN_RANGE",
"operand": {"numberRange": {"min": "60", "max": "80"}}
}
]
}
]
}
```
Au début de l'exécution :
+ Si vous le fournissez `"temperature": {"I": 75}` dans la demande, 75 est utilisé
+ Si vous omettez le paramètre de température, la valeur par défaut 72 est utilisée
+ Les deux valeurs sont validées par rapport à la condition de plage [60,80]
## États de commande
Les commandes que vous Compte AWS contiennent peuvent être dans l'un des trois états suivants : *Disponible*, *Obsolète* ou *En attente* de suppression.
**Disponible**
Une fois la création réussie, une commande passe à l'état Disponible et peut être exécutée sur les appareils.
**Obsolète**
Marquez les commandes comme obsolètes lorsqu'elles ne sont plus nécessaires. Les commandes obsolètes ne peuvent pas démarrer de nouvelles exécutions, mais les exécutions en attente se poursuivent jusqu'à leur fin. Pour activer de nouvelles exécutions, restaurez l'état Disponible de la commande.
**Suppression en attente**
Lorsque vous marquez une commande pour suppression, elle est automatiquement supprimée si elle est obsolète au-delà du délai maximum (par défaut : 12 heures). Cette action est permanente. Si elle n'est pas déconseillée ou déconseillée pendant une durée inférieure au délai imparti, la commande passe à l'état En attente de suppression et est supprimée une fois le délai expiré.
## Statut d’exécution de la commande
Lorsque vous lancez une exécution sur une machine cible, celle-ci entre dans un `CREATED` état et peut passer à d'autres statuts en fonction des rapports de l'appareil. Vous pouvez récupérer les informations d'état et suivre les exécutions.
**Note**
Vous pouvez exécuter plusieurs commandes simultanément sur un appareil. Utilisez le contrôle de simultanéité pour limiter les exécutions par appareil et éviter les surcharges. Pour connaître le nombre maximal d'exécutions simultanées par appareil, voir [AWS IoT Device Management les quotas de commandes](https://docs.aws.amazon.com/general/latest/gr/iot_device_management.html#commands-limits).
Le tableau suivant indique les états d'exécution et leurs transitions en fonction de la progression de l'exécution.
**État et source de l'exécution des commandes**
| Statut d’exécution de la commande | Initié par un appareil/le cloud ? | Exécution du terminal ? | Transitions de statut autorisées |
| --- | --- | --- | --- |
| CREATED | Cloud | Non | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/iot-remote-command-concepts.html) |
| IN\$1PROGRESS | Appareil | Non | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/iot-remote-command-concepts.html) |
| TIMED\$1OUT | Appareil et cloud | Non | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/iot-remote-command-concepts.html) |
| SUCCEEDED | Appareil | Oui | Non applicable |
| FAILED | Appareil | Oui | Non applicable |
| REJECTED | Appareil | Oui | Non applicable |
Les appareils peuvent publier des mises à jour de statut et de résultats à tout moment à l'aide de commandes réservées aux sujets MQTT. Pour fournir un contexte supplémentaire, les appareils peuvent utiliser `reasonDescription` les champs `reasonCode` et de l'`statusReason`objet.
Le schéma suivant montre les transitions entre les états d'exécution.
![\[Image montrant comment l'état d'exécution d'une commande passe d'un statut à un autre.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/command-execution-status-transitions.png)
**Note**
Lorsqu'aucune réponse de l'appareil n'est AWS IoT détectée dans le délai imparti, il est défini `TIMED_OUT` comme un statut temporaire autorisant les nouvelles tentatives et les changements d'état. Si votre appareil le signale explicitement`TIMED_OUT`, cela devient un statut de terminal sans autre transition. Pour de plus amples informations, veuillez consulter [Exécutions de commandes non terminales](#iot-command-execution-status-nonterminal).
Les sections suivantes décrivent les exécutions terminales et non terminales ainsi que leurs statuts.
**Topics**
+ [Exécutions de commandes non terminales](#iot-command-execution-status-nonterminal)
+ [Exécutions des commandes du terminal](#iot-command-execution-status-terminal)
### Exécutions de commandes non terminales
Une exécution n'est pas terminale si elle peut accepter les mises à jour des appareils. Les exécutions non terminales sont considérées comme *actives*. Les statuts suivants ne sont pas terminaux :
+
**CRÉÉ**
Lorsque vous lancez une exécution depuis la AWS IoT console ou que vous utilisez l'`StartCommandExecution`API, les demandes réussies changent le statut en`CREATED`. À partir de ce statut, les exécutions peuvent passer à n'importe quel autre statut non terminal ou terminal.
+
**EN\$1COURS**
Après avoir reçu la charge utile, les appareils peuvent commencer à exécuter des instructions et à effectuer des actions spécifiées. Pendant l'exécution, les appareils peuvent publier des réponses à la rubrique de réponse des commandes et mettre à jour l'état sur`IN_PROGRESS`. À partir de`IN_PROGRESS`, les exécutions peuvent passer à n'importe quel statut terminal ou non terminal, à l'exception `CREATED` de.
**Note**
L'`UpdateCommandExecution`API peut être invoquée plusieurs fois avec un `IN_PROGRESS` statut. Spécifiez des détails d'exécution supplémentaires à l'aide de `statusReason` l'objet.
+
**TIMED\$1OUT**
Le cloud et l'appareil peuvent déclencher cet état. Les exécutions `CREATED` ou `IN_PROGRESS` le statut peuvent changer `TIMED_OUT` pour les raisons suivantes :
+ Après avoir envoyé la commande, une minuterie démarre. Si l'appareil ne répond pas dans le délai spécifié, le cloud passe à`TIMED_OUT`. Dans ce cas, l'exécution n'est pas terminale.
+ L'appareil peut remplacer le statut par n'importe quel état du terminal ou signaler un délai d'expiration et régler le statut sur. `TIMED_OUT` Dans ce cas, le statut est conservé`TIMED_OUT`, mais les champs `StatusReason` d'objet changent en fonction des informations de l'appareil. L'exécution devient terminale.
Pour de plus amples informations, veuillez consulter [Valeur du délai d'expiration et statut `TIMED_OUT` d'exécution](iot-remote-command-execution-start-monitor.md#iot-command-execution-timeout-status).
### Exécutions des commandes du terminal
Une exécution devient un terminal lorsqu'elle n'accepte plus les mises à jour des appareils. Les statuts suivants sont terminaux. Les exécutions peuvent passer aux statuts de terminal à partir de n'importe quel statut non terminal :`CREATED`,`IN_PROGRESS`, ou. `TIMED_OUT`
+
**RÉUSSI**
Si l'appareil termine l'exécution avec succès, il peut publier une réponse à la rubrique de réponse des commandes et mettre à jour l'état sur`SUCCEEDED`.
+
**ÉCHEC**
Lorsqu'un appareil ne parvient pas à terminer l'exécution, il peut publier une réponse à la rubrique de réponse des commandes et mettre à jour l'état sur`FAILED`. Utilisez les `reasonDescription` champs `reasonCode` et de l'`statusReason`objet, ou CloudWatch des journaux, pour résoudre les problèmes.
+
**REFUSÉE**
Lorsqu'un appareil reçoit une demande non valide ou incompatible, il peut appeler l'`UpdateCommandExecution`API avec statut`REJECTED`. Utilisez les `reasonDescription` champs `reasonCode` et de l'`statusReason`objet, ou CloudWatch des journaux, pour résoudre les problèmes.
# Workflow de commandes de haut niveau
Ce flux de travail montre comment les appareils interagissent avec AWS IoT Device Management les commandes. Toutes les demandes d'API HTTP utilisent les [informations d'identification Sigv4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) pour la signature.
![\[Vue d'ensemble du flux de travail de haut niveau relatif aux commandes des AWS IoT Device Management appareils.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/device-command-workflow.png)
**Topics**
+ [Création et gestion de commandes](#command-create-command)
+ [Choisissez l'appareil cible pour vos commandes et abonnez-vous aux rubriques MQTT](#command-choose-target)
+ [Démarrez et surveillez les exécutions de commandes pour votre appareil cible](#command-command-executions)
+ [(Facultatif) Activer les notifications pour les événements liés aux commandes](#iot-remote-command-commands-notifications)
## Création et gestion de commandes
Pour créer et gérer des commandes pour vos appareils, effectuez les étapes suivantes.
1.
**Création d'une ressource de commande**
Créez une commande à partir du [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) ou à l'aide de l'[https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html)API.
1.
**Spécifiez la charge utile**
Fournissez une charge utile dans n'importe quel format. Spécifiez le type de contenu pour garantir une interprétation correcte de l'appareil.
Pour les commandes dynamiques avec des modèles de charge utile, la charge utile finale est générée au moment de l'exécution à l'aide des paramètres que vous avez fournis. Les modèles ne prennent en charge que le format JSON, mais la charge utile générée peut être envoyée au format JSON ou CBOR.
1.
**(Facultatif) Gérez les commandes créées**
Mettez à jour le nom d'affichage et la description après la création. Marquez les commandes comme obsolètes lorsqu'elles ne sont plus nécessaires ou supprimez-les définitivement. Pour modifier les informations de charge utile, créez une nouvelle commande.
## Choisissez l'appareil cible pour vos commandes et abonnez-vous aux rubriques MQTT
Choisissez votre appareil cible et configurez les sujets MQTT pour recevoir des commandes et publier des réponses.
1.
**Choisissez l'appareil cible pour votre commande**
Choisissez un équipement cible pour recevoir et exécuter la commande. Utilisez un nom d'objet pour les appareils enregistrés ou un ID client pour les appareils non enregistrés. Pour de plus amples informations, veuillez consulter [Considérations relatives à l'appareil cible](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1.
**Configuration de la politique de AWS IoT l'appareil**
Configurez une politique IAM octroyant des autorisations pour recevoir des exécutions et publier des mises à jour. Voir [Exemple de politique IAM](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-update-policy) pour des exemples de politiques.
1.
**Établir une connexion MQTT**
Connectez les appareils au courtier de messages et abonnez-vous aux rubriques de demande et de réponse. Les appareils ont besoin d'`iot:Connect`une autorisation. Trouvez le point de terminaison de votre plan de données à l'aide de l'`DescribeEndpoint`API ou de la commande `describe-endpoint` CLI :
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
L'exécution de cette commande renvoie le point de terminaison du plan de données spécifique au compte, comme indiqué ci-dessous.
```
account-specific-prefix.iot.region.amazonaws.com
```
1.
**S'abonner aux rubriques relatives aux commandes**
Abonnez-vous à la rubrique des demandes de commandes. Lorsque vous lancez une exécution, le courtier de messages publie la charge utile dans cette rubrique. Votre appareil reçoit et traite la commande.
(Facultatif) Abonnez-vous aux sujets de réponse (`accepted`ou`rejected`) pour recevoir la confirmation si le service cloud a accepté ou rejeté la réponse de l'appareil.
Dans cet exemple, remplacez :
+ *``*avec `thing` ou `client` selon que l'appareil que vous ciblez a été enregistré en tant qu'objet IoT ou spécifié en tant que client MQTT.
+ *``*avec l'identifiant unique de votre appareil cible. Cet identifiant peut être l'identifiant unique du client MQTT ou un nom d'objet.
**Note**
Si le type de charge utile n'est pas JSON ou CBOR, le ** champ n'est peut-être pas présent dans la rubrique de demande de commandes. Pour obtenir le format de charge utile, nous vous recommandons d'obtenir les informations de format MQTT5 à partir des en-têtes de message MQTT. Pour de plus amples informations, veuillez consulter [Rubriques relatives aux commandes](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
$aws/commands///executions/+/response/accepted/
$aws/commands///executions/+/response/rejected/
```
## Démarrez et surveillez les exécutions de commandes pour votre appareil cible
Après avoir créé les commandes et spécifié les cibles de la commande, vous pouvez démarrer l'exécution sur le périphérique cible en effectuant les étapes suivantes.
1.
**Lancer l'exécution de la commande sur le périphérique cible**
Démarrez l'exécution depuis le [hub de commande](https://console.aws.amazon.com/iot/home#/commandHub) ou en utilisant l'`StartCommandExecution`API avec le point de terminaison spécifique à votre compte. À utiliser `iot:Data-ATS` pour une pile double (IPv4/IPv6) ou IPv4 uniquement `iot:Jobs` pour.
L'API publie la charge utile dans la rubrique de demande de commandes.
**Note**
Si le périphérique est hors ligne et utilise des sessions persistantes MQTT, la commande attend le courtier de messages. Lorsque l'appareil se reconnecte avant l'expiration du délai imparti, il peut traiter la commande et publier les résultats. Si le délai expire, l'exécution expire et la charge utile sera supprimée.
1.
**Mettre à jour le résultat de l'exécution de la commande**
L'appareil reçoit la charge utile, traite la commande, exécute les actions spécifiées et publie les résultats dans la rubrique de réponse aux commandes à l'aide d'une API basée sur `UpdateCommandExecution` MQTT. S'il est abonné à des sujets acceptés et rejetés, l'appareil reçoit une confirmation indiquant si le service cloud a accepté ou rejeté la réponse.
Selon ce que vous avez spécifié dans le sujet de la demande, il ** peut s'agir d'objets ou de clients, et il ** peut s'agir du nom de votre AWS IoT objet ou de l'ID du client MQTT.
**Note**
Il ne ** peut s'agir que de JSON ou CBOR dans la rubrique de réponse aux commandes.
```
$aws/commands///executions//response/
```
1.
**(Facultatif) Récupère le résultat de l'exécution de la commande**
Récupérez les résultats de l'exécution depuis AWS IoT la console ou en utilisant`GetCommandExecution`. L'appareil doit publier les résultats dans la rubrique de réponse aux commandes pour obtenir les informations les plus récentes. Consultez des informations supplémentaires, notamment l'heure de la dernière mise à jour, le résultat et l'heure d'achèvement.
## (Facultatif) Activer les notifications pour les événements liés aux commandes
Abonnez-vous aux événements Commands pour recevoir des notifications lorsque le statut d'exécution change. Pour des informations détaillées sur les événements d'exécution de commandes, notamment le format du message d'événement et les attributs de charge utile, consultez[Événements d'exécution de commandes](command-events.md).
1.
**Créer une règle de rubrique**
Abonnez-vous à la rubrique des événements relatifs aux commandes pour recevoir des notifications de changement de statut. Créez une règle thématique pour acheminer les données des appareils vers d'autres AWS IoT services tels AWS Lambda qu'Amazon SQS et AWS Step Functions à l'aide de la AWS IoT console ou. [Création d'une AWS IoT règle](iot-create-rule.md)
Dans cet exemple, remplacez-le `` par l'identifiant de la commande pour laquelle vous souhaitez recevoir des notifications et `` par le statut de l'exécution de la commande.
```
$aws/events/commandExecution//
```
**Note**
Pour recevoir des notifications concernant toutes les commandes et les statuts d'exécution des commandes, vous pouvez utiliser des caractères génériques et vous abonner à la rubrique suivante.
```
$aws/events/commandExecution/+/#
```
1.
**Réception et traitement des événements liés aux commandes**
Gérez les notifications push des commandes et créez des applications à l'aide des événements souscrits.
Le code suivant montre un exemple de charge utile pour les notifications d'événements de commande que vous recevrez.
```
{
"executionId": "2bd65c51-4cfd-49e4-9310-d5cbfdbc8554",
"status":"FAILED",
"statusReason": {
"reasonCode": "DEVICE_TOO_BUSY",
"reasonDescription": ""
},
"eventType": "COMMAND_EXECUTION",
"commandArn":"arn:aws:iot:us-east-1:123456789012:command/0b9d9ddf-e873-43a9-8e2c-9fe004a90086",
"targetArn":"arn:aws:iot:us-east-1:123456789012:thing/5006c3fc-de96-4def-8427-7eee36c6f2bd",
"timestamp":1717708862107
}
```
# Création et gestion de commandes
Utilisez AWS IoT Device Management les commandes pour configurer des actions à distance réutilisables ou pour envoyer des instructions immédiates aux appareils. Créez et gérez des commandes depuis la AWS IoT console ou à l'aide du AWS CLI.
**Topics**
+ [Création d'une ressource de commande](#iot-remote-command-create)
+ [Récupérer les informations relatives à une commande](#iot-remote-command-get)
+ [Répertoriez les commandes dans votre Compte AWS](#iot-remote-command-list)
+ [Mettre à jour une ressource de commande](#iot-remote-command-update)
+ [Dépréciation ou restauration d'une ressource de commande](#iot-remote-command-deprecatecmd)
+ [Supprimer une ressource de commande](#iot-remote-command-delete)
## Création d'une ressource de commande
Fournissez les informations suivantes lors de la création d'une commande :
+
**Informations générales**
Fournissez un ID de commande unique pour identifier la commande lorsque vous l'exécutez sur des machines cibles. Spécifiez éventuellement un nom d'affichage, une description et des balises pour la gestion.
+ **Charge utile**
Pour les commandes statiques, fournissez une charge utile définissant les actions de l'appareil. Spécifiez le type de format de charge utile pour une interprétation correcte de l'appareil.
Pour les commandes dynamiques, consultez l'attribut du modèle de charge utile.
+ **Modèle de charge utile**
Pour les commandes dynamiques, fournissez un PayloadTemplate avec des espaces réservés et des paramètres. Fournissez éventuellement `defaultValue` des conditions. AWS IoT Device Management Les commandes remplacent les espaces réservés lors de l'exécution. Les paramètres manquants utilisent leur DefaultValue. Toutes les valeurs doivent satisfaire à des conditions définies.
Les types d'espaces réservés distinguant majuscules et minuscules suivants sont pris en charge :
+ `${aws:iot:commandexecution::parameter:parameter1}`— Un espace réservé pour la valeur d'un paramètre portant le nom`parameter1`.
+ `${aws:iot:commandexecution::executionTimeoutSec}`— Un espace réservé pour le paramètre de délai d'exécution de la commande fourni lors de l'exécution.
### Sujets relatifs à la charge utile et aux commandes
Commandes réservées Les rubriques utilisent un format basé sur le type de format de charge utile.
+ Pour `application/json` nos types de `application/cbor` contenu, utilisez ce sujet de demande :
```
$aws/commands///executions/+/request/
```
+ Pour d'autres types de contenu ou un format non spécifié, utilisez cette rubrique de demande. Le format Payload apparaît dans l'en-tête du message MQTT.
```
$aws/commands///executions/+/request
```
La rubrique de réponse aux commandes utilise `json` ou met en `cbor` forme quel que soit le type de charge utile. **doit être `json` ou `cbor` :
```
$aws/commands///executions//response/
```
### Création d'une ressource de commande (console)
Les sections suivantes décrivent les considérations relatives au format de charge utile et la création de commandes depuis la console.
**Topics**
+ [Format de charge utile des commandes statiques](#iot-commands-payload-format)
+ [Format de charge utile des commandes dynamiques](#iot-commands-dynamic-payload-format)
+ [Comment créer une commande (console)](#iot-commands-console-how)
#### Format de charge utile des commandes statiques
La charge utile prend en charge tous les formats jusqu'à 32 Ko. Spécifiez le type de format de charge utile pour une interprétation sûre et correcte de l'appareil.
Spécifiez le type de format de charge utile en utilisant le `type/subtype` format (par exemple, `application/json` ou`application/cbor`). Valeur par défaut : `application/octet-stream`. Consultez la section [Types MIME courants](https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types) pour connaître les formats pris en charge.
#### Format de charge utile des commandes dynamiques
Le PayloadTemplate doit être un JSON valide avec au moins un espace réservé, jusqu'à 32 Ko.
Pour le `AwsJsonSubstitution` préprocesseur, AWS IoT Device Management Commands envoie des notifications au format JSON ou CBOR en fonction de la configuration du préprocesseur.
#### Comment créer une commande (console)
Pour créer une commande depuis la console, accédez au [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) et procédez comme suit :
1. Choisissez **Créer une commande**.
1. Spécifiez un ID de commande unique.
1. (Facultatif) Spécifiez le nom d'affichage, la description et les balises.
1. Téléchargez le fichier de charge utile contenant les actions de l'appareil. Spécifiez le type de format de charge utile pour une interprétation correcte de l'appareil.
1. (Facultatif) Pour les modèles de charge utile JSON avec espaces réservés, les paramètres sont préremplis dans le tableau intégré pour être modifiés.
1. (Facultatif) Configurez le type de valeur du paramètre (obligatoire), la valeur par défaut et les conditions.
1. Choisissez **Créer une commande**.
### Création d'une ressource de commande (CLI)
Utilisez l'[https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html)API ou la commande [https://docs.aws.amazon.com/cli/latest/reference/iot/create-command.html](https://docs.aws.amazon.com/cli/latest/reference/iot/create-command.html)CLI pour créer une commande.
**Topics**
+ [Charge utile de commande](#iot-commands-payload)
+ [Exemple de politique IAM](#iot-remote-command-create-iam)
+ [Exemple de création de commande statique](#iot-remote-command-create-example)
+ [Exemple de création de commande dynamique](#iot-remote-dynamic-command-create-example)
#### Charge utile de commande
Fournissez une charge utile ou un modèle de charge utile statique. Les charges utiles statiques sont codées en base64. Pour les modèles de charge utile, la charge utile finale est générée au moment de l'exécution à l'aide de valeurs de paramètres. Les appareils traitent la charge utile et exécutent les actions spécifiées. Spécifiez le type de contenu de charge utile pour une réception correcte de l'appareil.
**Note**
Les charges utiles ne peuvent pas être modifiées après la création de la commande. Créez une nouvelle commande pour modifier la charge utile.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`CreateCommand`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec un identifiant unique pour votre identifiant de AWS IoT commande, tel que`LockDoor`. Si vous souhaitez envoyer plusieurs commandes, vous pouvez les spécifier dans la section *Ressource* de la stratégie IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:CreateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Exemple de création de commande statique
L'exemple suivant montre comment créer une commande statique. En fonction de votre application, remplacez :
+ *``*avec un identifiant unique pour la commande. Par exemple, pour verrouiller la porte de votre maison, vous pouvez spécifier*`LockDoor`*. Nous vous recommandons d'utiliser l'UUID. Vous pouvez également utiliser des caractères alphanumériques, « - » et « \$1 ».
+ (Facultatif) *``* et *``* qui sont des champs facultatifs que vous pouvez utiliser pour fournir un nom convivial et une description significative à la commande, tels que*`Lock the doors of my home`*.
+ `namespace`, que vous pouvez utiliser pour spécifier l'espace de noms de la commande. Ça doit l'être`AWS-IoT`. Pour plus d'informations sur l'utilisation de cette fonctionnalité pour AWS IoT FleetWise, voir [Commandes à distance](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payload`contient des informations sur la charge utile que vous souhaitez utiliser lors de l'exécution de la commande et son type de contenu.
```
aws iot create-command \
--command-id \
--display-name \
--description \
--namespace AWS-IoT \
--payload '{"content":"eyAibWVzc2FnZSI6ICJIZWxsbyBJb1QiIH0=","contentType":"application/json"}'
```
L'exécution de cette commande génère une réponse contenant l'ID et l'ARN (nom de ressource Amazon) de la commande. Par exemple, si vous avez spécifié la `LockDoor` commande lors de sa création, voici un exemple de sortie d'exécution de la commande.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor"
}
```
#### Exemple de création de commande dynamique
L'exemple suivant montre comment créer une commande dynamique. En fonction de votre application, remplacez :
+ *``*avec un identifiant unique pour la commande. Par exemple, pour définir l'état de puissance de la lampe, vous pouvez spécifier*`Light_Power_Status`*. Nous vous recommandons d'utiliser l'UUID. Vous pouvez également utiliser des caractères alphanumériques, « - » et « \$1 ».
+ (Facultatif) *``* et *``* qui sont des champs facultatifs que vous pouvez utiliser pour fournir un nom convivial et une description significative à la commande, tels que*`Turn a light ON or OFF`*.
+ `namespace`, que vous pouvez utiliser pour spécifier l'espace de noms de la commande. Ça doit l'être`AWS-IoT`. Pour plus d'informations sur l'utilisation de cette fonctionnalité pour AWS IoT FleetWise, voir [Commandes à distance](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payloadTemplate`contient le modèle de charge de jeu au format JSON avec des espaces réservés.
+ `preprocessor`contient la configuration du préprocesseur qui détermine la manière dont le PayloadTemplate doit être traité.
+ `mandatoryParameter`contient les paramètres correspondant aux espaces réservés du PayloadTemplate, leur type, leurs valeurs par défaut et leurs conditions.
```
aws iot create-command \
--command-id Light_Power_Status \
--description "Turn a light ON or OFF" \
--namespace AWS-IoT \
--payload-template '{"powerStatus":"${aws:iot:commandexecution::parameter:powerStatus}"}' \
--preprocessor awsJsonSubstitution={outputFormat=JSON} \
--mandatory-parameters "name=powerStatus, defaultValue={S=OFF}, valueConditions=[{comparisonOperator=IN_SET, operand={strings=['ON','OFF']}}]"
```
L'exécution de cette commande génère une réponse contenant l'ID et l'ARN (nom de ressource Amazon) de la commande. Par exemple, si vous avez spécifié la `Light_Power_Status` commande lors de sa création, voici un exemple de sortie d'exécution de la commande.
```
{
"commandId": "Light_Power_Status",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/Light_Power_Status"
}
```
## Récupérer les informations relatives à une commande
Après avoir créé une commande, vous pouvez récupérer des informations la concernant depuis la AWS IoT console et en utilisant le AWS CLI. Vous pouvez obtenir les informations suivantes.
+ L'ID de commande, le nom de la ressource Amazon (ARN), tout nom d'affichage et toute description que vous avez spécifiés pour la commande.
+ L'état de la commande, qui indique si une commande est disponible pour être exécutée sur le périphérique cible, ou si elle est obsolète ou supprimée.
+ La charge utile ou le modèle de charge utile que vous avez fourni.
+ Le préprocesseur que vous avez fourni.
+ Les paramètres obligatoires que vous avez fournis.
+ Heure à laquelle la commande a été créée et mise à jour pour la dernière fois.
### Récupérer une ressource de commande (console)
Pour récupérer une commande depuis la console, accédez au [hub de commande](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console, puis choisissez la commande que vous avez créée pour en afficher les détails.
Outre les détails de la commande, vous pouvez consulter l'historique des commandes, qui fournit des informations sur l'exécution de la commande sur le périphérique cible. Après avoir exécuté cette commande sur l'appareil, vous trouverez des informations sur les exécutions dans cet onglet.
### Récupérer une ressource de commande (CLI)
Utilisez l'opération API du plan de contrôle [https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html)HTTP ou la [https://docs.aws.amazon.com/cli/latest/reference/get-command.html](https://docs.aws.amazon.com/cli/latest/reference/get-command.html) AWS CLI commande pour récupérer des informations sur une ressource de commande. Vous devez déjà avoir créé la commande à l'aide de la demande `CreateCommand` d'API ou de la `create-command` CLI.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`GetCommand`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789023`.
+ `command-id`avec votre identifiant de commande AWS IoT unique, tel que `LockDoor` ou`Light_Power_Status`. Si vous souhaitez récupérer plusieurs commandes, vous pouvez les spécifier dans la section *Ressource* de la politique IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:GetCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Récupérez un exemple de commande (AWS CLI)
L'exemple suivant montre comment récupérer des informations sur une commande à l'aide du `get-command` AWS CLI. En fonction de votre application, *``* remplacez-le par l'identifiant de la commande pour laquelle vous souhaitez récupérer des informations. Vous pouvez obtenir ces informations à partir de la réponse de la `create-command` CLI.
```
aws iot get-command --command-id
```
L'exécution de cette commande génère une réponse contenant des informations sur la commande, la charge utile, ainsi que l'heure à laquelle elle a été créée et mise à jour pour la dernière fois. Il fournit également des informations indiquant si une commande est obsolète ou en cours de suppression.
Par exemple, le code suivant montre un exemple de réponse.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:::command/LockDoor",
"namespace": "AWS-IoT",
"payload":{
"content": "eyAibWVzc2FnZSI6ICJIZWxsbyBJb1QiIH0=",
"contentType": "application/json"
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"lastUpdatedAt": "2024-03-23T00:50:10.095000-07:00",
"deprecated": false,
"pendingDeletion": false
}
```
## Répertoriez les commandes dans votre Compte AWS
Après avoir créé des commandes, vous pouvez consulter celles que vous avez créées dans votre compte. Dans la liste, vous trouverez des informations sur :
+ L'ID de commande et tout nom d'affichage que vous avez spécifié pour les commandes.
+ Le nom de ressource Amazon (ARN) des commandes.
+ État de la commande qui indique si les commandes peuvent être exécutées sur le périphérique cible ou si elles sont obsolètes.
**Note**
La liste des personnes en cours de suppression de votre compte ne s'affiche pas. Si les commandes sont en attente de suppression, vous pouvez toujours consulter les détails de ces commandes à l'aide de leur ID de commande.
+ Heure à laquelle les commandes ont été créées et mises à jour pour la dernière fois.
### Répertorier les commandes de votre compte (console)
Dans la AWS IoT console, vous pouvez trouver la liste des commandes que vous avez créées et leurs détails en accédant au [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub).
### Répertorier les commandes de votre compte (CLI)
Pour répertorier les commandes que vous avez créées, utilisez l'opération [https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html](https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html)API ou la [https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html](https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html)CLI.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`ListCommands`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:ListCommands",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/*"
}
}
```
#### Exemple de liste des commandes dans votre compte
La commande suivante indique comment répertorier les commandes de votre compte.
```
aws iot list-commands --namespace "AWS-IoT"
```
L'exécution de cette commande génère une réponse contenant une liste des commandes que vous avez créées, l'heure à laquelle les commandes ont été créées et la date de leur dernière mise à jour. Il fournit également des informations sur l'état de la commande, qui indiquent si une commande est obsolète ou si elle est disponible pour être exécutée sur le périphérique cible. Pour plus d'informations sur les différents statuts et la raison du statut, consultez[Statut d’exécution de la commande](iot-remote-command-concepts.md#iot-command-execution-status).
## Mettre à jour une ressource de commande
Après avoir créé une commande, vous pouvez mettre à jour le nom d'affichage et la description de la commande.
**Note**
La charge utile de la commande ne peut pas être mise à jour. Pour mettre à jour ces informations ou utiliser une charge utile modifiée, vous devez créer une nouvelle commande.
### Mettre à jour une ressource de commande (console)
Pour mettre à jour une commande depuis la console, accédez au [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez les étapes suivantes.
1. Pour mettre à jour une ressource de commande existante, choisissez la commande que vous souhaitez mettre à jour, puis sous **Actions**, choisissez **Modifier**.
1. Spécifiez le nom d'affichage et la description que vous souhaitez utiliser, ainsi que toutes les paires nom-valeur en tant que balises pour votre commande.
1. Choisissez **Modifier** pour enregistrer la commande avec les nouveaux paramètres.
### Mettre à jour une ressource de commande (CLI)
Utilisez l'opération API du plan de [https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html)contrôle ou le [https://docs.aws.amazon.com/cli/latest/reference/iot/update-command.html](https://docs.aws.amazon.com/cli/latest/reference/iot/update-command.html) AWS CLI pour mettre à jour une ressource de commande. Grâce à cette API, vous pouvez :
+ Modifiez le nom d'affichage et la description d'une commande que vous avez créée.
+ Dépréciez une ressource de commande ou restaurez une commande déjà obsolète.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`UpdateCommand`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec votre identifiant de commande AWS IoT unique, tel que`LockDoor`. Si vous souhaitez récupérer plusieurs commandes, vous pouvez les spécifier dans la section *Ressource* de la politique IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:UpdateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Exemples de mise à jour des informations relatives à une commande (AWS CLI)
L'exemple suivant montre comment mettre à jour les informations relatives à une commande à l'aide de cette `update-command` AWS CLI commande. Pour plus d'informations sur la façon dont vous pouvez utiliser cette API pour déprécier ou restaurer une ressource de commande, consultez. [Mettre à jour une ressource de commande (CLI)](iot-remote-command-deprecate.md#iot-remote-command-deprecate-cli)
L'exemple montre comment mettre à jour le nom d'affichage et la description d'une commande. En fonction de votre application, *``* remplacez-le par l'identifiant de la commande pour laquelle vous souhaitez récupérer des informations.
```
aws iot update-command \
--command-id
--displayname \
--description
```
L'exécution de cette commande génère une réponse contenant les informations mises à jour sur la commande et l'heure de sa dernière mise à jour. Le code suivant montre un exemple de demande et de réponse pour mettre à jour le nom d'affichage et la description d'une commande qui met le courant alternatif hors tension.
```
aws iot update-command \
--command-id \
--displayname \
--description
```
L'exécution de cette commande génère la réponse suivante.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor",
"displayName": "Secondary lock door",
"description": "Locks doors to my home",
"lastUpdatedAt": "2024-05-09T23:15:53.899000-07:00"
}
```
## Dépréciation ou restauration d'une ressource de commande
Après avoir créé une commande, si vous ne souhaitez plus continuer à l'utiliser, vous pouvez la marquer comme obsolète. Lorsque vous désapprouvez une commande, toutes les exécutions de commandes en attente continuent de s'exécuter sur le périphérique cible jusqu'à ce qu'elles atteignent le statut de terminal. Une fois qu'une commande est devenue obsolète, si vous souhaitez l'utiliser, par exemple pour envoyer une nouvelle exécution de commande à la machine cible, vous devez la restaurer.
**Note**
Vous ne pouvez pas modifier une commande obsolète, ni exécuter de nouvelles exécutions pour celle-ci. Pour exécuter de nouvelles commandes sur l'appareil, vous devez le restaurer afin que l'état de la commande passe à *Disponible*.
Pour plus d'informations sur la dépréciation et la restauration d'une commande, ainsi que sur les considérations associées, consultez. [Obsolescence d’une ressource de commande](iot-remote-command-deprecate.md)
## Supprimer une ressource de commande
Si vous ne souhaitez plus utiliser une commande, vous pouvez la supprimer définitivement de votre compte. Si l'action de suppression est réussie :
+ Si la commande est devenue obsolète pendant une durée supérieure au délai maximum de 12 heures, elle sera immédiatement supprimée.
+ Si la commande n'est pas obsolète, ou si elle l'a été pendant une durée inférieure au délai maximum, la commande sera dans un état. `pending deletion` Il sera automatiquement supprimé de votre compte après le délai maximum de 12 heures.
**Note**
La commande peut être supprimée même si des exécutions de commandes sont en attente. La commande sera en attente de suppression et sera automatiquement supprimée de votre compte.
### Supprimer une ressource de commande (console)
Pour supprimer une commande de la console, accédez au [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez les étapes suivantes.
1. Choisissez la commande que vous souhaitez supprimer, puis sous **Actions**, choisissez **Supprimer**.
1. Confirmez que vous souhaitez supprimer la commande, puis choisissez **Supprimer**.
La commande sera marquée pour suppression et sera définitivement supprimée de votre compte au bout de 12 heures.
### Supprimer une ressource de commande (CLI)
Utilisez l'opération API du plan de contrôle `DeleteCommand` HTTP ou la `delete-command` AWS CLI commande pour supprimer une ressource de commande. Si l'action de suppression aboutit, vous verrez un HTTP `statusCode` 204 ou 202, et la commande sera automatiquement supprimée de votre compte après le délai d'expiration maximal de 12 heures. Dans le cas du statut 204, cela indique que la commande a été supprimée.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`DeleteCommand`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec votre identifiant de commande AWS IoT unique, tel que`LockDoor`. Si vous souhaitez récupérer plusieurs commandes, vous pouvez les spécifier dans la section *Ressource* de la politique IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:DeleteCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Exemple de suppression d'une commande (AWS CLI)
Les exemples suivants montrent comment supprimer une commande à l'aide de cette `delete-command` AWS CLI commande. En fonction de votre application, *``* remplacez-le par l'identifiant de la commande que vous supprimez.
```
aws iot delete-command --command-id
```
Si la demande d'API aboutit, la commande génère un code d'état 202 ou 204. Vous pouvez utiliser l'`GetCommand`API pour vérifier que la commande n'existe plus dans votre compte.
# Démarrage et surveillance des exécutions de commandes
Après avoir créé une commande, lancez une exécution sur le périphérique cible. L'appareil met à jour les résultats et publie le statut dans les rubriques réservées au MQTT. Récupérez et surveillez l'état d'exécution depuis votre compte.
Démarrez et surveillez les commandes à l'aide de AWS IoT la console ou AWS CLI.
**Topics**
+ [Lancer l'exécution d'une commande](#iot-remote-command-execution-start)
+ [Mise à jour du résultat de l’exécution d’une commande](#iot-remote-command-execution-update)
+ [Récupérer l'exécution d'une commande](#iot-remote-command-execution-get)
+ [Affichage des mises à jour des commandes à l'aide du client de test MQTT](#iot-remote-command-execution-update-mqtt)
+ [Répertoriez les exécutions de commandes dans votre Compte AWS](#iot-remote-command-execution-list)
+ [Supprimer l'exécution d'une commande](#iot-remote-command-execution-delete)
## Lancer l'exécution d'une commande
**Important**
Vous êtes seul responsable du déploiement des commandes d'une manière sûre et conforme aux lois applicables.
Avant de commencer une exécution, assurez-vous que :
+ Vous avez créé une commande dans l'espace de AWS IoT noms avec des informations de charge utile. Au démarrage de l'exécution, l'appareil traite les instructions de charge utile et exécute les actions spécifiées. Voir [Création d'une ressource de commande](iot-remote-command-create-manage.md#iot-remote-command-create) pour la création de commandes.
+ Votre appareil s'est abonné aux rubriques réservées aux commandes du MQTT. Au démarrage de l'exécution, les informations de charge utile sont publiées sur cette requête MQTT réservée. Rubrique :
**peuvent être des clients Things ou MQTT. **est le nom de l'objet ou l'ID client. **Valeurs prises en charge : JSON et CBOR. Pour de plus amples informations, veuillez consulter [Rubriques relatives aux commandes](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
```
Pour les applications autres que JSON/CBOR**, utilisez ce format de rubrique de commandes :
```
$aws/commands///executions/+/request
```
### Considérations relatives à l'appareil cible
Spécifiez le périphérique cible qui recevra et exécutera la commande. Utilisez un nom d'objet pour les appareils enregistrés ou un identifiant client pour les appareils non enregistrés. Après avoir reçu la charge utile, l'appareil exécute la commande et exécute les actions spécifiées.
#### AWS IoT chose
Les appareils cibles peuvent être des objets enregistrés dans le AWS IoT registre. Cela simplifie la recherche et la gestion des appareils.
Enregistrez les appareils en tant qu'objets depuis la [page Connect device](https://console.aws.amazon.com/iot/home#/connect-overview) ou en utilisant [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html). Trouvez des objets existants depuis [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) ou en utilisant [https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html). Voir [Gérer les choses avec le registre](https://docs.aws.amazon.com/iot/latest/developerguide/thing-registry) pour les détails de l'enregistrement.
#### ID de client
Pour les appareils non enregistrés, utilisez l'ID client.
L'ID client est un identifiant unique que vous attribuez aux appareils. Défini dans le protocole MQTT, il contient des caractères alphanumériques, des traits de soulignement ou des tirets. Chaque appareil connecté AWS IoT a besoin d'un identifiant client unique.
**Note**
Pour les objets enregistrés, l'ID client peut correspondre au nom de l'objet.
Lorsque vous ciblez un ID client spécifique, les appareils doivent se connecter à AWS IoT l'aide de cet ID client pour recevoir la charge utile.
L'ID client est l'ID client MQTT que les appareils utilisent pour se connecter à AWS IoT Core. AWS IoT utilise cet identifiant pour identifier les appareils et gérer les connexions et les abonnements.
### Considérations relatives au délai d'exécution des commandes
Le délai d'expiration indique la durée (en secondes) pendant laquelle les appareils fournissent les résultats d'exécution.
Après avoir créé une exécution, un chronomètre démarre. Si l'appareil se déconnecte ou ne communique pas les résultats dans le délai imparti, le délai d'exécution expire avec le statut`TIMED_OUT`.
Par défaut : 10 secondes. Maximum : 12 heures
#### Valeur du délai d'expiration et statut `TIMED_OUT` d'exécution
Le cloud et l'appareil peuvent signaler un délai d'expiration.
Après avoir envoyé la commande, un chronomètre démarre. Si aucune réponse de l'appareil n'arrive dans le délai imparti, le cloud définit le statut d'exécution sur `TIMED_OUT` avec le code `$NO_RESPONSE_FROM_DEVICE` de raison.
Cela se produit lorsque :
+ L'appareil s'est déconnecté pendant l'exécution.
+ Le périphérique n'a pas réussi à terminer l'exécution dans le délai imparti.
+ L'appareil n'a pas pu signaler l'état dans le délai imparti.
Dans ce cas, lorsque l'état d'exécution de `TIMED_OUT` est signalé depuis le cloud, l'exécution de la commande n'est pas terminale. Votre appareil peut publier une réponse qui remplace le statut par l'un des états du terminal :`SUCCEEDED`,`FAILED`, ou. `REJECTED` L'exécution de la commande devient alors un terminal et n'accepte aucune autre mise à jour.
Votre appareil peut également mettre à jour un `TIMED_OUT` état initié par le cloud en signalant qu'un délai d'attente s'est produit lors de l'exécution de la commande. Dans ce cas, l'état d'exécution de la commande reste `TIMED_OUT` activé, mais l'`statusReason`objet est mis à jour en fonction des informations communiquées par le périphérique. L'exécution de la commande devient alors terminale et aucune autre mise à jour n'est acceptée.
#### Utilisation de sessions persistantes MQTT
Vous pouvez configurer des sessions persistantes MQTT à utiliser avec la fonction de AWS IoT Device Management commandes. Cette fonctionnalité est particulièrement utile lorsque votre appareil est hors ligne et que vous voulez vous assurer que l'appareil reçoit toujours la commande lorsqu'il revient en ligne avant le délai d'expiration, et qu'il exécute les instructions spécifiées.
Par défaut, l’expiration de la session persistante MQTT est définie sur 60 minutes. Si le délai d'exécution de vos commandes est configuré sur une valeur supérieure à cette durée, les exécutions de commandes de plus de 60 minutes peuvent être rejetées par le courtier de messages et échouer. Pour exécuter des commandes d’une durée supérieure à 60 minutes, vous pouvez demander une augmentation de la durée d’expiration de la session persistante.
**Note**
Pour vous assurer que vous utilisez correctement la fonctionnalité de sessions persistantes MQTT, réglez l'indicateur Clean Start sur zéro. Pour plus d’informations, consultez [Sessions persistantes MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html#mqtt-persistent-sessions).
### Lancer l'exécution d'une commande (console)
Pour commencer à exécuter la commande depuis la console, rendez-vous sur la page [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez les étapes suivantes.
1. Pour exécuter la commande que vous avez créée, choisissez **Exécuter la commande**.
1. Passez en revue les informations relatives à la commande que vous avez créée, y compris les rubriques réservées au MQTT et les paramètres, le cas échéant.
Pour les commandes dynamiques, entrez les valeurs des paramètres ou conservez-les par défaut. Pour les paramètres qui n'ont pas de valeur par défaut, vous devez fournir une valeur à envoyer dans le cadre de cette exécution.
1. Spécifiez le périphérique cible qui recevra et exécutera la commande. L'appareil peut être spécifié comme n'importe AWS IoT quel objet s'il a été enregistré AWS IoT, ou en utilisant l'ID client si votre appareil n'a pas encore été enregistré. Pour de plus amples informations, consultez [Considérations relatives à l'appareil cible](#iot-command-execution-target).
1. (Facultatif) Configurez une valeur de délai d'expiration pour la commande qui détermine la durée pendant laquelle vous souhaitez que la commande s'exécute avant son expiration. Si votre commande doit s'exécuter pendant plus de 60 minutes, vous devrez peut-être augmenter le délai d'expiration des sessions persistantes MQTT. Pour de plus amples informations, veuillez consulter [Considérations relatives au délai d'exécution des commandes](#iot-command-execution-timeout).
1. Sélectionnez **Run Command (Exécuter la commande)**.
### Lancer l'exécution d'une commande (AWS CLI)
Utilisez l'opération d'API du plan de données [https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html)HTTP pour démarrer l'exécution d'une commande. La demande et la réponse de l'API sont corrélées par l'ID d'exécution de la commande. Une fois que l'appareil a terminé d'exécuter la commande, il peut signaler l'état et le résultat de l'exécution au cloud en publiant un message dans la rubrique de réponse aux commandes. Pour un code de réponse personnalisé, les codes d'application que vous possédez peuvent traiter le message de réponse et publier le résultat sur AWS IoT.
Si vos appareils se sont abonnés à la rubrique de demande de commandes, l'`StartCommandExecution`API publiera le message de charge utile dans cette rubrique. La charge utile peut utiliser n'importe quel format de votre choix. Pour de plus amples informations, veuillez consulter [Charge utile de commande](iot-remote-command-create-manage.md#iot-commands-payload).
```
$aws/commands///executions/+/request/
```
Si le format de charge utile n'est pas JSON ou CBOR, le tableau suivant indique le format de la rubrique de demande de commandes.
```
$aws/commands///executions/+/request
```
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`StartCommandExecution`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec un identifiant unique pour votre AWS IoT commande, tel que`LockDoor`. Si vous souhaitez envoyer plusieurs commandes, vous pouvez les spécifier dans la politique IAM.
+ `devices`avec l'un `thing` ou l'autre ou `client` selon que vos appareils ont été enregistrés en tant qu' AWS IoT objets ou sont spécifiés en tant que clients MQTT.
+ `device-id`avec votre AWS IoT `thing-name` or`client-id`.
```
{
"Effect": "Allow",
"Action": [
"iot:StartCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
Pour consulter la liste des clés de condition prises en charge`StartCommandExecution`, consultez la section [Clés de condition pour AWS IoT](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-policy-keys) dans le *guide de l'utilisateur IAM*.
#### Obtenir le point de terminaison du plan de données spécifique au compte
Avant d'exécuter la commande API, vous devez obtenir l'URL du point de terminaison spécifique au compte pour le point de terminaison. Si vous utilisez des points de terminaison à double pile (IPv4et IPv6), utilisez le. `iot:Data-ATS` Le `iot:Jobs` point de terminaison est destiné IPv4 uniquement. Par exemple, si vous exécutez la commande suivante :
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Il renvoie l'URL du point de terminaison spécifique au compte, comme indiqué dans l'exemple de réponse ci-dessous.
```
{
"endpointAddress":
"-ats.iot..api.com"
}
```
#### Démarrer un exemple d'exécution de commande (AWS CLI)
L'exemple suivant montre comment démarrer l'exécution d'une commande à l'aide de cette `start-command-execution` AWS CLI commande.
Dans cet exemple, remplacez :
+ *``*avec l'ARN de la commande que vous souhaitez exécuter. Vous pouvez obtenir ces informations à partir de la réponse de la commande `create-command` CLI. Par exemple, si vous exécutez la commande pour changer le mode volant, utilisez`arn:aws:iot:region:account-id:command/SetComfortSteeringMode`.
+ *``*avec le Thing ARN de l'appareil cible, qui peut être un objet IoT ou un client MQTT, pour lequel vous souhaitez exécuter la commande. Par exemple, si vous exécutez la commande pour le périphérique cible`myRegisteredThing`, utilisez`arn:aws:iot:region:account-id:thing/myRegisteredThing`.
+ *``*avec le point de terminaison spécifique au compte dans lequel vous l'avez obtenu[Obtenir le point de terminaison du plan de données spécifique au compte](#iot-remote-command-execution-start-endpoint), préfixé par. `https://` Par exemple, `https://123456789012abcd.jobs.iot.us-east-1.amazonaws.com`.
+ (Facultatif) Vous pouvez également spécifier un paramètre supplémentaire lors de l'exécution de l'opération `StartCommandExecution` d'API. `executionTimeoutSeconds` Ce champ facultatif indique le délai en secondes pendant lequel le périphérique doit terminer l'exécution de la commande. Par défaut, la valeur est de 10 secondes. Lorsque le statut d'exécution de la commande est `CREATED` défini, un temporisateur démarre. Si le résultat de l'exécution de la commande n'est pas reçu avant l'expiration du délai, le statut passe automatiquement à`TIMED_OUT`.
+
```
aws iot-jobs-data start-command-execution \
--command-arn \
--target-arn \
--endpoint \
--execution-timeout-seconds 900
```
+ (Facultatif) Pour les commandes dynamiques, spécifiez les paramètres et leurs valeurs à utiliser pour la substitution. Vous devez fournir une valeur pour les paramètres pour lesquels aucune DefaultValue n'est définie lors de la création de la commande. Si un paramètre possède une DefaultValue, la valeur du paramètre fournie ici est prioritaire. Pour les paramètres pour lesquels ValueConditions est définie, la valeur du paramètre fournie ici doit satisfaire à la condition.
Sur la base d'`Light_Power_Status`un exemple de commande dynamique :
+
```
aws iot-jobs-data start-command-execution \
--command-arn arn:aws:iot:us-east-1:123456789012:command/Light_Power_Status \
--target-arn arn:aws:iot:us-east-1:123456789012:thing/exampleThing \
--endpoint \
--execution-timeout-seconds 900 \
--parameters "powerStatus={S=ON}"
```
L'exécution de cette commande renvoie un ID d'exécution de commande. Vous pouvez utiliser cet ID pour demander le statut, les détails et l'historique de l'exécution des commandes.
**Note**
Si la commande est obsolète, la demande d'`StartCommandExecution`API échouera avec une exception de validation. Pour corriger cette erreur, restaurez d'abord la commande à l'aide de l'`UpdateCommand`API, puis exécutez la `StartCommandExecution` demande.
```
{
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542"
}
```
## Mise à jour du résultat de l’exécution d’une commande
Utilisez l'opération d'API du plan de données `UpdateCommandExecution` MQTT pour mettre à jour le statut ou le résultat d'une exécution de commande.
**Note**
Avant d'utiliser cette API :
Votre appareil doit avoir établi une connexion MQTT et être abonné aux rubriques de demande et de réponse des commandes. Pour de plus amples informations, veuillez consulter [Workflow de commandes de haut niveau](iot-remote-command-workflow.md).
Vous devez déjà avoir exécuté cette commande à l'aide de l'opération `StartCommandExecution` API.
### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM autorise votre appareil à effectuer ces actions. Vous trouverez ci-dessous un exemple de politique qui autorise votre appareil à effectuer cette action. Pour d'autres exemples de politiques IAM autorisant l'utilisateur à effectuer l'action `UpdateCommandExecution` MQTT, consultez. [Exemples de stratégies de connexion et de publication](connect-and-pub.md)
Dans cet exemple, remplacez :
+ `Region`avec votre Région AWS, par exemple`us-east-1`.
+ `AccountID`avec votre Compte AWS numéro, par exemple*`123456789012`*.
+ `ThingName`avec le nom de l' AWS IoT objet pour lequel vous ciblez l'exécution de la commande, par exemple*`myRegisteredThing`*.
+ `commands-request-topic`et `commands-response-topic` avec les noms des sujets de demande et de réponse de vos AWS IoT commandes. Pour de plus amples informations, veuillez consulter [Workflow de commandes de haut niveau](iot-remote-command-workflow.md).
#### Exemple de politique IAM pour l'ID client MQTT
Le code suivant montre un exemple de politique de périphérique lors de l'utilisation de l'ID client MQTT.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/request",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/request/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/request",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/request/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/${iot:ClientId}"
}
]
}
```
#### Exemple de politique IAM pour l'IoT
Le code suivant montre un exemple de politique en matière d'appareil lors de l'utilisation d'un AWS IoT objet.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": "arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response"
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/request",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/request/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/request",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/request/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/${iot:ClientId}"
}
]
}
```
### Comment utiliser l'`UpdateCommandExecution`API
Une fois que l'exécution de la commande est reçue sur le sujet de la demande, le dispositif traite la commande. Il utilise ensuite l'`UpdateCommandExecution`API pour mettre à jour l'état et le résultat de l'exécution de la commande en fonction de la rubrique de réponse suivante.
```
$aws/commands///executions//response/
```
Dans cet exemple, *``* il s'agit de l'identifiant unique de votre équipement cible et *``* de l'identifiant de l'exécution de la commande sur le périphérique cible. Il ** peut s'agir de JSON ou de CBOR.
**Note**
Si vous n'avez pas enregistré votre appareil AWS IoT, vous pouvez utiliser l'identifiant client comme identifiant au lieu d'un nom d'objet.
```
$aws/commands/clients//executions//response/
```
#### L'appareil a signalé des mises à jour de l'état d'exécution
Vos appareils peuvent utiliser l'API pour signaler l'une des mises à jour de statut suivantes lors de l'exécution de la commande. Pour plus d'informations sur ces statuts, consultez[Statut d’exécution de la commande](iot-remote-command-concepts.md#iot-command-execution-status).
+ `IN_PROGRESS`: Lorsque l'appareil commence à exécuter la commande, il peut mettre à jour l'état à`IN_PROGRESS`.
+ `SUCCEEDED`: Lorsque l'appareil traite avec succès la commande et termine son exécution, il peut publier un message dans le sujet de réponse sous le nom de`SUCCEEDED`.
+ `FAILED`: Si l'appareil n'a pas réussi à exécuter la commande, il peut publier un message dans le sujet de réponse sous le nom`FAILED`.
+ `REJECTED`: Si l'appareil n'accepte pas la commande, il peut publier un message dans le sujet de réponse en tant que`REJECTED`.
+ `TIMED_OUT`: L'état d'exécution de la commande peut changer pour `TIMED_OUT` l'une des raisons suivantes.
+ Le résultat de l'exécution de la commande n'a pas été reçu. Cela peut se produire parce que l'exécution n'a pas été terminée dans le délai spécifié ou si l'appareil n'a pas publié les informations d'état dans le sujet de réponse.
+ L'appareil signale qu'un délai d'attente s'est produit lors de la tentative d'exécution de la commande.
Pour plus d'informations sur le `TIMED_OUT` statut, consultez[Valeur du délai d'expiration et statut `TIMED_OUT` d'exécution](#iot-command-execution-timeout-status).
#### Considérations relatives à l'utilisation de l'`UpdateCommandExecution`API
Voici quelques points importants à prendre en compte lors de l'utilisation de l'`UpdateCommandExecution`API.
+ Vos appareils peuvent utiliser un `statusReason` objet facultatif pour fournir des informations supplémentaires sur l'exécution. Si vos appareils fournissent cet objet, le `reasonCode` champ de l'objet est obligatoire, mais le `reasonDescription` champ est facultatif.
+ Lorsque vos appareils utilisent l'`statusReason`objet, ils `reasonCode` doivent utiliser le modèle `[A-Z0-9_-]+` et ne pas dépasser 64 caractères. Si vous fournissez le`reasonDescription`, assurez-vous qu'il ne dépasse pas 1 024 caractères. Il peut utiliser n'importe quel caractère à l'exception des caractères de contrôle tels que les nouvelles lignes.
+ Vos appareils peuvent utiliser un `result` objet facultatif pour fournir des informations sur le résultat de l'exécution de la commande, telles que la valeur de retour d'un appel de fonction à distance. Si vous le fournissez`result`, il doit nécessiter au moins une entrée.
+ Dans le `result` champ, vous spécifiez les entrées sous forme de paires clé-valeur. Pour chaque entrée, vous devez spécifier les informations de type de données sous forme de chaîne, de booléen ou de binaire. Un type de données chaîne doit utiliser la clé`s`, un type de données booléen utilise la clé `b` et un type de données binaire doit utiliser la clé. `bin` Assurez-vous que ces touches sont en minuscules.
+ Si vous rencontrez une erreur lors de l'exécution de l'`UpdateCommandExecution`API, vous pouvez consulter l'erreur dans le groupe de `AWSIoTLogsV2` journaux d'Amazon CloudWatch. Pour plus d'informations sur l'activation de la journalisation et l'affichage des journaux, consultez[Configuration de la AWS IoT journalisation](configure-logging.md).
#### `UpdateCommandExecution`Exemple d'API
Le code suivant montre comment votre appareil peut utiliser l'`UpdateCommandExecution`API pour signaler l'état d'exécution, le `statusReason` champ pour fournir des informations supplémentaires sur l'état et le champ de résultat pour fournir des informations sur le résultat de l'exécution, comme le pourcentage de batterie de la voiture dans ce cas.
```
{
"status": "IN_PROGRESS",
"statusReason": {
"reasonCode": "200",
"reasonDescription": "Execution_in_progress"
},
"result": {
"car_battery": {
"s": "car battery at 50 percent"
}
}
}
```
## Récupérer l'exécution d'une commande
Après avoir exécuté une commande, vous pouvez récupérer des informations sur l'exécution de la commande à partir de la AWS IoT console et à l'aide du AWS CLI. Vous pouvez obtenir les informations suivantes.
**Note**
Pour récupérer le dernier statut d'exécution des commandes, votre appareil doit publier les informations d'état dans la rubrique de réponse à l'aide de l'API `UpdateCommandExecution` MQTT, comme décrit ci-dessous. Jusqu'à ce que l'appareil publie sur cette rubrique, l'`GetCommandExecution`API signalera l'état sous la forme `CREATED` ou`TIMED_OUT`.
Chaque exécution de commande que vous créez a :
+ Un **ID d’exécution**, qui est l’identifiant unique d’exécution de la commande.
+ Le **statut** de l’exécution de la commande. Lorsque vous exécutez la commande sur l’appareil cible, elle passe à l’état `CREATED`. EIle peut ensuite passer à d’autres statuts d’exécution de commande, comme décrit ci-dessous.
+ Le **résultat** de l'exécution de la commande.
+ L’**ID de commande** unique et l’appareil cible pour lequel les exécutions ont été créées.
+ La **Date de début**, qui indique l’heure à laquelle l’exécution de la commande a été créée.
### Récupérer une exécution de commande (console)
Vous pouvez récupérer une exécution de commande depuis la console à l'aide de l'une des méthodes suivantes.
+
**Depuis la page Command Hub**
Accédez à la page [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez ces étapes.
1. Choisissez la commande pour laquelle vous avez créé une exécution sur le périphérique cible.
1. Sur la page des détails des commandes, sous l'onglet **Historique des commandes**, vous pouvez voir les exécutions que vous avez créées. Choisissez l'exécution pour laquelle vous souhaitez récupérer des informations.
1. Si vos appareils ont utilisé l'`UpdateCommandExecution`API pour fournir les informations relatives aux résultats, vous pouvez les trouver dans l'onglet **Résultats** de cette page.
+
**Depuis la page du hub Thing**
Si vous avez choisi un AWS IoT objet comme équipement cible lors de l'exécution de la commande, vous pouvez consulter les détails de l'exécution sur la page du hub d'objets.
1. Accédez à la page [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT console et choisissez l'objet pour lequel vous avez créé l'exécution de la commande.
1. Dans la page des détails de l'objet, dans **l'historique des commandes**, vous pouvez voir les exécutions que vous avez créées. Choisissez l'exécution pour laquelle vous souhaitez récupérer des informations.
1. Si vos appareils ont utilisé l'`UpdateCommandExecution`API pour fournir les informations relatives aux résultats, vous pouvez les trouver dans l'onglet **Résultats** de cette page.
### Récupérer une exécution de commande (CLI)
Utilisez l'opération d'API HTTP du plan de [https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommandExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommandExecution.html) AWS IoT Core contrôle pour récupérer les informations relatives à l'exécution d'une commande. Vous devez déjà avoir exécuté cette commande à l'aide de l'opération `StartCommandExecution` API.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`GetCommandExecution`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec votre identifiant de AWS IoT commande unique, tel que`LockDoor`.
+ `devices`avec l'un `thing` ou l'autre ou `client` selon que vos appareils ont été enregistrés en tant qu' AWS IoT objets ou sont spécifiés en tant que clients MQTT.
+ `device-id`avec votre AWS IoT `thing-name` or`client-id`.
```
{
"Effect": "Allow",
"Action": [
"iot:GetCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
#### Récupérer un exemple d'exécution de commande
L'exemple suivant montre comment récupérer des informations sur une commande exécutée à l'aide de cette `start-command-execution` AWS CLI commande. L'exemple suivant montre comment récupérer des informations sur une commande exécutée pour désactiver le mode volant.
Dans cet exemple, remplacez :
+ *``*avec l'identifiant de l'exécution de la commande pour laquelle vous souhaitez récupérer des informations.
+ *``*avec le numéro de ressource Amazon (ARN) de l'appareil pour lequel vous ciblez l'exécution. Vous pouvez obtenir ces informations à partir de la réponse de la commande `start-command-execution` CLI.
+ Facultativement, si vos appareils ont utilisé l'`UpdateCommandExection`API pour fournir le résultat de l'exécution, vous pouvez spécifier s'il convient d'inclure le résultat de l'exécution de la commande dans la réponse de l'`GetCommandExecution`API à l'aide de l'`GetCommandExecution`API.
```
aws iot get-command-execution
--execution-id \
--target-arn \
--include-result
```
L'exécution de cette commande génère une réponse contenant des informations sur l'ARN de l'exécution de la commande, son état d'exécution, ainsi que l'heure à laquelle elle a commencé à s'exécuter et à laquelle elle s'est terminée. Il fournit également un `statusReason` objet contenant des informations supplémentaires sur le statut. Pour plus d'informations sur les différents statuts et la raison du statut, consultez[Statut d’exécution de la commande](iot-remote-command-concepts.md#iot-command-execution-status).
Le code suivant montre un exemple de réponse à la demande d'API.
**Note**
Le `completedAt` champ de la réponse d'exécution correspond au moment où l'appareil signale l'état du terminal au cloud. En cas d'`TIMED_OUT`état, ce champ ne sera défini que lorsque l'appareil signalera un délai d'expiration. Lorsque le `TIMED_OUT` statut est défini par le cloud, il n'est pas mis à jour. `TIMED_OUT` Pour plus d'informations sur le comportement en cas de temporisation, consultez[Considérations relatives au délai d'exécution des commandes](#iot-command-execution-timeout).
```
{
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/myRegisteredThing",
"status": "SUCCEEDED",
"statusReason": {
"reasonCode": "DEVICE_SUCCESSFULLY_EXECUTED",
"reasonDescription": "SUCCESS"
},
"result": {
"sn": { "s": "ABC-001" },
"digital": { "b": true }
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"completedAt": "2024-03-23T00:50:10.095000-07:00"
}
```
## Affichage des mises à jour des commandes à l'aide du client de test MQTT
Vous pouvez utiliser le client de test MQTT pour visualiser l'échange de messages via MQTT lorsque vous utilisez la fonction de commandes. Une fois que votre appareil a établi une connexion MQTT avec AWS IoT, vous pouvez créer une commande, spécifier la charge utile, puis l'exécuter sur l'appareil. Lorsque vous exécutez la commande, si votre appareil est abonné à la rubrique des requêtes réservées MQTT pour les commandes, il voit le message de charge utile publié dans cette rubrique.
Le dispositif reçoit ensuite les instructions de charge utile et exécute les opérations spécifiées sur le AWS IoT dispositif. Il utilise ensuite l'`UpdateCommandExecution`API pour publier le résultat de l'exécution des commandes et les informations d'état dans les rubriques de réponse réservées aux commandes du MQTT. AWS IoT Device Management écoute les mises à jour sur les sujets de réponse, stocke les informations mises à jour et publie des journaux sur Amazon AWS CloudTrail et sur Amazon CloudWatch. Vous pouvez ensuite récupérer les dernières informations d'exécution des commandes depuis la console ou à l'aide de l'`GetCommandExecution`API.
Les étapes suivantes montrent comment utiliser le client de test MQTT pour observer les messages.
1. Ouvrez le [client de test MQTT](https://console.aws.amazon.com/iot/home#/test) dans la AWS IoT console.
1. Dans l'onglet **S'abonner**, entrez le sujet suivant, puis choisissez **S'abonner**, où se ** trouve le nom de l'appareil avec lequel vous vous êtes enregistré AWS IoT.
**Note**
Vous trouverez le nom de votre appareil sur la page [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT console. Si vous n'avez pas enregistré votre appareil en tant qu'objet, vous pouvez l'enregistrer lors de la connexion AWS IoT depuis la [page Connect device](https://console.aws.amazon.com/iot/home#/connect-overview).
```
$aws/commands/things//executions/+/request
```
1. (Facultatif) Dans l'onglet **S'abonner**, vous pouvez également saisir les sujets suivants et choisir **S'abonner**.
```
$aws/commands/things/+/executions/+/response/accepted/json
$aws/commands/things/+/executions/+/response/rejected/json
```
1. Lorsque vous lancez l'exécution d'une commande, la charge utile du message est envoyée à l'appareil en utilisant le sujet de demande auquel l'appareil s'est abonné,`$aws/commands/things//executions/+/request`. Dans le client de test MQTT, vous devriez voir la charge utile de commande contenant les instructions permettant au périphérique de traiter la commande.
1. Une fois que le périphérique a commencé à exécuter la commande, il peut publier des mises à jour de statut dans la rubrique de réponse réservée MQTT suivante pour les commandes.
```
$aws/commands///executions//response/json
```
Par exemple, considérez une commande que vous avez exécutée pour allumer le climatiseur de votre voiture afin de réduire la température à la valeur souhaitée. Le JSON suivant montre un exemple de message publié par le véhicule dans le sujet de réponse qui indique qu'il n'a pas réussi à exécuter la commande.
```
{
"deviceId": "My_Car",
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542",
"status": "FAILED",
"statusReason": {
"reasonCode": "CAR_LOW_ON_BATTERY",
"reasonDescription": "Car battery is lower than 5 percent"
}
}
```
Dans ce cas, vous pouvez charger la batterie de votre voiture, puis exécuter à nouveau la commande.
## Répertoriez les exécutions de commandes dans votre Compte AWS
Après avoir exécuté une commande, vous pouvez récupérer des informations sur l'exécution de la commande à partir de la AWS IoT console et à l'aide du AWS CLI. Vous pouvez obtenir les informations suivantes.
+ Un **ID d’exécution**, qui est l’identifiant unique d’exécution de la commande.
+ Le **statut** de l’exécution de la commande. Lorsque vous exécutez la commande sur l’appareil cible, elle passe à l’état `CREATED`. EIle peut ensuite passer à d’autres statuts d’exécution de commande, comme décrit ci-dessous.
+ L’**ID de commande** unique et l’appareil cible pour lequel les exécutions ont été créées.
+ La **Date de début**, qui indique l’heure à laquelle l’exécution de la commande a été créée.
### Répertorier les exécutions de commandes dans votre compte (console)
Vous pouvez voir toutes les exécutions de commandes depuis la console à l'aide de l'une des méthodes suivantes.
+
**Depuis la page Command Hub**
Accédez à la page [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez ces étapes.
1. Choisissez la commande pour laquelle vous avez créé une exécution sur le périphérique cible.
1. Sur la page des détails de la **commande, accédez à l'onglet Historique** des commandes et vous verrez la liste des exécutions que vous avez créées.
+
**Depuis la page du hub Thing**
Si vous avez choisi un AWS IoT objet comme équipement cible lors de l'exécution de la commande et que vous avez créé plusieurs exécutions de commandes pour un seul appareil, vous pouvez consulter les exécutions de cet appareil sur la page du hub d'objets.
1. Accédez à la page [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT console et choisissez l'objet pour lequel vous avez créé les exécutions.
1. Sur la page des détails de l'objet, dans **l'historique des commandes**, vous pouvez voir la liste des exécutions que vous avez créées pour l'appareil.
### Répertorier les exécutions de commandes dans votre compte (CLI)
Utilisez l'opération d'API HTTP du plan de [https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommandExecutions.html](https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommandExecutions.html) AWS IoT Core contrôle pour répertorier toutes les exécutions de commandes dans votre compte.
#### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM vous autorise à effectuer cette action sur l'appareil. L'exemple suivant montre une politique IAM qui autorise l'utilisateur à effectuer l'`ListCommandExecutions`action.
Dans cet exemple, remplacez :
+ `region`avec votre Région AWS, par exemple`us-east-1`.
+ `account-id`avec votre Compte AWS numéro, par exemple`123456789012`.
+ `command-id`avec votre identifiant de AWS IoT commande unique, tel que`LockDoor`.
```
{
"Effect": "Allow",
"Action": "iot:ListCommandExecutions",
"Resource": *
}
```
#### Exemple d'exécution de commandes de liste
L'exemple suivant vous montre comment répertorier les exécutions de commandes dans votre Compte AWS.
Lorsque vous exécutez la commande, vous devez spécifier s'il faut filtrer la liste pour afficher uniquement les exécutions de commandes créées pour un appareil particulier à l'aide de`targetArn`, ou les exécutions pour une commande spécifique spécifiée à l'aide du`commandArn`.
Dans cet exemple, remplacez :
+ *``*avec le numéro de ressource Amazon (ARN) de l'appareil pour lequel vous ciblez l'exécution, tel que`arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`.
+ *``*avec le numéro de ressource Amazon (ARN) de l'appareil pour lequel vous ciblez l'exécution, tel que`arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`.
+ *``*avec le délai après lequel vous souhaitez répertorier les exécutions créées, par exemple,`2024-11-01T03:00`.
```
aws iot list-command-executions \
--target-arn \
--started-time-filter '{after=}' \
--sort-order "ASCENDING"
```
L'exécution de cette commande génère une réponse qui contient une liste des exécutions de commandes que vous avez créées, ainsi que l'heure à laquelle les exécutions ont commencé à s'exécuter et à laquelle elles se sont terminées. Il fournit également des informations sur le statut, ainsi que l'`statusReason`objet qui contient des informations supplémentaires sur le statut.
```
{
"commandExecutions": [
{
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/TestMe002",
"executionId": "b2b654ca-1a71-427f-9669-e74ae9d92d24",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f",
"status": "TIMED_OUT",
"createdAt": "2024-11-24T14:39:25.791000-08:00",
"startedAt": "2024-11-24T14:39:25.791000-08:00"
},
{
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/TestMe002",
"executionId": "34bf015f-ef0f-4453-acd0-9cca2d42a48f",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f",
"status": "IN_PROGRESS",
"createdAt": "2024-11-24T14:05:36.021000-08:00",
"startedAt": "2024-11-24T14:05:36.021000-08:00"
}
]
}
```
Pour plus d'informations sur les différents statuts et la raison du statut, consultez[Statut d’exécution de la commande](iot-remote-command-concepts.md#iot-command-execution-status).
## Supprimer l'exécution d'une commande
Si vous ne souhaitez plus utiliser l'exécution d'une commande, vous pouvez la supprimer définitivement de votre compte.
**Note**
L'exécution d'une commande ne peut être supprimée que si elle est entrée dans un statut de terminal`SUCCEEDED`, tel que`FAILED`, ou`REJECTED`.
Cette opération ne peut être effectuée qu'à l'aide de l' AWS IoT Core API ou du AWS CLI. Il n'est pas disponible depuis la console.
### Exemple de politique IAM
Avant d'utiliser cette opération d'API, assurez-vous que votre politique IAM autorise votre appareil à effectuer ces actions. Vous trouverez ci-dessous un exemple de politique qui autorise votre appareil à effectuer cette action.
Dans cet exemple, remplacez :
+ `Region`avec votre Région AWS, par exemple`us-east-1`.
+ `AccountID`avec votre Compte AWS numéro, par exemple*`123456789012`*.
+ `CommandID`avec l'identifiant de la commande dont vous souhaitez supprimer l'exécution.
+ `devices`avec l'un `thing` ou l'autre ou `client` selon que vos appareils ont été enregistrés en tant qu' AWS IoT objets ou sont spécifiés en tant que clients MQTT.
+ `device-id`avec votre AWS IoT `thing-name` or`client-id`.
```
{
"Effect": "Allow",
"Action": [
"iot:DeleteCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
### Supprimer un exemple d'exécution de commande
L'exemple suivant montre comment supprimer une commande à l'aide de cette `delete-command` AWS CLI commande. En fonction de votre application, remplacez-le *``* par l'identifiant de l'exécution de la commande que vous supprimez, puis *``* par l'ARN de votre appareil cible.
```
aws iot delete-command-execution \
--execution-id \
--target-arn
```
Si la demande d'API aboutit, l'exécution de la commande génère un code d'état de 200. Vous pouvez utiliser l'`GetCommandExecution`API pour vérifier que l'exécution de la commande n'existe plus dans votre compte.
# Obsolescence d’une ressource de commande
Dépréciez les commandes pour indiquer qu'elles sont périmées et ne doivent pas être utilisées. Par exemple, dépréciez les commandes qui ne sont plus maintenues activement ou lorsque vous créez de nouvelles commandes avec le même identifiant mais des charges utiles différentes.
## Considérations clés
Considérations importantes à prendre en compte lors de la dépréciation de commandes :
+ La dépréciation d'une commande ne la supprime pas. Vous pouvez récupérer la commande à l'aide de son identifiant et la restaurer pour la réutiliser.
+ Toute tentative de lancement de nouvelles exécutions sur des commandes obsolètes génère une erreur, empêchant ainsi l'utilisation de commandes obsolètes.
+ Pour exécuter une commande obsolète, restaurez-la d'abord. Après restauration, la commande devient disponible pour une utilisation et une exécution régulières sur les appareils cibles.
+ Si vous désapprouvez une commande alors que son exécution est en cours, elle continue de s'exécuter jusqu'à la fin. Vous pouvez toujours récupérer le statut d'exécution.
## Déprécier une ressource de commande (console)
Pour désactiver une commande depuis la console, accédez au [hub de commande](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console et effectuez les étapes suivantes.
1. **Choisissez la commande que vous souhaitez déprécier, puis sous **Actions**, choisissez Déprécier.**
1. **Confirmez que vous souhaitez déprécier la commande, puis choisissez Déprécier.**
## Déprécier une ressource de commande (CLI)
Marquez les commandes comme obsolètes à l'aide de la CLI`update-command`. Vous devez déprécier une commande avant de la supprimer. Pour utiliser une commande obsolète, restaurez-la d'abord.
```
aws iot update-command \
--command-id \
--deprecated
```
Par exemple, si vous avez déconseillé la `ACSwitch` commande que vous avez mise à jour dans l'exemple ci-dessus, le code suivant montre un exemple de sortie de l'exécution de la commande.
```
{
"commandId": "turnOffAc",
"deprecated": true,
"lastUpdatedAt": "2024-05-09T23:16:51.370000-07:00"
}
```
## Vérifiez l'heure et le statut de la dépréciation
Utilisez l'`GetCommand`API pour déterminer si une commande est obsolète et quand elle l'a été pour la dernière fois.
```
aws iot get-command --command-id
```
Cette commande génère une réponse contenant des informations de commande, notamment les horodatages de création et de dépréciation à partir du dernier champ mis à jour. Cela permet de déterminer la durée de vie des commandes et de déterminer s'il faut les supprimer ou les réutiliser. Voici un exemple de réponse à la `turnOffAc` commande :
```
{
"commandId": "turnOffAC",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/turnOffAC",
"namespace": "AWS-IoT",
"payload": {
"content": "testPayload.json",
"contentType": "application/json"
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"lastUpdatedAt": "2024-05-09T23:16:51.370000-07:00",
"deprecated": false
}
```
## Restaurer une ressource de commande
Pour utiliser ou envoyer la `ACSwitch` commande sur votre appareil, restaurez-la d'abord.
Pour restaurer une commande depuis la console, accédez au [hub de commande](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT console, choisissez la commande que vous souhaitez restaurer, puis sous **Actions**, choisissez **Restaurer**.
Pour restaurer une commande à l'aide de l' AWS IoT Core API ou du AWS CLI, utilisez l'opération `UpdateCommand` API ou la `update-command` CLI. Le code suivant montre un exemple de demande et de réponse.
```
aws iot update-command \
--command-id
--no-deprecated
```
Le code suivant montre un exemple de sortie.
```
{
"commandId": "ACSwitch",
"deprecated": false,
"lastUpdatedAt": "2024-05-09T23:17:21.954000-07:00"
}
```