Concevoir facilement un plugin Nagios en Perl

djibril

Ce tutoriel a pour but de vous expliquer en quelques lignes comment concevoir un plugin Nagios respectant les normes Nagios avec Perl.
Commentez

- Titre : Concevoir facilement un plugin Nagios en Perl

- Auteur : djibril

- Parution : 5 mars 2011

- Mise à jour : 21 décembre 2014

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2017 djibril. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Voir également :

- Installation et configuration de Nagios pour débutants

Sommaire

- I. Introduction

- II. Plugins Nagios

- II-A. Qu'est-ce que Nagios ?

- II-B. Qu'est-ce qu'un plugin Nagios ?

- II-C. Fonctionnement d'un plugin Nagios

- II-D. Plugin Nagios en Perl

- II-D-1. Méthode simple

- II-D-2. Méthode propre

- II-D-2-a. Plugin 1 - check_file_exist

- II-D-2-b. Plugin 2 - check_file_size

- II-D-2-c. Plugin 3 - check_process

- III. Références utilisées

- IV. Conclusion

- V. Remerciement

I - Introduction

Nagios est un logiciel open source de supervision. Il existe plusieurs logiciels se basant sur lui pour superviser un réseau informatique. Pour avoir plus d'informations sur son utilisation ou installation, vous pouvez vous référer à ce tutoriel - Installation et configuration de Nagios pour débutants. Nagios étant assez configurable, il donne la possibilité de créer ses propres programmes (plugins) afin de tester le bon fonctionnement d'un serveur, d'un matériel, d'un service. Ce tutoriel vous expliquera comment concevoir un tel programme en utilisant le langage Perl.

II - Plugins Nagios

II-A - Qu'est-ce que Nagios ?

Comme expliqué ci-dessus, Nagios est un outil de supervision. Mais si vous lisez cet article, nous supposons que vous connaissez déjà cet outil et de ce fait, nous ne rentrerons pas dans les détails de son mode de fonctionnement.

II-B - Qu'est-ce qu'un plugin Nagios ?

Les plugins Nagios sont des programmes compilés (écrits en C, C++…) ou des scripts (écrits en Perl, Shell…), ou tout autre langage de programmation pouvant s'exécuter en ligne de commande. Ils permettent de vérifier l'existence ou l'état d'un service, l'état d'un serveur… puis génèrent un résultat que Nagios exploite pour effectuer une action de notifications, pour exécuter des gestionnaires d'événements, etc. L'avantage est de superviser tout ce que l'on veut du moment que l'on peut écrire le plugin : un service HTTP, FTP, la taille d'un répertoire, l'existence d'un fichier sur un serveur, la température d'un onduleur…

Lorsque vous installez Nagios, il vous est également demandé d'installer des plugins, qui vous permettent d'effectuer certaines tâches. Sachez qu'il existe d'autres sites qui proposent des plugins Nagios gratuits.

II-C - Fonctionnement d'un plugin Nagios

Tout plugin Nagios doit retourner au moins une ligne de texte (1) sur la sortie standard STDOUT et renvoyer un code de retour compris entre 0 et 3.

Nagios ne s'intéresse pas au contenu d'un plugin, il ne se base que sur les informations (code de retour, texte) qu'il a reçues pour déduire le bon fonctionnement de l'hôte ou du service que vous surveillez. Voici comment Nagios interprète ce code de retour.

Explication des codes retour

Code de retour du plugin

Etat du service

Etat de l'hôte

0

OK (tout va bien)

UP

1

