Séance 2 : Monitoring des réseaux (2h)

Réalisé par Pr Mbida Mohamed

Plan :
Cours Théorique (45min) :
- Surveillance des équipements réseau (routeurs, commutateurs).
- Utilisation de SNMP et MIB.
Atelier (1h15) :
- Configuration de SNMP sur un routeur/switch virtuel.
- Utilisation de Wireshark pour analyser le trafic SNMP.
Séance 2 : Monitoring des réseaux (2h)

@Théorie (45 min)

1. Surveillance des équipements réseau (routeurs, commutateurs)
 Objectifs de la surveillance réseau :
o Assurer la disponibilité des équipements (routeurs,
commutateurs, points d’accès, etc.) en détectant rapidement les
défaillances.
o Optimiser la performance du réseau en surveillant des indicateurs
clés tels que le trafic, la latence, et le taux d’erreurs.
o Prévenir les incidents en identifiant les comportements anormaux
ou les surcharges potentielles.
 Principaux équipements surveillés :
o Routeurs : Gèrent la transmission des données entre différents
réseaux. Leur disponibilité et performance sont essentielles pour
assurer une connectivité continue.
o Commutateurs (switches) : Distribuent le trafic réseau entre les
différents dispositifs d’un réseau local. Leur surveillance permet de
détecter des problèmes de congestion ou de défaillance de ports.
2. Utilisation de SNMP et MIB
 SNMP (Simple Network Management Protocol) :
o Définition : Protocole standard utilisé pour collecter et organiser
des informations sur les équipements réseau. Il permet la gestion
et la surveillance des dispositifs réseau.
o Fonctionnement : SNMP fonctionne via un modèle de
communication « manager/agent » où le manager interroge les
agents installés sur les équipements.
 o Types de messages SNMP :
 GET/GETNEXT : Pour récupérer des informations.
 SET : Pour modifier la configuration d’un équipement.
 TRAP : Pour que l’équipement envoie une alerte spontanée
au manager en cas d’événement particulier.
 MIB (Management Information Base) :
o Définition : Base de données hiérarchique contenant des objets
gérés (variables) sur les équipements réseau.
o Utilisation : Chaque équipement surveillé dispose d’une MIB
spécifique qui définit les informations accessibles via SNMP. Par
exemple, une MIB peut contenir des indicateurs comme
l’utilisation de la bande passante, l’état des ports ou des erreurs
de transmission.
o Importance pour la supervision : La connaissance de la MIB
permet de configurer correctement les outils de supervision et
d’interpréter les données collectées pour identifier des problèmes.

Atelier Pratique configurations SNMP /

WIRESHARK(1h15)
1. Configuration de SNMP sur un routeur/switch virtuel
 Objectif du TP :
Configurer SNMP sur un équipement réseau virtuel afin de permettre la
collecte des données de supervision.
 Étapes proposées :
1. Mise en place de l’environnement virtuel :
 Utilisez VirtualBox pour lancer une machine virtuelle qui
simule un routeur ou un switch (certains simulateurs ou
appliances virtuelles, comme GNS3 ou Cisco Packet Tracer,
peuvent être utilisés selon les ressources disponibles).
2. Activation et configuration du service SNMP :
 Pour un routeur/switch virtuel basé sur Linux :
 Installer le paquet SNMP (par exemple, snmpd sur
Ubuntu/Debian).
sudo apt update && sudo apt install snmpd snmp
 Modifier le fichier de configuration
(/etc/snmp/[Link]) pour définir la communauté
(exemple : "public") et les adresses autorisées.
 Redémarrer le service SNMP pour appliquer les
modifications.
sudo systemctl restart snmpd
 Pour un environnement Windows ou une appliance dédiée
:
 Accédez aux paramètres SNMP du système et activez
le service en configurant la communauté et les
autorisations nécessaires.
Vérifiez le pare-feu (UFW) :
Autorisez le port SNMP (UDP 161) depuis votre réseau :
sudo ufw allow from [Link]/24 to any port 161 proto
udp
3. Vérification de la configuration :
 Utilisez une commande comme snmpwalk pour interroger
