Implémentation d'un MOM open-source

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

Table des matières 1 Introduction et problématiques 3 1.1 Objectifs............................................. 3 1.2 Contexte............................................. 3 1.2.1 Composition de l'équipe................................ 3 1.2.2 Délai........................................... 4 1.2.3 Répartitions des rôles................................. 4 1.2.4 Planning réalisé..................................... 5 1.2.5 Remerciements..................................... 5 1.3 Qu'est ce qu'un MOM..................................... 6 2 État de l'art 7 2.1 Historique : JMS........................................ 7 2.2 Les Protocoles......................................... 7 2.2.1 AMQP......................................... 7 2.2.2 MQTT......................................... 7 2.2.3 STOMP......................................... 7 2.2.4 OpenWire........................................ 8 2.2.5 Comparatif....................................... 8 2.2.6 Protocole sélectionné.................................. 8 2.3 Les MOMs........................................... 9 2.3.1 RabbitMQ....................................... 9 2.3.2 HornetQ......................................... 9 2.3.3 Apollo.......................................... 9 2.3.4 QPID.......................................... 10 2.3.5 Comparatif....................................... 10 3 Les premiers pas sous RabbitMQ 11 3.1 Les premiers pas avec RabbitMQ via un client PHP.................... 11 3.1.1 Introduction...................................... 11 3.1.2 Installation du broker RabbitMQ........................... 11 3.1.3 Implémentation du Hello World............................ 12 3.1.4 Le producer....................................... 12 3.1.5 Le consumer...................................... 13 4 Les concepts 14 4.1 Gestion des virtual hosts (ci-après nommé vhost)...................... 14 4.2 Gestion des utilisateurs.................................... 14 4.3 Les types d'exchange...................................... 14 4.3.1 Default......................................... 15 4.3.2 Fanout.......................................... 15 4.3.3 Direct.......................................... 16 4.3.4 Topic.......................................... 16 4.3.5 Headers......................................... 17 5 Infrastructure utilisée 18 5.1 Phase 1 : Le bac à sable.................................... 18 5.2 Phase 2 : L'infrastructure de la maquette - Chirement de mail.............. 19 5.3 Phase 3 : L'infrastructure de la maquette - Load-balancing et haute disponibilité.... 21 6 Envoi et chirement de mail 21 6.1 Présentation du besoin..................................... 21 Licence ASRALL 2 IUT Charlemagne

6.2 Présentation de la solution................................... 22 6.3 Le fonctionnement....................................... 23 6.3.1 mail-input........................................ 23 6.3.2 encrypter........................................ 25 6.3.3 mail-output....................................... 26 6.3.4 broker1......................................... 27 6.3.5 récepteur du mail.................................... 27 7 Industrialisation 28 7.1 Transformation des consumers en services Linux (daemon)................. 28 7.1.1 Pourquoi........................................ 28 7.1.2 Mise en place...................................... 28 7.2 Redondance et clustering................................... 31 7.2.1 Objectifs........................................ 31 7.2.2 Mise en place du cluster................................ 32 7.2.3 Mise en place du load-balancing........................... 34 7.2.4 Changement au sein de nos applications....................... 35 7.2.5 Conclusion sur le clustering et le loadbalancing................... 35 8 Apollo : Un autre MOM pour d'autres protocoles 36 8.1 Introduction........................................... 36 8.2 Architecture........................................... 36 8.2.1 Implémentation..................................... 36 8.2.2 Indépendance du protocole.............................. 36 8.2.3 Administration par service REST........................... 37 8.3 Installation d'apollo...................................... 37 8.4 Protocoles............................................ 37 8.5 Envoi de message simple via MQTT............................. 38 8.5.1 MQTT - Consumer................................... 38 8.5.2 MQTT - Producer................................... 38 8.6 Envoi de message simple via STOMP............................. 39 8.6.1 STOMP - Consumer.................................. 39 8.6.2 STOMP - Producer.................................. 39 9 En conclusion 40 9.1 Acquis Techniques....................................... 40 9.2 Atouts en milieux professionnels............................... 41 9.3 L'équipe............................................. 41 9.4 Gestion du temps........................................ 42 9.5 Le mot de la n......................................... 42 10 Annexes 43 Licence ASRALL 3 IUT Charlemagne

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 professionnelle réel. Nous avons donc, dans notre travail, essayés d'imaginer les besoins à anticiper, 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é (maquette), 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 devait répondre aux critères suivants : Être open-source Assurer une redondance logicielle (assurer du failover via une solution de clustering) Haute scalabilité (capacité à supporter des pics de charge importants) Ainsi, même s'il ne s'agit que d'une maquette, l'implémentation que nous avons fournie devait être exploitable sur demande et intégrable au sein d'un ensemble applicatif plus grand, ceci dans un délai raisonnable. 1.2 Contexte 1.2.1 Composition de l'équipe Pour ce projet, nous sommes 4 étudiants en licence professionnelle ASRALL : Nom : Saber Dir Email : dirsaber2000@yahoo.fr Nom : Victor Laborie Email : victor.laborie@openmailbox.org Nom : Guillaume Penaud Email : guillaume.penaud@gmail.com Nom : Israël Olguin Suarez Email : ramnusiak23@gmail.com Licence ASRALL 4 IUT Charlemagne

1.2.2 Délai Le projet "MOM open source : Middleware orientés messages implémentation et exploitation" a été réalisé sur un délai de 2 mois. Pour organiser notre travail nous avons réalisés ce retroplanning : 1.2.3 Répartitions des rôles Il a été décidé au cours de la première réunion entre membres de l'équipe, que Guillaume endosserait le rôle de "chef de projet". Voici donc les devoirs qui lui ont incombés dans ce domaine : S'assurer que la charge de travail était équitablement répartie entre les membres de l'équipe. S'occuper de la communication avec les tuteurs. Motiver les troupes si besoin. S'agissant de la rédaction des compte-rendus hebdomadaire collectifs, Guillaume en a écrit une grosse partie. Principalement parce qu'il aime bien écrire, que ça ne lui posait pas de soucis particulier et que ça lui demandait peu d'eorts. Pour le travail sur le projet en lui-même, des rôles (parlons même de spécialisation) sont apparus assez spontanément, en suivant les intérêts de chacun. Voici ce que nous avons pu constater : Saber s'est senti à l'aise dans la découverte des concepts et de techniques, concernant les MOM et les outils "annexes" que nous avons du utiliser (utilisation de gpg, transformation des scripts en services). Il a donc surtout travaillé en environnement "bac à sable" (environnement dédié et nu) ; son travail a permis à Guillaume d'implémenter la maquette en condition de production (la phase d'implémentation de la fonctionnalité "défrichée" était d'ailleurs réalisée en binôme). Comme dit précédemment, Guillaume a principalement travaillé sur la maquette elle-même, son implémentation en environnement de production ; aimant beaucoup scripter et disposant de compétences en développement certaines, il a écrit et réalisé une grosse partie de l'applicatif, ainsi que la construction et la gestion de l'infrastructure virtualisée. Licence ASRALL 5 IUT Charlemagne

Victor, quand à lui, s'est consacré à la recherche théorique et à l'implémentation des protocoles et des MOMs "secondaires" (appolo, etc...), tout en contribuant fortement au scripting de l'application, conjointement à Guillaume. Néanmoins, nous avons tous participés à l'élaboration de l'ensemble du projet, nous concertant très souvent et travaillant main dans la main, an que chacun ait une vision globale et complète. Concernant Israël, il s'est rapidement désengagé et n'a que très partiellement participé sur la partie théorique en début de projet ; il a par ailleurs été débarqué du projet par l'équipe pédagogique suite à plusieurs semaines d'absences an de ne pas pénaliser les autres membres de l'équipe. 1.2.4 Planning réalisé Le planning réalisé montre des diérences avec le rétro-planning, principalement due à la défection d'israël, mais aussi à des dicultés que nous avons rencontrés lors de la réalisation de la maquette. 1.2.5 Remerciements Nous souhaitons chaleureusement remercier les personnes suivantes : Antoine Alluin et Mathieu Goulin, nos tuteurs, qui nous ont énormément guidés, soutenus, et encouragés tout au long de la réalisation ce projet. Merci à eux pour s'être autant impliqués, pour s'être déplacés à l'iut an de participer aux réunions, et surtout, pour le travail que ça leur a demandé. Monsieur Yohan Parent, qui nous a donné un sacré coup de pouce dans des moments diciles. A toute l'équipe pédagogique de la licence ASRALL, pour nous avoir donné les outils technique nécessaires à la réalisation de ce projet. A tous ceux qui prendront le temps de lire et d'évaluer ce rapport. Licence ASRALL 6 IUT Charlemagne

