Surveiller son système avec Monit

Une des choses importantes dont on a besoin une fois qu’on a un petit système informatique et domotique à la maison, c’est d’avoir un bon niveau de disponibilité. Rien de plus désagréable que de se retrouver à des kilomètres de chez soi et de ne plus pouvoir prendre la main sur son système.

Alors, pour améliorer la disponibilité, ou au minimum être alerté quand quelque chose ne tourne pas rond, on doit mettre en œuvre de la surveillance et des alertes. Et pour faire ça, j’ai trouvé un petit soft vraiment, vraiment bien fichu qui s’appelle Monit. Nous allons voir comment l’installer et le configurer.

Monit est donc un petit utilitaire Open Source qui tourne sur les plateformes Unix. Ça tombe bien, la plupart des systèmes d’exploitation tournant sur les Raspberry Pi ont l’insigne honneur de faire partie de cette belle famille.

Monit va permettre de surveiller tout un tas de choses de manière très fine, et d’agir lorsque certaines conditions définies par nos soins sont remplies. L’utilitaire est léger, robuste, tourne en tâche de fond (daemon Unix) et embarque même une interface de visualisation web, minimaliste, mais très pratique.

Monit peut surveiller les types d’objet suivants:

  • les processus
  • les fichiers et répertoires
  • les ressources et services accessibles sur le réseau
  • l’exécution d’un programme et son code d’erreur de sortie
  • le système local (CPU, mémoire, espace disque etc…)

Ensuite, pour chaque objet surveillé, il est possible de définir un certain nombre de conditions à remplir qui déclenchent une action. Les actions définies sont non exclusives: on peut les cumuler pour chaque condition remplie, sur chaque objet surveillé.

Les actions possibles sont :

  • alerter par e-mail
  • redémarrer un processus
  • arrêter un processus
  • exécuter un programme arbitraire
  • stopper la surveillance

Les combinaisons sont donc nombreuses, paramétrables de manière assez fine, et configurables dans autant de petits fichiers de configuration. La page de manuel est très bien faite, avec plein d’exemples.

Mais passons aux choses sérieuses et concrètes.

Installation de Monit


Sur la page de l’auteur, on trouve le code source, mais également des binaires pour différentes plateforme. Pour le Raspberry Pi, on prendra la version Linux-Arm. On télécharge l’archive, on la décompresse et on se place dans le répertoire obtenu:

pi@raspberrypi ~ $ wget http://mmonit.com/monit/dist/binary/5.12.2/monit-5.12.2-linux-arm.tar.gz
pi@raspberrypi ~ $ tar -zxf monit-5.12.2-linux-arm.tar.gz
pi@raspberrypi ~ $ cd monit-5.12.2
pi@raspberrypi ~/monit-5.12.2 $

Regardons le contenu du répertoire:

pi@raspberrypi ~/monit-5.12.2 $ ls -la
total 56
drwxr-xr-x  5 pi pi  4096 Mar 20 10:23 .
drwxr-xr-x 14 pi pi  4096 Mar 26 21:28 ..
drwxr-xr-x  2 pi pi  4096 Mar 20 10:23 bin
drwxr-xr-x  2 pi pi  4096 Mar 20 10:23 conf
-rw-r--r--  1 pi pi 34940 Mar 20 10:23 COPYING
drwxr-xr-x  3 pi pi  4096 Mar 20 10:23 man

Il n’y a pas de script d’installation, il faut donc tout faire à la main, mais heureusement rien de bien compliqué. On se place bien dans le répertoire contenant tout le package.

1. Installation du binaire:

pi@raspberrypi ~/monit-5.12.2 $ sudo cp bin/monit /usr/sbin
pi@raspberrypi ~/monit-5.12.2 $ sudo chown root:root /usr/sbin/monit

 2. Installation de la man page :

pi@raspberrypi ~/monit-5.12.2 $ sudo cp man/man1/monit.1 /usr/share/man/man1

 3. Installation du fichier de configuration maître par défaut, et création du répertoire qui contiendra nos définitions de fichier de surveillance :

pi@raspberrypi ~/monit-5.12.2 $ sudo cp conf/monitrc /etc
pi@raspberrypi ~/monit-5.12.2 $ sudo chown root:root /etc/monitrc
pi@raspberrypi ~/monit-5.12.2 $ sudo mkdir /etc/monit.d

