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 de l' AWS IoT appareil SDK

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.

Prérequis

Avant de commencer ce didacticiel, assurez-vous de disposer des éléments suivants :

Préparez votre appareil pour AWS IoT

Dans Commencer à utiliser les AWS IoT Core didacticiels, 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 :

Passez en revue le MQTT protocole

Avant de parler de l'exemple d'application, il est utile de comprendre le MQTT protocole. Le MQTT protocole offre certains avantages par rapport aux autres protocoles de communication réseau, notammentHTTP, ce qui en fait un choix populaire pour les appareils IoT. Cette section passe en revue les principaux aspects MQTT qui s'appliquent à ce didacticiel. Pour plus d'informations sur le MQTT mode de comparaison avecHTTP, voirChoix d'un protocole d'application pour la communication de votre appareil.

MQTTutilise un modèle de communication publication/abonnement

Le MQTT protocole utilise un publish/subscribe communication model with its host. This model differs from the request/response modèle qui HTTP utilise. AvecMQTT, 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.

MQTTprend 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, —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'SDKexemple d'application pubsub.py pour appareil

Cette section passe en revue l'pubsub.pyexemple d'application du AWS IoT Device SDK v2 pour Python utilisé dans ce didacticiel. Ici, nous allons voir comment il se connecte AWS IoT Core pour publier des MQTT messages 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.

Protocoles de communication

L'pubsub.pyexemple montre une MQTT connexion utilisant les WSS protocoles MQTT and MQTT over. La bibliothèque AWS common runtime (AWS CRT) 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 mqtt_connection_builderpour établir une connexion à AWS IoT Core l'aide du MQTT protocole. mtls_from_pathutilise les certificats X.509 et TLS v1.2 pour authentifier le périphérique. La AWS CRT bibliothèque 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
)

MQTTterminé WSS

Les pubsub.py exemples d'appels websockets_with_default_aws_signing (présentés ici) dans le mqtt_connection_builderpour établir une connexion en AWS IoT Core utilisant le MQTT protocole overWSS. websockets_with_default_aws_signingcrée une MQTT connexion à l'WSSaide de Signature V4 pour authentifier l'appareil.

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 HTTPS ? AWS IoT Core prend en charge les appareils qui publient HTTPS des demandes. Du point de vue de la programmation, les appareils envoient HTTPS des demandes AWS IoT Core comme le ferait n'importe quelle autre application. Pour un exemple de programme Python qui envoie un HTTP message depuis un appareil, consultez l'exemple de HTTPS code utilisant la requests bibliothèque Python. Cet exemple envoie un message à AWS IoT Core un HTTPS utilisateur qui l' AWS IoT Core interprète comme un MQTT message.

Tout AWS IoT Core en prenant en charge les HTTPS demandes des appareils, assurez-vous de consulter les informations Choix d'un protocole d'application pour la communication de votre appareil correspondantes 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.

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

Le AWS CRT moteur d'exécution de Python définit les constantes suivantes 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).

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.pyexemple appelle le publish 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 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, 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 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()

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.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.pyexempleon_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.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 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 MQTT 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'pubsub.pyexemple du AWS IoT Device SDK v2 pour Python et s'appuient sur votre expérience des Commencer à utiliser les AWS IoT Core didacticiels didacticiels.

Pour ces exercices, vous allez commencer par 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 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.

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.pyexemple d'application pour évaluer les sujets des messages et traiter les messages souscrits en fonction du sujet.

Procédure d'exercice

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 JSON documents. Cet exercice modifie l'exemple d'application afin de pouvoir publier JSON des documents lisibles dans la charge utile des messages. 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
        }
    ]
}

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 :