Étiquette : nagios

Catégories
Open-source Reseau

Surveiller vos serveurs Windows avec Nagios

Dans la longue série des billets sur Nagios, en voici un tout spécialement dédié aux lecteurs qui ont à administrer des machines sous Windows. Nous allons décrire l’installation de NSClient, un plugin permettant de récupérer un nombre important de d’informations à surveiller sur une machine Windows.

Comme les plugins NRPE et NSCA (disponible seulement sous Linux et Mac OS X), NSClient se base sur une architecture client/serveur. La partie cliente (nommée check_nt), doit être disponible sur le serveur Nagios. La partie serveur (NSClient++) est à installer sur chacune des machines Windows à surveiller.

Installation de check_nt

Il y a de forte chance que le plugin check_nt soit installé par défaut sur votre serveur Nagios. Pour le vérifier, il faut se rendre dans le répertoire Nagios ou se trouve vos plugins (/usr/lib/nagios/plugins sur Fedora).

# cd /usr/lib/nagios/plugins
# ls check_nt
check_nt

Si ce n’est pas le cas, il suffit de l’installer grâce aux commandes suivantes:

Fedora:
# sudo yum install nagios-plugins-nt

Ubuntu:
# sudo apt-get install nagios-plugins-nt

Installation de NSClient++

Remarque: cette opération est à faire sur l’ensemble des PC Windows à surveiller.

La première chose à faire est de télécharger la dernière version (0.2.5e ou supérieure) à l’adresse suivante: Sourceforge de NSClient++.

Ensuite il faut:

  • « dézipper » le client dans le répertoire c:\nsclient
  • ouvrir une commande DOS (cmd.exe)
  • puis entrer les commandes suivantes:
    • cd \nsclient
    • nsclient++ /install
  • Ouvrir le gestionnaire des services et vérifier que le service est autorisé à « Interagir avec le bureau »

  • Editer le fichier c:\nsclient\NSC.INI en:
    • décommentant tous les modules listé dans la section [modules] sauf CheckWMI.dll et RemoteConfiguration.dll
    • décommentant la ligne allowed_hosts dans la section [Settings] et en y ajoutant l’adresse du serveur Nagios.
  • puis entrer les commandes suivantes dans votre fenêtres DOS:
    • cd \nsclient
    • nsclient++ /start

Pour tester que l’installation à bien marché, le plus simple est de faire un test depuis le serveur Nagios. Pour cela, il faut:

# cd /usr/lib/nagios/plugins

# ./check_nt -H IPMACHINEWINDOWS -v CLIENTVERSION -p  12489

Si tout ce passe bien, le client doit envoyer la version de NSClient (0.2.5e)

Si cela ne fonctionne pas, il faut peut être vérifier que la requête (TCP sur port 12489) n’est pas bloqué par un Firewall.

Configuration de Nagios pour surveiller vos machines Windows

Une fois le client et le serveur installé, il faut configurer Nagios de la manière suivantes. Il faut dans un premier temps éditer votre fichier de configuration des hosts (hosts.cfg par défaut) et y ajouter votre machine Windows:

define host {
use generic-host
host_name billgates
alias Ma machine Win
address 192.168.6.66
}

Puis ajouter les services offerts par NSClient (dans le fichier services.cfg):

# Affiche la version du NSClient
define service {
use generic-service
host_name billgates
service_description VERSION
check_command check_nt!CLIENTVERSION
}

# Temps écoulé depuis le dernier reboot (uptime)
define service {
use generic-service
host_name billgates
service_description UPTIME
check_command check_nt!UPTIME
}

# Charge CPU
# WARNING si charge > 80% pendant plus de 5 minutes
# CRITICAL si charge > 90% pendant plus de 5 minutes
define service {
use generic-service
host_name billgates
service_description CPU
check_command check_nt!CPULOAD!-l 5,80,90
}

# Etat de la mémoire vive libre
# WARNING si mémoire > 80%
# CRITICAL si mémoire > 90%
define service {
use generic-service
host_name billgates
service_description MEM
check_command check_nt!MEMUSE!-w 80 -c 90
}

# Etat de la mémoire disque libre (sur disque c:)
# WARNING si mémoire > 80%
# CRITICAL si mémoire > 90%
define service {
use generic-service
host_name billgates
service_description DISK
check_command check_nt!USEDDISKSPACE!-l c -w 80 -c 90
}

