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.
# Conservation de l'état de l'appareil lorsque celui-ci est hors ligne avec Device Shadows
Ces didacticiels vous montrent comment utiliser le service AWS IoT Device Shadow pour stocker et mettre à jour les informations d'état d'un appareil. Le document Shadow, qui est un document JSON, montre la modification de l'état de l'appareil en fonction des messages publiés par un appareil, une application locale ou un service. Dans ce didacticiel, le document Shadow montre le changement de couleur d'une ampoule. Ces didacticiels montrent également comment le shadow stocke ces informations même lorsque l'appareil est déconnecté d'Internet, et transmet les dernières informations d'état à l'appareil lorsqu'il revient en ligne et demande ces informations.
Nous vous recommandons d'essayer ces didacticiels dans l'ordre dans lequel ils sont présentés ici, en commençant par les AWS IoT ressources dont vous avez besoin pour créer et la configuration matérielle nécessaire, ce qui vous permet également d'apprendre les concepts progressivement. Ces didacticiels montrent comment configurer et connecter un appareil Raspberry Pi à utiliser avec AWS IoT. Si vous ne disposez pas du matériel requis, vous pouvez suivre ces didacticiels en les adaptant à l'appareil de votre choix ou en [créant un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md).
**Présentation des scénarios du didacticiel**
Le scénario de ces didacticiels est une application ou un service local qui modifie la couleur d'une ampoule et publie ses données sur des sujets d'ombre réservés. Ces didacticiels sont similaires à la fonctionnalité Device Shadow décrite dans le [didacticiel de démarrage interactif](interactive-demo.md) et sont implémentés sur un appareil Raspberry Pi. Les didacticiels de cette section se concentrent sur une seule ombre classique tout en montrant comment vous pouvez adapter des ombres nommées ou plusieurs appareils.
Les didacticiels suivants vous aideront à apprendre à utiliser le service AWS IoT Device Shadow.
+
**[Tutoriel : Préparation de votre Raspberry Pi pour exécuter l'application fantôme](create-resources-shadow.md)**
Ce didacticiel explique comment configurer un appareil Raspberry Pi pour se connecter à AWS IoT. Vous allez également créer un document de AWS IoT stratégie et une ressource d'objet, télécharger les certificats, puis associer la politique à cette ressource d'objet. Ce didacticiel vous prendra environ 30 minutes.
+
**[Tutoriel : Installation du SDK du périphérique et exécution de l'exemple d'application pour Device Shadows](lightbulb-shadow-application.md)**
Ce didacticiel explique comment installer les outils et logiciels requis, ainsi que le SDK AWS IoT Device pour Python, puis exécuter l'exemple d'application Shadow. Ce didacticiel s'appuie sur les concepts présentés dans le document [Connectez un Raspberry Pi ou un autre appareil](connecting-to-existing-device.md) et dure 20 minutes.
+
**[Tutoriel : Interaction avec Device Shadow à l'aide de l'exemple d'application et du client de test MQTT](interact-lights-device-shadows.md)**
Ce didacticiel explique comment utiliser les `shadow.py` exemples d'application et de **AWS IoT console** pour observer l'interaction entre AWS IoT Device Shadows et les changements d'état de l'ampoule. Le didacticiel montre également comment envoyer des messages MQTT aux rubriques réservées du Device Shadow. Ce didacticiel vous prendra environ 45 minutes.
**AWS IoT Présentation de Device Shadow**
Un Device Shadow est une représentation virtuelle persistante d'un appareil géré par une [ressource d'objets](iot-thing-management.md) que vous créez dans le AWS IoT registre. Le document Shadow est un document JSON ou un document de JavaScript notation utilisé pour stocker et récupérer les informations d'état actuel d'un appareil. Vous pouvez utiliser l'ombre pour obtenir et définir l'état d'un appareil via des sujets MQTT ou HTTP REST APIs, que l'appareil soit connecté à Internet ou non.
Vous pouvez utiliser l'ombre pour obtenir et définir l'état d'un appareil via des sujets MQTT ou des API HTTP REST, que l'appareil soit ou non connecté à l'internet.
+ Les applications spécifient les états souhaités des propriétés de l'appareil en mettant à jour `desired` l'objet.
+ `reported` : Les appareils rapportent leur état actuel dans `reported` l'objet .
+ `delta`: AWS IoT indique les différences entre l'état souhaité et l'état indiqué dans l'`delta`objet.
Voici un exemple de document de l'État fantôme.
```
{
"state": {
"desired": {
"color": "green"
},
"reported": {
"color": "blue"
},
"delta": {
"color": "green"
}
}
}
```
Pour mettre à jour le document Shadow d'un appareil, vous pouvez utiliser les [rubriques MQTT réservées](reserved-topics.md#reserved-topics-shadow), le [Device Shadow REST APIs](device-shadow-rest-api.md) qui prend en charge le `GET``UPDATE`, et les `DELETE` opérations avec HTTP, ainsi que la [AWS IoT CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot-data/index.html).
Dans l'exemple précédent, supposons que vous souhaitiez changer la `desired` couleur en`yellow`. Pour ce faire, envoyez une demande à l'[UpdateThingShadow](device-shadow-rest-api.md#API_UpdateThingShadow)API ou publiez un message dans la rubrique [Mise à jour](device-shadow-mqtt.md#update-pub-sub-topic), `$aws/things/THING_NAME/shadow/update`.
```
{
"state": {
"desired": {
"color": yellow
}
}
}
```
Les mises à jour concernent uniquement les champs spécifiés dans la demande. Après avoir correctement mis à jour le Device Shadow, le nouvel `desired` état est AWS IoT publié dans la `delta` rubrique`$aws/things/THING_NAME/shadow/delta`. Dans ce cas, le document Shadow ressemble à ceci :
```
{
"state": {
"desired": {
"color": yellow
},
"reported": {
"color": green
},
"delta": {
"color": yellow
}
}
}
```
Le nouvel état est ensuite signalé au AWS IoT Device Shadow en utilisant le `Update` sujet `$aws/things/THING_NAME/shadow/update` avec le message JSON suivant :
```
{
"state": {
"reported": {
"color": yellow
}
}
}
```
Si vous souhaitez obtenir les informations sur l'état actuel, envoyez une demande à l'[GetThingShadow](device-shadow-rest-api.md#API_GetThingShadow)API ou publiez un message MQTT dans la rubrique [Get](device-shadow-mqtt.md#get-pub-sub-topic),`$aws/things/THING_NAME/shadow/get`.
Pour plus d'informations, consultez Service d'ombre de périphérique dans le [AWS IoT Service Device Shadow](iot-device-shadows.md).
Pour plus d'informations sur l'utilisation de Device Shadows dans les appareils, les applications et les services, consultez [Utilisation des shadows sur les appareils](device-shadow-comms-device.md) et [Utilisation des shadows dans les applications et les services](device-shadow-comms-app.md).
Pour plus d'informations sur l'interaction avec AWS IoT les ombres, voir[Interaction avec les shadows](device-shadow-data-flow.md).
Pour plus d'informations sur les sujets réservés MQTT et HTTP REST APIs, consultez [Rubriques MQTT de Device Shadow](device-shadow-mqtt.md) et[API REST Device Shadow](device-shadow-rest-api.md).
# Tutoriel : Préparation de votre Raspberry Pi pour exécuter l'application fantôme
Ce didacticiel explique comment installer et configurer un appareil Raspberry Pi et comment créer les AWS IoT ressources dont un appareil a besoin pour se connecter et échanger des messages MQTT.
**Note**
Si vous avez l'intention de [Création d'un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md), vous pouvez ignorer cette page et passer à [Configurer votre appareil](configure-device.md). Vous créerez ces ressources lorsque vous créerez votre objet virtuel. Si vous souhaitez utiliser un autre appareil à la place du Raspberry Pi, vous pouvez essayer de suivre ces tutoriels en les adaptant à l'appareil de votre choix.
**Dans ce didacticiel, vous allez découvrir comment :**
+ Installez un appareil Raspberry Pi et configurez-le pour une utilisation avec AWS IoT.
+ Créez un document AWS IoT de politique qui autorise votre appareil à interagir avec les AWS IoT services.
+ Créez une ressource d'objet dans AWS IoT les certificats de périphérique X.509, puis joignez le document de politique.
Le truc, c'est la représentation virtuelle de votre appareil dans le AWS IoT registre. Le certificat authentifie votre appareil auprès de AWS IoT Core, et le document de politique autorise l'interaction avec votre appareil. AWS IoT
**Comment exécuter ce didacticiel**
Pour exécuter l'`shadow.py`exemple d'application pour Device Shadows, vous aurez besoin d'un appareil Raspberry Pi connecté à AWS IoT. Nous vous recommandons de suivre ce didacticiel dans l'ordre dans lequel il est présenté ici, en commençant par configurer le Raspberry Pi et ses accessoires, puis en créant une politique et en l'attachant à une ressource d'objet que vous créez. Vous pouvez ensuite suivre ce didacticiel en utilisant l'interface utilisateur graphique (GUI) prise en charge par le Raspberry Pi pour ouvrir la AWS IoT console sur le navigateur Web de l'appareil, ce qui facilite également le téléchargement des certificats directement sur votre Raspberry Pi pour vous y connecter AWS IoT.
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+ Un Compte AWS. Si vous n'en avez pas, effectuez les étapes décrites dans [Configurez Compte AWS](setting-up.md) avant de continuer. Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
+ Le Raspberry Pi et ses accessoires nécessaires. Vous aurez besoin de :
+ Un [Raspberry Pi 3 modèle B](https://www.raspberrypi.com/products/) ou un modèle plus récent. Ce tutoriel peut fonctionner sur des versions antérieures du Raspberry Pi, mais nous ne l'avons pas testé.
+ Système d'[exploitation Raspberry Pi (32 bits)](https://www.raspberrypi.com/software/operating-systems/) ou version ultérieure. Nous vous recommandons d'utiliser la dernière version du système d'exploitation Raspberry Pi. Les versions antérieures du système d'exploitation peuvent fonctionner, mais nous ne les avons pas testées.
+ Une connexion Ethernet ou Wi-Fi.
+ Clavier, souris, écran, câbles et blocs d'alimentation.
Ce didacticiel vous prendra environ 30 minutes.
## Étape 1 : Installation et configuration de l'appareil Raspberry Pi
Dans cette section, nous allons configurer un appareil Raspberry Pi à utiliser avec AWS IoT.
**Important**
L'adaptation de ces instructions à d'autres appareils et systèmes d'exploitation peut s'avérer difficile. Vous devez avoir une connaissance suffisante de votre appareil pour être en mesure d'interpréter ces instructions et de les appliquer. Si vous rencontrez des difficultés, vous pouvez essayer l'une des autres options de l'appareil comme alternative, telle que [Création d'un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md) ou[Utilisez votre PC ou Mac Windows ou Linux comme AWS IoT appareil](using-laptop-as-device.md).
Vous devez configurer votre Raspberry Pi de manière à ce qu'il puisse démarrer le système d'exploitation (OS), se connecter à Internet et vous permettre d'interagir avec lui via une interface en ligne de commande. Vous pouvez également utiliser l'interface utilisateur graphique (GUI) compatible avec le Raspberry Pi pour ouvrir la AWS IoT console et exécuter le reste de ce didacticiel.
**Pour configurer le Raspberry Pi**
1. Insérez la carte SD dans le port MicroSD dans le Raspberry Pi. Certaines cartes SD sont préchargées avec un gestionnaire d'installation qui vous invite dans un menu à installer le système d'exploitation après le démarrage de la carte. Vous pouvez également utiliser l'imageur Raspberry Pi pour installer le système d'exploitation sur votre carte.
1. Connectez un téléviseur ou un moniteur HDMI au câble HDMI qui se connecte au port HDMI du Raspberry Pi.
1. Connectez le clavier et la souris aux ports USB du Raspberry Pi, puis branchez l'adaptateur secteur pour démarrer la carte.
Après le démarrage du Raspberry Pi, si la carte SD a été préchargée avec le gestionnaire d'installation, un menu apparaît pour installer le système d'exploitation. Si vous rencontrez des difficultés lors de l'installation du système d'exploitation, vous pouvez essayez de suivre la procédure ci-dessous. Pour plus d'informations sur la configuration de votre Raspberry Pi, consultez le [Guide de démarrage Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/).
**Si vous ne parvenez pas à configurer le Raspberry Pi :**
+ Vérifiez si vous avez inséré la carte SD avant de démarrer la carte. Si vous branchez la carte SD après avoir démarré la carte, le menu d'installation risque de ne pas apparaître.
+ Assurez-vous que le téléviseur ou le moniteur est allumé et que l'entrée correcte est sélectionnée.
+ Assurez-vous que vous utilisez un logiciel compatible avec le Raspberry Pi.
Après avoir installé et configuré le système d'exploitation Raspberry Pi, ouvrez le navigateur Web du Raspberry Pi et accédez à la AWS IoT Core console pour poursuivre les étapes suivantes de ce didacticiel.
Si vous pouvez ouvrir la AWS IoT Core console, votre Raspberry Pi est prêt et vous pouvez continuer[Tutoriel : provisionnement de votre appareil dans AWS IoT](shadow-provision-cloud.md).
Si vous rencontrez des problèmes ou avez besoin d'une aide supplémentaire, consultez [Obtenir de l'aide pour votre Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/5).
# Tutoriel : provisionnement de votre appareil dans AWS IoT
Cette section crée les AWS IoT Core ressources que votre didacticiel utilisera.
**Topics**
+ [Étape 1 : créer une AWS IoT politique pour le Device Shadow](#create-policy-shadow)
+ [Étape 2 : créer une ressource d'objet et associer la politique à l'objet](#create-thing-shadow)
+ [Étape 3 : examen des résultats et des étapes suivantes](#resources-shadow-review)
## Étape 1 : créer une AWS IoT politique pour le Device Shadow
Les certificats X.509 authentifient votre appareil avec. AWS IoT Core AWS IoT des politiques sont associées au certificat qui permettent à l'appareil d'effectuer AWS IoT des opérations, telles que l'abonnement ou la publication de sujets réservés au MQTT utilisés par le service Device Shadow. Votre appareil présente son certificat lorsqu'il se connecte et envoie des messages à AWS IoT Core.
Dans cette procédure, vous allez créer une politique qui permet à votre appareil d'effectuer les AWS IoT opérations nécessaires pour exécuter le programme d'exemple. Nous vous recommandons de créer une politique qui n'accorde que les autorisations nécessaires à l'exécution de la tâche. Vous créez d'abord la AWS IoT politique, puis vous l'associez au certificat de terminal que vous créerez ultérieurement.
**Pour créer une AWS IoT politique**
1. Dans le panneau de navigation, choisissez **Sécurité**, puis **Stratégies**. Si des politiques existent déjà dans votre compte, choisissez **Créer**, sinon, sur la page **Vous n'avez pas encore de politique**, choisissez **Créer une politique**.
1. Sur la page **Create a policy (Créer une politique)** :
1. Dans le champ **Nom** entrez un nom pour la politique (par exemple, **My\$1Device\$1Shadow\$1policy**). N'utilisez pas d'informations personnelles identifiables dans vos noms de stratégie.
1. Dans le document de politique, vous décrivez les actions de connexion, d'abonnement, de réception et de publication qui donnent à l'appareil l'autorisation de publier et de s'abonner aux sujets réservés au MQTT.
Copiez l'exemple de politique suivant et collez-le dans votre document de politique. Remplacez-le `thingname` par le nom de l'objet que vous allez créer (par exemple,`My_light_bulb`), `region` par la AWS IoT région dans laquelle vous utilisez les services et `account` par votre Compte AWS numéro. Pour plus d'informations sur AWS IoT les politiques, consultez[AWS IoT Core politiques](iot-policies.md).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/test-*"
}
]
}
```
## Étape 2 : créer une ressource d'objet et associer la politique à l'objet
Les appareils connectés à AWS IoT peuvent être représentés par *des ressources* d'objets dans le AWS IoT registre. Une *ressource d'objet* représente un périphérique ou une entité logique spécifique, comme l'ampoule dans ce didacticiel.
Pour savoir comment créer un objet dans AWS IoT, suivez les étapes décrites dans[Créez un objet](create-iot-resources.md#create-aws-thing). Voici quelques points essentiels à noter lorsque vous suivez les étapes de ce didacticiel :
1. Choisissez **Créer un objet unique**, puis dans le champ **Nom**, entrez un nom pour l'objet identique à celui `thingname` (par exemple`My_light_bulb`) que vous avez spécifié lors de la création de la politique précédemment.
Il n'est pas possible de modifier le nom d'une chose après sa création. Si vous lui avez donné un autre nom que `thingname`, créez un nouvel objet avec le nom as `thingname` et supprimez l'ancien.
**Note**
N'utilisez pas d'informations personnellement identifiables dans votre nom de domaine. Le nom de l'objet peut apparaître dans les communications et les rapports non chiffrés.
1. Nous vous recommandons de télécharger chacun des fichiers de certificat figurant sur le **certificat créé \$1** page vers un endroit où vous pouvez facilement les trouver. Vous devez installer ces fichiers pour exécuter l'exemple d'application.
Nous vous recommandons de télécharger les fichiers dans un `certs` sous-répertoire de votre `home` répertoire sur le Raspberry Pi et de nommer chacun d'eux avec un nom plus simple, comme suggéré dans le tableau suivant.
**Noms des fichiers de certificat**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/shadow-provision-cloud.html)
1. Après avoir activé le certificat pour autoriser les connexions AWS IoT, choisissez **Attacher une politique** et assurez-vous d'associer la politique que vous avez créée précédemment (par exemple,**My\$1Device\$1Shadow\$1policy**) à l'objet.
Une fois que vous avez créé un objet, vous pouvez voir sa ressource s'afficher dans la liste des objets de la AWS IoT console.
## Étape 3 : examen des résultats et des étapes suivantes
**Dans ce didacticiel, vous allez découvrir comment :**
+ Installation et configuration de l'appareil Raspberry Pi.
+ Créez un document AWS IoT de politique qui autorise votre appareil à interagir avec les AWS IoT services.
+ Créez une ressource d'objet et le certificat de périphérique X.509 associé, puis joignez-y le document de politique.
**Étapes suivantes**
Vous pouvez désormais installer le SDK du AWS IoT périphérique pour Python, exécuter l'`shadow.py`exemple d'application et utiliser Device Shadows pour contrôler l'état. Pour de plus amples informations sur sa configuration, veuillez consulter [Tutoriel : Installation du SDK du périphérique et exécution de l'exemple d'application pour Device Shadows](lightbulb-shadow-application.md).
# Tutoriel : Installation du SDK du périphérique et exécution de l'exemple d'application pour Device Shadows
Cette section explique comment installer le logiciel requis et le SDK AWS IoT Device pour Python et exécuter l'`shadow.py`exemple d'application pour modifier le document Shadow et contrôler l'état de l'ombre.
**Dans ce didacticiel, vous allez découvrir comment :**
+ Utilisez le logiciel installé et le SDK AWS IoT Device pour Python pour exécuter l'exemple d'application.
+ Découvrez comment la saisie d'une valeur à l'aide de l'exemple d'application permet de publier la valeur souhaitée dans la AWS IoT console.
+ Passez en revue l'`shadow.py`exemple d'application et découvrez comment elle utilise le protocole MQTT pour mettre à jour l'état de l'ombre.
**Avant de lancer ce didacticiel :**
Vous devez avoir configuré votre Compte AWS appareil Raspberry Pi, et créé un AWS IoT élément et une politique qui donnent à l'appareil l'autorisation de publier et de s'abonner aux sujets réservés MQTT du service Device Shadow. Pour de plus amples informations, veuillez consulter [Tutoriel : Préparation de votre Raspberry Pi pour exécuter l'application fantôme](create-resources-shadow.md).
Vous devez également avoir installé Git, Python et le AWS IoT Device SDK pour Python. Ce didacticiel s'appuie sur les concepts présentés dans le didacticiel[Connectez un Raspberry Pi ou un autre appareil](connecting-to-existing-device.md). Si vous n'avez pas essayé ce didacticiel, nous vous recommandons de suivre les étapes décrites dans ce didacticiel pour installer les fichiers de certificat et le SDK du périphérique, puis de revenir à ce didacticiel pour exécuter l'`shadow.py`exemple d'application.
**Topics**
+ [Étape 1 : Exécutez l'exemple d'application shadow.py](#run-sample-application-shadows)
+ [Étape 2 : passez en revue l'exemple d'application shadow.py Device SDK](#review-shadow-sample-code)
+ [Étape 3 : résolution des problèmes liés à l'`shadow.py`exemple d'application](#shadow-sample-app-troubleshoot)
+ [Étape 4 : examen des résultats et des étapes suivantes](#sample-app-shadow-review)
Ce didacticiel vous prendra environ 20 minutes.
## Étape 1 : Exécutez l'exemple d'application shadow.py
Avant d'exécuter l'`shadow.py`exemple d'application, vous aurez besoin des informations suivantes, en plus des noms et de l'emplacement des fichiers de certificats que vous avez installés.
**Valeurs des paramètres de l'application**
| Paramètre | Où trouver la valeur |
| --- | --- |
| your-iot-thing-name | Nom de l' AWS IoT objet que vous avez créé plus tôt dans[Étape 2 : créer une ressource d'objet et associer la politique à l'objet](shadow-provision-cloud.md#create-thing-shadow). Pour trouver cette valeur, dans la [AWS IoT console](https://console.aws.amazon.com/iot/home), choisissez **Gérer**, puis **Objets**. |
| your-iot-endpoint | La *your-iot-endpoint* valeur a le format suivant :`endpoint_id-ats.iot.region.amazonaws.com`, par exemple,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`. Utilisez pour trouver cette valeur. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/lightbulb-shadow-application.html) |
**Installez et exécutez l'exemple d'application**
1. Accédez au répertoire de l’exemple d’application.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
```
1. Dans la fenêtre de ligne de commande, remplacez *your-iot-endpoint* et *your-iot-thing-name* comme indiqué et exécutez cette commande.
```
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
1. Notez que l'exemple d'application :
1. Se connecte au service AWS IoT associé à votre compte.
1. S'abonne aux `Delta` événements et `Update` et `Get` aux réponses.
1. Vous invite à saisir la valeur souhaitée dans le terminal.
1. Affiche une sortie similaire à celle-ci :
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow contains reported value 'off'.
Enter desired value:
```
**Note**
Si vous ne parvenez pas à exécuter l'`shadow.py`exemple d'application, consultez[Étape 3 : résolution des problèmes liés à l'`shadow.py`exemple d'application](#shadow-sample-app-troubleshoot). Pour obtenir des informations supplémentaires susceptibles de vous aider à corriger le problème, ajoutez le `--verbosity debug` paramètre sur la ligne de commande afin que l'exemple d'application affiche des messages détaillés sur ce qu'elle fait.
**Entrez des valeurs et observez les mises à jour dans le document Shadow**
Vous pouvez entrer des valeurs dans le terminal pour spécifier la `desired` valeur, qui met également à jour la `reported` valeur. Supposons que vous saisissiez la couleur `yellow` dans le terminal. La `reported` valeur est également mise à jour en fonction de la couleur`yellow`. Les messages affichés dans le terminal sont les suivants :
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Lorsque vous publiez cette demande de mise à jour, elle AWS IoT crée une ombre classique par défaut pour la ressource objet. Vous pouvez observer la demande de mise à jour que vous avez publiée sur `desired` les valeurs `reported` et de la AWS IoT console en consultant le document Shadow correspondant à la ressource d'objet que vous avez créée (par exemple,`My_light_bulb`). Pour voir la mise à jour dans le document Shadow :
1. Dans la AWS IoT console, choisissez **Gérer**, puis **Objets**.
1. Dans la liste des éléments affichés, sélectionnez l'objet que vous avez créé, choisissez **Ombre**, puis **Ombre classic**.
Le document Shadow doit ressembler à ce qui suit, avec les `desired` valeurs `reported` et définies en fonction de la couleur`yellow`. Vous pouvez voir ces valeurs dans la section **Shadow state** du document.
```
{
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
}
```
Vous pouvez également voir une section de **métadonnées** qui contient les informations d'horodatage et le numéro de version de la demande.
Vous pouvez utiliser la version du document d'état pour vous assurer que vous mettez à jour la version la plus récente du document d'ombre d'un appareil. Si vous envoyez une autre demande de mise à jour, le numéro de version augmente de 1. Lorsque vous fournissez une version avec une demande de mise à jour, le service rejette la demande avec un code de réponse de conflit HTTP 409 si la version actuelle du document d'état ne correspond pas à la version fournie.
```
{
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
}
},
"version": 10
}
```
Pour en savoir plus sur le document Shadow et observer les modifications apportées aux informations d'état, passez au didacticiel suivant, [Tutoriel : Interaction avec Device Shadow à l'aide de l'exemple d'application et du client de test MQTT](interact-lights-device-shadows.md) comme décrit dans la [Étape 4 : examen des résultats et des étapes suivantes](#sample-app-shadow-review) section de ce didacticiel. Vous pouvez éventuellement en apprendre davantage sur l'`shadow.py`exemple de code et sur la façon dont il utilise le protocole MQTT dans la section suivante.
## Étape 2 : passez en revue l'exemple d'application shadow.py Device SDK
Cette section passe en revue l'`shadow.py`exemple d'application du **AWS IoT Device SDK v2 pour Python** utilisé dans ce didacticiel. Ici, nous allons voir comment il se connecte à l'aide AWS IoT Core des protocoles MQTT et MQTT over WSS. La bibliothèque [AWS Common Runtime (AWS-CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) fournit le support des protocoles de communication de bas niveau et est incluse dans le AWS IoT Device SDK v2 pour Python.
Bien que ce didacticiel utilise MQTT et MQTT sur WSS, il AWS IoT prend en charge les appareils qui publient des requêtes HTTPS. Pour un exemple de programme Python qui envoie un message HTTP depuis un appareil, consultez l'[exemple de code HTTPS](http.md#codeexample) utilisant la `requests` bibliothèque Python.
Pour savoir comment prendre une décision éclairée quant au protocole à utiliser pour les communications de votre appareil, consultez le [Choix d'un protocole d'application pour la communication de votre appareil](protocols.md#protocol-selection).
**MQTT**
Les `shadow.py` exemples d'appels `mtls_from_path` (présentés ici) dans le [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)pour établir une connexion à AWS IoT Core l'aide du protocole MQTT. `mtls_from_path` utilise les certificats X.509 et le protocole TLS v1.2 pour authentifier le périphérique. La bibliothèque AWS-CRT gère les détails de niveau inférieur de cette connexion.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
+ `endpoint`est votre AWS IoT point de terminaison que vous avez transmis depuis la ligne de commande et `client_id` est l'identifiant qui identifie de manière unique cet appareil dans le Région AWS.
+ `cert_filepath`, `pri_key_filepath`, et `ca_filepath` sont les chemins d'accès aux fichiers de certificat et de clé privée de l'appareil, ainsi qu'au fichier CA racine.
+ `client_bootstrap` est l'objet d'exécution courant qui gère les activités de communication par socket et qui est instancié avant l'appel à `mqtt_connection_builder.mtls_from_path`.
+ `on_connection_interrupted` et `on_connection_resumed` sont des fonctions de rappel à appeler lorsque la connexion de l'appareil est interrompue et reprise.
+ `clean_session` est de savoir s'il faut démarrer une nouvelle session persistante ou, s'il y en a une, se reconnecter à une session existante. `keep_alive_secs` est la valeur de maintien en vie, en secondes, à envoyer à la `CONNECT` demande. Un ping sera automatiquement envoyé à cet intervalle. Le serveur suppose que la connexion est perdue s'il ne reçoit pas de ping après 1,5 fois cette valeur.
L'`shadow.py` exemple fait également appel `websockets_with_default_aws_signing` au [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) pour établir une connexion en AWS IoT Core utilisant le protocole MQTT via WSS. MQTT over WSS utilise également les mêmes paramètres que MQTT et prend les paramètres supplémentaires suivants :
+ `region`est la région de AWS signature utilisée par l'authentification Signature V4 et `credentials_provider` les AWS informations d'identification fournies pour l'authentification. La région est transmise depuis la ligne de commande et l'`credentials_provider`objet est instancié juste avant l'appel à. `mqtt_connection_builder.websockets_with_default_aws_signing`
+ `websocket_proxy_options` est l'option du proxy HTTP, si vous utilisez un hôte proxy. Dans l'`shadow.py`exemple d'application, cette valeur est instanciée juste avant l'appel à `mqtt_connection_builder.websockets_with_default_aws_signing`.
**Abonnez-vous aux sujets et événements du Shadow**
L'`shadow.py`échantillon tente d'établir une connexion et attend d'être complètement connecté. S'il n'est pas connecté, les commandes sont mises en file d'attente. Une fois connecté, l'échantillon s'abonne aux événements delta, met à jour et reçoit des messages, et publie des messages avec un niveau de qualité de service (QoS) de 1 (`mqtt.QoS.AT_LEAST_ONCE`).
Lorsqu'un appareil s'abonne à un message avec QoS de niveau 1, le courtier de messages enregistre les messages auxquels le périphérique est abonné jusqu'à ce qu'ils puissent être envoyés au terminal. Le courtier de messages renvoie les messages jusqu'à ce qu'il reçoive une `PUBACK` réponse de l'appareil.
Pour plus d'informations sur les procédures stockées, consultez [Examiner le protocole MQTT](sdk-tutorials.md#sdk-tutorials-mqtt-review) et [MQTT](mqtt.md).
Pour plus d'informations sur la façon dont MQTT, MQTT over WSS, les sessions persistantes et les niveaux de QoS utilisés dans ce didacticiel, consultez [Consultez l'exemple d'application pubsub.py du SDK pour appareils](sdk-tutorials.md#sdk-tutorials-explore-sample).
## Étape 3 : résolution des problèmes liés à l'`shadow.py`exemple d'application
Lorsque vous exécutez l'`shadow.py`exemple d'application, certains messages devraient s'afficher dans le terminal et vous demander de saisir une `desired` valeur. Si le programme génère une erreur, alors pour corriger l'erreur, vous pouvez commencer par vérifier si vous avez exécuté la bonne commande pour votre système.
Dans certains cas, le message d'erreur peut indiquer des problèmes de connexion et ressembler à : `Host name was invalid for dns resolution` ou`Connection was closed unexpectedly`. Dans de tels cas, voici certaines choses que vous pouvez vérifier :
+
**Vérifiez l'adresse du point de terminaison dans la commande**
Vérifiez l'`endpoint`argument de la commande que vous avez saisie pour exécuter l'exemple d'application (par exemple,`a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com`) et vérifiez cette valeur dans la **AWS IoT console**.
Pour vérifier si vous avez utilisé la bonne valeur :
1. Dans la **AWS IoT console**, choisissez **Gérer**, puis **Tâches**.
1. Choisissez l'élément que vous avez créé pour votre exemple d'application (par exemple, **My\$1light\$1bulb**), puis choisissez **Interact.**
Sur la page des détails de l'objet votre point de terminaison s'affiche dans la section **HTTPS** Vous devriez également voir un message indiquant : `This thing already appears to be connected.`
+
**Vérifier l'activation du certificat**
Les certificats authentifient votre appareil avec AWS IoT Core.
Pour vérifier si votre certificat est actif, procédez comme suit :
1. Dans la **AWS IoT console**, choisissez **Gérer**, puis **Tâches**.
1. **Choisissez l'élément que vous avez créé pour votre exemple d'application (par exemple, **My\$1light\$1bulb**), puis sélectionnez Security**.
1. Sélectionnez le certificat, puis, sur la page de détails du certificat, choisissez Sélectionner le certificat puis, sur la page de détails du certificat, choisissez **Actions**.
Si l'option **Activer** n'est pas disponible dans la liste déroulante et que vous pouvez uniquement sélectionner **Désactiver**, votre certificat est actif. Si ce n'est pas le cas, choisissez **Activer** et réexécutez l'exemple de programme.
Si le programme ne s'exécute toujours pas, vérifiez les noms des fichiers de certificats dans le `certs` dossier.
+
**Vérifiez la politique attachée à la ressource Thing**
Alors que les certificats authentifient votre appareil, AWS IoT les politiques permettent à l'appareil d'effectuer AWS IoT des opérations, telles que l'abonnement ou la publication sur des sujets réservés au MQTT.
Pour vérifier si la bonne politique est jointe, procédez comme suit :
1. Recherchez le certificat comme décrit précédemment, puis choisissez **Policies**.
1. Choisissez la politique affichée et vérifiez si elle décrit les`connect`, `subscribe`, `receive`, et `publish` actions qui autorisent l'appareil à publier et à s'abonner aux sujets réservés au MQTT.
Consultez [Étape 1 : créer une AWS IoT politique pour le Device Shadow](shadow-provision-cloud.md#create-policy-shadow) pour obtenir un exemple de stratégie.
Si vous voyez des messages d'erreur indiquant un problème de connexion AWS IoT, cela peut être dû aux autorisations que vous utilisez pour la politique. Dans ce cas, nous vous recommandons de commencer par une politique qui fournit un accès complet aux AWS IoT ressources, puis de réexécuter l'exemple de programme. Vous pouvez soit modifier la stratégie actuelle, soit choisir la stratégie actuelle, choisir **Détacher**, puis créer une autre politique fournissant un accès complet et l'associer à votre ressource d'objet. Vous pouvez ensuite restreindre la politique aux seules actions et politiques dont vous avez besoin pour exécuter le programme.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
```
+
**Vérifiez l'installation du SDK de votre appareil**
Si le programme ne s'exécute toujours pas, vous pouvez réinstaller le SDK du périphérique pour vous assurer que l'installation du SDK est complète et correcte.
## Étape 4 : examen des résultats et des étapes suivantes
**Dans ce didacticiel, vous allez découvrir comment :**
+ Installez le logiciel, les outils et le SDK AWS IoT Device pour Python requis.
+ Découvrez comment l'exemple d'application, `shadow.py`, le protocole MQTT pour récupérer et mettre à jour l'état actuel de l'ombre.
+ Exécutez l'exemple d'application pour Device Shadows et observez la mise à jour du document Shadow dans la AWS IoT console. Vous avez également appris à résoudre les problèmes et à corriger les erreurs lors de l'exécution du programme.
**Étapes suivantes**
Vous pouvez désormais exécuter l'`shadow.py`exemple d'application et utiliser Device Shadows pour contrôler l'état. Vous pouvez observer les mises à jour apportées au document Shadow dans la AWS IoT console et observer les événements delta auxquels l'exemple d'application répond. À l'aide du client de test MQTT, vous pouvez vous abonner aux sujets secondaires réservés et observer les messages reçus par les sujets lors de l'exécution de l'exemple de programme. Pour de plus amples informations sur sa configuration veuillez consulter [Tutoriel : Interaction avec Device Shadow à l'aide de l'exemple d'application et du client de test MQTT](interact-lights-device-shadows.md).
# Tutoriel : Interaction avec Device Shadow à l'aide de l'exemple d'application et du client de test MQTT
Pour interagir avec l'`shadow.py`exemple d'application, entrez une valeur dans le terminal pour cette `desired` valeur. Par exemple, vous pouvez spécifier des couleurs qui ressemblent aux feux de signalisation, AWS IoT répondre à la demande et mettre à jour les valeurs signalées.
**Dans ce didacticiel, vous allez découvrir comment :**
+ Utilisez l'`shadow.py`exemple d'application pour spécifier les états souhaités et mettre à jour l'état actuel de l'ombre.
+ Modifiez le document Shadow pour observer les événements delta et la façon dont l'`shadow.py`exemple d'application y répond.
+ Utilisez le client de test MQTT pour vous abonner à des sujets fictifs et observer les mises à jour lorsque vous exécutez l'exemple de programme.
**Avant d'exécuter ce didacticiel, vous devez disposer des éléments suivants :**
Configurez votre Compte AWS appareil Raspberry Pi, configurez votre appareil et créez AWS IoT quelque chose et une politique. Vous devez également avoir installé le logiciel requis, le SDK du périphérique, les fichiers de certificat et exécuté l'exemple de programme dans le terminal. Pour de plus amples informations, veuillez consulter [Tutoriel : Préparation de votre Raspberry Pi pour exécuter l'application fantôme](create-resources-shadow.md) et les didacticiels et [Étape 1 : Exécutez l'exemple d'application shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows). Vous devez suivre ces didacticiels si ce n'est pas déjà fait.
**Topics**
+ [Étape 1 : Mettre à jour les valeurs souhaitées et signalées à l'aide d'`shadow.py`un exemple d'application](#update-desired-shadow-sample)
+ [Étape 2 : Afficher les messages de l'`shadow.py`exemple d'application dans le client de test MQTT](#shadow-sample-view-msg)
+ [Étape 3 : Résolution des erreurs liées aux interactions entre Device Shadow et Device Shadow](#shadow-observe-messages-troubleshoot)
+ [Étape 4 : examen des résultats et des étapes suivantes](#sample-shadow-review)
Ce didacticiel vous prendra environ 45 minutes.
## Étape 1 : Mettre à jour les valeurs souhaitées et signalées à l'aide d'`shadow.py`un exemple d'application
Dans le didacticiel précédent[Étape 1 : Exécutez l'exemple d'application shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows), vous avez appris à observer un message publié dans le document Shadow dans la AWS IoT console lorsque vous entrez une valeur souhaitée, comme décrit dans la section[Tutoriel : Installation du SDK du périphérique et exécution de l'exemple d'application pour Device Shadows](lightbulb-shadow-application.md).
Dans l'exemple précédent, nous avons défini la couleur souhaitée sur `yellow`. Après avoir saisi chaque valeur, le terminal vous invite à en saisir une autre`desired` valeur. Si vous entrez à nouveau la même valeur (`yellow`), l'application le reconnaît et vous invite à saisir une nouvelle `desired` valeur.
```
Enter desired value:
yellow
Local value is already 'yellow'.
Enter desired value:
```
Maintenant, disons que vous entrez la couleur`green`. AWS IoT répond à la demande et met à jour la `reported` valeur en`green`. C'est ainsi que la mise à jour se produit lorsque l'`desired`état est différent de l'`reported`état, provoquant un delta.
**Comment l'`shadow.py`exemple d'application simule les interactions avec Device Shadow :**
1. Entrez une `desired` valeur (disons`yellow`) dans le terminal pour publier l'état souhaité.
1. Comme l'`desired`état est différent de l'`reported`état (disons la couleur`green`), un delta se produit et l'application abonnée au delta reçoit ce message.
1. L'application répond au message et met à jour son état en fonction de la `desired` valeur, `yellow`.
1. L'application publie ensuite un message de mise à jour avec la nouvelle valeur signalée de l'état de l'appareil, `yellow`.
Vous trouverez ci-dessous les messages affichés dans le terminal indiquant comment la demande de mise à jour est publiée.
```
Enter desired value:
green
Changed local shadow value to 'green'.
Updating reported shadow value to 'green'...
Update request published.
Finished updating reported shadow value to 'green'.
```
Dans la AWS IoT console, le document Shadow reflète la valeur mise à jour `green` pour les `desired` champs `reported` et, et le numéro de version est incrémenté de 1. Par exemple, si le numéro de version précédent était affiché sous la forme 10, le numéro de version actuel sera affiché sous la forme 11.
**Note**
La suppression d'une ombre ne rétablit pas le numéro de version à 0. Vous verrez que la version fantôme est incrémentée de 1 lorsque vous publiez une demande de mise à jour ou que vous créez une autre version fantôme portant le même nom.
**Modifiez le document Shadow pour observer les événements du delta**
L'`shadow.py`exemple d'application est également abonnée aux `delta` événements et répond lorsque la `desired` valeur est modifiée. Par exemple, vous pouvez remplacer la `desired` valeur par la couleur`red`. Pour ce faire, dans la AWS IoT console, modifiez le document Shadow en cliquant sur **Modifier**, puis définissez la `desired` valeur sur `red` dans le JSON, tout en conservant la `reported` valeur sur`green`. Avant d'enregistrer les modifications, laissez le terminal du Raspberry Pi ouvert, car des messages s'afficheront sur le terminal lorsque le changement se produira.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Après avoir enregistré la nouvelle valeur, l'`shadow.py`exemple d'application répond à cette modification et affiche des messages dans le terminal indiquant le delta. Vous devriez alors voir les messages suivants apparaître sous l'invite de saisie de la `desired` valeur.
```
Enter desired value:
Received shadow delta event.
Delta reports that desired value is 'red'. Changing local value...
Changed local shadow value to 'red'.
Updating reported shadow value to 'red'...
Finished updating reported shadow value to 'red'.
Enter desired value:
Update request published.
Finished updating reported shadow value to 'red'.
```
## Étape 2 : Afficher les messages de l'`shadow.py`exemple d'application dans le client de test MQTT
Vous pouvez utiliser le **client de test MQTT** dans la **AWS IoT console** pour surveiller les messages MQTT transmis à votre Compte AWS. En vous abonnant à des sujets MQTT réservés utilisés par le service Device Shadow, vous pouvez observer les messages reçus par les sujets lors de l'exécution de l'exemple d'application.
Si vous n'avez pas encore utilisé le client de test MQTT, vous pouvez le consulter [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md). Cela vous permet d'apprendre à utiliser le **client de test MQTT** dans la **AWS IoT console** pour afficher les messages MQTT lorsqu'ils transitent par l’agent de messages.
1.
**Ouvrez le client de test MQTT**
Ouvrez le [client de test MQTT dans la AWS IoT console](https://console.aws.amazon.com//iot/home#/test) dans une nouvelle fenêtre afin de pouvoir observer les messages reçus par les sujets MQTT sans perdre la configuration de votre client de test MQTT. Le client de test MQTT ne conserve aucun abonnement ou journal de messages si vous le quittez pour accéder à une autre page de la console. Dans cette section du didacticiel, vous pouvez ouvrir le document Shadow correspondant à votre appareil et AWS IoT le client de test MQTT dans des fenêtres séparées afin d'observer plus facilement l'interaction avec Device Shadows.
1.
**Abonnez-vous aux Shadow topics réservés au MQTT**
Vous pouvez utiliser le client de test MQTT pour saisir les noms des sujets réservés au MQTT de Device Shadow et vous y abonner pour recevoir des mises à jour lors de l'exécution de l'`shadow.py`exemple d'application. Pour s'abonner à la rubrique MQTT
1. Dans le **client de test MQTT** de la **AWS IoT console**, choisissez **S'abonner à un sujet**.
1. Dans la section **Filtre par sujet**, entrez : ***thingname*\$1aws/things/** /shadow/update/ \$1. `thingname`Voici le nom de la ressource d'objets que vous avez créée précédemment (par exemple,`My_light_bulb`).
1. Conservez les valeurs par défaut pour les paramètres de configuration supplémentaires, puis choisissez **Subscribe**.
En utilisant le caractère générique **\$1** dans l'abonnement aux sujets, vous pouvez vous abonner à plusieurs sujets MQTT en même temps et observer tous les messages échangés entre l'appareil et son Shadow dans une seule fenêtre. Pour plus d'informations sur les caractères génériques et leur utilisation de, consultez[Sujets MQTT](topics.md).
1.
**Exécutez `shadow.py` un exemple de programme et observez les messages**
Dans la fenêtre de ligne de commande du Raspberry Pi, si vous avez déconnecté le programme, réexécutez l'exemple d'application et regardez les messages du **client de test MQTT** dans la **AWS IoT console**.
1. Exécutez la commande suivante pour redémarrer le programme d'exemple. Remplacez *your-iot-thing-name* et *your-iot-endpoint* par les noms de l' AWS IoT objet que vous avez créé précédemment (par exemple,`My_light_bulb`) et du point de terminaison pour interagir avec l'appareil.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
L'`shadow.py`exemple d'application s'exécute ensuite et récupère l'état d'ombre actuel. Si vous avez supprimé l'ombre ou effacé les états actuels, le programme définit la valeur actuelle sur `off` puis vous invite à en saisir une `desired`.
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow document lacks 'color' property. Setting defaults...
Changed local shadow value to 'off'.
Updating reported shadow value to 'off'...
Update request published.
Finished updating reported shadow value to 'off'...
Enter desired value:
```
En revanche, si le programme était en cours d'exécution et que vous l'avez redémarré, vous verrez la dernière valeur de couleur signalée dans le terminal. **Dans le client de test MQTT, vous verrez une mise à jour des rubriques **\$1aws/things/ /shadow/get et \$1aws/things//*thingname***. *thingname* shadow/get/accepted**
Supposons que la dernière couleur signalée soit `green`. Ce qui suit montre le contenu du fichier **\$1aws/things//JSON *thingname***. shadow/get/accepted
```
{
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
}
},
"version": 10,
"timestamp": 1620173908
}
```
1. Entrez une `desired` valeur dans le terminal, telle que`yellow`. L'`shadow.py`exemple d'application répond et affiche les messages suivants dans le terminal qui indiquent la modification de la `reported` valeur de`yellow`.
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Dans le **client de test MQTT** de la **AWS IoT console**, sous **Abonnements**, vous pouvez voir que les sujets suivants ont reçu un message :
+ **\$1aws/things/ *thingname* /shadow/update** : indique que les deux `desired` valeurs et les valeurs changent de couleur. `updated` `yellow`
+ **\$1aws/things/*thingname*/shadow/update/accepted**: affiche les valeurs actuelles des `reported` états `desired` et ainsi que leurs métadonnées et informations de version.
+ **\$1aws/things/*thingname*/shadow/update/documents**: affiche les valeurs précédentes et actuelles des `reported` états et ainsi que leurs métadonnées `desired` et informations de version.
Comme le document **\$1aws/things/*thingname*/**contient shadow/update/documents également des informations contenues dans les deux autres rubriques, nous pouvons le consulter pour voir les informations d'état. L'état précédent indique la valeur signalée définie sur`green`, ses métadonnées et ses informations de version, ainsi que l'état actuel qui indique la valeur signalée mise à jour vers `yellow`.
```
{
"previous": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
}
},
"version": 10
},
"current": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
}
},
"version": 11
},
"timestamp": 1617297904
}
```
1. Désormais, si vous entrez une autre `desired` valeur, d'autres modifications sont apportées aux `reported` valeurs et des mises à jour des messages reçues par ces rubriques. Le numéro de version est également incrémenté de 1. Par exemple, si vous entrez la valeur `green`, l'état précédent indique la valeur `yellow` et l'état actuel indique la valeur`green`.
1.
**Modifier le document Shadow pour observer les événements du delta**
Pour observer les modifications apportées à la rubrique delta, modifiez le document Shadow dans la AWS IoT console. Par exemple, vous pouvez remplacer la `desired` valeur par la couleur`red`. Pour ce faire, dans la AWS IoT console, choisissez **Modifier**, puis définissez la `desired` valeur en rouge dans le JSON, tout en conservant la `reported` valeur définie sur`green`. Avant d'enregistrer la modification, laissez le terminal ouvert car vous verrez le message delta s'afficher dans le terminal.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
L'`shadow.py`exemple d'application répond à cette modification et affiche des messages dans le terminal indiquant le delta. Dans le client de test MQTT, les `update` sujets auront reçu un message indiquant les modifications apportées aux valeurs `desired` et `reported`.
Vous voyez également que le sujet **\$1aws/things/*thingname*/shadow/update/delta**a reçu un message. Pour voir le message, choisissez ce sujet, qui est répertorié sous **Abonnements**.
```
{
"version": 13,
"timestamp": 1617318480,
"state": {
"color": "red"
},
"metadata": {
"color": {
"timestamp": 1617318480
}
}
}
```
## Étape 3 : Résolution des erreurs liées aux interactions entre Device Shadow et Device Shadow
Lorsque vous exécutez l'application Shadow sample, vous pouvez rencontrer des problèmes lors de l'observation des interactions avec le service Device Shadow.
Si le programme s'exécute correctement et vous invite à saisir une `desired` valeur, vous devriez pouvoir observer les interactions entre Device Shadow en utilisant le document Shadow et le client de test MQTT comme décrit précédemment. Toutefois, si vous ne parvenez pas à voir les interactions, voici quelques points que vous pouvez vérifier :
+
**Vérifiez le nom de l'objet et son ombre dans la AWS IoT console**
Si vous ne voyez pas les messages dans le document Shadow, vérifiez la commande et assurez-vous qu'elle correspond au nom de l'objet dans la **AWS IoT console**. Vous pouvez également vérifier si vous avez une ombre classique en choisissant votre ressource matérielle, puis en choisissant **Shadows**. Ce tutoriel se concentre principalement sur les interactions avec l'ombre classique.
Vous pouvez également vérifier que l'appareil que vous avez utilisé est connecté à Internet. Dans la **AWS IoT console**, choisissez l'élément que vous avez créé précédemment, puis choisissez **Interact**. Sur la page des détails de l'objet, vous devriez voir un message disant : `This thing already appears to be connected.`
+
**Vérifiez les sujets réservés au MQTT auxquels vous vous êtes abonné**
Si les messages ne s'affichent pas dans le client de test MQTT, vérifiez si les sujets auxquels vous vous êtes abonné sont correctement formatés. Les sujets MQTT Device Shadow ont le format **\$1aws/things/ *thingname* /shadow/** et peuvent avoir `update` ou `delete` suivre ce format en fonction des actions que vous souhaitez effectuer sur l'ombre. `get` **Ce didacticiel utilise le sujet **\$1aws/things/ *thingname* /shadow/ \$1.** Assurez-vous donc de l'avoir saisi correctement lorsque vous vous êtes abonné au sujet dans la section Filtre de sujets du client de test.**
Lorsque vous entrez le nom du sujet, assurez-vous qu'il *thingname* est identique au nom de l' AWS IoT élément que vous avez créé précédemment. Vous pouvez également vous abonner à des rubriques MQTT supplémentaires pour voir si une mise à jour a été effectuée avec succès. Par exemple, vous pouvez vous abonner à la rubrique **\$1aws/things/*thingname*/shadow/update/rejected**pour recevoir un message chaque fois qu'une demande de mise à jour échoue afin de pouvoir résoudre les problèmes de connexion. Pour de plus amples informations sur les rubriques réservées pour les shadows, veuillez consulter [Rubriques de shadow](reserved-topics.md#reserved-topics-shadow) et [Rubriques MQTT de Device Shadow](device-shadow-mqtt.md).
## Étape 4 : examen des résultats et des étapes suivantes
**Dans ce didacticiel, vous allez découvrir comment :**
+ Utilisez l'`shadow.py`exemple d'application pour spécifier les états souhaités et mettre à jour l'état actuel de l'ombre.
+ Modifiez le document Shadow pour observer les événements delta et la façon dont l'`shadow.py`exemple d'application y répond.
+ Utilisez le client de test MQTT pour vous abonner à des sujets fictifs et observer les mises à jour lorsque vous exécutez l'exemple de programme.
**Étapes suivantes**
Vous pouvez vous abonner à d'autres rubriques réservées au MQTT pour suivre les mises à jour de l'application parallèle. Par exemple, si vous vous abonnez uniquement à la rubrique **\$1aws/things/*thingname*/shadow/update/accepted**, vous ne verrez que les informations d'état actuel lorsqu'une mise à jour est effectuée avec succès.
Vous pouvez également vous abonner à des rubriques supplémentaires pour résoudre les problèmes ou en savoir plus sur les interactions entre Device Shadow et également résoudre les problèmes liés aux interactions Device Shadow. Pour plus d’informations, consultez [Rubriques de shadow](reserved-topics.md#reserved-topics-shadow) et [Rubriques MQTT de Device Shadow](device-shadow-mqtt.md).
Vous pouvez également choisir d'étendre votre application en utilisant des ombres nommées ou en utilisant du matériel supplémentaire connecté au Raspberry Pi pour observer LEDs les modifications de leur état à l'aide des messages envoyés depuis le terminal.
Pour plus d'informations sur le service Device Shadow et son utilisation dans les appareils, les applications et les services[AWS IoT Service Device Shadow](iot-device-shadows.md), consultez[Utilisation des shadows sur les appareils](device-shadow-comms-device.md), et[Utilisation des shadows dans les applications et les services](device-shadow-comms-app.md).