Prometheus Grafana - Superviser vos serveurs - Français

Sommaire

Présentation
1) Objectifs
2) Préparation de l’environnement
3) Prérequis
4) Déploiement de Prometheus et Grafana
5) Interfaces webs Prometheus et Grafana
6) Déploiement de node_exporter
7) Configuration de Grafana
8) Déploiement de cAdvisor
9) Déploiement de process_exporter
10) Déploiement de blackbox_exporter
11) Déploiement d’Alert Manager
12) Création d’alertes dans Prometheus

Présentation

Dans ce tutoriel, nous allons installer et configurer Prometheus ainsi que Grafana pour superviser notre infrastructure.
Prometheus est un outil qui collecte et stocke des métriques à intervalles réguliers afin de superviser les performances et l’état des systèmes.
Grafana est un autre outil qui permet de visualiser et d’analyser ces métriques à travers des tableaux de bord interactifs.
En somme, Prometheus collecte les données et Grafana les exploite pour en proposer une représentation graphique.

1) Objectifs

1.1) Présentation

Nous souhaitons superviser les serveurs de notre infrastructure afin de connaître leur état en temps réel (utilisation des ressources, disponibilité des services, etc.), mais aussi de pouvoir revenir plusieurs heures ou plusieurs jours en arrière pour observer l’état de l’infrastructure à une date précise.
Nous souhaitons également être alerté si une ressource dépasse un seuil par exemple.

1.2) Infrastructure existante

L’infrastructure existante est composée de 2 serveurs :

srv1 : VM hébergeant une application web (ici : Nextcloud).
srv2 : VM hébergeant Docker pour faire tourner des containers.

1.3) Infrastructure cible (Non-exhaustive)

Ajout d’un nouveau serveur monitoring sous Debian 12 :
- Il hébergera la solution de supervision : Prometheus, Grafana etc…
- La solution sera déployée à l’aide de Docker afin de simplifier son implémentation et ses futures mises à jour.
Ajout d’exporters (sortes d’agents) sur les serveurs à superviser :
- node_exporter : Met à disposition les métriques système d’un serveur. Il sera installé en tant que service systemd, afin d’éviter l’installation de Docker sur des serveurs n’en ayant pas l’utilité.
- cAdvisor : Met à disposition les métriques des containers. Il sera déployé en tant que container en utilisant l’hôte Docker déjà présent.
- Et bien d’autres que nous verrons un peu plus tard dans le tutoriel.

2) Préparation de l’environnement

Remarque 1 : Opérations à réaliser sur tous les serveurs.
Remarque 2 : Le paquet sudo doit être installé.

2.1) Mettre à jour tous les paquets

sudo apt update -y && sudo apt upgrade -y

1	sudo apt update -y && sudo apt upgrade -y

3) Prérequis

Remarque : Opérations à réaliser sur le serveur monitoring.

3.1) Installer Docker

Vous pouvez suivre le tutoriel d’installation de Docker (Moins de 10 minutes)

4) Déploiement de Prometheus et Grafana

Remarque : Opérations à réaliser sur le serveur monitoring.

4.1) Créer un répertoire monitoring

sudo mkdir /monitoring

1	sudo mkdir /monitoring

Le répertoire /monitoring centralise tout ce qui concerne la solution de supervision.

4.2) Créer un fichier docker-compose.yml

sudo nano /monitoring/docker-compose.yml

1	sudo nano /monitoring/docker-compose.yml

Le fichier /monitoring/docker-compose.yml contient la description de la solution de supervision.

Contenu :

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--web.config.file=/etc/prometheus/web.yml"
      - "--storage.tsdb.retention.time=30d"               # Prometheus data retention period (default: 15d)
      - "--web.external-url=http://ip_or_servername:9090" # Change this value, Prometheus external web URL (default: "")
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/rules:/etc/prometheus/rules:ro
      - ./prometheus/web.yml:/etc/prometheus/web.yml:ro
      - prometheus-data:/prometheus
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin                  # Grafana default admin username
      - GF_SECURITY_ADMIN_PASSWORD=Ch@ngeThisPassw0rd # Change this value, Grafana default admin password
    volumes:
      - grafana-storage:/var/lib/grafana
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-storage:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

services:

prometheus:

image: prom/prometheus:latest

container_name: prometheus

command:

- "--config.file=/etc/prometheus/prometheus.yml"

- "--web.config.file=/etc/prometheus/web.yml"

- "--storage.tsdb.retention.time=30d" # Prometheus data retention period (default: 15d)

- "--web.external-url=http://ip_or_servername:9090" # Change this value, Prometheus external web URL (default: "")

ports:

- "9090:9090"

volumes:

- ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro

- ./prometheus/rules:/etc/prometheus/rules:ro

- ./prometheus/web.yml:/etc/prometheus/web.yml:ro

- prometheus-data:/prometheus

restart: unless-stopped

grafana:

image: grafana/grafana:latest

container_name: grafana

ports:

- "3000:3000"

environment:

- GF_SECURITY_ADMIN_USER=admin # Grafana default admin username

- GF_SECURITY_ADMIN_PASSWORD=Ch@ngeThisPassw0rd # Change this value, Grafana default admin password

volumes:

- grafana-storage:/var/lib/grafana

restart: unless-stopped

cadvisor:

image: gcr.io/cadvisor/cadvisor:latest

container_name: cadvisor

ports:

- "8080:8080"

volumes:

- /:/rootfs:ro

- /var/run:/var/run:ro

- /sys:/sys:ro

- /var/lib/docker/:/var/lib/docker:ro

restart: unless-stopped

volumes:

prometheus-data:

grafana-storage:

Important :

--storage.tsdb.retention.time : Durée de rétention des données (par défaut : 15 jours).
--web.external-url : Url à laquelle Prometheus sera accessible depuis un navigateur client.
--GF_SECURITY_ADMIN_USER : Utilisateur admin de Grafana.
--GF_SECURITY_ADMIN_PASSWORD : Mot de passe de l’admin de Grafana (à remplacer).

4.3) Créer les répertoires de configuration pour Prometheus

sudo mkdir /monitoring/prometheus
sudo mkdir /monitoring/prometheus/rules

1 2	sudo mkdir /monitoring/prometheus sudo mkdir /monitoring/prometheus/rules

Ces répertoires contiendront les fichiers de configuration de Prometheus.

4.4) Créer un mot de passe pour sécuriser l’API de Prometheus

Installer python3-bcrypt si ce n’est pas déjà fait :

sudo apt install -y python3-bcrypt

1	sudo apt install -y python3-bcrypt

Générer le hash du mot de passe de l’utilisateur admin de Prometheus :

python3 -c \
  "import getpass, bcrypt; pwd=getpass.getpass('Password:'); print(bcrypt.hashpw(pwd.encode(), bcrypt.gensalt()).decode())"

1 2	python3 -c \ "import getpass, bcrypt; pwd=getpass.getpass('Password:'); print(bcrypt.hashpw(pwd.encode(), bcrypt.gensalt()).decode())"

4.5) Créer un fichier de configuration pour l’API de Prometheus

sudo nano /monitoring/prometheus/web.yml

1	sudo nano /monitoring/prometheus/web.yml

Contenu :

basic_auth_users:
    admin: $2b$12$gdLNi3sJ2CU...

1 2	basic_auth_users: admin: $2b$12$gdLNi3sJ2CU...

Important : Remplacer $2b$12... par le hash du mot de passe généré précédemment.

4.6) Créer un fichier pour la configuration générale de Prometheus

Le fichier de configuration de Prometheus contient une liste de jobs.
Chaque job contient une liste de targets à cibler.

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Contenu :

global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "/etc/prometheus/rules/*.yml"

scrape_configs:
  - job_name: 'prometheus'
    basic_auth:
      username: admin
      password: Ch@ngeThisPassw0rd
    static_configs:
      - targets:
        - 'localhost:9090'

  - job_name: 'cadvisor'
    static_configs:
      - targets:
        - 'cadvisor:8080'

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

global:

scrape_interval: 15s

evaluation_interval: 15s

rule_files:

- "/etc/prometheus/rules/*.yml"

scrape_configs:

- job_name: 'prometheus'

basic_auth:

username: admin

password: Ch@ngeThisPassw0rd

static_configs:

- targets:

- 'localhost:9090'

- job_name: 'cadvisor'

static_configs:

- targets:

- 'cadvisor:8080'

Remarque : password: Ch@ngeThisPassw0rd, le mot de passe de l’admin Prometheus en clair (non haché).

La configuration précédente comporte 2 jobs :

prometheus : Pour récolter les métriques des serveurs Prometheus.
cadvisor : Pour récolter les métriques des containers sur les serveurs Docker. Le nom de serveur cadvisor fait référence au nom du service de même nom défini dans le fichier docker-compose.yml.

4.7) Déployer Prometheus et Grafana

Se déplacer dans le répertoire contenant le fichier docker-compose.yml :

cd /monitoring

1	cd /monitoring

Lancer le déploiement :

docker compose up -d

1	docker compose up -d

4.8) Vérifier l’état des containers

docker compose ps

1	docker compose ps

Important : L’état de chaque container doit être Up.

4.9) Tester la connexion à l’API Prometheus

curl -u admin http://ip_or_servername:9090/metrics

1	curl -u admin http://ip_or_servername:9090/metrics

Remarque : -u admin pour s’authentifier avec l’utilisateur admin.

5) Interfaces webs Prometheus et Grafana

5.1) Lancer l’interface web de Prometheus

Se rendre sur l’interface web de Prometheus à l’adresse http://IPouNomServeur:9090

Remarque : Une authentification sera demandée si vous l’avez configurée précédemment.

Cliquer sur `Status` puis `Target health`.

5.2) Lancer l’interface web de Grafana

Se rendre sur l’interface web de Grafana à l’adresse http://IPouNomServeur:3000

Se connecter avec **l’utilisateur et le mot de passe** définis dans le fichier `docker-compose.yaml` un peu plus tôt.

Remarque : Nous reviendrons plus tard dans Grafana pour le configurer.

6) Déploiement de node_exporter

Remarque 1 : Opérations à réaliser sur chaque serveur à superviser.
Remarque 2 : Il est possible de déployer node_exporter via ansible en utilisant la collection ansible officielle de Prometheus. Dans ce cas, vous pourrez passer ce chapitre.

6.1) Installer curl si nécessaire

sudo apt install -y curl

1	sudo apt install -y curl