Il est également possible de surveiller l’état d’un service (SERVICESTATE) ou d’un processus (PROCSTATE).

Catégories
Open-source Reseau

Nagios et les greffons

Nagios est un outil libre de monitoring réseau souvent abordé dans ce blog. A mes yeux, la principale force de ce produit est sa grande modularité qui lui permet de s’adapter aux besoins des utilisateurs. Il est ainsi possible de surveiller un grands nombres de paramètres sur les machines de votre réseau. Nous allons dans ce billet évoquer les différentes méthodes que l’on peut utiliser pour récupérer ces informations.

Le protocole SNMP

C’est LE protocole pour la gestion de réseaux. Basée sur UDP (port 161), ce protocole de communication permet la remontée d’informations stockées dans la table MIB (« Management Information Base ») des machines. SNMP se base sur une architecture client (Nagios) / serveur (la machine à surveiller). Il est donc nécessaire que vos machines soient compatibles SNMP. C’est le cas de la plupart des équipements réseaux de type routeurs, commutateurs Ethernet…

Sur les serveurs de type Linux, il suffit d’installer le daemon snmpd de la suite Open-SNMP. Sur Windows, il est également possible d’installer le daemon Net-SNMP. Enfin, Mac OS X inclue un daemon SNMP (UCD-SNMP), il suffit de suivre cette procédure pour l’activer.

Les plugins locaux

En standard, SNMP ne remonte que des informations systèmes basiques. Pour aller plus loin et surveiller des processus plus complexe, Nagios à mis en place un système de type plugins locaux. Un plugin local est un script localisé sur le serveur Nagios (/usr/lib/nagios/plugins sous Linux, c’est pour cela que l’on dit qu’il est local).

Ce script, lancé à la demande de Nagios, doit retourner un code dont la signification est la suivante:

  • Code 0: OK – Tout va bien
  • Code 1: WARNING – Alerte
  • Code 2: CRITICAL – Alerte critique
  • Code 3: UNKNOWN – Problème lors de l’exécution du plugin

En plus de ces codes, un plugins peut fournir d’autres informations (sous la forme d’une chaine de caractères) qui seront affichées à coté du statut de la machine.

Pour ceux que cela intéresse, j’ai écrit un petit tutoriel sur la création d’un plugin pour Nagios.

Les plugins actifs avec NRPE

A la différence des plugins locaux, le plugin NRPE permet l’exécution de plugins dit actifs directement sur les machines à surveiller.
L’architecture est la suivante (schéma trouvé sur le site officiel de Nagios):

Avec NRPE, la demande d’exécution d’un plugin actif est faite à l’initiative du serveur Nagios. La procédure interne est la suivante:

  • le serveur Nagios demande, via le client NRPE, l’exécution du plugin P sur la machine H
  • le daemon NRPE hébergé sur la machine H, reçoit la requête d’exécution du plugin P
  • le plugin P est exécuté sur la machine H
  • le daemon NRPE de la machine H envoie le résultat du plugin P au serveur Nagios
  • le serveur Nagios interprète les résultats retournés par le pugin P

Les plugins passifs avec NSCA

Comme l’on vient de le voir NRPE est déclenché à l’initiative du serveur Nagios. Ce mode de fonctionnement peut poser problème, par exemple dans le cas ou les machines à surveiller son derrières un réseau sécurisé par un Firewall ou si le processus à surveiller demande une fréquence d’exécution très courte. Le plugin NSCA répond à ce problème en proposant l’exécution de plugins passifs sur les machines à surveiller.

Ici, c’est donc le daemon NSCA qui va envoyer l’information au serveur Nagios. On peut comparer cette fonction à un TRAP SNMP.

et pour Windows ?

Les plugins NRPE et NSCA ne sont disponibles que pour Linux et Mac OS X. Si vous souhaitez surveiller des machines sous Windows (il vaut mieux les surveiller de prêt ces bêtes là…) , il va falloir utiliser le plugin NSClient.

Cliquez ici pour voir tous mes billets sur Nagios.

Catégories
Nagios Open-source Reseau

Installation de Nagios 3 sous Ubuntu

—

Update: Ce billet n’est plus à jour.

