inlinetoc

GLPI est une solution open-­source de gestion de parc informatique et de servicedesk, GLPI (Gestion Libre de Parc Informatique) est une application Full Web pour gérer l'ensemble des problématiques de gestion de parc informatique : de la gestion de l'inventaire des composantes matérielles ou logicielles d'un parc informatique à la gestion de l'assistance aux utilisateurs :

• Gestion et suivi des ressources informatiques
• Gestion et suivi des licences
• Gestion et suivi des consommables
• Base de connaissances
• Gestion des réservations
• ServiceDesk (helpdesk, SLA..)
• Inventaire automatisé avec FusionIventory ¹⁾.
• Télédéploiement
• Supervision avec Shinken ²⁾

Le plugin de supervision Monitoring pour GLPI permet d'intégrer SHINKEN pour :

• Se baser sur l'inventaire du matériel / logiciel pour définir automatiquement les ressources à superviser. On utilise des règles utilisant le puissant moteur de recherche de GLPI. À chaque nouveau matériel ou modification, les règles sont rejouées et les contrôles ajoutés ou supprimés automatiquement.
• Visualiser l'état des ressources dans la fiche d'un matériel.
• Des vues synthétiques sous forme de tableau de bord (vues managers, techniciens)
• Délégation du monitoring possible via l'utilisation des entités de GLPI.
• La supervision est assurée en « temps réel » via la remontée directe des derniers contrôles
• Un peu de métrologie via les graphiques RRDtool via les perfdata des commandes exécutées.
• Avoir des modèles génériques pour RRDtool au format JSON (pouvant être utilisés par d'autres projets)
• Gestion des catalogues de services (business rules)
• Utiliser les fonctionnalités offertes par Shinken pour la supervision

Il permet de paramétrer depuis celui-ci les éléments essentiels de la supervision par SHINKEN :

• Les commandes : pour définir les contrôles
• Les calendriers: pour définir les périodes de contrôles en jours: Lundi/Mardi/etc… et la période de notification
• Les composants: pour définir quoi monitorer sur chaque hôte.
• Les catalogues: pour définir quels hôtes système de monitorer.

Le plugin monitoring à pour but “d'intégrer” Shinken à GLPI. En effet grâce à ce plugin Shinken sera paramétrable à partir de GLPI et les alertes seront visibles dans celui-ci. GLPI devient donc un outil complet d'inventaire, monitoring et gestion d'assistance.

Installer le module xmlrpc pour PHP:

yum install xmlrpc
service apache2 reload

Installer Mongodb:

vi /etc/yum.repos.d/mongodb-org-4.4.repo
[mongodb-org-4.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc

sudo yum install -y mongodb-org
systemctl enable mongod
systemctl start mongod

Installer Shinken:

git clone https://github.com/naparuba/shinken
yum install git
cd shinken
./install -i && ./install -p nagios-plugins && ./install -a pnp4nagios
ln -s /usr/local/shinken/etc /etc/shinken
ln -s /bin/mail /usr/bin/mail
cd /etc/shinken/

Installer la Webui2:

pip install -r https://raw.githubusercontent.com/shinken-monitoring/mod-webui/develop/requirements.txt
shinken install webui2
htpasswd -c /etc/shinken/htpasswd.users admin

Installer le “vrai” paquet nagios-plugins, et copier ceux-ci dans le répertoire utilisé pour les plugins de Shinken.

yum install nagios-plugins-all
cp -u /usr/lib*/nagios/plugins/* /usr/local/shinken/libexec/
chown shinken.shinken /usr/local/shinken/libexec/*
chmod 755 shinken.shinken /usr/local/shinken/libexec/*

Installer les plugins NRPE:

yum install nagios-plugins-nrpe
cp /usr/lib*/nagios/plugins/check_nrpe /usr/local/shinken/libexec/
chown shinken.shinken /usr/local/shinken/libexec/*
chmod 755 /usr/local/shinken/libexec/*

Il faut installer:

1. Plugin Webservices (Permettra de gérer les communications par service web https://forge.indepnet.net/projects/show/webservices)
2. Plugin FusionInventory (Qui gère l'inventaire des machines. http://fusioninventory.org/wordpress/) (la partie “fusioninventory SNMP” est optionnelle, on peut ne pas cliquer sur “Installer”)
3. Le plugin monitoring (https://forge.indepnet.net/projects/monitoring)

Pour installer un plugin dans GLPI, il suffit de télécharger son archive puis de l'extraire dans le dossier …/glpi/plugins, et de l'installer via l'interface de GLPI.

cd /var/www/glpi/plugins
wget https://github.com/ddurieux/glpi_monitoring/releases/download/0.90%2B1.1/glpi_monitoring_0.90.1.1.tar.gz
tar -xvzf glpi_monitoring_0.90.1.1.tar.gz
rm glpi_monitoring_0.90.1.1.tar.gz
wget https://github.com/fusioninventory/fusioninventory-for-glpi/releases/download/glpi090%2B1.3/fusioninventory-for-glpi_0.90.1.3.tar.gz
tar -xvzf fusioninventory-for-glpi_0.90.1.3.tar.gz
rm fusioninventory-for-glpi_0.90.1.3.tar.gz
wget https://forge.glpi-project.org/attachments/download/2263/glpi-webservices-1.9.0.tar.gz
tar -xvzf glpi-webservices-1.9.0.tar.gz
rm glpi-webservices-1.9.0.tar.gz
chown -R www-data.www-data *

Ensuite, dans l'interface GLPI, aller sous Configuration > Plugins cliquer sur Installer puis Activer.

Il faut créer 2 comptes. Un dans GLPI pour permettre à Shinken de se connecter au plugin Webservices afin de récupérer sa configuration, et un dans la base MySql pour lui donner la possibilité d'altérer la base de données (notamment pour les alertes).

• Créer un compte local GLPI via Administration > Utilisateur
• Créer un compte MySQL car le module Broker de Shinken va ajouter et mettre à jour des évènements dans la base de donées.

Se connecter à la base

mysql -u root -p glpi
Enter password: 

GRANT select,update ON glpi_plugin_monitoring_services TO shinkenbroker IDENTIFIED BY 'password';
GRANT insert ON glpi_plugin_monitoring_serviceevents TO shinkenbroker;
GRANT select,update ON glpi_plugin_monitoring_servicescatalogs TO shinkenbroker;
exit

Le premier “GRANT” va aussi créer l'utilisateur shinkenbroker, il doit donc contenir le mot de passe.

Configurer les services web de GLPI pour Shinken Dans GLPI, aller dans le menu Plugins > Web Services, et ajouter un nouveau service web. Mettre les valeurs :

1. Nom : Shinken
2. Services actifs : Oui
3. Activer la compression : Non (pas testé avec la compression activée)
4. Tracer les connexions : Non (activez le si vous voulez garder une trace des connexions)
5. Debug : Non (activer pour le debugging)
6. Motif SQL des services : .*
7. Plage d'adressage IP : définir une plage IP, dans ce cas, mettre 2 fois la même IP du serveur ou Shinken est installé
8. Utilisateur: (laisser vide dans ce cas)
9. Mot de passe: (laisser vide dans ce cas)

Cliquer sur le bouton ajouter. Le service web pour Shinken est bien créé et donne accès à Shinken.”

Il faut paramétrer les daemons Arbiter et Broker pour qu'il puissent, respectivement, se connecter à GLPI et se connecter à la BDD. La configuration des modules se trouve dans le fichier shinken-specific.cfg dans /usr/local/shinken/etc/

Ici on ne modifie pas vraiment la configuration de l'arbiter mais on lui ajoute un module, lui fournissant les infos pour se connecter à GLPI. Modifiez le bloc suivant, en fonction de votre configuration

define module{
module_name GLPI
module_type glpi
uri http://localhost/glpi/plugins/webservices/xmlrpc.php
login_name glpi
login_password glpi
tag
}

Les valeurs à modifier pour votre environnement sont :

1. uri: url de GLPI, se termine toujours par /plugins/webservices/xmlrpc.php
2. loginname: compte GLPI créé dans “créer des comptes GLPI” - loginpassword: mot de passe du compte GLPI
3. tag: défini l'étiquette si on l'utilise, sinon laisser vide“

Il faut ensuite ajouter le module a l'Arbiter. Chercher le bloc define arbiter et ajoutez GLPI à la ligne modules. L'arbiter chargera alors le module GLPI à son lancement.

define arbiter {
 modules PickleRetentionArbiter, GLPI
 spare 0
 address localhost
 port 7770
 arbiter_name Arbiter-Master
}

C'est la même chose qu'avec Arbiter sauf qu'on définit cette fois l'accès à la base MySql. Dans shinken-specific.cfg modifier le module glpidb

define module{
module_name glpidb
module_type glpidb
database glpi
user root
password root
host localhost
}

Les valeurs à modifier sont :

1. database: nom de la base MySQL de GLPI
2. user: compte MySQL créé plus haut (dans notre exemple, c'est shinkenbroker )
3. password: mot de passe du compte GLPI
4. host: IP ou nom du serveur où le serveur MySQL est installé.

Il faut ensuite ajouter le module au Broker. Chercher le bloc define broker et ajoutez GLPI à la ligne modules.

define broker {
  broker_name broker-1
  data_timeout 120
  check_interval 60
  modules Livestatus, Simple-log, WebUI,NPCDMOD, GLPI
  port 7772
[...]

Par défaut, Shinken charge les object communs comme les commandes, timeperiod, hôtes, services avec ses fichiers locaux. Nous voulons charger la configuration avec GLPI. Pour cela, modifier le fichier nagios.cfg dans /usr/local/shinken/etc/ et commenter les lignes en début de fichier comme suit :

#Configuration files with common objects like commands, timeperiods,
#or templates that are used by the host/service/contacts
#cfg_file=commons.cfg
#cfg_file=commands.cfg
#cfg_file=timeperiods.cfg
#cfg_file=escalations.cfg
#cfg_file=dependencies.cfg
#cfg_file=contacts.cfg
#cfg_dir=/opt/omd/sites/pilot/etc/nagios/conf.d/pilot/dynamic

#Now templates of hosts, services and contacts
#cfg_file=templates.cfg

#Now groups
#cfg_file=servicegroups.cfg
#cfg_file=hostgroups.cfg
#cfg_file=contactgroups.cfg

#and now real hosts, services, packs and
# discovered hosts
#cfg_dir=hosts
#cfg_dir=services
#cfg_dir=packs
#cfg_dir=objects/discovery

# And read triggers from packs too!
#triggers_dir=packs

# Uncomment this for a sample configuration
#cfg_dir=sample

# Some macros
#resource_file=resource.cfg
[...]

Cette partie permet de créer des configurations qui seront récupérés par le système de monitoring, ici Shinken. On va donc configurer :

• Des Calendriers (sur quelle période monitorer ?)
• Des Définitions de contrôle (fréquence des checks)
• Des Commandes - Des Composants (quoi monitorer ?)
• Un Catalogue de composant regroupant les configurations précédentes + les hôtes que l'ont souhaite monitorer selon ces configurations.

Les calendriers sont relativement simples à configurer. Créer un nouveau calendrier, lui donner un nom et cliquer sur ajouter. Il suffit ensuite d'entrer les périodes sur lesquels on souhaite monitorer less hôtes grâce aux menus déroulants.

Pour accéder aux calendriers et en créer : Monitoring > Calendriers

Les calendriers définissent les périodes pour monitorer les hôte :

Un objet calendrier décrit :

• La fréquence des contrôles en jour
• La plage horaire des contrôles dans la journée

Les définitions de contrôle vont permettre de définir la fréquence a laquelle les contrôles sont effectués, au bout de combien d'essais un service ou un hôte est déclaré “down” et le nombre de temps entre chaque essai.

On ne peut pas créer de définition de contrôles, il faudra donc utiliser et éventuellement modifier les 3 déjà éxistants.

Pour les voir aller dans Monitoring > Définition d'un contrôle.

Pour créer un nouvel élément de calendrier:

• Dans la vue par défaut du plugin Monitoring appuyer sur = pour accéder à la vue système
• Dans le menu Calendrier ajouter une élément +
• Créer l'élément de calendrier en indiquant le nom
• Cliquer sur Ajouter

Renseigner les éléments de planification

• Retourner dans le menu calendrier
• Sélectionner le calendrier
• Ajouter autant de plages horaires que nécessaire
• Retourner dans Calendrier puis Sauvegarder

Ici sont définies toutes les commandes que Shinken va utiliser pour surveiller les hôtes (exemple : ping, requètes http…). Habituellement on ne touche pas à ces configurations. On va juste se servir des objets commandes ici pour les ajouter au Catalogue de commandes.

Il est préférable de tester les commandes localement afin de voir si cela fonctionne bien. Par exemple

  user@shinken:~$./check_snmp_storage.pl -H 127.0.0.1 -C public -m / -w 80% -c 90% -G\\ /dev: 0%used(0GB/0GB) /: 20%used(11GB/57GB) (<80%) : OK

Les composants sont une association des 3 objets précédents, qui définiront un contrôle avec :

1. Une commande (ping par exemple)
2. Un calendrier
3. Une définition de contrôle

On définit ici seulement quel service, quel matériel on veut checker chez les hôtes. On associera ensuite un ou plusieurs de ces composants à des hôtes, dans le Catalogue de composants.

Pour accéder aux Composants aller sous Monitoring > Commandes.

• Dans la vue par défaut du plugin Monitoring appuyer sur = pour accéder à la vue système
• Dans le menu Composants ajouter une élément +
• Créer le composant en indiquant :
  • le nom
  • la commande
  • Sélectionner un modèle graphique. La plupart des modèles sont déjà définis. Si vous souhaitez en créer un: Il suffit de mettre la commande dans le champ Example of perfdata for this control et Enregistrer. Le plugin va générer un nouveau modèle.
  • la définition de contrôle
  • la période de contrôle

Et voilà la dernière étape. Un fois les Composants intéressant créés, on les regroupe dans les catalogues de composants, puis on y ajoutera des hôtes. Une fois ceci fait, les hôtes seront monitorés suivant les contrôles définis dans le catalogue ! Configurer le catalogue de composants

• Dans la vue par défaut du plugin Monitoring appuyer sur = pour accéder à la vue système
• Dans le menu Catalogue de Composants ajouter une élément +
• Indiquer le nom du nouveau catalogue
• Puis cliquer sur Ajouter

Mettre à jour le catalogue en indiquant les composants

• Dans le sous menu Composants
• Ajouter les hôtes à monitorer (il est possible d'ajouter les hôtes selon 3 méthodes: Manuellement (hôtes statiques), Selon une règle prédéfinie, Dynamiquement. Seule la première méthode est décrite pour les autres méthodes cf. le guide utilisateur avancé)
• Dans le sous menu Hôtes statiques
  • Sélectionner le type d'hôte à ajouter
  • Sélectionner les hôtes dans la liste

    • Puis cliquer sur Ajouter
    • Dans le sous menu Contacts ajouter un contact (optionnel)
    • Ajouter un contact qui sera prévenu si l'état des composants change (UP, DOWN, WARNING, etc…).
    • Retourner sur l'onglet Catalogue de composantspuis appuyer sur Sauvegarder

    Une fois le catalogue défini, Shinken devrait normalement redémarrer automatiquement.

Retourner dans le catalogue ainsi créer pour vérifier la présence de tous les éléments .

Avec cette intégration à GLPI, Shinken ne perd pas sa fonction d'envoie de mails ! Pour pouvoir envoyer des mails sur des alertes il faut : Définir et assigner un gabarit de contact

L'accès à ce menu se fait par Plugins > Monitoring > Gabarits de contact.

Après avoir créé des gabarits, il faut assigner ce gabarit à un compte utilisateur. Pour faire celà, voir l'onglet Monitoring-Contact dans le formulaire utilisateur (menu Administration > Utilisateurs).

Une fois le gabarit créé et assigné à un utilisateur, il faut ajouter cet utilisateur dans le Catalogue de composants via l'onglet Contacts.

Les mails seront alors envoyé à l'adresse mail définie dans la fiche de l'utilisateur.

Les plugins nagios (et donc les commandes) ont été normalement installés avec Shinken.

Toutes les commandes fournies par Shinken ne sont pas définies dans le plugin glpi_monitoring.

Tableau comparatif des commandes NAGIOS/PLUGIN MONITORING

Shinken est une application permettant la surveillance système et réseau. Elle surveille les hôtes et services spécifiés, alertant lorsque les systèmes vont mal et quand ils vont mieux. C'est un logiciel libre sous licence GNU AGPL. Elle est complètement compatible avec le logiciel Nagios et elle a pour but d'apporter une supervision distribuée et hautement disponible facile à mettre en place. Démarrée comme une preuve de concept pour Nagios sur les architectures distribuées.

À la suite d'un refus en décembre 2009 des développeurs de Nagios de voir Shinken devenir la nouvelle branche de développement de Nagios dans le futur, Shinken peut désormais être considéré comme un projet indépendant de système de surveillance système et réseau

Shinken prend en charge l'importation d'hôtes de GLPI. Les hôtes importés de GLPI seront traités comme des hôtes standard à partir de fichiers plats (héritage, groupes, etc.).

En fait, le plugin monitoring de GLPI permet d'offrir un interface d'administration graphique à SHINKEN (les modules WEB de celui-ci n'ontr qu'une approche utilisateur). Mais on peut toujours avoir des fichiers plats ET GLPI pour administrer SHINKEN.

Dans le menu configuration de SHINKEN on peut rapidement voir les limites de celui-ci puisqu'il ne permet pas d'ajouter des éléments de configuration, mais juste de les visualiser.

Dans SHINKEN la configuration est faite dans les fichiers plats de l'application.

En fait le plugin Monitoring de GLPI permet la configuration et l'exécution planifiée de SHINKEN, mais il fait écran :

• On ne peut débugger une commande depuis cet interface
• On ne pas relancer un et un seul check (le relance de SHINKEN depuis GLPI permet de relancer TOUS les checks sur toutes les machines monitorées).

Pour ces raisons il est inintéressant d'utiliser le GUI de SHINKEN.

• Cliquer sur le bonton [Filter] en haut à gauche
• Choisir {All services} pour afficher la table de tous les services
• Ou rechercher un service dans la barre de recherche (nom du composant tel que défini dans GLPI)
• Sélectionner le service (composant)
• Cliquer sur le bouton [Execute an action] en bas à droite
• Choisir {Recheck}

La définition des commandes est réalisée dans GLPI ou à partir de fichiers à plat. Mais il est préférable de mettre au poit les commandes en les testant depuis SHINKEN