Introduction à Supervisor

Mise à jour : 09/10/2024

Je vais te présenter Supervisor, un outil open source de gestion de processus, particulièrement utile pour exécuter et superviser des programmes en arrière-plan. Bien qu’il soit souvent utilisé pour gérer des services directement sur des serveurs physiques ou virtuels, Supervisor est également très adapté à la gestion de services dans des conteneurs.

Dans un contexte où les conteneurs sont de plus en plus utilisés pour isoler les applications, Supervisor peut être un allié précieux pour gérer les processus internes à ces conteneurs. Par exemple, il est fréquent d’utiliser Supervisor pour superviser plusieurs processus au sein d’un même conteneur. En effet, bien que les conteneurs soient souvent conçus pour ne lancer qu’un seul service, des scénarios complexes nécessitent parfois l’exécution de plusieurs services dans un seul conteneur. C’est là que Supervisor entre en jeu, en garantissant que chaque service reste actif, redémarre en cas de panne, et est surveillé de manière centralisée.

En intégrant Supervisor dans des environnements basés sur Docker ou Podman, tu peux facilement gérer et superviser plusieurs processus à l’intérieur d’un conteneur, sans avoir à déployer des solutions plus complexes comme Kubernetes. Supervisor devient ainsi une solution idéale pour des conteneurs nécessitant une gestion fine des processus internes.

Historique

À l’origine, Supervisor a été développé pour combler un besoin dans la gestion de processus sur des systèmes Unix. Dans les environnements où plusieurs services doivent tourner en continu, il est souvent difficile d’assurer que chaque processus fonctionne sans interruption, surtout lorsqu’il s’agit de services critiques comme des bases de données ou des serveurs web.

Avant l’apparition de Supervisor, les administrateurs systèmes devaient souvent utiliser des scripts personnalisés ou des solutions comme cron pour redémarrer les services échoués manuellement. Cela était non seulement laborieux, mais aussi peu fiable dans les environnements complexes. C’est dans ce contexte que Supervisor a été créé, avec pour but de rendre la gestion des processus plus automatisée et plus accessible.

Au fil des années, Supervisor a gagné en popularité, notamment parce qu’il est simple à configurer et à utiliser. Il est rapidement devenu un outil de choix pour les administrateurs qui cherchent à superviser des processus sans avoir à déployer des solutions plus lourdes comme Kubernetes. L’introduction d’une interface web et de la gestion centralisée des logs ont renforcé son adoption, faisant de Supervisor une solution largement utilisée dans les environnements de production.

Fonctionnalités principales

Supervisor se distingue par plusieurs fonctionnalités qui en font un outil pratique pour la gestion de processus en arrière-plan. L’une des principales forces de Supervisor est sa capacité à surveiller des processus et à les redémarrer automatiquement en cas de panne. Cela permet de garantir la continuité de services critiques, sans intervention manuelle de l’administrateur.

Voici quelques-unes des fonctionnalités les plus importantes de Supervisor :

Surveillance automatique : Si un processus surveillé tombe en panne, Supervisor peut automatiquement tenter de le redémarrer, assurant ainsi une disponibilité continue.
Gestion des journaux (logs) : Chaque processus supervisé peut avoir ses propres fichiers de logs, que Supervisor peut centraliser. Cela facilite l’analyse des événements et la détection des pannes.
Contrôle à distance via une interface Web : L’interface web intégrée de Supervisor permet de surveiller et contrôler les processus à distance. C’est un outil visuel simple mais efficace pour démarrer, arrêter ou redémarrer des services, ou simplement pour voir leur état en temps réel.
Hiérarchisation des services : Les processus peuvent être configurés avec des priorités de démarrage ou d’arrêt. Par exemple, si plusieurs services doivent démarrer dans un ordre précis, Supervisor peut les gérer selon une séquence définie.
Commandes simples : Grâce à supervisorctl, il est possible de contrôler les processus avec des commandes comme start, stop ou restart. Cela simplifie énormément la gestion au quotidien.
Supervision des groupes de processus : Il est possible de regrouper des processus similaires, ce qui permet de les gérer ensemble. Par exemple, redémarrer tous les services web d’un coup devient facile grâce à cette fonctionnalité.