6.2) Télécharger la dernière version de node_exporter

curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest \
| grep browser_download_url \
| grep linux-amd64.tar.gz \
| cut -d '"' -f 4 \
| wget -i - -P /tmp

1

2

3

4

5

curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest \

| grep browser_download_url \

| grep linux-amd64.tar.gz \

| cut -d '"' -f 4 \

| wget -i - -P /tmp

6.3) Vérifier le téléchargement

ls -lah /tmp/node_exporter*

1	ls -lah /tmp/node_exporter*

6.4) Extraire node_exporter dans le répertoire /usr/local/bin

sudo tar -xzf /tmp/node_exporter-1.9.1.linux-amd64.tar.gz \
  --wildcards \
  --strip-components=1 \
  -C /usr/local/bin \
  'node_exporter-*/node_exporter'

1

2

3

4

5

sudo tar -xzf /tmp/node_exporter-1.9.1.linux-amd64.tar.gz \

--wildcards \

--strip-components=1 \

-C /usr/local/bin \

'node_exporter-*/node_exporter'

Remarque : Remplacer le numéro de version 1.9.1 par la version téléchargée précédemment.

6.5) Vérifier l’extraction de node_exporter

node_exporter --version

1	node_exporter --version

6.6) Créer un utilisateur pour le service node_exporter

Utilisateur node-exp qui lancera le service systemd node_exporter.

sudo useradd --no-create-home \
  --shell /usr/sbin/nologin \
  --comment "Node Exporter system user" \
  node-exp

1

2

3

4

sudo useradd --no-create-home \

--shell /usr/sbin/nologin \

--comment "Node Exporter system user" \

node-exp

6.7) Créer le service node_exporter

sudo nano /etc/systemd/system/node_exporter.service

1	sudo nano /etc/systemd/system/node_exporter.service

Contenu :

[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node-exp
Group=node-exp
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

1

2

3

4

5

6

7

8

9

10

11

12

13

[Unit]

Description=Prometheus Node Exporter

Wants=network-online.target

After=network-online.target

[Service]

User=node-exp

Group=node-exp

Type=simple

ExecStart=/usr/local/bin/node_exporter

[Install]

WantedBy=multi-user.target

On retrouve bien l’utilisateur créé précédemment ainsi que le groupe du même nom.

6.8) Recharger la configuration de systemd

sudo systemctl daemon-reload

1	sudo systemctl daemon-reload

6.9) Démarrer et activer le service node_exporter

sudo systemctl start node_exporter
sudo systemctl enable node_exporter

1 2	sudo systemctl start node_exporter sudo systemctl enable node_exporter

6.10) Vérifier l’état du service node_exporter

sudo systemctl status node_exporter

1	sudo systemctl status node_exporter

6.11) Vérifier le fonctionnement node_exporter

Appeler le node_exporter en local et à partir du serveur monitoring pour valider son bon fonctionnement.

curl http://IPouNomServeur:9100/metrics

1	curl http://IPouNomServeur:9100/metrics

6.12) Configurer Prometheus pour récupérer les metriques de node_exporter

Remarque : Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Ajouter la configuration suivante :

- job_name: 'node_exporter'
    static_configs:
      - targets:
        - 'ip_or_servername1:9100'
        - 'ip_or_servername2:9100'

1

2

3

4

5

- job_name: 'node_exporter'

static_configs:

- targets:

- 'ip_or_servername1:9100'

- 'ip_or_servername2:9100'

Remarque : Remplacer le nom du serveur pour chaque targets.

6.13) Redémarrer les containers

Remarque : Opérations à réaliser sur le serveur monitoring.

docker compose restart

1	docker compose restart

Commande à exécuter dans le répertoire contenant le fichier docker-compose.yml.

6.14) Vérifier nouveau job dans prometheus

Se rendre sur l’interface web de Prometheus à l’adresse http://IPouNomServeur:9090 puis Status, target health.

L’état de tous les **Endpoints** du job `node_exporter` ajouté précédemment doit être UP.

7) Configuration de Grafana

7.1) Ajouter une source de données

Il faut créer et configurer une source de données (Data Source) de type Prometheus pour que Grafana puisse exploiter les métriques récoltées par notre serveur Prometheus.

Cliquer sur `Connections`, `Data sources`, `Add data source` puis `Prometheus`.

Saisir les informations de la source de données.

Remarque : Le nom de serveur prometheus dans Prometheus server URL correspond au nom du service de même nom dans le fichier docker-compose.yml

Se rendre à la fin du formulaire puis valider la création de la source de données en cliquant sur `Save & test`.

Ce message devrait s’afficher indiquant que tout est OK.

7.2) Import d’un tableau de bord pour node_exporter

La communauté de Grafana partage des Dashboard (Tableaux de bord) ce qui est très utile pour gagner du temps et pouvoir exploiter rapidement les métriques de Prometheus dans Grafana.
Nous utiliserons le tableau de bord 1860 Node Exporter Full pour visualiser les métriques provenant des nodes_exporter.

Cliquer sur le « `+` » en haut à droite puis `Import dashboard`.

Saisir l’**id du dashboard** à importer puis cliquer sur `Load`.

Ne pas oublier de sélectionner la **source de données**, dans notre cas : `prometheus`.

8) Déploiement de cAdvisor

