Implémentation d'un MOM open-source

Transcription

1 Implémentation d'un MOM open-source Saber Dir - Victor Laborie - Guillaume Penaud 18 mars

2 Table des matières 1 Introduction et problématiques Objectifs Délai Composition de l'équipe Qu'est ce qu'un MOM État de l'art Historique : JMS Les Protocoles AMQP MQTT STOMP OpenWire Comparatif Protocole sélectionné Les MOMs RabbitMQ HornetQ Apollo QPID Comparatif Les premiers pas sous RabbitMQ Un "Hello World" pas à pas avec un client PHP Introduction Installation RabbitMQ Création du projet Le producer Le consumer Les concepts Gestion des virtual hosts (ci-après nommé vhost) Gestion des utilisateurs Les diérents types d'échanges Répartition de tâches via messages Publication / Distribution Routage Topic Infrastructure utilisée Phase 1 : Le bac à sable Phase 2 : L'infrastructure du POC - Chirement de mail Phase 3 : L'infrastructure du POC - Load-balancing et haute disponibilité Proof Of Concept : Chirement de mail Présentation du besoin Présentation de la solution Comment ça marche mail-input encrypter mail-output Licence ASRALL 2 IUT Charlemagne

3 6.3.4 broker Industrialisation Démonisation Pourquoi la démonisation Mise en place Redondance et clustering Monitoring Test de charge Apollo : Un autre MOM pour d'autres protocoles Introduction Architecture Implémentation Indépendance du protocole Administration par service REST Installation d'apollo Protocoles Envoi de message simple via MQTT Consumer Producer Envoi de message simple via STOMP Consumer Producer Gestion de projet Répartition des rôles Points forts et points faibles de chacun Gestion du temps En conclusion Annexes Liens Spécication Site Ociel Licence ASRALL 3 IUT Charlemagne