1.3 Qu'est ce qu'un MOM Un MOM (Message Oriented Middleware) est un logiciel qui permet l'échange asynchrone de messages entres des applications hétérogènes (n'implémentant pas par défaut de moyen de communication entre elles) présentes sur un réseau informatique. L'ensemble des serveurs MOM, rassemblés au sein d'un cluster est appelé un broker (courtier de messages) ; dans ce contexte, un serveur MOM est alors appelé un noeud. Pour simplier, dans la suite de ce rapport, nous appelerons également un serveur MOM un broker (en considérant qu'il s'agit d'un cluster à 1 noeud). Lorsqu'une application veut envoyer un message à une autre application, elle l'envoit dans une le d'attente, située dans un exchange (un élément qui dénit la façon dont le message sera diusé), sur le broker concerné. Les applications destinatrices n'ont plus qu'à se connecter au broker et à récupérer le message sur la le d'attente. Le fonctionnement d'un MOM n'est pas sans rappeler celui d'un serveur de mail. En eet, lorsque vous envoyez un mail à une personne, vous l'envoyez en réalité à un "broker" (nommé diérement dans ce contexte, bien sûr), constitué de l'ensemble des serveurs mails nécessaire à son routage à travers internet. Votre destinataire n'aura plus qu'à se connecter au "broker de mail" pour récupérer votre message. Vous n'êtes pas obligés d'avoir vos machines connectées en même temps, d'ou la notion d'asynchronicité, principal atout des MOM. En revanche, et contrairement aux serveurs mails, les MOMs sont faits pour envoyer des messages très volumineux et conçus pour être rapide. Ils sont aussi spécialisés dans la communication interapplication, tandis que les mails sont prévus pour les échanges inter-humains, à travers le réseau. Licence ASRALL 7 IUT Charlemagne

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énit une interface, pas une façon de communiquer. JMS ne garantie donc pas d'interopérabilité, chaque implémentation de l'api pouvant utiliser un protocole diérent. Pour communiquer ensemble, deux applications utilisant JMS devront utiliser une implémentation qui utilise le même protocole, tandis 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 est de pouvoir changer plus facilement de protocole en changeant d'implémentation de l'api. Son défaut majeur est sa compatibilité, qui se limite au seul langage Java. 2.2 Les Protocoles 2.2.1 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 binaire. Il est assez dicile à mettre en place, mais peut être utilisé dans de grosses infrastructures. JP Morgan l'utilise pour envoyer plus d'un milliard de messages par jour, la NASA pour son système de Cloud Computing "Nebula" et Google pour GooglePlex. 2.2.2 MQTT C'est un protocole orienté "embarqué", il est désigné spéciquement pour les machines à faible ressources, disposant de peu de bande passante. Il est pensé pour ce que l'on appelle "l'internet des objets". Les messages sont aux formats binaire pour diminuer le débit. C'est un standard du consortium OASIS depuis la version 3.1.1. Facebook, notamment, l'utilise pour l'application Facebook Messenger pour sa faible consommation et sa faible bande passante. 2.2.3 STOMP C'est un protocole plus haut niveau, similaire à HTTP, les messages sont au formats texte. Il a pour but d'être simple à implémenter coté client ; un client peut communiquer avec un serveur STOMP simplement avec Telnet. Il est simple, léger, est implémenté dans de nombreux langages et peut même être utilisé à travers des websockets. Licence ASRALL 8 IUT Charlemagne

2.2.4 OpenWire C'est un protocole binaire, dont le but est d'être performant au maximum et d'avoir le plus de fonctionnalités possible. Bien qu'au format binaire il est similaire sur les commandes au protocole STOMP. 2.2.5 Comparatif Formats d'échanges Standards Binaire Texte OASIS ISO/IEC AMQP X X 1 19464 2 MQTT X X 3 STOMP X OpenWire X AMQP est un standard OASIS et ISO/IEC. Il est robuste, mature et éprouvé puisqu'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 est conçu pour l'embarqué. Il est donc à privilégier quand AMQP ne peut faire l'aaire en raison de contraintes de ressources ou de réseau. STOMP n'est pas un standard, cependant son format d'échange peut être un avantage pour les clients qui veulent 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 dans notre situation. 2.2.6 Protocole sélectionné Pour notre projet, nous avons décidés 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 3.1.1 (29 octobre 2014) Licence ASRALL 9 IUT Charlemagne

2.3 Les MOMs 2.3.1 RabbitMQ RabbitMQ à été développé avec le langage fonctionnel Erlang, 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 persistance, RabbitMQ possède une base de données interne appelée "Mnesia". RabbitMQ permet de construire un cluster de type actif/passif, et peut donc pallier ecacement à la panne d'un serveur en assurant la haute-disponibilité du broker. 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é. 2.3.2 HornetQ HornetQ, d'abord connu sous le nom de JBoss Messaging 2.0, a été développé par JBoss dans l'optique de 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 librairies, est assimilable à un framework de messagerie java. Dans ce MOM la persistance 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 d'incident ; à la diérence des autres MOM mentionnés dans ce rapport, HornetQ n'utilise pas de bases de données, mais le système de journalisation Java NIO. HotnetQ implémente une solution de haute-disponibilité. Il permet de déclarer un serveur de fallback au serveur actif, an d'assurer un basculement en cas de défaillance. En revanche, il n'implémente pas de mécanismes de répartition de charge. HornetQ supporte les protocoles AMQP et STOMP. 2.3.3 Apollo Le projet Apollo à démarré comme une expérience pour rendre ActiveMQ plus performant sur des machines multi-processeur. An de le rendre plus rapide, plus robuste et plus facile à maintenir, une architecture complètement nouvelle à été introduite. Cette architecture est basée sur le langage de programmation Scala, avec support de systèmes concurrents. Comme ActiveMQ, Apollo est un broker multi-protocole et supporte AMQP, MQTT, STOMP et OpenWire. Licence ASRALL 10 IUT Charlemagne

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. 2.3.5 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 s'est donc faite principalement sur les protocoles supportés, ainsi que sur les langages dans lesquels ils sont conçus ; notre choix s'est porté sur le MOM connu comme étant le plus didactique, et facilement implémentable. Critères RabbitMQ MOM HornetQ Apollo QPID dépôts debian X X installation paquets deb X X dépôts rhel X X paquets rpm X X AMQP X X X X protocoles MQTT X 1 X STOMP X 1 X X Openwire X simplicité X X documentation prise en main X X interface web X 2 X X plugins existants X X X extensibilité création de plugins X X mirroring de queues X X haute disponibilité clustering interne X X 3 X X maturité année de sortie 2006 2009 2012 2005 langage erlang java scala C++ 4 Il nous a fallu choisir le MOM le plus adapté à la réalisation de notre maquette ; les critères étant, nous le rappelons : opensource, simplicité de mise en oeuvre, support de charge. Au vu de ces critères, RabbitMQ s'est démarqué comme étant la solution présentant le plus de qualités. En outre, c'est la solution que nos tuteurs maîtrisaient le mieux. 1. Via plugins 2. Disponible dans JBoss Application Server 3. Failover uniquement (pas de répartition de charge) 4. Initialement en Java Licence ASRALL 11 IUT Charlemagne

3 Les premiers pas sous RabbitMQ 3.1 Les premiers pas avec RabbitMQ via un client PHP 3.1.1 Introduction RabbitMQ est un système permettant à diérentes applications clientes de communiquer très simplement en échangeant des messages. Il s'appuie sur le protocole AMQP. Sur la base de ce MOM, nous avons choisis de vous présenter deux exemples distincts, réalisés en nous appuyant sur deux langages : PHP et Ruby. Nous allons voir comment une application A envoie des messages vers RabbitMQ, qui va ensuite les transmettre à une autre application B. La première chose à faire est donc bien évidemment d'installer RabbitMQ. 3.1.2 Installation du broker RabbitMQ Le paquet rabbitmq-server est inclus dans le dépôt Debian à partir de la version 6.0 (Squeeze) et la version 9.04 d'ubuntu. Le site ociel de RabbitMQ conseille néanmoins d'installer le.deb à partir du site (ou en ajoutant leur propre dépôt dans sources.list), car les versions des dépôts sont désuètes (2.8, sur Debian stable, alors que la dernière version de RabbitMQ est la 3.5). Voila les étapes d'installation : 1. Ajoutez la ligne suivante dans /etc/apt/sources.list : 1 deb http://www.rabbitmq.com/debian/ testing main 2. Mise a jour des dépôts et installation : 1 sudo apt-get update && sudo apt-get install rabbitmq-server 3. Pour activer RabbitMQ Management Console : 1 sudo rabbitmq-plugins enable rabbitmq management 4. On peut maintenant accéder aux service web de RabbitMQ en utilisant l'adresse suivante : http://localhost:15672/ A noter : par défaut, le nom et le mot de passe de l'utilisateur sont "guest/guest". Il est impossible d'accéder à l'interface de management à partir de ce compte. Licence ASRALL 12 IUT Charlemagne

3.1.3 Implémentation du Hello World Nous avons repris l'exemple donné dans la documentation du site ociel de RabbitMQ. Il s'agit d'une implémentation très simple, composée d'un producer (application P) qui envoie des messages ; et d'un consumer (application C) qui les reçoit. Nous avons donc écrit deux scripts PHP, exécutés depuis un shell. Un producer, qui a la charge d'envoyer un message, et un consumer, qui reçoit les messages et les achent. Dans le schéma cidessous (image1), "P" est notre producer et "C" est notre consumer. La boîte rouge est une le d'attente (queue) qui contient les messages le temps que le consumer les récupèrent. Nous avons utilisés la librairie php-amqplib pour pouvoir communiquer avec le broker. Il faut alors : 1. Ajouter un chier composer.json au dossier : 1 { 2 "require": 3 { 4 "videlalvaro/php-amqplib": "v2.1.0" 5 } 6 } 2. Installer composer : 1 curl https://getcomposer.org/installer php 3. Exécuter la commande : 1./composer.phar install 3.1.4 Le producer Le producer envoit un message 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 connexion vers le broker. On créé un nouveau channel. On déclare ensuite une queue. (pour que le message arrive dans une queue, il faut que celleci existe. La méthode queue_declare() permet de créer une queue si elle n'existe pas). Dans cet 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. Licence ASRALL 13 IUT Charlemagne

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('192.168.1.3', 5672, 'nathan', 'nathan'); 7 $connection = new AMQPConnection('localhost', 5672, 'guest', 'guest'); 8 $channel = $connection->channel(); 9 $channel->queue_declare('hello', false, false, false, false); 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?> 3.1.5 Le consumer Ici, il s'agit d'établir une connection et de déclarer la queue. 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 (dont la durée est dénie dans le message). Lorsqu'il n'a aucun message à traiter, le consumer attend jusqu'à ce qu'il y en ait un qui lui parvienne. On peut lancer le consumer an que celui-ci se mette en attente de messages. Enn, à 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 14 IUT Charlemagne