Merci de consulter cet autre tutoriel pour une installation de Nagios 3 sous Ubuntu

ou alors

cet autre billet avec un script automatique d’installation de Nagios sur GNU/Linux

—

Nagios, l’outil libre de monitoring réseau va bientôt passer en version 3.0. Nous allons donc dans cet article décrire l’installation de cette nouvelle monture sous un OS Linux Ubuntu (la procédure est presque la même pour Fedora).

Pre-requis

Nous avons d’abord besoin d’installer un serveur web (si ce n’est pas déjà fait) et les librairies de bases nécessaires pour la compilation de Nagios. Pour cela, il faut utiliser les commandes suivantes:

# sudo apt-get install apache2
# sudo apt-get install build-essential

Si vous voulez utiliser l’option de visualisation graphique de votre réseau (« status map »), il faut également installer les librairie suivantes.

# sudo apt-get install libgd2-noxpm-dev libpng12-dev libjpeg62 libjpeg62-dev

Il faut également créer un utilisateur et un groupe dédié au processus Nagios (pour d’évidente raison de sécurité).

# sudo -s
# /usr/sbin/useradd nagios
# passwd nagios
# /usr/sbin/groupadd nagios
# /usr/sbin/usermod -G nagios nagios
# /usr/sbin/groupadd nagcmd
# /usr/sbin/usermod -G nagcmd nagios
# /usr/sbin/usermod -G nagcmd www-data

Téléchargement des sources de Nagios

Afin de rendre cette procédure la plus générique possible (et don adaptable sous d’autres distributions Linux), nous allons faire une installation de Nagios à partir des sources. Nous allons donc commencer à les récupérer sur le site Nagios:

# cd /usr/src
# wget  http://surfnet.dl.sourceforge.net/sourceforge/nagios/nagios-3.0.2.tar.gz
# wget  http://kent.dl.sourceforge.net/sourceforge/nagiosplug/nagios-plugins-1.4.12.tar.gz

PS: Pensez à changer le nom du fichier quand la version finale de Nagios sera sortie

Compiler les sources de Nagios

Une fois les sources décompressés:

# tar xzf nagios-3.0.2.tar.gz
# cd nagios-3.0.2

Nous allons lancer la compilation grâce aux commandes suivantes:

# ./configure –with-command-group=nagcmd
# make all
# make install
# make install-init
# make install-config
# make install-commandmode
# ln -s /etc/init.d/nagios /etc/rcS.d/S99nagios

Il faut ensuite installer l’interface Web:

# make install-webconf
# sudo htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin
# /etc/init.d/apache2 reload

Puis finir par la compilation des plugins de base.

# cd ..
# tar xzf nagios-plugins-1.4.12.tar.gz
# cd nagios-plugins-1.4.12
# ./configure –with-nagios-user=nagios –with-nagios-group=nagios
# make
# make install

Configuration de Nagios

Nagios est maintenant installé sur votre machine. Avant de pouvoir le lancer, il faut éditer les fichiers de configuration qui se trouve dans le répertoire /usr/local/nagios/etc. Pour faire un premier test, le seul fichier à configurer avant d’éxecuter Nagios est le fichier /usr/local/nagios/etc/objects/contacts.cfg et de changer l’adresse email de contact (nagiosadmin) ou seront envoyés les mails en cas d’alerte.

Pour la configuration finale en fonction de vos besoin, vous pouvez consulter cette page qui décrit les fichiers de configurations.

Pour vérifier que la configration de Nagios est bonne (qu’il n’y a pas d’erreur dans les fichiers de configuration), vous pouvez utiliser l’option « -v » de la commande nagios:

# /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg

Si vous n’avez pas d’erreurs, vous pouvez passer à la dernière étape.

Lancement de Nagios

Pour lancer Nagios, vous pouvez utiliser les commandes:

# /etc/init.d/nagios start
ou bien
# service nagios start

Pour le redémarrage de Nagios (par exemple si vous modifiez les fichiers de configurations):

# /etc/init.d/nagios restart
ou bien
# service nagios restart

Utilisation de Nagios

L’accès à l’interface Web de Nagios se fait par l’URL suivante: http://localhost/nagios/ (ne pas oublier le / final).

Pour aller plus loin…

