9  Partie IX — MQTT

9.1 Ce que le système de fichiers a enseigné, et ce pour quoi il n’est pas fait

Le système de fichiers a enseigné les frontières de publication, les répertoires comme adresses, l’observation, des processus indépendants, des langages indépendants, la latence de synchronisation, le câblage à l’exécution, le State, l’Intent, les Events, le coût des médiateurs, la propriété des services et les services transformateurs. Ce fut un bon professeur, et ce n’est pas un courtier de messages élégant : à la fin, l’architecture était propre et le transport était un amas de fichiers .tmp, de déplacements atomiques, de rescans, de chemins partagés et de délais de réplication.

La conclusion n’est pas « fichiers mauvais, MQTT bon ». Le système de fichiers a un avantage que MQTT ne peut égaler — il stocke couramment des gigaoctets ou des téraoctets, alors que courtiers et clients sont conçus pour de petits messages, et découper une charge énorme sur MQTT revient à inventer un protocole de transfert de fichiers dans un protocole de messages. Donc :

Utilisez les messages pour la coordination et les événements. Utilisez un stockage de fichiers ou d’objets adapté pour les grandes données. Un message peut porter l’emplacement, l’identité et les métadonnées de ces données au lieu des téraoctets eux-mêmes.

Un système de fichiers répliqué donne aussi à chaque machine une copie locale, ce qui est une vraie force — mais la réplication n’est pas une sauvegarde : suppressions et corruptions se répliquent aussi, à moins qu’un versionnement conserve les copies antérieures.

9.2 MQTT devrait sembler familier

système de fichiers / Syncthing MQTT
racine du tableau de messages synchronisé courtier / espace de noms
chemin de répertoire sujet (topic)
fichier .msg publication
contenu du fichier charge utile
WatchService abonnement
répertoire dynamique sujet / filtre
répertoire de contrôle I
répertoire d’état S/…
répertoire d’événements E/…

La réaction visée par le matériel : « Ah. Nous connaissons déjà cette architecture. » MQTT est un changement de transport, pas une affirmation architecturale.

Deux choses qu’un répertoire ne pouvait pas faire, visibles en une minute en ligne de commande. Une publication faite avant l’existence d’un abonné ne lui parvient jamais — le constat des messages bloqués, pour la troisième fois, mais avec une réponse que le système de fichiers n’avait pas. Et un filtre comme test/# correspond à test/a et test/a/b/c mais pas à testing/x, car # travaille par niveaux et non par préfixes de chaîne ; test/+ ne correspondrait qu’à un seul niveau.

La correction plus profonde : un sujet n’est pas un conteneur. Il n’existe aucun objet nommé test/a sur le courtier. Un sujet est une clé de routage portée par chaque publication et confrontée aux filtres de qui est abonné à cet instant. Les répertoires contiennent les messages ; les sujets les filtrent. Un seul abonnement couvre donc des sujets qui n’existent pas encore — là où un tableau de messages exigeait un nouveau répertoire et un nouvel enregistrement.

9.3 La bibliothèque, l’identifiant client et l’adresse du courtier

Java n’a pas de client MQTT dans sa bibliothèque standard ; Paho arrive donc maintenant — après le besoin, comme le médiateur à l’étape 7 et Jackson à l’étape 64. Quatre choses suffisent : se connecter, publier, s’abonner, rappeler. La connexion est volontairement anticlimatique : « Rien d’architectural ne s’est produit ici. Nous avons simplement attaché notre processus au transport. »

Deux détails de la connexion comptent :

  • l’identifiant client n’est pas qu’un jeton d’unicité. Le courtier reconnaît par lui un client qui revient et conserve son état de session : abonnements, messages en file en QoS > 0, et l’association à sa dernière volonté. Un répertoire ne savait jamais qui l’observait, et c’est précisément pour cela qu’un observateur redémarré ne rejouait rien.
  • l’adresse du courtier est de la configuration de déploiement : chaque programme lit System.getProperty("mqtt.broker", "tcp://localhost:1883"). C’est aussi la seule configuration qui ne peut pas arriver par Intent, puisque l’Intent passe par le courtier. La topologie se publie ; l’adresse de ce qui la publie, non.

S’abonner coûte un paquet, et le courtier détient la liste des abonnements. Il n’existe aucun moyen standard de lui demander à quoi un autre client s’est abonné — d’où S/subscriptions : la déclaration par un composant de son propre câblage, publiée pour que l’architecture sache ce que le transport garde privé. Seul son propriétaire peut la publier, par la règle de l’écrivain unique, car seul lui sait ce qu’il a accepté.