4. Ensuite, on crée un petit script qui va permettre de lancer Monit automatiquement au démarrage du système :

pi@raspberrypi ~ $ sudo nano /etc/init.d/monit

On tape le code suivant, que j’ai légèrement adapté (simplifié) par rapport au script initial fourni par les deux auteurs:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          monit
# Required-Start:    $remote_fs
# Required-Stop:     $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: service and resource monitoring daemon
### END INIT INFO
# /etc/init.d/monit start and stop monit daemon monitor process.
# Fredrik Steen, stone@debian.org
# Stefan Alfredsson, alfs@debian.org
 
PATH=/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/sbin/monit
CONFIG="/etc/monitrc"
NAME=monit
DESC="Monit Daemon"
 
# Check if DAEMON binary exist
test -f $DAEMON || exit 0
 
if [ -f "/etc/default/monit" ]; then
     . /etc/default/monit
fi
 
monit_not_configured () {
    printf "%b\n" "monit won't be started/stopped\n\tunless it it's configured"
    if [ "$1" != "stop" ]
        then
        printf "%b\n" "\tplease configure monit and then edit /etc/default/monit"
        printf "%b\n" "\tand set the \"startup\" variable to 1 in order to allow "
        printf "%b\n" "\tmonit to start"
    fi
    exit 0
}
 
monit_check_config () {
    # Check for emtpy config, probably default configfile.
    if [ "`grep -s -v \"^#\" $CONFIG`" = "" ]; then
        echo "empty config, please edit $CONFIG."
        exit 0
    fi
}
 
monit_check_perms () {
    # Check the permission on configfile.
    # The permission must not have more than -rwx------ (0700) permissions.
 
    # Skip checking, fix perms instead.
    /bin/chmod go-rwx $CONFIG
 
}
 
monit_check_syntax () {
  $DAEMON -c $CONFIG -t 2>/dev/null >/dev/null
  if [ $? -eq 1 ] ; then
      echo "Syntax error:"
                $DAEMON -t
                exit 0
  fi
}

monit_checks () {
    # Check if startup variable is set to 1, if not we exit.
    if [ "$startup" != "1" ]; then
        monit_not_configured $1
    fi
    # Check for emtpy configfile
    monit_check_config
    # Check permissions of configfile
    monit_check_perms
         # Check syntax of config file
    monit_check_syntax
}
 
case "$1" in
  start)
        echo -n "Starting $DESC: "
        monit_checks
        echo -n "$NAME"
        $DAEMON > /dev/null 2>&1
        echo "."
        ;;
  stop)
        echo -n "Stopping $DESC: "
        #monit_checks $1
        echo -n "$NAME"
        $DAEMON quit > /dev/null 2>&1
        echo "."
        ;;
  restart|force-reload)
        $0 stop
        $0 start
        ;;
  syntax)
   monit_check_syntax
   ;;
  *)
        N=/etc/init.d/$NAME
        echo "Usage: $N {start|stop|restart|force-reload|syntax}" >&2
        exit 1
        ;;
esac
 
exit 0

Vous pouvez télécharger ce script directement depuis ce lien.

Il faut ensuite donner les droits d’exécution au script, et l’ajouter au système de démarrage automatique des services:

pi@raspberrypi ~ $ sudo chmod a+x /etc/init.d/monit
pi@raspberrypi ~ $ sudo update-rc.d monit defaults

On doit créer un petit fichier qui indique au script qu’on souhaite bien activer le lancement de Monit à chaque démarrage du système :

pi@raspberrypi ~ $ sudo nano /etc/default/monit

et y entrer simplement la ligne suivante:

startup=1

5. Pour finir, il ne reste plus qu’à démarrer Monit :

pi@raspberrypi ~ $ sudo service monit start

Et voilà pour l’installation manuelle !

Configuration de Monit


La configuration de Monit se fait:

  • via le fichier principal « /etc/monitrc » , qui contient l’ensemble de la configuration de base
  • et par autant de fichiers de configuration, en général un par service, contenu dans le répertoire « /etc/monit-d/ ». Ces fichiers sont automatiquement lus par Monit au démarrage.

A titre d’exemple, je vous propose de voir la configuration de Monit que j’utilise sur mon RPi frontal (voir l’article de présentation de mon environnement pour rappel).

