Monit : Alerter et Réagir en cas de panne

Cette page est considérée comme vétuste et ne contient plus d'informations utiles.
Apportez votre aide…

administration, systeme, serveur, vétuste

monit est un outil de surveillance de services locaux. Il vérifie la disponibilité des *daemons* présents sur le serveur qui l'accueille. En cas de panne, monit peut alerter l'administrateur du système.

monit peut comme d'autres solutions similaires (Zabbix, Nagios) déclencher des actions pour tenter de rétablir un service interrompu, comme par exemple relancer un serveur Apache si il ne répond plus ou vider la file d'attente d'un serveur Postfix en cas d'engorgement.

monit est un logiciel à la fois simple et puissant. À utiliser avec précautions !

Quelques infos :

Licence : GPL
Site officiel : http://www.tildeslash.com/monit/

Une solution de gestion distribuée de monit, appelée m/monit permet de superviser à distance de multiples instances monit, c'est-à-dire les administrer et centraliser des informations historiques et statistiques envoyées par chaque instance monit gérée.

L'installation est très simple :

$ apt-get install monit

Le paquet se trouve dans le dépôt Universe

Dans premier temps, il convient d'éditer la configuration pour définir les paramètres généraux du démon monit. La configuration des services surveillés sera abordée dans la partie suivante.

Éditer le fichier /etc/monit/monitrc. afin d'obtenir les options suivantes :

 set daemon  60
 set logfile syslog facility log_daemon
 set mailserver localhost
 set mail-format { from: monit@serveurdev.example.com }
 set alert root@localhost
 set httpd port 2812 and
    SSL ENABLE
    PEMFILE  /var/certs/monit.pem
    allow admin:test

L'instruction set daemon permet de définir la durée d'un "cycle" monit. Un cycle correspond à l'intervalle (en secondes) entre deux vérifications.

Cette configuration active le serveur web (https) de monit sur le port 2812. L'utilisateur est admin et son mot de passe est test. Les messages d'alertes sont envoyés à root@localhost.

Le fichier de configuration est très clair et il est relativement simple de modifier le comportement du *daemon* de surveillance.

Il faut ensuite engendrer un certificat SSL. Tout d'abord créer le répertoire qui accueillera le certificat :

$ mkdir /var/certs
$ cd /var/certs

Puis définir les options du certificat :

 vi /var/certs/monit.cnf

   # create RSA certs - Server
   RANDFILE = ./openssl.rnd
   [ req ]
   default_bits = 1024
   encrypt_key = yes
   distinguished_name = req_dn
   x509_extensions = cert_type
   [ req_dn ]
   countryName = Country Name (2 letter code)
   countryName_default = MO
   stateOrProvinceName    = Ile de France
   stateOrProvinceName_default     = Monitoria
   localityName                    = Paris
   localityName_default            = Monittown
   organizationName                = the_company
   organizationName_default        = Monit Inc.
   organizationalUnitName          = Organizational Unit Name
   organizationalUnitName_default  = Dept. of Monitoring Technologies
   commonName                      = Common Name (FQDN of your server)
   commonName_default              = server.monit.mo
   emailAddress                    = Email Address
   emailAddress_default            = root@monit.mo
   [ cert_type ]
   nsCertType = server

Puis procéder à la génération du certificat :

   $ openssl req -new -x509 -days 365 -nodes -config ./monit.cnf -out /var/certs/monit.pem -keyout /var/certs/monit.pem
   $ openssl gendh 512 >> /var/certs/monit.pem
   $ openssl x509 -subject -dates -fingerprint -noout -in /var/certs/monit.pem
   $ chmod 700 /var/certs/monit.pem

Dans un environnement de développement, la sécurisation par SSL peut ne pas être nécessaire, on peut donc avantageusement remplacer la procédure ci-dessus par les lignes :

   set httpd port 2812 and
   allow admin:monit

L'étape suivante consiste à activer le *daemon* par défaut et définir la fréquence de surveillance (ici : 60 secondes). Pour cela on édite le fichier /etc/default/monit :

   startup=1
   CHECK_INTERVALS=60

Il ne reste plus qu'à démarrer monit :

   $ /etc/init.d/monit start

Vérifier que le *daemon* est activé, en se connectant à l'adresse : ::

   http://serveurdev.exemple.fr:2812/

Pour surveiller un service donné, il suffit d'éditer le fichier monitrc et de spécifier :

le fichier PID du service,
les commandes de démarrage et d'arrêt du service,
l'utilisateur système du service,
la condition de test à effectuer,
le(s) commande(s) à effectuer lorsque le test est positif.

Par exemple, voici comment redémarrer automatiquement le serveur SSH s'il ne répond plus : ::

     check process sshd with pidfile /var/run/sshd.pid
           start program  "/etc/init.d/ssh start"
           stop program  "/etc/init.d/ssh stop"
           if failed port 22 protocol ssh then restart
           if 5 restarts within 5 cycles then timeout

La dernière ligne permet d'éviter des boucles infinies, notamment si la configuration du serveur SSH est erronée.

Bien sûr il est possible de configurer des traitements d'erreurs plus fins. Voici par exemple, une politique de surveillance d'Apache : ::

      check process apache with pidfile /var/run/apache2.pid group www
        start program = "/etc/init.d/apache2 start"
        stop program = "/etc/init.d/apache2 stop"
        if failed host www.example.com port 80 protocol http
           and request "/monit/token" then restart
        if  cpu is greater than 60% for 2 cycles then alert
        if cpu > 80%  for 5 cycles then restart
        if totalmem > 500 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

Dans cet exemple, monit vérifiera la présence d'un fichier monit/token sur le serveur. En cas d'absence le serveur sera redémarré.

On note également qu'une alerte par courriel sera envoyé dès qu'Apache utilisera plus de 60% des capacités du ou des processeurs.