Si vous avez besoins d’informations et d’aide supplémentaires sur Nagios, vous pouvez consulter:

Traitant régulièrement de sujet autour de Nagios, vous pouvez également vous abonnez au blog pour ne pas louper un article ;).

Catégories
Open-source Reseau

Nagios vs Solutions payantes ?

Un lecteur m’a posé, par mail, la question suivante:

…
je suis à la recherche d’un produit de supervision et je trouve des produits
comme Patrol visualis, Spectrum, HP Open View…. aux prix exorbitants
– j’aurai à superviser: 20 switchs cisco, 10 routeurs cisco, des serveurs windows
2003, ISA, exchange et 60 cisco pix (en VPN ipsec et en extrémité un ISA) soit
environ 100 équipements snmp.
– ma priorité étant les « cisco pix » afin de détecter les ruptures de ligne adsl
et par exemple permettre d’envoyer un mail, sms avec une remontée d’alerte
visuelle sur le produit de supervision…
– obtenir des graphiques sur la bande passante utilisée…
– les équipements non snmp, peut-on les gérer par un ping à intervalle régulier ?
Ce produit est-il difficile à mettre en oeuvre ? (mes connaissances linux dates de 5 ans).
…


Ce genre de question revient régulièrement quand on doit faire le choix entre une solution open-source et une solution payante. Dans ce cas précis et au vu du nombre relativement faible de machine à « monitorer », je pense qu’une solution à base de Nagios (pour le monitoring) et de Cacti (pour la génération des graphes de bande passante ou autres) est la meilleure.

En effet, une des qualités première de Nagios est son architecture facilement adaptable à l’environnement, notamment grâce à l’utilisation de plugins. Notre lecteur dispose d’un parc composé en majorité de machine compatible SNMP, il sera donc très facile d’adapter Nagios aux besoins des utilisateurs. Il existe même des sites comme Nagios Exchange permettant de trouver facilement des extensions spécifiques pour les équipements Cisco et les serveurs Windows. Pour les équipements non compatibles SNMP, il est bien sur possible de les surveiller grâce à des « ping ». Pour être plus précis, on passe alors par un système de scripts permettant de faire un peu ce que l’on veut (faire une ping, émuler une requête HTTP, tester une connection telnet…). En ce qui concerne la remontée des alarmes, Nagios dispose de tout un panel de possibilité: message dans l’interface Web, message dans fichier syslog, mail, SMS (si vous disposez d’un serveur SMS).

Bien que l’installation de Nagios soit relativement simple, il faut avouer que les taches d’administrations (ajout/modification/suppression de machine) sont un peu lourdes. Elles peuvent cependant être faite par n’importe quel utilisateur maitrisant les bases d’un OS Linux. Si vous souhaitez toutefois avoir un support professionnel, de nombreuses SSII offrent leurs services pour l’installation et la maintenance de telles solutions.

L’archivage des l’utilisation de la bande passante n’est par contre pas une fonction inclue dans Nagios, je conseille pour cela l’utilisation d’un autre logiciel: Cacti. Ce dernier se présente lui aussi comme une interface Web et est bien plus simple à utiliser que des graphes MRTG.

Catégories
Open-source Reseau Systeme

Installation de Centreon (Oreon)

—

Update: Ce billet n’est plus à jour.
Merci de consulter cet autre tutoriel pour une installation de Centreon 2 avec Nagios 3:
http://blog.nicolargo.com/2009/01/le-serveur-de-supervision-libre-part-3.html

—

Nagios, que j’ai abordé dans de nombreux articles est un outil de monitoring système et réseau de très grande qualité pour sa souplesse de configuration, sa puissance de traitement ou encore sa stabilité. Par contre, son interface ulisateur n’est pas des plus réussie et il est impossible de faire des actions d’administrations de base (comme ajouter une nouvelle machine à monitorer) dans l’interface Web. Centreon (anciennement appelé Oreon) a pour but de combler ces lacunes.


Avant (Nagios) / Après (Nagios+Centreon)

Oreon est une interface Web (écrite en PHP) venant s’ajouter à Nagios. Cette interface permet:

  • d’amméliorer l’interface de base de Nagios
  • ajouter des fonctions de reporting (des graphes par exemple)
  • d’administrer Nagios à partir d’une interface Web (plus besoin de toucher les fichiers de configurations)