Utilisation de Supervisor sur une machine

Supervisor est particulièrement utile pour gérer des processus sur une machine classique. Il permet de superviser plusieurs services avec plus de flexibilité qu’avec des solutions comme systemd, tout en offrant des fonctionnalités comme le redémarrage automatique, la gestion des logs et une interface web simple pour contrôler les processus.

Installation de Supervisor

Pour installer Supervisor sur un système Linux, utilise les commandes suivantes selon ta distribution :

Sur Ubuntu/Debian :
Terminal window
```
sudo apt-get install supervisor
```
Sur CentOS/RHEL :
Terminal window
```
sudo yum install supervisor
```

Une fois installé, Supervisor crée un fichier de configuration global (/etc/supervisord.conf) et un répertoire pour les fichiers de configuration de chaque service (/etc/supervisor/conf.d/).

Configuration des services avec Supervisor

Chaque service que tu veux superviser nécessite son propre fichier de configuration. Par exemple, pour superviser un service appelé mon_service, crée un fichier /etc/supervisor/conf.d/mon_service.conf :

[program:mon_service]
command=/usr/bin/mon_service --option
autostart=true
autorestart=true
stdout_logfile=/var/log/mon_service.log
stderr_logfile=/var/log/mon_service.err.log

Dans cet exemple :

command : Spécifie la commande pour lancer le service.
autostart : Démarre automatiquement le service lorsque Supervisor démarre.
autorestart : Redémarre le service s’il échoue.
stdout_logfile et stderr_logfile : Spécifient où enregistrer les logs du service.

Commandes de base avec Supervisor

Après avoir configuré tes services, tu peux utiliser supervisorctl pour les gérer :

Démarrer un service :
Terminal window
```
sudo supervisorctl start mon_service
```
Arrêter un service :
Terminal window
```
sudo supervisorctl stop mon_service
```
Redémarrer un service :
Terminal window
```
sudo supervisorctl restart mon_service
```
Vérifier l’état de tous les services supervisés :
Terminal window
```
sudo supervisorctl status
```

Utilisation de Supervisor dans un Conteneur Docker

Dans ce chapitre, nous allons configurer Supervisor pour superviser MySQL et Redis dans un conteneur Docker basé sur Alpine Linux. Cela est particulièrement utile pour gérer plusieurs services au sein d’un même conteneur.

Dockerfile avec Alpine, Supervisor, MySQL et Redis

Voici un Dockerfile complet pour créer un conteneur contenant Supervisor, MySQL, et Redis :

# Utilise l'image alpine comme base
FROM alpine:latest

# Installe Supervisor, MySQL, Redis et autres dépendances
RUN apk update && apk add --no-cache \
    supervisor \
    mysql mysql-client \
    redis \
    bash

# Crée les répertoires pour Supervisor et MySQL
RUN mkdir -p /etc/supervisor.d /var/log/supervisor /run/mysqld /var/lib/mysql

# Change les permissions pour le répertoire MySQL
RUN chown -R mysql:mysql /run/mysqld /var/lib/mysql

# Initialiser la base de données MySQL
RUN mysql_install_db --user=mysql --datadir=/var/lib/mysql

# Script pour préparer le répertoire socket avant le démarrage de MySQL
COPY init-mysql.sh /usr/local/bin/init-mysql.sh
RUN chmod +x /usr/local/bin/init-mysql.sh

# Copie les fichiers de configuration pour Supervisor
COPY supervisord.conf /etc/supervisord.conf
COPY mysql.ini /etc/supervisor.d/mysql.ini
COPY redis.ini /etc/supervisor.d/redis.ini

# Expose les ports MySQL et Redis
EXPOSE 3306 6379

# Commande de démarrage : exécute Supervisor pour gérer MySQL et Redis
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisord.conf"]

Script d’initialisation pour MySQL

