MQTT (pour Message Queue Telemetry Transport) est un protocole de messagerie simple et léger, basé sur une architecture dit « publish / subscribe » spécifiquement conçue pour des applications M2M (Machine To Machine) et très utilisé dans l’IoT (Internet of Things).

Ces appareils IoT utilisent MQTT pour le transfert de données car il est facile à mettre en œuvre et communique efficacement les données IoT. MQTT prend en charge la messagerie appareil-à-cloud et cloud-à-appareil.

Présentation technique

L’architecture publish / subscribe permet à un client MQTT (un capteur de température par exemple) de publier un message sur le réseau sans se soucier des destinataires du message. Le client est alors ce qu’on appelle un « publisher ».

Schéma de l’architecture Publish/Subscribe (sources : KEB america)

Le client « publisher » publie son message sur un topic (sujet) auquel peuvent être abonnés les clients qui souhaitent recevoir ce type de message. Les clients abonnés au topic sont les «subscribers » de ce topic.

Le lien entre les « publishers » (ceux qui publient) et les « subscribers » (ceux qui souscrivent) est assuré par un serveur central appelé « broker » dont la principale fonction est de distribuer les messages publiés sur un topic aux abonnés de ce topic (les subscribers).

L'implémentation

• Le protocole MQTT fonctionne sur TCP.
• Le broker le plus utilisé s'appelle Mosquitto (Eclipse open source EPL/EDL licensed)
• Mosquitto permet d'interfacer MQTT avec WebSockets (qui fonctionne sur HTTP)
• La bibliothèque cliente la plus utilisée s'appelle PubSubClient

Voici une représentation de l'encapsulation des protocoles réseau :

Avantages

• Notification en temps réel de la publication des nouvelles données sans devoir constamment interroger un serveur
• Un matériel connecté peut être à la fois publisher et subscriber. Il peut donc recevoir des données et renvoyer des données traitées.
• Le protocole MQTT peut envoyer tout type de donnée, que ce soit du texte ou des données binaires. Il suffit juste que l’entité qui reçoit la donnée sache l’interpréter et la traiter.
• Grâce aux Qualités de Service (QoS), le protocole MQTT gagne en fiabilité et assure la bonne réception des données.
• L’architecture publisher / subscriber est économe en énergie.

Inconvénients

• Toutes les données étant envoyées sur le broker, si ce dernier se déconnecte d’internet, tout le réseau publisher / subscriber est paralysé.
• Le protocole MQTT n’est pas chiffré par défaut. Il faut donc rajouter un protocole de sécurité comme TLS/SSL.

Installation du broker Mosquitto sur Linux

Dans un premier temps, on s'assure de mettre à jour la liste des dépôts et les mises à jours système :

sudo apt update
sudo apt upgrade

Ensuite, au niveau de l'installation de Mosquitto, elle se fait très simplement depuis le gestionnaire de paquet APT :

sudo apt install mosquitto

Après l'installation, Mosquitto est démarré automatiquement avec son paramétrage par défaut (démarrage en tâche de fond en tant que daemon linux).

Tester si le daemon est démarré (dans les processus) :

ps -ef | grep mosquitto
mosquit+   891     1  0 12:02 ?        00:00:00 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

Tester si le daemon est démarré (avec systemctl) :

systemctl status mosquitto

● mosquitto.service - Mosquitto MQTT v3.1/v3.1.1 Broker
   Loaded: loaded (/lib/systemd/system/mosquitto.service; enabled; vendor preset: enabled)
   Active: active (running) since Sun 2021-01-31 12:02:46 GMT; 4min 46s ago
     Docs: man:mosquitto.conf(5)
           man:mosquitto(8)
 Main PID: 891 (mosquitto)
    Tasks: 1 (limit: 2063)
   CGroup: /system.slice/mosquitto.service
           └─891 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

Jan 31 12:02:46 raspberrypi systemd[1]: Starting Mosquitto MQTT v3.1/v3.1.1 Broker...
Jan 31 12:02:46 raspberrypi systemd[1]: Started Mosquitto MQTT v3.1/v3.1.1 Broker.

Le fichier de configuration principal de mosquitto est /etc/mosquitto/mosquitto.conf, il indique que pour modifier la configuration de mosquitto, il faut ajouter un fichier xxx.conf dans le dossier /etc/mosquitto/conf.d/.