Installation de Centreon

Nous allons détailler l’installation de Centreon sur une machine Fedora Core 6 (mais la procèdure devrait être la même sur d’autres distributions Linux). Dans notre exemple, la machine a déjà les services suivants installés:

Nous allons installer la version 1.4 de Centreon (dernière version stable).

Lire la suite « Installation de Centreon (Oreon) »

Catégories
Open-source Reseau

De Nagios à XML…

La manipulation des fichiers de configuration de Nagios peut s’avérer délicate quand la taille et la complexité du réseau à surveiller deviennent importante. L’utilisation d’un fichier de configuration au format XML permet une plus grande flexibilité au niveau du développement de scripts au d’interface Web de management. La première brique est donc de transformer les fichiers de configuration de Nagios en un fichier XML.

J’ai donc écrit deux scripts Perl (à télécharger ici).

Le permier permet à partir d’une configuration existante (fichiers nagios.cfg …) de créer un fichier XML.

Exemple d’utilisation:

# cd /etc/nagios
# nagios2xml.pl -f ./nagios.cfg -x /tmp/nagios.xml

Le second permet à partir d’un fichier XML de générer un fichier de configuration de Nagios (« lisible » par Nagios).

Exemple d’utilisation:

# cd /etc/nagiosnew
# xml2nagios.pl -x /tmp/nagios.xml -f ./

Il ne reste plus qu’a créer les scripts pou manipuler cette nouvelle structure XML !
Suite au prochain épisode.

Catégories
Open-source Reseau

Exemple de configuration de Nagios

Ce post fait suite à celui sur l’installation de Nagios sur une machine Linux. Nous allons y décrire les fichiers de configurations nécessaires pour surveiller (« to monitor ») un réseau simple comporant: une machine client, une machine serveur avec un serveur Web et une serveur FTP et une liaison Internet.

Note: les fichiers de configurations données en exemple dans ce post se basent sur la version 2.8 de Nagios.

Sous Fedora Linux, les fichiers de configurations de Nagios se trouvent dans le répertoire /etc/nagios/ (/usr/local/etc/nagios sous BSD). Le fichier nagios.cfg définie l’ensemble des sous fichiers de configurations grâce aux variables cfg_file:

…
#cfg_file=/etc/nagios/localhost.cfg
cfg_file=/usr/local/etc/nagios/timeperiods.cfg
cfg_file=/usr/local/etc/nagios/contacts.cfg
cfg_file=/usr/local/etc/nagios/contactgroups.cfg
cfg_file=/usr/local/etc/nagios/hosts.cfg
cfg_file=/usr/local/etc/nagios/services.cfg
cfg_file=/usr/local/etc/nagios/hostgroups.cfg
…

Il faut également configurer le fichier cgi.cfg (en partant de cgi.cfg-sample):

authorized_for_system_information=admin
authorized_for_configuration_information=admin
authorized_for_system_commands=admin
authorized_for_all_services=admin
authorized_for_all_hosts=admin
authorized_for_all_service_commands=admin
authorized_for_all_host_commands=admin

Définition des plages horaires

La première étape consiste à définir les périodes de temps que nous allons pouvoir utiliser dans les autres fichiers de configurations. Pour simplifier, nous allons juste créer la période 24×7 (tout les jours, toutes les heures…). Pour cela, il faut éditer le fichier /usr/local/etc/nagios/timeperiods.cfg:

# Time periods definitions
##########################
# 7d/7 24h/24
define timeperiod {
timeperiod_name 24×7
alias 24 Hours A Day, 7 Days A Week
sunday 00:00-24:00
monday 00:00-24:00
tuesday 00:00-24:00
wednesday 00:00-24:00
thursday 00:00-24:00
friday 00:00-24:00
saturday 00:00-24:00
}

Définition des contacts

Nous allons ensuite définir les contacts. C’est à dire les personnes devant être prevenu par un moyen ou un autre (mail, SMS…) quand une alerte est générée par Nagios (par exemple quand votre serveur Web ne répond plus).

Il faut pour cela modifier deux fichiers, /usr/local/etc/nagios/contacts.cfg pour la définition du/des contacts:

