Comment installer, configurer et utiliser RabbitMQ

Les courtiers de messages (message brokers) sont des applications intermédiaires utilisées dans différentes architectures logicielles, comme les microservices. Ils transfèrent les informations sous forme de messages d’un service à un autre.

Un concept fréquemment associé aux courtiers de messages est le modèle éditeur-abonné (publisher-subscriber), dans lequel les événements sont envoyés par les éditeurs (Producers) aux consommateurs (Consumers).

En général, un composant intermédiaire — un message broker — participe à la mise en œuvre de ce modèle.

Pour simplifier, utilisons une analogie. Pensez à YouTube : il existe des chaînes auxquelles vous pouvez vous abonner pour recevoir des notifications. Lorsqu’une nouvelle vidéo est publiée (un événement), vous êtes averti car vous êtes abonné.

Comment les applications fonctionnent avec les courtiers de messages

Trois termes principaux sont importants ici : Exchange, Queue et Binding.

• Exchange. C’est là que les événements de message sont envoyés. L’Exchange décide quels événements vont dans quelle file d’attente (Queue), en fonction des connexions — les bindings — que nous verrons plus tard.

• Queue. La file d’attente est une structure de données qui fonctionne selon le principe « premier entré, premier sorti » (FIFO). Elle stocke les données sur disque ou en mémoire et représente directement les messages. La file fournit des copies de ces messages aux consommateurs.

• Binding. Il s’agit de l’ensemble des règles qui indiquent à l’Exchange à quelles files d’attente les messages doivent être routés. Il peut y avoir plusieurs bindings avec différents paramètres entre un Exchange et une Queue.

Autres termes importants :

• Le Producer est un service qui génère des messages et les envoie au broker.
• Le Consumer est un autre service qui commence à traiter le message dès sa réception. Dans notre analogie YouTube, l’éditeur est YouTube lui-même, et le consommateur est votre téléphone, qui reçoit les notifications push.

Voici une explication étape par étape du fonctionnement du processus :

1. Le Producer envoie un message, qui est dirigé vers l’Exchange.

2. La Queue stocke ce message, par exemple sur le disque.

3. Lorsqu’un Consumer est prêt à recevoir un message (soit parce qu’il a terminé de traiter le précédent, soit parce que l’application d’événements a démarré), le serveur envoie une copie des données de la file au consommateur.

4. Le Consumer reçoit le message, le traite, puis envoie un accusé de réception (ACK) au broker.

5. Une fois que le broker reçoit l’accusé de réception, le message est supprimé.

Qu’est-ce que RabbitMQ ?

RabbitMQ est un courtier de messages open source populaire, basé sur le protocole AMQP (Advanced Message Queuing Protocol), un protocole ouvert permettant la transmission de messages d’événements via un broker dédié. AMQP offre de nombreuses fonctionnalités et, outre RabbitMQ, il est également implémenté par d’autres systèmes comme Apache Qpid.

RabbitMQ est écrit en Erlang, et ses principaux avantages sont son débit élevé et sa flexibilité maximale en matière de routage. RabbitMQ propose de nombreuses options de configuration permettant de définir les règles qui déterminent où et comment les messages sont envoyés pour traitement.

Les connexions à RabbitMQ se font via le protocole TCP : le client initie une connexion à l’adresse de l’hôte et la maintient ouverte aussi longtemps que l’interaction avec RabbitMQ est nécessaire. RabbitMQ prend également en charge l’authentification, comme le login et le mot de passe, pour un accès sécurisé.

Installation sur différents systèmes d’exploitation

RabbitMQ se compose du serveur et de l’interface Web (WebUI). La WebUI vous permet de surveiller ce qui se passe à l’intérieur du broker, comme vérifier si les nœuds du cluster sont actifs, voir combien de messages sont en cours de traitement, etc. Voyons comment installer RabbitMQ sur différents systèmes d’exploitation.

Avant de commencer, nous devons mettre à jour le nom d’hôte du serveur. Exécutez la commande suivante :

sudo hostnamectl set-hostname <nouveau-nom>

Par exemple, nous utiliserons rabbitmq comme nom d’hôte pour ce serveur :

sudo hostnamectl set-hostname rabbitmq

Installez nano :

sudo apt install nano

Et ajoutez le nouveau nom d’hôte dans le fichier /etc/hosts :

sudo nano /etc/hosts

Il doit ressembler à ceci :

127.0.0.1 <nouveau-nom>

Dans notre exemple :

127.0.0.1 rabbitmq

Ubuntu / Debian

Nous allons installer RabbitMQ sur Ubuntu 22.04. Pour d’autres distributions Ubuntu/Debian, consultez le guide sur le site officiel.

1. Mettez à jour la liste des paquets et installez les dépendances :

