⚙️ Installation et Configuration de RabbitMQ

Bienvenue dans votre première installation de RabbitMQ ! Cette leçon vous guide pas-à-pas pour mettre en place un environnement RabbitMQ fonctionnel, que ce soit pour le développement ou la production.

🎯 Ce que vous allez apprendre

  • Installation rapide avec Docker (5 minutes)
  • Configuration de base pour démarrer
  • Sécurisation de votre installation
  • Monitoring et supervision
  • Bonnes pratiques de production

🐳 Installation avec Docker (Recommandée pour débuter)

Pourquoi Docker ?

  • ✅ Simple et rapide : une seule commande
  • ✅ Pas de conflits avec votre système
  • ✅ Environnement propre et reproductible
  • ✅ Interface web incluse

Étape 1 : Créer le fichier Docker Compose

Créez un fichier docker-compose.yml :

version: '3.8'
services:
  rabbitmq:
    image: rabbitmq:3.12-management
    container_name: rabbitmq-formation
    ports:
      - "5672:5672"     # Port AMQP
      - "15672:15672"   # Interface web
    environment:
      RABBITMQ_DEFAULT_USER: admin
      RABBITMQ_DEFAULT_PASS: password123
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq

volumes:
  rabbitmq_data:

Étape 2 : Démarrer RabbitMQ

# Lancer le conteneur
docker-compose up -d

# Vérifier que tout fonctionne
docker-compose logs -f rabbitmq

Étape 3 : Accéder à l'interface web

Ouvrez votre navigateur : http://localhost:15672

  • Utilisateur : admin
  • Mot de passe : password123

🎉 Félicitations ! RabbitMQ est maintenant installé et prêt à utiliser.

💡 Comprendre l'interface de gestion

Une fois connecté, vous verrez plusieurs onglets :

| Onglet | Description | Usage | |--------|-------------|--------| | Overview | Vue d'ensemble du système | Monitoring général | | Connections | Connexions actives | Debug des clients | | Channels | Canaux de communication | Performance | | Exchanges | Points de routage | Configuration | | Queues | Files de messages | Surveillance |

💡 Astuce : Commencez par explorer l'onglet "Overview" pour vous familiariser avec les métriques de base.

🖥️ Installation Native (Production)

Ubuntu/Debian

# 1. Installer Erlang (requis pour RabbitMQ)
wget -O- https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
sudo dpkg -i erlang-solutions_2.0_all.deb
sudo apt-get update && sudo apt-get install esl-erlang

# 2. Installer RabbitMQ
curl -s https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.deb.sh | sudo bash
sudo apt-get install rabbitmq-server

# 3. Démarrer le service
sudo systemctl enable rabbitmq-server
sudo systemctl start rabbitmq-server

# 4. Activer l'interface web
sudo rabbitmq-plugins enable rabbitmq_management

macOS avec Homebrew

# Installation
brew install rabbitmq

# Démarrage automatique
brew services start rabbitmq

# Interface web
rabbitmq-plugins enable rabbitmq_management

🔧 Configuration de Base

Créer un utilisateur administrateur

# Créer l'utilisateur
sudo rabbitmqctl add_user monprojet motdepasse123

# Donner les droits administrateur
sudo rabbitmqctl set_user_tags monprojet administrator

# Donner toutes les permissions
sudo rabbitmqctl set_permissions -p / monprojet ".*" ".*" ".*"

# Supprimer l'utilisateur guest (sécurité)
sudo rabbitmqctl delete_user guest

Fichier de configuration simple

Créez /etc/rabbitmq/rabbitmq.conf :

# Mémoire : utilise 60% de la RAM disponible
vm_memory_high_watermark.relative = 0.6

# Espace disque : minimum 2GB libre
disk_free_limit.absolute = 2GB

# Désactiver l'accès distant pour guest
loopback_users.guest = false

# Logs plus verbeux
log.console = true
log.console.level = info

🏢 Organiser avec les Virtual Hosts

Les Virtual Hosts (vhosts) permettent de séparer vos projets sur le même serveur RabbitMQ.

Créer des environnements

# Créer les vhosts
sudo rabbitmqctl add_vhost developpement
sudo rabbitmqctl add_vhost production

# Créer des utilisateurs dédiés
sudo rabbitmqctl add_user dev_user dev_pass
sudo rabbitmqctl add_user prod_user prod_pass_secure

# Assigner les permissions
sudo rabbitmqctl set_permissions -p developpement dev_user ".*" ".*" ".*"
sudo rabbitmqctl set_permissions -p production prod_user ".*" ".*" ".*"

Configuration client (Node.js)

const amqp = require('amqplib');