4 Les concepts 4.1 Gestion des virtual hosts (ci-après nommé vhost) Les vhosts sont des espaces virtuels, intégrés au broker, qui peuvent héberger un nombre illimité d'exchanges et de queues tout en les isolant les uns des autres. Des droits utilisateurs peuvent être y être dénis ; les vhosts permettent à un serveur RabbitMQ de simuler la pésence d'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 sont des entités disposant de certains droits vis à vis du broker, 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 types d'exchange Note : Les schémas présentés ci-après proviennent de la documentation ocielle de RabbitMQ : http ://www.rabbitmq.com/tutorials/tutorial-six-php.html Licence ASRALL 15 IUT Charlemagne

Rappel : un exchange est un espace dans lequel sont déposés les messages (par les publishers), d'ou ils sont distribués aux queues spéciées, selon une méthode particulière. Ce sont ces méthodes qui diérencient les exchanges ; nous en verrons 5 pour RabbitMQ. Il en existe 6 en réalité, mais la dernière, nommée "RPC", est très particulière et très peu utilisée. Les exchanges sous RabbitMQ : L'exchange default L'exchange fanout L'exchange direct L'exchange topic L'exchange headers 4.3.1 Default Ce premier exchange est celui activé par défaut ; il ne prend aucun paramètre, et place simplement le message dans la queue qui a été désignée lors de l'appel du producer. Néanmoins, comme le montre le schéma ci-dessous, cet exchange permet de répartir la charge de travail entre plusieurs consumers s'ils écoutent tous les deux sur la queue concernée. 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'envoie pas d'acknowledgement au producer), alors celui ci va renvoyer le message pour que consumer 2 exécute la tâche à sa place. 4.3.2 Fanout Le fonctionnement de l'exchange fanout ressemble très fortement au concept de broadcast ; le producer place un message dans l'exchange, an que tous les consumers ayant souscrit à la queue puissent récupérer une instance du message, et ce sans aucun ltrage ni distinction. Licence ASRALL 16 IUT Charlemagne

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 consommer le message), qu'ils bindent (attachent) à l'exchange. Ne reste plus alors qu'à consumer les messages. 4.3.3 Direct L'exchange direct nécessite 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 queue doit aller le message. Ce mécanisme permet de router les messages selon un ou plusieurs paramètres. Comme l'indique le schéma, ce type d'exchange 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. Ainsi, les messages dont les routing-keys ont la valeur suivante : orange : ira dans la queue 1 black ou green : ira dans la queue 2 4.3.4 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 Si nous imaginons une communication en mode topic sur des messages dont les routing-keys sont composés de noms d'animaux et de couleur : Licence ASRALL 17 IUT Charlemagne

Ainsi, les messages dont les routing-keys ont la valeur suivante : faster.orange : n'ira nul part (il doit y avoir 1 mot avant ET après orange) lazy.orange.ape : ira dans la queue 1 (répond aux critères) very.lazy.white.rabbit : n'ira nulle part (ne doit pas contenir plus de 2 mots avant rabbit) lazy : ira dans la queue 2 (les paramètres sont optionnels) lazy.white.blue.red.green.little.tiger : ira dans la queue 2 (nombre de paramètres entre 0 et N) 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. 4.3.5 Headers L'exchange headers route les messages selon un ou plusieurs entête(s) du message AMQP, à la diérence des autres qui se basent sur une routing-key. Licence ASRALL 18 IUT Charlemagne

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és de simuler une infrastructure physique à 3 noeuds, à l'aide de kvm et libvirt. Chaque noeud de cette infrastructure hébergeait un serveur RabbitMQ, et se trouvait 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 (3 brokers diérents, pas 1 broker à 3 noeuds...) : Sur l'hôte : kvm 1 :2.1 libvirt 1.2.9-8 Sur les machines virtuelles : rabbimq-server 2.8.4-1 ruby 1 :1.9.3 amq-protocol 1.9.2 bunny 1.7.0 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 aérents. 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. Licence ASRALL 19 IUT Charlemagne

5.2 Phase 2 : L'infrastructure de la maquette - Chirement de mail Cette infrastructure a été pensée dans le but de répondre aux besoins de la maquette 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 cette maquette imposait les contraintes suivantes : Deux serveurs postx 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" de la maquette en l'intégrant à une machine virtuelle dédiée. Sur l'hôte (10.0.0.254), nous avons conguré un serveur DNS (avec bind9) et dénis un domaine "rmq" comportant les entrées suivantes. Pour le broker : broker1 IN A 10.0.0.1 Pour l'application : encrypter IN A 10.0.0.7 mail-input IN A 10.0.0.8 mail-output IN A 10.0.0.9 Pour la haute disponibilité broker2 IN A 10.0.0.2 virtual-ip IN A 10.0.0.100 Licence ASRALL 20 IUT Charlemagne

Voici un schéma décrivant le contenu de chacune de ces machines : Licence ASRALL 21 IUT Charlemagne

Voici quelques réponses aux questions que vous vous posez certainement : 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? D'une part, nous avons préférés séparer "physiquement" (quoique virtuellement) les diérentes parties de notre maquette ; 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 pipe ; ainsi, avec un unique serveur postx, les mails auraient bouclés sans n dans le circuit de notre infrastructure. Pourquoi mettre l'application de chirement sur une VM à part? 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 de la maquette - Load-balancing et haute disponibilité Pour la phase 3, l'infrastructure a du évoluer, en ajoutant à l'existant un second serveur RabbitMQ, que nous avons nommé broker2. Ci-contre, les caractéristiques de la machine : 6 Envoi et chirement de mail 6.1 Présentation du besoin Le besoin lié à la réalisation de cette maquette (Proof of Concept) peut être découpé ainsi : Le besoin métier : Réaliser une maquette 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. Licence ASRALL 22 IUT Charlemagne

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 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ée 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 la maquette sous la forme d'un schéma : Licence ASRALL 23 IUT Charlemagne

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. Comme langage de script, nous avons choisi bash, et ce pour plusieurs raisons : C'est un langage 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 langage é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 tous ceux que nous avons étudiés, c'est lui le plus simple, le plus facile à utiliser et à installer ; sa documentation, 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 de 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 (dont le module pipe fait partie), qui était une caractéristique 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 Le fonctionnement 6.3.1 mail-input En résumé : Tout d'abord, le serveur postx de mail-input est conguré de façon à détourner les mails vers le script mailinput_mom_mailinjecter, grâce au module "pipe". Juste avant d'être envoyé au destinataire via smtp (ou directement dans la mailbox si le serveur local est le domaine nal de destination), le mail est "détourné" vers l'entrée standard d'une commande ; permettant ainsi d'opérer un traitement, via un langage de script quelconque, dessus. Ci-après, le schéma du mécanisme de pipe dans le contexte de notre maquette. Licence ASRALL 24 IUT Charlemagne

1 # Voici la conguration postx aérente sur mail-input : /etc/postx/master.cf 2 # Exécution du script à destination du MOM 3 # 4 mailinjecter unix - n n - - pipe 5 user=rabbit argv=/home/rabbit/mailinput_mom_mailinjecter ${sender} ${recipient} Quelques explications s'imposent : mailinjecter : le nom de l'entrée dans le chier de conguration pipe : le module postx à utiliser user : l'utilisateur unix qui lance le script argv : le chemin complet du script à exécuter ${sender} et ${recipient} : des macros postx - informations contenues dans le mail Licence ASRALL 25 IUT Charlemagne

Il faut commencer par envoyer un mail, qui sera intercepté par le module pipe de postx ; voici un script réalisant cela : En ce qui concerne mailinput_mom_mailinjecter, ce script reçoit un mail provenant du module pipe de postx (conguré dans cet but) ; 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-key "to_encrypt". Voici les logs produits, si tout se passe comme prévu : Pour plus de détails quant au fonctionnement de ce script, vous pouvez vous référer à l'annexe 1 : 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. 6.3.2 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) Licence ASRALL 26 IUT Charlemagne

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. Voici les logs produits, si tout se passe comme prévu : Pour plus de détails quant au fonctionnement de ce script, vous pouvez vous référer à l'annexe 2 : 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 il sera évidemment bien plus frais sur le problème à résoudre, avec un regard neuf et le recul indispensable. 6.3.3 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. Voici les logs produits, si tout se passe comme prévu : Licence ASRALL 27 IUT Charlemagne