WARNING (le seuil d'alerte est dépassé)

UP ou DOWN/UNREACHABLE (2)

2

CRITICAL (le service a un problème)

DOWN/UNREACHABLE

3

UNKNOWN (impossible de connaître l'état du service)

DOWN/UNREACHABLE

Vous comprenez maintenant pourquoi il est simple de concevoir un plugin , les règles à respecter sont : simplicité, efficacité et légèreté. Le texte retourné doit être court (car il y a une restriction de longueur (3)) mais explicatif. Voici un exemple de lignes de sortie issu de la documentation officielle.

- DISK OK - free space: / 3326 MB (56%);

- DISK OK - free space: / 3326 MB (56%); | /=2643MB;5948;5958;0;5968

La sortie doit être de type $SERVICEOUTPUT$. Pour en savoir plus, consulter la documentation officielle.

II-D - Plugin Nagios en Perl

Entrons dans le vif du sujet !! Il est plus simple de comprendre en utilisant un exemple.
Nous avons à notre disposition deux serveurs :

- le premier nommé « gendarme »qui, comme vous l'aurez compris, a pour but de superviser le second serveur ;

- le deuxième nommé « suspect » qui sera notre serveur à surveiller ;

Ecrivons 3 plugins dont les rôles seront les suivants :

1. vérifier l'existence d'un fichier suspect ;

2. vérifier qu'un fichier ne dépasse pas une taille fixée ;

3. vérifier qu'un processus quelconque tourne bien sur le serveur « suspect ».

La surveillance pourrait se faire localement, le principe est le même. Parlons maintenant Perl. Un programme Perl minimal doit toujours contenir ces quelques lignes de code :

#!/usr/bin/perl
#===============================================================================
# Auteur : djibril
# Date   : 02/03/2011 22:42:13
# But    : Exemple de plugin Nagios
#===============================================================================
use strict;
use warnings;

__END__

Nous allons maintenant utiliser deux méthodes pour écrire nos plugins.

II-D-1 - Méthode simple

Pour illustrer un exemple de méthode simple, créons un premier plugin avec pour nom check_file_exist. Son but est de vérifier qu'un fichier passé en argument est toujours présent sur le serveur distant « suspect ». Si oui, tout est OK, si non, Nagios doit générer une erreur critique et nous alerter. Ce plugin retournera (vous l'aurez compris), la valeur 0 ou 2. Voici notre programme :

#===============================================================================
# Auteur : djibril
# Date   : 04/03/2011 09:16:24
# But    : Plugin vérifiant l'existence d'un fichier
#===============================================================================
use strict;
use warnings;
use Getopt::Long;
use File::Basename;

my ( $fichier_a_verifier ) = ();
GetOptions( 'file|f=s' => \$fichier_a_verifier );
if ( not defined $fichier_a_verifier ) {
print "Il manque l'argument --file ou -f\n";
exit 0;
}

my $NOM_PROCESS = 'CheckFileExiste';
my $nom_fichier = basename  $fichier_a_verifier;
# Vérification de l'existence du fichier
if ( -e $fichier_a_verifier ) {
print "$NOM_PROCESS OK - $nom_fichier exists";
exit 0;
}
else {
print "$NOM_PROCESS CRITICAL - $nom_fichier not exists";
exit 2;
}

__END__

On remarque sa simplicité. Il vérifie l'existence d'un fichier et retourne une phrase ainsi qu'un code retour. Pour le tester nous allons nommer ce plugin check_file_exist (sans l'extension .pl, mais on peut la garder). Nous le mettons sur le serveur « suspect » dans le répertoire /usr/local/nagios/libexec (nous supposons que vous avez installé NRPE et les plugins Nagios sur le serveur), le rendons exécutable (chmod +x /usr/local/nagios/libexec/check_file_exist). Voici un test en ligne de commande.

suspect # /usr/local/nagios/libexec/check_file_exist -f /home/toto
CheckFileExiste CRITICAL - toto not exists
suspect # echo $?
2

Le programme fonctionne bien. Nous avons testé l'existence du fichier /home/toto et il n'a pas été trouvé. Un code retour de 2 a bien été retourné. Essayons de le tester depuis le serveur « gendarme » comme le ferait Nagios via NRPE.
Pour cela, sur le serveur « suspect », modifions le fichier /usr/local/nagios/nrpe.cfg et rajoutons la ligne

nrpe.cfg