const config = {
  development: {
    protocol: 'amqp',
    hostname: 'localhost',
    port: 5672,
    username: 'dev_user',
    password: 'dev_pass',
    vhost: 'developpement'
  },
  production: {
    protocol: 'amqp',
    hostname: 'prod-rabbitmq.monsite.com',
    port: 5672,
    username: 'prod_user',
    password: process.env.RABBITMQ_PASSWORD,
    vhost: 'production'
  }
};

// Utilisation
const env = process.env.NODE_ENV || 'development';
const connection = await amqp.connect(config[env]);

🛡️ Sécurité de Base

Principe des permissions

RabbitMQ utilise 3 niveaux de permissions :

  1. Configure : Créer/modifier exchanges et queues
  2. Write : Publier des messages
  3. Read : Consommer des messages

Exemples de permissions restrictives

# Utilisateur qui peut seulement lire les logs
sudo rabbitmqctl set_permissions -p production lecteur_logs "" "" "^logs-.*"

# Microservice qui ne peut utiliser que ses propres ressources
sudo rabbitmqctl set_permissions -p production api_users "^users-.*" "^users-.*" "^users-.*"

# Service de monitoring (lecture seule)
sudo rabbitmqctl set_permissions -p production monitoring "" "" ".*"

📊 Monitoring Simple

Plugins essentiels

# Interface web (déjà activé avec Docker)
sudo rabbitmq-plugins enable rabbitmq_management

# Monitoring en temps réel
sudo rabbitmq-plugins enable rabbitmq_top

# Métriques Prometheus (optionnel)
sudo rabbitmq-plugins enable rabbitmq_prometheus

Surveiller les métriques importantes

Depuis l'interface web, surveillez :

  • Memory usage : doit rester sous 80%
  • Connections : nombre de clients connectés
  • Messages : taux de production vs consommation
  • Queues : éviter l'accumulation de messages

🚨 Alert : Si une queue accumule des messages, c'est souvent que les consumers ne suivent pas la charge.

✅ Checklist d'installation réussie

Vérifications de base

  • [ ] RabbitMQ démarre correctement
  • [ ] Interface web accessible (http://localhost:15672)
  • [ ] Utilisateur admin créé et fonctionnel
  • [ ] Utilisateur guest désactivé ou supprimé
  • [ ] Configuration mémoire/disque adaptée

Tests de fonctionnement

  • [ ] Création d'une queue via l'interface
  • [ ] Envoi d'un message test
  • [ ] Réception du message
  • [ ] Suppression de la queue test

Pour la production

  • [ ] SSL/TLS configuré
  • [ ] Firewall configuré (ports 5672, 15672)
  • [ ] Monitoring activé
  • [ ] Sauvegardes planifiées
  • [ ] Documentation des accès

🚀 Script d'installation rapide

Voici un script qui automatise l'installation complète :

#!/bin/bash
# install-rabbitmq.sh

echo "🚀 Installation RabbitMQ pour Formation"

# Variables
USER_NAME="formation"
USER_PASS=$(openssl rand -base64 12)

# Installation (Ubuntu/Debian)
echo "📦 Installation des packages..."
sudo apt update
curl -s https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.deb.sh | sudo bash
sudo apt install -y rabbitmq-server

# Configuration
echo "⚙️ Configuration de base..."
sudo rabbitmq-plugins enable rabbitmq_management

# Utilisateur
echo "👤 Création de l'utilisateur..."
sudo rabbitmqctl add_user $USER_NAME $USER_PASS
sudo rabbitmqctl set_user_tags $USER_NAME administrator
sudo rabbitmqctl set_permissions -p / $USER_NAME ".*" ".*" ".*"
sudo rabbitmqctl delete_user guest

echo "✅ Installation terminée !"
echo ""
echo "🌐 Interface web : http://localhost:15672"
echo "👤 Utilisateur    : $USER_NAME"
echo "🔑 Mot de passe   : $USER_PASS"
echo ""
echo "💡 Sauvegardez ces informations !"

🎯 Prochaines étapes

Maintenant que RabbitMQ est installé, vous êtes prêt pour :

  1. Comprendre les concepts (Exchange, Queue, Binding)
  2. Créer vos premiers messages
  3. Explorer les patterns (Work Queues, Pub/Sub)
  4. Intégrer dans vos applications

💡 Conseil : Gardez l'interface web ouverte dans un onglet, elle sera votre meilleur outil de debug pendant l'apprentissage !

Félicitations ! 🎉 Vous avez maintenant un environnement RabbitMQ fonctionnel. Dans la prochaine leçon, nous explorerons les concepts fondamentaux : Exchange, Queue et Binding.

📝 Testez vos connaissances !

Répondez à 10 questions pour valider ce cours

Up next

2. Concepts Clés : Exchange, Queue, Binding

Comprendre le modèle AMQP, le rôle des exchanges, queues, bindings et routing keys.