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.
# Création de solutions avec l' AWS IoT appareil SDKs
Les didacticiels de cette section vous aident à suivre les étapes du développement d'une solution IoT pouvant être déployée dans un environnement de production à l'aide de AWS IoT.
Ces didacticiels peuvent prendre plus de temps que ceux présentés dans la section correspondante, [Création de démos avec le AWS IoT Device Client](iot-tutorials-dc-intro.md) car ils utilisent l' AWS IoT appareil SDKs et expliquent les concepts appliqués de manière plus détaillée pour vous aider à créer des solutions sécurisées et fiables.
## Commencez à créer des solutions avec l' AWS IoT appareil SDKs
Ces didacticiels vous présentent différents AWS IoT scénarios. Le cas échéant, les didacticiels utilisent l' AWS IoT appareil SDKs.
**Topics**
+ [Commencez à créer des solutions avec l' AWS IoT appareil SDKs](#iot-sdk-tutorial-overview)
+ [Tutoriel : Connexion d'un appareil à AWS IoT Core l'aide du SDK du AWS IoT périphérique](sdk-tutorials.md)
+ [Création de AWS IoT règles pour acheminer les données des appareils vers d'autres services](iot-rules-tutorial.md)
+ [Conservation de l'état de l'appareil lorsque celui-ci est hors ligne avec Device Shadows](iot-shadows-tutorial.md)
+ [Tutoriel : Création d'un autorisateur personnalisé pour AWS IoT Core](custom-auth-tutorial.md)
+ [Tutoriel : Surveillance de l'humidité du sol avec un AWS IoT Raspberry Pi](iot-moisture-tutorial.md)
# Tutoriel : Connexion d'un appareil à AWS IoT Core l'aide du SDK du AWS IoT périphérique
Ce didacticiel explique comment connecter un appareil AWS IoT Core afin qu'il puisse envoyer et recevoir des données depuis et vers AWS IoT. Une fois ce didacticiel terminé, votre appareil sera configuré pour se connecter à AWS IoT Core et vous comprendrez comment les appareils communiquent avec AWS IoT.
**Topics**
+ [Conditions préalables](#sdk-tutorials-prereq)
+ [Préparez votre appareil pour AWS IoT](#sdk-tutorials-prepare)
+ [Examiner le protocole MQTT](#sdk-tutorials-mqtt-review)
+ [Consultez l'exemple d'application pubsub.py du SDK pour appareils](#sdk-tutorials-explore-sample)
+ [Connectez votre appareil et communiquez avec AWS IoT Core](#sdk-tutorials-experiment)
+ [Passez en revue les résultats](#sdk-tutorials-conclusion)
+ [Tutoriel : Utilisation du Kit SDK des appareils AWS IoT pour Embedded C](iot-embedded-c-sdk.md)
## Conditions préalables
Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :
+
**Terminé [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md)**
Dans la section de ce didacticiel où vous devez[Configurer votre appareil](configure-device.md), sélectionnez l'[Connectez un Raspberry Pi ou un autre appareil](connecting-to-existing-device.md)option correspondant à votre appareil et utilisez les options du langage Python pour configurer votre appareil.
**Note**
Gardez ouverte la fenêtre du terminal que vous utilisez dans ce didacticiel, car vous l'utiliserez également dans ce didacticiel.
+
**Un appareil capable d'exécuter le AWS IoT Device SDK v2 pour Python.**
Ce didacticiel montre comment connecter un appareil à l'aide AWS IoT Core d'exemples de code Python, qui nécessitent un périphérique relativement puissant. Si vous travaillez avec des appareils dont les ressources sont limitées, il est possible que ces exemples de code ne fonctionnent pas sur eux. Dans ce cas, vous aurez peut-être plus de succès avec le [Tutoriel : Utilisation du Kit SDK des appareils AWS IoT pour Embedded C](iot-embedded-c-sdk.md) didacticiel.
+
**Vous avez obtenu les informations requises pour vous connecter à l'appareil**
Pour connecter votre appareil à AWS IoT, vous devez disposer d'informations sur le nom de l'objet, le nom d'hôte et le numéro de port.
**Note**
Vous pouvez également utiliser l'authentification personnalisée pour connecter des appareils à AWS IoT Core. Les données de connexion que vous transmettez à votre fonction Lambda d'autorisation dépendent du protocole que vous utilisez.
+ **Nom de l'objet** : nom de l' AWS IoT objet auquel vous souhaitez vous connecter. Vous devez avoir enregistré votre appareil en tant qu' AWS IoT objet. Pour de plus amples informations, veuillez consulter [Gestion des appareils avec AWS IoT](iot-thing-management.md).
+ **Nom d'hôte : nom** d'hôte du point de terminaison IoT spécifique au compte.
+ **Numéro de port** : numéro de port auquel se connecter.
Vous pouvez utiliser la `configureEndpoint` méthode du SDK AWS IoT Python pour configurer le nom d'hôte et le numéro de port.
```
myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)
```
## Préparez votre appareil pour AWS IoT
Dans [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md), vous avez préparé votre appareil et votre AWS compte pour qu'ils puissent communiquer. Cette section passe en revue les aspects de cette préparation qui s'appliquent à toute connexion d'appareil avec AWS IoT Core.
Pour qu'un appareil puisse se connecter à AWS IoT Core :
1. Vous devez avoir un **Compte AWS**.
La procédure [Configurez Compte AWS](setting-up.md) décrite dans décrit comment créer un Compte AWS si vous n'en avez pas déjà un.
1. Dans ce compte, les **AWS IoT ressources** suivantes doivent être définies pour l'appareil de votre région Compte AWS et de votre région.
La procédure décrite ci-dessous [Créez des AWS IoT ressources](create-iot-resources.md) décrit comment créer ces ressources pour l'appareil dans votre région Compte AWS .
+ Un **certificat d'appareil** enregistré AWS IoT et activé pour authentifier l'appareil.
Le certificat est souvent créé avec un **AWS IoT objet** et y est attaché. Bien qu'il ne soit pas nécessaire qu'un appareil se connecte à un objet AWS IoT, il met des AWS IoT fonctionnalités supplémentaires à la disposition de celui-ci.
+ **Politique** attachée au certificat de l'appareil qui l'autorise à se connecter AWS IoT Core et à effectuer toutes les actions que vous souhaitez qu'il effectue.
1. Une **connexion Internet** qui peut accéder aux terminaux Compte AWS de votre appareil.
Les points de terminaison de l'appareil sont décrits [AWS IoT données de l'appareil et points de terminaison de service](iot-connect-devices.md#iot-connect-device-endpoints) et peuvent être consultés sur la [page des paramètres de la AWS IoT console](https://console.aws.amazon.com/iot/home#/settings).
1. **Logiciel de communication** tel que celui SDKs fourni par l' AWS IoT appareil. Ce didacticiel utilise le [AWS IoT Device SDK v2 pour Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python).
## Examiner le protocole MQTT
Avant de parler de l'exemple d'application, il est utile de comprendre le protocole MQTT. Le protocole MQTT offre certains avantages par rapport aux autres protocoles de communication réseau, tels que le HTTP, ce qui en fait un choix populaire pour les appareils IoT. Cette section passe en revue les principaux aspects du MQTT qui s'appliquent à ce didacticiel. Pour plus d'informations sur la comparaison entre MQTT et HTTP, consultez[Choix d'un protocole d'application pour la communication de votre appareil](protocols.md#protocol-selection).
**MQTT utilise un modèle publish/subscribe de communication**
Le protocole MQTT utilise un modèle publish/subscribe de communication avec son hôte. Ce modèle est différent du request/response modèle utilisé par HTTP. Avec MQTT, les appareils établissent une session avec l'hôte qui est identifié par un identifiant client unique. Pour envoyer des données, les appareils publient des messages identifiés par sujets à un courtier de messages sur l'hôte. Pour recevoir des messages du courtier de messages, les appareils s'abonnent aux sujets en envoyant des filtres de sujets dans les demandes d'abonnement adressées au courtier de messages.
**MQTT prend en charge les sessions persistantes**
Le courtier de messages reçoit les messages des appareils et publie des messages aux appareils qui y sont abonnés. Avec les [sessions persistantes](mqtt.md#mqtt-persistent-sessions), —c'est-à-dire des sessions qui restent actives même lorsque l'appareil initiateur est déconnecté— les appareils peuvent récupérer les messages publiés alors qu'ils étaient déconnectés. Du côté de l'appareil, MQTT prend en charge les niveaux de qualité de service ([QoS](mqtt.md#mqtt-qos)) qui garantissent que l'hôte reçoit les messages envoyés par le périphérique.
## Consultez l'exemple d'application pubsub.py du SDK pour appareils
Cette section passe en revue l'`pubsub.py`exemple d'application du **AWS IoT Device SDK v2 pour Python** utilisé dans ce didacticiel. Ici, nous verrons comment il se connecte AWS IoT Core pour publier des messages MQTT et s'y abonner. La section suivante présente quelques exercices destinés à vous aider à découvrir comment un appareil se connecte et communique avec lui AWS IoT Core.
**L'`pubsub.py`exemple d'application illustre les aspects suivants d'une connexion MQTT avec AWS IoT Core :**
+ [Protocoles de communication](#sdk-tutorials-explore-protocols)
+ [Sessions persistantes](#sdk-tutorials-explore-persistent)
+ [Qualité du service](#sdk-tutorials-explore-qos)
+ [Publication du message](#sdk-tutorials-explore-publish)
+ [Abonnement aux messages](#sdk-tutorials-explore-subscribe)
+ [Déconnexion et reconnexion de l'appareil](#sdk-tutorials-explore-connect)
### Protocoles de communication
L'`pubsub.py`exemple illustre une connexion MQTT utilisant les 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.
#### MQTT
Les `pubsub.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`
Le point Compte AWS de terminaison de votre appareil IoT
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`cert_filepath`
Chemin d'accès au fichier de certificat de l'appareil
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`pri_key_filepath`
Le chemin d'accès au fichier de clé privée de l'appareil créé avec son fichier de certificat
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`ca_filepath`
Chemin d'accès au fichier de l'autorité de certification racine. Obligatoire uniquement si le serveur MQTT utilise un certificat qui ne se trouve pas déjà dans votre magasin de confiance.
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`client_bootstrap`
L'objet d'exécution commun qui gère les activités de communication avec les sockets
Dans l'exemple d'application, cet objet est instancié avant l'appel à `mqtt_connection_builder.mtls_from_path`.
`on_connection_interrupted``on_connection_resumed`
Les fonctions de rappel permettent d'appeler lorsque la connexion de l'appareil est interrompue et reprise
`client_id`
L'identifiant qui identifie de manière unique cet appareil dans Région AWS
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`clean_session`
S'il faut démarrer une nouvelle session persistante ou, le cas échéant, se reconnecter à une session existante
`keep_alive_secs`
La valeur de maintien en vie, en secondes, à envoyer à la `CONNECT` demande. Un ping sera automatiquement envoyé à cet intervalle. Si le serveur ne reçoit pas de ping après 1,5 fois cette valeur, il suppose que la connexion est perdue.
#### MQTT via WSS
Les `pubsub.py` exemples d'appels `websockets_with_default_aws_signing` (présentés ici) permettent [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)d'établir une connexion en AWS IoT Core utilisant le protocole MQTT via WSS. `websockets_with_default_aws_signing`crée une connexion MQTT via WSS à l'aide de [Signature V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) pour authentifier le périphérique.
```
mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
endpoint=args.endpoint,
client_bootstrap=client_bootstrap,
region=args.signing_region,
credentials_provider=credentials_provider,
websocket_proxy_options=proxy_options,
ca_filepath=args.ca_file,
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`
Le point Compte AWS de terminaison de votre appareil IoT
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`client_bootstrap`
L'objet d'exécution commun qui gère les activités de communication avec les sockets
Dans l'exemple d'application, cet objet est instancié avant l'appel à. `mqtt_connection_builder.websockets_with_default_aws_signing`
`region`
Région de AWS signature utilisée par l'authentification Signature V4. Dans `pubsub.py`, il transmet le paramètre saisi dans la ligne de commande.
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`credentials_provider`
Les AWS informations d'identification fournies à utiliser pour l'authentification
Dans l'exemple d'application, cet objet est instancié avant l'appel à `mqtt_connection_builder.websockets_with_default_aws_signing`.
`websocket_proxy_options`
Options de proxy HTTP, si vous utilisez un hôte proxy
Dans l'exemple d'application, cette valeur est initialisée avant l'appel à `mqtt_connection_builder.websockets_with_default_aws_signing`.
`ca_filepath`
Chemin d'accès au fichier de l'autorité de certification racine. Obligatoire uniquement si le serveur MQTT utilise un certificat qui ne se trouve pas déjà dans votre magasin de confiance.
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`on_connection_interrupted``on_connection_resumed`
Les fonctions de rappel permettent d'appeler lorsque la connexion de l'appareil est interrompue et reprise
`client_id`
L'identifiant qui identifie de manière unique cet appareil dans le Région AWS.
Dans l'exemple d'application, cette valeur est transmise depuis la ligne de commande.
`clean_session`
S'il faut démarrer une nouvelle session persistante ou, le cas échéant, se reconnecter à une session existante
`keep_alive_secs`
La valeur de maintien en vie, en secondes, à envoyer à la `CONNECT` demande. Un ping sera automatiquement envoyé à cet intervalle. Si le serveur ne reçoit pas de ping après 1,5 fois cette valeur, il suppose que la connexion est perdue.
#### HTTPS
Qu'en est-il du HTTPS ? AWS IoT Core prend en charge les appareils qui publient des requêtes HTTPS. Du point de vue de la programmation, les appareils envoient des requêtes HTTPS AWS IoT Core comme le ferait n'importe quelle autre application. 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. Cet exemple envoie un message à AWS IoT Core l'aide du protocole HTTPS, qui l' AWS IoT Core interprète comme un message MQTT.
Bien qu'il prenne AWS IoT Core en charge les requêtes HTTPS provenant d'appareils, assurez-vous de consulter les informations correspondantes [Choix d'un protocole d'application pour la communication de votre appareil](protocols.md#protocol-selection) afin de pouvoir prendre une décision éclairée quant au protocole à utiliser pour les communications de votre appareil.
### Sessions persistantes
Dans l'exemple d'application, la définition du `clean_session` paramètre sur `False` indique que la connexion doit être permanente. En pratique, cela signifie que la connexion ouverte par cet appel se reconnecte à une session persistante existante, s'il en existe une. Dans le cas contraire, il crée une nouvelle session persistante et s'y connecte.
Dans le cas d'une session permanente, les messages envoyés à l'appareil sont stockés par le courtier de messages lorsque l'appareil n'est pas connecté. Lorsqu'un appareil se reconnecte à une session permanente, le courtier de messages envoie au terminal tous les messages enregistrés auxquels il est abonné.
Sans session permanente, l'appareil ne recevra pas les messages envoyés lorsqu'il n'est pas connecté. L'option à utiliser dépend de votre application et de la nécessité de communiquer les messages qui apparaissent alors qu'un appareil n'est pas connecté. Pour de plus amples informations, veuillez consulter [Sessions permanentes MQTT](mqtt.md#mqtt-persistent-sessions).
### Qualité du service
Lorsque l'appareil publie des messages et s'y abonne, la qualité de service (QoS) préférée peut être définie. AWS IoT prend en charge les niveaux de QoS 0 et 1 pour les opérations de publication et d'abonnement. Pour plus d'informations sur les niveaux de QoS dans AWS IoT, consultez. [Options de qualité de service (QoS) MQTT](mqtt.md#mqtt-qos)
Le moteur d'exécution AWS CRT pour Python définit les constantes suivantes pour les niveaux de QoS qu'il prend en charge :
**Niveaux de qualité de service en Python**
| Niveau de QoS MQTT | Valeur symbolique Python utilisée par le SDK | Description |
| --- | --- | --- |
| QoS niveau 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Une seule tentative d'envoi du message sera effectuée, qu'il soit reçu ou non. Le message peut ne pas être envoyé du tout, par exemple si l'appareil n'est pas connecté ou s'il y a une erreur réseau. |
| QoS niveau 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | Le message est envoyé à plusieurs reprises jusqu'à ce qu'un PUBACK accusé de réception soit reçu. |
Dans l'exemple d'application, les demandes de publication et d'abonnement sont effectuées avec un niveau de QoS de 1 (`mqtt.QoS.AT_LEAST_ONCE`).
+
**QoS lors de la publication**
Lorsqu'un appareil publie un message avec le niveau de QoS 1, il l'envoie à plusieurs reprises jusqu'à ce qu'il reçoive une `PUBACK` réponse du courtier de messages. Si l'appareil n'est pas connecté, le message est mis en file d'attente pour être envoyé après sa reconnexion.
+
**QoS lors de l'abonnement**
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 périphérique. Le courtier de messages renvoie les messages jusqu'à ce qu'il reçoive une `PUBACK` réponse de l'appareil.
### Publication du message
Une fois la connexion établie avec succès AWS IoT Core, les appareils peuvent publier des messages. Pour ce faire, l'`pubsub.py`exemple appelle le `publish` fonctionnement de l'`mqtt_connection`objet.
```
mqtt_connection.publish(
topic=args.topic,
payload=message,
qos=mqtt.QoS.AT_LEAST_ONCE
)
```
`topic`
Le nom du sujet du message qui identifie le message
Dans l'exemple d'application, cela est transmis depuis la ligne de commande.
`payload`
La charge utile du message formatée sous forme de chaîne (par exemple, un document JSON)
Dans l'exemple d'application, cela est transmis depuis la ligne de commande.
Un document JSON est un format de charge utile courant, reconnu par d'autres AWS IoT services ; toutefois, le format de données de la charge utile du message peut être celui sur lequel les éditeurs et les abonnés sont d'accord. Cependant, d'autres AWS IoT services ne reconnaissent que le JSON et le CBOR, dans certains cas, pour la plupart des opérations.
`qos`
Le niveau de QoS pour ce message
### Abonnement aux messages
Pour recevoir des messages provenant AWS IoT d'autres services et appareils, les appareils s'abonnent à ces messages en utilisant le nom de leur sujet. Les appareils peuvent s'abonner à des messages individuels en spécifiant un [nom de sujet](topics.md#topicnames), et à un groupe de messages en spécifiant un [filtre de sujet](topics.md#topicfilters), qui peut inclure des caractères génériques. L'`pubsub.py`exemple utilise le code présenté ici pour s'abonner aux messages et enregistrer les fonctions de rappel afin de traiter le message après sa réception.
```
subscribe_future, packet_id = mqtt_connection.subscribe(
topic=args.topic,
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_message_received
)
subscribe_result = subscribe_future.result()
```
`topic`
Le sujet auquel s'abonner. Il peut s'agir d'un nom de rubrique ou d'un filtre de rubrique.
Dans l'exemple d'application, cela est transmis depuis la ligne de commande.
`qos`
Si le courtier de messages doit stocker ces messages lorsque l'appareil est déconnecté.
Une valeur de `mqtt.QoS.AT_LEAST_ONCE` (QoS niveau 1) nécessite qu'une session persistante soit spécifiée (`clean_session=False`) lors de la création de la connexion.
`callback`
Fonction à appeler pour traiter le message souscrit.
La `mqtt_connection.subscribe` fonction renvoie un futur et un ID de paquet. Si la demande d'abonnement a été lancée avec succès, l'ID de paquet renvoyé est supérieur à 0. Pour vous assurer que l'abonnement a été reçu et enregistré par le courtier de messages, vous devez attendre le retour du résultat de l'opération asynchrone, comme indiqué dans l'exemple de code.
**Fonction de rappel**
Le rappel de l'`pubsub.py`exemple traite les messages souscrits au fur et à mesure que l'appareil les reçoit.
```
def on_message_received(topic, payload, **kwargs):
print("Received message from topic '{}': {}".format(topic, payload))
global received_count
received_count += 1
if received_count == args.count:
received_all_event.set()
```
`topic`
Le sujet du message
Il s'agit du nom de sujet spécifique du message reçu, même si vous vous êtes abonné à un filtre de sujet.
`payload`
La charge utile des messages
Le format utilisé est spécifique à l'application.
`kwargs`
Arguments supplémentaires possibles tels que décrits dans [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe).
Dans l'`pubsub.py`exemple`on_message_received`, affiche uniquement le sujet et sa charge utile. Il compte également les messages reçus pour terminer le programme une fois la limite atteinte.
Votre application évaluera le sujet et la charge utile pour déterminer les actions à effectuer.
### Déconnexion et reconnexion de l'appareil
L'`pubsub.py`exemple inclut des fonctions de rappel qui sont appelées lorsque le périphérique est déconnecté et lorsque la connexion est rétablie. Les actions entreprises par votre appareil face à ces événements sont spécifiques à l'application.
Lorsqu'un appareil se connecte pour la première fois, il doit s'abonner aux rubriques pour pouvoir les recevoir. Si la session d'un appareil est présente lorsqu'il se reconnecte, ses abonnements sont restaurés et tous les messages enregistrés provenant de ces abonnements sont envoyés à l'appareil après sa reconnexion.
Si la session d'un appareil n'existe plus lorsqu'il se reconnecte, il doit se réabonner à ses abonnements. Les sessions persistantes ont une durée de vie limitée et peuvent expirer lorsque l'appareil est déconnecté trop longtemps.
## Connectez votre appareil et communiquez avec AWS IoT Core
Cette section présente quelques exercices destinés à vous aider à explorer les différents aspects de la connexion de votre appareil à AWS IoT Core. Pour ces exercices, vous allez utiliser le [client de test MQTT](https://console.aws.amazon.com/iot/home#/test) de la AWS IoT console pour voir ce que votre appareil publie et pour publier des messages sur votre appareil. Ces exercices utilisent l'[https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py)exemple du [AWS IoT Device SDK v2 pour Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) et s'appuient sur votre expérience avec les [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md) didacticiels.
**Topics**
+ [Abonnez-vous aux filtres thématiques génériques](#sdk-tutorials-experiment-wild)
+ [Traiter les abonnements aux filtres thématiques](#sdk-tutorials-experiment-process)
+ [Publiez des messages depuis votre appareil](#sdk-tutorials-experiment-publish)
Pour ces exercices, vous allez commencer par l'`pubsub.py`exemple de programme.
**Note**
Ces exercices supposent que vous avez terminé les [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md) didacticiels et que vous utilisez la fenêtre du terminal de votre appareil à partir de ce didacticiel.
### Abonnez-vous aux filtres thématiques génériques
Dans cet exercice, vous allez modifier la ligne de commande utilisée pour `pubsub.py` vous abonner à un filtre de sujet générique et traiter les messages reçus en fonction du sujet du message.
#### Procédure d'exercice
Pour cet exercice, imaginez que votre appareil contient une commande de température et une commande d'éclairage. Il utilise ces noms de rubriques pour identifier les messages les concernant.
1. Avant de commencer l'exercice, essayez d'exécuter cette commande à partir des [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md) didacticiels de votre appareil pour vous assurer que tout est prêt pour l'exercice.
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Vous devriez voir le même résultat que celui que vous avez vu dans le [didacticiel de démarrage](connecting-to-existing-device.md#gs-device-node-app-run).
1. Pour cet exercice, modifiez ces paramètres de ligne de commande.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/sdk-tutorials.html)
Ces modifications apportées à la ligne de commande initiale se traduisent par cette ligne de commande. Entrez cette commande dans la fenêtre du terminal de votre appareil.
```
python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Le programme doit afficher ce qui suit :
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
```
Si vous voyez quelque chose comme ça sur votre terminal, celui-ci est prêt et il écoute les messages dont le nom des sujets commence par `device` et se termine par`/detail`. Alors, testons cela.
1. Voici quelques messages que votre appareil est susceptible de recevoir.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/sdk-tutorials.html)
1. À l'aide du client de test MQTT de la AWS IoT console, envoyez les messages décrits à l'étape précédente à votre appareil.
1. Ouvrez le [client de test MQTT](https://console.aws.amazon.com/iot/home#/test) dans la AWS IoT console.
1. Dans **Subscribe to a topic**, dans le champ **Subscription topic**, entrez le filtre d’objet **device/\$1/details**, puis choisissez **Subscribe to topic**.
1. Dans la colonne **Abonnements** du client de test MQTT, sélectionnez **device/\$1/details**.
1. Pour chacun des sujets du tableau précédent, effectuez les opérations suivantes dans le client de test MQTT :
1. Dans **Publier**, entrez la valeur de la colonne **Nom du sujet** dans le tableau.
1. Dans le champ de charge utile du message situé sous le nom du sujet, entrez la valeur de la colonne **Charge utile du message** du tableau.
1. Regardez la fenêtre du terminal dans laquelle `pubsub.py` elle s'exécute et, dans le client de test MQTT, choisissez **Publier dans le sujet**.
Vous devriez voir que le message a été reçu `pubsub.py` dans la fenêtre du terminal.
#### Résultat de l'exercice
Ainsi,`pubsub.py`, s'est abonné aux messages à l'aide d'un filtre thématique générique, les a reçus et les a affichés dans la fenêtre du terminal. Notez que vous vous êtes abonné à un filtre de sujet unique et que la fonction de rappel a été appelée pour traiter les messages ayant deux sujets distincts.
### Traiter les abonnements aux filtres thématiques
Sur la base de l'exercice précédent, modifiez l'`pubsub.py`exemple d'application pour évaluer les sujets des messages et traiter les messages souscrits en fonction du sujet.
#### Procédure d'exercice
**Pour évaluer le sujet du message**
1. Copiez `pubsub.py` dans `pubsub2.py`.
1. Ouvrez le fichier `pubsub2.py` dans votre éditeur de texte favori.
1. Dans`pubsub2.py`, trouvez la `on_message_received` fonction.
1. Dans`on_message_received`, insérez le code suivant après la ligne commençant par `print("Received message` et avant la ligne commençant par`global received_count`.
```
topic_parsed = False
if "/" in topic:
parsed_topic = topic.split("/")
if len(parsed_topic) == 3:
# this topic has the correct format
if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
# this is a topic we care about, so check the 2nd element
if (parsed_topic[1] == 'temp'):
print("Received temperature request: {}".format(payload))
topic_parsed = True
if (parsed_topic[1] == 'light'):
print("Received light request: {}".format(payload))
topic_parsed = True
if not topic_parsed:
print("Unrecognized message topic.")
```
1. Enregistrez vos modifications et exécutez le programme modifié à l'aide de cette ligne de commande.
```
python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. Dans la AWS IoT console, ouvrez le [client de test MQTT](https://console.aws.amazon.com/iot/home#/test).
1. Dans **Subscribe to a topic**, dans le champ **Subscription topic**, entrez le filtre d’objet **device/\$1/details**, puis choisissez **Subscribe to topic**.
1. Dans la colonne **Abonnements** du client de test MQTT, sélectionnez **device/\$1/details**.
1. Pour chacune des rubriques de ce tableau, effectuez les opérations suivantes dans le client de test MQTT :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/sdk-tutorials.html)
1. Dans **Publier**, entrez la valeur de la colonne **Nom du sujet** dans le tableau.
1. Dans le champ de charge utile du message situé sous le nom du sujet, entrez la valeur de la colonne **Charge utile du message** du tableau.
1. Regardez la fenêtre du terminal dans laquelle `pubsub.py` elle s'exécute et, dans le client de test MQTT, choisissez **Publier dans le sujet**.
Vous devriez voir que le message a été reçu `pubsub.py` dans la fenêtre du terminal.
Le résultat devrait être similaire dans la fenêtre de votre terminal.
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Résultat de l'exercice
Dans cet exercice, vous avez ajouté du code afin que l'exemple d'application reconnaisse et traite plusieurs messages dans la fonction de rappel. Ainsi, votre appareil pourrait recevoir des messages et agir en conséquence.
Un autre moyen pour votre appareil de recevoir et de traiter plusieurs messages consiste à s'abonner à différents messages séparément et à attribuer à chaque abonnement sa propre fonction de rappel.
### Publiez des messages depuis votre appareil
Vous pouvez utiliser l'exemple d'application pubsub.py pour publier des messages depuis votre appareil. Bien qu'il publie les messages tels quels, ils ne peuvent pas être lus sous forme de documents JSON. Cet exercice modifie l'exemple d'application afin de pouvoir publier des documents JSON dans la charge utile des messages qui peuvent être lus par. AWS IoT Core
#### Procédure d'exercice
Dans cet exercice, le message suivant sera envoyé avec le `device/data` sujet.
```
{
"timestamp": 1601048303,
"sensorId": 28,
"sensorData": [
{
"sensorName": "Wind speed",
"sensorValue": 34.2211224
}
]
}
```
**Pour préparer votre client de test MQTT à surveiller les messages de cet exercice**
1. Dans **Subscribe to a topic**, dans le champ **Subscription topic**, entrez **device/data**, puis choisissez **Subscribe to topic**.
1. Dans la colonne **Abonnements** du client de test MQTT, sélectionnez **device/data**.
1. Laissez la fenêtre du client de test MQTT ouverte pour attendre les messages de votre appareil.
**Pour envoyer des documents JSON avec l'exemple d'application pubsub.py**
1. Sur votre appareil, copiez-le `pubsub.py` vers`pubsub3.py`.
1. Modifiez `pubsub3.py` pour modifier le format des messages qu'il publie.
1. Ouvrez `pubsub3.py` dans un éditeur de texte.
1. Localisez cette ligne de code :
`message = "{} [{}]".format(message_string, publish_count)`
1. Remplacer par :
`message = "{}".format(message_string)`
1. Localisez cette ligne de code :
`message_json = json.dumps(message)`
1. Remplacer par :
`message = "{}".json.dumps(json.loads(message))`
1. Enregistrez vos modifications.
1. Sur votre appareil, exécutez cette commande pour envoyer le message deux fois.
```
python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint
```
1. Dans le client de test MQTT, vérifiez qu'il a interprété et formaté le document JSON dans la charge utile du message, par exemple :
![\[Image montrant comment la charge utile d'un message JSON est affichée dans le client MQTT de la AWS IoT console.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/mqtt-test-client-output.png)
Par défaut, s'abonne `pubsub3.py` également aux messages qu'il envoie. Vous devriez voir qu'elle a reçu les messages dans la sortie de l'application. La fenêtre du terminal doit se présenter comme suit.
```
Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Résultat de l'exercice
Ainsi, votre appareil peut générer des messages à envoyer AWS IoT Core pour tester la connectivité de base et fournir des messages AWS IoT Core à traiter. Par exemple, vous pouvez utiliser cette application pour envoyer des données de test depuis votre appareil afin de tester les actions des AWS IoT règles.
## Passez en revue les résultats
Les exemples présentés dans ce didacticiel vous ont permis d'acquérir une expérience pratique des bases de la communication entre les AWS IoT Core appareils, élément fondamental de votre AWS IoT solution. Lorsque vos appareils sont en mesure de communiquer avec eux AWS IoT Core, ils peuvent transmettre des messages aux AWS services et autres appareils sur lesquels ils peuvent agir. De même, AWS les services et autres appareils peuvent traiter des informations qui se traduisent par le renvoi de messages vers vos appareils.
Lorsque vous serez prêt à AWS IoT Core poursuivre votre exploration, essayez ces didacticiels :
+ [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)
+ [Tutoriel : Stockage des données de l'appareil dans une table DynamoDB](iot-ddb-rule.md)
+ [Tutoriel : Formatage d'une notification à l'aide d'une AWS Lambda fonction](iot-lambda-rule.md)
# Tutoriel : Utilisation du Kit SDK des appareils AWS IoT pour Embedded C
Cette section décrit comment exécuter le Kit SDK des appareils AWS IoT pour Embedded C.
**Topics**
+ [Étape 1 : installez le Kit SDK des appareils AWS IoT pour Embedded C](#install-embedded-c-sdk)
+ [Étape 2 : Configurer l'exemple d'application](#iot-c-sdk-app-config)
+ [Étape 3 : Créer et exécuter l'exemple d'application](#iot-c-sdk-app-run)
## Étape 1 : installez le Kit SDK des appareils AWS IoT pour Embedded C
Kit SDK des appareils AWS IoT pour Embedded C Il est généralement destiné aux appareils aux ressources limitées qui nécessitent un environnement d'exécution optimisé en langage C. Vous pouvez utiliser le SDK sur n'importe quel système d'exploitation et l'héberger sur n'importe quel type de processeur (par exemple, MCUs et MPUs). Si vous disposez de davantage de mémoire et de ressources de traitement, nous vous recommandons d'utiliser un AWS IoT appareil ou un appareil mobile de niveau supérieur SDKs (par exemple, C\$1\$1 JavaScript, Java et Python).
En général, Kit SDK des appareils AWS IoT pour Embedded C il est destiné aux systèmes utilisant MCUs ou bas de gamme exécutant MPUs des systèmes d'exploitation intégrés. Pour l'exemple de programmation présenté dans cette section, nous supposons que votre appareil utilise Linux.
**Example**
1. Téléchargez-le Kit SDK des appareils AWS IoT pour Embedded C sur votre appareil à partir de [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C).
```
git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules
```
Cette opération crée un répertoire nommé `aws-iot-device-sdk-embedded-c` dans le répertoire actuel.
1. Accédez à ce répertoire et consultez la dernière version. Veuillez consulter [github. com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags)pour le dernier tag de publication.
```
cd aws-iot-device-sdk-embedded-c
git checkout latest-release-tag
```
1. Installez OpenSSL version 1.1.0 ou ultérieure. Les bibliothèques de développement OpenSSL sont généralement appelées « libssl-dev » ou « openssl-devel » lorsqu'elles sont installées via un gestionnaire de paquets.
```
sudo apt-get install libssl-dev
```
## Étape 2 : Configurer l'exemple d'application
Kit SDK des appareils AWS IoT pour Embedded C Il inclut des exemples d'applications que vous pouvez essayer. Pour des raisons de simplicité, ce didacticiel utilise l'`mqtt_demo_mutual_auth`application, qui montre comment se connecter au courtier de AWS IoT Core messages, s'abonner et publier sur des sujets MQTT.
1. Copiez le certificat et la clé privée que vous avez créés dans [Commencer à utiliser les AWS IoT Core didacticiels](iot-gs.md) dans le répertoire `build/bin/certificates`.
**Note**
Les certificats d'autorité de certification racine et d'appareil sont susceptibles d'expirer ou d'être révoqués. Si ces certificats expirent ou sont révoqués, vous devez copier un nouveau certificat d'autorité de certification ou une nouvelle clé privée et un nouveau certificat d'appareil sur votre appareil.
1. Vous devez configurer l'exemple avec votre point de AWS IoT Core terminaison personnel, votre clé privée, votre certificat et votre certificat CA racine. Accédez au répertoire `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth`.
Si vous l'avez AWS CLI installé, vous pouvez utiliser cette commande pour trouver l'URL du point de terminaison de votre compte.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si ce n'est pas le AWS CLI cas, ouvrez votre [AWS IoT console](https://console.aws.amazon.com/iot/home). Dans le panneau de navigation, choisissez **Manage (Gérer)**, puis **Things (Objets)**. Choisissez l'objet IoT pour votre appareil, puis choisissez **Interagir**. Votre point de terminaison s'affiche dans la section **HTTPS** de la page de détails de l'objet.
1. Ouvrez le fichier `demo_config.h` et mettez à jour les valeurs des éléments suivants :
AWS\$1IOT\$1POINT DE TERMINAISON
Votre point de terminaison personnel.
CLIENT\$1CERT\$1PATH
Le chemin de votre fichier de certificat, par exemple `certificates/device.pem.crt"`.
CLIENT\$1PRIVATE\$1KEY\$1PATH
Le nom de votre fichier de clé privée, par exemple`certificates/private.pem.key`.
Par exemple :
```
// Get from demo_config.h
// =================================================
#define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com"
#define AWS_MQTT_PORT 8883
#define CLIENT_IDENTIFIER "testclient"
#define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt"
#define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt"
#define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key"
// =================================================
```
1. Vérifiez si vous l'avez CMake installé sur votre appareil à l'aide de cette commande.
```
cmake --version
```
Si vous voyez les informations de version du compilateur, vous pouvez passer à la section suivante.
Si vous obtenez une erreur ou ne voyez aucune information, vous devrez alors installer le package cmake à l'aide de cette commande.
```
sudo apt-get install cmake
```
Réexécutez la **cmake --version** commande et confirmez qu' CMake elle a été installée et que vous êtes prêt à continuer.
1. Vérifiez si les outils de développement sont installés sur votre appareil à l'aide de cette commande.
```
gcc --version
```
Si vous voyez les informations de version du compilateur, vous pouvez passer à la section suivante.
Si vous obtenez une erreur ou que vous ne voyez aucune information de compilateur, vous devrez installer le package `build-essential` à l'aide de cette commande.
```
sudo apt-get install build-essential
```
Exécutez à nouveau la commande **gcc --version** et vérifiez que les outils de génération ont été installés et que vous êtes prêt à continuer.
## Étape 3 : Créer et exécuter l'exemple d'application
Cette procédure explique comment générer l'`mqtt_demo_mutual_auth`application sur votre appareil et comment la connecter à la [AWS IoT console](https://console.aws.amazon.com/iot/home) à l'aide du. Kit SDK des appareils AWS IoT pour Embedded C
**Pour exécuter les Kit SDK des appareils AWS IoT pour Embedded C exemples d'applications**
1. Accédez à un répertoire de construction `aws-iot-device-sdk-embedded-c` et créez-le.
```
mkdir build && cd build
```
1. Entrez la CMake commande suivante pour générer les Makefiles nécessaires à la construction.
```
cmake ..
```
1. Entrez la commande suivante pour créer le fichier d'application exécutable.
```
make
```
1. Exécutez l'application `mqtt_demo_mutual_auth` avec cette commande.
```
cd bin
./mqtt_demo_mutual_auth
```
Vous devez voir des résultats similaires à ce qui suit :
![\[Sortie en ligne de commande pour exécuter l' Kit SDK des appareils AWS IoT pour Embedded C exemple d'application.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/successful-run2.png)
Votre appareil est maintenant connecté à AWS IoT l'aide du Kit SDK des appareils AWS IoT pour Embedded C.
Vous pouvez également utiliser la AWS IoT console pour afficher les messages MQTT publiés par l'exemple d'application. Pour de plus amples informations sur l’utilisation du client MQTT dans la [console AWS IoT](https://console.aws.amazon.com/iot/home), veuillez consulter [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md) .
# Création de AWS IoT règles pour acheminer les données des appareils vers d'autres services
Ces didacticiels vous montrent comment créer et tester des AWS IoT règles à l'aide de certaines des actions de règles les plus courantes.
AWS IoT les règles envoient des données de vos appareils à d'autres AWS services. Ils écoutent des messages MQTT spécifiques, formatent les données contenues dans les charges utiles des messages et envoient le résultat à d'autres AWS services.
Nous vous recommandons de les essayer dans l'ordre dans lequel ils apparaissent ici, même si votre objectif est de créer une règle utilisant une fonction Lambda ou une fonction plus complexe. Les didacticiels sont présentés dans l'ordre du plus élémentaire au plus complexe. Ils présentent de nouveaux concepts de manière progressive afin de vous aider à apprendre les concepts que vous pouvez utiliser pour créer les actions de règles qui ne font pas l'objet d'un didacticiel spécifique.
**Note**
AWS IoT les règles vous aident à envoyer les données de vos appareils IoT vers d'autres AWS services. Pour le faire avec succès, vous devez toutefois avoir une connaissance pratique des autres services auxquels vous souhaitez envoyer des données. Bien que ces didacticiels fournissent les informations nécessaires pour effectuer les tâches, vous trouverez peut-être utile d'en savoir plus sur les services auxquels vous souhaitez envoyer des données avant de les utiliser dans votre solution. Une explication détaillée des autres AWS services n'entre pas dans le cadre de ces didacticiels.
**Présentation des scénarios de didacticiel**
Le scénario de ces didacticiels est celui d'un capteur météo qui publie périodiquement ses données. Il existe de nombreux capteurs de ce type dans ce système imaginaire. Les didacticiels de cette section se concentrent toutefois sur un seul appareil tout en montrant comment vous pouvez intégrer plusieurs capteurs.
Les didacticiels de cette section vous montrent comment utiliser des AWS IoT règles pour effectuer les tâches suivantes avec ce système imaginaire de capteurs météorologiques.
+
**[Tutoriel : Republication d'un message MQTT](iot-repub-rule.md)**
Ce didacticiel montre comment republier un message MQTT reçu des capteurs météorologiques sous la forme d'un message contenant uniquement l'identifiant du capteur et la valeur de température. Il utilise uniquement AWS IoT Core des services et montre une requête SQL simple et explique comment utiliser le client MQTT pour tester votre règle.
+
**[Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)**
Ce didacticiel explique comment envoyer un message SNS lorsqu'une valeur d'un capteur météo dépasse une valeur spécifique. Il s'appuie sur les concepts présentés dans le didacticiel précédent et explique comment travailler avec un autre AWS service, l'[Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) (Amazon SNS).
Si vous débutez avec Amazon SNS, consultez ses exercices de [mise en route](https://docs.aws.amazon.com//sns/latest/dg/sns-getting-started.html) avant de commencer ce didacticiel.
+
**[Tutoriel : Stockage des données de l'appareil dans une table DynamoDB](iot-ddb-rule.md)**
Ce didacticiel montre comment stocker les données des capteurs météorologiques dans une table de base de données. Il utilise l'énoncé de requête de règle et les modèles de substitution pour formater les données des messages pour le service de destination, [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html).
Si vous utilisez DynamoDB pour la première fois, consultez ses exercices de [mise en route](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) avant de commencer ce didacticiel.
+
**[Tutoriel : Formatage d'une notification à l'aide d'une AWS Lambda fonction](iot-lambda-rule.md)**
Ce didacticiel explique comment appeler une fonction Lambda pour reformater les données de l'appareil, puis les envoyer sous forme de message texte. Il ajoute un script Python et des fonctions du AWS SDK dans une [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)fonction permettant de formater avec le message les données de charge utile provenant des capteurs météorologiques et d'envoyer un message texte.
Si vous utilisez Lambda pour la première fois, consultez ses exercices de [mise en route](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) avant de commencer ce didacticiel.
**AWS IoT vue d'ensemble des règles**
Tous ces didacticiels créent des AWS IoT règles.
Pour qu'une AWS IoT règle envoie les données d'un appareil à un autre AWS service, elle utilise :
+ Une déclararionde requête de règle composée des éléments suivants :
+ Une clause SQL SELECT qui sélectionne et met en forme les données de la charge utile du message
+ Un filtre de rubrique (l'objet FROM dans l'déclararionde requête de règle) qui identifie les messages à utiliser
+ Une déclararionconditionnelle facultative (une clause SQL WHERE) qui spécifie les conditions spécifiques sur lesquelles agir
+ Au moins une action de règle
Les appareils publient des messages dans des rubriques MQTT. Le filtre de rubrique de l'déclararionSQL SELECT identifie les objets MQTT auxquels appliquer la règle. Les champs spécifiés dans l'déclararionSQL SELECT mettent en forme les données de la charge utile du message MQTT entrant afin qu'elles soient utilisées par les actions de la règle. Pour obtenir la liste complète des actions de règle, consultez [Actions de règle AWS IoT](iot-rule-actions.md).
**Topics**
+ [Tutoriel : Republication d'un message MQTT](iot-repub-rule.md)
+ [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)
+ [Tutoriel : Stockage des données de l'appareil dans une table DynamoDB](iot-ddb-rule.md)
+ [Tutoriel : Formatage d'une notification à l'aide d'une AWS Lambda fonction](iot-lambda-rule.md)
# Tutoriel : Republication d'un message MQTT
Ce didacticiel explique comment créer une AWS IoT règle qui publie un message MQTT lorsqu'un message MQTT spécifié est reçu. La charge utile des messages entrants peut être modifiée par la règle avant sa publication. Cela permet de créer des messages adaptés à des applications spécifiques sans qu'il soit nécessaire de modifier votre appareil ou son microprogramme. Vous pouvez également utiliser l'aspect filtrage d'une règle pour publier des messages uniquement lorsqu'une condition spécifique est remplie.
Les messages republiés par une règle agissent comme des messages envoyés par n'importe quel autre AWS IoT appareil ou client. Les appareils peuvent s'abonner aux messages republiés de la même manière qu'ils peuvent s'abonner à n'importe quel autre objet de message MQTT.
**Ce que vous allez apprendre dans ce didacticiel :**
+ Comment utiliser des requêtes et des fonctions SQL simples dans une déclararionde requête de règle
+ Comment utiliser le client MQTT pour tester une règle AWS IoT
Ce didacticiel vous prendra environ 30 minutes.
**Topics**
+ [Passez en revue les sujets et AWS IoT les règles du MQTT](#iot-repub-rule-mqtt)
+ [Étape 1 : créer une AWS IoT règle pour republier un message MQTT](#iot-repub-rule-define)
+ [Étape 2 : Test de votre règle](#iot-repub-rule-test)
+ [Étape 3 : examen des résultats et des étapes suivantes](#iot-repub-rule-review)
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+
**[Configurez Compte AWS](setting-up.md)**
Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
+
**Révisé [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md)**
Assurez-vous de pouvoir utiliser le client MQTT pour vous abonner à un objet et le publier. Vous allez utiliser le client MQTT pour tester votre nouvelle règle dans le cadre de cette procédure.
## Passez en revue les sujets et AWS IoT les règles du MQTT
Avant de parler de AWS IoT règles, il est utile de comprendre le protocole MQTT. Dans les solutions IoT, le protocole MQTT offre certains avantages par rapport aux autres protocoles de communication réseau, tels que le HTTP, ce qui en fait un choix populaire pour les appareils IoT. Cette section passe en revue les principaux aspects du MQTT tels qu'ils s'appliquent à ce didacticiel. Pour plus d'informations sur la comparaison entre MQTT et HTTP, consultez [Choix d'un protocole d'application pour la communication de votre appareil](protocols.md#protocol-selection).
**Protocole MQTT**
Le protocole MQTT utilise un modèle publish/subscribe de communication avec son hôte. Pour envoyer des données, les appareils publient des messages identifiés par des sujets sur le courtier de AWS IoT messages. Pour recevoir des messages du courtier de messages, les appareils s'abonnent aux objets qu'ils recevront en envoyant des filtres de objets dans les demandes d'abonnement adressées au courtier de messages. Le moteur de AWS IoT règles reçoit les messages MQTT du courtier de messages.
**AWS IoT règles**
AWS IoT les règles consistent en une instruction de requête de règle et une ou plusieurs actions de règles. Lorsque le moteur de AWS IoT règles reçoit un message MQTT, ces éléments agissent sur le message comme suit.
+
**Déclaration de requête de règle**
L'déclararionde requête de la règle décrit les objets MQTT à utiliser, interprète les données issues de la charge utile du message et met en forme les données comme décrit par une déclararionSQL similaire aux instructions utilisées par les bases de données SQL courantes. Le résultat de l'déclararionde requête correspond aux données envoyées aux actions de la règle.
+
**Action de règle**
Chaque action de règle d'une règle agit sur les données qui résultent de l'instruction de requête de la règle. AWS IoT prend en charge [de nombreuses actions de règles](iot-rule-actions.md). Dans ce didacticiel, vous allez toutefois vous concentrer sur l'action de la [Republier](republish-rule-action.md) règle, qui publie le résultat de l'déclararionde requête sous forme de message MQTT avec un objet spécifique.
## Étape 1 : créer une AWS IoT règle pour republier un message MQTT
La AWS IoT règle que vous allez créer dans ce didacticiel s'abonne aux rubriques `device/device_id/data` MQTT où *device\$1id* figure l'identifiant de l'appareil qui a envoyé le message. Ces rubriques sont décrites par un [filtre de rubrique](topics.md#topicfilters) en tan que `device/+/data`, où le `+` est un caractère générique correspondant à n'importe quelle chaîne située entre les deux barres obliques.
Lorsque la règle reçoit un message d'un objet correspondant, elle republie les valeurs `device_id` et `temperature` sous la forme d'un nouveau message MQTT avec l’ `device/data/temp` objet.
Par exemple, la charge utile d'un message MQTT avec l’ `device/22/data` objet se présente comme suit :
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
La règle prend la `temperature` valeur de la charge utile du message et celle `device_id` de l'objet, et les republie sous forme de message MQTT avec le `device/data/temp` objet et une charge utile du message qui ressemblent à ceci :
```
{
"device_id": "22",
"temperature": 28
}
```
Avec cette règle, les appareils qui n'ont besoin que de l'identifiant de l'appareil et des données de température s'abonnent à la `device/data/temp` rubrique pour ne recevoir que ces informations.
**Pour créer une règle qui republie un message MQTT**
1. Ouvrez [le hub de **règles** de la AWS IoT console](https://console.aws.amazon.com//iot/home#/rulehub).
1. Dans **Règles**, choisissez **Créer** et commencez à créer votre nouvelle règle.
1. Dans la partie supérieure de **Créer une règle** :
1. Dans **Nom**, entrez le nom de la règle. Pour ce didacticiel, nommez le **republish\$1temp**.
N'oubliez pas qu'un nom de règle doit être unique au sein de votre compte et de votre région, et qu'il ne doit pas comporter d'espaces. Nous avons utilisé un trait de soulignement dans ce nom pour séparer les deux mots du nom de la règle.
1. Dans **Description**, décrivez la règle.
Une description significative vous permet de vous souvenir du rôle de cette règle et de la raison pour laquelle vous l'avez créée. La description peut être aussi longue que nécessaire, donc soyez aussi détaillée que possible.
1. Dans l'**déclararionde requête règle** de **Create a rule** :
1. Dans **Utiliser la version SQL**, sélectionnez **2016-03-23**.
1. Dans la zone d'édition de la **instruction de requête de règle**, entrez l'instruction :
```
SELECT topic(2) as device_id, temperature FROM 'device/+/data'
```
Cette instruction :
+ Écoute les messages MQTT dont le objet correspond au filtre de `device/+/data` objet.
+ Sélectionne le deuxième élément dans la chaîne de l'objet et l'affecte au `device_id` champ.
+ Sélectionne le `temperature` champ de valeur dans la charge utile du message et l'affecte au `temperature` champ.
1. Dans **Définir une ou plusieurs actions** :
1. Pour ouvrir la liste des actions de règle pour cette règle, choisissez **Ajouter une action**.
1. Dans **Sélectionner une action**, choisissez **Republier un message dans un AWS IoT sujet**.
1. Au bas de la liste d'actions, choisissez **Configurer l'action** pour ouvrir la page de configuration de l'action sélectionnée.
1. Sous **Configurer les actions** :
1. Dans **Sujet**, entrez **device/data/temp**. Il s'agit de l'objet MQTT du message que cette règle publiera.
1. Dans **Qualité de service**, choisissez **0 - Le message est délivré zéro fois ou plus**.
1. Dans **Choisir ou créer un rôle pour accorder AWS IoT l'accès pour effectuer cette action** :
1. Choisissez **Create Role** (Créer un rôle). La boîte de dialogue **Créer un rôle** s'ouvre.
1. Saisissez un nom qui décrit le nouveau rôle. Dans le cadre de ce tutoriel, utilisez **republish\$1role**.
Lorsque vous créez un nouveau rôle, les politiques appropriées pour exécuter l'action de la règle sont créées et associées au nouveau rôle. Si vous modifiez le objet de cette action de règle ou si vous utilisez ce rôle dans une autre action de règle, vous devez mettre à jour la politique de ce rôle afin d'autoriser le nouveau objet ou la nouvelle action. Pour mettre à jour un rôle existant, choisissez **Mettre à jour le rôle** dans cette section.
1. Choisissez **Create Role** pour créer le rôle et fermer la boîte de dialogue.
1. Choisissez **Ajouter une action** pour ajouter l'action à la règle et revenez à la page **Créer une règle**.
1. L'action **Republier un message dans un AWS IoT sujet** est désormais répertoriée dans **Définir une ou plusieurs actions**.
Dans la vignette de la nouvelle action, sous **Republier un message dans un AWS IoT objet**, vous pouvez voir le objet dans lequel votre action de republication sera publiée.
Il s'agit de la seule action de règle que vous ajouterez à cette règle.
1. Dans **Créer une règle**, faites défiler l'écran vers le bas et choisissez **Créer une règle** pour créer la règle et terminer cette étape.
## Étape 2 : Test de votre règle
Pour tester votre nouvelle règle, vous allez utiliser le client MQTT pour publier et vous abonner aux messages MQTT utilisés par cette règle.
Ouvrez le [client MQTT dans la AWS IoT console](https://console.aws.amazon.com//iot/home#/test) dans une nouvelle fenêtre. Cela vous permettra de modifier la règle sans perdre la configuration de votre client MQTT. Le client MQTT ne conserve aucun abonnement ou journal de messages si vous le quittez pour accéder à une autre page de la console.
**Vous pouvez utiliser le client MQTT pour tester votre règle.**
1. Dans le [client MQTT de la AWS IoT console](https://console.aws.amazon.com//iot/home#/test), abonnez-vous aux rubriques d'entrée, dans ce cas, `device/+/data`.
1. Dans le client MQTT, sous Souscriptions, choisissez Publish to topic.
1. Dans **Sujet d'abonnement**, entrez le objet du filtre de objet d'entrée,**device/\$1/data**.
1. Conservez les valeurs par défaut des autres paramètres.
1. Choisissez **Subscribe to topic (S'abonner à la rubrique)**.
Dans la colonne **Abonnements**, la section **Publier dans un objet** **device/\$1/data** apparaît.
1. Abonnez-vous à l’objet que votre règle publiera :`device/data/temp`.
1. Sous **Abonnements**, choisissez **S’abonner à un objet** nouveau, puis dans **Sujet d'abonnement**, entrez l’objet du message republié,**device/data/temp**.
1. Conservez les paramètres par défaut du reste des champs
1. Choisissez **Subscribe to topic (S'abonner à la rubrique)**.
Dans la colonne **Abonnements**, la section **appareil/\$1/data**, **device/data/temp** apparaît.
1. Publiez un message sur le objet d'entrée avec un identifiant d'appareil spécifique, **device/22/data**. Vous ne pouvez pas publier au format MQTT des objets contenant des caractères génériques.
1. Dans le client MQTT, sous **Souscriptions**, choisissez **Publier dans la rubrique**.
1. Dans le champ **Publier**, entrez le nom de l'objet d'entrée, **device/22/data**.
1. Copiez les exemples de données présentés ici et, dans la zone d'édition située sous le nom de l'objet, collez les exemples de données.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Pour envoyer votre message MQTT, choisissez **Publier dans le objet**.
1. Passez en revue les messages qui ont été envoyés.
1. Dans le client MQTT, sous **Abonnements**, il y a un point vert à côté des deux objets auxquels vous vous êtes abonné précédemment.
Les points verts indiquent qu'un ou plusieurs nouveaux messages ont été reçus depuis la dernière fois que vous les avez consultés.
1. Sous **Abonnements**, choisissez **device/\$1/data** pour vérifier que la charge utile du message correspond à ce que vous venez de publier et ressemble à ceci :
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Sous **Abonnements**, choisissez **device/data/temp**de vérifier que la charge utile de vos messages republiés ressemble à ceci :
```
{
"device_id": "22",
"temperature": 28
}
```
Notez que la `device_id` valeur est une chaîne entre guillemets et que la `temperature` valeur est numérique. Cela est dû au fait que la [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) fonction a extrait la chaîne du nom de l'objet du message d'entrée tandis que la `temperature` valeur utilise la valeur numérique de la charge utile du message d'entrée.
Si vous souhaitez transformer la `device_id` valeur en valeur numérique, remplacez-la `topic(2)` dans l'déclararionde requête de règle par :
```
cast(topic(2) AS DECIMAL)
```
Notez que la conversion de la `topic(2)` valeur en valeur numérique ne fonctionnera que si cette partie de la rubrique contient uniquement des caractères numériques.
1. Si vous constatez que le message correct a été publié dans le **device/data/temp**sujet, cela signifie que votre règle a fonctionné. Découvrez les informations supplémentaires que vous pouvez obtenir sur l'action Republier la règle dans la section suivante.
Si vous ne voyez pas que le message correct a été publié sur l'**appareil/\$1/data** ou **device/data/temp**sur les rubriques, consultez les conseils de dépannage.
### Résolution des problèmes liés à la règle de republication des messages
Voici quelques points à vérifier au cas où vous n'obtiendriez pas les résultats escomptés.
+
**Vous avez reçu une bannière d'erreur**
Si une erreur est apparue lorsque vous avez publié le message d'entrée, corrigez-la d'abord. Les étapes suivantes peuvent vous aider à corriger cette erreur.
+
**Vous ne voyez pas le message d'entrée dans le client MQTT**
Chaque fois que vous publiez votre message d'entrée dans le `device/22/data` objet, ce message doit apparaître dans le client MQTT si vous vous êtes abonné au filtre de `device/+/data` objet comme décrit dans la procédure.
**À savoir**
+
**Vérifiez le filtre de objets auquel vous vous êtes abonné**
Si vous vous êtes abonné au objet du message d'entrée comme décrit dans la procédure, vous devriez voir une copie du message d'entrée chaque fois que vous le publiez.
Si le message ne s'affiche pas, vérifiez le nom de l'objet auquel vous vous êtes abonné et comparez-le au objet dans lequel vous avez publié. Les noms des objets distinguent les majuscules et minuscules et le objet auquel vous vous êtes abonné doit être identique au objet dans lequel vous avez publié la charge utile du message.
+
**Vérifiez la fonction de publication des messages**
Dans le client MQTT, sous **Abonnements**, choisissez **device/\$1/data**, vérifiez l’objet du message de publication, puis choisissez **Publier dans le objet.** La charge utile du message figurant dans la zone d'édition située sous le objet devrait apparaître dans la liste des messages.
+
**Vous ne voyez pas votre message republié dans le client MQTT**
Pour que votre règle fonctionne, elle doit disposer de la politique appropriée qui l'autorise à recevoir et à republier un message et elle doit recevoir le message.
**À savoir**
+
**Vérifiez le nom Région AWS de votre client MQTT et la règle que vous avez créée**
La console dans laquelle vous exécutez le client MQTT doit se trouver dans la même AWS région que la règle que vous avez créée.
+
**Vérifiez le objet du message d'entrée dans la déclaration de requête de règle**
Pour que la règle fonctionne, elle doit recevoir un message dont le nom de rubrique correspond au filtre de rubrique figurant dans la clause FROM de l'déclararionde requête de règle.
Vérifiez l'orthographe du filtre de rubrique dans l'déclararionde requête de règle avec celle de l'objet dans le client MQTT. Les noms de objets distinguent les majuscules et minuscules et le objet du message doit correspondre au filtre de objet indiqué dans l'déclararionde requête de règle.
+
**Vérifiez le contenu de la charge utile des messages d'entrée**
Pour que la règle fonctionne, elle doit trouver le champ de données dans la charge utile du message déclarée dans l'déclararionSELECT.
Vérifiez l'orthographe du `temperature` champ dans l'déclararionde requête de règle avec celle de la charge utile du message dans le client MQTT. Les noms de champs distinguent les majuscules et minuscules et le `temperature` champ de l'déclararionde requête de règle doit être identique au `temperature` champ de la charge du message.
Assurez-vous que le document JSON contenu dans la charge utile du message est correctement formaté. Si le JSON contient des erreurs, telles qu'une virgule manquante, la règle ne pourra pas le lire.
+
**Vérifiez le objet du message republié dans l'action de la règle**
Le objet auquel l'action Republier la règle publie le nouveau message doit correspondre au objet auquel vous vous êtes abonné dans le client MQTT.
Ouvrez la règle que vous avez créée dans la console et vérifiez le objet dans lequel l'action de règle republiera le message.
+
**Vérifiez le rôle utilisé par la règle**
L'action de règle doit être autorisée à recevoir le objet d'origine et à publier le nouveau objet.
Les politiques qui autorisent la règle à recevoir les données des messages et à les republier sont spécifiques aux objets utilisés. Si vous modifiez le objet utilisé pour republier les données du message, vous devez mettre à jour le rôle de l'action de règle afin de mettre à jour sa politique afin qu'elle corresponde au objet actuel.
Si vous pensez que c'est le problème, modifiez l'action Republier la règle et créez un nouveau rôle. Les nouveaux rôles créés par l'action de règle reçoivent les autorisations nécessaires pour effectuer ces actions.
## Étape 3 : examen des résultats et des étapes suivantes
**Dans ce tutoriel**
+ Vous avez utilisé une simple requête SQL et quelques fonctions dans une instruction de requête de règle pour produire un nouveau message MQTT.
+ Vous avez créé une règle qui republie ce nouveau message.
+ Vous avez utilisé le client MQTT pour tester votre AWS IoT règle.
**Étapes suivantes**
Après avoir republié quelques messages avec cette règle, essayez de l'utiliser pour voir comment la modification de certains aspects du didacticiel affecte le message republié. Voici quelques idées pour vous aider à démarrer.
+ Modifiez le *device\$1id* sujet du message d'entrée et observez l'effet sur la charge utile du message republié.
+ Modifiez les champs sélectionnés dans l'déclararionde requête de règle et observez l'effet sur la charge utile des messages republiés.
+ Essayez le prochain didacticiel de cette série et découvrez comment [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md).
L'action Republier la règle utilisée dans ce didacticiel peut également vous aider à déboguer les instructions de requête relatives aux règles. Par exemple, vous pouvez ajouter cette action à une règle pour voir comment son déclararionde requête de règle met en forme les données utilisées par ses actions de règle.
# Tutoriel : envoi d'une notification Amazon SNS
Ce didacticiel explique comment créer une AWS IoT règle qui envoie des données de message MQTT à une rubrique Amazon SNS afin qu'elles puissent être envoyées sous forme de SMS.
Dans ce didacticiel, vous allez créer une règle qui envoie des données de message depuis un capteur météo à tous les abonnés d'une rubrique Amazon SNS, chaque fois que la température dépasse la valeur définie dans la règle. La règle détecte lorsque la température signalée dépasse la valeur définie par la règle, puis crée une nouvelle charge utile de message qui inclut uniquement l'identifiant de l'appareil, la température signalée et la limite de température dépassée. La règle envoie la charge du nouveau message sous forme de document JSON à une rubrique SNS, qui avertit tous les abonnés à la rubrique SNS.
**Ce que vous allez apprendre dans ce didacticiel :**
+ Comment créer et tester une notification Amazon SNS
+ Comment appeler une notification Amazon SNS à partir d'une règle AWS IoT
+ Comment utiliser des requêtes et des fonctions SQL simples dans une déclararionde requête de règle
+ Comment utiliser le client MQTT pour tester une règle AWS IoT
Ce didacticiel vous prendra environ 30 minutes.
**Topics**
+ [Étape 1 : créer une rubrique Amazon SNS qui envoie un message texte SMS](#iot-sns-rule-create-sns-topic)
+ [Étape 2 : créer une AWS IoT règle pour envoyer le message texte](#iot-sns-rule-create-rule)
+ [Étape 3 : tester la AWS IoT règle et la notification Amazon SNS](#iot-sns-rule-test-rule)
+ [Étape 4 : examen des résultats et des étapes suivantes](#iot-sns-rule-review-results)
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+
**[Configurez Compte AWS](setting-up.md)**
Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
+
**Révisé [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md)**
Assurez-vous de pouvoir utiliser le client MQTT pour vous abonner à un objet et le publier. Vous allez utiliser le client MQTT pour tester votre nouvelle règle dans le cadre de cette procédure.
+
**Révisé le [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html)**
Si vous n'avez jamais utilisé Amazon SNS auparavant, consultez [Configuration de l'accès à Amazon SNS.](https://docs.aws.amazon.com//sns/latest/dg/sns-setting-up.html) Si vous avez déjà suivi d'autres AWS IoT didacticiels, vous Compte AWS devriez déjà être correctement configuré.
## Étape 1 : créer une rubrique Amazon SNS qui envoie un message texte SMS
Cette procédure explique comment créer la rubrique Amazon SNS à laquelle votre capteur météo peut envoyer des données de message. La rubrique Amazon SNS informera ensuite tous ses abonnés par SMS de la limite de température dépassée.
**Créer une rubrique Amazon SNS qui envoie un SMS**
1. **Créer une rubrique Amazon SNS**.
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com//sns/home).
1. Dans le panneau de navigation de gauche, choisissez **Rubriques**.
1. Sur la page **Rubriques**, choisissez **Créer une rubrique**.
1. Dans **Détails**, choisissez le type **Standard**. Par défaut, la console crée une rubrique FIFO.
1. Dans **Nom**, entrez le nom de la rubrique SNS. Dans le cadre de ce didacticiel, entrez **high\$1temp\$1notice**.
1. Faites défiler la page jusqu'en bas et choisissez **Créer une rubrique**.
La console ouvre la page **Détails** de la nouvelle rubrique.
1. **Créez un abonnement Amazon SNS.**
**Note**
Le numéro de téléphone que vous utilisez dans cet abonnement peut entraîner des frais de messagerie texte en raison des messages que vous allez envoyer dans ce didacticiel.
1. Sur la page des détails de la rubrique **high\$1temp\$1notice**, sélectionnez **Créer un abonnement**.
1. Dans **Créer un abonnement**, dans la section **Détails**, dans la liste des **protocoles**, choisissez **SMS**.
1. Dans **Endpoint**, entrez le numéro d'un téléphone pouvant recevoir des SMS. Assurez-vous de le saisir de telle sorte qu'il commence par un `+`, qu'il inclue le code du pays et de la région, et qu'il n'inclue aucun autre caractère de ponctuation.
1. Choisissez **Créer un abonnement**.
1. **Testez la notification Amazon SNS.**
1. Dans la [console Amazon SNS](https://console.aws.amazon.com//sns/home), dans le volet de navigation de gauche, choisissez **Rubrique**.
1. Pour ouvrir la page de détails de l'objet, dans **Rubriques**, dans la liste des objets, choisissez **high\$1temp\$1notice**.
1. Pour ouvrir la page **Publier le message dans le objet**, sur la page de détails de **high\$1temp\$1notice**, choisissez **Publier le message.**
1. Dans **Publier le message dans le objet**, dans la section **Corps du message**, dans **le corps du message à envoyer au point de terminaison**, entrez un message court.
1. Faites défiler la page vers le bas et choisissez **Publier des message**.
1. Sur le téléphone avec le numéro que vous avez utilisé précédemment lors de la création de l'abonnement, confirmez que le message a bien été reçu.
Si vous n'avez pas reçu le message de test, vérifiez le numéro de téléphone et les paramètres de votre téléphone.
Assurez-vous de pouvoir publier des messages de test depuis la [console Amazon SNS](https://console.aws.amazon.com//sns/home) avant de poursuivre le didacticiel.
## Étape 2 : créer une AWS IoT règle pour envoyer le message texte
La AWS IoT règle que vous allez créer dans ce didacticiel s'abonne aux rubriques `device/device_id/data` MQTT où `device_id` figure l'identifiant de l'appareil qui a envoyé le message. Ces rubriques sont décrites dans un filtre de rubrique sous `device/+/data`, où la `+` est un caractère générique qui correspond à n'importe quelle chaîne de caractères comprise entre les deux barres obliques. Cette règle teste également la valeur du `temperature` champ dans la charge utile du message.
Lorsque la règle reçoit un message d'une rubrique correspondante, `device_id` elle prend du nom de l'objet, la `temperature` valeur de la charge utile du message, ajoute une valeur constante pour la limite qu'elle teste, puis envoie ces valeurs sous forme de document JSON à une rubrique de notification Amazon SNS.
Par exemple, un message MQTT provenant du capteur météo numéro 32 utilise le `device/32/data` objet et contient une charge utile du message qui ressemble à ceci :
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
L'énoncé de la règle de la requête prend la `temperature` valeur de la charge de message, celle `device_id` du nom de l'objet, et ajoute la `max_temperature` valeur constante pour envoyer une charge utile de message qui ressemble à ceci à la rubrique Amazon SNS :
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30
}
```
**Pour créer une AWS IoT règle afin de détecter une valeur de température supérieure à la limite et de créer les données à envoyer à la rubrique Amazon SNS**
1. Ouvrez [le hub de **règles** de la AWS IoT console](https://console.aws.amazon.com//iot/home#/rulehub).
1. S'il s'agit de votre première règle, choisissez **Créer** ou **Créer une règle**.
1. Dans **Créer a règle**: :
1. Pour **Name (Nom)**, entrez **temp\$1limit\$1notify**.
N'oubliez pas qu'un nom de règle doit être unique dans votre région Compte AWS et qu'il ne doit pas comporter d'espaces. Nous avons utilisé un trait de soulignement dans ce nom pour séparer les mots du nom de la règle.
1. Dans **Description**, décrivez la règle.
Une description significative permet de se souvenir plus facilement du rôle de cette règle et de la raison pour laquelle vous l'avez créée. La description peut être aussi longue que nécessaire, donc soyez aussi détaillée que possible.
1. Dans ** l'déclararionde requête** règle de **Create a rule** :
1. Dans Utiliser** is a version SQL**, sélectionnez **2016-03-23**.
1. Dans la boîte d'édition Rôle d’instruction de requête entrez l'instruction :
```
SELECT topic(2) as device_id,
temperature as reported_temperature,
30 as max_temperature
FROM 'device/+/data'
WHERE temperature > 30
```
Cette instruction :
+ Écoute les messages MQTT dont le objet correspond au filtre de `device/+/data` objet et dont la `temperature` valeur est supérieure à 30.
+ Sélectionne le deuxième élément dans la chaîne de l'objet et l'affecte au `device_id` champ.
+ Sélectionne le `temperature` champ de valeur dans la charge utile du message et l'affecte au `reported_temperature` champ.
+ Crée une valeur constante `30` pour représenter la valeur limite et l'affecte au `max_temperature` champ.
1. Pour ouvrir la liste des actions de règle pour cette règle, dans **Définir une ou plusieurs actions**, choisissez **Ajouter une action**.
1. Dans **Sélectionner une action**, choisissez **Envoyer un message en tant que notification push SNS**.
1. Pour ouvrir la page de configuration de l'action sélectionnée, en bas de la liste d'actions, choisissez **Configurer l'action**.
1. Sous **Configurer les actions** :
1. **Dans **SNS target**, choisissez **Select**, recherchez votre rubrique SNS nommée **high\$1temp\$1notice**, puis sélectionnez Select.**
1. Pour **Format du message**, choisissez **RAW**.
1. Dans **Choisir ou créer un rôle pour accorder AWS IoT l'accès pour effectuer cette action**, choisissez **Créer un rôle**.
1. Dans **Créer un nouveau rôle**, dans **Nom**, entrez un nom unique pour le nouveau rôle. Dans le cadre de ce tutoriel, utilisez **sns\$1rule\$1role**.
1. Choisissez **Créer un rôle**.
Si vous répétez ce didacticiel ou si vous réutilisez un rôle existant, choisissez **Mettre à jour le rôle** avant de continuer. Cela met à jour le document de politique du rôle pour qu'il fonctionne avec la cible SNS.
1. Choisissez **Ajouter une action** et revenez à la page **Créer une règle**.
Dans la vignette de la nouvelle action, sous **Envoyer un message sous forme de notification push SNS**, vous pouvez voir la rubrique SNS que votre règle appellera.
Il s'agit de la seule action de règle que vous ajouterez à cette règle.
1. Pour créer la règle et terminer cette étape, dans **Créer une règle**, faites défiler la page vers le bas et choisissez **Créer une règle**.
## Étape 3 : tester la AWS IoT règle et la notification Amazon SNS
Pour tester votre nouvelle règle, vous allez utiliser le client MQTT pour publier et vous abonner aux messages MQTT utilisés par cette règle.
Ouvrez le [client MQTT dans la AWS IoT console](https://console.aws.amazon.com//iot/home#/test) dans une nouvelle fenêtre. Cela vous permettra de modifier la règle sans perdre la configuration de votre client MQTT. Si vous quittez le client MQTT pour accéder à une autre page de la console, il ne conservera aucun abonnement ni journal de messages.
**Vous pouvez utiliser le client MQTT pour tester votre règle.**
1. Dans le [client MQTT de la AWS IoT console](https://console.aws.amazon.com//iot/home#/test), abonnez-vous aux rubriques d'entrée, dans ce cas, `device/+/data`.
1. Dans le client MQTT, sous Souscriptions, choisissez Publish to topic.
1. Dans **Sujet d'abonnement**, entrez le objet du filtre de objet d'entrée,**device/\$1/data**.
1. Conservez les valeurs par défaut des autres paramètres.
1. Choisissez **Subscribe to topic (S'abonner à la rubrique)**.
Dans la colonne **Abonnements**, la section **Publier dans un objet** **device/\$1/data** apparaît.
1. Publiez un message sur le objet d'entrée avec un identifiant d'appareil spécifique, **device/32/data**. Vous ne pouvez pas publier au format MQTT des objets contenant des caractères génériques.
1. Dans le client MQTT, sous **Souscriptions**, choisissez **Publier dans la rubrique**.
1. Dans le champ **Publier**, entrez le nom de l'objet d'entrée, **device/32/data**.
1. Copiez les exemples de données présentés ici et, dans la zone d'édition située sous le nom de l'objet, collez les exemples de données.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Choisissez **Publier dans la rubrique** pour publier votre message.
1. Confirmez que le message texte a été envoyé.
1. Dans le client MQTT, sous **Abonnements**, il y a un point vert à côté de l'objet auquel vous vous êtes abonné plus tôt.
Le point vert indique qu'un ou plusieurs nouveaux messages ont été reçus depuis la dernière fois que vous les avez consultés.
1. Sous **Abonnements**, choisissez **device/\$1/data** pour vérifier que la charge utile du message correspond à ce que vous venez de publier et ressemble à ceci :
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Vérifiez le téléphone que vous avez utilisé pour vous abonner à la rubrique SNS et vérifiez que le contenu de la charge utile du message ressemble à ceci :
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
Notez que la `device_id` valeur est une chaîne entre guillemets et que la `temperature` valeur est numérique. Cela est dû au fait que la [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) fonction a extrait la chaîne du nom de l'objet du message d'entrée tandis que la `temperature` valeur utilise la valeur numérique de la charge utile du message d'entrée.
Si vous souhaitez transformer la `device_id` valeur en valeur numérique, remplacez-la `topic(2)` dans l'déclara l’instruction requête de règle par :
```
cast(topic(2) AS DECIMAL)
```
Notez que la conversion de la `topic(2)` valeur numérique, `DECIMAL` ne fonctionnera que si cette partie de l'objet contient uniquement des caractères numériques.
1. Essayez d'envoyer un message MQTT dans lequel la température ne dépasse pas la limite.
1. Dans le client MQTT, sous **Souscriptions**, choisissez **Publier dans la rubrique**.
1. Dans le champ **Publier**, entrez le nom de l'objet d'entrée, **device/33/data**.
1. Copiez les exemples de données présentés ici et, dans la zone d'édition située sous le nom de l'objet, collez les exemples de données.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Pour envoyer votre message MQTT, choisissez **Publier dans le objet**.
Vous devriez voir le message que vous avez envoyé dans l'**device/\$1/data**abonnement. Toutefois, étant donné que la valeur de température est inférieure à la température maximale indiquée dans l'déclararionde requête de règle, vous ne devriez pas recevoir de message texte.
Si vous ne voyez pas le comportement correct, consultez les conseils de dépannage.
### Résolution des problèmes liés à votre règle de message SNS
Voici quelques points à vérifier, au cas où vous n'obtiendriez pas les résultats escomptés.
+
**Vous avez reçu une bannière d'erreur**
Si une erreur est apparue lorsque vous avez publié le message d'entrée, corrigez-la d'abord. Les étapes suivantes peuvent vous aider à corriger cette erreur.
+
**Vous ne voyez pas le message d'entrée dans le client MQTT**
Chaque fois que vous publiez votre message d'entrée dans l’`device/22/data` objet, ce message doit apparaître dans le client MQTT, si vous vous êtes abonné au filtre de `device/+/data` objet comme décrit dans la procédure.
**À savoir**
+
**Vérifiez le filtre de objets auquel vous vous êtes abonné**
Si vous vous êtes abonné au objet du message d'entrée comme décrit dans la procédure, vous devriez voir une copie du message d'entrée chaque fois que vous le publiez.
Si le message ne s'affiche pas, vérifiez le nom de l'objet auquel vous vous êtes abonné et comparez-le au objet dans lequel vous avez publié. Les noms des objets distinguent les majuscules et minuscules et le objet auquel vous vous êtes abonné doit être identique au objet dans lequel vous avez publié la charge utile du message.
+
**Vérifiez la fonction de publication des messages**
Dans le client MQTT, sous **Abonnements**, choisissez **device/\$1/data**, vérifiez l’objet du message de publication, puis choisissez **Publier dans le objet.** La charge utile du message figurant dans la zone d'édition située sous le objet devrait apparaître dans la liste des messages.
+
**Si vous ne recevez pas le message :**
Pour que votre règle fonctionne, elle doit disposer de la politique appropriée l'autorisant à recevoir un message et à envoyer une notification SNS, et elle doit recevoir le message.
**À savoir**
+
**Vérifiez le nom Région AWS de votre client MQTT et la règle que vous avez créée**
La console dans laquelle vous exécutez le client MQTT doit se trouver dans la même AWS région que la règle que vous avez créée.
+
**Vérifiez que la valeur de température dans la charge utile du message dépasse le seuil de test**
Si la valeur de température est inférieure ou égale à 30, telle que définie dans l'déclararionde requête de règle, la règle n'exécutera aucune de ses actions.
+
**Vérifiez le objet du message d'entrée dans la déclaration de requête de règle**
Pour que la règle fonctionne, elle doit recevoir un message dont le nom de rubrique correspond au filtre de rubrique figurant dans la clause FROM de l'déclararionde requête de règle.
Vérifiez l'orthographe du filtre de rubrique dans l'déclararionde requête de règle avec celle de l'objet dans le client MQTT. Les noms de objets distinguent les majuscules et minuscules et le objet du message doit correspondre au filtre de objet indiqué dans l'déclararionde requête de règle.
+
**Vérifiez le contenu de la charge utile des messages d'entrée**
Pour que la règle fonctionne, elle doit trouver le champ de données dans la charge utile du message déclarée dans l'déclararionSELECT.
Vérifiez l'orthographe du `temperature` champ dans l'déclararionde requête de règle avec celle de la charge utile du message dans le client MQTT. Les noms de champs distinguent les majuscules et minuscules et le `temperature` champ de l'déclararionde requête de règle doit être identique au `temperature` champ de la charge du message.
Assurez-vous que le document JSON contenu dans la charge utile du message est correctement formaté. Si le JSON contient des erreurs, telles qu'une virgule manquante, la règle ne pourra pas le lire.
+
**Vérifiez le objet du message republié dans l'action de la règle**
Le objet auquel l'action Republier la règle publie le nouveau message doit correspondre au objet auquel vous vous êtes abonné dans le client MQTT.
Ouvrez la règle que vous avez créée dans la console et vérifiez le objet dans lequel l'action de règle republiera le message.
+
**Vérifiez le rôle utilisé par la règle**
L'action de règle doit être autorisée à recevoir le objet d'origine et à publier le nouveau objet.
Les politiques qui autorisent la règle à recevoir les données des messages et à les republier sont spécifiques aux objets utilisés. Si vous modifiez le objet utilisé pour republier les données du message, vous devez mettre à jour le rôle de l'action de règle afin de mettre à jour sa politique afin qu'elle corresponde au objet actuel.
Si vous pensez que c'est le problème, modifiez l'action Republier la règle et créez un nouveau rôle. Les nouveaux rôles créés par l'action de règle reçoivent les autorisations nécessaires pour effectuer ces actions.
## Étape 4 : examen des résultats et des étapes suivantes
**Dans ce tutoriel :**
+ Vous avez créé et testé une rubrique de notification Amazon SNS ainsi qu'un abonnement.
+ Vous avez utilisé une requête SQL simple et des fonctions dans une déclararionde requête de règle pour créer un nouveau message pour votre notification.
+ Vous avez créé une AWS IoT règle pour envoyer une notification Amazon SNS utilisant la charge utile de vos messages personnalisés.
+ Vous avez utilisé le client MQTT pour tester votre AWS IoT règle.
**Étapes suivantes**
Après avoir envoyé quelques SMS avec cette règle, essayez de l'utiliser pour voir comment la modification de certains aspects du didacticiel affecte le message et le moment où il est envoyé. Voici quelques idées pour vous aider à démarrer.
+ Modifiez le *device\$1id* sujet du message d'entrée et observez l'effet dans le contenu du message texte.
+ Modifiez les champs sélectionnés dans l'déclararionde requête de règle et observez l'effet dans le contenu du message texte.
+ Modifiez le test dans l'déclararionde requête de règle pour tester une température minimale au lieu d'une température maximale. N'oubliez pas de changer le nom de `max_temperature` \$1
+ Ajoutez une action de règle de republication pour envoyer un message MQTT lorsqu'une notification SNS est envoyée.
+ Essayez le prochain didacticiel de cette série et découvrez comment [Tutoriel : Stockage des données de l'appareil dans une table DynamoDB](iot-ddb-rule.md) .
# Tutoriel : Stockage des données de l'appareil dans une table DynamoDB
Ce didacticiel explique comment créer une AWS IoT règle qui envoie des données de message à une table DynamoDB.
Dans ce didacticiel, vous allez créer une règle qui envoie les données des messages d'un capteur météo imaginaire vers une table DynamoDB. La règle met en forme les données de nombreux capteurs météorologiques de manière à ce qu'elles puissent être ajoutées à une seule table de base de données.
**Ce que vous allez apprendre dans ce didacticiel**
+ Pour créer une table DynamoDB
+ Comment envoyer des données de message à une table DynamoDB à partir d'une règle AWS IoT
+ Comment utiliser des modèles de substitution dans une AWS IoT règle
+ Comment utiliser des requêtes et des fonctions SQL simples dans une déclararionde requête de règle
+ Comment utiliser le client MQTT pour tester une règle AWS IoT
Ce didacticiel vous prendra environ 30 minutes.
**Topics**
+ [Dans l'étape 1 de ce didacticiel, vous allez créer une table dans DynamoDB en utilisant l'.](#iot-ddb-rule-ddb-table)
+ [Étape 2 : créer une AWS IoT règle pour envoyer des données à la table DynamoDB](#iot-ddb-rule-topic-rule)
+ [Étape 3 : tester la AWS IoT règle et la table DynamoDB](#iot-ddb-rule-test)
+ [Étape 4 : examen des résultats et des étapes suivantes](#iot-ddb-rule-review)
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+
**[Configurez Compte AWS](setting-up.md)**
Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
+
**Révisé [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md)**
Assurez-vous de pouvoir utiliser le client MQTT pour vous abonner à un objet et le publier. Vous allez utiliser le client MQTT pour tester votre nouvelle règle dans le cadre de cette procédure.
+
**J'ai consulté la présentation [d'Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html)**
Si vous n'avez jamais utilisé DynamoDB auparavant, consultez [Mise en route with DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) pour vous familiariser avec les concepts et opérations de DynamoDB.
## Dans l'étape 1 de ce didacticiel, vous allez créer une table dans DynamoDB en utilisant l'.
Dans ce didacticiel, vous allez créer une table DynamoDB avec les attributs suivants pour enregistrer les données des capteurs météorologiques imaginaires :
+ `sample_time`est une clé primaire et décrit l'heure à laquelle l'échantillon a été enregistré.
+ `device_id`est une clé de tri et décrit le périphérique qui a fourni l'échantillon
+ `device_data`correspond aux données reçues de l'appareil et formatées par l'déclararionde requête de règle
**Pour créer la table DynamoDB pour ce didacticiel**
1. Ouvrez la [console DynamoDB](https://console.aws.amazon.com//dynamodb/home), puis choisissez **Créer une un tableau**.
1. Dans **Créer une table** :
1. Saisissez un nom de table dans la zone **Nom de la table**.
1. Dans **Clé de partition**, entrez **sample\$1time**, puis dans la liste d'options à côté du champ, sélectionnez **Number**.
1. Dans **Touche de tri**, entrez **device\$1id**, et dans la liste d'options à côté du champ, sélectionnez **Number**.
1. En bas de la page, choisissez **Create **.
Vous le définirez `device_data` ultérieurement, lorsque vous configurerez l'action de règle DynamoDB.
## Étape 2 : créer une AWS IoT règle pour envoyer des données à la table DynamoDB
Au cours de cette étape, vous allez utiliser l'déclararionde requête de règle pour formater les données provenant des capteurs météorologiques imaginaires afin de les écrire dans la table de base de données.
Voici un exemple de charge utile de messages reçue d'un capteur météo :
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Pour l'entrée de base de données, vous allez utiliser l'déclararionrule query pour aplatir la structure de la charge utile du message de manière à ce qu'elle ressemble à ceci :
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind_velocity": 22,
"wind_bearing": 255
}
```
Dans cette règle, vous utiliserez également deux [Modèles de substitution](iot-substitution-templates.md). Les modèles de substitution sont des expressions qui vous permettent d'insérer des valeurs dynamiques à partir de fonctions et de données de message.
**Pour créer la AWS IoT règle permettant d'envoyer des données à la table DynamoDB**
1. Ouvrez [les Règles du hub de la console AWS IoT](https://console.aws.amazon.com//iot/home#/rulehub). Vous pouvez également ouvrir la AWS IoT page d'accueil dans le AWS Management Console et accéder à **Routage des messages** > Règles.
1. Pour commencer à créer votre nouvelle règle dans **Règles**, choisissez **Créer une règle**.
1. Dans **Propriétés de la règle** :
1. Sous **Nom du rôle**, entrez **wx\$1data\$1ddb**.
N'oubliez pas qu'un nom de règle doit être unique dans votre région Compte AWS et qu'il ne doit pas comporter d'espaces. Nous avons utilisé un trait de soulignement dans ce nom pour séparer les deux mots du nom de la règle.
1. Dans **Description de la règle**, décrivez la règle.
Une description significative permet de se souvenir plus facilement du rôle de cette règle et de la raison pour laquelle vous l'avez créée. La description peut être aussi longue que nécessaire, donc soyez aussi détaillée que possible.
1. Choisissez **Next (Suivant)** pour continuer.
1. Dans **Instruction SQL**:
1. Dans la **version SQL**, sélectionnez**2016-03-23**.
1. Dans la zone d'édition de l'**instruction SQL**, entrez l'instruction :
```
SELECT temperature, humidity, barometer,
wind.velocity as wind_velocity,
wind.bearing as wind_bearing,
FROM 'device/+/data'
```
Cette instruction :
+ Écoute les messages MQTT dont le objet correspond au filtre de `device/+/data` objet.
+ Formate les éléments de l'`wind`attribut en tant qu'attributs individuels.
+ Transmet les `temperature`, `humidity`, et `barometer`, attributs et tels quels.
1. Choisissez **Next (Suivant)** pour continuer.
1. Dans **Rule actions** :
1. Pour ouvrir la liste des actions de règle pour cette règle, dans **Action 1**, sélectionnez**DynamoDB**.
**Note**
Assurez-vous de choisir DynamoDB et non DBv2 Dynamo comme action de règle.
1. Dans **Nom de la table**, choisissez le nom de la table DynamoDB que vous avez créée lors d'une étape précédente :. **wx\$1data**
Les champs **Type de clé de partition** et **Type de clé de tri** sont remplis avec les valeurs de votre tableau DynamoDB.
1. Dans **Clé de partition**, entrer **sample\$1time**.
1. Dans **Valeur de la clé de partition**, tapez **\$1\$1timestamp()\$1**.
Il s'agit de la première des [Modèles de substitution](iot-substitution-templates.md) que vous utiliserez dans cette règle. Au lieu d'utiliser une valeur provenant de la charge utile du message, il utilisera la valeur renvoyée par la fonction d'horodatage. Pour en savoir plus, consultez [timestamp](iot-sql-functions.md#iot-function-timestamp) dans le AWS IoT Core Guide du développeur.
1. Dans **clé de tri**, entrez **device\$1id**.
1. Dans **Valeur de la clé de tri**, entrez **\$1\$1cast(topic(2) AS DECIMAL)\$1**.
Il s'agit de la deuxième des [Modèles de substitution](iot-substitution-templates.md) que vous utiliserez dans cette règle. Il insère la valeur du deuxième élément dans le nom de l'objet, qui est l'ID de l'appareil, après l'avoir converti en valeur DÉCIMALE pour correspondre au format numérique de la clé. Pour de plus amples informations, veuillez consulter [Rubriques](iot-sql-functions.md#iot-function-topic) dans le *AWS IoT Core Guide du développeur*. Ou pour en savoir plus sur le [casting](iot-sql-functions.md#iot-sql-function-cast), consultez le *AWS IoT Core guide du développeur*.
1. Dans **Write message data to this column (Écrire des données de message dans cette colonne)**, entrez **device\$1data**.
Cela créera la `device_data` colonne dans la table DynamoDB.
1. Laissez le champ **Operation (Opération)** vide.
1. Pour Rôle IAM, choisissez Créer un rôle.********
1. Dans la boîte de dialogue **Créer un rôle**, pour **Nom du rôle**, entrez **wx\$1ddb\$1role**. Ce nouveau rôle contiendra automatiquement une politique avec le préfixe « aws-iot-rule » qui permettra à la **wx\$1data\$1ddb** règle d'envoyer des données à la table **wx\$1data** DynamoDB que vous avez créée.
1. Pour **Rôle IAM**, choisissez **wx\$1ddb\$1role**.
1. Au bas de la page, sélectionnez **Next**.
1. Au bas de la page **Réviser et créer**, choisissez **Créer** pour créer la règle.
## Étape 3 : tester la AWS IoT règle et la table DynamoDB
Pour tester la nouvelle règle, vous allez utiliser le client MQTT pour publier et vous abonner aux messages MQTT utilisés dans ce test.
Ouvrez le [client MQTT dans la AWS IoT console](https://console.aws.amazon.com//iot/home#/test) dans une nouvelle fenêtre. Cela vous permettra de modifier la règle sans perdre la configuration de votre client MQTT. Le client MQTT ne conserve aucun abonnement ou journal de messages si vous le quittez pour accéder à une autre page de la console. Vous devez également ouvrir une fenêtre de console distincte sur le [hub de tables DynamoDB de AWS IoT la console pour afficher les](https://console.aws.amazon.com//dynamodb/home#tables:) nouvelles entrées envoyées par votre règle.
**Vous pouvez utiliser le client MQTT pour tester votre règle.**
1. Dans le [client MQTT de la AWS IoT console](https://console.aws.amazon.com//iot/home#/test), abonnez-vous au objet d'entrée,`device/+/data`.
1. Dans le client MQTT, choisissez ** Publier dans une rubrique.**
1. Pour le **filtre de objet**, entrez l’objet du filtre de l’objet d'entrée, **device/\$1/data**.
1. Choisissez **Souscrire**.
1. Maintenant, publiez un message sur le objet d'entrée avec un identifiant d'appareil spécifique, **device/22/data**. Vous ne pouvez pas publier au format MQTT des objets contenant des caractères génériques.
1. Dans le client MQTT, choisissez **Publier dans une rubrique**.
1. Dans **Nom de la rubrique**, attribuez un nom à la rubrique **device/22/data**.
1. Pour la **charge du message**, entrez les exemples de données suivants.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Pour publier le message MQTT, choisissez **Publier**.
1. Maintenant, dans le client MQTT, choisissez **S'abonner à un objet**. Dans la colonne **S'abonner**, choisissez l'**device/\$1/data**abonnement. Vérifiez que les exemples de données de l'étape précédente y figurent.
1. Vérifiez la ligne de la table DynamoDB créée par votre règle.
1. **Dans le [hub de tables DynamoDB de AWS IoT la](https://console.aws.amazon.com//dynamodb/home#tables:) console, **choisissez** wx\$1data, puis l'onglet Éléments.**
Si vous êtes déjà dans l'onglet **Éléments** savoir, vous devrez peut-être actualiser l'affichage en choisissant l'icône d'actualisation dans le coin supérieur droit de l'en-tête du tableau.
1. Notez que les valeurs **sample\$1time** de la table sont des liens et ouvrez-en un. Si vous venez d'envoyer votre premier message, ce sera le seul de la liste.
Ce lien affiche toutes les données de cette ligne du tableau.
1. Développez l'entrée **device\$1data** pour voir les données résultant de l'déclararionde requête de règle.
1. Explorez les différentes représentations des données disponibles dans cet affichage. Vous pouvez également modifier les données de cet affichage.
1. Après avoir passé en revue cette ligne de données, pour enregistrer les modifications que vous avez apportées, choisissez **Enregistrer**, ou pour quitter sans enregistrer les modifications, choisissez **Annuler**.
Si vous ne voyez pas le comportement correct, consultez les conseils de dépannage.
### Résolution des problèmes de votre règle DynamoDB
Voici quelques points à vérifier au cas où vous n'obtiendriez pas les résultats escomptés.
+
**Vous avez reçu une bannière d'erreur**
Si une erreur est apparue lorsque vous avez publié le message d'entrée, corrigez-la d'abord. Les étapes suivantes peuvent vous aider à corriger cette erreur.
+
**Vous ne voyez pas le message d'entrée dans le client MQTT**
Chaque fois que vous publiez votre message d'entrée dans le `device/22/data` objet, ce message doit apparaître dans le client MQTT si vous vous êtes abonné au filtre de `device/+/data` objet comme décrit dans la procédure.
**À savoir**
+
**Vérifiez le filtre de objets auquel vous vous êtes abonné**
Si vous vous êtes abonné au objet du message d'entrée comme décrit dans la procédure, vous devriez voir une copie du message d'entrée chaque fois que vous le publiez.
Si le message ne s'affiche pas, vérifiez le nom de l'objet auquel vous vous êtes abonné et comparez-le au objet dans lequel vous avez publié. Les noms des objets distinguent les majuscules et minuscules et le objet auquel vous vous êtes abonné doit être identique au objet dans lequel vous avez publié la charge utile du message.
+
**Vérifiez la fonction de publication des messages**
Dans le client MQTT, sous **Abonnements**, choisissez **device/\$1/data**, vérifiez l’objet du message de publication, puis choisissez **Publier dans le objet.** La charge utile du message figurant dans la zone d'édition située sous le objet devrait apparaître dans la liste des messages.
+
**Vous ne voyez pas vos données dans la table DynamoDB**
La première chose à faire est d'actualiser l'affichage en choisissant l'icône d'actualisation dans le coin supérieur droit de l'en-tête du tableau. Si les données que vous recherchez ne s'affichent pas, vérifiez les points suivants.
**À savoir**
+
**Vérifiez le nom Région AWS de votre client MQTT et la règle que vous avez créée**
La console dans laquelle vous exécutez le client MQTT doit se trouver dans la même AWS région que la règle que vous avez créée.
+
**Vérifiez le objet du message d'entrée dans la déclaration de requête de règle**
Pour que la règle fonctionne, elle doit recevoir un message dont le nom de rubrique correspond au filtre de rubrique figurant dans la clause FROM de l'déclararionde requête de règle.
Vérifiez l'orthographe du filtre de rubrique dans l'déclararionde requête de règle avec celle de l'objet dans le client MQTT. Les noms de objets distinguent les majuscules et minuscules et le objet du message doit correspondre au filtre de objet indiqué dans l'déclararionde requête de règle.
+
**Vérifiez le contenu de la charge utile des messages d'entrée**
Pour que la règle fonctionne, elle doit trouver le champ de données dans la charge utile du message déclarée dans l'déclararionSELECT.
Vérifiez l'orthographe du `temperature` champ dans l'déclararionde requête de règle avec celle de la charge utile du message dans le client MQTT. Les noms de champs distinguent les majuscules et minuscules et le `temperature` champ de l'déclararionde requête de règle doit être identique au `temperature` champ de la charge du message.
Assurez-vous que le document JSON contenu dans la charge utile du message est correctement formaté. Si le JSON contient des erreurs, telles qu'une virgule manquante, la règle ne pourra pas le lire.
+
**Vérifiez les noms de clé et de champ utilisés dans l'action de la règle**
Les noms de champs utilisés dans la règle de rubrique doivent correspondre à ceux trouvés dans la charge utile du message JSON du message publié.
Ouvrez la règle que vous avez créée dans la console et vérifiez les noms des champs dans la configuration de l'action des règles avec ceux utilisés dans le client MQTT.
+
**Vérifiez le rôle utilisé par la règle**
L'action de règle doit être autorisée à recevoir le objet d'origine et à publier le nouveau objet.
Les politiques qui autorisent la règle à recevoir des données de message et à mettre à jour la table DynamoDB sont spécifiques aux rubriques utilisées. Si vous modifiez le nom de rubrique ou de table DynamoDB utilisé par la règle, vous devez mettre à jour le rôle de l'action de règle afin de mettre à jour sa politique en conséquence.
Si vous pensez que c'est le problème, modifiez l'action de la règle et créez un nouveau rôle. Les nouveaux rôles créés par l'action de règle reçoivent les autorisations nécessaires pour effectuer ces actions.
## Étape 4 : examen des résultats et des étapes suivantes
Après avoir envoyé quelques messages à la table DynamoDB avec cette règle, essayez de l'utiliser pour voir comment la modification de certains aspects du didacticiel affecte les données écrites dans la table. Voici quelques idées pour vous aider à démarrer.
+ Modifiez le *device\$1id* sujet du message d'entrée et observez l'effet sur les données. Vous pouvez l'utiliser pour simuler la réception de données provenant de plusieurs capteurs météorologiques.
+ Modifiez les champs sélectionnés dans l'déclararionde requête de règle et observez l'effet sur les données. Vous pouvez l'utiliser pour filtrer les données stockées dans la table.
+ Ajoutez une action de règle de republication pour envoyer un message MQTT pour chaque ligne ajoutée au tableau. Vous pouvez l'utiliser pour le débogage.
Après avoir terminé ce didacticiel, jetez un œil [Tutoriel : Formatage d'une notification à l'aide d'une AWS Lambda fonction](iot-lambda-rule.md).
# Tutoriel : Formatage d'une notification à l'aide d'une AWS Lambda fonction
Ce didacticiel explique comment envoyer des données de message MQTT à une AWS Lambda action pour le formatage et l'envoi à un autre AWS service. Dans ce didacticiel, l' AWS Lambda action utilise le AWS SDK pour envoyer le message formaté à la rubrique Amazon SNS que vous avez créée dans le didacticiel sur la procédure à suivre. [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)
Dans le didacticiel expliquant comment procéder[Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md), le document JSON issu de l'déclararionde requête de la règle a été envoyé dans le corps du message texte. Le résultat a été un message texte qui ressemblait à cet exemple :
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
Dans ce didacticiel, vous allez utiliser une action de AWS Lambda règle pour appeler une AWS Lambda fonction qui met en forme les données de l'instruction de requête de règle dans un format plus convivial, comme dans cet exemple :
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
La AWS Lambda fonction que vous allez créer dans ce didacticiel formate la chaîne du message en utilisant les données de l'instruction de requête de règle et appelle la fonction de [publication SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) du AWS SDK pour créer la notification.
**Ce que vous allez apprendre dans ce didacticiel**
+ Comment créer et tester une AWS Lambda fonction
+ Comment utiliser le AWS SDK dans une AWS Lambda fonction pour publier une notification Amazon SNS
+ Comment utiliser des requêtes et des fonctions SQL simples dans une déclararionde requête de règle
+ Comment utiliser le client MQTT pour tester une règle AWS IoT
Ce didacticiel vous prendra environ 45 minutes.
**Topics**
+ [Étape 1 : créer une AWS Lambda fonction qui envoie un message texte](#iot-lambda-rule-create-lambda)
+ [Étape 2 : Création d'une AWS IoT règle avec une action de AWS Lambda règle](#iot-lambda-rule-create-rule)
+ [Étape 3 : tester la AWS IoT AWS Lambda règle et son action](#iot-lambda-rule-test-rule)
+ [Étape 4 : examen des résultats et des étapes suivantes](#iot-lambda-rule-next-steps)
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+
**[Configurez Compte AWS](setting-up.md)**
Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
+
**Révisé [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md)**
Assurez-vous de pouvoir utiliser le client MQTT pour vous abonner à un objet et le publier. Vous allez utiliser le client MQTT pour tester votre nouvelle règle dans le cadre de cette procédure.
+
**Vous avez terminé les autres didacticiels sur les règles de cette section**
Ce didacticiel nécessite la rubrique de notification SNS que vous avez créée dans le didacticiel pour savoir comment [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md). Cela suppose également que vous avez suivi les autres didacticiels relatifs aux règles de cette section.
+
**J'ai revu l'[AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html) aperçu**
Si vous ne l'avez jamais utilisé AWS Lambda auparavant, consultez le [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)guide [Getting started with Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) pour en apprendre les termes et les concepts.
## Étape 1 : créer une AWS Lambda fonction qui envoie un message texte
La AWS Lambda fonction de ce didacticiel reçoit le résultat de l'instruction de requête de règle, insère les éléments dans une chaîne de texte et envoie la chaîne résultante à Amazon SNS sous forme de message dans une notification.
Contrairement au didacticiel expliquant comment[Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md), qui utilisait une action de AWS IoT règle pour envoyer la notification, ce didacticiel envoie la notification à partir de la fonction Lambda à l'aide d'une fonction du AWS SDK. Le objet des notifications Amazon SNS utilisé dans ce didacticiel est toutefois le même que celui que vous avez utilisé dans le didacticiel expliquant comment procéder. [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)
**Pour créer une AWS Lambda fonction qui envoie un message texte**
1. Créez une nouvelle AWS Lambda fonction.
1. Dans la [AWS Lambda console](https://console.aws.amazon.com//lambda/home), choisissez **Créer une fonction**.
1. Dans **Créer une fonction**, sélectionnez **Utiliser un plan**.
Recherchez et sélectionnez le **hello-world-python** plan, puis choisissez **Configurer**.
1. Dans **Informations de base** :
1. Dans **Nom de la fonction**, entrez le nom de votre fonction, par exemple **format-high-temp-notification**.
1. Dans **Rôle d'exécution**, choisissez **Créer un nouveau rôle à partir de modèles de AWS politique**.
1. Dans Role name, entrez un nom pour le nouveau rôle.
1. Dans **Modèles de politiques- *(facultatif)***, recherchez et sélectionnez la politique de **publication Amazon SNS**.
1. Choisissez **Créer une fonction**.
1. Modifiez le code du plan pour formater et envoyer une notification Amazon SNS.
1. Après avoir créé votre fonction, vous devriez voir la page de **format-high-temp-notification**détails. Si ce n'est pas le cas, ouvrez-le depuis la page des [Lambda**fonctions**](https://console.aws.amazon.com//lambda/home#/functions).
1. Sur la page de **format-high-temp-notification**détails, choisissez l'onglet **Configuration** et faites défiler l'écran jusqu'au panneau des **codes de fonction**.
1. Dans la fenêtre **Code de fonction**, dans le volet **Environnement**, choisissez le fichier Python, `lambda_function.py`.
1. Dans la fenêtre **Code de fonction**, supprimez tout le code du programme d'origine du plan et remplacez-le par ce code.
```
import boto3
#
# expects event parameter to contain:
# {
# "device_id": "32",
# "reported_temperature": 38,
# "max_temperature": 30,
# "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
# }
#
# sends a plain text string to be used in a text message
#
# "Device {0} reports a temperature of {1}, which exceeds the limit of {2}."
#
# where:
# {0} is the device_id value
# {1} is the reported_temperature value
# {2} is the max_temperature value
#
def lambda_handler(event, context):
# Create an SNS client to send notification
sns = boto3.client('sns')
# Format text message from data
message_text = "Device {0} reports a temperature of {1}, which exceeds the limit of {2}.".format(
str(event['device_id']),
str(event['reported_temperature']),
str(event['max_temperature'])
)
# Publish the formatted message
response = sns.publish(
TopicArn = event['notify_topic_arn'],
Message = message_text
)
return response
```
1. Choisissez **Déployer**.
1. Dans une nouvelle fenêtre, recherchez l'Amazon Resource Name (ARN) de votre rubrique Amazon SNS [Tutoriel : envoi d'une notification Amazon SNS](iot-sns-rule.md)
1. Dans une nouvelle fenêtre ouvrez la [Topics (Rubriques) de la console Amazon SNS](https://console.aws.amazon.com//sns/v3/home#/topics).
1. Sur la page **Rubriques**, recherchez la rubrique de notification **high\$1temp\$1notice** dans la liste des rubriques Amazon SNS.
1. Trouvez l'**ARN** de la rubrique de notification **high\$1temp\$1notice** à utiliser à l'étape suivante.
1. Créez un scénario de test pour votre fonction Lambda.
1. Sur la page [**Fonctions** Lambda](https://console.aws.amazon.com//lambda/home#/functions) de la console, sur la page de **format-high-temp-notification**détails, choisissez **Sélectionner un événement de test** dans le coin supérieur droit de la page (même s'il semble désactivé), puis choisissez **Configurer les événements de test**.
1. Dans **Configure test event (Configurer un événement de test)** choisissez **Select a test event (Sélectionner un événement de test)**.
1. Dans **Event name** (Nom de l'événement), saisissez **SampleRuleOutput**.
1. Dans l'éditeur JSON sous **Nom de l'événement**, collez cet exemple de document JSON. Voici un exemple de ce que votre AWS IoT règle enverra à la fonction Lambda.
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
1. Reportez-vous à la fenêtre contenant l'**ARN** de la rubrique de notification **high\$1temp\$1notice** et copiez la valeur de l'ARN.
1. Remplacez la `notify_topic_arn` valeur dans l'éditeur JSON par l'ARN de votre objet de notification.
Gardez cette fenêtre ouverte afin de pouvoir réutiliser cette valeur ARN lors de la création de la AWS IoT règle.
1. Choisissez **Créer**.
1. Testez la fonction avec des exemples de données.
1. Sur la page de **format-high-temp-notification**détails, dans le coin supérieur droit de la page, vérifiez que cela **SampleRuleOutput**apparaît à côté du bouton **Test**. Si ce n'est pas le cas, sélectionnez-le dans la liste des événements de test disponibles.
1. Pour envoyer le message de sortie de l'exemple de règle à votre fonction, choisissez **Test**.
Si la fonction et la notification ont toutes deux fonctionné, vous recevrez un message texte sur le téléphone abonné à la notification.
Si vous n'avez pas reçu de SMS au téléphone, vérifiez le résultat de l'opération. Dans le panneau **Code de fonction**, dans l'onglet **Résultat de l'exécution**, passez en revue la réponse pour détecter les erreurs qui se sont produites. Ne passez pas à l'étape suivante tant que votre fonction n'a pas pu envoyer la notification à votre téléphone.
## Étape 2 : Création d'une AWS IoT règle avec une action de AWS Lambda règle
Au cours de cette étape, vous allez utiliser l'déclararionde requête de règle pour formater les données provenant du capteur météo imaginaire à envoyer à une fonction Lambda, qui formatera et enverra un message texte.
Voici un exemple de charge utile des messages reçus des appareils météorologiques :
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Dans cette règle, vous allez utiliser l'déclararionrule query pour créer une charge utile de message pour la fonction Lambda qui ressemble à ceci :
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
Il contient toutes les informations dont la fonction Lambda a besoin pour formater et envoyer le message texte correct.
**Pour créer la AWS IoT règle permettant d'appeler une fonction Lambda**
1. Ouvrez le [hub de **règles** de la AWS IoT console](https://console.aws.amazon.com//iot/home#/rulehub).
1. Pour commencer à créer votre nouvelle règle dans **Règles**, choisissez **Créer**.
1. Dans la partie supérieure de **Créer une règle** :
1. Dans **Nom**, entrez le nom de la règle, **wx\$1friendly\$1text**.
N'oubliez pas qu'un nom de règle doit être unique dans votre région Compte AWS et qu'il ne doit pas comporter d'espaces. Nous avons utilisé un trait de soulignement dans ce nom pour séparer les deux mots du nom de la règle.
1. Dans **Description**, décrivez la règle.
Une description significative permet de se souvenir plus facilement du rôle de cette règle et de la raison pour laquelle vous l'avez créée. La description peut être aussi longue que nécessaire, donc soyez aussi détaillée que possible.
1. Dans l'**déclararionde requête règle** de **Create a rule** :
1. Dans **Utiliser la version SQL**, sélectionnez **2016-03-23**.
1. Dans la zone d'édition de la **instruction de requête de règle**, entrez l'instruction :
```
SELECT
cast(topic(2) AS DECIMAL) as device_id,
temperature as reported_temperature,
30 as max_temperature,
'arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice' as notify_topic_arn
FROM 'device/+/data' WHERE temperature > 30
```
Cette instruction :
+ Écoute les messages MQTT dont le objet correspond au filtre de `device/+/data` objet et dont la `temperature` valeur est supérieure à 30.
+ Sélectionne le deuxième élément dans la chaîne de l'objet, le convertit en nombre décimal, puis l'affecte au `device_id` champ.
+ Sélectionne la valeur du `temperature` champ dans la charge utile du message et l'affecte au `reported_temperature` champ.
+ Crée une valeur constante, `30`, pour représenter la valeur limite et l'affecte au `max_temperature` champ.
+ Crée une valeur constante pour le `notify_topic_arn` champ.
1. Reportez-vous à la fenêtre contenant l'**ARN** de la rubrique de notification **high\$1temp\$1notice** et copiez la valeur de l'ARN.
1. Remplacez la valeur ARN (*arn:aws:sns:us-east-1:57EXAMPLE833:high\$1temp\$1notice*) dans l'éditeur d'instructions de requête de règle par l'ARN de votre sujet de notification.
1. Dans **Définir une ou plusieurs actions** :
1. Pour ouvrir la liste des actions de règle pour cette règle, choisissez **Ajouter une action**.
1. Dans **Sélectionner une action**, choisissez **Envoyer un message à une fonction Lambda**.
1. Pour ouvrir la page de configuration de l'action sélectionnée, en bas de la liste d'actions, choisissez **Configurer l'action**.
1. Sous **Configurer les actions** :
1. Dans **Nom de la fonction**, choisissez **Sélectionner**.
1. Sélectionnez **format-high-temp-notification**.
1. Au bas de **Configurer l'action**, choisissez **Ajouter une action**.
1. Pour créer la règle, en bas de **Créer une règle**, sélectionnez **Créer une règle**.
## Étape 3 : tester la AWS IoT AWS Lambda règle et son action
Pour tester votre nouvelle règle, vous allez utiliser le client MQTT pour publier et vous abonner aux messages MQTT utilisés par cette règle.
Ouvrez le [client MQTT dans la AWS IoT console](https://console.aws.amazon.com//iot/home#/test) dans une nouvelle fenêtre. Vous pouvez désormais modifier la règle sans perdre la configuration de votre client MQTT. Si vous quittez le client MQTT pour accéder à une autre page de la console, vous perdrez vos abonnements ou vos journaux de messages.
**Vous pouvez utiliser le client MQTT pour tester votre règle.**
1. Dans le [client MQTT de la AWS IoT console](https://console.aws.amazon.com//iot/home#/test), abonnez-vous aux rubriques d'entrée, dans ce cas, `device/+/data`.
1. Dans le client MQTT, sous Souscriptions, choisissez Publish to topic.
1. Dans **Sujet d'abonnement**, entrez le objet du filtre de objet d'entrée,**device/\$1/data**.
1. Conservez les valeurs par défaut des autres paramètres.
1. Choisissez **Subscribe to topic (S'abonner à la rubrique)**.
Dans la colonne **Abonnements**, la section **Publier dans un objet** **device/\$1/data** apparaît.
1. Publiez un message sur le objet d'entrée avec un identifiant d'appareil spécifique, **device/32/data**. Vous ne pouvez pas publier au format MQTT des objets contenant des caractères génériques.
1. Dans le client MQTT, sous **Souscriptions**, choisissez **Publier dans la rubrique**.
1. Dans le champ **Publier**, entrez le nom de l'objet d'entrée, **device/32/data**.
1. Copiez les exemples de données présentés ici et, dans la zone d'édition située sous le nom de l'objet, collez les exemples de données.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Choisissez Publier dans la rubrique pour publier votre message dans .
1. Confirmez que le message texte a été envoyé.
1. Dans le client MQTT, sous **Abonnements**, il y a un point vert à côté de l'objet auquel vous vous êtes abonné plus tôt.
Le point vert indique qu'un ou plusieurs nouveaux messages ont été reçus depuis la dernière fois que vous les avez consultés.
1. Sous **Abonnements**, choisissez **device/\$1/data** pour vérifier que la charge utile du message correspond à ce que vous venez de publier et ressemble à ceci :
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Vérifiez le téléphone que vous avez utilisé pour vous abonner à la rubrique SNS et vérifiez que le contenu de la charge utile du message ressemble à ceci :
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
Si vous modifiez l'élément ID de objet dans le objet du message, n'oubliez pas que la conversion de la `topic(2)` valeur en valeur numérique ne fonctionnera que si cet élément de l'objet du message contient uniquement des caractères numériques.
1. Essayez d'envoyer un message MQTT dans lequel la température ne dépasse pas la limite.
1. Dans le client MQTT, sous **Souscriptions**, choisissez **Publier dans la rubrique**.
1. Dans le champ **Publier**, entrez le nom de l'objet d'entrée, **device/33/data**.
1. Copiez les exemples de données présentés ici et, dans la zone d'édition située sous le nom de l'objet, collez les exemples de données.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Pour envoyer votre message MQTT, choisissez **Publier dans le objet **.
Vous devriez voir le message que vous avez envoyé dans l'**device/\$1/data**abonnement ; toutefois, comme la valeur de température est inférieure à la température maximale indiquée dans l'énoncé de la requête de règle, vous ne devriez pas recevoir de message texte.
Si vous ne voyez pas le comportement correct, consultez les conseils de dépannage.
### Résolution des problèmes liés à votre AWS Lambda règle et à votre notification
Voici quelques points à vérifier, au cas où vous n'obtiendriez pas les résultats escomptés.
+
**Vous avez reçu une bannière d'erreur**
Si une erreur est apparue lorsque vous avez publié le message d'entrée, corrigez-la d'abord. Les étapes suivantes peuvent vous aider à corriger cette erreur.
+
**Vous ne voyez pas le message d'entrée dans le client MQTT**
Chaque fois que vous publiez votre message d'entrée dans l’`device/32/data` objet, ce message doit apparaître dans le client MQTT, si vous vous êtes abonné au filtre de `device/+/data` objet comme décrit dans la procédure.
**À savoir**
+
**Vérifiez le filtre de objets auquel vous vous êtes abonné**
Si vous vous êtes abonné au objet du message d'entrée comme décrit dans la procédure, vous devriez voir une copie du message d'entrée chaque fois que vous le publiez.
Si le message ne s'affiche pas, vérifiez le nom de l'objet auquel vous vous êtes abonné et comparez-le au objet dans lequel vous avez publié. Les noms des objets distinguent les majuscules et minuscules et le objet auquel vous vous êtes abonné doit être identique au objet dans lequel vous avez publié la charge utile du message.
+
**Vérifiez la fonction de publication des messages**
Dans le client MQTT, sous **Abonnements**, choisissez **device/\$1/data**, vérifiez l’objet du message de publication, puis choisissez **Publier dans le objet.** La charge utile du message figurant dans la zone d'édition située sous le objet devrait apparaître dans la liste des messages.
+
**Si vous ne recevez pas le message :**
Pour que votre règle fonctionne, elle doit disposer de la politique appropriée l'autorisant à recevoir un message et à envoyer une notification SNS, et elle doit recevoir le message.
**À savoir**
+
**Vérifiez le nom Région AWS de votre client MQTT et la règle que vous avez créée**
La console dans laquelle vous exécutez le client MQTT doit se trouver dans la même AWS région que la règle que vous avez créée.
+
**Vérifiez que la valeur de température dans la charge utile du message dépasse le seuil de test**
Si la valeur de température est inférieure ou égale à 30, telle que définie dans l'déclararionde requête de règle, la règle n'exécutera aucune de ses actions.
+
**Vérifiez le objet du message d'entrée dans la déclaration de requête de règle**
Pour que la règle fonctionne, elle doit recevoir un message dont le nom de rubrique correspond au filtre de rubrique figurant dans la clause FROM de l'déclararionde requête de règle.
Vérifiez l'orthographe du filtre de rubrique dans l'déclararionde requête de règle avec celle de l'objet dans le client MQTT. Les noms de objets distinguent les majuscules et minuscules et le objet du message doit correspondre au filtre de objet indiqué dans l'déclararionde requête de règle.
+
**Vérifiez le contenu de la charge utile des messages d'entrée**
Pour que la règle fonctionne, elle doit trouver le champ de données dans la charge utile du message déclarée dans l'déclararionSELECT.
Vérifiez l'orthographe du `temperature` champ dans l'déclararionde requête de règle avec celle de la charge utile du message dans le client MQTT. Les noms de champs distinguent les majuscules et minuscules et le `temperature` champ de l'déclararionde requête de règle doit être identique au `temperature` champ de la charge du message.
Assurez-vous que le document JSON contenu dans la charge utile du message est correctement formaté. Si le JSON contient des erreurs, telles qu'une virgule manquante, la règle ne pourra pas le lire.
+
**Vérifiez la notification Amazon SNS**
Dans[Étape 1 : créer une rubrique Amazon SNS qui envoie un message texte SMS](iot-sns-rule.md#iot-sns-rule-create-sns-topic), reportez-vous à l'étape 3 qui décrit comment tester la notification Amazon SNS et tester la notification pour vous assurer qu'elle fonctionne.
+
**La fonction Lambda.**
Dans[Étape 1 : créer une AWS Lambda fonction qui envoie un message texte](#iot-lambda-rule-create-lambda), reportez-vous à l'étape 5 qui décrit comment tester la fonction Lambda à l'aide de données de test et tester la fonction Lambda.
+
**Vérifiez le rôle utilisé par la règle**
L'action de règle doit être autorisée à recevoir le objet d'origine et à publier le nouveau objet.
Les politiques qui autorisent la règle à recevoir les données des messages et à les republier sont spécifiques aux objets utilisés. Si vous modifiez le objet utilisé pour republier les données du message, vous devez mettre à jour le rôle de l'action de règle afin de mettre à jour sa politique afin qu'elle corresponde au objet actuel.
Si vous pensez que c'est le problème, modifiez l'action Republier la règle et créez un nouveau rôle. Les nouveaux rôles créés par l'action de règle reçoivent les autorisations nécessaires pour effectuer ces actions.
## Étape 4 : examen des résultats et des étapes suivantes
**Dans ce tutoriel :**
+ Vous avez créé une AWS IoT règle pour appeler une fonction Lambda qui envoyait une notification Amazon SNS utilisant la charge utile de vos messages personnalisés.
+ Vous avez utilisé une requête SQL simple et des fonctions dans une déclararionde requête de règle pour créer une nouvelle charge utile de message pour votre fonction Lambda.
+ Vous avez utilisé le client MQTT pour tester votre AWS IoT règle.
**Étapes suivantes**
Après avoir envoyé quelques SMS avec cette règle, essayez de l'utiliser pour voir comment la modification de certains aspects du didacticiel affecte le message et le moment où il est envoyé. Voici quelques idées pour vous aider à démarrer.
+ Modifiez le *device\$1id* sujet du message d'entrée et observez l'effet dans le contenu du message texte.
+ Modifiez les champs sélectionnés dans l'déclararionde requête de règle, mettez à jour la fonction Lambda pour les utiliser dans un nouveau message et observez l'effet dans le contenu du message texte.
+ Modifiez le test dans l'déclararionde requête de règle pour tester une température minimale au lieu d'une température maximale. Mettez à jour la fonction Lambda pour formater un nouveau message et n'oubliez pas de changer le nom de `max_temperature`.
+ Pour en savoir plus sur la détection des erreurs susceptibles de se produire lors du développement et de l'utilisation de AWS IoT règles, consultez[Surveillance AWS IoT](monitoring_overview.md).
# 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).
# Tutoriel : Création d'un autorisateur personnalisé pour AWS IoT Core
Ce didacticiel explique les étapes de création, de validation et d'utilisation de l'authentification personnalisée à l'aide du AWS CLI. En option, à l'aide de ce didacticiel, vous pouvez utiliser Postman pour envoyer des données à l'aide de AWS IoT Core de l'API HTTP Publish.
Ce didacticiel explique comment créer un exemple de fonction Lambda qui implémente la logique d'autorisation et d'authentification et un mécanisme d'autorisation à l'aide de l'appel **create-authorizer** avec signature par jeton activée. L'autorisateur est ensuite validé à l'aide du**test-invoke-authorizer**, et vous pouvez enfin envoyer des données à AWS IoT Core un sujet MQTT de test à l'aide de l'API HTTP Publish. Un exemple de demande indiquera l'autorisateur à invoquer en utilisant l'`x-amz-customauthorizer-name`en-tête et en transmettant les en-têtes de demande token-key-name et `x-amz-customauthorizer-signature` in.
**Ce que vous allez apprendre dans ce didacticiel:**
+ Comment créer une fonction Lambda en tant que gestionnaire de mécanisme d'autorisation personnalisé
+ Comment créer un autorisateur personnalisé à l'aide du bouton AWS CLI avec signature par jeton activée
+ Comment tester votre mécanisme d'autorisation personnalisé à l'aide de la commande **test-invoke-authorizer**
+ Comment publier une rubrique MQTT à l'aide de [Postman](https://www.postman.com/) et valider la demande avec votre mécanisme d'autorisation personnalisé
Ce didacticiel vous prendra environ 60 minutes.
**Topics**
+ [Étape 1 : Créez une fonction Lambda pour votre mécanisme d'autorisation personnalisé](#custom-auth-tutorial-define)
+ [Étape 2 : Créez une paire de clés publique et privée pour votre mécanisme d’autorisation personnalisé](#custom-auth-tutorial-keys)
+ [Étape 3 : créer une ressource d'autorisation personnalisée et son autorisation](#custom-auth-tutorial-authorizer)
+ [Étape 4 : Testez l'autorisateur en appelant test-invoke-authorizer](#custom-auth-tutorial-test)
+ [Étape 5 : Testez la publication du message MQTT à l'aide de Postman](#custom-auth-tutorial-postman)
+ [Étape 6 : Afficher les messages dans le client de test MQTT](#custom-auth-tutorial-testclient)
+ [Étape 7 : examen des résultats et des étapes suivantes](#custom-auth-tutorial-review)
+ [Étape 8 : nettoyer](#custom-auth-tutorial-cleanup)
**Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :**
+
**[Configurez Compte AWS](setting-up.md)**
Vous aurez besoin de votre AWS IoT console Compte AWS et de votre console pour terminer ce didacticiel.
Le compte que vous utilisez pour ce didacticiel fonctionne mieux lorsqu'il inclut au moins les politiques AWS gérées suivantes :
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor)
**Important**
Les politiques IAM utilisées dans ce didacticiel sont plus permissives que celles que vous devriez suivre dans le cadre d'une implémentation de production. Dans un environnement de production, assurez-vous que vos politiques de compte et de ressources n'accordent que les autorisations nécessaires.
Lorsque vous venez de créer l'Amazon Resource Name (ARN), vous ne pouvez pas supprimer la liste des politiques que les utilisateurs (et les rôles) doivent effectuer et élaborez des politiques leur permettant de réaliser ces tâches.
Pour de plus amples informations, veuillez consulter [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/best-practices.html).
+
**A installé le AWS CLI**
Pour plus d'informations sur l'installation de la CLI AWS CLI, reportez-vous à la section [Installation de la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-install.html). Ce didacticiel nécessite une AWS CLI version `aws-cli/2.1.3 Python/3.7.4 Darwin/18.7.0 exe/x86_64` ou une version ultérieure.
+
**Boîte à outils OpenSSL**
Les exemples de ce didacticiel utilisent [LibreSSL 2.6.5.](https://www.libressl.org/) Vous pouvez également utiliser les outils [OpenSSL v1.1.1i](https://www.openssl.org/) pour ce didacticiel.
+
**J'ai revu l'aperçu [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)**
Si vous ne l'avez jamais utilisé AWS Lambda auparavant, consultez le [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)guide [Getting started with Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) pour en apprendre les termes et les concepts.
+
**J'ai examiné comment créer des demandes dans Postman**
Pour plus d'informations, consultez [Demandes de construction](https://learning.postman.com/docs/sending-requests/requests/).
+
**Autorisateurs personnalisés supprimés du didacticiel précédent**
Vous ne Compte AWS pouvez configurer qu'un nombre limité d'autorisateurs personnalisés à la fois. Pour plus d'informations sur la suppression d'un mécanisme d'autorisation personnalisé, consultez [Étape 8 : nettoyer](#custom-auth-tutorial-cleanup).
## Étape 1 : Créez une fonction Lambda pour votre mécanisme d'autorisation personnalisé
L'authentification personnalisée AWS IoT Core utilise les [ressources d'autorisation](https://docs.aws.amazon.com//iot/latest/apireference/API_AuthorizerDescription.html) que vous créez pour authentifier et autoriser les clients. La fonction que vous allez créer dans cette section authentifie et autorise les clients lorsqu'ils se connectent aux ressources AWS IoT Core et y accèdent AWS IoT .
La fonction Lambda effectue les opérations suivantes :
+ Si une demande provient de **test-invoke-authorizer**, elle renvoie une politique IAM avec une action `Deny`.
+ Si une demande provient de Postman via HTTP et que le `actionToken` paramètre a une valeur de`allow`, il renvoie une politique IAM avec une `Allow` action. Dans le cas contraire, il renvoie une politique IAM avec une action `Deny`.
**Pour créer une fonction Lambda pour votre mécanisme d'autorisation personnalisé**
1. Dans la console [Lambda](https://console.aws.amazon.com//lambda/home#), ouvrez [Fonctions](https://console.aws.amazon.com//lambda/home#/functions).
1. Choisissez **Créer une fonction**.
1. Confirmez que **l'auteur à partir de zéro (Author from scratch)** est sélectionné.
1. Sous **Basic information** :
1. Sous **Nom de la fonction**, entrez **custom-auth-function**.
1. sSous **Runtime**, confirmez **Node.js 18.x**
1. Choisissez **Créer une fonction**.
Lambda crée une fonction Node.js et un [rôle d'exécution](https://docs.aws.amazon.com//lambda/latest/dg/lambda-intro-execution-role.html) qui accorde à la fonction l'autorisation de charger des journaux. La fonction Lambda assume le rôle d'exécution lorsque vous appelez votre fonction et utilise le rôle d'exécution pour créer des informations d'identification pour le AWS SDK et pour lire des données provenant de sources d'événements.
1. Pour voir le code et la configuration de la fonction dans l'[AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)éditeur, choisissez **custom-auth-function**dans la fenêtre du concepteur, puis choisissez **index.js** dans le volet de navigation de l'éditeur.
Pour créer une fonction Lambda, sélectionnez l'Amazon Resource Name (ARN) de la fonction Lambda. Node.js Vous pouvez utiliser l'éditeur [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html) pour éditer votre fonction tant que votre code source ne dépasse pas 3 Mo.
1. Remplacez le code **index.js** dans l'éditeur par le code suivant :
```
// A simple Lambda function for an authorizer. It demonstrates
// How to parse a CLI and Http password to generate a response.
export const handler = async (event, context, callback) => {
//Http parameter to initiate allow/deny request
const HTTP_PARAM_NAME='actionToken';
const ALLOW_ACTION = 'Allow';
const DENY_ACTION = 'Deny';
//Event data passed to Lambda function
var event_str = JSON.stringify(event);
console.log('Complete event :'+ event_str);
//Read protocolData from the event json passed to Lambda function
var protocolData = event.protocolData;
console.log('protocolData value---> ' + protocolData);
//Get the dynamic account ID from function's ARN to be used
// as full resource for IAM policy
var ACCOUNT_ID = context.invokedFunctionArn.split(":")[4];
console.log("ACCOUNT_ID---"+ACCOUNT_ID);
//Get the dynamic region from function's ARN to be used
// as full resource for IAM policy
var REGION = context.invokedFunctionArn.split(":")[3];
console.log("REGION---"+REGION);
//protocolData data will be undefined if testing is done via CLI.
// This will help to test the set up.
if (protocolData === undefined) {
//If CLI testing, pass deny action as this is for testing purpose only.
console.log('Using the test-invoke-authorizer cli for testing only');
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
} else{
//Http Testing from Postman
//Get the query string from the request
var queryString = event.protocolData.http.queryString;
console.log('queryString values -- ' + queryString);
/* global URLSearchParams */
const params = new URLSearchParams(queryString);
var action = params.get(HTTP_PARAM_NAME);
if(action!=null && action.toLowerCase() === 'allow'){
callback(null, generateAuthResponse(ALLOW_ACTION,ACCOUNT_ID,REGION));
}else{
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
}
}
};
// Helper function to generate the authorization IAM response.
var generateAuthResponse = function(effect,ACCOUNT_ID,REGION) {
var full_resource = "arn:aws:iot:"+ REGION + ":" + ACCOUNT_ID + ":*";
console.log("full_resource---"+full_resource);
var authResponse = {};
authResponse.isAuthenticated = true;
authResponse.principalId = 'principalId';
var policyDocument = {};
policyDocument.Version = '2012-10-17';
policyDocument.Statement = [];
var statement = {};
statement.Action = 'iot:*';
statement.Effect = effect;
statement.Resource = full_resource;
policyDocument.Statement[0] = statement;
authResponse.policyDocuments = [policyDocument];
authResponse.disconnectAfterInSeconds = 3600;
authResponse.refreshAfterInSeconds = 600;
console.log('custom auth policy function called from http');
console.log('authResponse --> ' + JSON.stringify(authResponse));
console.log(authResponse.policyDocuments[0]);
return authResponse;
}
```
1. Choisissez **Déployer**.
1. Après le **déploiement des modifications (Changes deployed)** apparaît au-dessus de l'éditeur :
1. Accédez à la section **Vue d'ensemble des fonctions** au-dessus de l'éditeur.
1. Copiez l'**ARN de la fonction** et enregistrez-le pour l'utiliser ultérieurement dans ce didacticiel.
1. Testez votre fonction .
1. Choisissez l’onglet **Test**.
1. À l'aide des paramètres de test par défaut, choisissez **Invoquer**.
1. Si le test a réussi, dans les **résultats de l'exécution**, ouvrez l'aperçu **Détails**. Vous devriez voir le document de politique renvoyé par la fonction.
Si le test a échoué ou si aucun document de politique ne s'affiche, examinez le code pour rechercher et corriger les erreurs.
## Étape 2 : Créez une paire de clés publique et privée pour votre mécanisme d’autorisation personnalisé
Votre mécanisme d'autorisation personnalisé nécessite une clé publique et privée pour l'authentifier. Les commandes de cette section utilisent les outils OpenSSL pour créer cette paire de clés.
**Pour créer une paire de clés publique et privée pour votre mécanisme d’autorisation personnalisé**
1. Créez le fichier de clé privée.
```
openssl genrsa -out private-key.pem 4096
```
1. Vérifiez le fichier de clé privée que vous venez de créer.
```
openssl rsa -check -in private-key.pem -noout
```
Si la commande n'affiche aucune erreur, le fichier de clé privée est valide.
1. Créez le fichier de clé publique.
```
openssl rsa -in private-key.pem -pubout -out public-key.pem
```
1. Vérifiez le fichier de clé publique.
```
openssl pkey -inform PEM -pubin -in public-key.pem -noout
```
Si la commande n'affiche aucune erreur, le fichier de clé publique est valide.
## Étape 3 : créer une ressource d'autorisation personnalisée et son autorisation
L'autorisateur AWS IoT personnalisé est la ressource qui réunit tous les éléments créés au cours des étapes précédentes. Dans cette section, vous allez créer une ressource de mécanisme d’autorisation personnalisée et lui donner l'autorisation d'exécuter la fonction Lambda que vous avez créée précédemment. Vous pouvez créer une ressource d'autorisation personnalisée à l'aide de la AWS IoT console AWS CLI, de ou de l' AWS API.
Pour ce didacticiel, il vous suffit de créer un seul mécanisme d'autorisation personnalisé. Cette section décrit comment créer à l'aide de la AWS IoT console et du AWS CLI, afin que vous puissiez utiliser la méthode qui vous convient le mieux. Il n'y a aucune différence entre les ressources de mécanisme d'autorisation personnalisées créées par l'une ou l'autre méthode.
### Création d'une ressource d'autorisation personnalisée
**Choisissez l'une de ces options pour créer votre ressource de mécanisme d'autorisation personnalisée**
+ [Créez un autorisateur personnalisé à l'aide de la console AWS IoT](#create-custom-auth-in-console)
+ [Créer un mécanisme d'autorisation à l'aide de AWS CLI](#create-custom-auth-in-cli)
**Pour créer un mécanisme d'autorisation personnalisé (console)**
1. Ouvrez la [page d'autorisation personnalisée de la AWS IoT console, puis choisissez **Create Authorizer**](https://console.aws.amazon.com//iot/home#/authorizerhub).
1. Dans **Créer un mécanisme d'autorisation**
1. Dans **Nom de mécanisme d'autorisation**, entrez **my-new-authorizer**.
1. Dans **État du mécanisme d'autorisation**, cochez **Actif**.
1. Dans **Fonction mécanisme d'autorisation**, choisissez la fonction Lambda que vous avez créée précédemment.
1. Dans **Validation du jeton, facultatif** :
1. Activez la **validation des jetons**.
1. Dans **Nom de la clé du jeton**, entrez**tokenKeyName**.
1. Sélectionnez **Ajouter une clé**.
1. Dans **Key name (Nom de la clé)**, saisissez **FirstKey**.
1. Dans **Clé publique**, entrez le contenu du fichier `public-key.pem`. Veillez à inclure les lignes du fichier dans le contenu du fichier `-----BEGIN PUBLIC KEY-----` et `-----END PUBLIC KEY-----` à ne pas ajouter ou supprimer des fils de ligne, des retours en chariot ou d'autres caractères. La chaîne que vous entrez devrait ressembler à cet exemple.
```
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----
```
1. Choisissez **Créer un mécanisme d’autorisation**.
1. Si la ressource du mécanisme d'autorisation personnalisée a été créée, vous verrez la liste des mécanismes d'autorisation personnalisés et votre nouvel mécanisme d'autorisation personnalisé devrait apparaître dans la liste. Vous pouvez passer à la section suivante pour le tester.
Si une erreur s'affiche, examinez-la, réessayez de créer votre mécanisme d'autorisation personnalisé et vérifiez les entrées. Notez que chaque ressource de mécanisme d'autorisation personnalisée doit avoir un nom unique.
**Pour créer un mécanisme d'autorisation personnalisé (AWS CLI)**
1. Remplacez vos valeurs par `authorizer-function-arn` et `token-signing-public-keys`, puis exécutez la commande suivante :
```
aws iot create-authorizer \
--authorizer-name "my-new-authorizer" \
--token-key-name "tokenKeyName" \
--status ACTIVE \
--no-signing-disabled \
--authorizer-function-arn "arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function" \
--token-signing-public-keys FirstKey="-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----"
```
**Où :**
+ La valeur `authorizer-function-arn` est l'Amazon Resource Name (ARN) de la fonction Lambda que vous avez créée pour votre mécanisme d'autorisation personnalisé.
+ La valeur `token-signing-public-keys` inclut le nom de la clé **FirstKey** et le contenu du fichier `public-key.pem`. Veillez à inclure les lignes du fichier dans le contenu du fichier `-----BEGIN PUBLIC KEY-----` et `-----END PUBLIC KEY-----` à ne pas ajouter ou supprimer des fils de ligne, des retours en chariot ou d'autres caractères.
Remarque : soyez prudent en saisissant la clé publique car toute modification de la valeur de la clé publique la rend inutilisable.
1. Si le mécanisme d'autorisation personnalisé est créé, la commande renvoie le nom et l'ARN de la nouvelle ressource, tels que.
```
{
"authorizerName": "my-new-authorizer",
"authorizerArn": "arn:aws:iot:Region:57EXAMPLE833:authorizer/my-new-authorizer"
}
```
Notez la sortie `authorizerArn` pour l'utiliser lors de l'étape suivante.
N'oubliez pas que chaque ressource de mécanisme d'autorisation personnalisée doit avoir un nom unique.
### Autoriser la ressource de mécanisme d'autorisation personnalisée
Dans cette section, vous accorderez à la ressource d'autorisation personnalisée que vous venez de créer l'autorisation d'exécuter la fonction Lambda. Pour accorder l'autorisation, vous pouvez utiliser la commande CLI [add-permission](https://docs.aws.amazon.com//cli/latest/reference/lambda/add-permission.html).
**Accordez l'autorisation à votre fonction Lambda à l'aide du AWS CLI**
1. Après avoir inséré vos valeurs, entrez la commande suivante. Notez que la valeur `statement-id` doit être unique. Remplacez `Id-1234` par une autre valeur si vous avez déjà exécuté ce didacticiel ou si une erreur `ResourceConflictException` s'affiche.
```
aws lambda add-permission \
--function-name "custom-auth-function" \
--principal "iot.amazonaws.com" \
--action "lambda:InvokeFunction" \
--statement-id "Id-1234" \
--source-arn authorizerArn
```
1. Si la commande aboutit, elle renvoie une instruction d'autorisation, comme dans cet exemple. Vous pouvez passer à la section suivante pour tester le mécanisme d’autorisation personnalisée.
```
{
"Statement": "{\"Sid\":\"Id-1234\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\"}}}"
}
```
Si la commande échoue, elle renvoie une erreur, comme dans cet exemple. Vous devez vérifier et corriger l'erreur avant de continuer.
```
An error occurred (AccessDeniedException) when calling the AddPermission operation: User: arn:aws:iam::57EXAMPLE833:user/EXAMPLE-1 is not authorized to perform: lambda:AddPer
mission on resource: arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function
```
## Étape 4 : Testez l'autorisateur en appelant test-invoke-authorizer
Une fois toutes les ressources définies, dans cette section, vous appellerez test-invoke-authorizer depuis la ligne de commande pour tester la passe d'autorisation.
Notez que lorsque vous invoquez le mécanisme d’autorisation depuis la ligne de commande, `protocolData` n'est pas défini, de sorte que le mécanisme d’autorisation renvoie toujours un document DENY. Ce test confirme toutefois que votre mécanisme d’autorisation personnalisé et votre fonction Lambda sont correctement configurés, même s'ils ne testent pas complètement la fonction Lambda.
**Pour tester votre autorisateur personnalisé et sa fonction Lambda à l'aide du AWS CLI**
1. Dans le répertoire où vous avez créé le fichier `private-key.pem`, entrez la commande suivante.
```
echo -n "tokenKeyValue" | openssl dgst -sha256 -sign private-key.pem | openssl base64 -A
```
Cette commande crée une chaîne de signature à utiliser à l'étape suivante. La chaîne de signature ressemble à ceci :
```
dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mn
VB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeeh
bQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjj
szEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29V
QJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuX
f3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+K
EWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFH
xRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Copiez cette chaîne de signature pour l'utiliser à l'étape suivante. Veillez à ne pas inclure de caractères supplémentaires ou à ne pas en omettre.
1. Dans cette commande, remplacez la valeur `token-signature` par la chaîne de signature de l'étape précédente et exécutez cette commande pour tester votre mécanisme d’autorisation.
```
aws iot test-invoke-authorizer \
--authorizer-name my-new-authorizer \
--token tokenKeyValue \
--token-signature dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mnVB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeehbQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjjszEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29VQJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuXf3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+KEWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFHxRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Si la commande aboutit, elle renvoie les informations générées par votre fonction d'autorisation personnalisée, comme dans cet exemple.
```
{
"isAuthenticated": true,
"principalId": "principalId",
"policyDocuments": [
"{\"Version\":\"2012-10-17\", \"Statement\":[{\"Action\":\"iot:*\",\"Effect\":\"Deny\",\"Resource\":\"arn:aws:iot:Region:57EXAMPLE833:*\"}]}"
],
"refreshAfterInSeconds": 600,
"disconnectAfterInSeconds": 3600
}
```
Si la commande renvoie une erreur, vérifiez l'erreur et revérifiez les commandes que vous avez utilisées dans cette section.
## Étape 5 : Testez la publication du message MQTT à l'aide de Postman
1. Pour obtenir le point de terminaison des données de votre appareil depuis la ligne de commande, appelez [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) comme indiqué ici
```
aws iot describe-endpoint --output text --endpoint-type iot:Data-ATS
```
Enregistrez cette adresse pour une utilisation ultérieure. *device\$1data\$1endpoint\$1address*
1. Ouvrez une nouvelle fenêtre Postman et créez une nouvelle requête HTTP POST.
1. Sur votre ordinateur, ouvrez l'application Postman.
1. Dans Postman, dans le menu **File (Fichier)**, choisissez **New… (Nouveau)**.
1. Dans la boîte de dialogue **Nouveau**, choisissez ** Requête**.
1. Dans Enregistrer la requête,
1. Dans **Nom de la requête**, entrez **Custom authorizer test request**.
1. Dans **Sélectionner une collection ou un dossier dans lequel enregistrer** : choisissez ou créez une collection dans laquelle enregistrer cette demande.
1. Choisissez **Enregistrer dans *collection\$1name***.
1. Créez la requête POST pour tester votre mécanisme d’autorisation personnalisé.
1. Dans le sélecteur de méthode de demande situé à côté du champ URL, choisissez **POST**.
1. Dans le champ URL, créez l'URL de votre demande en utilisant l'URL suivante avec la commande *device\$1data\$1endpoint\$1address* from the [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) lors d'une étape précédente.
```
https://device_data_endpoint_address:443/topics/test/cust-auth/topic?qos=0&actionToken=allow
```
Notez que cette URL inclut le paramètre de requête `actionToken=allow` qui indiquera à votre fonction Lambda de renvoyer un document de politique autorisant l'accès à AWS IoT. Après avoir saisi l'URL, les paramètres de requête apparaissent également dans l'onglet Paramètres **Postman.**
1. Dans l'onglet **Auth**, dans le champ **Type**, sélectionnez **No Auth**.
1. Dans la section suivante, passez à l'étape suivante.
1. Si une clé **d'hôte** est cochée, décochez-la.
1. Au bas de la liste des en-têtes, ajoutez ces nouveaux en-têtes et confirmez qu'ils sont cochés. Remplacez la **Host** valeur par votre *device\$1data\$1endpoint\$1address* et la **x-amz-customauthorizer-signature** valeur par la chaîne de signature que vous avez utilisée avec la **test-invoke-authorize** commande de la section précédente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/custom-auth-tutorial.html)
1. Dans l'onglet Body :
1. Dans la zone d'option du format des données, choisissez **Raw**.
1. Dans la liste des types de données, sélectionnez **JavaScript**.
1. Dans le champ de texte, entrez la charge utile du message JSON pour votre message de test :
```
{
"data_mode": "test",
"vibration": 200,
"temperature": 40
}
```
1. Choisissez **Send** pour envoyer la requête.
Si la requête aboutit, elle renvoie :
```
{
"message": "OK",
"traceId": "ff35c33f-409a-ea90-b06f-fbEXAMPLE25c"
}
```
La réponse positive indique que votre autorisateur personnalisé a autorisé la connexion à AWS IoT et que le message de test a été remis au broker in AWS IoT Core.
S'il renvoie une erreur, consultez le message d'erreur*device\$1data\$1endpoint\$1address*, la chaîne de signature et les autres valeurs d'en-tête.
Conservez cette demande dans Postman pour l'utiliser dans la section suivante.
## Étape 6 : Afficher les messages dans le client de test MQTT
À l'étape précédente, vous avez envoyé des messages simulés à un appareil à l'aide AWS IoT de Postman. La réponse positive indique que votre mécanisme d’autorisation personnalisé a autorisé la connexion à AWS IoT et que le message de test a été livré au courtier en AWS IoT Core. Dans cette section, vous allez utiliser le client de test MQTT de la AWS IoT console pour voir le contenu du message, comme le feraient d'autres appareils et services.
**Pour voir les messages de test autorisés par votre mécanisme d’autorisation personnalisé**
1. Dans la AWS IoT console, ouvrez le [client de test MQTT](https://console.aws.amazon.com//iot/home#/test).
1. Dans l'onglet **S'abonner à la rubrique**, dans le **filtre de rubrique****test/cust-auth/topic**, entrez la rubrique du message utilisé dans l'exemple Postman de la section précédente.
1. Choisissez **Abonner**.
Gardez cette fenêtre visible pour l'étape suivante.
1. Dans Postman, dans la demande que vous avez créée pour la section précédente, choisissez **Envoyer**.
Passez en revue la réponse pour vous assurer qu'elle a bien été prise en compte. Si ce n'est pas le cas, corrigez l'erreur comme décrit dans la section précédente.
1. Dans le **client de test MQTT**, vous devriez voir une nouvelle entrée indiquant la rubrique du message et, s'il est développé, la charge utile du message provenant de la demande que vous avez envoyée depuis Postman.
Si vous ne voyez pas vos messages dans le **client de test MQTT**, voici quelques points à vérifier :
+ Assurez-vous que votre demande Postman a été renvoyée avec succès. En cas de AWS IoT rejet de la connexion et de renvoi d'une erreur, le message contenu dans la demande n'est pas transmis au courtier de messages.
+ Assurez-vous que le Compte AWS et Région AWS utilisé pour ouvrir la AWS IoT console sont les mêmes que ceux que vous utilisez dans l'URL du Postman.
+ Assurez-vous que vous utilisez le point de terminaison approprié pour l'autorisateur personnalisé. Le point de terminaison IoT par défaut peut ne pas prendre en charge l'utilisation d'autorisateurs personnalisés dotés de fonctions Lambda. Vous pouvez plutôt utiliser des configurations de domaine pour définir un nouveau point de terminaison, puis spécifier ce point de terminaison pour l'autorisateur personnalisé.
+ Assurez-vous d'avoir correctement saisi la rubrique dans le **client de test MQTT**. Le filtre de sujet est sensible à la casse. En cas de doute, vous pouvez également vous abonner à la **\$1** rubrique, qui s'abonne à tous les messages MQTT qui passent par le courtier de messages Compte AWS et Région AWS utilisés pour ouvrir la AWS IoT console.
## Étape 7 : examen des résultats et des étapes suivantes
**Dans ce tutoriel :**
+ Vous avez créé une fonction Lambda pour être un gestionnaire de mécanisme d'autorisation personnalisé
+ Vous avez créé un mécanisme d'autorisation personnalisé avec la signature par jeton activée
+ Vous avez testé votre mécanisme d'autorisation personnalisé à l'aide de la commande **test-invoke-authorizer**
+ Vous avez publié une rubrique MQTT à l'aide de [Postman](https://www.postman.com/) et valider la demande avec votre mécanisme d'autorisation personnalisé
+ Vous avez utilisé le **client de test MQTT** pour visualiser les messages envoyés depuis votre test Postman
**Étapes suivantes**
Après avoir envoyé des messages de Postman pour vérifier que le mécanisme d’autorisation personnalisé fonctionne, essayez d'expérimenter pour voir comment la modification des différents aspects de ce didacticiel affecte les résultats. Voici quelques exemples pour vous aider à démarrer.
+ Modifiez la chaîne de signature afin qu'elle ne soit plus valide pour voir comment les tentatives de connexion non autorisées sont traitées. Vous devriez obtenir une réponse d'erreur, comme celle-ci, et le message ne devrait pas apparaître dans le **client de test MQTT**.
```
{
"message": "Forbidden",
"traceId": "15969756-a4a4-917c-b47a-5433e25b1356"
}
```
+ Pour en savoir plus sur la façon de détecter les erreurs susceptibles de se produire lors du développement et de l'utilisation de AWS IoT règles, consultez[Surveillance AWS IoT](monitoring_overview.md).
## Étape 8 : nettoyer
Si vous souhaitez répéter ce didacticiel, vous devrez peut-être supprimer certains de vos mécanismes d’autorisation personnalisés. Vous ne Compte AWS pouvez configurer qu'un nombre limité d'autorisateurs personnalisés à la fois et vous pouvez en obtenir un `LimitExceededException` lorsque vous essayez d'en ajouter un nouveau sans supprimer un autorisateur personnalisé existant.
**Pour supprimer un mécanisme d'autorisation personnalisé (console)**
1. Ouvrez la [page d'autorisation personnalisée de la AWS IoT console](https://console.aws.amazon.com//iot/home#/authorizerhub) et, dans la liste des autorisateurs personnalisés, recherchez l'autorisateur personnalisé à supprimer.
1. Ouvrez la page de détails de mécanisme d’autorisation personnalisé et, dans le menu **Actions**, choisissez **Modifier**.
1. Décochez la case **Activer l'autorisateur**, puis choisissez **Mettre à jour**.
Vous ne pouvez pas supprimer un mécanisme d'autorisation personnalisé lorsqu'il est actif.
1. Sur la page Détails du mécanisme d’autorisation personnalisé, ouvrez le menu **Actions** et choisissez **Supprimer**.
**Pour supprimer un mécanisme d'autorisation personnalisé (AWS CLI)**
1. Répertoriez les mécanismes d’autorisation personnalisées que vous avez installées et recherchez ceux que vous souhaitez supprimer.
```
aws iot list-authorizers
```
1. Définissez le mécanisme d'autorisation personnalisé sur `inactive` en exécutant cette commande après avoir remplacé `Custom_Auth_Name` par `authorizerName` du mécanisme d'autorisation personnalisé à supprimer.
```
aws iot update-authorizer --status INACTIVE --authorizer-name Custom_Auth_Name
```
1. Supprimez le mécanisme d'autorisation personnalisé `Custom_Auth_Name` en exécutant cette commande après avoir remplacé `authorizerName` par du mécanisme d'autorisation personnalisé à supprimer.
```
aws iot delete-authorizer --authorizer-name Custom_Auth_Name
```
# Tutoriel : Surveillance de l'humidité du sol avec un AWS IoT Raspberry Pi
Ce didacticiel vous explique comment utiliser un [Raspberry Pi](https://www.raspberrypi.org/), un capteur d'humidité, et comment AWS IoT surveiller le niveau d'humidité du sol pour une plante d'intérieur ou un jardin. Le Raspberry Pi exécute un code qui lit le niveau d'humidité et la température à partir du capteur, puis envoie les données à AWS IoT. Vous créez une règle AWS IoT qui envoie un e-mail à une adresse abonnée à une rubrique Amazon SNS lorsque le niveau d'humidité tombe en dessous d'un seuil.
**Note**
Ce didacticiel n'est peut-être pas à jour. Certaines références ont peut-être été remplacées depuis la publication initiale de ce sujet.
**Contents**
+ [Conditions préalables](#iot-moisture-prereqs)
+ [Con AWS IoT figuration](iot-moisture-setup.md)
+ [Étape 1 : Création de la AWS IoT politique](iot-moisture-policy.md)
+ [Étape 2 : Création de l' AWS IoT objet, du certificat et de la clé privée](iot-moisture-create-thing.md)
+ [3e étape : Créer une rubrique Amazon SNS et s'abonner](iot-moisture-create-sns-topic.md)
+ [Étape 4 : créer une AWS IoT règle pour envoyer un e-mail](iot-moisture-create-rule.md)
+ [Configuration de votre Raspberry Pi et du capteur d'humidité](iot-moisture-raspi-setup.md)
## Conditions préalables
Pour suivre ce didacticiel, vous devez disposer des éléments suivants :
+ Un Compte AWS.
+ Utilisateur IAM possédant des autorisations de niveau administrateur.
+ Un ordinateur de développement exécutant Windows, macOS, Linux ou Unix pour accéder à la [console AWS IoT](https://console.aws.amazon.com/iot/home).
+ Un [Raspberry Pi 3B ou 4B](https://www.raspberrypi.com/products/) exécutant le dernier système d'[exploitation Raspberry Pi](https://www.raspberrypi.com/software/operating-systems/). Pour les instructions d'installation, voir [Installer un système d'exploitation](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) sur le site Web du Raspberry Pi.
+ Un écran, un clavier, une souris et un réseau Wi-Fi ou une connexion Ethernet pour votre Raspberry Pi.
+ Un capteur d'humidité compatible avec Raspberry Pi. Le capteur utilisé dans ce didacticiel est un [capteur d'humidité capacitif SteMMA I2C Adafruit](https://www.adafruit.com/product/4026) avec un [en-tête de câble à 4 broches vers connecteur femelle JST](https://www.adafruit.com/product/3950).
# Con AWS IoT figuration
Pour suivre ce didacticiel, vous devez créer les ressources suivantes. Pour connecter un appareil à AWS IoT, vous devez créer un objet IoT, un certificat d'appareil et une AWS IoT politique.
+ N' AWS IoT importe quoi.
Un objet représente un appareil physique (dans ce cas, votre Rasberry Pi) et contient des métadonnées statiques sur l'appareil.
+ Un certificat d'appareil.
Tous les appareils doivent avoir un certificat d'appareil pour se connecter à AWS IoT et s'authentifier auprès de celui-ci.
+ Une AWS IoT politique.
Une ou plusieurs AWS IoT politiques sont associées à chaque certificat d'appareil. Ces politiques déterminent les AWS IoT ressources auxquelles l'appareil peut accéder.
+ Un certificat CA AWS IoT racine.
Les appareils et autres clients utilisent un certificat CA AWS IoT racine pour authentifier le AWS IoT serveur avec lequel ils communiquent. Pour de plus amples informations, veuillez consulter [Authentification du serveur](server-authentication.md).
+ Une AWS IoT règle.
Une règle contient une requête et une ou plusieurs actions de règle. La requête extrait les données des messages de l'appareil pour déterminer si les données du message doivent être traitées. L'action de règle spécifie ce qu'il faut faire si les données correspondent à la requête.
+ Une rubrique Amazon SNS et une souscription de rubrique.
La règle écoute les données d'humidité de votre Raspberry Pi. Si la valeur est inférieure à un seuil, un message est envoyé dans la rubrique Amazon SNS. Amazon SNS envoie ce message à toutes les adresses e-mail abonnées au sujet.
# Étape 1 : Création de la AWS IoT politique
Créez une AWS IoT politique qui permet à votre Raspberry Pi de se connecter et d'envoyer des messages à AWS IoT.
1. Dans la [console AWS IoT](https://console.aws.amazon.com/iot), si un bouton **Commencer** s'affiche, appuyez dessus. Dans le panneau de navigation du service, développez **Sécurité**, puis choisissez **Politiques**.
1. Si une boîte de dialogue **Vous ne possédez pas encore de stratégie** s'affiche, choisissez **Créer une stratégie**. Sinon, cliquez sur **Create**.
1. Entrez le nom de la AWS IoT politique (par exemple,**MoistureSensorPolicy**).
1. Dans la section **Ajouter des instructions**, remplacez la stratégie existante par le code JSON suivant. Remplacez *region* et *account* par votre Compte AWS numéro Région AWS et.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
}
]
}
```
1. Choisissez **Créer**.
# Étape 2 : Création de l' AWS IoT objet, du certificat et de la clé privée
Créez un objet dans le AWS IoT registre pour représenter votre Raspberry Pi.
1. Dans la [console AWS IoT](https://console.aws.amazon.com/iot/home), dans le panneau de navigation, choisissez **Gérer**, puis **Objets**.
1. Si une boîte de dialogue **Vous n'avez pas encore d'objets** s'affiche, choisissez **Enregistrer un objet**. Sinon, cliquez sur **Create**.
1. Sur la page **Création d' AWS IoT objets**, choisissez **Créer un objet unique**.
1. Sur la page **Add your device to the device registry (Ajouter votre appareil au registre des appareils)**, entrez un nom pour votre objet IoT (par exemple, **RaspberryPi**), puis choisissez **Next (Suivant)**. Vous ne pouvez pas modifier le nom d'un objet après l'avoir créé. Pour changer le nom d'un objet, vous devez créer un objet, lui donner un nouveau nom, puis supprimer l'ancien objet.
1. Sur la page **Add a certificate for your thing (Ajouter un certificat pour votre objet)**, choisissez **Create certificate (Créer un certificat)**.
1. Choisissez les liens **Télécharger** pour télécharger le certificat, la clé privée et le certificat CA racine.
**Important**
C'est la seule fois que vous pouvez télécharger votre certificat et votre clé privée.
1. Choisissez **Activer** pour activer votre certificat. Le certificat doit être actif pour qu'un appareil puisse se connecter à AWS IoT.
1. Choisissez **Attacher une stratégie**.
1. Pour **Ajouter une politique pour votre objet**, choisissez **MoistureSensorPolicy**, puis choisissez **Enregistrer l'objet**.
# 3e étape : Créer une rubrique Amazon SNS et s'abonner
Créer une rubrique Amazon SNS et s'abonner
1. Dans la [AWS console SNS, dans le volet de navigation, choisissez ](https://console.aws.amazon.com/sns/home)Rubriques, puis **Créer un rôle**.
1. Choisissez le type **Standard** et entrez le nom du sujet (par exemple,**MoistureSensorTopic**).
1. Entrez un nom d'affichage pour la rubrique (par exemple, **Moisture Sensor Topic**). Il s'agit du nom affiché pour votre rubrique dans la console Amazon SNS.
1. Choisissez **Créer une rubrique**.
1. Sur la page des détails de la rubrique , sélectionnez **Créer un abonnement**.
1. Pour **Protocole**, choisissez **E-mail**.
1. Saisissez votre adresse e-mail dans **Endpoint (Point de terminaison)**.
1. Choisissez **Créer un abonnement**.
1. Ouvrez votre client de messagerie et recherchez un message avec l'objet **MoistureSensorTopic**. Ouvrez cet e-mail et cliquez sur le lien **Confirmer l'abonnement**.
**Important**
Vous ne recevrez aucune alerte par e-mail de cette rubrique Amazon SNS tant que vous n'aurez pas confirmé l'abonnement.
Vous devriez recevoir un message électronique contenant le texte que vous avez saisi.
# Étape 4 : créer une AWS IoT règle pour envoyer un e-mail
Une AWS IoT règle définit une requête et une ou plusieurs actions à effectuer lorsqu'un message est reçu d'un appareil. Le moteur de AWS IoT règles écoute les messages envoyés par les appareils et utilise les données contenues dans les messages pour déterminer si des mesures doivent être prises. Pour de plus amples informations, veuillez consulter [Règles pour AWS IoT](iot-rules.md).
Dans ce didacticiel, votre Raspberry Pi publie des messages sur `aws/things/RaspberryPi/shadow/update`. Il s'agit d'une rubrique MQTT interne utilisée par les appareils et le service Thing Shadow. Le Raspberry Pi publie des messages sous la forme suivante :
```
{
"reported": {
"moisture" : moisture-reading,
"temp" : temperature-reading
}
}
```
Vous créez une requête qui extrait les données d'humidité et de température du message entrant. Vous créez également une action Amazon SNS qui prend les données et les envoie aux abonnés de la rubrique Amazon SNS si le relevé d'humidité est inférieur à un seuil.
**Créer une rubrique Amazon SNS**
1. Dans la [AWS IoT console](https://console.aws.amazon.com/iot/home), choisissez **Routage des messages**, puis **Règles**. Si une boîte de dialogue **Vous ne possédez pas encore de règle** s'affiche, choisissez **Créer une règle**. Sinon, choisissez **Créer une règle**.
1. Dans la page **des propriétés de la règle**, entrez un **Nom de règle** tel que**MoistureSensorRule**, et fournissez une brève **description de la règle**, telle que**Sends an alert when soil moisture level readings are too low**.
1. Choisissez **Next** et configurez votre instruction SQL. Choisissez **la version SQL** **2016-03-23** et entrez l'instruction de requête AWS IoT SQL suivante :
```
SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
```
Cette instruction déclenche l'action de la règle lorsque la valeur de `moisture` est inférieure à `400`.
**Note**
Vous devrez peut-être utiliser une valeur différente. Une fois que vous avez le code qui s'exécute sur votre Raspberry Pi, vous pouvez voir les valeurs que vous obtenez de votre capteur en touchant le capteur, en le plaçant dans l'eau ou en le plaçant dans un pot.
1. Choisissez **Next** et associez des actions de règle. Pour **l'action 1**, choisissez **Simple Notification Service**. La description de cette action de règle est **Envoyer un message sous forme de notification push SNS**.
1. Pour le **sujet SNS**, choisissez le sujet dans [3e étape : Créer une rubrique Amazon SNS et s'abonner](iot-moisture-create-sns-topic.md) lequel vous avez créé le message et laissez le format du **message au format** **RAW**. **MoistureSensorTopic** Pour Rôle IAM, choisissez Créer un rôle.******** Entrez un nom pour le rôle par exemple, **LowMoistureTopicRole**, puis choisissez **Créer un rôle**.
1. Cliquez sur **Suivant** pour passer en revue, puis sur **Créer** pour créer la règle.
# Configuration de votre Raspberry Pi et du capteur d'humidité
Insérez votre carte micro SD dans le Raspberry Pi, connectez votre écran, votre clavier, votre souris et, si vous n'utilisez pas le Wi-Fi, un câble Ethernet. Ne connectez pas encore le câble d'alimentation.
Connectez le câble jumper JST au capteur d'humidité. L'autre côté du jumper a quatre câbles :
+ Vert : I2C SCL
+ Blanc : I2C SDA
+ Rouge : alimentation (3,5 V)
+ Black : terre
Maintenez la carte Raspberry Pi enfoncée avec la prise Ethernet sur la droite. Dans cette orientation, il y a deux lignes de broches GPIO en haut. Connectez les câbles du capteur d'humidité à la ligne inférieure de broches dans l'ordre suivant. À partir du connecteur le plus à gauche, connectez rouge (alimentation), blanc (SDA) et vert (SCL). Ignorez une broche, puis connectez le fil noir (terre). Pour plus d'informations, consultez [Câblage informatique Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).
Attachez le câble d'alimentation au Raspberry Pi et branchez l'autre extrémité à une prise murale pour l'allumer.
**Configuration de votre Raspberry Pi**
1. Sur **Welcome to Raspberry Pi (Bienvenue dans Raspberry Pi)**, choisissez **Next (Suivant)**.
1. Choisissez votre pays, votre langue, votre fuseau horaire et votre disposition du clavier. Choisissez **Suivant**.
1. Saisissez un mot de passe pour votre Raspberry Pi, puis choisissez **Next (Suivant)**.
1. Choisissez votre réseau Wi-Fi, puis choisissez **Next (Suivant)**. Si vous n'utilisez pas de réseau Wi-Fi, choisissez **Skip (Ignorer)**.
1. Choisissez **Next (Suivant)** pour rechercher les mises à jour logicielles. Lorsque les mises à jour sont terminées, choisissez **Restart (Redémarrer)** pour redémarrer votre Raspberry Pi.
Une fois que votre Raspberry Pi a démarré, activez l'interface I2C.
1. Dans le coin supérieur gauche du bureau Raspbian, cliquez sur l'icône Raspberry, choisissez **Preferences (Préférences)**, puis **Raspberry Pi Configuration (Configuration du Raspberry Pi)**.
1. Sous l'onglet **Interfaces** pour **I2C**, choisissez **Enable (Activer)**.
1. Choisissez **OK**.
Les bibliothèques du capteur d'humidité Adafruit STEMMA ont été écrites pour. CircuitPython Pour les exécuter sur un Raspberry Pi, vous devez installer la dernière version de Python 3.
1. Exécutez les commandes suivantes à partir d'une invite de commande pour mettre à jour votre logiciel Raspberry Pi :
`sudo apt-get update`
`sudo apt-get upgrade`
1. Exécutez la commande suivante pour mettre à jour votre installation Python 3 :
`sudo pip3 install --upgrade setuptools`
1. Exécutez la commande suivante pour installer les bibliothèques GPIO Raspberry Pi :
`pip3 install RPI.GPIO`
1. Exécutez la commande suivante pour installer les bibliothèques Adafruit Blinka :
`pip3 install adafruit-blinka`
Pour plus d'informations, consultez [Installation de CircuitPython bibliothèques sur le Raspberry Pi](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi).
1. Exécutez la commande suivante pour installer les bibliothèques Adafruit Seesaw :
`sudo pip3 install adafruit-circuitpython-seesaw`
1. Exécutez la commande suivante pour installer le AWS IoT Device SDK pour Python :
`pip3 install AWSIoTPythonSDK`
Votre Raspberry Pi dispose désormais de toutes les bibliothèques requises. Créez un fichier appelé **moistureSensor.py** et copiez le code Python suivant dans le fichier :
```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA
import logging
import time
import json
import argparse
import busio
# Shadow JSON schema:
#
# {
# "state": {
# "desired":{
# "moisture":,
# "temp":
# }
# }
# }
# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):
# Display status and data from update request
if responseStatus == "timeout":
print("Update request " + token + " time out!")
if responseStatus == "accepted":
payloadDict = json.loads(payload)
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Update request with token: " + token + " accepted!")
print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Update request " + token + " rejected!")
# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):
# Display status and data from delete request
if responseStatus == "timeout":
print("Delete request " + token + " time out!")
if responseStatus == "accepted":
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Delete request with token: " + token + " accepted!")
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Delete request " + token + " rejected!")
# Read in command-line parameters
def parseArgs():
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")
args = parser.parse_args()
return args
# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Parse command line arguments
args = parseArgs()
if not args.certificatePath or not args.privateKeyPath:
parser.error("Missing credentials for authentication.")
exit(2)
# If no --port argument is passed, default to 8883
if not args.port:
args.port = 8883
# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)
# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec
# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)
# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)
# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()
# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)
# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)
# Read data from moisture sensor and update shadow
while True:
# read moisture level through capacitive touch pad
moistureLevel = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
# Display moisture and temp readings
print("Moisture Level: {}".format(moistureLevel))
print("Temperature: {}".format(temp))
# Create message payload
payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}
# Update shadow
deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
time.sleep(1)
```
Enregistrez le fichier dans un emplacement où vous le trouverez. Sur la ligne de commande, tapez `moistureSensor.py` avec les paramètres suivants :
point de terminaison
Votre point de AWS IoT terminaison personnalisé. Pour de plus amples informations, veuillez consulter [API REST Device Shadow](device-shadow-rest-api.md).
rootCA
Le chemin complet vers votre certificat CA AWS IoT racine.
cert
Le chemin complet vers le certificat de votre AWS IoT appareil.
clé
Le chemin complet vers la clé privée du certificat de votre AWS IoT appareil.
thingName
Votre nom d'objet (dans ce cas, `RaspberryPi`).
clientId
ID du client MQTT. Utilisez `RaspberryPi`.
La ligne de commande doit se présenter comme suit :
`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`
Essayez de toucher le capteur, de le placer dans un pot ou de le placer dans un verre d'eau pour voir comment le capteur réagit à différents niveaux d'humidité. Si nécessaire, vous pouvez modifier la valeur de seuil dans `MoistureSensorRule`. Lorsque la valeur du capteur d'humidité est inférieure à la valeur spécifiée dans l'instruction de requête SQL de votre règle, AWS IoT un message est publié dans la rubrique Amazon SNS. Vous devez recevoir un e-mail contenant les données relatives à l'humidité et à la température.
Une fois que vous avez vérifié la réception des e-mails provenant de , appuyez sur **CTRL\$1C** pour arrêter le programme Python. Il est peu probable que le programme Python envoie suffisamment de messages pour générer des frais, mais il est recommandé d'arrêter le programme une fois que vous avez terminé.