4 1 Introduction et problématiques Le projet "MOM open source : Middleware Orientés Messages implémentation et exploitation", a pour objet d'étudier le fonctionnement et l'écosystème des MOM dans un contexte applicatif simplié, tout en répondant à un certain nombre de contraintes simulant un contexte d'utilisation professionnel réel. Nous avons donc, dans notre travail, essayé d'imaginer les domaines "à prévoir" pour répondre à ce besoin, et chaque partie du travail eectué (état de l'art, étude des diérents moyens de communication, droits et accès, etc...) l'a été avec cette arrière-pensée. Ce rapport présente notre compréhension collective du fonctionnement d'un MOM, d'un point de vue à la fois théorique et concret. 1.1 Objectifs Notre projet se décompose en trois parties : Comprendre le rôle et le fonctionnement des MOM. Implémenter un MOM en contexte applicatif simplié (Proof Of Concept), choisi après une étude de marché selon un ensemble de critères fournis par notre tuteur. Créer et gérer un ensemble de routines de production. La solution retenue devra répondre aux critères suivants : Etre open-source Assurer une redondance logicielle (failover via solution de clustering) Haute scalabilité (capacité à supporter des pics de charge importants) Ainsi, même s'il ne s'agit que d'un "Proof Of Concept", l'implémentation que nous fournirons devra être exploitable sur demande et intégrable au sein d'un ensemble applicatif plus grand, ceci dans un délai raisonnable. 1.2 Délai Le projet "MOM open source : Middleware orientés messages implémentation et exploitation" sera réalisé sur un délai de 2 mois. 1.3 Composition de l'équipe Pour ce projet, nous sommes 3 étudiants, tous de la licence ASRALL : Nom : Saber Dir dirsaber2000@yahoo.fr Nom : Victor Laborie victor.laborie@openmailbox.org Nom : Guillaume Penaud guillaume.penaud@gmail.com Licence ASRALL 4 IUT Charlemagne

5 1.4 Qu'est ce qu'un MOM Un MOM (Message Oriented Middleware) est un logiciel qui permet l'échange de messages entres applications présentes sur un réseau informatique de manière asynchrone. C'est à dire qu'une application peut envoyer un message à une autre application sans savoir oû elle se trouve ni même que l'application réceptrice ne soit active. Le message sera reçu par le MOM, et le récepteur viendra chercher ses message sur le MOM lorsqu'il sera actif et vice versa. C'est le même principe que l' , lorsque vous envoyé un à une personne vous l'envoyé en fait à votre serveur mail qui lui le communiquer au serveur mail de votre destinataire. Votre destinataire n'aura plus cas se connecter à son serveur mail pour recupérer votre message. Vous n'êtes pas obligés d'avoir vos machines connecté en même temps. Dans le cas des s, le logiciel que l'on apelle MOM est le serveur de mail, postx par exemple. Licence ASRALL 5 IUT Charlemagne

6 2 État de l'art 2.1 Historique : JMS Pendant longtemps il n'y a eu aucun standard pour les protocoles de messageries. Le standard de facto était JMS, mais JMS est une API et non un protocole, elle dénie une interface pas une façon de communiquer. JMS ne garantie donc pas l'interopérabilité, chaque implémentation pouvant utilisé un protocole diérent. Pour communiquer ensemble, deux applications utilisant JMS devront utilisé une implémentation qui utilise le même protocole, sachant qu'aujourd'hui des implémentations pour AMQP, MQTT, STOMP et OpenWire sont disponibles, ce qui ne fut pas toujours le cas. Le seul apport de JMS étant de pouvoir changer plus facilement de protocole en changeant d'implémentation de l'api. Son plus gros défaut étant sa compatibilité limité au seul langage Java. 2.2 Les Protocoles AMQP Développé par la banque JPMorgan Chase, son objectif est de standardiser les échanges entres serveurs de messages. Il est depuis sa version 1, un standard ISO/IEC et un standard du consortium OASIS. C'est un protocole bas niveau dont les messages sont au format binaires. Il est assez dicile à mettre en place mais peut être utilisé dans de grosses infrastructures, JP Morgan l'utilise pour plus d'un milliard de message par jour. La NASA pour son système de Cloud Computing Nebula et Google pour son GooglePlex MQTT C'est un protocole orienté embarqué, il est désigné spéciquement pour les machines à faible ressources et avec peu de bande passante. Il est pensé pour ce que l'on appelle l'internet des objets. Les messages sont aux formats binaires pour diminuer le débit. C'est un standard du consortium OASIS depuis la version Facebook l'utilise pour l'application Facebook Messenger pour sa faible consommation et sa faible bande passante STOMP C'est un protocole plus haut niveau, similaire à HTTP, les messages sont au formats textes. Il a pour but d'être simple à implémenter coté client. Un client peut communiqué avec un serveur STOMP simplement avec Telnet. Il est simple et léger, il est implémenté dans de nombreux langages et peut même être utilisé à travers des websockets OpenWire C'est un protocole binaire, dont le but est d'être performant au maximum et d'avoir le plus possible de fonctionnalité. Bien qu'au format binaire il est similaire sur les commandes au protocole STOMP. Licence ASRALL 6 IUT Charlemagne

7 2.2.5 Comparatif Formats d'échanges Standards Binaire Texte OASIS ISO/IEC AMQP X X MQTT X X 3 STOMP X OpenWire X AMQP est un standard OASIS et ISO/IEC, de plus il est éprouvé puisque utilisé par de très grosses infrastructures, tels que la banque JP Morgan, la NASA et Google, il est donc à privilégier. MQTT est un standard OASIS et il est conçu pour l'embarqué, il est donc à privilégier quand AMQP ne peut faire l'aaire à cause de contraintes de ressources ou de réseaux. STOMP n'est pas un standard, cependant son format d'échange peut être un avantage pour les clients qui peuvent communiquer directement en mode texte, sans aucune transformation. OpenWire n'est pas un standard, il n'est apparemment utilisé que par des projets de la fondation Apache et très peu de documentation est disponible, il n'est pas à privilégier Protocole sélectionné Pour notre installation, nous avons décidé d'utiliser le protocole AMQP pour plusieurs raison : C'est un standard OASIS et ISO/IEC (Standard) Il est implémenté par la majorité des MOMs (Disponible) Il est utilisé par de nombreuses entreprises (Réputé) Il est utilisé pour de très grosses quantités de messages (Scalable) 1. Version 1.0 (29 octobre 2012) 2. Version 1.0 (1 mai 2014) 3. Version (29 octobre 2014) Licence ASRALL 7 IUT Charlemagne

8 2.3 Les MOMs RabbitMQ RabbitMQ à été développé avec le langage fonctionnel Erlang qui est spécialement conçu pour les applications distribuées ; il implémente le protocole AMQP et ne supporte que lui par défaut. Mais il est extensible, les protocoles MQTT et STOMP sont disponibles via des plugins. RabbitMQ garantie la disponibilité du message de bout en bout, c'est-à-dire à partir de l'envoi par le producer du message jusqu'à la réception par le consumer. En terme de persistence, RabbitMq possède une base de données internes appelée "Mnesia". En relation avec le cluster ng, RabbitQM permet de construire un cluster de type actif/passif, et peut donc pallier ecacement à la panne d'un serveur en assurant la haute-disponibilité des brokers. En conclusion, avec RabbitMQ, on dispose d'une excellente gestion de la persistance, du clustering, et de l'envoi asynchrone. Ainsi qu'un puissant mécanisme d'acknowledgments, qui garantit au producer d'un message sa bonne réception par le consumer auquel il était destiné HornetQ HornetQ, d'abord connu sous le nom de JBoss Messaging 2.0, a été tout d'abord développé par JBoss pour l'intégrer à JBoss Application Server, il en est d'ailleurs le broker par défaut depuis la version 6. Il peut aussi être utilisé indépendamment mais ne comporte pas de console d'administration intégrée (JBoss Application Server est nécessaire). HornetQ, grâce a un ensemble de librairie, est assimilable à un framework de messagerie java. Dans ce MOM la persistence est obtenue grâce au journal, un élément chargé de persister les messages sur un périphérique de stockage externe pour éviter de les perdre en cas de incidents ; à la diérence des autres MOMS mentionés dans ce rapport, HornetQ n'utilise pas de bases de donnés, mais le système de journalisation Java NIO. Bien qu'hornetq semble disposer d'un système de haute disponibilité, il est dicile de le caractériser ainsi à cause de son caractère peu dynamique. En eet, la haute disponibilité sur HornetQ se résume à déclarer un serveur de fallback au serveur actif, an d'assurer un basculement en cas de défaillance. Il n'existe pas ici de mécanismes de répartition de charge. HornetQ supporte les protocoles AMQP et STOMP Apollo Le projet Apollo à démarré comme une expérience pour rendre ActiveMQ plus performant sur des machines multi-processeurs. Dans le but d'être plus rapide, robuste et plus facile à maintenir qu'activemq, une architecture complètement nouvelle à été introduite. Cette architecture est basé sur le langage de programmation Scala, avec le support des systèmes concurrents. Comme ActiveMQ, Apollo est un broker multi-protocole et supporte AMQP, MQTT, STOMP et OpenWire. Licence ASRALL 8 IUT Charlemagne

9 2.3.4 QPID Apache QPID à été crée par un groupe de travail comprenant entre autre JPMorgan Chase, Red Hat et Cisco Systems dans le but d'être 100% compatible avec le protocole AMQP, il est d'ailleurs le seul protocole supporté. Initialement développé en Java, il est maintenant développé en C++, la version Java étant toujours disponible. Le projet QPID maintient un sous-projet dénommé "Proton", dont le but est d'être une implémentation légère du protocole AMQP Comparatif Tout d'abord, il est important de noter que tous les MOMs sélectionnés pour le comparatif sont des JMS providers, car il s'agit d'un standard assurant ainsi qu'ils disposeront des principales fonctionnalités attendues d'un MOM digne de ce nom. La comparaison des solutions se fera donc principalement sur les protocoles supportés, ainsi que sur les languages dans lesquels ils sont conçus ; notre choix se portera sur le MOM connu comme étant le plus didactique, et facilement implémentable. Protocoles AMQP MQTT STOMP OpenWire Langage Licence RabbitMQ X X 1 X 1 Erlang Mozilla HornetQ X X Java Apache 2.0 Apollo X X X X Scala Apache 2.0 QPID X C++ 2 Apache Via plugins 2. Initialement en Java Licence ASRALL 9 IUT Charlemagne

10 3 Les premiers pas sous RabbitMQ 3.1 Un "Hello World" pas à pas avec un client PHP Introduction RabbitMQ est un système permettant aux diérents clients de communiquer très simplement et d'échanger des messages. Il s'appuie sur le protocole AMQP. Ce protocole dénit précisément la façon dont vont communiquer les diérents clients avec RabbitMQ. AMQP n'étant qu'un protocole et non une implémentation, nous avons choisis dans ce rapport de présenter deux exemples que nous avons tester en s'appuyant sur deux bibliothèques : PHP et ruby. Nous allons voir comment une application A envoie des messages vers RabbitMQ, qui va ensuite les transmettre à une autre application B à sa demande. La première chose à faire est donc bien évidemment de commencer par installer RabbitMQ Installation RabbitMQ RabbitMQ-serveur est inclus dans le dépôt Debian à partir de la version 6.0 (Squeeze) et la version 9.04 d'ubuntu. Le site ociels de RabbitMQ conseille d'installer le.deb à partir du site car les versions incluses dans les dépôts debian ou Ubuntu sont souvent assez vieux. Nous avons choisis d'installer a partir des dépôt pour commencer nos test et que plus tard nous installerons le.deb du site ociel et le congurer selon notre cahier de charge. Voila les étapes d'installation : 1. Ajoutez la ligne suivante au chier : deb tests de http :// principale 2. (Optionnel) Pour éviter les avertissements sur les paquets non signés, ajouter la clé publique à votre liste clé de conance comme ceci : wget https :// sudo apt-key ajouter RabbitMQ-signature-clé public.asc 3. apt-get update 4. Installer des paquets Installer des paquets 5. Pour activer RabbitMQ Management Console : sudo rabbitmq-plugins enable rabbitmq management. On peut maintenant accéder aux service web de RabbitMQ en utilisant l'adresse suivante : http ://localhost :15672/. Le nom d'utilisateur et le password sont par défaut guest Création du projet Pour ce projet nous avons repris l'exemple donner dans la documentation du site ociels de RabbitMQ. Il s'agit d'un exemple vraiment très basique avec un producer (application P) qui envoie des messages, et un consumer (application C) pour les traiter. Nous allons écrire deux programmes en PHP en ligne de commande directement et la bibliothèque php-amqplib pour communiquer avec RabbitMQ. un producteur qui envoie un message unique, et un consommateur qui reçoit les messages et les imprime. Dans le schéma ci-dessous (image1), "P" est Licence ASRALL 10 IUT Charlemagne

11 notre producteur et "C" est notre consommateur. La boîte du milieu est une le d'attente qui contient les messages tampons. RabbitMQ utilise le protocole AMQP, nous allons donc utiliser la librairie php-amqplib pour pouvoir communiquer avec lui. Il faut alors : 1. Ajouter un chier composer.json au projet : 1 { 2 "require": 3 { 4 "videlalvaro/php-amqplib": "v2.1.0" 5 } 6 } 2. Installer composer : 1 curl php 3. Exécuter la commande : 1./composer.phar install Le producer Le producer envoyant simplement un message qui va contenir du JSON, contenant le titre de la tâche à eectuer et le temps que celle-ci doit prendre. Une fois l'autoloader de composer chargé : On initialise une connection vers RabbitMQ. On créé un nouveau channel. On déclare ensuite une queue. (pour que le message arrive dans une queue, il faut que celle-ci existe. La méthode queue_declare() permet de créer une queue si elle n'existe pas). Dans cette exemple elle s'appelle hello, et n'est pas durable (si le serveur redémarre, cette queue n'existera plus, ni les messages qu'elle contenait à ce moment là). On créée un message et on le publie. Le paramètre basic_publish() contient le nom de l'exchange à utiliser. RabbitMQ a quelques exchanges précongurés. 1 #!/usr/bin/php5 2 <?php 3 require_once DIR. '/vendor/autoload.php'; 4 use PhpAmqpLib\Connection\AMQPConnection; 5 use PhpAmqpLib\Message\AMQPMessage; 6 #$connection = new AMQPConnection(' ', 5672, 'nathan', 'nathan'); 7 $connection = new AMQPConnection('localhost', 5672, 'guest', 'guest'); 8 $channel = $connection->channel(); 9 $channel->queue_declare('hello', false, false, false, false); Licence ASRALL 11 IUT Charlemagne

12 10 $msg = new AMQPMessage('Hello World!'); 11 $channel->basic_publish($msg, '', 'hello'); 12 echo " [x] Sent 'Hello World!'\n"; 13 $channel->close(); 14 $connection->close(); 15?> Le consumer Ici, il s'agit d'établir une connexion et de déclarer la queue. Une fois ceci fait, le consumer s'abonne à la queue. La méthode basic_consume() est la méthode qui sera exécutée pour chaque message transmis à notre consumer. Ici, elle achera simplement le titre fourni dans le message et attendra un temps déni dans le message. Lorsqu'il n'a aucun message à traiter, le consumer attend jusqu'à ce qu'un message lui parvienne. On peut lancer le consumer an que celui-ci se mette en attente de message. Ensuite, à l'aide d'un autre terminal, on peut exécuter le producer. 1 #!/usr/bin/php5 2 <?php 3 require_once DIR. '/vendor/autoload.php'; 4 use PhpAmqpLib\Connection\AMQPConnection; 5 $connection = new AMQPConnection('localhost', 5672, 'guest', 'guest'); 6 $channel = $connection->channel(); 7 $channel->queue_declare('hello', false, false, false, false); 8 echo ' [*] Waiting for messages. To exit press CTRL+C', "\n"; 9 $callback = function($msg) { 10 echo " [x] Received ", $msg->body, "\n"; 11 }; 12 $channel->basic_consume('hello', '', false, true, false, false, $callback); 13 while(count($channel->callbacks)) { 14 $channel->wait(); 15 } 16 $channel->close(); 17 $connection->close(); 18?> Licence ASRALL 12 IUT Charlemagne

13 4 Les concepts 4.1 Gestion des virtual hosts (ci-après nommé vhost) Les vhosts sont des brokers virtuels, déployables au sein d'un serveur RabbitMQ, qui peuvent héberger un nombre non-limité d'exchanges et de queues, et auxquels des droits utilisateurs peuvent être dénis ; les vhosts permettent à un serveur d'héberger autant de brokers que voulu, et permettent de ce fait des communications en loopback physique. Les vhosts se gèrent en ligne de commande via l'outil rabbitmqctl : 1 #creation 2 rabbitmqctl add_vhost vhost_name 3 #listing 4 rabbitmqctl list_vhosts 5 #suppression 6 rabbitmqctl delete_vhost vhost_name 4.2 Gestion des utilisateurs Les utilisateurs dans rabbitmq sont des entités ayant ou non le droit d'accéder à un broker de message, situé soit localement (sur le même serveur), ou à distance. Il existe 3 droits fondamentaux : congure : droit de supprimer les exchanges et les queues du broker, et d'en déclarer pour certains modes particuliers. read : droit de déclarer des exchange et des queues, de bind / unbind des routing_keys dans les exchanges uniquement, de consommer et de purger des messages. write : droit de publier un message, et de bind / unbind pour les exchange et les queues. Note importante : Les droits utilisateurs s'appliquent toujours à un vhost ; les commandes suivantes ne fonctionneront qu'à la condition que l'argument -p soit non-vide et fasse référence à un vhost existant. 1 #suppression d'un utilisateur 2 rabbitmqctl delete_user guest 3 #ajout d'un utilisateur 4 rabbitmqctl add_user my_user_1 5 #ajout de toutes les permissions sur vhost_name a my_user_1 6 rabbitmqctl set_permissions -p vhost_name my_user_1 ".*" ".*" ".*" 7 #ajout du droit de lecture / ecriture uniquement sur queues et exchanges prexes par " test " 8 rabbitmqctl set_permissions -p vhost_name my_user_2 "" "test.*" "test.*" 4.3 Les diérents types d'échanges Note : Les schémas présentés ci-après proviennent de la documentation ocielle de RabbitMQ : http :// Licence ASRALL 13 IUT Charlemagne

14 4.3.1 Répartition de tâches via messages Le but de cette façon de communiquer est de s'assurer qu'une tâche, dont l'ordre d'exécution a été donné via un message, s'est bien terminée ; de surcroit, en imaginant que la tâche soit lourde (traitement batch, par exemple) cela permet de répartir la charge entre deux consumers. Ainsi, le producer place le message, via un exchange par défaut, dans une queue identiée (nommée). Nos deux consumers vont se connecter à cette même queue, et attendre qu'on leur assigne des tâches. Si une seconde tâche est poussée dans la queue avant que la première ne soit terminée par consumer 1, alors consumer 2 va intervenir et s'en occuper. De plus, si consumer 1 échoue à réaliser la tâche (s'il n'envoit pas d'acknowledgement au producer), alors celui ci va renvoyer le message pour que consumer 2 exécute la tâche à sa place Publication / Distribution Ce mode de distribution ressemble très fortement au concept de broadcast ; le producer place un message dans un exchange de type fanout, an que tous les consumers qui s'y connectent puissent récupérer une instance du message, et ce sans aucun ltrage ni distinction. Une fois le message dans l'exchange de type fanout, les consumers s'y connectent (l'exchange doit donc posséder un nom) ; ils créent alors une queue anonyme et temporaire (existant seulement le temps de consomner le message), qu'ils bindent (attachent) à l'exchange. Ne reste plus alors qu'à consumer les messages Routage Le routage fonctionne à peu de chose près comme la publication. A ceci près que l'on rajoute un argument au message envoyé par le producer ; cet argument peut alors être pris en compte par le consumer pour savoir dans quelle le doit aller le message. Ce mécanisme permet de router, dans une certaine mesure, les messages selon un ou plusieurs paramètres. Licence ASRALL 14 IUT Charlemagne