Pour plus de détails quant au fonctionnement de ce script, vous pouvez vous référer à l'annexe 3 : 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 utilise le compte gmail de guillaume pour envoyer les mails chirés. 6.3.4 broker1 Le broker a simplement été conguré pour disposer d'un utilisateur nommé "ub1v1". 6.3.5 récepteur du mail Le client mail était situé, dans notre cas, sur l'hôte de l'infrastructure. Nous avons travaillés avec icedove (thunderbird - debian), et le plugin enigmail. Ci-contre, une capture d'écran du mail dans le cas ou l'utilisateur n'insère pas la passphrase qui lui est demandé : Ici, une capture d'écran sur le mail déchiré après que l'utilisateur eut entré sa passphrase dans le popup ouvert par enigmail : Licence ASRALL 28 IUT Charlemagne

7 Industrialisation 7.1 Transformation des consumers en services Linux (daemon) 7.1.1 Pourquoi Il était très laborieux de lancer manuellement les scripts consumers à chaque démarrage de notre infrastructure ; de surcroit, ces appications devant tourner en continu, il nous a semblé tout à fait naturel de chercher à les transformer en service. Dans ce but, nous avons crées, sur la base de procédures trouvées sur le site ociel de debian, deux scripts (daemon_structure.sh et create_daemon.sh) permettant une génération totalement autiomatisée de services sysvinit. Lancer cette transformation est plutôt simple : bash create-deamon.sh <nom du script> 7.1.2 Mise en place Il a d'abord fallu créer un script bash constituant le squelette d'un service, que nous avons nommés daemon_structure.sh. En voici le contenu (la gestion des paramètres d'entrée a été volontairement retirée, ne présentant que peu d'intérêt) : 1 #@**************************************************************************** 2 #@ Auteur : Saber Dir (dirsaber2000@yahoo.fr) 3 #@ Organisation : IUT Charlemagne (License ASRALL) 4 #@ License : GNU/GPL 5 #@ 6 #@ Description : Structure de base nécessaire pour transformer un script passé 7 #@ en paramètre en service (daemon) 8 #@**************************************************************************** 9 10 DAEMON="/home/rabbit/SCRIPT_BASENAME" 11 DAEMON_OPT="" 12 DAEMON_USER="rabbit" 13 DAEMON_NAME="SCRIPT_BASENAME" 14 15 PATH="/sbin:/bin:/usr/sbin:/usr/bin:/home/rabbit" 16 17 test -x $DAEMON exit 0 18. /lib/lsb/init-functions 19 20 d_start () { 21 log_daemon_msg "Starting system $DAEMON_NAME Daemon" 22 # On s'assure ainsi que ce démon se à la n du démarrage de la machine 23 # pour s'assurer de la disponibilité des connections réseaux. 24 sleep 0.5 25 Licence ASRALL 29 IUT Charlemagne

