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.
# 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) .