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 de l'AWS IoTappareil

Ce didacticiel explique comment connecter un appareilAWS IoT Core afin qu'il puisse envoyer et recevoir des données depuis et versAWS IoT. Une fois ce didacticiel terminé, votre appareil sera configuré pour se connecter àAWS IoT Core et vous comprendrez comment les appareils communiquent avecAWS IoT.

Dans ce didacticiel, vous allez :

Ce tutoriel vous prendra environ une heure.

Préparez votre appareil pourAWS IoT

DansCommencer avec AWS IoT Core, vous avez préparé votre appareil et votreAWS compte afin qu'ils puissent communiquer. Cette section passe en revue les aspects de cette préparation qui s'appliquent à tout appareil connecté àAWS IoT Core.

Pour connecter un appareil àAWS IoT Core :

Vérifier le protocole MSON

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 HTTP, ce qui en fait un choix populaire pour les appareils IoT. Cette section passe en revue les principaux aspects de MQTT qui s'appliquent à ce didacticiel. Pour plus d'informations sur la comparaison entre MQTT et HTTP, consultezChoix d'un protocole pour la communication de votre appareil.

MQTT utilise un modèle de communication publié/abonnement

Le protocole MQTT utilise un modèle de communication publié/abonnement avec son hôte. Ce modèle est différent du modèle de demande/réponse utilisé par HTTP. Avec MQTT, les appareils établissent une session avec l'hôte identifié par un identifiant client unique. Pour envoyer des données, les appareils publient des messages identifiés par sujets vers un courtier de messages de l'hôte. Pour recevoir des messages du courtier de messages, les appareils s'abonnent à des sujets en envoyant des filtres de sujet dans les demandes d'abonnement 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 vers les appareils qui y sont abonnés. Grâce aux sessions persistantes, 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) qui garantissent que l'hôte reçoit les messages envoyés par l'appareil.

Consultez l'exemple d'application pubsub.py Device SDK

Cette section passe en revue l'pubsub.pyexemple d'application du AWS IoTDevice SDK v2 pour Python utilisé dans ce didacticiel. Ici, nous allons voir comment il se connecteAWS IoT Core pour publier des messages MQTT et s'y abonner. La section suivante présente des exercices qui vous aideront à découvrir comment un appareil se connecte et communique avecAWS IoT Core.

Protocoles de communication

L'pubsub.pyexemple montre une connexion MQTT utilisant les protocoles MQTT et MQTT over WSS. La bibliothèque AWSCRT (AWSCommon Runtime) prend en charge les protocoles de communication de bas niveau et est incluse dans leAWS IoT Device SDK v2 pour Python.

MQTT

Lespubsub.py exemples d'appelsmtls_from_path (présentés ici) dans le mqtt_connection_builderpour établir une connexion àAWS IoT Core l'aide du protocole MQTT. mtls_from_pathutilise des certificats X.509 et TLS v1.2 pour authentifier l'appareil. La bibliothèqueAWS 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
)

MSON sur WSON

Lespubsub.py exemples d'appelswebsockets_with_default_aws_signing (présentés ici) dans le mqtt_connection_builderpour établir une connexion àAWS IoT Core l'aide du protocole MQTT via WSS. websockets_with_default_aws_signingcrée une connexion MQTT via WSS à l'aide de Signature V4 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
)

HTTPS

Qu'en est-il du protocole HTTPS ? AWS IoT Coreprend en charge les appareils qui publient des requêtes HTTPS. Du point de vue de la programmation, les appareils envoient des requêtes HTTPSAWS IoT Core comme 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 utilisant larequests bibliothèque Python. Cet exemple envoie un message àAWS IoT Core l'aide du protocole HTTPS afin qu'il soitAWS IoT Core interprété comme un message MQTT.

Bien queAWS IoT Core les demandes HTTPS soient prises en charge depuis des appareils, assurez-vous de consulter les informations vous concernantChoix d'un protocole pour la communication de votre appareil afin de pouvoir prendre une décision éclairée sur le protocole à utiliser pour les communications de votre appareil.

Sessions persistantes

Dans l'exemple d'application, définir leclean_session paramètre surFalse indique que la connexion doit être persistante. En pratique, cela signifie que la connexion ouverte par cet appel se reconnecte à une session persistante existante, s'il en existe une. Sinon, il crée une nouvelle session persistante et s'y connecte.

Dans le cas d'une session persistante, 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 persistante, le courtier de messages envoie à l'appareil tous les messages stockés auxquels il s'est abonné.

Sans session permanente, l'appareil ne recevra pas les messages envoyés alors qu'il n'est pas connecté. L'option à utiliser dépend de votre application et de la nécessité ou non de communiquer les messages qui apparaissent alors qu'un appareil n'est pas connecté. Pour plus d'informations, veuillez consulter Sessions permanentes MQTT.