26 start-stop-daemon --background --start --quiet --chuid $DAEMON_USER --exec $DAEMON -- $DAEMON_OPT 27 log_end_msg $? 28 } Nous avons dénis dans ces variables bash un marqueur (SCRIPT_BASENAME), remplacé plus tard (avec la commande sed) par le nom du script à transformer en service : DAEMON="/home/rabbit/SCRIPT_BASENAME" DAEMON_OPT="" DAEMON_USER="rabbit" DAEMON_NAME="SCRIPT_BASENAME" Les options utilisées : --start - pour démarrer le script ; --quiet - pour rendre le script silencieux (CQFD) ; --background - pour mettre le script en arrière-plan (CQFD) ; --exec $DAEMON - pour lancer le programme ; Au départ, nous avions utilisés deux autres options : --make-pidfile afin de créer un fichier contenant le pid du service (pour pouvoir forcer l'arrêt plus --pidfile \$PIDFILE qui nous permet de définir le fichier dans lequel sera le PID. Mais nous nous sommes vite rendu compte que les programmes dont nous avions besoin du PID étaient les commandes amqp-consume forkées à l'intérieur de nos scripts encrypter_mom_mailconsumer et mailoutput_mom_mailconsumer ; il était donc inutile d'utiliser ces options ; les PID devaient être récupérés et sauvegardés dans le code même de nos consumers, juste après l'exécution des commandes amqp-consume. Puis, le script create_daemon.sh, qui se charge, sur la base de daemon_structure.sh, de générer un service complètement valide et compatible sysvinit sous debian stable. En voici la partie essentielle : 1 cp /home/rabbit/$script_name /usr/bin/$script_name 2 3 # Copie la structure du démon dans /etc/init.d/ 4 write_log INF "Copy the daemon structure into /etc/init.d" 5 cp /home/rabbit/daemon_structure.sh /etc/init.d/$script_name 6 7 # Remplace la chaîne SCRIPT_BASENAME par le nom du script dans la structure du démon 8 write_log INF "Replace SCRIPT_BASENAME by $script_name" 9 sed -i "s/script_basename/$script_name/g" /etc/init.d/$script_name 10 11 # Procède à quelques vérications 12 write_log INF "Ensure that $script_name is executable and rabbit is the owner" 13 chmod u+x /etc/init.d/$script_name 14 chown rabbit:rabbit /etc/init.d/$script_name Licence ASRALL 30 IUT Charlemagne

15 16 # Génère les liens symbolqies nécessaires dans les dossier rc*.d 17 # Enregistre le script en tant que service 18 write_log INF "Make an update.rc defaults and a insserv on $script_name" 19 update-rc.d $script_name defaults 20 insserv $script_name 21 22 # Démarre le service 23 write_log INF "Start the daemon $script_name" 24 /etc/init.d/$script_name start 25 26 #************************************************************************** 27 #EOF 28 #************************************************************************** 29 30 write_log END "Successfully executed" 31 exit 0 Notre service 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 Lors de la réalisation de cette partie du projet, nous avons rencontrés une épineuse diculté. Les processus amqp-consume ne s'exécutaient pas à chaque démarrage de l'infrastructure. Au début, ça nous a semblé se produire de façon totalement aléatoire. Les logs des diérents consumers ne montraient rien, si ce n'est que les scripts se lançaient correctement ; c'était les commandes amqp-consume, qui ne fonctionnaient pas. Au cours de tests, nous nous sommes aperçus que certaines ressources du broker étaient verrouillées lors du redémarrage de l'infrastructure ; fort de cette nouvelle donnée, nous nous sommes vite rendus compte qu'arrêter, puis redémarrer le broker RabbiMQ arrangeait le soucis. Chaque redémarrage qui suivait une purge du broker permettaient aux processus amqp-consume de démarrer. Néanmoins, impossible de comprendre pourquoi le broker avait besoin d'être purgé pour que les consumers démarrent et soient à l'écoute. Nous avons donc réaliser un debug "step by step", en exécutant l'infrastructure, et en faisant varier les paramètres suivants : variation de la durée du sleep, pour le lancement du service exécution des consumers en utilisateurs diérents (root, rabbit) purge, ou non, de broker1 Licence ASRALL 31 IUT Charlemagne

Ces exécutions comparatives nous ont permis d'éliminer un certain nombre d'hypothèses, et nous ont amenées à nous concentrer sur le problème du broker qui bloque ses ressources (queues et exchanges) en cas de redémarrage de l'infrastructure. En faisant quelques recherches, nous avons nalement trouvés le bug : Nous arrêtions les vm en faisant : virsh --connect system:///qemu destroy nom_de_la_vm Cette commande équivaut à débrancher un serveur physiquement. En eectuant cela sur broker1, celuici n'avait pas le temps de libérer les ressources précédement allouées ; ainsi, lors du redémarrage elles étaient en état "locked", et il était nécessaire de purger broker1 pour permettre à nos consumers de démarrer. La solution était simplement d'arrêter nos vm à l'aide de cette commande : virsh --connect system:///qemu shutdown nom_de_la_vm Ainsi, broker1 fermait proprement ses processus, et libérait toutes les ressources qu'il utilisait précédemment. La résolution de ce bug a été longue et dicile, car nous ne disposions pas de logs précis permettant de comprendre ce problème, et ce soucis pouvait avoir de nombreuses sources ; il nous a fallu procéder par élimination. Ce fut un authentique dé intellectuel et méthodologique. Le problème a été résolu à partir du moment ou nous nous sommes contraints à noter chaque étape du processus de debug, an d'avancer pas à pas, de façon rigoureuse. ce bug nous a également apporté une connaissance bien plus ne de la façon dont RabbitMQ gère ses élements (queues, exchanges) ; nous savons les lister, les manipuler, et les purger, quand c'est nécessaire. Ca n'a donc pas été du temps perdu ; bien au contraire. 7.2 Redondance et clustering 7.2.1 Objectifs Cette partie du travail avait pour objet les points suivants : Assurer la haute disponibilité du broker via du clustering Répartir la charge sur les deux noeuds du broker Voici la solution conçue pour répondre à ce besoin. Une autre solution était possible, plus simple, mais elle ne permettait pas le loadbalancing. Activer la fonctionnalité de clustering interne de RabbitMQ, an de faire de broker1 et broker2 les noeuds d'un même broker, joignable sur une des deux ip. Nous avons préféré utiliser une solution plus générique, à savoir deux serveurs haproxy mis en cluster grâce à Pacemaker et Corosync. Le choix de ces solutions a été rapide à faire ; nous les maîtrisions, et elles sont open-source. Des critères susants pour nous convaincre. Il s'agit ici dun cluster actif/passif. Le schéma de l'infrastructure de haute-disponibilité mise en place : Licence ASRALL 32 IUT Charlemagne

7.2.2 Mise en place du cluster Tout d'abord, il a fallu installer la suite logicielle pacemaker (qui contient corosync). apt-get install pacemaker corosync-keygen Puis, congurer ainsi /etc/default/corosync start=yes An que broker1 et broker2 soient reconnus comme les noeuds d'un même cluster, il a fallu congurer /et/corosync/corosync.conf et y modier la partie "interface" de la façon suivante : Licence ASRALL 33 IUT Charlemagne

interface { # IP des noeud du broker member { # IP de broker1 memberaddr: 10.0.0.1 } member { # IP de broker2 memberaddr: 10.0.0.2 } ringnumber: 0 # IP du réseau bindnetaddr: 10.0.0.0 } mcastaddr: 226.94.1.1 mcastport: 5405 transport: udpu An de permettre aux deux noeuds de communiquer ensemble, il a fallu générer la clef corosync grâce à la commande suivante : corosync-keygen Puis il a été nécessaire de copier ces 2 chiers sur broker2 à l'aide de la commande : scp /etc/corosync/corosync.conf /etc/corosync/authkey rabbit@broker2.rmq:/etc/corosync/corosync.conf Suivi d'un démarrage en règle du gestionnaire de cluster : /etc/init.d/corosync start Seconde étape, et non des moindre, la conguration des ressources du cluster. Nous avons choisi ici de procéder avec l'outil cli "crm" en mode non-interactif : # pas de fencing ici crm configure property stonith-enabled=false # deux noeuds seulement, donc il est nécessaire de désactiver le quorum crm configure property no-quorum-policy=ignore crm configure primitive VIRTUAL-IP ocf:heartbeat:ipaddr2 params ip="10.0.0.100" nic="eth0" op monitor crm configure primitive HAPROXY lsb:haproxy op monitor interval="10s" # nécessaire pour que les ressources démarrent ensemble group group-web VIRTUAL-IP HAPROXY commit Licence ASRALL 34 IUT Charlemagne

Il est à noter que la ressource VIRTUAL-IP a une adresse membre du réseau 10.0.0.0/24. Néanmoins, le cluster ne fonctionne pas encore, car les load-balancers haproxy ne sont pas installés sur les noeuds ; il s'agit de notre prochaine étape. 7.2.3 Mise en place du load-balancing Notre choix logiciel concernant le load-balancing, comme l'indique la conguration Pacemaker, s'est arrêté sur Haproxy. Les raisons en sont simples : il s'agit d'un projet mature, réputé, et open-source, que nous avons eu l'occasion d'utiliser par le passé. Notre objectif dans la mise en place d'haproxy était d'en installer un sur chaque noeud du cluster. De cette façon, même si un noeud du cluster se retrouve déconnecté ou dysfonctionne, la répartition de charge aura toujours lieu. Voici comment l'installation d'haproxy s'est déroulée : étant sous debian stable (Wheezy), haproxy n'était pas dans les dépôts ociels ; il a donc été nécessaire d'ajouter les dépôts backports, en ajoutant dans /etc/apt/sources.list : deb http://ftp.debian.org/debian/ wheezy-backports main Voici la conguration du load-balancing tel que décrite dans le chier /etc/haproxy/haproxy.cfg listen rabbitmq_cluster 10.0.0.100:5673 mode tcp # load-balancing en tour par tour balance roundrobin # délai de 3 heures avant la fermeture inopinée de la connection TCP timeout client 3h timeout server 3h # envoit des paquets TCP keepalived côté client ET côté serveur option tcpka # les 2 noeuds RabbitMQ doivent être actifs et en capacité de répondre server broker1 broker1.rmq:5672 check inter 5000 rise 2 fall 3 server broker2 broker2.rmq:5672 check inter 5000 rise 2 fall 3 Il ne reste plus qu'à relancer corosync : /etc/init.d/corosync restart Et à acher l'état du cluster pour voir le résultat : Licence ASRALL 35 IUT Charlemagne

Voilà, Le cluster est correctement conguré. 7.2.4 Changement au sein de nos applications Au niveau de notre application de chirement, il a fallu changer la valeur du paramètre server des commandes amqp-consume et amqp-publish, an que les producers et consumers s'adressent à l'ip virtuelle du cluster, sur laquelle écoute haproxy au niveau du port 5673, an que celui-ci redispatche en round-robin les requêtes sur broker1 et broker2 alternativement. 1 --server virtual-ip.rmq:5673 \ RAPPEL : virtual-ip est enregistré dans la zone "rmq" du DNS de l'hôte, à l'ip 10.0.0.100. 7.2.5 Conclusion sur le clustering et le loadbalancing C'est une partie que nous n'avons pas pu terminer, faute de temps. La défection d'israël nous a privé d'une force de travail qui nous eut été utile pour terminer ce morceau. Le basculement des noeuds fonctionne au niveau du cluster, mais nous ne sommes pas parvenus à faire en sorte que les connections TCP se déplacent sur broker2 sans s'interrompre, au cas ou nous eteignions brutalement broker1 (le basculement s'opère, mais la connection des commandes amqp-consume cesse). De plus, nous n'avons pas pu prouver que la répartition de charge s'opérait bien sur les noeuds. En apporter la preuve est relativement complexe, et nous aurait demandé un peu de travail supplémentaire. Licence ASRALL 36 IUT Charlemagne

Nous avons réalisé un script conçu pour "écouter" le trac sur les noeuds du broker an de vérier le roundrobin ; il fonctionne grâce à la fonctionnalité "rehose" de RabbitMQ, un tracer de messages performant activable ainsi : rabbitmqctl trace on Vous trouverez ce script en annexe de ce rapport (broker1_mom_logconsumer.rb) ; il faut y congurer une queue particulière, conçue spéciquement pour le déboguage. 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 atteint cet objectif en utilisant une architecture de répartition des messages et des processus complètement diérente de son aîné. Comme ActiveMQ, Apollo supporte les protocoles AMQP, MQTT, STOMP et OpenWire. 8.2 Architecture 8.2.1 Implémentation Apollo est basé sur le patron de conception Reactor qui permet le traitement d'évènement dans un environnement où les évènements peuvent provenir de sources diverses. Ce nouveau modèle de gestion permet à Apollo d'atteindre des niveaux très élevé d'évolutivité et d'ecacité 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 façon plus concise d'exprimer les fonctions de rappels (callback), il à été décidé qu'il serait utilisé en remplacement de Java. 8.2.2 Indépendance du protocole ActiveMQ supporte plusieurs protocoles depuis quelques années déjà, mais sous le capot, tous les protocoles sont convertis pour utiliser le protocole OpenWire. Cette approche n'est pas optimale car elle induit : Un surcoût de charge dû à la conversion des protocoles. Une dépendance à la compatibilité avec OpenWire du protocole subjacent. Licence ASRALL 37 IUT Charlemagne

Apollo est beaucoup plus modulaire et indépendant. Tous les protocoles sont égaux et construits sous forme de plugins pour le broker. 8.2.3 Administration par service REST ActiveMQ expose son interface d'administration via JMX : Supporte seulement le langage Java. N'est pas extensible pour de nombreux objets (peut créer un goulot d'étranglement). Les types de données riches sont dicile à exposer. 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 quel langage. Il n'y a que très peu de surcoût de ressource dû à l'administration. 8.3 Installation d'apollo Apollo est disponible sous forme de binaire sur le site ociel, à cette adresse : http://activemq.apache.org/apollo/download.html Pour nos tests, nous avons installés la version 1.7.1, la dernière version ocielle à ce jour. 1 # Installation Apollo 2 cd /opt 3 wget http://mir2.ovh.net/ftp.apache.org/dist/activemq/activemq-apollo/$ 4 1.7.1/apache-apollo-1.7.1-unix-distro.tar.gz 5 tar -zxvf apache-apollo-1.7.1-unix-distro.tar.gz 6 rm apache-apollo-1.7.1-unix-distro.tar.gz 7 ln -s apache-apollo-1.7.1 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és le protocole AMQP pour notre infrastructure avec RabbitMQ, AMQP étant le seul protocole qu'il supporte. Licence ASRALL 38 IUT Charlemagne

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émentation. 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 respectivement l'avantage 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, diérents types d'exchange ont été étudiés : default, fanout, direct, topic et headers. Ces diérents types d'échanges sont spéciques à AMQP. 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 exchanges de type topic. Notre implémentation utilise le langage Ruby et la librairie gem mqtt. 8.5.1 MQTT - Consumer Après avoir inclus 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éthode connect, puis va écouter les messages provenant de l'exchange 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 8.5.2 MQTT - Producer Après avoir inclu les librairies et s'être connecté au broker de la même façon que le consumer, le client envoit un message dans l'exchange topic "Time" contenant la date et le temps courant à l'aide de la méthode publish. 1 #!/usr/bin/ruby Licence ASRALL 39 IUT Charlemagne

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 8.6 Envoi de message simple via STOMP Le protocole STOMP supporte les messages de type default et topic. Ici nous verrons les échanges de type default. Le protocole STOMP étant très facilement implémentable et de type texte, notre implémentation utilise telnet et le langage Bash. 8.6.1 STOMP - Consumer L'implémentation du consumer via bash et telnet : 1 ( 2 echo "STOMP" 3 echo "accept-version:1.2" 4 echo "host:mybroker" 5 echo "login:admin" 6 echo "passcode:password" 7 echo "" 8 printf "\u000d\u000a" 9 sleep 1 10 echo "SUBSCRIBE" 11 echo "id:sub1" 12 echo "destination:/queue/telnet-sh" 13 echo "" 14 printf "\u000d\u000a" 15 ) telnet localhost 61613 8.6.2 STOMP - Producer L'implémentation du producer via bash et telnet : 1 ( 2 echo "STOMP" Licence ASRALL 40 IUT Charlemagne

3 echo "accept-version:1.2" 4 echo "host:mybroker" 5 echo "login:admin" 6 echo "passcode:password" 7 echo "" 8 printf "\u000d\u000a" 9 sleep 1 10 echo "SEND" 11 echo "destination:/queue/telnet-sh" 12 echo "content-type:text/plain" 13 echo "" 14 echo "Message" 15 printf "\u000d\u000a" 16 ) telnet localhost 61613 9 En conclusion 9.1 Acquis Techniques Tout d'abord ce projet nous à permis de découvrir toute une famille de logiciel, les intergiciel (ou middleware), dont font parties les MOM. Nous disposons donc, en tant qu'administrateur système, d'un type de solution de plus aux problèmes que nous aurons à résoudre dans notre vie professionnelle. Grâce à ce projet et avec l'aide de nos tuteurs, nous sommes maintenant capable de réaliser des scripts de niveau professionnel, notamment en respectant ces quelques bonnes pratiques : Respecter les conventions de nommage (nom des script, des variables). Mettre en place des entête de script générateurs de documentation (paramètres nécessaires, historique du script, aide utilisation,...). Commenter le script (spécier les fonctions et éléments importants, les étapes, la n de chier). Tester les paramètres en entrée, les variables d'environnement si nécessaire. Importer la conguration depuis un autre chier. Tester les codes retours des binaires lancés. Logger les actions eectuées dans un chier de logs dédié. Travailler sur ce projet nous a aussi permis de mettre en application ce que nous avons appris au cours de la licence, particulièrement en ce qui concerne le scripting bash, ruby, awk ; ainsi que des connaissances réseaux et systèmes avancées (clustering, loadbalancing). Nous avons été amenés à nous intéresser au fonctionnement des services Linux, même si nous avons travaillé sur SysVinit qui tend à disparaître, il est toujours utilisé en entreprise et va le rester encore un moment. Nous sommes également montés en compétences sur les serveurs mails en général, et postx en particulier ; notamment le détournement d'un mail au niveau de la couche transport, via le module pipe. Toute l'équipe est maintenant capable de manipuler un broker RabbitMQ avec aisance ; gestion des vhosts, des utilisateurs, des queues ; implémentation des diérents exchanges, mise en cluster des Licence ASRALL 41 IUT Charlemagne

diérents noeuds. Plus spécique à Guillaume, qui a travaillé seul sur cette question, le projet a été l'occasion de consolider ses connaissances en virtualisation ; comment créer une infrastructure sous kvm, comment la gérer et scripter par dessus. Enn, outre le fait qu'il nous ait fait découvrir de nouveaux protocoles relatifs au MOM, tels qu'amqp, MQTT, STOMP et OpenWire, le projet MOM nous a aussi permis de comprendre un peu mieux comment fonctionne le protocole SMTP, relatif à l'envoi de mail, et le protocole telnet pour l'envoi de messages via STOMP. N'oublions pas, d'ailleurs, le fait que nous avons progressés dans notre maîtrise de Latex et dans l'art de rédiger des rapports. 9.2 Atouts en milieux professionnels Les compétences que nous avons acquises sur les MOM sont très intéressantes, et peuvent être aisément réinvesties dans le monde professionnel. Cette famille de logiciel est très utilisée dans les grandes entreprise et les systèmes distribués, sous formes d'eai (Enterprise Application Integration) et d'esb (Enterprise Service Bus). L'EAI est une architecture intergicielle qui permet à des applications hétérogènes de gérer leurs échanges. Sa particularité est d'échanger les données en pseudo temps réel. L'ESB peut être considérée comme une nouvelle génération d'eai, la diérence majeure étant que l'esb propose une intégration complètement distribuée grâce à l'utilisation de conteneurs de services qui contiennent la logique d'intégration et peuvent être déposés n'importe où sur le réseau. Les autres secteurs utilisateurs des MOM incluent, par exemple, les entrepôts de données (Data Warehouse), les messageries interbancaires ainsi que la diusion d'informations. Nous avons même découverts que le développement de certains jeux, notamment les MMORPG, nécessite l'implémentation d'une solution de type MOM. 9.3 L'équipe Tout d'abord, nous pouvons dire que le départ d'israël en cours de projet à été très handicapant quant à notre avancement, en milieu de projet. A part cet accroc, l'ambiance de travail et les interactions au sein de l'équipe se sont plutôt bien passées. Chacun a travaillé avec sérieux et ardeur dans la mesure de ses compétences. Quelques tensions ont pu apparaître en phase de diculté (lors de la transformation des consumers en services Linux, notamment) entre Guillaume et Saber ; concernant les solutions à mettre en oeuvre. Mais ce conit naissant a vite été résorbé. Lors de la dernière ligne droite (rédaction du rapport, préparation de la présentation), tous le monde était un peu tendu, et ça s'est ressenti. Mais rien de grave. Licence ASRALL 42 IUT Charlemagne

9.4 Gestion du temps Dans cette partie, nous avons souhaités décrire la façon dont nous avons travaillés et gérés notre temps ; et faire un bilan de ce qui a été dicile / aisé. Phase 1 (semaine 1 - semaine 4) : Le démarrage du projet. Le travail qui nous a été demandé ici était de nous familiariser avec le concept des MOM, de tester une implémentation en contexte "bac à sable", et d'assimiler les concepts aérents (asynchronicité, exchanges, queues). Conjointement, nous devions commencer à comparer les diérents MOM du marché, en étudier plusieurs dans le but de les comparer. Nous avons perdus du temps sur cette première phase ; l'échéance nale étant loin, et le travail assez théorique, nous avons été long à nous harmoniser et à nous lancer. Cette inertie nous a coûté pour la suite du projet. Nous avons fait ce qui avait été demandé, mais dans un délai qui eut put être plus court (ce qui nous aurait laissé du temps pour approfondir la phase d'industrialisation). Phase 2 (semaine 5 - semaine 8) : Cette phase comportait 3 volets : Implémentation de la maquette Industrialisation Rédaction du rapport et préparation de la présentation Nous avons abordés cette phase avec beaucoup d'enthousiasme et de force de travail ; le sujet étant devenu bien plus concret et assimilé par l'équipe, nous avons avancés beaucoup plus rapidement ; les talents de chacun se sont exprimés pleinement et nous avons pu, dans une certaine mesure, rattraper le retard accumulé en phase 1. Les sessions de travail ont été productives et régulières. En outre, chacun disposait de l'infrastructure lui permettant de travailler chez lui indépendamment de ses camarades, ce qui a permis des sessions de travail "à distance" le week-end et le soir en semaine. 9.5 Le mot de la n Le projet MOM nous a beaucoup plu, à tous ; nous sommes conscient que découvrir ce type de logiciel est une chance, car ils sont très utilisés, représentant donc un atout de poids dans notre CV. En outre, le projet comportait une grosse partie de réalisation, et le travail n'en a été que plus enthousiasmant. Aucun de nous ne regrette d'avoir choisi ce sujet. Merci d'avoir lu ce rapport. Licence ASRALL 43 IUT Charlemagne

10 Annexes 10.1 Scripts 10.1.1 Structure Ce script a servi de base à tous les scripts de notre maquette et qui met en place quelques bonnes pratiques comme la mise en place d'un cartouche, la vérication des paramètres et le logging des actions eectuées. Tous nos scripts ont été réalisés de cette façon et les extraits suivants ne montreront que les étapes concernant la tâche en elle-même. 1 #! /bin/bash 2 3 #@**************************************************************************** 4 #@ Auteur : Guillaume PENAUD (guillaume.penaud@gmail.com) 5 #@ Organisation : IUT Charlemagne (License ASRALL) 6 #@ License : GNU/GPL 7 #@ 8 #@ Description : 9 #@ 10 #@ Prérequis : 11 #@ Arguments : 12 #@ Codes retour: 13 #@ 0: OK Tout s'est bien déroulé 14 #@ 1: KO Ache l'aide 15 #@ 2: KO Problème d'utilisateur 16 #@ 3: KO Problème d'argument 17 #@ 18 #@**************************************************************************** 19 20 # Conguration statique 21 script=`basename "$0" cut -f1 -d"."` 22 log_file=/var/log/`hostname`/$script.log 23 24 function usage () { 25 echo "$0 params1 params2" 26 } 27 28 function help () { 29 echo; grep -e "^#@" $script.sh sed "s/^#@//"; exit 1 30 } 31 32 # Fonction vériant la concordance entre le propriétaire et l ' exécuteur du script 33 function check_owner () { 34 # Trouve le propriétaire du script 35 owner=`stat -c %U $(readlink -f ${script}.sh)` 36 37 # Vérie l ' égalité entre le propriétaire et celui qui exécute 38 [ "$(id -un)"!= "$owner" ] && write_log ERR "Wrong user, must be run as $owner" && exit 2 39 } 40 41 # Fonction vériant le nombre et la nature des arguments passés au script 42 function check_arguments () { Licence ASRALL 44 IUT Charlemagne

43 # @TODO si nécessaire supprimer sinon 44 } 45 46 # Fonction de log 47 function write_log () { 48 log_state=$1; shift; log_txt=$*; log_date=`date +'%Y/%m/%d %H:%M:%S'` 49 50 case ${log_state} in 51 BEG) state="[start]" ;; 52 CFG) state="[conf ERR]" ;; 53 ERR) state="[error]" ;; 54 END) state="[end]" ;; 55 INF) state="[info]" ;; 56 *) state="[ - ]" ;; 57 esac 58 59 echo "$log_date $state : ${log_txt}" tee -a ${log_file} 2>&1 60 } 61 62 write_log BEG "Executing $script..." 63 write_log INF "Check script arguments and owner" 64 65 # Gestion des paramètres du script 66 # o : Options courtes 67 # l : Options longues 68 options=$(getopt -o h,f: -l help,fonction: -- "$@") 69 # Eclatement de $options en $1, $2... 70 set -- $options 71 72 while true; do 73 case "$1" in 74 -h --help) help; exit 1;; 75 -f --fonction) fonction $2; 76 shift 2;; 77 --) check_arguments $*; 78 break;; 79 *) write_log ERR "Unknown option"; exit 3;; 80 esac 81 done 82 83 # Optionnel seulement si l' utilisateur doit être le propriétaire 84 check_owner 85 86 #************************************************************************** 87 #@ Etape 88 #************************************************************************** 89 90 91 92 #************************************************************************** 93 #EOF 94 #************************************************************************** 95 96 write_log END "Successfully executed" 97 exit 0 Licence ASRALL 45 IUT Charlemagne

10.1.2 mailinput_mom_mailinjecter Ce script est appelé par Postx lors de la réception d'un mail, il fait le lien entre le serveur mail et le MOM, il transforme les mails qu'il reçoit en message AMQP, qu'il transfère au broker. 1 #************************************************************************** 2 #@ Etape 1: Récupération de l' entrée standard 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" 13 14 # 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 18 19 #************************************************************************** 20 #@ Etape 2: Traitement du contenu du mail 21 #************************************************************************** 22 23 # Récupère 24 write_log INF "Parse mail to retrieve the subject" 25 subject=$(egrep "Subject:" $mail_tmp cut -d ' ' -f2-) 26 27 28 # 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}') 33 34 # 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 4 36 37 # 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` 45 46 #************************************************************************** 47 #@ Etape 3: Envoi du mail modié en tant que message amqp 48 #************************************************************************** 49 50 # Envoit le message en exchange direct avec la clef de routage Licence ASRALL 46 IUT Charlemagne

51 # "to_encrypt" de façon à le diriger vers encrypt 52 # à travers le serveur broker1.rmq 53 write_log INF "Send message through RabbitMQ - routing-key: to_encrypt" 54 amqp-publish \ 55 --server virtual-ip.rmq:5673 \ 56 --vhost "/" \ 57 --username ub1v1 \ 58 --password aze \ 59 --exchange amq.direct \ 60 --routing-key to_encrypt \ 61 --body "$message" 62 63 # Plus besoin du chier temporaire, donc on supprime 64 write_log INF "Remove the temporary mail file" 65 rm $mail_tmp 10.1.3 encrypter_mom_mailconsumer Ce script écoute les messages arrivant sur la queue to_encrypt et les transmet au script encrypter_mom_mailencrypter pour qu'il les chire. 1 #************************************************************************** 2 #@ Etape unique : se connecte à la queue q_encrypt, puis lance l ' encrypter 3 #************************************************************************** 4 5 write_log INF "Forward broker message to encrypter_mom_mailencrypter" 6 amqp-consume \ 7 --server virtual-ip.rmq:5673 \ 8 --vhost "/" \ 9 --username ub1v1 --password aze \ 10 --exchange amq.direct \ 11 --routing-key to_encrypt \ 12 --declare \ 13 --queue ha.encrypt \ 14 /bin/bash /home/rabbit/encrypter_mom_mailencrypter & 15 16 echo $! > /tmp/$script.pid 10.1.4 encrypter_mom_mailencrypter Ce script reçoit le contenu d'un mail en entrée standard, vérie qu'il possède la clé publique du destinataire et, si c'est le cas, retourne le mail chiré au broker à destination du serveur mail de sortie (situé sur mail-output). Si ne c'est pas le cas, il envoit un message d'erreur au broker à destination du serveur mail d'entrée (situé sur mail-input). Licence ASRALL 47 IUT Charlemagne

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") 13 recipient=$(sed -n 2p <<< "$message") 14 subject=$(sed -n 3p <<< "$message") 15 content=$(sed -n '4,$p' <<< "$message") 16 17 #********************************************************************************* 18 #@ Etape 2 : Chire le mail envoit un message amqp à mail input en cas d'erreur 19 #********************************************************************************* 20 21 # 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) 24 25 if [ $? -eq $ERROR_PUBKEY_NOT_FOUND_STATUS ]; then 26 27 # Renvoit un message d'erreur à l'envoyeur 28 amqp-publish \ 29 --server virtual-ip.rmq:5673 \ 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")" 36 37 # 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 41 42 # 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` 50 51 #************************************************************************** 52 #@ Etape 3 : Envoit le message crypté à mail output 53 #************************************************************************** 54 Licence ASRALL 48 IUT Charlemagne

55 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 virtual-ip.rmq:5673 \ 60 --vhost "/" \ 61 --username ub1v1 \ 62 --password aze \ 63 --exchange amq.direct \ 64 --routing-key to_send \ 65 --body "$encrypted_message" 10.1.5 mailoutput_mom_mailconsumer Ce script écoute les messages arrivant sur la queue to_send et les transmet au script mailoutpout_mom_mailforwarder pour qu'il les envoit au destinataire d'origine via sendmail. 1 #************************************************************************** 2 #@ Etape unique : Attend le message crypté à forwarder sur postx 3 #************************************************************************** 4 5 write_log INF "Listening on broker1.rmq - queue: q_sender" 6 amqp-consume \ 7 --server virtual-ip.rmq:5673 \ 8 --vhost "/" \ 9 --username ub1v1 --password aze \ 10 --exchange amq.direct \ 11 --routing-key to_send \ 12 --declare \ 13 --queue ha.sender \ 14 /bin/bash /home/rabbit/mailoutput_mom_mailforwarder & 10.1.6 mailoutput_mom_mailforwarder Ce script reçoit le contenu d'un mail en entrée standard et l'envoit par sendmail. 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") Licence ASRALL 49 IUT Charlemagne

14 content=$(sed -n '4,$p' <<< "$message") 15 16 #************************************************************************** 17 #@ Etape 2: Forwarding du mail via postx et sendmail 18 #************************************************************************** 19 20 write_log INF "Sent formatted e-mail" 21 22 echo "$content" mail -s "$subject" "$recipient" -afrom:"$sender" 10.1.7 create_daemon.sh Ce script permet de créer un service SysVinit à partir du nom du script que l'on veut transformer en service et du script daemon_structure.sh. 1 #************************************************************************** 2 #@ Etape unique: Transforme un script donné en service syvinit 3 #************************************************************************** 4 5 # Supprime les quotes superues du nom du script 6 script_name=$(echo $1 tr -d "'") 7 8 # Copie le script dans /usr/bin 9 write_log INF "Copy $script_name into /usr/bin" 10 cp /home/rabbit/$script_name /usr/bin/$script_name 11 12 # Copie la structure du démon dans /etc/init.d/ 13 write_log INF "Copy the daemon structure into /etc/init.d" 14 cp /home/rabbit/daemon_structure.sh /etc/init.d/$script_name 15 16 # Remplace la chaîne SCRIPT_BASENAME par le nom du script dans la structure du démon 17 write_log INF "Replace SCRIPT_BASENAME by $script_name" 18 sed -i "s/script_basename/$script_name/g" /etc/init.d/$script_name 19 20 # Procède à quelques vérications 21 write_log INF "Ensure that $script_name is executable and rabbit is the owner" 22 chmod u+x /etc/init.d/$script_name 23 chown rabbit:rabbit /etc/init.d/$script_name 24 25 # Génère les liens symbolqies nécessaires dans les dossier rc*.d 26 # Enregistre le script en tant que service 27 write_log INF "Make an update.rc defaults and a insserv on $script_name" 28 update-rc.d $script_name defaults 29 insserv $script_name 30 31 # Démarre le service 32 write_log INF "Start the daemon $script_name" 33 /etc/init.d/$script_name start Licence ASRALL 50 IUT Charlemagne

10.1.8 daemon_structure.sh Ce script est la structure de base des services SysVinit de notre maquette, il est utilisé par le script create_daemon.sh pour automatiquement créer un service SysVinit. 1 #! /bin/sh e 2 3 #@**************************************************************************** 4 #@ Auteur : Saber Dir (dirsaber2000@yahoo.fr) 5 #@ Organisation : IUT Charlemagne (License ASRALL) 6 #@ License : GNU/GPL 7 #@ 8 #@ Description : Structure de base nécessaire pour transformer un script passé 9 #@ en paramètre en service (daemon) 10 #@**************************************************************************** 11 12 DAEMON="/home/rabbit/SCRIPT_BASENAME" 13 DAEMON_OPT="" 14 DAEMON_USER="rabbit" 15 DAEMON_NAME="SCRIPT_BASENAME" 16 17 PATH="/sbin:/bin:/usr/sbin:/usr/bin:/home/rabbit" 18 19 test -x $DAEMON exit 0 20. /lib/lsb/init-functions 21 22 d_start () { 23 log_daemon_msg "Starting system $DAEMON_NAME Daemon" 24 # On s'assure ainsi que ce démon se à la n du démarrage de la machine 25 # pour s'assurer de la disponibilité des connections réseaux. 26 sleep 0.5 27 28 start-stop-daemon --background --start --quiet --chuid $DAEMON_USER --exec $DAEMON -- $DAEMON_OPT 29 log_end_msg $? 30 } 31 32 d_stop () { 33 log_daemon_msg "Stopping system $DAEMON_NAME Daemon" 34 # le pid se trouve dans tmp car l ' utilisateur rabbit, qui éxecute le consumer, 35 # n'a pas accès en écriture à /var/run (seul le consumer connait son pid) 36 kill -9 $(cat /tmp/$daemon_name.pid) 37 rm /tmp/$daemon_name.pid 38 log_end_msg $? 39 } 40 41 case "$1" in 42 start stop) 43 d_${1} 44 ;; 45 46 restart reload force-reload) 47 d_stop 48 d_start 49 ;; Licence ASRALL 51 IUT Charlemagne

50 51 force-stop) 52 d_stop 53 killall -q $DAEMON_NAME true 54 sleep 2 55 killall -q -9 $DAEMON_NAME true 56 ;; 57 58 status) 59 status_of_proc "$DAEMON_NAME.sh" "$DAEMON" "system-wide $DAEMON_NAME.sh" && exit 0 exit $? 60 ;; 61 *) 62 echo "Usage: /etc/init.d/$daemon_name {start stop force-stop restart reload forcereload status}" 63 exit 1 64 ;; 65 esac 66 exit 0 10.1.9 synchronizer.sh Ce script permet de synchroniser les machines virtuelles avec le dépôt Git de l'hôte. 1 #! /bin/bash 2 3 #@**************************************************************************** 4 #@ Auteur : Guillaume PENAUD (guillaume.penaud@gmail.com) 5 #@ Organisation : IUT Charlemagne (License ASRALL) 6 #@ License : GNU/GPL 7 #@ 8 #@ Description : Synchronise les scripts présents sur les vm de l' infrastructure 9 #@ avec ceux présents dans le dépôt git de l ' hôte 10 #@**************************************************************************** 11 12 scp rabbit@mail-input.rmq:/home/rabbit/*../script/mail-input/ 13 [ $? -eq 0 ] && echo -e "\nmail-input a été correctement synchronisé\n" echo -e "\nerreur durant la synchronisation\n" 14 15 scp rabbit@encrypter.rmq:/home/rabbit/*../script/encrypter/ 16 [ $? -eq 0 ] && echo -e "\nencrypter a été correctement synchronisé\n" echo -e "\nerreur durant la synchronisation\n" 17 18 scp rabbit@mail-output.rmq:/home/rabbit/*../script/mail-output/ 19 [ $? -eq 0 ] && echo -e "\nmail-output a été correctement synchronisé\n" echo -e "\nerreur durant la synchronisation\n" Licence ASRALL 52 IUT Charlemagne