Configuration du fichier monitrc

Le chemin du fichier de configuration principale est /etc/monitrc. Pour des raisons de sécurité, des droits d’accès très strict sont posés sur ce fichier, seul le compte root peut le lire et le modifier :

-rw------- 1 root root 10989 Feb  4 15:49 /etc/monitrc

A moins de vouloir tout personnaliser, seuls quelques paramètres sont à modifier dans ce fichier :

1. La période (le cycle) de surveillance, en secondes: c’est la période à laquelle le service Monit va effectuer toutes les vérifications configurées.

set daemon 60

2. Le serveur SMTP utilisé pour émettre les e-mails d’alertes: il s’agit normalement du serveur SMTP de votre fournisseur d’accès à internet, mais vous pouvez en mettre un autre.

set mailserver smtp.free.fr

3.  Il est possible de définir complètement le modèle d’e-mail d’alerte qui sera envoyé. Entre autre chose, on peut spécifier l’adresse de l’expéditeur.

set mail-format { from: arno0x0x@free.fr }

4. L’adresse e-mail du destinataire des alertes e-mails doit être définie.

set alert arno0x0x@gmail.com

5. Le serveur web minimaliste embarqué dans le service Monit peut être configuré pour limiter les accès, définir des utilisateurs, et activer une authentification simple en définissant un couple utilisateur/mot-de-passe. Ici, je n’autorise qu’un accès local à l’interface web (localhost) et un seul utilisateur ayant les droits d’accès.

set httpd port 2812 and
    use address localhost          # only accept connection from localhost
    allow localhost                    # allow localhost to connect to the server and
    allow arno:"mypassword"    # require user 'arno' with password 'mypassword'

 Configuration de la surveillance

Il est maintenant temps d’indiquer à Monit ce qu’il doit surveiller exactement, et les actions qu’il doit prendre en fonction des différents cas de figures. On va donc créer autant de petits fichiers de configuration que de services à surveiller, dans le répertoire « /etc/monit.d/ ».

1. Surveillance du serveur web Nginx

Créer un fichier « /etc/monit.d/nginx.conf » et entrer les lignes suivantes :

check process nginx with pidfile /var/run/nginx.pid
        start program = "/etc/init.d/nginx start" with timeout 60 seconds
        stop program  = "/etc/init.d/nginx stop"
        if cpu > 60% for 2 cycles then alert
        if cpu > 80% for 5 cycles then restart
        if totalmem > 200.0 MB for 5 cycles then restart
        if children > 250 then restart
        if loadavg(5min) greater than 10 for 8 cycles then stop
        if failed
                host localhost
                port 443
                type tcpssl
                with timeout 15 seconds
        then restart
        if 3 restarts within 5 cycles then timeout

Explications: on surveille le processus nginx dont le pid (process id = numéro de process) se trouve, par défaut, dans le fichier « /var/run/nginx.pid ». Puis on spécifie les deux commandes qui permettent de démarrer et d’arrêter le serveur nginx, avec un timeout de 60s pour le démarrage. Ensuite, on définit les tests sur ce processus :

  • Si le CPU consommé par le processus est supérieur à 60% pendant 2 cycles (1 cycle = 60s comme définit dans le fichier monitrc), Monit nous alerte (par e-mail)
  • Si le CPU consommé par le processus est supérieur à 80% pendant 5 cycles, alors on redémarre le serveur nginx
  • Si la mémoire consommée par le processus est supérieure à 200MB pendant 5 cycles, alors on redémarre le serveur nginx
  • Si le nombre de processus fils est supérieur à 250, alors on redémarre le serveur nginx
  • Si la charge moyenne du système sur 5 minutes est supérieure à 10 pendant 8 cycles, alors on arrête le serveur nginx
  • Si la connexion SSL sur le port 443 du serveur local (localhost) échoue, avec un timeout de 15s, alors on redémarre le serveur nginx
  • S’il y a eu 3 redémarrage en 5 cycle, alors on génère un évènement système de timeout

2. Surveillance de PHP5

Créer un fichier « /etc/monit.d/php5.conf », et entrer les lignes suivantes:

check process php5 with pidfile /var/run/php5-fpm.pid
        start program = "/etc/init.d/php5-fpm start" with timeout 60 seconds
        stop program  = "/etc/init.d/php5-fpm stop"
        if cpu > 60% for 2 cycles then alert
        if cpu > 80% for 5 cycles then restart
        if totalmem > 200.0 MB for 5 cycles then restart
        if children > 250 then restart
        if loadavg(5min) greater than 10 for 8 cycles then stop
        if 3 restarts within 5 cycles then timeout

Les explications de cette configuration sont similaires à celles de la surveillance de nginx.

3. Surveillance de la connexion au DomoPi

Si vous avez bien suivi mes articles précédents, vous savez que dans mon installation maison, le RPi frontal communique avec le DomoPi sur le port TCP/6868.  Il est possible de surveiller que cette connexion entre les deux RPi est toujours opérationnelle.

Créer un fichier « /etc/monit.d/domopi.conf », et entrer les lignes suivantes :

check host domopi with address 192.168.0.10
        if failed port 6868 then alert

Explications: on surveille le système appelé « domopi » accessible sur l’adresse IP 192.168.0.10. Ensuite, on définit les tests sur ce processus :

  • Si la connexion TCP sur le port 6868 (timeout par défaut) est en échec, alors on envoie un e-mail d’alerte.

Avec ces quelques exemples, vous avez compris ce qu’il est possible de faire avec Monit. J’ai créé plusieurs autres fichiers de définition de surveillance pour les processus de gateone, fail2ban (voir l’article sur les packages de base de mon installation) et également sur la connexion à la webcam.

Une fois tous les fichiers de configuration créés, on peut vérifier que la syntaxe est correcte, puis on indique à Monit de relire ses fichiers de configuration :

pi@raspberrypi ~ $ sudo monit -t
Control file syntax OK

pi@raspberrypi ~ $ sudo monit reload
Reinitializing monit daemon

Configuration de Nginx


Plutôt que d’exposer le service web de Monit (son port TCP/2812) sur internet, et avoir à configurer une nouvelle redirection de port (voir cet article sur la configuration réseau), il est plus simple de demander au serveur web Nginx de jouer le rôle de proxy inversé pour ce service. Ca présente l’avantage de laisser uniquement Nginx en frontal, et le laisser gérer la connexion sécurisée SSL avec les clients.

Il faut donc modifier le fichier de configuration correspondant au site, dans le répertoire « /etc/nginx/sites-available », et rajouter le bloc de définition suivant, sous la directive « server » du fichier:

location /monit/ {
                auth_basic off;
                proxy_pass_header Server;
                proxy_set_header Host $http_host;
                proxy_redirect off;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Scheme $scheme;
                proxy_pass http://127.0.0.1:2812/;
        }

Explications: on crée un nouveau répertoire virtuel « /monit/ » sur notre site web qui pointe sur le serveur web intégré à Monit, en écoute sur le port TCP/2812 comme préalablement configuré dans le fichier /etc/monitrc. Comme Nginx et Monit tournent sur le même système, on peut utiliser l’adresse « 127.0.0.1 ».

On redémarre le serveur Nginx:

pi@raspberrypi ~ $ sudo service nginx restart

Résultats


Après tous ces efforts, on se connecte à l’interface web de Monit via l’URL du site web servi par Nginx. Tout dépend de votre installation et de votre adressage IP, mais dans mon cas, le RPi frontal est accessible sur l’IP 192.168.0.9.

L’URL d’accès à Monit sera donc https://192.168.0.9/monit/, on s’authentifie avec les identifiants spécifiés dans le fichier « /etc/monitrc » et voilà le résultat:

Il est possible de cliquer sur chacun des objets (process, host, system) ce qui permet :

  • de voir le détail de la configuration de surveillance
  • de voir le dernier statut
  • d’arrêter/redémarrer les processus
  • d’arrêter/relancer la surveillance

Et voilà ! Monit est capable de faire tant d’autres choses de manières fines, je vous encourage à consulter le manuel qui est très complet et très bien fait.

J’aurai l’occasion de revenir, dans un futur article, sur une autre configuration de Monit, pour le DomoPi, où l’on verra alors la possibilité de tenter de restaurer un service parti dans les choux. A bientôt !

Vous aimez cet article ? Faites le savoir avec quelques bitcoins !

Publicités

Une réflexion sur “Surveiller son système avec Monit

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s