command[check_file_exist]=/usr/local/nagios/libexec/check_file_exist -f $ARG1$

Nagios appellera le programme avec l'argument -f. Depuis le serveur « gendarme », nous pouvons lancer la ligne de commande suivante :

/usr/local/nagios/libexec/check_nrpe -n -H suspect_ou_IP_suspect -c check_file_exist -a /home/toto
CheckFileExiste CRITICAL - toto not exists

ou

CheckFileExiste OK - toto exists

Nous avons pu constater que nous arrivons à tester ce programme à distance comme l'aurait fait Nagios. Pour un fonctionnement depuis l'interface Nagios, il suffit de définir un nouveau service dans le fichier de configuration de Nagios permettant de surveiller l'hôte « suspect ». Par exemple :

suspect.cfg

define service{
use                     generic-service
host_name               suspect
service_description     TEST
check_command           check_nrpe!check_file_exist!/home/djibril/.xtalkrc
}

Dans notre interface Nagios, nous obtenons ceci :

En cas d'échec :

Génial non ? Bon, ce programme Perl est vraiment très très simple, je dirais même trop simple. Nous allons voir maintenant comment ré-écrire ce même programme de façon plus propre car ce dernier présente quand même quelques inconvénients !!

II-D-2 - Méthode propre

Nous avons vu dans l'exemple ci-dessus qu'il est assez facile d'écrire un petit programme fonctionnel, mais ce dernier contient quelques petits défauts :

- la gestion des arguments est faite mais peut être améliorée ;

- le code n'a pas de version ;

- il ne contient aucune documentation pour son usage ;

- un bon plugin doit être capable de fournir une aide via l'option --help ;

- la gestion du type de sortie de code retour est un peu brute et ne rend pas le programme lisible et maintenable facilement, même si ce dernier est assez simple ;

- de plus, si vous avez lu d'autres documentations de Perl et les plugins Nagios, il est souvent demandé d'exporter des variables (pour la gestion des codes retour), ce que nous n'avons pas fait ici.

Un module CPAN permet de générer facilement des plugins Nagios Perl propres : c'est le module Monitoring::Plugin. Il respecte toutes les recommandations du Nagios Plugin guidelines. Vous devez l'installer (4) sur le serveur qui contiendra le plugin.

II-D-2-a - Plugin 1 - check_file_exist

Reprenons notre code minimal Perl, chargeons le module et définissons une version pour notre plugin.

#!/usr/bin/perl
#===============================================================================
# Auteur : djibril
# Date   : 03/03/2011 20:49:03
# But    : Exemple de plugin Nagios
#===============================================================================
use strict;
use warnings;
use Monitoring::Plugin; # Chargement du module

use vars qw/ $VERSION /; # Version du plugin
$VERSION = '1.0';

__END__

Créons notre constructeur Monitoring::Plugin en lui spécifiant le nom de notre process, son usage, la version du programme et éventuellement une licence.

my $LICENCE
= "Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance."
. ' Il est livré avec ABSOLUMENT AUCUNE GARANTIE.';

my $plugin_nagios = Monitoring::Plugin->new(
shortname => 'Check bank file',
usage     => 'Usage : %s',
version   => $VERSION,
license   => $LICENCE,
);

Définissons les arguments que l'on souhaite lire. Dans notre cas, nous voulons récupérer le fichier à tester via l'option -f ou --file. Il faut utiliser la méthode add_arg.

# Définition de l'argument --file ou -f pour récupérer le fichier
$plugin_nagios->add_arg(
spec     => 'file|f=s',         # =s pour string
help     => 'file to check',    # Aide au sujet de cette option
required => 1,                  # Argument obligatoire
);

Activons l'analyse des arguments du programme (--help, -V, -f…).

# Activer le parsing des options de ligne de commande
$plugin_nagios->getopts;

Maintenant, nous pouvons effectuer notre test sur le fichier !

my $fichier_a_verifier = $plugin_nagios->opts->file;
my $nom_fichier        = basename $fichier_a_verifier;