10.1.10 infra.sh Ce script permet de gérer l'infrastructure de notre maquette en y passant en argument les commandes start, stop, reboot, display ou status, puis un scope "front" (mail-input, encrypter, mail-output) ou "back" (broker1, broker2). 1 #! /bin/bash 2 3 #@**************************************************************************** 4 #@ Auteur : Guillaume PENAUD (guillaume.penaud@gmail.com) 5 #@ Organisation : IUT Charlemagne (License ASRALL) 6 #@ License : GNU/GPL 7 #@ 8 #@ Description : Gère l' infrastructure en séparant logiquement la couche 9 #@ applicative de la couche communication 10 #@ 11 #@ Prérequis : libvirt et kvm 12 #@ Arguments : type d'action scope 13 #@ Codes retour: 14 #@ 0: OK Tout s'est bien déroulé 15 #@ 1: KO Ache l'aide 16 #@ 2: KO Problème d'utilisateur 17 #@ 3: KO Problème d'arguments 18 #@ 4: KO Mail vide 19 #@ 20 #@**************************************************************************** 21 22 #************************************************************************** 23 #@ Déclaration des diérents scopes 24 #************************************************************************** 25 declare -a front_vm=(mail-input encrypter mail-output) 26 declare -a back_vm=(broker1 broker2 loadbalancer) 27 declare -a all_vm=(mail-input encrypter mail-output broker1 broker2 loadbalancer) 28 29 scope=all_vm 30 virsh="virsh --connect qemu:///system" 31 32 33 #************************************************************************** 34 #@ NOTE: "eval vms=\${$scope[*]}" permet d'extraire les vms membre du scope 35 #@ passé en paramètre du script 36 #************************************************************************** 37 38 start() { 39 eval vms=\${$scope[*]} 40 for vm in ${vms[*]}; do 41 $virsh start $vm >/dev/null 2>&1 42 echo "$vm is starting..." 43 sleep 0.5 44 done 45 } 46 47 48 stop() { 49 eval vms=\${$scope[*]} Licence ASRALL 53 IUT Charlemagne