15 Comme l'indique le schéma, ce type d'exchange se nomme direct, car il matchera exactement les arguments passés. Le consumer, dans ses bindings, doit passer les arguments qui lui permettront de matcher les messages qui l'intéressent Topic Ce dernier mode est le plus exible et le plus puissant de tous. Il permet de router très nement les messages, grâce à un mécanisme de pattern proche des expressions régulières. Les topics s'appuient sur deux symboles : # : signie 0 ou N mots : signie exactement 1 mot Cela signie que pour faster.# faster.orange matchera orange.faster ne matchera pas faster.blue.lynx.africa matchera Et que pour *.green.* green.ape ne matchera pas tiger.black.green.faster ne matchera pas elephant.green.lay matchera Cette façon de faire permet à un consumer d'écouter des messages provenant d'ensembles structurés et hiérarchiques. Comme pour le routage, les consumers bindent un ensemble de routing_keys matchant les topics souhaités. Ainsi, il est possible de congurer les applications réceptrices avec toute la exibilité désirée. Licence ASRALL 15 IUT Charlemagne

16 5 Infrastructure utilisée 5.1 Phase 1 : Le bac à sable L'objectif de cette première infrastructure était de "jouer" avec RabbitMQ, et de nous familiariser avec le fonctionnement des queues et des diérents types d'exchanges. An de faciliter les tests et la manipulation des brokers RabbitMQ, nous avons décidé de simuler une infrastructure physique à 3 noeuds, à l'aide de kvm et libvirt. Chaque noeud (pc) de cette infrastructure héberge un serveur RabbitMQ, et se trouve donc en position de produire comme de consommer des messages. Voici les caractéristiques techniques de l'infrastructure, composée de 3 brokers de messages : Sur l'hôte : kvm 1 :2.1 libvirt Sur les machines virtuelles : rabbimq-server ruby 1 :1.9.3 amq-protocol bunny Pourquoi avoir fait ce choix d'infrastructure? D'une part, il nous fallait tester la possibilité de se connecter à distance aux diérents brokers ; et donc que des consumers situé sur un noeud A puissent accéder à une queue sur un noeud B. D'autre part, le choix de 3 noeuds diérents nous a semblé pertinent pour les raisons suivantes Pouvoir utiliser un producer et deux consumers simultanément (pour les exchanges fanout, direct et topic), tout en s'assurant qu'ils communiquent tous à distance Dispatcher des vhosts RabbitMQ sur de multiples noeuds, et savoir donc gérer la conguration des consumers relative à ce point. Etre en capacité de dénir plusieurs utilisateurs disposant de droits diérents sur les noeuds, dans le but d'également en maîtriser la manipulation et la conguration. 5.2 Phase 2 : L'infrastructure du POC - Chirement de mail Cette infrastructure a été pensée dans le but de répondre aux besoins du POC que nous ont demandés de réaliser monsieur Goulin et monsieur Alluin. Notre préoccupation, à cette étape, a été de créer une infrastructure fonctionnelle ; la scalabilité ou la redondance n'ont pas été des critères importants en phase 2. Réaliser ce POC imposait les contraintes suivantes : Deux serveurs postx Licence ASRALL 16 IUT Charlemagne