cAdvisor est un outil open source qui collecte et expose des métriques sur l’utilisation des ressources des containers en temps réel. La solution la plus simple consiste à le déployer en tant que container directement sur l’hôte Docker que l’on souhaite superviser.

Remarque : cAdvisor a déjà été déployé précédemment sur le serveur monitoring grâce au service de même nom dans le fichier docker-compose.yml. Nous l’installerons donc sur les autres serveurs docker de notre infrastructure dans notre cas srv2.

Aperçu :

8.1) Créer un répertoire cadvisor

sudo mkdir -p /monitoring/cadvisor

1	sudo mkdir -p /monitoring/cadvisor

8.2) Créer un fichier docker-compose.yml

sudo nano /monitoring/cadvisor/docker-compose.yml

1	sudo nano /monitoring/cadvisor/docker-compose.yml

Contenu :

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

1

2

3

4

5

6

7

8

9

10

11

12

services:

cadvisor:

image: gcr.io/cadvisor/cadvisor:latest

container_name: cadvisor

ports:

- "8080:8080"

volumes:

- /:/rootfs:ro

- /var/run:/var/run:ro

- /sys:/sys:ro

- /var/lib/docker/:/var/lib/docker:ro

restart: unless-stopped

Remarque : Modifier le port 8080:8080 côté hôte si 8080 est déjà utilisé.

8.3) Déployer cAdvisor

Se déplacer dans le répertoire contenant le fichier docker-compose.yml :

cd /monitoring/cadvisor

1	cd /monitoring/cadvisor

Lancer le déploiement de cadvisor :

docker compose up -d

1	docker compose up -d

8.4) Vérifier le déploiement de cAdvisor

docker compose ps

1	docker compose ps

L’état du container cadvisor doit être UP.

8.5) Ajouter une nouvelle cible pour le job cadvisor dans Prometheus

Remarque : Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Aperçu :

Dans notre cas, le job cadvisor a déjà été créé précédemment.
Nous avons donc ajouté une nouvelle cible à `targets` pour cibler le `cadvisor` déployé sur **srv2**.

8.6) Redémarrer les containers

docker compose restart

1	docker compose restart

Remarque : Commande à exécuter dans le répertoire contenant le fichier docker-compose.yml.

8.7) Tester l’exporter cadvisor

Vérifier l’accès aux metrics de cadvisor en local et depuis le serveur monitoring.

curl http://IPouNomServeur:8080/metrics

1	curl http://IPouNomServeur:8080/metrics

Vérifier dans l’interface web :

Une nouvelle cible (target) est maintenant visible et UP dans Prometheus.

8.8) Tableau de bord pour cAdvisor dans Grafana

Il existe de nombreux tableaux de bord pour exploiter les métriques provenant de cAdvisor.
Nous utiliserons le tableaux de bord 13946 Docker-cAdvisor.

9) Déploiement de process_exporter

process_exporter est un outil Prometheus qui collecte des métriques détaillées sur les processus système, comme l’utilisation CPU, mémoire et le nombre de threads, pour superviser les applications et services en profondeur.

9.1) Télécharger la dernière version de process_exporter

Remarque : Opérations à réaliser sur les serveurs pour lesquels ont souhaite observer les processus.

curl -s https://api.github.com/repos/ncabatoff/process-exporter/releases/latest \
| grep browser_download_url \
| grep linux_amd64.deb \
| cut -d '"' -f 4 \
| wget -i - -P /tmp

1

2

3

4

5

curl -s https://api.github.com/repos/ncabatoff/process-exporter/releases/latest \

| grep browser_download_url \

| grep linux_amd64.deb \

| cut -d '"' -f 4 \

| wget -i - -P /tmp

9.2) Installer process_exporter

sudo dpkg -i /tmp/process-exporter_0.8.7_linux_amd64.deb

1	sudo dpkg -i /tmp/process-exporter_0.8.7_linux_amd64.deb

Remarque : Remplacer le numéro de version 0.8.7 par la version téléchargée précédemment.

9.3) Vérifier l’état du service de process_exporter

sudo systemctl status process-exporter.service

1	sudo systemctl status process-exporter.service

9.4) Vérifier l’accès aux métriques de process_exporter

Tester la récupération des métriques en local et depuis le serveur monitoring.

curl http://IPouNomServeur:9256/metrics

1	curl http://IPouNomServeur:9256/metrics

9.5) Ajouter d’un job process_exporter dans Prometheus

Remarque : Opérations à réaliser sur les serveurs monitoring.

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Contenu :

- job_name: 'process_exporter'
    static_configs:
      - targets: ['IPouNomServeur1:9256']
      - targets: ['IPouNomServeur2:9256']
      - targets: ['IPouNomServeur3:9256']

1

2

3

4

5

- job_name: 'process_exporter'

static_configs:

- targets: ['IPouNomServeur1:9256']

- targets: ['IPouNomServeur2:9256']

- targets: ['IPouNomServeur3:9256']

9.6) Redémarrer et vérifier le job process_exporter dans Prometheus

Se déplacer dans le répertoire contenant le fichier docker-compose.yml :

cd /monitoring

1	cd /monitoring

Redémarrer les containers :

sudo docker compose restart

1	sudo docker compose restart

Nouveau job process_exporter visible dans Prometheus :

9.7) Tableau de bord pour process_exporter dans Grafana