50 for vm in ${vms[*]}; do 51 $virsh shutdown $vm >/dev/null 2>&1 52 echo "$vm is stopping..." 53 sleep 0.5 54 done 55 } 56 57 reboot() { 58 eval vms=\${$scope[*]} 59 for vm in ${vms[*]}; do 60 state=$($virsh list --all egrep $vm awk '{ print $3}') 61 62 if [ $state == "shut" ]; then 63 $virsh start $vm >/dev/null 2>&1 64 echo "$vm is starting..." 65 elif [ $state == "running" ]; then 66 $virsh reboot $vm >/dev/null 2>&1 67 echo "$vm is rebooting..." 68 fi 69 70 sleep 0.5 71 done 72 } 73 74 #************************************************************************** 75 #@ NOTE: Disponible uniquement sous le tiling manager i3, ache de façon 76 #@ automatique les shells dans de nouvelles fenêtres 77 #************************************************************************** 78 display() { 79 reboot $scope 80 81 echo -e "\r" 82 echo "Please wait few seconds during the boot time of the VMs" 83 sleep 20 84 85 i3-msg split v >/dev/null 2>&1 86 87 eval vms=\${$scope[*]} 88 for vm in ${vms[*]}; do 89 i3-msg exec 'urxvtc -e bash -c "ssh rabbit@'$vm'.rmq"' >/dev/null 2>&1 90 sleep 0.5 91 done 92 } 93 94 status() { 95 $virsh list --all 96 } 97 98 case "$1" in 99 100 start) 101 case "$2" in 102 front) scope=front_vm;; 103 back) scope=back_vm ;; 104 *) ;; 105 esac Licence ASRALL 54 IUT Charlemagne