Qualité de 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 IoTprend 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 dansAWS IoT, consultezOptions de qualité de service (QoS) MQTT.

Le moteur d'exécutionAWS CRT pour Python définit ces constantes pour les niveaux de QoS qu'il prend en charge :

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

Publier un message

Une fois la connexion établie avec succèsAWS IoT Core, les appareils peuvent publier des messages. Pour ce faire, l'pubsub.pyexemple appelle lepublish fonctionnement de l'mqtt_connectionobjet.

mqtt_connection.publish(
    topic=args.topic,
    payload=message,
    qos=mqtt.QoS.AT_LEAST_ONCE
)

Abonnement aux messages

Pour recevoir des messages provenantAWS IoT d'autres services et appareils, les appareils s'abonnent à ces messages par le nom de leur sujet. Les appareils peuvent s'abonner à des messages individuels en spécifiant un nom de sujet, et à un groupe de messages en spécifiant un filtre de sujet, qui peut inclure des caractères génériques. L'pubsub.pyexemple utilise le code affiché ici pour s'abonner aux messages et enregistrer les fonctions de rappel afin de traiter le message une fois qu'il a été reçu.

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()

Lamqtt_connection.subscribe fonction renvoie un future et un identifiant 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.

La fonction de rappel

Le callback de l'pubsub.pyexemple 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()

Dans l'pubsub.pyexemple, afficheon_message_received uniquement la rubrique 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 afin de déterminer les actions à effectuer.

Déconnexion et reconnexion de l'appareil

L'pubsub.pyexemple 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 lors de ces événements sont spécifiques à l'application.

Lorsqu'un appareil se connecte pour la première fois, il doit s'abonner à des sujets pour les recevoir. Si la session d'un appareil est présente lorsqu'il se reconnecte, ses abonnements sont restaurés et tous les messages stocké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.

Connect votre appareil et communiquez avecAWS IoT Core

Cette section présente des exercices qui vous aideront à 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 de laAWS IoT console pour voir ce que votre appareil publie et pour publier des messages sur votre appareil. Ces exercices utilisent l'pubsub.pyexemple du AWS IoTDevice SDK v2 pour Python et s'appuient sur votre expérience à l'aide deCommencer avec AWS IoT Core didacticiels.

Pour ces exercices, vous allez partir de l'pubsub.pyexemple de programme.

Abonnez-vous aux filtres thématiques génériques

Dans cet exercice, vous allez modifier la ligne de commande utilisée pour appelerpubsub.py afin de vous abonner à un filtre thématique générique et traiter les messages reçus en fonction du sujet du message.

Procédure d'

Pour cet exercice, imaginez que votre appareil contient un contrôle de température et un contrôle de lumière. Il utilise ces noms de rubriques pour identifier les messages les concernant.

Résultat de l'exercice

Ainsipubsub.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. Remarquez que vous vous êtes abonné à un filtre de rubrique unique et que la fonction de rappel a été appelée pour traiter les messages comportant deux sujets distincts.

Traiter les abonnements aux filtres thématiques

Sur la base de l'exercice précédent, modifiez l'pubsub.pyexemple d'application pour évaluer les sujets des messages et traiter les messages auxquels vous êtes abonné en fonction du sujet.

Procédure d'

Vous devez voir ceci 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 peut 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.

Publier 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, les messages ne peuvent pas être lus en tant que 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 parAWS IoT Core.

Procédure d'

Dans cet exercice, le message suivant sera envoyé avec ledevice/data sujet.

{
    "timestamp": 1601048303,
    "sensorId": 28,
    "sensorData": [
        {
        "sensorName": "Wind speed",
        "sensorValue": 34.2211224
        }
    ]
}

Par défaut, il s'abonnepubsub3.py également aux messages qu'il envoie. Vous devriez voir qu'il 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 à envoyerAWS IoT Core pour tester la connectivité de base et fournir des messagesAWS 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 desAWS IoT règles.

Vérifier les résultats

Les exemples de ce didacticiel vous ont permis de découvrir les bases de la communication entre les appareilsAWS IoT Core, un élément fondamental de votreAWS IoT solution. Lorsque vos appareils sont en mesure de communiquer avec euxAWS IoT Core, ils peuvent transmettre des messages à desAWS services et à d'autres appareils sur lesquels ils peuvent agir. De même,AWS les services et autres appareils peuvent traiter des informations qui se traduisent par des messages renvoyés à vos appareils.

Lorsque vous serez prêt àAWS IoT Core approfondir votre exploration, essayez ces didacticiels :