9.4 Intent structuré, et deux mappeurs

TOPIC some/path a un champ et un sens. Il ne peut pas dire de quel type d’Intent il s’agit, porter un second paramètre, s’imbriquer ou s’étendre ; et un récepteur n’a rien contre quoi valider. Un Intent plus riche demande une structure :

subscribe:
  topic: Demo/ConsoleIn/U/alice/E/text

C’est seulement là qu’une bibliothèque de sérialisation a une tâche claire. JsonTools garde deux mappeurs, et l’asymétrie est voulue :

  • en entrée, une fabrique YAML avec FAIL_ON_UNKNOWN_PROPERTIES désactivé — JSON étant un sous-ensemble de YAML, un Intent tapé à la main est accepté, et un configurateur plus récent peut envoyer des champs qu’un service plus ancien ignore ;
  • l’écriture utilise du JSON strict avec INDENT_OUTPUT activé, donc les charges publiées sont strictes et lisibles.

Tolérant en entrée, strict en sortie. Un mappeur unique devrait renoncer à l’un des deux.

9.5 DUISE, et recâbler un système en marche

Le schéma de nommage reçoit enfin son nom : Description (quels contrats ce service comprend et publie), Unit (quelle instance), Intent (comportement demandé), Status (ce qui est vrai maintenant), Event (ce qui est arrivé).

Demo/ROT13/U/alice/{I, S/online, S/subscriptions/text, E/crypted}

U/<unit> est ce dont le système de fichiers n’avait pas besoin : chaque machine avait sa réplique du même chemin relatif, l’identité d’instance était implicite. MQTT a un espace de noms partagé : un sujet doit donc dire quelle copie. Coder en dur U/alice dans une capacité est donc pire que de coder en dur consoleIn.outbox : cela lie la compilation à un déploiement. Configuré par Intent, une seule compilation sert tout le monde — d’où les trois noms d’unité en arguments de MqttConfigure. Les noms d’unité sont la topologie.

Recâblage observé sur un système en marche : publiez un nouvel Intent nommant une autre source, et le service se désabonne de l’ancienne, s’abonne à la nouvelle et republie S/subscriptions en conséquence. Sans redémarrage, sans édition. Envoyez au contraire un filtre invalide — Demo/#/E/text, où # n’est pas le dernier niveau — et MqttTools.isValidFilter le rejette ; l’ancien abonnement demeure et le Status continue de dire vrai.

Ce rejet révèle une vraie lacune, à nommer plutôt qu’à cacher : il n’est journalisé que localement. Le configurateur ne peut savoir si son Intent a été appliqué ou refusé, et un moniteur ne peut distinguer « refusé » de « pas encore traité ». Dans cette conception, l’émetteur apprend le résultat en lisant le Status et en le comparant à sa demande. Publier les refus comme Event, ou un Status de dernière erreur, combleraient la lacune ; ni l’un ni l’autre n’est dans le matériel : c’est une décision de conception à justifier.

9.6 Ce qu’un nouvel abonné apprend, et ce qu’un mort avoue

S’abonner à Demo/# pendant trois secondes, sans que rien ne soit publié, renvoie ceci :

Demo/ROT13/U/nitro5/S/online              {"value":true}
Demo/ROT13/U/nitro5/S/subscriptions/text  "Demo/ConsoleIn/U/nitro5/E/text"
Demo/ConsoleOut/U/nitro5/S/online         {"value":true}
Demo/ConsoleOut/U/nitro5/S/subscriptions/text  "Demo/ROT13/U/nitro5/E/crypted"

Un arrivant tardif apprend instantanément tout le câblage actuel du système, sans rien demander et sans qu’aucun composant sache qu’un moniteur existe. C’est le Status retenu. Aucun Event n’arrive, car les Events sont publiés non retenus — « State retenu, Events non retenus ». C’est aussi la bonne réponse à l’instinct de demander à un service ce qu’il fait : personne ne demande ; le service le déclare, une fois, et le courtier le garde pour quiconque se présente.

Le Status retenu seul mentirait pourtant. Tuez un service par Ctrl+C et son S/online = true reste sur le courtier à jamais. D’où la dernière volonté, enregistrée au moment de la connexion :

var will = new MqttMessage("{\"value\":false}".getBytes(UTF_8), 1, true, new MqttProperties());
options.setWill(lastWillTopic, will);

Elle est retenue : quand le courtier la publie au nom du client, elle remplace le true périmé. Le composant qui échoue n’est pas celui qui signale l’échec — seul arrangement qui puisse fonctionner. Une réserve : une déconnexion propre ne déclenche pas la dernière volonté ; un service bien élevé publie donc online=false lui-même en partant, la volonté couvrant les morts brutales.