17 Une application de chirement Un broker RabbitMQ assurant le transport des données L'application de chirement et le serveur postx devaient se situer sur des VMs diérents, car elles implémentent chacune un consumer amqp destinée à recevoir tout les messages provenant du broker RabbitMQ, puis les injectent dans les applications qui les traitent. Il était bien plus simple, confortable, et compréhensible, de séparer chaque "couche" du POC en l'intégrant à une machine virtuelle dédiée. Voici un schéma décrivant le contenu de chacune de ces machines : Licence ASRALL 17 IUT Charlemagne

18 Voici quelques réponses aux questions que vous vous posez certainement : Question 1 : Pourquoi deux serveurs postx diérents? Un serveur postx remplissant les rôles de mail-input et mail-output n'eut-il pas été susant? Licence ASRALL 18 IUT Charlemagne

19 question 2 : Pourquoi mettre l'application de chirement sur une VM à part? Réponse 1 D'une part, nous avons préférés séparer "physiquement" (quoique virtuellement) les diérentes parties de notre POC ; cela nous apportait une meilleure lisibilité, et la possibilité d'expliquer notre travail plus aisément. En second lieu, il était inconcevable de n'avoir qu'un seul serveur postx, car il est impossible de conditionner l'utilisation du module transport ; ainsi, avec un unique serveur postx, les mails auraient bouclés sans n dans le circuit de notre infrastructure. Réponse 2 Là encore, notre principal objectif a été la clarté. Mais il était également nécessaire de générer le plus de trac amqp possible, car c'est là l'objet de ce projet. Il eut donc été stupide de procéder diéremment. 5.3 Phase 3 : L'infrastructure du POC - Load-balancing et haute disponibilité cf : Voir section "industrialisation" Licence ASRALL 19 IUT Charlemagne