# Vérification de l'existence du fichier
if ( $plugin_nagios->opts->verbose ) { print "Test du fichier $nom_fichier\n"; }
if ( -e $fichier_a_verifier ) {
if ( $plugin_nagios->opts->verbose ) { print "Fichier existant\n"; }
$plugin_nagios->plugin_exit( OK, "$nom_fichier exists" );
}
else {
if ( $plugin_nagios->opts->verbose ) { print "Fichier inexistant\n"; }
$plugin_nagios->plugin_exit( CRITICAL, "$nom_fichier not exists" );
}

La méthode plugin_exit permet de sortir du programme avec le code retour et notre message au format Nagios. Vous avez remarqué que nous avons rajouté des print en testant les méthodes opts->verbose. En fait, cette subtilité permet de faire un débogage si besoin. Si vous exécutez le programme avec l'option -v, vous aurez l'affichage des print. Voici notre programme final :

#!/usr/bin/perl
#===============================================================================
# Auteur : djibril
# Date   : 04/03/2011 09:16:24
# But    : Plugin vérifiant l'existence d'un fichier
#===============================================================================
use strict;
use warnings;

# Chargement du module
use Monitoring::Plugin;
use File::Basename;

use vars qw/ $VERSION /;

# Version du plugin
$VERSION = '1.0';

my $LICENCE
= "Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance."
. ' Il est livré avec ABSOLUMENT AUCUNE GARANTIE.';

my $plugin_nagios = Monitoring::Plugin->new(
shortname => 'Verification fichier',
usage     => 'Usage : %s [-f <file> ou --file <file>]',
version   => $VERSION,
license   => $LICENCE,
);

# Définition de l'argument --file ou -f pour récupérer le fichier
$plugin_nagios->add_arg(
spec     => 'file|f=s',
help     => 'file to check',    # Aide au sujet de cette option
required => 1,                  # Argument obligatoire
);

# Activer le parsing des options de ligne de commande
$plugin_nagios->getopts;

my $fichier_a_verifier = $plugin_nagios->opts->file;
my $nom_fichier        = basename $fichier_a_verifier;

# Vérification de l'existence du fichier
if ( $plugin_nagios->opts->verbose ) { print "Test du fichier $nom_fichier\n"; }
if ( -e $fichier_a_verifier ) {
if ( $plugin_nagios->opts->verbose ) { print "Fichier existant\n"; }
$plugin_nagios->plugin_exit( OK, "$nom_fichier exists" );
}
else {
if ( $plugin_nagios->opts->verbose ) { print "Fichier inexistant\n"; }
$plugin_nagios->plugin_exit( CRITICAL, "$nom_fichier not exists" );
}
__END__

Avec ces quelques lignes de code simples et claires, voici ce que nous obtenons en ligne de commande pour un test en local ou à distance :

suspect:~ # /usr/local/nagios/libexec/check_file_exist
Usage : check_file_exist [-f <file> ou --file <file>]

Missing argument: file

suspect:~ # /usr/local/nagios/libexec/check_file_exist -V
check_file_exist 1.0

suspect:~ # /usr/local/nagios/libexec/check_file_exist --usage
Usage : check_file_exist [-f <file> ou --file <file>]

suspect:~ # /usr/local/nagios/libexec/check_file_exist -h
check_file_exist 1.0

Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance. Il est livré avec ABSOLUMENT AUCUNE GARANTIE.

Usage : check_file_exist [-f <file> ou --file <file>]

-?, --usage
Print usage information
-h, --help
Print detailed help screen
-V, --version
Print version information
--extra-opts=[section][@file]
Read options from an ini file. See http://nagiosplugins.org/extra-opts
for usage and examples.
-f, --file=STRING
file to check
-t, --timeout=INTEGER
Seconds before plugin times out (default: 15)
-v, --verbose
Show details for command-line debugging (can repeat up to 3 times)