Pour s’assurer que MySQL peut démarrer correctement, nous allons utiliser un script init-mysql.sh qui crée le répertoire de socket nécessaire et applique les bonnes permissions avant de lancer MySQL.

#!/bin/bash

# S'assurer que le répertoire de socket existe et appartient à l'utilisateur mysql
if [ ! -d /run/mysqld ]; then
  mkdir -p /run/mysqld
fi

chown -R mysql:mysql /run/mysqld

Fichier de configuration `supervisord.conf`

Le fichier principal de configuration supervisord.conf inclut les paramètres globaux pour Supervisor et référence les fichiers spécifiques à MySQL et Redis.

[supervisord]
nodaemon=true
logfile=/var/log/supervisord.log
pidfile=/var/run/supervisord.pid
childlogdir=/var/log/supervisor

[unix_http_server]
file=/tmp/supervisor.sock
chmod=0755

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock

[include]
files = /etc/supervisor.d/*.ini

Fichier `mysql.ini`

Ce fichier configure Supervisor pour gérer MySQL et s’assure que le script d’initialisation s’exécute avant que MySQL ne démarre.

[program:mysql]
command=/usr/local/bin/init-mysql.sh && /usr/bin/mysqld --user=mysql --datadir=/var/lib/mysql --pid-file=/run/mysqld/mysqld.pid
autostart=true
autorestart=true
startsecs=10
startretries=5
stdout_logfile=/var/log/mysql.log
stderr_logfile=/var/log/mysql.err.log
user=mysql

Fichier `redis.ini`

Ce fichier configure Supervisor pour gérer Redis.

[program:redis]
command=/usr/bin/redis-server
autostart=true
autorestart=true
stdout_logfile=/var/log/redis.log
stderr_logfile=/var/log/redis.err.log

Construction et exécution du conteneur

Construire l’image Docker :

Depuis le répertoire contenant ton Dockerfile et les fichiers de configuration, exécute cette commande pour construire l’image :
Terminal window
```
docker build -t my-supervisor-container .
```
Exécuter le conteneur :

Une fois l’image construite, tu peux lancer le conteneur avec la commande suivante :
Terminal window
```
docker run -d -p 3306:3306 -p 6379:6379 --name supervisor-container my-supervisor-container
```
Vérifier les logs :

Pour t’assurer que tout fonctionne correctement, vérifie les logs de MySQL et Redis :
Terminal window
```
docker exec -it supervisor-container sh
tail -f /var/log/mysql.log
tail -f /var/log/redis.log
```

L’interface Web de Supervisor

L’interface web de Supervisor te permet de gérer visuellement les processus supervisés. Voici comment l’ajouter à ton conteneur Docker.

Modifier le fichier de configuration supervisord.conf pour inclure la section suivante :

[inet_http_server]
port=*:9001           ; Expose l'interface sur le port 9001
username=admin        ; Optionnel : ajouter un nom d'utilisateur
password=adminpass    ; Optionnel : ajouter un mot de passe

Expose le port 9001 dans le Dockerfile :

EXPOSE 9001

Une fois les modifications effectuées, reconstruis et redémarre ton conteneur. Tu pourras alors accéder à l’interface web à l’URL suivante :

http://<adresse_ip_du_serveur>:9001

Conclusion

Démarrer plusieurs services dans un même conteneur via Supervisor peut être utile dans certains scénarios spécifiques, comme des environnements de développement ou des déploiements légers. Cependant, cela va à l’encontre des meilleures pratiques de conteneurisation, qui recommandent un service par conteneur pour faciliter l’isolation et la gestion.

Cela dit, Supervisor peut aussi être très utile en dehors des conteneurs pour gérer des services sur des serveurs classiques. Comparé à systemd, Supervisor offre une gestion plus simple des processus, notamment pour redémarrer automatiquement les services en cas de panne, surveiller les logs, et gérer plusieurs services de manière centralisée. Dans des environnements où la configuration et la gestion de services doivent être simples, Supervisor est une alternative plus légère et accessible que systemd pour des projets qui ne nécessitent pas la complexité et la granularité de ce dernier.