20 6 Proof Of Concept : Chirement de mail 6.1 Présentation du besoin Le besoin lié à la réalisation de ce POC (Proof of Concept) peut être découpé ainsi : Le besoin métier : Réaliser un POC permettant de chirer automatiquement un grand nombre de mails. La contrainte pédagogique : utiliser un MOM comme solution de communication entre les diérents composants, an d'avoir un couplage faible entre la couche application et la couche communication, c'est à dire que les applications devaient être totalement indépendantes de leur moyen de communication. A titre d'exemple, il faut que l'ajout d'une fonctionnalité (une application de traduction, par exemple) ne change rien à la topologie du système de communication inter-applicatif. Les MOMs ont été pensés pour cela, leur utilisation de s'imposait donc comme une évidence dans ce contexte. La contrainte de scalabilité l'application devait présenter une scalabilité certaine, ainsi qu'une tenue de charge importante, et se devait donc d'être compatible avec des solutions de clustering et de loadbalancing telles qu'haproxy et pacemaker. La plupart des MOMs répondent à ces contraintes, et possèdent une architecture pensées dans ce sens. 6.2 Présentation de la solution Basée sur l'infrastructure décrite dans le chapitre précédent, elle nous a permis d'avoir une répartition des rôles claire. voici le POC sous la forme d'un schéma : Licence ASRALL 20 IUT Charlemagne

21 Licence ASRALL 21 IUT Charlemagne

22 La solution retenue a été : trois applications en interaction, dialoguant ensemble à travers un broker RabbitMQ. mail-input, qui s'occupe de détourner l'envoi des mails, de formatter ses données (et ses métadonnées) sous une forme exploitable par le protocole amqp. L'application encrypter, ensuite, chargée de recevoir le message amqp, de l'ouvrir, d'en chirer le contenu, puis de le renvoyer vers la dernière application mail-output, chargée pour sa part de naliser l'envoi du mail. Voici un résumé des technologies utilisées : Comme language de script, nous avons choisi bash, et ce pour plusieurs raisons : C'est un language standard, ne nécessitant aucune installation supplémentaire. Il permet de gérer facilement les processus, les status, et l'appel de commandes système. Le language était connu et maîtrisé par nos tuteurs. C'est l'outil le plus répandu chez les administrateurs système à l'heure actuelle. Le MOM que nous avons choisi est bien entendu RabbitMQ, car de tout ceux que nous avons étudiés, c'est lui le plus simple, le plus facile à utiliser et à installer ; sa documentation extrêmement claire et complète nous a beaucoup facilitée le travail ; il répondait de surcroît à toutes les contraintes qui nous avaient été données. Le client AMQP qui a été sélectionné est : amqp-tools. il s'agit d'un ensemble de binaire, exécutable en ligne de commande, packagé au sein de Debian, permettant l'envoi et la réception de message amqp à destination de brokers tels que RabbitMQ ; à noter : il permet de lire le corps des messages amqp, mais pas leurs entêtes, ce qui nous a causés des ennuis lors de la phase load-balancing. Pour pallier à ce manque nous avons du utiliser ruby et sa bibliothèque amqp Bunny. Pour gérer l'envoi de mail, nous avons choisi le serveur de mail postx, en grande partie pour sa exibilité et sa gestion du transport, qui était un composant indispensable de notre application de chirement. C'est enn le caractère standard de ce serveur qui a fait pencher la balance dénitivement en sa faveur. 6.3 Comment ça marche Expliquer la partie postx & transport En résumé : Ce script reçoit un mail provenant du module transport de postx (conguré dans cet objectif) ; il nettoie le mail reçu de son contenu superu (les headers smtp, notamment), puis construit un message amqp exploitable par amqp-tools et RabbitMQ ; enn, il envoit le message sur l'exchange direct, bindé sur la routing-queue "to_send". Voici la partie du script traitant de ces actions, et les commentaires en détaillant chaque étape : En détail : 1 #************************************************************************** 2 #@ Etape 1: Récupération de l' entrée standard Licence ASRALL 22 IUT Charlemagne