suspect:~ # /usr/local/nagios/libexec/check_file_exist -f /var/log/messages
Verification fichier OK - messages exists

suspect:~ # /usr/local/nagios/libexec/check_file_exist -f /var/log/toto.txt
Verification fichier CRITICAL - toto.txt not exists

gendarme:~ # /usr/local/nagios/libexec/check_nrpe -n -H suspect_ou_IP_suspect -c check_file_exist -a /var/log/messages
/usr/local/nagios/libexec/check_nrpe -n -H suspect_ou_IP_suspect -c check_file_exist -a /var/log/messages

gendarme:~ # /usr/local/nagios/libexec/check_nrpe -n -H suspect_ou_IP_suspect -c check_file_exist
Usage : check_file_exist [-f <file> ou --file <file>]

On constate que notre programme est assez simple avec un rendu propre et complet !! Le module Monitoring::Plugin nous facilite la vie car nous n'avons plus à nous soucier de la gestion des arguments, il le fait pour nous ! Nous disposons d'une véritable documentation (un man). De plus, le formatage Nagios est respecté et le code est plus lisible. Ceci n'est qu'un exemple, mais le module peut nous permettre d'aller plus loin dans la documentation avec peu de code.

II-D-2-b - Plugin 2 - check_file_size

Le but de ce plugin est de vérifier la taille d'un fichier quelconque. Nagios devra nous notifier un warning, ou une alerte critique si le fichier dépasse les tailles que l'on passera en argument au plugin.

Avant de commencer, nous devons nous poser les questions suivantes :

- quel est le but de notre programme ?

- quels sont les arguments que notre plugin attend ?

En ce qui concerne le but, nous l'avons déjà, pour ce qui est des arguments, nous voulons fixer des seuils. Avec Nagios, les options utilisées pour les seuils de warnings et d'alertes critiques sont souvent respectivement -w et -c. Nous allons donc utiliser les mêmes. Les valeurs spécifiées à -w et -c devront être des entiers ou nombres réels. Elles représentent la taille en octets. Il nous faut une dernière option pour récupérer le fichier à tester. Voilà, nous pouvons commencer à coder  !!

Chargeons notre module et créons notre constructeur en spécifiant la version de notre programme, son nom et une licence.

#!/usr/bin/perl
#===============================================================================
# Auteur : djibril
# Date   : 04/03/2011 09:16:24
# But    : Plugin vérifiant la taille d'un fichier
#===============================================================================
use strict;
use warnings;

# Chargement du module
use Monitoring::Plugin;
use File::Basename;

use vars qw/ $VERSION /;

# Version du plugin
$VERSION = '1.0';

my $LICENCE
= "Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance."
. ' Il est livré avec ABSOLUMENT AUCUNE GARANTIE.';

my $plugin_nagios = Monitoring::Plugin->new(
shortname => 'Verification fichier',
usage =>
'Usage : %s [-f <file> ou --file <file>] [ -c|--critical=<threshold> ] [ -w|--warning=<threshold> ]',
version => $VERSION,
license => $LICENCE,
);

Créons maintenant nos arguments.

# Définition de l'argument --file ou -f pour récupérer le fichier
$plugin_nagios->add_arg(
spec     => 'file|f=s',
help     => 'File to check',    # Aide au sujet de cette option
required => 1,                  # Argument obligatoire
);

# Définition de l'argument warning
$plugin_nagios->add_arg(
spec     => 'warning|w=f',                                                # Nous acceptons des nombres réels
help     => 'Exit with WARNING status if less than BYTES bytes of file',
label    => 'BYTES',
required => 1,
);

# Définition de l'argument critical
$plugin_nagios->add_arg(
spec     => 'critical|c=f',
help     => 'Exit with CRITICAL status if less than BYTES bytes of file',
label    => 'BYTES',
required => 1,
);

Nous avons créé trois options avec chacune un alias. --file pour -f, --warning pour -w et --critical pour -c. Remarquez que pour -w et -c, il y a une option label => 'BYTES'. Cette ligne permet au module d'afficher dans l'aide « BYTES » pour le type d'arguments à recevoir.