Tester le port d'écoute de Mosquitto avec netstat (doc des commandes netstat et ss ici) :

sudo netstat -tunlp

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      592/sshd
tcp        0      0 0.0.0.0:1883            0.0.0.0:*               LISTEN      891/mosquitto
tcp6       0      0 :::22                   :::*                    LISTEN      592/sshd
tcp6       0      0 :::1883                 :::*                    LISTEN      891/mosquitto
udp        0      0 0.0.0.0:68              0.0.0.0:*                           586/dhcpcd
udp        0      0 0.0.0.0:5353            0.0.0.0:*                           338/avahi-daemon: r
udp        0      0 0.0.0.0:39793           0.0.0.0:*                           338/avahi-daemon: r
udp6       0      0 :::5353                 :::*                                338/avahi-daemon: r
udp6       0      0 :::46989                :::*                                338/avahi-daemon: r

Par défaut, Mosquitto écoute sur le port TCP:1883 (en IPv4 0.0.0.0 et en IPv6 ::).

Remarque : Sur Linux, la commande netstat est peu à peu remplacée par la commande ss :

sudo ss -tunlp

Netid  State    Recv-Q   Send-Q     Local Address:Port      Peer Address:Port
udp    UNCONN   0        0                0.0.0.0:68             0.0.0.0:*      users:(("dhcpcd",pid=586,fd=10))
udp    UNCONN   0        0                0.0.0.0:5353           0.0.0.0:*      users:(("avahi-daemon",pid=338,fd=12))
udp    UNCONN   0        0                0.0.0.0:39793          0.0.0.0:*      users:(("avahi-daemon",pid=338,fd=14))
udp    UNCONN   0        0                      *:5353                 *:*      users:(("avahi-daemon",pid=338,fd=13))
udp    UNCONN   0        0                      *:46989                *:*      users:(("avahi-daemon",pid=338,fd=15))
tcp    LISTEN   0        128              0.0.0.0:22             0.0.0.0:*      users:(("sshd",pid=592,fd=3))
tcp    LISTEN   0        100              0.0.0.0:1883           0.0.0.0:*      users:(("mosquitto",pid=891,fd=5))
tcp    LISTEN   0        128                 [::]:22                [::]:*      users:(("sshd",pid=592,fd=4))
tcp    LISTEN   0        100                 [::]:1883              [::]:*      users:(("mosquitto",pid=891,fd=6))

Ajouter l'interfaçage WebSocket

L'objectif est d'utiliser un client MQTT dans une page web simple en abordant ce protocole avec le JavaScript.

Pourquoi le WebSocket ?

Comme les navigateurs web ne peuvent communiquer qu'avec le protocole HTTP, on ne peut pas utiliser le protocole MQTT directement (voir pile de protocole plus haut dans ce document)

Le protocole WebSocket permet de combler ce manque car :

• Il s'agit d'un protocole qui fonctionne au dessus de HTTP,
• Il permet le dialogue par notification nécessaire pour les subscribers.

Le WebSocket permet de créer et de garder ouvert un canal de communication HTTP entre le client web et le serveur web. Comme le canal reste ouvert, le serveur peut envoyer des messages de notifications au client (ce qui est impossible avec le fonctionnement requête/réponse du HTTP standard).

Configuration de Mosquitto pour WebSocket

Pour pouvoir communiquer avec les clients WebSocket, le broker Mosquitto doit agir comme un serveur WebSocket. Pour lui ajouter cette fonctionnalité, il faut modifier sa configuration au démarrage.

Créez un fichier de configuration supplémentaire pour Mosquitto :

sudo nano /etc/mosquitto/conf.d/websockets.conf

Voici le contenu du fichier websockets.conf. Garder la configuration du port TCP 1883 pour les clients MQTT et ajoutez TCP:1884 pour les clients WebSocket :

listener 1883

listener 1884
protocol websockets

Dans l'éditeur nano, Ctrl+O enregistre les modifications, Ctrl+X afin de quitter la fenêtre d'édition.

Redémarrer Mosquitto pour qu'il prenne en compte les modifications de sa config.

sudo systemctl restart mosquitto

Vérifiez que Mosquitto écoute bien sur les deux ports TCP:1883 et TCP:1884 :