23 3 #************************************************************************** 4 5 # Récupère les arguments passés dans master.cf 6 sender=$(echo $1 tr -d "'" ) 7 recipient=$(echo $2 tr -d "'") 8 9 # Génère un chier temporaire contenant le contenu du mail 10 # an de travailler dessus confortablement 11 mail_tmp=$(mktemp) 12 write_log INF "Create a temporary mail file: $mail_tmp" # Redirection de l ' entrée standard ( ici, un pipe postx ) 15 # vers le chier temporaire 16 write_log INF "Wait for STDIN filled by postfix transport" 17 cat - > $mail_tmp #************************************************************************** 20 #@ Etape 2: Traitement du contenu du mail 21 #************************************************************************** # Récupère 24 write_log INF "Parse mail to retrieve the subject" 25 subject=$(egrep "Subject:" $mail_tmp cut -d ' ' -f2-) # Supprime du contenu du mail tout ce qui se trouve après 29 # la première ligne vide 30 # elf : empty line found 31 write_log INF "Trunk mail headers" 32 mail_content=$(awk < $mail_tmp 'elf;!nf{elf=1}') # Teste que le mail possède un contenu, sinon, inutile de crypter du vide 35 [ -z $mail_content ] && write_log ERR "Missing mail content" && exit # Formate le message de façon à ce que sender recipient et content 38 # soient sur des lignes diérentes ( facilités de parsing futurs ) 39 message=`cat << EOF 40 $sender 41 $recipient 42 $subject 43 $mail_content 44 EOF` #************************************************************************** 47 #@ Etape 3: Envoi du mail modié en tant que message amqp 48 #************************************************************************** # Envoit le message en exchange direct avec la clef de routage 51 # "to_encrypt" de façon à le diriger vers l ' application "process" 52 # à travers le serveur "broker1.rmq" 53 write_log INF "Send message through RabbitMQ - routing-key: to_encrypt" 54 amqp-publish \ 55 --server loadbalancer.rmq:5672 \ 56 --vhost "/" \ 57 --username ub1v1 \ 58 --password aze \ Licence ASRALL 23 IUT Charlemagne

24 59 --exchange amq.direct \ 60 --routing-key to_encrypt \ 61 --body "$message" # Plus besoin du chier temporaire, donc on supprime 64 write_log INF "Remove the temporary mail file" 65 rm $mail_tmp La réalisation de ce script a posée quelques dicultés, notamment lorsque nous avons du choisir un format pour le message amqp. Comment nettoyer le mail pipé par postx? Par quelle méthode découper la chaine de caractère de façon à la splitter au sein de diérentes variables? Et surtout, comment faire, une fois le message amqp transmis sur une autre machine (et donc un autre shell bash) pour retrouver exactement le même format et la même indentation? De façon à ce que le destinataire reçoive le même mail que celui d'origine, évidemment. Awk proposait une solution très puissante pour le nettoyage du mail ; et la syntaxe HEREDOC nous a permis de conserver parfaitement l'indentation, la "forme" du mail encrypter En résumé : Pour encrypter_mom_mailencrypter, le fonctionnement est le suivant : il reçoit le contenu du message amqp provenant de mail-input.rmq sur son entrée standard ; il extrait du message les informations suivantes dans des variables bien distinctes : sender (expéditeur) recipient (destinataire) subject (sujet) content (contenu du message) Suite à cela, il essaie de chirer le mail avec la clef publique du destinataire ; si celle ci n'existe pas, il envoie une erreur sous la forme d'un message amqp à mail-input, qui alerte l'expéditeur de l'echéc de l'opération. Sinon, le message amqp d'origine est reconstruit, avec le contenu chiré cette fois ; puis est envoyé vers mail-output. En détail : 1 #************************************************************************** 2 #@ Etape 1 : Lit et éclate le message en 3 parties distinctes 3 #************************************************************************** 4 5 write_log INF "Get broker message from standard input" 6 # Place le contenu de l ' entrée standard dans la variable $message 7 message=$(cat -) 8 9 write_log INF "Explode message content" 10 # Aecte les lignes 1 et 2 dans les variables $sender et $recipient 11 # et de la 3ème à la dernière dans $content 12 sender=$(sed -n 1p <<< "$message") Licence ASRALL 24 IUT Charlemagne