sudo apt-get update -y
sudo apt-get install curl gnupg -y
sudo apt-get install apt-transport-https

2. Ajoutez les clés de signature du dépôt :

curl -1sLf "https://keys.openpgp.org/vks/v1/by-fingerprint/0A9AF2115F4687BD29803A206B73A36E6026DFCA" | sudo gpg --dearmor | sudo tee /usr/share/keyrings/com.rabbitmq.team.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-erlang.E495BB49CC4BBE5B.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-server.9F4587F226208342.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.9F4587F226208342.gpg > /dev/null

3. Créez le fichier du dépôt (Apt Source List) :

sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
EOF

4. Mettez à jour à nouveau la liste des paquets :

sudo apt-get update -y

5. Installez Erlang :

sudo apt-get install -y erlang-base \
                       erlang-asn1 erlang-crypto erlang-eldap erlang-ftp erlang-inets \
                       erlang-mnesia erlang-os-mon erlang-parsetools erlang-public-key \
                       erlang-runtime-tools erlang-snmp erlang-ssl \
                       erlang-syntax-tools erlang-tftp erlang-tools erlang-xmerl

6. Enfin, installez RabbitMQ :

sudo apt-get install rabbitmq-server -y --fix-missing

Une fois l’installation terminée, vérifiez que le serveur RabbitMQ fonctionne :

systemctl status rabbitmq-server

Créez un utilisateur personnalisé :

sudo rabbitmqctl add_user <votre-utilisateur> <votre-motdepasse>

Attribuez les autorisations nécessaires :

sudo rabbitmqctl set_user_tags  <votre-utilisateur> administrator
sudo rabbitmqctl set_permissions -p /  <votre-utilisateur> ".*" ".*" ".*"

Activez ensuite la console d’administration de RabbitMQ :

sudo rabbitmq-plugins enable rabbitmq_management

Accédez à [votre IP de serveur]:15672. Entrez votre nom d’utilisateur et votre mot de passe pour accéder à l’interface Web de RabbitMQ.

Windows

Le guide d’installation est disponible sur le site Web de RabbitMQ. Vous pouvez utiliser Chocolatey ou l’installateur classique.

Avant d’installer RabbitMQ, il faut d’abord installer Erlang/OTP à partir du site officiel d’Erlang.

Exécutez le fichier téléchargé et suivez le processus d’installation.

Une fois Erlang installé, vous pouvez installer RabbitMQ en utilisant l’installateur officiel.

Activez ensuite l’interface Web :

cd 'C:\Program Files\RabbitMQ Server\rabbitmq_server-3.13.0\sbin'
./rabbitmq-plugins.bat enable rabbitmq_management

Vous pouvez maintenant accéder à localhost:15672 avec le nom d’utilisateur et le mot de passe par défaut guest:guest.

Docker

L’installation via Docker est probablement la méthode la plus simple et la plus pratique pour installer RabbitMQ.

Vous pouvez installer RabbitMQ avec la commande suivante :

docker run --rm -p 15672:15672 rabbitmq:3.13.7-management

L’interface d’administration sera disponible sur le port 15672, où vous pouvez vous connecter avec les identifiants par défaut guest:guest.

Cependant, cette méthode n’est pas adaptée à un environnement de production. Docker attribue un nom de serveur au conteneur et le broker stocke son état dans un dossier portant ce nom. À chaque nouvelle création du conteneur, RabbitMQ perdra ces informations d’état.

Nous pouvons définir facilement tous les paramètres de service nécessaires avec docker-compose, comme modifier le nom d’utilisateur et le mot de passe par défaut ou monter un dossier pour la persistance de l’état. Voici un exemple de fichier docker-compose.yml :

version: "3.3"
services:
  rabbit:
    image: rabbitmq:3.13.7-management
    environment:
      - RABBITMQ_DEFAULT_USER=admin #enter your username
      - RABBITMQ_DEFAULT_PASS=password #enter your password
    volumes:
      - ./rabbit:/var/lib/rabbitmq # mounting folder for state persistence
    ports:
      - 15672:15672 # expose port for the admin interface

Exécutez :

docker compose up -d

L’interface Web de RabbitMQ est maintenant disponible.

Vue d’ensemble de RabbitMQ Management

Sur la page principale de l’interface d’administration de RabbitMQ, vous pouvez voir des informations générales telles que les nœuds, leur état, le nombre total de messages, etc.

• Connections – la liste des connexions au cluster.

• Channels – la liste des canaux. Plusieurs canaux peuvent être créés au sein d’une seule connexion, à travers lesquels les messages sont envoyés. Cela permet d’éviter de créer plusieurs connexions TCP.

Exchanges

Regardons de plus près les Exchanges.

Il existe plusieurs types d’Exchanges, chacun avec son propre mécanisme de filtrage des messages. En fonction de ces règles, les événements sont routés vers des files d’attente spécifiques.

