Récemment, j'ai utilisé le protocole MQTT dans un projet pour la transmission de données. Comme je n'avais aucune connaissance préalable sur ce sujet, j'ai entrepris une étude approfondie. Cet article sert de mémoire pour mes futures références.

1. Qu'est-ce que MQTT

MQTT est un protocole de messagerie léger basé sur le modèle publication/abonnement, spécifiquement conçu pour les applications IoT dans des environnements à faible bande passante et réseaux instables. Il permet d'offrir des services de messagerie en temps réel et fiables aux appareils connectés avec un minimum de code. Le protocole MQTT est largement utilisé dans les domaines de l'Internet des objets, de l'Internet mobile, du matériel intelligent, des véhicules connectés, des villes intelligentes, de la médecine à distance, de l'électricité, du pétrole et de l'énergie.

Selon le créateur du protocole MQTT, ce dernier doit posséder les caractéristiques suivantes :

1. Simple et facile à implémenter
2. Support du QoS (en raison des environnements réseau complexes des appareils)
3. Léger et économique en bande passante (à une époque où la bande passante était très coûteuse)
4. Indépendant des données (ne se soucie pas du format des données utiles)
5. Capacité de perception de session continue (savoir en permanence si l'appareil est en ligne)

Grâce à ses avantages tels que sa légèreté, son efficacité, la transmission de messages fiable, le support de connexions massives et une communication bidirectionnelle sécurisée, MQTT est devenu le protocole de choix pour l'industrie IoT.

2. Principes de fonctionnement de MQTT

2.1 Concepts de base

Client MQTT : Toute application ou appareil exécutant une bibliothèque client MQTT est considéré comme un client MQTT. Par exemple, une application de messagerie enstantanée utilisant MQTT est un client, divers capteurs utilisant MQTT pour transmettre des données sont des clients, et divers outils de test MQTT sont également des clients.

Broker MQTT : Le Broker MQTT est le composant clé responsable du traitement des requêtes des clients, y compris l'établissement et la rupture de connexions, les abonnements et les désabonnements, ainsi que le transfert de messages. (EMQX, en tant que broker MQTT exceptionnel, est le choix idéal pour l'apprentissage. Cet article est basé sur EMQX pour l'apprentissage et la présentation.)

Modèle publication/abonnement : La différence entre le modèle publication/abonnement et le modèle client/serveur réside dans le fait que ce dernier découple le client émetteur de messages (éditeur) et le client récepteur de messages (abonné). L'éditeur et l'abonné n'ont pas besoin d'établir de connexion directe, le MQTT Broker se charge du routage et de la distribution des messages.

Thème : Le protocole MQTT transfère les messages en fonction des thèmes. Les thèmes sont hiérarchisés à l'aide de /, et les thèmes MQTT supportent deux types de caractères génériques : + et #.

1. + : représente un caractère générique unique, par exemple a/+ correspond à a/x ou a/y.
2. # : représente un caractère générique multiple, par exemple a/# correspond à a/x, a/b/c/d. [Remarque : les thèmes génériques ne peuvent être utilisés que pour l'abonnement, pas pour la publication.]

QoS (Qualité de Service) :

MQTT propose trois niveaux de qualité de service pour garantir la fiabilité des messages dans différents environnements réseau :

• QoS 0 : Le message est délivré au plus une fois. Si le client n'est pas disponible, le message sera perdu.
• QoS 1 : Le message est délivré au moins une fois.
• QoS 2 : Le message est délivré exactement une fois.

2.2 Flux de travail

1. Le client établit une connexion avec le Broker en utilisant le protocole TCP/IP, en optionnant TLS/SSL pour une communication sécurisée. Le client fournit des informations d'authentification et spécifie le type de session (Session propre ou Session persistante).
2. Le client peut publier des messages vers des thèmes spécifiques ou s'abonner à des thèmes pour recevoir des messages. Lorsqu'un client publie un message, l'envoie au MQTT Broker ; lorsqu'il s'abonne à un thème, il reçoit les messages correspondants.
3. Le MQTT Broker reçoit les messages publiés et les transfère aux clients abonnés aux thèmes correspondants. Il garantit la transmission fiable des messages en fonction du niveau QoS et stocke les messages pour les clients déconnectés en fonction du type de session.

3. Utilisation simple de MQTT

L'un des avantages d'EMQX est de fournir un client sous forme Web (MQTTX) ainsi qu'un Broker d'essai en ligne, ce qui offre une grande commodité pour les apprenants MQTT.

Cet article utilise Docker pour déployer localement emqx. Les étapes de déploiement sont les suivantes :

1. docker pull emqx/emqx:5.1.6
2. docker run -d --name emqx -p 1883:1883 -p 8083:8083 -p 8084:8084 -p 8883:8883 -p 18083:18083 emqx/emqx:5.1.6
3. Dans votre navigateur, entrez votre IP:18083, le nom d'utilisateur et le mot de passe par défaut sont admin/public, un changement de mot de passe est requis lors de la première connexion.

La page ouverte est la console de gestion intégrée fournie par EMQX, c'est-à-dire l'EMQX Dashboard. Cela permet aux utilisateurs de gérer et de surveiller facilement le cluster EMQX via une interface Web, et de configurer et utiliser les fonctionnalités nécessaires. C'est également l'un des avantages d'EMQX.

Dans la page d'authentification client de l'EMQX Dashboard, ajoutez un mécanisme d'authentification basé sur les mots de passe. Vous pouvez également choisir la source de données pour stocker les informations d'authentification, ce qui rend son utilisation très pratique. [Optionnel]

Voici un exemple de démonstration de réception et d'envoi de données avec un client Python (paho-mqtt). Le Broker utilisé est déployé localement, mais vous pouvez également utiliser le Broker d'essai fourni par EMQX.

import random
import time
from paho.mqtt import client as mqtt_client

serveur_broker = 'ADRESSE_IP'
port = 8083
theme = "/exemple/mqtt"
identifiant_client = f'client-mqtt-{random.randint(0, 1000)}'
utilisateur = 'nom_utilisateur'
mot_de_passe = 'mot_passe'


def connexion_mqtt() -> mqtt_client:
    def lors_connexion(client, donnees_utilisateur, drapeaux, code_retour):
        if code_retour == 0:
            print("Connecté au Broker MQTT !")
        else:
            print("Échec de la connexion, code de retour %d\n", code_retour)

    client = mqtt_client.Client(identifiant_client, transport="websockets")
    client.username_pw_set(username=utilisateur, password=mot_de_passe)
    client.on_connect = lors_connexion
    client.connect(host=serveur_broker, port=port)
    return client


def publier(client: mqtt_client):
    compteur_messages = 0
    while True:
        time.sleep(1)
        message = f"message: {compteur_messages}"
        resultat = client.publish(theme, message)
        statut = resultat[0]
        if statut == 0:
            print(f"Envoyé {message} au thème {theme}")
        else:
            print(f"Échec de l'envoi du message au thème {theme}")
        compteur_messages += 1


def execution():
    client = connexion_mqtt()
    client.loop_start()
    publier(client)

import random
from paho.mqtt import client as mqtt_client

serveur_broker = 'ADRESSE_IP'
port = 8083
theme = "/exemple/mqtt"
identifiant_client = f'client-mqtt-{random.randint(0, 1000)}'
utilisateur = 'nom_utilisateur'
mot_de_passe = 'mot_passe'


def connexion_mqtt() -> mqtt_client:
    def lors_connexion(client, donnees_utilisateur, drapeaux, code_retour):
        if code_retour == 0:
            print("Connecté au Broker MQTT !")
        else:
            print("Échec de la connexion, code de retour %d\n", code_retour)

    client = mqtt_client.Client(identifiant_client, transport="websockets")
    client.username_pw_set(username=utilisateur, password=mot_de_passe)
    client.on_connect = lors_connexion
    client.connect(host=serveur_broker, port=port)
    return client


def s_abonner(client: mqtt_client):
    def lors_reception(client, donnees_utilisateur, message):
        print(message)
        print(f"Reçu {message.payload.decode()} du thème {message.topic}")

    client.subscribe(theme)
    client.on_message = lors_reception


def execution():
    client = connexion_mqtt()
    s_abonner(client)
    client.loop_forever()

Après exécution des scripts, vous pouvez voir en temps réel l'utilisation du Broker dans la console, ce qui est extrêmement pratique.

4. Débogage MQTT

Dans la console EMQX, l'aperçu vous montre le volume de données entrantes actuel. Vous pouvez statistiquement quantifier la quantité de données reçues et consommées par thème par période, mais si vous souhaitez déboguer spécifiquement les entrées et sorties de données pour un thème particulier, vous pouvez utiliser la fonctionnalité de surveillance des thèmes. Sous la surveillance des thèmes, vous pouvez consulter les valeurs d'entrée, de sortie et de perte de messages pour un thème spécifique.

Lors de l'envoi de messages, après l'appel de client.loop_start(), l'utilisation de la valeur de retour de publish pour déterminer si l'envoi du message a réussi ou échoué n'est pas très précis. Pour garantir l'envoi réussi du message, il est nécessaire d'appeler la méthode wait_for_publish() après la valeur de retour de publish, pour garantir un envoi à 100% des données.