# Contacts defintions
#####################
define contact {
contact_name nico
alias Nicolas
host_notification_period 24×7
service_notification_period 24×7
host_notification_options d,u,r
service_notification_options w,u,c,r
host_notification_commands host-notify-by-email
service_notification_commands notify-by-email
email nico@votreadressemail.com
}

Nous venons donc de créer un contact nommé « nico » qui sera joingnable 24 heures sur 24, 7 jours sur 7 par mail.

Le deuxième fichier (/usr/local/etc/nagios/contactgroups.cfg) permet d’intégrer le nouvel utilisateur dans un groupe:

# Contacts groups definition
############################
define contactgroup {
contactgroup_name admins
alias Administrators
members nico
}

Nous avons donc ajouté « nico » dans le groupe « admins ».

Définition des machines à surveiller

Entrons dans le vif du sujet en déclarant les machines que l’on veut surveiller. Cette définition sefait dans le fichier /usr/local/etc/nagios/hosts.cfg:

On commence le fichier en définissant un template:

# Nagios server – Hosts definitions
###################################
# Templates
#———-
define host{
name template-host
check_command check-host-alive
max_check_attempts 2
check_interval 5
active_checks_enabled 1
passive_checks_enabled 0
check_period 24×7
notification_interval 60
notification_period 24×7
obsess_over_host 0
check_freshness 0
event_handler_enabled 0
flap_detection_enabled 0
process_perf_data 0
retain_status_information 1
retain_nonstatus_information 1
contact_groups admins
register 0
}

Puis on ajoute la définition pour notre routeur d’accès à Internet (Freebox, 9box, OrangeBox, Trucbox…):

# Ma box
#————
define host{
use template-hosts
host_name monrouteuramoi
alias Mon routeur à moi c’est une Freebox
address 192.168.100.254
}

celle de mon PC client:

# Mon PC client
#————
define host{
use template-hosts
host_name monpcamoi
alias Mon MacBook Pro à moi
address 192.168.100.2
}

et enfin celle de mon serveur:

# Mon serveur
#————
define host{
use template-hosts
host_name monserveuramoi
alias Mon serveur Linux à moi
address 192.168.100.1
}

on termine en surveillant la liaison Internet (pour cela on va pinguer un serveur Web):

# Mon liaison Internet
#————
define host{
use template-hosts
host_name maliaisonamoi
alias Ma liaison ADSL à moi
address www.free.fr
parents monrouteuramoi
}

Vous pouvez remarquer dans cette dernière définition que nous avons définie « monrouteuramoi » comme père de ma « maliaisonamoi ». Ainsi, si le routeur n’est plus accéssible, Nagios n’essayera plus de surveiller la liaison Internet.

Définition des services à surveiller

Une fois les machines définies, nous devons décider ce que nous allons surveiller dessus. Cette configuration se fait grâce au fichier /usr/local/etc/nagios/services.cfg.

Nous allons commencer par un template:

# Templates
#———-
define service{
name template-services
active_checks_enabled 1
passive_checks_enabled 0
parallelize_check 1
obsess_over_service 1
check_freshness 0
notifications_enabled 0
event_handler_enabled 0
flap_detection_enabled 0
process_perf_data 1
retain_status_information 1
retain_nonstatus_information 1
check_period 24×7
max_check_attempts 3
normal_check_interval 5
retry_check_interval 1
contact_groups admins
notification_interval 240
notification_period 24×7
notification_options c,r
register 0
}

Puis par la surveillance du routeur:

# monrouteuramoi
#———
define service {
host_name monrouteuramoi
use template-services
service_description Ping
check_command check-host-alive
}

De mon PC client:

# monpcamoi
#———
define service {
host_name monpcamoi
use template-services
service_description Ping
check_command check-host-alive
}

mon serveur (on surveille également le serveur HTTP et le serveur FTP):

# monserveuramoi
#———
define service {
host_name monserveuramoi
use template-services
service_description Ping
check_command check-server-alive
}
define service {
host_name monserveuramoi
use template-services
service_description Web serveur
check_command check_http
}
define service {
host_name monserveuramoi
use template-services
service_description FTP serveur
check_command check_ftp
}

et enfin la liaison Internet:

# maliaisonamoi
#———
define service {
host_name maliaisonamoi
use template-services
service_description Ping
check_command check-server-alive
}

Définition des groupes de machines