Il existe de nombreux tableaux de bord pour exploiter les métriques provenant de process_exporter.
Nous utiliserons le tableaux de bord 22161 process-exporter-dashboard.

Remarque : Ce tableau de bord utilise conjointement node_exporter pour travailler les métriques. Il faudra lui spécifier le port de node_exporter sur les machines cibles.

Aperçu :

9.8) Filtrer les processus surveillés par process_exporter

Il est possible de filtrer les processus surveillés par process_exporter afin d’éviter de collecter trop de métriques et de surcharger Prometheus.
Pour aller plus loin : configuration and group naming

10) Déploiement de blackbox_exporter

blackbox_exporter est un outil de Prometheus qui permet de vérifier la disponibilité et la performance de services réseau (HTTP, DNS, TCP, ICMP, etc.) en effectuant des tests externes, comme un “blackbox”, sans accéder directement à l’intérieur des systèmes.

Remarque : Contrairement aux autres exporters, blackbox_exporter se déploie à un seul endroit et teste les services à distance, sans installation sur les serveurs cibles. Nous l’ajouterons donc en tant que service dans le fichier docker-compose.yml du serveur monitoring.

10.1) Ajouter un service blackbox_exporter au fichier docker-compose.yml

Remarque : Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/docker-compose.yml

1	sudo nano /monitoring/docker-compose.yml

Ajouter le service suivant :

blackbox:
    image: quay.io/prometheus/blackbox-exporter:latest
    container_name: blackbox_exporter
    ports:
      - "9115:9115"
    volumes:
      - ./blackbox_exporter:/config
    command:
      - "--config.file=/config/blackbox.yml"
    restart: unless-stopped

1

2

3

4

5

6

7

8

9

10

blackbox:

image: quay.io/prometheus/blackbox-exporter:latest

container_name: blackbox_exporter

ports:

- "9115:9115"

volumes:

- ./blackbox_exporter:/config

command:

- "--config.file=/config/blackbox.yml"

restart: unless-stopped

10.2) Créer d’un répertoire blackbox_exporter

sudo mkdir /monitoring/blackbox_exporter

1	sudo mkdir /monitoring/blackbox_exporter

10.3) Créer un fichier de configuration pour blackbox_exporter

sudo nano /monitoring/blackbox_exporter/blackbox.yml

1	sudo nano /monitoring/blackbox_exporter/blackbox.yml

Contenu :

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]
      valid_status_codes: []  # Defaults to 2xx
      method: GET
      follow_redirects: true
      fail_if_ssl: false
      fail_if_not_ssl: false
      fail_if_body_matches_regexp:
        - "Could not connect to database"
      #fail_if_body_not_matches_regexp:
      #  - "Download the latest version here"
      tls_config:
        insecure_skip_verify: true
      #preferred_ip_protocol: "ip4" # defaults to "ip6"
      #ip_protocol_fallback: false  # no fallback to "ip6"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

modules:

http_2xx:

prober: http

timeout: 5s

http:

valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]

valid_status_codes: [] # Defaults to 2xx

method: GET

follow_redirects: true

fail_if_ssl: false

fail_if_not_ssl: false

fail_if_body_matches_regexp:

- "Could not connect to database"

#fail_if_body_not_matches_regexp:

# - "Download the latest version here"

tls_config:

insecure_skip_verify: true

#preferred_ip_protocol: "ip4" # defaults to "ip6"

#ip_protocol_fallback: false # no fallback to "ip6"

Le fichier définit des modules, qui sont des modèles de requêtes réutilisables par Prometheus dans ses jobs.
Par exemple, le module http_2xx effectue une requête GET et évalue son succès selon la configuration : le code de retour doit être 2xx et le corps de la réponse ne doit pas contenir la chaîne Could not connect to database.

10.4) Ajouter un job blackbox_exporter dans Prometheus

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Contenu :

- job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]  # Look for a HTTP 200 response.
    static_configs:
      - targets:
        - url1
        - url2
        - url3
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: ip_or_servername:9115 # The blackbox exporter's real hostname:port. 

  - job_name: 'blackbox_exporter'
    static_configs:
      - targets:
        - 'ip_or_servername:9115' # The blackbox exporter's real hostname:port.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

- job_name: 'blackbox'

metrics_path: /probe

params:

module: [http_2xx] # Look for a HTTP 200 response.

static_configs:

- targets:

- url1

- url2

- url3

relabel_configs:

- source_labels: [__address__]

target_label: __param_target

- source_labels: [__param_target]

target_label: instance

- target_label: __address__

replacement: ip_or_servername:9115 # The blackbox exporter's real hostname:port.

- job_name: 'blackbox_exporter'

static_configs:

- targets:

- 'ip_or_servername:9115' # The blackbox exporter's real hostname:port.

Job blackbox  : Teste la disponibilité des services web spécifiés dans targets en utilisant le module http_2xx. Chaque URL est sondée par le Blackbox Exporter central, qui détermine le succès selon le code HTTP et le contenu de la réponse. Il permet de vérifier que les services sont joignables et répondent correctement.
Job blackbox_exporter  : Collecte les métriques opérationnelles du Blackbox Exporter lui-même, comme son état et ses performances internes.