25 13 recipient=$(sed -n 2p <<< "$message") 14 subject=$(sed -n 3p <<< "$message") 15 content=$(sed -n '4,$p' <<< "$message") #********************************************************************************* 18 Etape 2 : Chire le mail envoit un message amqp à mail input en cas d'erreur 19 #********************************************************************************* # Chire le contenu du mail 22 write_log INF "Encrypt mail content" 23 encrypted_content=$("${gpg}" --batch --armor --yes --trust-model always --keyring " $PATH_PUBKEY" --recipient "$recipient" --encrypt <<< "$content" 2>&1) if [ $? -eq $ERROR_PUBKEY_NOT_FOUND_STATUS ]; then # Renvoit un message d'erreur à l'envoyeur 28 amqp-publish \ 29 --server broker1.rmq:5672 \ 30 --vhost "/" \ 31 --username ub1v1 \ 32 --password aze \ 33 --exchange amq.direct \ 34 --routing-key status_unable_to_encrypt \ 35 --body "$(printf "$ERROR_PUBKEY_NOT_FOUND_MESSAGE", "$recipient")" # le script s' arrête avec un code ne renvoyant pas d'acknowledgements 38 write_log ERR "Public key not found - encryption failed - message sent with routing-key: status_unable_to_encrypt" 39 exit 4; 40 fi # Concatène les éléments du message: 43 # expéditeur et destinataires en clair contenu chiré 44 encrypted_message=`cat << EOF 45 $sender 46 $recipient 47 $subject 48 $encrypted_content 49 EOF` #************************************************************************** 52 #@ Etape 3 : Envoit le message crypté à mail output 53 #************************************************************************** write_log INF "Send encrypted message with routing-key: to_send" 56 # Envoit le message vers l ' application postprocess pour 57 # le passer à sendmail et terminer le circuit 58 amqp-publish \ 59 --server broker1.rmq:5672 \ 60 --vhost "/" \ 61 --username ub1v1 \ 62 --password aze \ 63 --exchange amq.direct \ 64 --routing-key to_send \ 65 --body "$encrypted_message" Licence ASRALL 25 IUT Charlemagne

26 A ce stade, la diculté a été de récupérer les données convenablement ; sed n'a pas été notre premier choix. Nous avons tentés beaucoup d'autres solutions, avec awk et bash, avant d'y penser. Nous avons eu un cas intéressant, qui nous a servi de leçon et nous a démontré l'intérêt du travail en équipe. Guillaume, qui travaillait sur ce script à ce moment là, était parti dans l'idée qu'il devait extraire les données du message amqp, à la façon de php (fonction array_pop, ou instruction "list") ; il a cherché à travailler sur les données elles-même, sans se rendre compte qu'il n'avait qu'à les acher avec un outil comme grep et sed, puis aecter la sortie standard à une variable bash, et de ce fait récupérer leur valeur comme il convenait. Cette erreur a été résolue par Saber, qui lui a simplement fait remarquer qu'il s'embêtait pour rien. Et cinq minutes plus tard, tout marchait parfaitement. Cet épisode nous a montré le danger d'avoir excessivement "la tête dans le guidon", et l'intérêt que chacun corrige ou soutienne le travail de l'autre ; car ilsera évidemment bien plus frais sur le problème à résoudre, avec un regard neuf et le recul indispensable mail-output En résumé : Le script mailoutput_mom_mailforwarder reçoit, via l'entrée standard, le message amqp en provenance de encrypter ; il en extrait les données, puis envoie un mail au destinataire dont l'adresse se trouve à l'intérieur du message. En détail : 1 #************************************************************************** 2 #@ Etape 1: Extraction du contenu et des méta données du mail à forwarder 3 #************************************************************************** 4 5 write_log INF "Get broker message from standard input (STDIN)" 6 message=$(cat -) 7 8 write_log INF "Extract message data and meta-data: sender, recipient, subject and content" 9 # Aecte les lignes 1 et 2 dans les variables $sender et $recipient 10 # et de la 3ème à la dernière dans $content 11 sender=$(sed -n 1p <<< "$message") 12 recipient=$(sed -n 2p <<< "$message") 13 subject=$(sed -n 3p <<< "$message") 14 content=$(sed -n '4,$p' <<< "$message") #************************************************************************** 17 #@ Etape 2: Forwarding du mail via postx et sendmail 18 #************************************************************************** write_log INF "Sent formatted " echo "$content" mail -s "$subject" "$recipient" -afrom:"$sender" Nous n'avons pas rencontré de dicultés particulières sur ce script ; il reprend dans les grandes lignes la structure des scripts précédents. En revanche, il nous a fallu congurer postx de façon à ce qu'il Licence ASRALL 26 IUT Charlemagne

27 utilise le compte gmail de guillaume pour envoyer les mails chirés broker1 Le broker a simplement été conguré pour disposer d'un utilisateur nommé "ub1v1". Licence ASRALL 27 IUT Charlemagne