La dernière étape consiste à définir un groupe de machine dans le fichier /usr/local/etc/nagios/hostgroups.cfg:

# Mon réseau à moi
define hostgroup{
hostgroup_name monreseauamoi
alias Mon reseau
members monrouteuramoi, monpcamoi, monserveuramoi, maliaisonamoi
}

et voila la configuration touche à sa fin, il ne reste plus qu’a vérifier la syntaxe de vos fichiers de configuration avec la commande suivante:

# nagios -v <nagios.cfg>

Si tout est ok, vous pouvez relancer le serveur Nagios:

# service nagios reload

That’s all folk !

Pour une description précise des options des fichiers de configuration de Nagios, c’est par ici.

Pour consulter l’ensemble des posts sur Nagios, c’est par là.

Catégories
Reseau

Nagios et Fast Ping (check_fping)

Si vous souhaitez utiliser fping en lieu et place de ping avec votre configuration de Nagios, il faut suivre les étapes suivantes:

Installer fping:

# wget http://fping.sourceforge.net/download/fping.tar.gz
# tar zxvf fping.tar.gz
# cd fping-x.y.z
# ./configure
# make
# make install

Autoriser l’utilisateur nagios à executer fping:

# chmod u+s /usr/local/sbin/fping

Installer ou re-installer les plugins Nagios (par exemple sous FreeBSD):

# cd /usr/ports/net-mgmt/nagios-plugins/
# make install
ou
# make deinstall ; make reinstall

Puis changer le fichier de configurations de Nagios (/usr/local/etc/nagios/commands.cfg):

…
define command {
command_name check_ping
command_line $USER1$/check_fping $HOSTADDRESS$ -w $ARG1$ -c $ARG2$ -n 5
}
…
define command{
command_name check-host-alive
command_line $USER1$/check_fping $HOSTADDRESS$ -w 3000.0,80% -c 5000.0,100% -n 1
}
…

Il ne reste plus qu’a relancer Nagios:

#/usr/local/etc/rc.d/nagios.sh reload

>

Et « f »hop…

Catégories
Reseau

Cacti, le complement idéal de Nagios !

Nous allons dans ce post parler de l’installation de Cacti, qui me semble offrir des fonctions complémentaires à Nagios déjà évoqué dans ce blog.

C’est quoi donc ?

Cacti est une interface Web écrite en PHP permettant de gérer des graphes RRD. Ces graphes RRD peuvent avoir comme source le résultat de n’importe quelle requêtes SNMP ou d’un simple script. Cela permet donc une large possibilitée d’utilisation. La gestion se fait par des menus relativement simple à utiliser (il faut tout de même un temps de prise en main mais la documentation est très bien faite).

Configuration nécessaire

Un operating system (Unix de préference)
Un serveur Web fraichement installé (Apache par exemple).
Une base de données MySQL.
Les sources de Cacti ou un package pour votre operating system.

Installation de cacti (exemple donnée pour une Fedora Core 6)

Update: cliquez ici pour voir un nouvel article sur une procédure d’upgrade en version 0.8.7 

Il faut commencer par installer les utilitaires SNMP:

# yum install net-snmp net-snmp-utils

Puis Cacti en lui même (on utilise le package du repos extra):

# yum install cacti

Avant toute chose, nous allons ajouter la configuration nécessaire pour que le serveur Web (Apache) prenne en compte cacti:

# cd /etc/httpd/conf.d/
# vi cacti.conf
Alias /cacti/ /usr/share/cacti/
<Directory /cacti/>
Options Indexes
AllowOverride None
Order allow,deny
Allow from all
</Directory>
# apachectl restart

Après vous être placé dans le répertoire d’installation, il faut créer la base de donnée MySQL (on part sur l’hypothése ou la base de donnée est sur le même serveur):

# mysqladmin –user=root create cacti
# mysql cacti < cacti.sql
# mysql –user=root mysql
mysql> GRANT ALL ON cacti.* TO cactiuser@localhost IDENTIFIED BY ‘somepassword’;
mysql> flush privileges;

… et la configurer en éditant le fichier include/config.php:

# vi include/db.php
<?
/* make sure these values refect your actual database/host/user/password */
$database_type = « mysql »;
$database_default = « cacti »;
$database_hostname = « localhost »;
$database_username = « cactiuser »;
$database_password = « password »;
$database_port = « 3306 »;
?>