9.7 Ce qui a survécu au transport, et le couplage restant

La moitié inférieure du tableau système de fichiers→MQTT est l’essentiel : I, S, E, les services égoïstes, la topologie à l’exécution et « transformateur si nécessaire » sont inchangés. L’architecture a survécu au remplacement du transport, et c’est la meilleure preuve disponible qu’elle n’a jamais dépendu du transport.

Un couplage faible ne signifie pas que rien ne sait rien. Ce qui reste, nécessairement, est l’accord sur : la syntaxe des messages, leur sémantique, les contrats de sujets, l’Intent, la propriété, le sens du State et celui des Events. Le but n’est pas d’éliminer le couplage mais d’éliminer la connaissance inutile. Concrètement, chaque service ici doit comprendre exactement un contrat d’Event étranger — ROT13 comprend E/text de ConsoleIn, ConsoleOut comprend E/crypted de ROT13 — plus le schéma d’Intent qu’il accepte sur son propre I. Cette liste est le minimum irréductible.

Par ailleurs, le courtier est une dépendance d’infrastructure partagée : tout le monde a besoin de son adresse et rien ne marche sans lui. Réel, mais d’une autre nature que la connaissance d’un composant par un autre.

La liste de l’étape 78 est l’outil à garder. Douze questions, dont ces six portent l’argument de ce système :

question réponse ici
une capacité contient-elle l’identité d’un producteur en dur ? non — elle arrive par Intent
quels contrats étrangers doit-elle comprendre ? un contrat d’Event chacun, plus son propre schéma d’Intent
où la topologie est-elle définie ? dans le configurateur, hors du chemin des données
la topologie peut-elle changer sans recompiler ? oui — démontré sur un système en marche
le transport pourrait-il être remplacé ? oui — démontré : système de fichiers puis MQTT
chaque médiateur fait-il quelque chose qui exige une médiation ? oui, trivialement : TEXT → TEXT n’en exige aucune, et il n’y en a aucun

La prudence du matériel s’applique : les réponses n’ont pas à être toutes « non ». Elles doivent être intentionnelles.

9.8 Le parcours complet

Le programme n’a jamais changé : une ligne entre, la même ressort décalée de 13 lettres. Ce qui a changé, onze fois, c’est la manière dont les parties sont reliées et qui détient la connaissance de ce câblage.

étape comment les parties sont reliées où vit la topologie dans le chemin des données, outre les capacités
1 procédural appels directs dans le code de la capacité —
2 services égoïstes pas reliées du tout nulle part — c’est le problème —
3 médiation statique, une JVM boîtes, copiées par des médiateurs les médiateurs, démarrés dans main() deux médiateurs
4 médiation statique, système de fichiers répertoires, copiés par des processus médiateurs les lignes de commande de l’opérateur deux processus médiateurs
5 médiation statique, Syncthing répertoires répliqués les lignes de commande de l’opérateur deux processus médiateurs, plus le délai de réplication
6 médiateurs nommés et configurables Intent ROUTE d’un orchestrateur l’orchestrateur, hors du chemin les médiateurs, encore
7 dynamique, une JVM les services écoutent, guidés par un Intent TOPIC le configurateur rien
8 dynamique, système de fichiers idem, sur des répertoires le configurateur rien
9 dynamique, Syncthing idem, sur des répertoires répliqués le configurateur rien — seulement des sauts de transport
10 contrats compatibles : direct ; incompatibles : un transformateur le configurateur un transformateur, seulement là où les contrats diffèrent
11 MQTT des sujets sur un courtier le configurateur rien — le courtier est du transport

Lisez la troisième colonne de haut en bas : la topologie s’éloigne, une étape après l’autre, jusqu’à ce qu’aucune capacité n’en détienne plus rien. Lisez la dernière : le prix de ce déplacement tombe à zéro à l’étape 7 et y reste pendant que le transport change trois fois en dessous. Même architecture, meilleur transport.

9.9 Les phrases à retenir

  • « Event-driven » décrit comment circulent l’information et le contrôle.
  • Le couplage faible décrit ce que les participants doivent savoir les uns des autres.
  • Publiez ce qui est arrivé.
  • Déclarez ce que vous voulez.
  • Publiez votre propre état.
  • Gardez les capacités égoïstes.
  • Gardez la topologie hors des capacités.
  • Ne payez pas un médiateur qui ne fait pas réellement de médiation.

Et chaque fois qu’une architecture devient confuse, revenez à la première question de ce livre : qui connaît qui ?