Remarque 1 : Remplacez url1, url2 et url3 par les URLs que vous souhaitez réellement tester.
Remarque 2  : Remplacez ip_or_servername par l’adresse IP ou le nom DNS de votre serveur monitoring.

10.5) Redéploiement de la solution de monitoring

sudo docker compose down
sudo docker compose up -d

1 2	sudo docker compose down sudo docker compose up -d

Commande à lancer dans le répertoire contenant le fichier docker-compose.yml.
docker compose restart ne suffira pas car nous avons modifier la définition du déploiement.

Les jobs blackbox et blackbox_exporter sont bien UP.
**Remarque  :** Un statut UP indique que la sonde (probe) a fonctionné correctement, mais ne garantit pas que le service cible est opérationnel. Pour connaître l’état réel du service, il faut consulter la métrique `probe_success` de la sonde.

10.6) Ajouter un tableau de bord pour blackbox_exporter dans Grafana

Il existe de nombreux tableaux de bord pour exploiter les métriques provenant de blackbox_exporter.
Nous utiliserons le tableaux de bord 18538 BlackBox Exporter.

Aperçu :

Ce tableau de bord permet de visualiser rapidement les services qui ne répondent plus.

11) Déploiement d’Alert Manager

Alertmanager est un outil qui reçoit les alertes de Prometheus, les regroupe, les filtre et les envoie vers des canaux de notification (email, Slack, etc.).

Remarque : Nous déploierons Alert Manager en tant que container sur le serveur monitoring.

11.1) Créer un répertoire alertmanager

sudo mkdir -p /monitoring/alertmanager

1	sudo mkdir -p /monitoring/alertmanager

11.2) Créer un fichier de configuration pour Alertmanager

Le fichier alertmanager.yml définit les destinataires des alertes, les routes de notification et les règles de regroupement des alertes envoyées par Prometheus.

sudo nano /monitoring/alertmanager/alertmanager.yml

1	sudo nano /monitoring/alertmanager/alertmanager.yml

Contenu :

global:
  resolve_timeout: 5m  # Time to consider an alert as resolved

route:
  receiver: "email-alerts"  # Default receiver
  group_by: ['instance','severity'] # Labels to group alerts together
  group_wait: 30s           # Wait time before sending the first notification
  group_interval: 5m        # Interval between notifications for the same group
  repeat_interval: 4h       # Interval to repeat the alert if it persists

receivers:
  - name: "email-alerts"
    email_configs:
      - to: "it-support@example.com"
        from: "alertmanager@example.com"
        smarthost: "smtp.example.com:465"
        auth_username: "alertmanager@example.com"
        auth_password: "Ch@ngeThisP@ssw0rd"
        require_tls: false # Do not require TLS encryption when sending emails
        send_resolved: true # Send notification when the alert is resolved

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

global:

resolve_timeout: 5m # Time to consider an alert as resolved

route:

receiver: "email-alerts" # Default receiver

group_by: ['instance','severity'] # Labels to group alerts together

group_wait: 30s # Wait time before sending the first notification

group_interval: 5m # Interval between notifications for the same group

repeat_interval: 4h # Interval to repeat the alert if it persists

receivers:

- name: "email-alerts"

email_configs:

- to: "it-support@example.com"

from: "alertmanager@example.com"

smarthost: "smtp.example.com:465"

auth_username: "alertmanager@example.com"

auth_password: "Ch@ngeThisP@ssw0rd"

require_tls: false # Do not require TLS encryption when sending emails

send_resolved: true # Send notification when the alert is resolved

Remplacer la configuration mail en fonction de votre service de messagerie.

Remarque : require_tls: false ne signifie pas que la connexion n’est pas chiffrée. Cela indique à Alertmanager de ne pas utiliser STARTTLS, qui n’est pas disponible avec SMTPS (port 465) car la connexion est déjà chiffrée dès le départ.

11.3) Configurer Prometheus pour envoyer les alertes à Alert Manager

sudo nano /monitoring/prometheus/prometheus.yml

1	sudo nano /monitoring/prometheus/prometheus.yml

Ajouter la configuration suivante :

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - "alertmanager:9093"

1

2

3

4

5

alerting:

alertmanagers:

- static_configs:

- targets:

- "alertmanager:9093"

alerting : Section qui indique à Prometheus où envoyer les alertes.
Remarque : Le nom de serveur alertmanager fait référence au service de même nom dans le fichier docker-compose.yml.

Aperçu :

11.4) Déployer Altermanager

Ajouter la définition du service alertmanager dans le fichier docker-compose.yml.

sudo nano /monitoring/docker-compose.yml

1	sudo nano /monitoring/docker-compose.yml

Contenu :

alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager:/etc/alertmanager
    command:
      - "--config.file=/etc/alertmanager/alertmanager.yml"
    restart: unless-stopped

1

2

3

4

5

6

7

8

9

10

alertmanager:

image: prom/alertmanager:latest

container_name: alertmanager

ports:

- "9093:9093"

volumes:

- ./alertmanager:/etc/alertmanager

command:

- "--config.file=/etc/alertmanager/alertmanager.yml"

restart: unless-stopped

Redéployer la solution en prenant en compte l’ajout du nouveau service altermanager :

docker compose down
docker compose up -d

1 2	docker compose down docker compose up -d

Remarque : Commande à lancer dans le répertoire contenant le fichier docker-compose.yml.