aide personnalisée

-w, --warning=BYTES
Exit with WARNING status if less than BYTES bytes of file
-c, --critical=BYTES
Exit with CRITICAL status if less than BYTES bytes of file

Les options -w et -c sont obligatoires d'où les options required => 1. Activons maintenant l'analyse des arguments.

# Activer le parsing des options de ligne de commande
$plugin_nagios->getopts;

Vérifions que le fichier à tester existe bien, si oui, calculons sa taille, si non envoyons une alerte critique.

my $fichier_a_verifier = $plugin_nagios->opts->file;
my $nom_fichier        = basename $fichier_a_verifier;

if ( ! -e $fichier_a_verifier ) {
$plugin_nagios->plugin_exit( CRITICAL, "$nom_fichier not exists\n" );
}

Nous pouvons maintenant tester les seuils fixés par rapport à la taille du fichier pour afficher le message adéquat pour Nagios.

my $taille_fichier     = -s $fichier_a_verifier;

# Récupérons le code retour en fonction des seuils
my $code_retour = $plugin_nagios->check_threshold(
check    => $taille_fichier,
warning  => $plugin_nagios->opts->warning,
critical => $plugin_nagios->opts->critical,
);

$plugin_nagios->plugin_exit( $code_retour, "Taille $nom_fichier ($taille_fichier)" );

La méthode check_threshold permet de spécifier une valeur à tester par rapport aux valeurs seuils pour retourner le code retour. Par exemple, si l'on souhaite qu'un fichier au-delà de 1000 octets émette (le plugin émet !) un warning et 2000 octets une alerte critique, il faudra les arguments -w 1000 -c 2000. Le plugin retournera le code retour adéquat (0, 1 ou 2). Il nous suffit ensuite de renvoyer le message qui sera automatiquement adapté en fonction de ce code retour. Voilà le programme final !!

#!/usr/bin/perl
#===============================================================================
# Auteur : djibril
# Date   : 04/03/2011 09:16:24
# But    : Plugin vérifiant la taille d'un fichier
#===============================================================================
use strict;
use warnings;

# Chargement du module
use Monitoring::Plugin;
use File::Basename;

use vars qw/ $VERSION /;

# Version du plugin
$VERSION = '1.0';

my $LICENCE
= "Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance."
. ' Il est livré avec ABSOLUMENT AUCUNE GARANTIE.';

my $plugin_nagios = Monitoring::Plugin->new(
shortname => 'Verification fichier',
usage =>
'Usage : %s [-f <file> ou --file <file>] [ -c|--critical=<threshold> ] [ -w|--warning=<threshold> ]',
version => $VERSION,
license => $LICENCE,
);

# Définition de l'argument --file ou -f pour récupérer le fichier
$plugin_nagios->add_arg(
spec     => 'file|f=s',
help     => 'File to check',    # Aide au sujet de cette option
required => 1,                  # Argument obligatoire
);

# Définition de l'argument warning
$plugin_nagios->add_arg(
spec     => 'warning|w=f',                                                # Nous acceptons des nombres réels
help     => 'Exit with WARNING status if less than BYTES bytes of file',
label    => 'BYTES',
required => 1,
);

# Définition de l'argument critical
$plugin_nagios->add_arg(
spec     => 'critical|c=f',
help     => 'Exit with CRITICAL status if less than BYTES bytes of file',
label    => 'BYTES',
required => 1,
);

# Activer le parsing des options de ligne de commande
$plugin_nagios->getopts;

my $fichier_a_verifier = $plugin_nagios->opts->file;
my $nom_fichier        = basename $fichier_a_verifier;

if ( !-e $fichier_a_verifier ) {
$plugin_nagios->plugin_exit( CRITICAL, "$nom_fichier not exists\n" );
}

my $taille_fichier = -s $fichier_a_verifier;