106 107 start ;; 108 109 stop) 110 case "$2" in 111 front) scope=front_vm;; 112 back) scope=back_vm ;; 113 *) ;; 114 esac 115 116 stop ;; 117 118 reboot) 119 case "$2" in 120 front) scope=front_vm;; 121 back) scope=back_vm ;; 122 *) ;; 123 esac 124 125 reboot ;; 126 127 display) 128 case "$2" in 129 front) scope=front_vm;; 130 back) scope=back_vm ;; 131 *) ;; 132 esac 133 134 display ;; 135 136 status) 137 status;; 138 139 *) 140 echo "Usage: start.sh {display start stop status} [front back]" 141 exit 2 142 ;; 143 esac 144 145 exit 0 Licence ASRALL 55 IUT Charlemagne

10.1.11 broker1_mom_logconsumer.rb Ce script permet de logger le trac circulant sur le broker ; il nécessite que le trac rehose soit activé sur le serveur RabbitMQ. 1 #! /usr/bin/ruby 2 require 'bunny' 3 4 connection = Bunny.new({ 5 :host => "broker1.rmq", 6 :port => 5672, 7 :ssl => false, 8 :vhost => "/", 9 :user => "ub1v1", 10 :pass => "aze", 11 }) 12 13 connection.start 14 15 channel = connection.create_channel 16 exchange = channel.topic( 17 "amq.rabbitmq.trace", 18 :durable => true, 19 :auto_delete => false, 20 :internal => true 21 ) 22 23 q = channel.queue('#', :exclusive => true).bind(exchange, :routing_key => "deliver.#") 24 25 # set up the consumer 26 q.subscribe(:exclusive => true, :manual_ack => false) do delivery_info, properties, payload 27 puts properties[:headers]["node"] 28 puts properties[:headers]["routing_keys"] 29 end 30 31 sleep 1000.0 32 connection.close Licence ASRALL 56 IUT Charlemagne

10.2 Liens 10.2.1 Spécication AMQP : http://docs.oasis-open.org/amqp/core/v1.0/amqp-core-complete-v1.0.pdf MQTT : http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.pdf STOMP : https://stomp.github.io/stomp-specification-1.2.html OpenWire : http://activemq.apache.org/openwire-version-2-specification.html 10.2.2 Site Ociel RabbitMQ : https://www.rabbitmq.com HornetQ : http://hornetq.jboss.org/ Apollo : http://activemq.apache.org/apollo QPID : https://qpid.apache.org Licence ASRALL 57 IUT Charlemagne