11.5) Vérifier le déploiement

Remarque : Commandes à lancer dans le répertoire contenant le fichier docker-compose.yml.

docker compose ps

1	docker compose ps

docker compose logs | egrep -i "error"

1	docker compose logs \| egrep -i "error"

11.6) Vérifier fonctionnement Alertmanager

Se rendre sur l’interface web d’Alertmanager à l’adresse http://IPouNomServeur:9093

12) Création d’alertes dans Prometheus

Important : Les seuils d’alertes définis ici ne sont pas forcemment adaptés à votre infrastructure. Libre à vous de les modifier à votre convenance.

Remarque : Nous déploierons Alert Manager en tant que container sur le serveur monitoring.

12.1) Créer un répertoire pour les règles Prometheus

sudo mkdir -p /monitoring/prometheus/rules

1	sudo mkdir -p /monitoring/prometheus/rules

12.2) Créer des alertes CPU

sudo nano /monitoring/prometheus/rules/infra_cpu.yml

1	sudo nano /monitoring/prometheus/rules/infra_cpu.yml

Contenu :

groups:
- name: cpu_alerts
  rules:
  
  # CRITICAL: CPU > 80% for 3m
  - alert: cpu_saturated
    expr: (100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100)) > 80
    for: 3m
    labels:
      severity: critical
    annotations:
      summary: "CPU saturation on {{ $labels.instance }}"
      description: "Instance {{ $labels.instance }} is saturated. CPU usage has been critically high at {{ $value | humanizePercentage }} for over 3 minutes. This is causing performance degradation and requires immediate action. (Threshold: 80%)"

  # WARNING: CPU > 50% for 5m
  - alert: cpu_high
    expr: (100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100)) > 50
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU usage on {{ $labels.instance }}"
      description: "Instance {{ $labels.instance }} has sustained a high CPU usage of {{ $value | humanizePercentage }} for over 5 minutes. This may indicate increased load or a potential issue that needs investigation. (Threshold: 50%)"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

groups:

- name: cpu_alerts

rules:

# CRITICAL: CPU > 80% for 3m

- alert: cpu_saturated

expr: (100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100)) > 80

for: 3m

labels:

severity: critical

annotations:

summary: "CPU saturation on {{ $labels.instance }}"

description: "Instance {{ $labels.instance }} is saturated. CPU usage has been critically high at {{ $value | humanizePercentage }} for over 3 minutes. This is causing performance degradation and requires immediate action. (Threshold: 80%)"

# WARNING: CPU > 50% for 5m

- alert: cpu_high

expr: (100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100)) > 50

for: 5m

labels:

severity: warning

annotations:

summary: "High CPU usage on {{ $labels.instance }}"

description: "Instance {{ $labels.instance }} has sustained a high CPU usage of {{ $value | humanizePercentage }} for over 5 minutes. This may indicate increased load or a potential issue that needs investigation. (Threshold: 50%)"

Cette configuration indique à Prometheus de surveiller l’utilisation CPU des instances :

cpu_saturated : Déclenche une alerte critical si le CPU dépasse 80% pendant 3 minutes.
cpu_high : Déclenche une alerte warning si le CPU dépasse 50% pendant 5 minutes.

12.3) Créer des alertes Mémoire

sudo nano /monitoring/prometheus/rules/infra_memory.yml

1	sudo nano /monitoring/prometheus/rules/infra_memory.yml

Contenu :

groups:
- name: memory_alerts
  rules:

  # CRITICAL: Memory > 85% for 3m
  - alert: memory_saturated
    expr: (1 - (node_memory_MemAvailable_bytes{} / node_memory_MemTotal_bytes{})) * 100 > 85
    for: 3m
    labels:
      severity: critical
    annotations:
      summary: "Critical memory usage on {{ $labels.instance }}"
      description: "Instance {{ $labels.instance }} has been using {{ $value | humanizePercentage }} of its memory for more than 3 minutes. (Threshold: 85%)"

  # WARNING: Memory > 70% for 5m
  - alert: memory_high
    expr: (1 - (node_memory_MemAvailable_bytes{} / node_memory_MemTotal_bytes{})) * 100 > 70
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High memory usage on {{ $labels.instance }}"
      description: "Instance {{ $labels.instance }} has been using {{ $value | humanizePercentage }} of its memory for more than 5 minutes. (Threshold: 70%)"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

groups:

- name: memory_alerts

rules:

# CRITICAL: Memory > 85% for 3m

- alert: memory_saturated

expr: (1 - (node_memory_MemAvailable_bytes{} / node_memory_MemTotal_bytes{})) * 100 > 85

for: 3m

labels:

severity: critical

annotations:

summary: "Critical memory usage on {{ $labels.instance }}"

description: "Instance {{ $labels.instance }} has been using {{ $value | humanizePercentage }} of its memory for more than 3 minutes. (Threshold: 85%)"

# WARNING: Memory > 70% for 5m

- alert: memory_high

expr: (1 - (node_memory_MemAvailable_bytes{} / node_memory_MemTotal_bytes{})) * 100 > 70

for: 5m

labels:

severity: warning

annotations:

summary: "High memory usage on {{ $labels.instance }}"

description: "Instance {{ $labels.instance }} has been using {{ $value | humanizePercentage }} of its memory for more than 5 minutes. (Threshold: 70%)"