l’équipement et vérifier que les données sont correctement
exposées.
{

Étapes de modification du fichier [Link]

1. Ouvrir le fichier en tant qu'administrateur :

Utilisez un éditeur de texte en mode superutilisateur. Par exemple, avec
nano :
sudo nano /etc/snmp/[Link]
2. Localiser ou ajouter la directive de communauté :
Dans ce fichier, la directive qui définit la communauté en lecture seule se
présente généralement sous la forme :

rocommunity public

Cependant, cette directive, si elle est définie seule, autorise potentiellement

des requêtes depuis n'importe quelle adresse.
3. Restreindre l'accès aux adresses autorisées :
Pour limiter l'accès à un réseau ou à une adresse spécifique, vous pouvez
ajouter un paramètre indiquant la source (l’adresse IP ou le réseau). Par
exemple, pour autoriser uniquement le réseau [Link]/24, modifiez ou
ajoutez la ligne suivante :
rocommunity public [Link]/24
@Explications :
 o rocommunity : Indique que la communauté est en lecture seule.
o public : Est le nom de la communauté. C'est une chaîne de caractères que les
"managers SNMP" devront utiliser pour interroger l'agent.
o [Link]/24 : Spécifie que seules les adresses appartenant à ce réseau pourront
accéder aux données SNMP.
4. Sauvegarder et fermer le fichier :
o Avec nano, appuyez sur Ctrl+O pour enregistrer, puis sur Ctrl+X pour quitter
l'éditeur.
5. Redémarrer le service SNMP :
Pour appliquer les modifications, redémarrez le service SNMP (le nom du
service peut varier selon la distribution, souvent snmpd) :
sudo systemctl restart snmpd

Exemple complet de modification

Supposons que votre fichier /etc/snmp/[Link] contienne initialement
une ligne comme :

# Exemple par défaut (non restreint) :

rocommunity public
Vous allez la modifier pour restreindre l'accès au réseau [Link]/24. La
ligne modifiée deviendra :

rocommunity public [Link]/24

Ainsi, seules les machines dont l'adresse IP se trouve dans la plage
[Link] à [Link] pourront interroger le service SNMP en utilisant
la communauté "public".

Conseils supplémentaires :
 Sécurité :
La communauté "public" est très courante et connue. Dans un environnement de
production, il est recommandé de la remplacer par une chaîne plus complexe pour éviter des
accès non autorisés.
 Vérification :
Après avoir modifié et redémarré SNMP, vous pouvez utiliser des outils comme snmpwalk
pour tester l'accès depuis une machine autorisée :

snmpwalk -v2c -c public 192.168.1.X

où 192.168.1.X est une adresse du réseau autorisé.

En résumé, pour restreindre l'accès à votre agent SNMP, modifiez la directive

rocommunity dans /etc/snmp/[Link] en y ajoutant l'adresse IP ou le
réseau autorisé, puis redémarrez le service SNMP pour que les modifications
prennent effet.

Exemple de Résultat
 Si la configuration est correcte, vous verrez les données SNMP de votre
machine Ubuntu :

@Conseils de Sécurité
 Évitez d'utiliser public comme nom de communauté : choisissez un mot complexe.
 Limitez toujours l'accès SNMP à des IPs spécifiques.
 Utilisez SNMPv3 pour le chiffrement (plus sécurisé mais plus complexe).

2. Utilisation de Wireshark pour analyser le trafic SNMP

 Objectif du TP :
Capturer et analyser les paquets SNMP échangés entre le manager et
l’équipement configuré.

 Étapes proposées :
1. Lancement de Wireshark :
 Installez et ouvrez Wireshark sur la machine du manager (ou
sur une machine qui peut accéder au réseau virtuel).
2. Capture du trafic :
 Sélectionnez l’interface réseau appropriée pour commencer
la capture.
 Filtrez le trafic en utilisant le filtre snmp pour isoler
uniquement les paquets SNMP.
***************************************Aide *******
 . Générer du trafic SNMP
Avant de lancer la capture, il faut s’assurer que du trafic SNMP est
bien généré sur votre machine. Vous pouvez par exemple utiliser
la commande suivante pour interroger l’agent SNMP local et ainsi
produire des paquets SNMP :
snmpwalk -v2c -c public localhost
Note : Assurez-vous que le service SNMP (snmpd) est bien installé
et en cours d’exécution, et que la communauté « public » est
correctement configurée dans le fichier /etc/snmp/[Link].

2. Lancer Wireshark avec les permissions nécessaires

Pour capturer des paquets sur Ubuntu, vous devez lancer
Wireshark avec les permissions adéquates. Deux options s’offrent
à vous :
 Option recommandée :
Configurez Wireshark pour permettre la capture par des utilisateurs non-
root (en ajoutant votre utilisateur au groupe wireshark). Par exemple :
sudo dpkg-reconfigure wireshark-common
sudo usermod -aG wireshark $USER
Ensuite, déconnectez-vous et reconnectez-vous pour que les
changements prennent effet, puis lancez Wireshark normalement.
 Option alternative (moins recommandée) :
Lancer Wireshark en tant que root (avec sudo), par exemple :
sudo wireshark
Cette méthode présente des risques de sécurité et est à éviter si
possible.

3. Sélectionner l’interface réseau appropriée

1. Ouvrez Wireshark.
2. Dans l’écran de sélection des interfaces, choisissez celle sur laquelle le
trafic SNMP transite.
o Si vous interrogez l’agent SNMP local, vous pouvez choisir
l’interface de loopback (généralement nommée lo) ou l’interface
réseau principale (comme eth0 ou wlan0), selon la configuration
de votre service SNMP.
 o Remarque : Sur certaines configurations, le trafic SNMP peut
transiter par l’interface lo si vous utilisez localhost.

4. Appliquer un filtre de capture ou d’affichage pour SNMP

Pour n’afficher que les paquets SNMP, vous pouvez utiliser l’un
des filtres suivants dans la barre de filtre Wireshark :
 Filtre d’affichage simple :
snmp
 Filtre par port UDP (SNMP utilise généralement le port 161 pour les
requêtes et 162 pour les traps) :
[Link] == 161 or [Link] == 162
Vous pouvez entrer ce filtre dans la barre en haut de Wireshark et
cliquer sur « Apply » (ou appuyer sur Entrée).
Avec Nano
@Sauvegarder (Write Out) :
o Appuyez sur Ctrl + O (la lettre O, pour "Output").
o Nano vous demandera de confirmer le nom du fichier. Appuyez sur
Entrée pour confirmer.
@Quitter :
o Appuyez sur Ctrl + X pour quitter Nano.

5. Démarrer la capture et générer du trafic

1. Cliquez sur le bouton Start Capture (l’icône de requin) pour démarrer la
capture sur l’interface sélectionnée.
2. Dans un terminal, exécutez la commande snmpwalk (ou toute autre
commande SNMP) pour générer du trafic :
snmpwalk -v2c -c public localhost
3. Retournez dans Wireshark et observez les paquets SNMP capturés. Vous
devriez voir des paquets correspondant aux requêtes SNMP (GET,
GETNEXT) et aux réponses envoyées par l’agent.

6. Analyser les paquets SNMP

 Cliquez sur un paquet SNMP pour l’ouvrir dans le volet de détail.
 Dans le panneau d’analyse, développez les sections pour voir les
informations du protocole SNMP, comme la version utilisée, la
communauté, et les OID interrogés.
 Vous pouvez également utiliser Wireshark pour suivre les échanges
SNMP et vérifier que la communication se déroule comme prévu.

Conseils supplémentaires
 Vérifier la configuration de snmpd :
Si vous ne voyez aucun paquet, assurez-vous que votre service SNMP est
configuré pour écouter sur l’interface utilisée et que la configuration de
la communauté est correcte.
 Utiliser un filtre de capture (facultatif) :
Vous pouvez démarrer la capture avec un filtre de capture intégré pour
limiter directement les paquets enregistrés. Dans le champ de capture
d’interface, saisissez par exemple :
udp port 161 or udp port 162
Cela permet de ne capturer que le trafic SNMP dès le départ.
**************************************************
3. Analyse des paquets SNMP :
 Identifiez les différents types de messages SNMP (GET, SET,
TRAP).
 Examinez le contenu des paquets pour voir les données
extraites de la MIB (par exemple, l’état d’un port ou le taux
d’erreurs).
4. Interprétation des résultats :
 Comprenez comment les données collectées par SNMP
peuvent être utilisées pour générer des alertes et alimenter
des tableaux de bord de supervision.
 Discutez des potentielles anomalies et des informations que
l’on peut déduire de l’analyse du trafic.

Résumé de la séance :
 Théorie (45 min) :
o Introduction à la surveillance des équipements réseau, en insistant
sur l'importance de surveiller les routeurs et commutateurs.
 o Présentation du protocole SNMP et de la MIB, leur rôle dans la
collecte et la gestion des données réseau.
 TP (1h15) :
o Configuration pratique de SNMP sur un routeur/switch virtuel afin
de simuler un environnement de supervision.
o Utilisation de Wireshark pour capturer et analyser le trafic SNMP,
permettant de visualiser concrètement les échanges et d’en
comprendre la structure.

Cette séance permettra aux étudiants de mieux comprendre le

fonctionnement de la surveillance des réseaux et de mettre en pratique
la configuration et l'analyse du protocole SNMP, essentiels pour la
supervision des infrastructures informatiques.

Séance 3 : Outils de supervision open-source (Nagios) (2h)

Partie Théorique (45min) :
- Architecture de Nagios.
- Plugins, services, et hôtes.
Atelier Pratique (1h15)
- Installation de Nagios.
- Configuration d’un hôte et d’un service de surveillance (ex : vérification
CPU).
Objectif : Maîtriser les bases de Nagios pour surveiller des
infrastructures.

Cours Théorique (45 minutes)

1. Architecture de Nagios
Définition :
Nagios est un outil de supervision open-source qui permet de surveiller
l’état d’hôtes (serveurs, routeurs, etc.) et de services (CPU, mémoire,
disque, etc.).
Composants clés :
 Nagios Core : Le moteur principal qui planifie les vérifications et génère
des alertes.
  Plugins : Scripts (exécutables en Bash, Python, etc.) utilisés pour
effectuer des contrôles spécifiques (ex : vérification de l’espace disque).
 Interface Web : Permet de visualiser l’état des hôtes/services et de
configurer des tableaux de bord.
 NRPE (Nagios Remote Plugin Executor) : Permet d’exécuter des plugins sur
des machines distantes.

2. Plugins, services et hôtes

 Hôte : Élément physique ou logique surveillé (ex : un serveur, un switch).

Service : Métrique ou ressource à surveiller sur un hôte (ex : utilisation

CPU, HTTP).

 Plugins :
o Situés dans /usr/lib/nagios/plugins/.
o Exemple : ./check_cpu pour surveiller l’utilisation du processeur.

Atelier 3 : Énoncés (1h15)

Etape 1 : Installation de Nagios
Énoncé :
 Installez Nagios Core sur une machine Ubuntu.
 Accédez à l’interface web via [Link]
 Identifiez les répertoires clés (/usr/local/nagios/, /etc/nagios/).
 Etape 2 : Configuration d’un hôte et d’un service simple
Objectif : Surveiller l’espace disque d’un hôte local avec Nagios.

Instructions à faire :
1. Créez un hôte nommé Mon_Serveur_Local avec l’adresse [Link].
2. Ajoutez un service pour vérifier l’espace disque sur la partition racine (/).
3. Vérifiez la configuration et redémarrez Nagios.

@Étapes simplifiées de l’étape 2

1. Créez un fichier de configuration :
sudo nano /usr/local/nagios/etc/objects/mon_serveur.cfg
2. Ajoutez la configuration de l’hôte :
define host {
host_name Mon_Serveur_Local
alias Mon Serveur Test
address [Link]
check_command check-host-alive
}
3. Ajoutez la configuration du service :
define service {
 host_name Mon_Serveur_Local
service_description Espace Disque Racine
check_command check_local_disk!20%!10%!/
}
Exemple d’affichage pour tester manuellement le disque

4. Incluez le fichier dans [Link] :

sudo nano /usr/local/nagios/etc/[Link]
Ajoutez cette ligne :
cfg_file=/usr/local/nagios/etc/objects/mon_serveur.cfg
5. Validez et redémarrez :
sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/[Link]
sudo systemctl restart nagios

Résultat attendu
 Dans l’interface web Nagios ([Link] vous verrez :
o Hôte : Mon_Serveur_Local avec statut UP.
o Service : Espace Disque Racine avec statut OK (si l’espace est
suffisant).
o Exemple d’affichage :
 Notes
 Commandes clés :
o check-host-alive : Vérifie si l’hôte répond aux pings.
o check_local_disk : Plugin Nagios pour surveiller l’espace disque.
 Seuils :
o 20% : Avertissement si moins de 20% d’espace libre.
o 10% : Alerte critique si moins de 10% d’espace libre.

Questions supplémentaires :
 Explorez les autres services a surveillez, expliquez les résultats obtenus.
 Séance 4 : Supervision avancée avec Zabbix (2h)
@ Cours Théorique :
- Fonctionnalités de Zabbix (modèles, triggers, actions).
- Intégration de bases de données.
@Atelier pratique (1h15) :
- Déploiement de Zabbix Server.
- Création d’un tableau de bord pour surveiller un serveur web.

---
Objectif : Maîtriser les fonctionnalités avancées de Zabbix pour surveiller
des infrastructures complexes.

Théorie (45 minutes)

1. Fonctionnalités de Zabbix
Modèles
 Définition : Pré-configurations réutilisables pour surveiller des dispositifs
similaires (ex : serveurs web, routeurs).
 Exemple : Un modèle "Serveur Web" inclut des métriques comme le
temps de réponse HTTP, l’utilisation CPU, etc.
@ Triggers (Déclencheurs)
 Définition : Règles qui détectent des anomalies en temps réel (ex : seuils
critiques).
 Syntaxe :

@ Actions
 Définition : Réponses automatisées aux déclencheurs (ex : envoi d’email,
exécution de script).
 Exemple : Envoyer une alerte Slack si le CPU dépasse 90%.
Intégration de bases de données
 Rôle : Stocker les données de métriques, configurations, et historiques.
 Bases supportées : MySQL, PostgreSQL, Oracle.
 Avantages : Scalabilité, performances pour les grands volumes de
données.
Atelier : Surveillance d’un serveur web avec Zabbix (1h15)
@ Plan des étapes généralisées
1. Installer Zabbix Server sur une machine Linux.
2. Configurer une base de données MySQL pour Zabbix.
3. Créer un tableau de bord pour surveiller :
o Disponibilité HTTP.
o Charge CPU.
o Espace disque.

Tutoriel complet (environ 1h15) pour installer et configurer Zabbix

Server sur Ubuntu 22.04 (Jammy), avec une base de données
MySQL et la création d’un tableau de bord pour surveiller la
disponibilité HTTP, la charge CPU et l’espace disque.

@ Objectifs :
 Installer Zabbix Server, l’interface web et l’agent sur Ubuntu 22.04.
 Configurer une base de données MySQL dédiée à Zabbix.
 Créer un tableau de bord Zabbix affichant : ( Consultez l’interface Zabbix)
o La disponibilité HTTP via un Web Scenario.
o La charge CPU.
o L’espace disque.
@ Compétences après l’exécution de l’atelier : la collecte de données
via un agent, la surveillance HTTP via un Web Scenario et la création d’un
tableau de bord personnalisé pour le suivi en temps réel.

@ Prérequis :
 Une machine sous Ubuntu 22.04 avec accès sudo.
 Une connexion Internet fonctionnelle.
 Un navigateur web pour accéder à l’interface Zabbix.

Partie I : Installation et configuration de Zabbix Server

1. Ajouter le dépôt officiel Zabbix
Ouvrez un terminal et exécutez :
Wget [Link]
release_6.0-1+ubuntu22.04_all.deb ( ou bien téléchargez directement du site officiel )
 sudo dpkg -i zabbix-release_6.0-1+ubuntu22.04_all.deb
sudo apt update
2. Installer Zabbix Server, l’interface web, les scripts SQL et l’agent
sudo apt install zabbix-server-mysql zabbix-frontend-php zabbix-apache-conf zabbix-sql-scripts
zabbix-agent
3. Installer MySQL Server
Si MySQL (ou MariaDB) n’est pas installé, installez-le :
sudo apt install mysql-server
4. Configurer la base de données MySQL pour Zabbix
4.1 Connectez-vous à MySQL en tant que root :
sudo mysql -uroot -p

4.2 Dans le shell MySQL, créez la base et l’utilisateur :

CREATE DATABASE zabbix CHARACTER SET utf8 COLLATE utf8_bin;
CREATE USER 'zabbix'@'localhost' IDENTIFIED BY 'votre_mot_de_passe';
GRANT ALL PRIVILEGES ON zabbix.* TO 'zabbix'@'localhost';
FLUSH PRIVILEGES;
EXIT;
Information : Remplacez ‘votre_mot_de_passe’ par un mot de passe sécurisé.
4.3 Importer le schéma initial dans la base de données
zcat /usr/share/doc/zabbix-sql-scripts/mysql/[Link] | mysql -uzabbix -p zabbix
Lorsque demandé, saisissez le mot de passe défini précédemment.
5. Configurer Zabbix Server pour utiliser MySQL
Éditez le fichier de configuration :
sudo nano /etc/zabbix/zabbix_server.conf
Recherchez la ligne :
# DBPassword=
Décommentez-la et indiquez le mot de passe, par exemple :
DBPassword=votre_mot_de_passe
Enregistrez et fermez (Ctrl+O, Entrée, Ctrl+X).
7. Démarrer et activer les services
Redémarrez Zabbix et Apache, puis activez-les au démarrage :
sudo systemctl restart zabbix-server zabbix-agent apache2
sudo systemctl enable zabbix-server zabbix-agent apache2
8. Finaliser l’installation via l’interface web
Ouvrez votre navigateur et accédez à :
[Link]
Suivez l’assistant d’installation en validant les prérequis, en renseignant
les paramètres de connexion à la base de données (utilisateur zabbix,
mot de passe, nom de la base : zabbix) et en complétant la configuration.
Une fois terminé, connectez-vous avec l’utilisateur par défaut (Admin /
zabbix).

Partie II : Création du tableau de bord de surveillance

1. Ajouter l’hôte à surveiller
Dans l’interface Zabbix, rendez-vous dans Configuration > Hosts.
A. Cliquez sur Create host.
B. Remplissez les champs :
o Host name : par exemple Serveur_Web.
o Visible name : nom affiché (optionnel).
o Groups : sélectionnez ou créez un groupe (ex. Linux servers).
o Interfaces : ajoutez l’IP de l’hôte (si vous surveillez le même
serveur ou un autre).
2. Associer un template pour la surveillance système
A. Dans l’onglet Templates de l’hôte, cliquez sur Select.
B. Choisissez Template OS Linux qui inclut des éléments de surveillance
pour la charge CPU et l’espace disque.
C. Validez et enregistrez.
3. Créer un Web Scenario pour tester la disponibilité HTTP
A. Dans l’interface, sélectionnez l’hôte concerné et rendez-vous dans
l’onglet Web.
B. Cliquez sur Create web scenario.
C. Remplissez les champs :
o Name : Test HTTP Disponibilité.
 o Application : choisissez ou créez une application, par exemple
Web scenarios.
o Steps : cliquez sur Add pour définir une étape :
 Name : Accès HTTP.
 URL : indiquez l’URL du site à surveiller (ex.
[Link] ou une URL externe).
 Configurez éventuellement d’autres paramètres (timeout,
variables, etc.).
D. Enregistrez le scénario.
4. Créer un tableau de bord personnalisé
A. Dans le menu principal, rendez-vous dans Dashboards.
B. Cliquez sur Create dashboard.
C. Donnez-lui un nom, par exemple Surveillance Serveur Web.
D. Ajoutez des widgets pour afficher :
o Disponibilité HTTP : utilisez le widget Data overview ou Web
scenario availability et sélectionnez le scénario créé.
o Charge CPU : ajoutez un widget Graph ou Latest data lié à l’item
de charge CPU (ex. [Link][all,avg1]).
o Espace disque : ajoutez un widget Graph pour visualiser la
métrique de l’espace disque (ex. [Link][/,free] pour le disque
racine).
E. Organisez les widgets sur le tableau de bord et enregistrez-le.

Partie III : Conclusion et vérifications

 Vérifiez que les services Zabbix sont bien démarrés et que les éléments
de l’hôte sont correctement rafraîchis (attention, il faut parfois quelques
minutes pour voir apparaître les données).
 Testez la visualisation du tableau de bord pour vérifier que la
disponibilité HTTP, la charge CPU et l’espace disque sont correctement
affichés.
 Effectuez les captures d’écrans au furs et a mesure pour rédiger le
compte rendu Zabbix

Cet atelier vous aura permis de mettre en place une solution de

surveillance complète sous Ubuntu 22.04 avec Zabbix, en intégrant
la collecte de données via un agent, la surveillance HTTP via un
 Web Scenario et la création d’un tableau de bord personnalisé
pour le suivi en temps réel.
Bonne réalisation et n’hésitez pas à adapter les paramètres selon
votre environnement !

Séance 5 : Métriques et logs avec Prometheus/Grafana (2h)

Cours Théorique :
- Concepts de métriques temps-réel (Time Series Database).
- Intégration Prometheus + Grafana.
Atelier pratique (1h15):
- Installation de Prometheus et configuration d’exporters (Node Exporter).
- Création d’un dashboard Grafana pour visualiser les données.

Cours Théorique (45 minutes)

1. Concepts des métriques temps-réel (Time Series Database - TSDB)

Objectif : Comprendre le stockage et l’analyse des données temporelles.
Explications :
 Définition d’une TSDB : Base de données optimisée pour stocker des
données indexées par le temps (ex : CPU usage, requêtes HTTP).
 Caractéristiques :
o Données horodatées et non modifiables (append-only).
o Requêtes efficaces pour des intervalles temporels.
o Compression des données pour réduire l’espace.
 Comparaison avec les bases relationnelles : Moins adaptées pour les
requêtes temporelles massives.
 Cas d’usage : Monitoring, IoT, finance.
2. Intégration Prometheus + Grafana
Objectif : Maîtriser l’écosystème Prometheus/Grafana.
Explications :
 Prometheus :
o Outil de collecte et stockage de métriques (TSDB intégrée).
o Modèle de pull : Scrape les endpoints HTTP exposant des
métriques.
o Composants : Serveur, Exporters (Node Exporter*, etc.),
Alertmanager.
  Grafana :
o Outil de visualisation et création de dashboards.
o Supporte Prometheus, Elasticsearch, MySQL, etc.
 Intégration et déroulement :
o Prometheus collecte les données.
o Grafana se connecte à Prometheus via un datasource pour afficher
les dashboards.

@ Node Exporter* est un outil open source conçu pour collecter et exposer des métriques
système (comme l'utilisation du CPU, de la mémoire, des disques, du réseau, etc.) sur un
serveur. Il s'agit d'un composant essentiel dans les environnements de surveillance,
notamment lorsqu'il est utilisé avec Prometheus.

@ Roles et points clés :

 Collecte de métriques : Le Node Exporter récupère des informations détaillées sur le

fonctionnement du système d'exploitation et du matériel.
 Exposition des données : Il expose ces données sous forme de points de métriques via
une interface HTTP, que des outils comme Prometheus peuvent interroger (scraping)
régulièrement.
 Surveillance et alertes : Les métriques collectées permettent aux équipes de surveiller
en temps réel l'état des serveurs, d'identifier les anomalies et de déclencher des alertes
en cas de problème.
 Installation légère : Généralement déployé comme un service sur les serveurs Linux,
il est conçu pour être léger et peu intrusif.
1. Short-lived jobs
o Il s’agit de tâches éphémères (scripts ou jobs ponctuels) qui
n’existent pas suffisamment longtemps pour être “scrapées”
directement par Prometheus.
o Au lieu de se faire interroger (pull) par Prometheus, elles envoient
(push) leurs métriques au Pushgateway.
2. Pushgateway
o C’est un composant qui permet de stocker temporairement les
métriques de ces jobs de courte durée.
o Prometheus peut ensuite “scraper” le Pushgateway pour
récupérer les métriques, évitant ainsi de perdre des données de
jobs qui se terminent rapidement.
3. Prometheus targets / Jobs / Exporters
o Ce sont les endpoints ou services (Node Exporter, applications,
bases de données, etc.) que Prometheus interroge (pull) à
intervalles réguliers pour collecter leurs métriques.
o Les exporters sont des utilitaires qui exposent des métriques d’un
service donné dans un format que Prometheus peut lire (ex. Node
Exporter pour la métrique système, MySQL Exporter, etc.).
4. Service Discovery
o Permet d’automatiser la détection des cibles (targets) à interroger.
o Peut être basé sur Kubernetes (Prometheus découvre
automatiquement les pods et services à monitorer) ou sur des
fichiers de configuration statiques (file_sd).
o L’idée est d’éviter une configuration manuelle des cibles et de
faciliter l’ajout/suppression de services.
5. Prometheus server
o Cœur de la solution :
 Retrieval : Il récupère (scrape) les métriques depuis les
cibles ou le Pushgateway.
 TSDB (Time Series Database) : Il stocke les métriques
collectées sous forme de séries temporelles.
 HTTP server : Il fournit une interface pour interroger les
données via PromQL et exposer l’UI de Prometheus.
6. PromQL
o Le langage de requête spécifique à Prometheus.
 o Permet de sélectionner, agréger et transformer les métriques
stockées pour créer des graphiques, des tableaux ou des alertes.
7. Prometheus web UI
o Interface intégrée à Prometheus pour visualiser rapidement des
métriques, exécuter des requêtes PromQL et inspecter les
données.
8. Grafana
o Outil externe populaire pour la visualisation et la création de
tableaux de bord (dashboards).
o Il se connecte à Prometheus en tant que source de données pour
afficher des graphiques plus élaborés.
9. API clients
o Applications ou bibliothèques qui peuvent communiquer avec l’API
de Prometheus pour récupérer ou manipuler les métriques.
o Utiles pour intégrer Prometheus dans des solutions
personnalisées.
[Link]
o Gère les alertes générées par Prometheus (en fonction de règles
définies dans des fichiers de configuration).
o Peut envoyer des notifications vers divers canaux (ex. PagerDuty,
Email, Slack, etc.).
o Permet de regrouper, filtrer et inhiber les alertes pour une gestion
plus efficace.
[Link] / Email / etc.
o Exemples de canaux de notification pour les alertes critiques.
o L’Alertmanager est configuré pour informer automatiquement les
bonnes personnes ou systèmes via ces moyens.
Prometheus suit un modèle « pull » en interrogeant régulièrement les
cibles (exporters, services, Pushgateway), stocke les données dans sa
base de séries temporelles (TSDB), et propose une interface pour
requêter et visualiser ces données (PromQL, web UI). L’Alertmanager se
charge de diffuser les alertes selon des règles prédéfinies, et Grafana
peut se brancher sur Prometheus pour offrir des dashboards avancés.

Atelier pratique (1h15)

 Objectif : Installer Prometheus, configurer Node Exporter, et créer un
dashboard Grafana.

Étape 1 : Installation de Prometheus

But : Déployer Prometheus pour collecter des métriques.
1. Téléchargement :

Configuration :
Éditez [Link] pour définir les cibles à scraper :

2. Lancement :

 Vérifiez sur [Link]

Rôle des manipulations :
 scrape_interval : Fréquence de collecte des métriques.
 targets : Endpoints à surveiller (ici, Prometheus lui-même).
Étape 2 : Configuration de Node Exporter
But : Exposer les métriques système (CPU, mémoire, disque).
1. Installation :

2. Mise à jour de Prometheus :

Modifiez [Link] pour ajouter Node Exporter :
 Nb : Redémarrez Prometheus.
Rôle des manipulations :
 Node Exporter expose les métriques système sur le port 9100.
 Prometheus collecte ces données pour analyse.

Étape 3 : Création d’un dashboard Grafana

But : Visualiser les métriques dans Grafana.
1. Installation de Grafana :

1. Configuration du datasource :
o Accédez à [Link] (login: admin/admin).
o Ajoutez un datasource de type "Prometheus".
o URL: [Link]
2. Création du dashboard :
o Cliquez sur "+" → "Dashboard" → "Add new panel".
o Requête Prometheus pour le CPU : ( Ajouter cette requête
Dans la section Query, sur Prometheus )
Enregistrer le Dashboard
 Clique sur Save
 Donne un nom à ton Dashboard (ex : Monitoring CPU)
 Clique sur Save

o Visualisation : Choisissez un graphique en temps réel.

o Ajoutez d’autres panels (mémoire, disque) avec des requêtes
similaires.

Exemple de requêtes :
 Mémoire utilisée : node_memory_MemTotal_bytes -
node_memory_MemFree_bytes

 Espace disque : node_filesystem_avail_bytes{mountpoint="/"}

@ Exemple de captures de metrics CPU / MEMORY/FILESTSTEM usage
 Erreurs courantes :
 Prometheus ne scrappe pas Node Exporter :
oVérifiez que Node Exporter est en marche (ss -tulpn | grep 9100).
o Vérifiez la syntaxe de [Link].
 Grafana n’affiche pas les données :
o Vérifiez le datasource (URL: [Link]
o Testez une requête simple dans l’onglet "Explore" de Grafana.[ref1]
[ref1] Tester une requête simple dans l’onglet "Explore" de Grafana

[ref1] Accéder à l'onglet "Explore"

1. Ouvre Grafana dans ton navigateur :
[Link]
2. Connecte-toi (Identifiants : admin / admin).
3. Va dans "Explore"
o Dans le menu de gauche, clique sur "Explore" (icône en forme de
boussole 🧭).
4. Sélectionne Prometheus comme datasource en haut à gauche.

2️.Lancer une requête Prometheus

1. Dans le champ de requête, écris :
Up
 Cette requête retourne l’état des cibles surveillées par
Prometheus (1 = actif, 0 = inactif).
2. Clique sur "Run Query" pour exécuter la requête.

3️/Lire les résultats

 Si la requête retourne "1" → Prometheus fonctionne et collecte les
données.
  Si la requête retourne "0" ou rien → Vérifie que Prometheus tourne
bien avec :
systemctl status prometheus

4️Tester une requête plus avancée

Pour surveiller l'utilisation du CPU :
rate(node_cpu_seconds_total{mode="user"}[5m])
 Cela affiche l'utilisation moyenne du CPU en mode "user" sur 5
minutes.

Références supplémentaires :
Tutoriel d’aide supplémentaire Constructeurs de requêtes visuelles prometheus :
[Link]
grafana-loki-nouvelle-navigation-flux-de-travail-ameliores-panneaux-heatmap-et-plus-encore/