Nous pouvons alors lancer un navigateur Web sur l’URL: http://votreadresseip/cacti/
Au premier lancement, une page de configuration va apparaître. Vous devez choisir RRD (dernière version).

Il est parfois nécessaire de changer les droits du répertoire de travail de Cacti:

# cd /usr/share/cacti/
# chown -R cacti rra/ log/

La dernière étape va automatiser le lancement de cacti toutes les 5 minutes:

# crontab -e -u cacti
*/5 * * * * /usr/bin/php /usr/share/cacti/poller.php > /dev/null 2>&1

Et voila, vous avez maintenant un bel outils pour générer toutes les courbes RRD possibles 😉

Catégories
Reseau

Creation d’un plugins pour Nagios

Nous allons dans ce post écrire un plugins (très simple) pour Nagios. Le corps de ce plugins pourra vous servir de base pour réaliser des plugins plus complexes.

Suite à un post sur l’installation de Nagios, je me suis penché sur l’écriture d’un plugins permettant de vérifier qu’un processus est bien lancé sur un serveur distant.

Voici ce que je l’on attend de notre plugins:

  • Ouvrir une session SSH vers le serveur distant
  • Lancement d’un script vérifiant si un processus (testd) est lancé
  • Renvoie de l’état du processus (OK / ERROR / WARNING)
    • OK: Le processus (testd) est lancé et fonctionne correctement
    • ERROR: Le processus n’est pas lancé
    • WARNING: Le processus est lancé mais ne fonctionne pas correctement

Avant d’entrer dans le vif du sujet, il faut savoir que les plugins Nagios sont de simple « scripts shell » retournant un code de status. Ces plugins sont localisés dans le répertoire /usr/lib/nagios/plugins (sous Linux). Un petit coups de ls donne la liste des plugins installés par défaut:

# ls
check_http check_pgsql check_smtp check_udp2 check_imap check_mysql check_ping check_spop check_udrelay term_power check_clamd check_jabber check_mysql_query check_pop check_ssmtp check_dns check_ldap check_nntp check_scheduler check_tcp check_ftp check_ldaps check_nntps check_simap check_udp …

Nous allons donc dans un premier temps créer le plugins qui va lancer la commande sur le serveur distant:

# vi check_testd
#!/bin/sh

##################################################################
# Creation: Nicolargo
# Last Modification:
# This script checks testd daemon is running on a server
##################################################################

ssh nagios@$1 /usr/local/bin/nagios_testd.pl

Une fois l’automatisation du SSH effectuée entre votre serveur Nagios et votre serveur distant (il ne faut pas que le script demande le password…). Il reste à créer le script nagios_testd.pl (je l’ai developpé en perl mais rien n’empêche de le faire en SH) dans le réperoire /usr/local/bin du serveur distant.

# vi /usr/local/bin/nagios_testd.pl
#!/bin/sh

##################################################################
# Creation: NicoLargo
# Last Modification:
# This script is polling if testd daemon is running
##################################################################

STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3
STATE_DEPENDENT=4

ps auxw | grep [t]estd | grep -v nagios > /dev/null
STATE=$?
if [ « $STATE » = « $STATE_OK » ]
then
echo « TESTD OK »
exit 0
else
echo « TESTD Failed »
exit $STATE_CRITICAL
fi

Pour tester votre plugins, rien de plus simple, il suffit de lancer la ligne de commande sur votre serveur Nagios:

# /usr/lib/nagios/plugins/check_testd.sh monserveurdistant.mondomaine.com
TESTD OK

Si cela ne fonctionne pas, il faut d’abord vérifier que les fichiers ont les bons droits (lecture et execution) et que le SSH fonctionne correctement entre les deux machines.

Une fois le plugins validé, il ne reste plus qu’a l’intégrer dans vos fichiers de configuration.

# vi /etc/nagios/checkcommands.cfg
…
# ‘check_testd’ command definition
define command{
command_name check_testd
command_line $USER1$/check_testd $HOSTADDRESS$
}
…

et enfin:

# vi /etc/nagios/services.cfg
…
define service{
use generic-service
host_name monserveurdistant.mondomaine.com
service_description TESTD
check_command check_testd
}
…

Voili a+