Cette configuration indique à Prometheus de surveiller l’utilisation mémoire des instances :

memory_saturated : Déclenche une alerte critical si la Mémoire dépasse 85% pendant 3 minutes.
memory_high : Déclenche une alerte warning si la Mémoire dépasse 70% pendant 5 minutes.

12.4) Créer une règle de surveillance des disques

sudo nano /monitoring/prometheus/rules/infra_disk.yml

1	sudo nano /monitoring/prometheus/rules/infra_disk.yml

Contenu :

groups:
- name: disk_alerts
  rules:

  # CRITICAL: disk available space < 10 for 5m
  - alert: disk_saturated
    expr: (node_filesystem_avail_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} / node_filesystem_size_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} * 100) < 10
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Critical disk space on {{ $labels.instance }} ({{ $labels.mountpoint }})"
      description: "Mount point {{ $labels.mountpoint }} on {{ $labels.instance }} has only {{ $value | humanizePercentage }} free space left."

  # WARNING: disk available space < 20 for 10m
  - alert: disk_low_free_space
    expr: (node_filesystem_avail_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} / node_filesystem_size_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} * 100) < 20
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "Low disk space on {{ $labels.instance }} ({{ $labels.mountpoint }})"
      description: "Mount point {{ $labels.mountpoint }} on {{ $labels.instance }} has only {{ $value | humanizePercentage }} free space left."

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

groups:

- name: disk_alerts

rules:

# CRITICAL: disk available space < 10 for 5m

- alert: disk_saturated

expr: (node_filesystem_avail_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} / node_filesystem_size_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} * 100) < 10

for: 5m

labels:

severity: critical

annotations:

summary: "Critical disk space on {{ $labels.instance }} ({{ $labels.mountpoint }})"

description: "Mount point {{ $labels.mountpoint }} on {{ $labels.instance }} has only {{ $value | humanizePercentage }} free space left."

# WARNING: disk available space < 20 for 10m

- alert: disk_low_free_space

expr: (node_filesystem_avail_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} / node_filesystem_size_bytes{mountpoint!~"/boot|/tmp.*|/run.*",fstype!~"tmpfs|squashfs|overlay"} * 100) < 20

for: 10m

labels:

severity: warning

annotations:

summary: "Low disk space on {{ $labels.instance }} ({{ $labels.mountpoint }})"

description: "Mount point {{ $labels.mountpoint }} on {{ $labels.instance }} has only {{ $value | humanizePercentage }} free space left."

Cette configuration indique à Prometheus de surveiller l’utilisation mémoire des instances :

disk_saturated : Déclenche une alerte critical si l’espace disque disponible est inférieur à 10% pendant 5 minutes.
disk_low_free_space : Déclenche une alerte warning si l’espace disque disponible est inférieur à 20% pendant 10 minutes.

12.5) Créer des alertes pour les machines injoignables

sudo nano /monitoring/prometheus/rules/infra_node.yml

1	sudo nano /monitoring/prometheus/rules/infra_node.yml

Contenu :

groups:
- name: node_alerts
  rules:

  # CRITICAL: Node down for 1m
  - alert: node_down
    expr: up{job=~".*node.*"} == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Node down: {{ $labels.instance }}"
      description: "Instance {{ $labels.instance }} (job: {{ $labels.job }}) has been unreachable for more than 1 minute. The machine might be powered off or the Node Exporter service is down."

1

2

3

4

5

6

7

8

9

10

11

12

13

groups:

- name: node_alerts

rules:

# CRITICAL: Node down for 1m

- alert: node_down

expr: up{job=~".*node.*"} == 0

for: 1m

labels:

severity: critical

annotations:

summary: "Node down: {{ $labels.instance }}"

description: "Instance {{ $labels.instance }} (job: {{ $labels.job }}) has been unreachable for more than 1 minute. The machine might be powered off or the Node Exporter service is down."

node_down : Déclenche une alerte critical si la machine est injoignable pendant 1 minute.

12.6) Redémarrer les containers

sudo docker compose restart

1	sudo docker compose restart

Remarque : Commande à lancer dans le répertoire contenant le fichier docker-compose.yml.

12.7) Vérifier règles dans Prometheus

12.8) Provoquer des alertes

Pour déclencher une alerte « serveur injoignable », vous pouvez par exemple stoper le service node_exporter sur une machine supervisée.

sudo systemctl stop node_exporter.service

1	sudo systemctl stop node_exporter.service

Pour déclencher une alerte CPU, vous pouvez par exemple lancer la commande suivante qui fera monter le CPU et/ou réduire les seuils CPU pour déclencher l’alerte plus rapidement.

yes > /dev/null

1	yes > /dev/null

12.9) Constater que la cible est injoignable dans Prometheus

12.10) Constater l’alerte dans Prometheus

Dans un premier temps à l’état PENDING :

Puis à l’état FIRING après 1 minutes (comme indiqué dans l’alerte) :

A ce stade, Prometheus a envoyé l’alerte à Alert Manager.

12.11) Constater l’alerte dans Alert Manager

12.12) Constater l’envoi du mail par Alert Manager

Si votre configuration mail est correcte, vous devriez recevoir un mail avec l’alerte.

En savoir plus sur Jj World

Subscribe to get the latest posts sent to your email.