28 7 Industrialisation 7.1 Démonisation Pourquoi la démonisation Il est nécessaire de transformer nos scripts sur les diérents serveurs en démons, surtout pour les serveurs comme encrypter.rmq et mail_output.rmq où nous n'avons pas apriori d'intéractivité. Donc tous les scripts consumers accedant au broker sont démonisés. Nous avons creé un script générateur de démonistation "create-deamon.sh" an de démoniser tous les scripts dont nous avions besoin. Ce script prend comme argument le nom du script à demoniser./create-deamon.sh <nom du script> Mise en place Il a d'abord fallu créer un script bash qui sert de skelette de démonisation dans notre projet, nous l'avons appelé deamon_structure.sh. Ensuite, nous avons travaillé comme ceci : 1. Copier le script à démoniser dans /usr/bin cp /home/rabbit/script_name /usr/bin/script_name.sh 2. Copiez le structure_deamon.sh dans /etc/init.d/ avec le même nom du script à démoniser. cp /home/rabbit/daemon_structure.sh /etc/init.d/script_name.sh Avec cette commande nous avons généré une copie du script structure_deamon.sh appelée script_name.sh 3. Editer ce script, les premières lignes contiennent le chemin, le nom, l'utilisateur et une description du script à démoniser. DAEMON="/home/rabbit/SCRIPT_BASENAME" DAEMON_OPT="" DAEMON_USER="rabbit" DAEMON_NAME="SCRIPT_BASENAME" Pour le reste du script nous avons utilisé start-stop-daemon qui permet de transformer n'importe quel programme en démon.voila quelques notions principales : --start pour démarrer le script ; --quiet pour rendre le script silencieux (CQFD) ; --background pour mettre le script en arrière-plan (CQFD) ; --make-pidfile pour faire un fichier de processus (pour pouvoir forcer l'arrêt plus tard) ; --pidfile $PIDFILE pour localiser le pidfile créé ci-dessus ; --exec $DAEMON pour lancer le programme ; Licence ASRALL 28 IUT Charlemagne

29 4. rendre le script exécutable chmod +x /etc/init.d/script_name.sh 5. Ajoute le service au démarrage de l'ordinateur update-rc.d script_name.sh defaults defaults : l-option par défaut c-à-d placement en bout de le d'attente, pour éviter les conits. Notre démon accepte maintenant un ensemble d'options que l'on peut passer directement au script de la ligne de commande, par exemple : start: démarre un service stop: arrète un service restart: redémarre un service sans recharger son fichier de configuration reload: envoie un signal SIGHUP à un processus en cours d'exécution status: renvoie l'état d'un service 7.2 Redondance et clustering 7.3 Monitoring 7.4 Test de charge Licence ASRALL 29 IUT Charlemagne

30 8 Apollo : Un autre MOM pour d'autres protocoles 8.1 Introduction ActiveMQ Apollo est un broker conçu à partir des fondements d'activemq dans le but d'être plus rapide, plus able et plus facile à maintenir que celui-ci. Il accomplit cela en utilisant une architecture de répartition des messages et des processus complémentement diérente de son ainée. Comme son ainée, Apollo supporte les protocoles AMQP, MQTT, STOMP et OpenWire. 8.2 Architecture Implémentation Apollo est basé sur le patron de conception Reactor qui consiste à permettre le traitement d'évenement dans un environnement oû les évenements peuvent provenir de sources diverse. Ce nouveau modèle de gestion permet à Apollo d'atteindre des niveaux très elevé d'évolutivité et d'écacité mais contraint les tâches à être non bloquantes. Cela requiert des changements majeurs pour le traitement des entrées/sorties réseaux, le design du contrôle de ux et les chemins des interfaces de magasins. Scala fournissant une manière beaucoup plus conçise d'exprimer les fonctions de rappels, il à été décidé qu'il serait utilisé en remplacement de Java Indépendance du protocole ActiveMQ supporte plusieurs protocoles depuis plusieurs années mais sous le capot tout les protocoles ont convertis pour utiliser le protocole OpenWire. Cette approche n'est pas optimale car elle induit : Un surcout de charge dû à la conversion des protocoles Une dépendance à la compatiblité avec OpenWire du protocole sus-jacent Apollo est beaucoup plus modulaire et indépendant de tout protocole. Tous les protocoles sont égaux et construit sous forme de plugin pour le broker Administration par service REST ActiveMQ expose son interface d'aministration via JMX : Supporte seulement le langage Java N'est pas extensible pour de nombreux objets (peut créer un goulet d'étranglement) Les types de données riches sont dicile à éxposer Apollo expose un état riche et détaillé du serveur à l'aide d'un service REST basé sur le format JSON. Deux avantages en découlent : Un client d'administration peut être facilement implémenté dans n'importe lequel langage Il n'y a que très peu de surcoût de ressource dû à l'administration Licence ASRALL 30 IUT Charlemagne

31 8.3 Installation d'apollo Apollo est disponible sous forme de binaire sur le site ociel, à cette adresse : Pour nos test, nous avons installé la version 1.7.1, la dernière version ocelle à ce jour 1 # Installation Apollo 2 cd /opt 3 wget /apache-apollo unix-distro.tar.gz 5 tar -zxvf apache-apollo unix-distro.tar.gz 6 rm apache-apollo unix-distro.tar.gz 7 ln -s apache-apollo apollo 8 #Creation du broker 9 cd /var/lib 10 /opt/apollo/bin/apollo create mybroker 11 #Creation du service 12 ln -s "/var/lib/mybroker/bin/apollo-broker-service" /etc/init.d/apollo 13 update-rc.d apollo defaults 14 service apollo start 8.4 Protocoles Nous avons exclusivement utilisé le protocole AMQP pour notre infrastructure avec RabbitMQ, AMQP étant le seul protocole qu'il supporte. Cependant comme nous l'avons vus dans la partie traitant des protocoles, AMQP bien qu'étant adapté à la majorité des cas d'utilisation, ne l'est pas en cas de contraintes de ressources ou de simplicité d'implémentations. C'est pourquoi nous allons voir dans cette partie, l'implémentation de l'envoi d'un message simple via les protocoles MQTT et STOMP, ayant l'avantages respectif d'être très peu gourmand en ressources pour le premier et très facile à implémenter pour le second. Dans la section sur RabbitMQ, on a vu diérents types d'échanges : queue, pub/sub, routage, topic et rpc. Ces diérents types d'échanges sont spécique à AMQP. Licence ASRALL 31 IUT Charlemagne

32 8.5 Envoi de message simple via MQTT Le protocole MQTT est conçu pour être très léger et ne supporte que les message de type topic. Notre implémentation utilise le langage Ruby et la librairie gem mqtt Consumer Après avoir inclu les librairies gem et mqtt, le client se connecte au broker déni grâce aux paramètres passés en options de la méthod connect puis va écouter les messages provenant du topic "Time" à l'aide de la méthode get. Puis quand il va recevoir un message il va simplement l'acher sur la sortie standard. 1 #!/usr/bin/ruby 2 require 'rubygems' 3 require 'mqtt' 4 MQTT::Client.connect( 5 :host => 'localhost', 6 :port => 61613, 7 :username => 'admin', 8 :password => 'password', 9 ) do client 10 client.get("time") do topic, message 11 puts "#{topic} => #{message}\n" 12 end 13 end Producer Après avoir inclu les librairies et s'être connecté au broker de la même façon que le consumer, le client envoie un message dans le topic "Time" contenant la date et le temps courant à l'aide de la méthode publish. 1 #!/usr/bin/ruby 2 require 'rubygems' 3 require 'mqtt' 4 MQTT::Client.connect( 5 :host => 'localhost', 6 :port => 61613, 7 :username => 'admin', 8 :password => 'password', 9 ) do client 10 client.publish("time","the time is: #{Time.now}") 11 end Licence ASRALL 32 IUT Charlemagne