# Récupérons le code retour en fonction des seuils
my $code_retour = $plugin_nagios->check_threshold(
check    => $taille_fichier,
warning  => $plugin_nagios->opts->warning,
critical => $plugin_nagios->opts->critical,
);

$plugin_nagios->plugin_exit( $code_retour, "Taille $nom_fichier ($taille_fichier)" );

__END__

Configurons NRPE et Nagios pour la réception des arguments.

/usr/local/nagios/nrpe.cfg

vi /usr/local/nagios/nrpe.cfg

command[check_file_size]=/usr/local/nagios/libexec/check_file_size -f $ARG1$ -w $ARG2$ -c $ARG3$

Une fois le fichier nrpe.cfg modifié, nous pouvons faire un test en ligne de commande depuis le serveur « gendarme ».

/usr/local/nagios/libexec/check_nrpe -n -H suspect_ou_IP_suspect -c check_file_size -a /var/log/messages 154524 21565658
Verification fichier WARNING - Taille messages (2589788)

Le résultat montre que notre fichier a une taille comprise entre 154524 et 21565658, d'où le warning.
Configurons Nagios sur le serveur de supervision pour permettre à Nagios de faire les vérifications.

define service{
use                     generic-service
host_name               suspect_ou_IP_suspect
service_description     Check size
check_command           check_nrpe!check_file_size!/var/log/messages 154524 21565658
}

Voilà, tout fonctionne parfaitement !! Vous pouvez encore améliorer ce plugin afin de permettre saisir en argument une option qui donnera la possibilité de définir les seuils en Ko, Mo, Go, etc. Cela peut être un bon exercice.
Vous pouvez en discuter sur le forum Perl ou ici. Commentez

II-D-2-c - Plugin 3 - check_process

Le but de ce plugin est de vérifier qu'un processus quelconque tourne sur une machine Linux via l'argument (-n ou --proc_name). Si le processus n'est pas trouvé, Nagios émettra une alerte critique sinon tout est OK.

Nous utiliserons le module Perl Proc::ProcessTable qui permet de lister facilement les processus sous Linux. Grâce à ce module, nous pouvons vérifier que le processus cherché existe et tourne. Voici notre plugin :

#!/usr/bin/perl
#==============================================================
# Auteur : Djibril
# But    : Plugin Nagios permettant de vérifier l'existence d'un
#          processus via le nom
# Date   : 05/03/2011 12:38:44
#==============================================================

use warnings;
use strict;
use Monitoring::Plugin;
use Proc::ProcessTable;

use vars qw/ $VERSION /;

# Version du plugin
$VERSION = '1.0';

my $LICENCE
= "Ce plugin Nagios est gratuit et libre de droits, et vous pouvez l'utiliser à votre convenance."
. ' Il est livré avec ABSOLUMENT AUCUNE GARANTIE.';

my $plugin_nagios = Monitoring::Plugin->new(
shortname => 'Check process',
usage     => 'Usage: %s [ -proc_name|-n=<Process name> ]',
version   => $VERSION,
license   => $LICENCE,
);

# Définition des options de ligne de commande
# 1- Récupération du nom du processus
$plugin_nagios->add_arg(
spec     => 'proc_name|n=s',
help     => 'Process name to find',
required => 1,
);

# Parser les options
$plugin_nagios->getopts;
my $proc_name = $plugin_nagios->opts->proc_name;

# Recherche du processus
my $process_table = new Proc::ProcessTable;
my $FORMAT        = "%-6s %-10s %-8s %-24s %s\n";
foreach my $proc ( @{ $process_table->table } ) {
if ( $proc->fname eq $proc_name ) {
my $message_OK = "Process $proc_name (" . $proc->pid . ') state (' . $proc->state . ')';

# Option verbose
if ( $plugin_nagios->opts->verbose ) {
printf( $FORMAT, 'PID', 'TTY', 'STAT', 'START', 'COMMAND' );
printf( $FORMAT,
$proc->pid, $proc->ttydev, $proc->state, scalar( localtime( $proc->start ) ),
$proc->cmndline );
}
$plugin_nagios->plugin_exit( OK, $message_OK );
}
}
$plugin_nagios->plugin_exit( CRITICAL, "$proc_name not found\n" );