Direct Exchange

Chaque message a une clé appelée Routing Key. Ces messages sont acheminés vers les files d’attente dont le binding spécifie la même clé.

Topic Exchange

Le routage est effectué selon un modèle de clé. Lors de la création du modèle, vous pouvez utiliser 0 ou plusieurs mots (lettres et chiffres) séparés par des points, par exemple key.event, et les symboles # et *.

Fanout Exchange

Aucune règle de filtrage n’est appliquée. Chaque message envoyé à un Fanout Exchange est acheminé vers toutes les files d’attente.

Headers Exchange

Utilise les en-têtes des messages et compare les paires clé-valeur avec les en-têtes de liaison (binding headers).

Queues

Lorsque vous consultez une file d’attente spécifique, vous pouvez voir un graphique indiquant le nombre de messages dans la file, ainsi que des statistiques sur les temps de livraison et de réception.

Les messages peuvent avoir deux états :

• Ready – en attente de traitement.
• Unacked – en cours de traitement par le consommateur.

Implémenter le modèle éditeur-abonné en Python

Voyons comment utiliser RabbitMQ pour implémenter le modèle Pub-Sub en Python. Vous devez avoir Python installé (dans cet exemple, la version 3.11.5) et la bibliothèque Pika.

1. Créez ou sélectionnez un dossier où résidera le code de l’application :

mkdir rabbitmq-article

2. Ouvrez ce dossier dans votre IDE (par exemple Visual Studio Code ou PyCharm).

3. Installez la bibliothèque Pika :

pip install pika

4. Créez deux fichiers : sender.py et receiver.py.

Code de sender.py

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType

# Create connection, specifying parameters in the ConnectionParameters object
connection = BlockingConnection(ConnectionParameters(host='localhost'))

# Create a channel
channel = connection.channel()

# Declare an exchange
channel.exchange_declare('new_exchange', ExchangeType.direct)

# Declare a queue
queue = channel.queue_declare(queue='new_queue')

# Bind the queue to the exchange
channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

# Publish a message
channel.basic_publish(exchange='new_exchange', routing_key='key', body='Hello World!')

print("Message 'Hello World!' sent")
connection.close()

Dans le code ci-dessus de sender.py :

• Nous établissons une connexion à RabbitMQ sur localhost.

• Nous déclarons un exchange direct appelé new_exchange.

• Nous déclarons une file d’attente appelée new_queue.

• Nous lions la file à l’exchange à l’aide de la clé de routage key.

• Enfin, nous publions le message 'Hello World!' dans l’exchange avec la clé de routage spécifiée.

Code de receiver.py

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType
import sys, os

def main():
    # Create connection
    connection = BlockingConnection(ConnectionParameters(host='localhost'))
    # Create channel
    channel = connection.channel()

    # Declare an exchange
    channel.exchange_declare('new_exchange', ExchangeType.direct)

    # Declare a queue
    queue = channel.queue_declare(queue='new_queue')

    # Bind the queue to the exchange
    channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

    # Function to handle incoming messages
    def handle(ch, method, properties, body):
        print(f"Received message: {body.decode()}")

    # Bind the callback function and queue
    channel.basic_consume(queue='new_queue', on_message_callback=handle, auto_ack=True)

    print('Waiting for messages. Press Ctrl+C to exit.')
    channel.start_consuming()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

Dans le code ci-dessus de receiver.py :

• Nous établissons une connexion et un canal à RabbitMQ, comme dans le sender.
• Nous déclarons l’exchange direct (new_exchange) et la file (new_queue).
• La file est liée à l’exchange à l’aide de la clé de routage key.
• La fonction handle() traite les messages en les affichant à leur réception.
• La méthode basic_consume() abonne la fonction de rappel à la file.
• Nous utilisons start_consuming() pour maintenir le processus en attente de messages indéfiniment.
  

Exécuter le code

Démarrez d’abord le récepteur :

python receiver.py

Vous devriez voir :

Waiting for messages. Press Ctrl+C to exit.

Ensuite, exécutez l’expéditeur :

python sender.py

Sortie :

Message 'Hello World!' sent

Dans le terminal où s’exécute le récepteur, vous verrez :

Received message: Hello World!

Dans la console de gestion de RabbitMQ, vous pouvez voir que l’exchange new_exchange est lié à la file new_queue à l’aide de la clé de routage key.

Conclusion

Dans cet article, nous avons exploré ce que sont les courtiers de messages, comment les applications interagissent avec eux et comment installer et utiliser RabbitMQ comme courtier de messages. Nous avons implémenté avec succès un modèle éditeur-abonné en utilisant Python, RabbitMQ et la bibliothèque Pika, où l’expéditeur publie des messages dans un exchange et le récepteur les consomme.