sudo netstat -tunlp

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      592/sshd
tcp        0      0 0.0.0.0:1883            0.0.0.0:*               LISTEN      1333/mosquitto
tcp        0      0 0.0.0.0:1884            0.0.0.0:*               LISTEN      1333/mosquitto
tcp6       0      0 :::22                   :::*                    LISTEN      592/sshd
tcp6       0      0 :::1883                 :::*                    LISTEN      1333/mosquitto
udp        0      0 0.0.0.0:68              0.0.0.0:*                           586/dhcpcd
udp        0      0 0.0.0.0:5353            0.0.0.0:*                           338/avahi-daemon: r
udp        0      0 0.0.0.0:39793           0.0.0.0:*                           338/avahi-daemon: r
udp6       0      0 :::5353                 :::*                                338/avahi-daemon: r
udp6       0      0 :::46989                :::*                                338/avahi-daemon: r

Testons notre broker MQTT !

Télécharger l'utilitaire Open Source mqtt-spy sur https://github.com/eclipse/paho.mqtt-spy/wiki/Downloads

Cet utilitaire nécessite une machine virtuelle avec Java version > 8u60.

Informations de configuration :

Doc d'utilisation de mqtt-spy

Connections > New Connection > Onglet Connectivity :

• Server URL : adresse IP du broker Mosquitto
• Client ID : generate
• Open connection
• (enregistrer la config)

Sélectionnez l'onglet de la connexion (normalement en vert si la connexion au broker est établie)

• Abonnez vous à un topic "essai"
• Publiez un message sur le topic "essai"

Vous pouvez aussi utiliser la Chrome App MQTTLens.

Exemple d'un client WebSocket dans une page web

Voici deux exemples qui vous permettent de vous connecter à un serveur WebSocket en Javascript : le premier en utilisant une méthode native de JavaScript et une autre en utilisant Socket.io.

En utilisant la méthode native en JavaScript :

Ce script crée un nouvel objet WebSocket et lui envoie une requête de connexion au serveur WebSocket situé à l'adresse 'ws://www.example.com/server'. Lorsque la connexion est établie, la fonction onopen est appelée et un message est envoyé au serveur à l'aide de la méthode send(). Si le serveur envoie un message, la fonction onmessage est appelée et le message reçu est affiché dans la console.

Si une erreur se produit, la fonction onerror est appelée et l'erreur est affichée dans la console. Enfin, si la connexion est fermée, la fonction onclose est appelée.

var ws = new WebSocket('ws://<YOUR_IP_ADDRESS>');

ws.onopen = function() {
 console.log('Connection ouverte');
 ws.send('Hello Server!');
};

ws.onmessage = function(event) {
 console.log('Message reçu du serveur : ', event.data);
};

ws.onerror = function(error) {
 console.log('Erreur : ', error);
};

ws.onclose = function() {
 console.log('Connexion fermée');
};

En utilisant Socket.io :

Tout d'abord, vous devez inclure la bibliothèque WebSocket de JavaScript en ajoutant cette ligne de code à votre fichier HTML :

<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/2.0.3/socket.io.js"></script>

Ensuite, vous pouvez créer une nouvelle instance de WebSocket en utilisant le constructeur WebSocket :

var socket = new WebSocket('ws://localhost:8080');

Vous pouvez maintenant écouter les événements de connexion du socket en utilisant les méthodes suivantes :

// Lorsque la connexion est ouverte 
socket.onopen = function() {
    console.log('Connexion établie');
};

// Lorsqu'un message est reçu 
socket.onmessage = function(event) {
    console.log('Message reçu : ' + event.data);
}; 

// Lorsqu'il y a une erreur de connexion 
socket.onerror = function(error) {
    console.log('Erreur : ' + error);
};

// Lorsque la connexion est fermée 
socket.onclose = function() {
    console.log('Connexion fermée');
};

Vous pouvez envoyer un message au serveur en utilisant la méthode send() :

socket.send('Bonjour à tous !');

Vous pouvez également fermer la connexion en utilisant la méthode close() :

socket.close();

Conclusion

Et voilà ! Maintenant, vous avez un petit bagage sur le fonctionnement du MQtt en passant de la configuration et de l'installation. Pour toute suggestion / amélioration du tutoriel, n'hésitez-pas à Proposer une modification !