__END__

Explication du programme :

Ce plugin liste tous les processus Linux tournant sur la machine grâce à la méthode table du module Proc::ProcessTable. Pour chaque processus, nous vérifions si le nom du processus est égal à celui que nous cherchons (méthode fname). Si le processus est trouvé, le plugin sort avec le bon code de retour et un message spécifiant le nom, l'état et le pid du processus. L'utilisation de l'option verbose en ligne de commande donne plus d'informations sur le processus trouvé. Exemple :

suspect:~ # /usr/local/nagios/libexec/check_process_ah -n mysqld -v
PID    TTY        STAT     START                    COMMAND
3646              sleep    Wed Apr  7 09:30:25 2010 /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --pid-file=/var/lib/mysql/mysqld.pid --skip-external-locking --port=3306 --socket=/var/lib/mysql/mysql.sock
Check process OK - Process mysqld (3646) state (sleep)

Configurons NRPE et Nagios pour la réception des arguments sur le serveur à surveiller.

/usr/local/nagios/nrpe.cfg

vi /usr/local/nagios/nrpe.cfg

command[check_process]=/usr/local/nagios/libexec/check_process -n $ARG1$

Configurons Nagios sur le serveur de supervision pour permettre à Nagios de faire la vérification.

define service{
use                     generic-service
host_name               suspect_ou_IP_suspect
service_description     Check Process Mysqld
check_command           check_nrpe!check_process!mysqld
}

La configuration ci-dessus permettra à Nagios de vérifier que le service mysqld tourne sur le serveur « suspect ».

Voilà !!

III - Références utilisées

- Installation et configuration de Nagios pour débutants

- Documentation officielle de Nagios

- Modules Perl : Proc::ProcessTable et Monitoring::Plugin

- API pour les plugins Nagios

- Projet Plugins Nagios

- Les plugins de Nagios depuis son site officiel

- NagiosExchange qui propose des centaines de plugins gratuits

- Le site officiel des grandes lignes du développement des plugins Nagios

IV - Conclusion

J'espère que ce tutoriel vous a permis de comprendre et de prendre conscience que le choix du langage Perl pour concevoir un plugin Nagios est un bon choix ! Nous avons vu comment créer des programmes respectant parfaitement les normes Nagios contrairement à beaucoup de plugins gratuits que l'on peut trouver sur la Toile. De plus, Perl est bien adapté pour les réseaux, la gestion de fichiers… N'hésitez donc pas à faire vos plugins à partir de ce tutoriel.
Si vous avez des questions, remarques, appréciations ou suggestions sur ce tutoriel, n'hésitez pas à laisser vos commentaires. Commentez .
Si vous avez besoin de réponses plus techniques au sujet de Perl, le forum est à votre disposition.

V - Remerciement

Je tiens à remercier l'équipe de developpez.com, puis ClaudeLELOUP, ram-0000 et stoyak pour la relecture de ce tutoriel.

(1)En fait, les plugins doivent retourner du texte en sortie. A partir de la version 3 de Nagios, les plugins peuvent optionnellement retourner plusieurs lignes de texte.

(2)Si l'option use_aggressive_host_checking est activée, les codes de retour 1 donneront un état DOWN ou UNREACHABLE pour l'hôte. Sinon, les codes de retour 1 donneront un état UP pour l'hôte.

(3)Nagios ne lit que les premiers 4KB des données qui seront retournées, mais cette limite est modifiable si besoin en modifiant la définition MAX_PLUGIN_OUTPUT_LENGTH dans le fichier include/nagios.h.in du code source et il faudra recompiler Nagios. N'en abusez pas !!

(4)Lisez ce tutoriel pour savoir comment installer un module Perl.