Monitorer PostgreSQL avec Prometheus et Grafana

Plus une instance PostgreSQL est utilisée et plus il devient crucial de la monitorer. De nombreuses solutions existent, je vais vous en présenter une que j’utilise régulièrement et qui repose sur Prometheus et Grafana et qui permet de faire de beaux tableaux de bord.

Pourquoi cette solution ? Car il est possible de monitorer d’autres programmes ainsi que des serveurs. Il s’agit donc d’une solution très modulaire.

Grafana est un logiciel libre de visualisation de données. Il permet notamment la réalisation de tableaux de bord et s’interface parfaitement avec Prometheus.

Prometheus est un logiciel libre d’enregistrement de métriques en temps réel. Il permet l’interrogation des données à l’aide d’un langage simple (PromQL) et de générer des alertes si besoin.

Exporters : il s’agit de petits logiciels qui permettent de récupérer des données en temps réel dans un format compréhensible par Prometheus. Il en existe de toutes sortes dont celui pour PostgreSQL : Postgres Exporter.

Exporters

Postgres Exporter

Postgres Exporter est l’outil qui va interroger votre instance PostgreSQL est récupérer les métriques nécessaires. Il est en général installé sur le serveur sur lequel se trouve l’instance PostgreSQL mais il peut être installer ailleurs, il doit simplement pouvoir accéder à la base de données.

Notez que Postgres Exporter gère le multi-instance mais ce n’est pour l’instant pas recommandé de l’utiliser. Il faudra donc autant de processus que d’instance PostgreSQL (pour rappel, une instance de PostgreSQL peut posséder plusieurs bases de données).

Attention, il n’est pas possible de sécuriser l’accès aux données exportées par Postgres Exporter directement. L’outil ne gère pas l’authentification, il faut donc utiliser des règle de pare-feu ou un serveur web frontal pour éviter que n’importe qui puisse voir les données.

Installation sur Windows

Commencez par télécharger le logiciel depuis le projet GitHub (dans les Releases).

Il suffit ensuite de le dézipper puis de la placer là où vous le souhaitez.

Créez ensuite un fichier start_127.0.0.1_5432.bat dans le répertoire de Postgres Exporter avec le contenu suivant (en remplaçant l’url d’accès à votre base de données dans le fichier et dans son nom) :

@echo off

REM Déclaration d'une variable pour identifier la source de données
set DATA_SOURCE_NAME=postgresql://postgres:postgres@127.0.0.1:5432/postgres?sslmode=disable

REM Lancement du processus postgres_exporter.exe avec différentes options
postgres_exporter.exe ^
  --web.listen-address=:9187 \
  --collector.database_wraparound ^
  --collector.locks ^
  --collector.long_running_transactions ^
  --collector.postmaster ^
  --collector.stat_activity_autovacuum ^
  --collector.stat_bgwriter ^
  --collector.stat_database ^
  --collector.stat_statements ^
  --collector.stat_user_tables ^
  --collector.statio_user_indexes ^
  --collector.statio_user_tables ^
  --collector.wal

Ce script permet deux choses :

• de gérer la variable DATA_SOURCE_NAME qui permet de déclarer la base de données à surveiller.
• de déclarer et éventuellement modifier facilement les options de surveillance (détaillées ici).
  • L’une des options est web.listen-adress=:9187, il s’agit du port sur lequel les données pourront être récupérées via HTTP.
    9187 est le port par défaut mais vous pouvez en attribuer un autre si celui-ci est déjà utilisé ou si vous avez plusieurs instances à surveiller.

La surveillance peut ensuite démarrer en lançant le fichier bat.

Vous pouvez tester le fonctionnement en récupérant les données collectées en vous rendant à l’adresse suivante : http://serveur:9187, vous devriez récupérer quelques chose qui ressemble à ceci :

# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 0
go_gc_duration_seconds{quantile="0.25"} 0
go_gc_duration_seconds{quantile="0.5"} 0
go_gc_duration_seconds{quantile="0.75"} 0.0005124
go_gc_duration_seconds{quantile="1"} 0.00158
go_gc_duration_seconds_sum 8.0821208
go_gc_duration_seconds_count 30800
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 16
# HELP go_info Information about the Go environment.
# TYPE go_info gauge
go_info{version="go1.21.3"} 1
...

Un service peut ainsi être créé pour automatiser le processus. Pour cela vous aurez besoin du logiciel gratuit NSSM qui permet de créer des service Windows pour tout et n’importe quoi. Notez que Grafana embarque NSSM, si vous avez prévu d’installer Grafana, vous pouvez attendre de l’avoir fait plutôt que de télécharger NSSM.

Une fois récupérer, vous pourrez créer un service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" install "Prometheus - Postgres Exporter - 127.0.0.1:5432" "C:\chemin\vers\start_127.0.0.1_5432.bat" Start Automatic

Vous pourrez supprimer le service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" remove "Prometheus - Postgres Exporter - 127.0.0.1:5432" confirm

Installation sur Linux

L’installation sous Linux (Ubuntu/Debian) démarre avec les commandes suivantes :

# Création d'un utilisateur dédié (si vous avez déjà PostgreSQL installé il est probable que l'utilisateur existe déjà)
sudo useradd postgres --shell /bin/bash

# Création d'un répertoire dédié
sudo mkdir /opt/postgres_exporter

# Téléchargement de Postgres_exporter
# Attention à la verion, dans le doute RDV sur le projet GitHub : https://github.com/prometheus-community/postgres_exporter
sudo wget -P /opt/postgres_exporter https://github.com/prometheus-community/postgres_exporter/releases/download/v0.15.0/postgres_exporter-0.15.0.linux-amd64.tar.gz

# Décrompression
sudo tar xvzf /opt/postgres_exporter/postgres_exporter-0.15.0.linux-amd64.tar.gz -C /opt/postgres_exporter

# Nettoyage
sudo rm /opt/postgres_exporter/postgres_exporter-0.15.0.linux-amd64.tar.gz

# Retrait du numero de version dans le nom du répertoire
sudo mv /opt/postgres_exporter/postgres_exporter-0.15.0.linux-amd64 /opt/postgres_exporter/postgres_exporter

# Gestion du propriétaire des fichiers
sudo chown postgres:postgres -R /opt/postgres_exporter

Créons le fichier de configuration des variables d’environnement :

sudo nano /opt/postgres_exporter/postgres_exporter_127.0.0.1_5432.env

Ajoutez alors la configuration suivante :

# BDD à monitorer
DATA_SOURCE_NAME="postgresql://postgres:postgres@127.0.0.1:5432/?sslmode=disable"

Il faut maintenant mettre en place le service qui gèrera Postgres Exporter. Ajoutez une information sur l’instance monitorée car postgres_exporter ne gère pas correctement le multi-instance.

sudo nano /etc/systemd/system/postgres_exporter_127.0.0.1_5432.service

Puis renseignez les éléments suivants :

[Unit] 
Description=Prometheus exporter for Postgresql
Wants=network-online.target 
After=network-online.target 

[Service] 
User=postgres
Group=postgres
Type=simple
Restart=always
RestartSec=1

WorkingDirectory=/opt/postgres_exporter
EnvironmentFile=/opt/postgres_exporter/postgres_exporter_127.0.0.1_5432.env
ExecStart=/opt/postgres_exporter/postgres_exporter/postgres_exporter \
    --web.listen-address=:9187 \
    --collector.database_wraparound \
    --collector.locks \
    --collector.long_running_transactions \
    --collector.postmaster \
    --collector.stat_activity_autovacuum \
    --collector.stat_bgwriter \
    --collector.stat_database \
    --collector.stat_statements \
    --collector.stat_user_tables \
    --collector.statio_user_indexes \
    --collector.statio_user_tables \
    --collector.wal


[Install]
WantedBy=multi-user.target

Nous intégrons dans la ligne de commande différentes options de surveillance (détaillées ici).

• L’une des options est web.listen-adress=:9187, il s’agit du port sur lequel les données pourront être récupérées via HTTP.
  9187 est le port par défaut mais vous pouvez en attribuer un autre si celui-ci est déjà utilisé ou si vous avez plusieurs instances à surveiller.

Utilisez les commandes suivantes pour créer et lancer le service :

# Recharger les paramètres des services
sudo systemctl daemon-reload

# Activer le service au démarrage
sudo systemctl enable postgres_exporter_127.0.0.1_5432.service

# Démarrer le service
sudo systemctl start postgres_exporter_127.0.0.1_5432

# Tester le démarrage du service
sudo systemctl status postgres_exporter_127.0.0.1_5432

Pour voir les logs, vous pouvez utiliser la commande suivante :

sudo journalctl -u postgres_exporter_127.0.0.1_5432.service -f

Vous pouvez tester le fonctionnement en récupérant les données collectées en vous rendant à l’adresse suivante : http://serveur:9187. Vous devriez récupérer quelques chose qui ressemble à ceci :

# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 0
go_gc_duration_seconds{quantile="0.25"} 0
go_gc_duration_seconds{quantile="0.5"} 0
go_gc_duration_seconds{quantile="0.75"} 0.0005124
go_gc_duration_seconds{quantile="1"} 0.00158
go_gc_duration_seconds_sum 8.0821208
go_gc_duration_seconds_count 30800
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 16
# HELP go_info Information about the Go environment.
# TYPE go_info gauge
go_info{version="go1.21.3"} 1
...

Node Exporter

Node Exporter est l’outil qui va collecter les métriques du système Linux.

Attention, il n’est pas possible de sécuriser l’accès aux données exportées par Node Exporter directement. L’outil ne gère pas l’authentification, il faut donc utiliser des règle de pare-feu ou un serveur web frontal pour éviter que n’importe qui puisse voir les données.

L’installation sous Linux (Ubuntu/Debian) démarre avec les commandes suivantes :

# Création d'un utilisateur dédié
sudo useradd node_exporter --shell /bin/bash

# Création d'un répertoire dédié
sudo mkdir /opt/node_exporter

# Téléchargement de Node_exporter
# Attention à la verion, dans le doute RDV sur le site de Prometheus : https://prometheus.io/download/#node_exporter
sudo wget -P /opt/node_exporter https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-amd64.tar.gz

# Décrompression
sudo tar xvzf /opt/node_exporter/node_exporter-1.8.1.linux-amd64.tar.gz -C /opt/node_exporter

# Nettoyage
sudo rm /opt/node_exporter/node_exporter-1.8.1.linux-amd64.tar.gz

# Retrait du numero de version dans le nom du répertoire
sudo mv /opt/node_exporter/node_exporter-1.8.1.linux-amd64 /opt/node_exporter/node_exporter

# Gestion du propriétaire des fichiers
sudo chown node_exporter:node_exporter -R /opt/node_exporter

Il faut maintenant mettre en place le service qui gèrera Node Exporter. Ajoutez une information sur l’instance monitorée car postgres_exporter ne gère pas correctement le multi-instance.

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

Puis renseignez les éléments suivants :

[Unit] 
Description=Prometheus exporter for Linux
Wants=network-online.target 
After=network-online.target 

[Service] 
User=node_exporter
Group=node_exporter
Type=simple
Restart=always
RestartSec=1

WorkingDirectory=/opt/node_exporter
ExecStart=/opt/node_exporter/node_exporter/node_exporter \
    --web.listen-address=:9100 


[Install]
WantedBy=multi-user.target

Nous pouvons intégrer dans la ligne de commande différentes options de surveillance (détaillées ici).

• L’une des options est web.listen-adress=:9100, il s’agit du port sur lequel les données pourront être récupérées via HTTP.
  9100 est le port par défaut mais vous pouvez en attribuer un autre si celui-ci est déjà utilisé.

Utilisez les commandes suivantes pour créer et lancer le service :

# Recharger les paramètres des services
sudo systemctl daemon-reload

# Activer le service au démarrage
sudo systemctl enable node_exporter.service

# Démarrer le service
sudo systemctl start node_exporter

# Tester le démarrage du service
sudo systemctl status node_exporter

Pour voir les logs, vous pouvez utiliser la commande suivante :

sudo journalctl -u node_exporter.service -f

Vous pouvez tester le fonctionnement en récupérant les données collectées en vous rendant à l’adresse suivante : http://serveur:9100. Vous devriez récupérer quelques chose qui ressemble à ceci :

# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 0
go_gc_duration_seconds{quantile="0.25"} 0
go_gc_duration_seconds{quantile="0.5"} 0
go_gc_duration_seconds{quantile="0.75"} 0
go_gc_duration_seconds{quantile="1"} 0
go_gc_duration_seconds_sum 0
go_gc_duration_seconds_count 0
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 7
# HELP go_info Information about the Go environment.
# TYPE go_info gauge
go_info{version="go1.22.3"} 1
...

Windows Exporter

Windows Exporter est l’outil qui va collecter les métriques du système Windows.

La procédure d’installation de cet exporter est bien détaillée sur la page du projet GitHub. Je ne la détaillerai donc pas entièrement ici.

Voici la ligne de commande utilisée pour installer l’exporter :

msiexec /i "C:\chemin_vers\windows_exporter-0.25.1-amd64.msi" LISTEN_PORT=9182 EXTRA_FLAGS="--config.file=""C:\Program Files\windows_exporter\config.yml"""

Cela permet de configurer Windows Exporter avec un fichier de configuration afin de pouvoir facilement modifier certains paramètres si besoin (il suffit ensuite de relancer le service pour prendre en compte le nouveau paramétrage).

Vous pouvez tester le fonctionnement en récupérant les données collectées en vous rendant à l’adresse suivante : http://serveur:9182. Vous devriez récupérer quelques chose qui ressemble à ceci :

# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 0
go_gc_duration_seconds{quantile="0.25"} 0
go_gc_duration_seconds{quantile="0.5"} 0
go_gc_duration_seconds{quantile="0.75"} 0.0005129
go_gc_duration_seconds{quantile="1"} 0.0005364
go_gc_duration_seconds_sum 0.0058283
go_gc_duration_seconds_count 37
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 15
# HELP go_info Information about the Go environment.
# TYPE go_info gauge
go_info{version="go1.21.5"} 1
...

Prometheus

Prometheus est l’outil qui va stocker les données récupérées par Postgres Exporter. Pour cela, il doit pouvoir contacter Postgres Exporter via HTTP.

Prometheus gère l’authentification basique, il faut pour cela suivre la procédure indiquée sur le site officiel : https://prometheus.io/docs/guides/basic-auth

Installation sur Windows

Commencez par télécharger le logiciel depuis le site de Prometheus.

Il suffit ensuite de le dézipper puis de la placer là où vous le souhaitez.

La configuration de Prometheus se fait au travers d’un fichier YAML. Un fichier de configuration de base est fournit, ouvrez le et complétez le avec les informations suivantes :

# Configuration globale
global:
  # Interval global de récupération (défaut 1 min)
  scrape_interval: 15s
  # Interval global d'évaluation des règles (défaut 1 min)
  evaluation_interval: 15s
  # Interval global de timeout (défaut 10s)
  scrape_timeout: 10s

# Gestionnaire d'alertes
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Règles
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# Configuration des data scraper (récupérateurs de données)
scrape_configs:
  # Prometheus lui-même
  # "job_name" est ajouté à chaque donnée récupérée via cette configuration
  - job_name: "Prometheus - Local"
    static_configs:
      # Cible à atteindre
      - targets: ["localhost:9090"]

    # Identifiant et mot de passe pour accéder à Prometheus
    basic_auth:
      username: identifiant
      password: mdp

Nous allons ensuite sécuriser l’accès à Prometheus. Créez un fichier web.yml avec les éléments suivants (pensez à utiliser les mêmes identifiant/mdp dans le fichier précédent : Prometheus doit pouvoir accéder à lui-même pour s’auto-monitorer) :

basic_auth_users:
  # Utilisateur 1 : identifiant: mdp_encrypté
  identifiant: $2a$12$P63ADVOo///fo4HiMm4sYuogjceHfzT3vfShmgAYvEw8v28Bt4GBq

Vous pouvez ajouter autant d’utilisateurs que vous le souhaitez. Le mot de passe doit être spécifié de façon crypté avec bcrypt. Vous pouvez utiliser un crypteur sur le web comme celui-ci.

Créez ensuite un fichier start.bat dans le répertoire de Prometheus avec le contenu suivant (en remplaçant l’url d’accès à votre base de données dans le fichier et dans son nom) :

@echo off

REM Lancement du processus prometheus.exe avec différentes options
prometheus.exe ^
  --web.listen-address=:9090 ^
  --web.config.file=web.yml

Ce script permet de déclarer et éventuellement modifier facilement les options de Prometheus.

• L’option web.listen-adress=:9090 permet de définir le port d’écoute.
  La valeur 9090 est la valeur par défaut, cette option n’est donc pas indispensable dans notre cas.
• L’option web.config.file=web.yml permet d’activer l’authentification.

La surveillance peut ensuite démarrer en lançant le fichier bat.

Vous pouvez tester le fonctionnement en vous rendant sur l’interface de Prometheus à l’adresse suivante : http://serveur:9090. Vous devriez obtenir la page suivante :

Un service peut ainsi être créé pour automatiser le processus. Pour cela vous aurez besoin du logiciel gratuit NSSM qui permet de créer des service Windows pour tout et n’importe quoi. Notez que Grafana embarque NSSM, si vous avez prévu d’installer Grafana, vous pouvez attendre de l’avoir fait plutôt que de télécharger NSSM.

Une fois récupérer, vous pourrez créer un service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" install "Prometheus" "C:\chemin\vers\start.exe" Start Automatic

Vous pourrez supprimer le service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" remove "Prometheus" confirm

Installation sur Linux

L’installation sous Linux (Ubuntu/Debian) démarre avec les commandes suivantes :

# Création d'un utilisateur dédié
sudo useradd prometheus --shell /bin/bash

# Création d'un répertoire dédié et d'un répertoire pour stocker les données
sudo mkdir /opt/prometheus
sudo mkdir /opt/prometheus/data

# Téléchargement de Prometheus
# Attention à la version qu'il vous faudra adapter
sudo wget -P /opt/prometheus https://github.com/prometheus/prometheus/releases/download/v2.51.1/prometheus-2.51.1.linux-amd64.tar.gz

# Décrompression
sudo tar xvzf /opt/prometheus/prometheus-2.51.1.linux-amd64.tar.gz -C /opt/prometheus

# Nettoyage
sudo rm /opt/prometheus/prometheus-2.51.1.linux-amd64.tar.gz

# Retrait du numero de version dans le nom du répertoire
sudo mv /opt/prometheus/prometheus-2.51.1.linux-amd64 /opt/prometheus/prometheus

# Gestion du propriétaire des fichiers
sudo chown prometheus:prometheus -R /opt/prometheus

La configuration de Prometheus se fait au travers d’un fichier YAML. Un fichier de configuration de base est fournit, ouvrez le :

sudo nano /opt/prometheus/prometheus/prometheus.yml

# Configuration globale
global:
  # Interval global de récupération (défaut 1 min)
  scrape_interval: 15s
  # Interval global d'évaluation des règles (défaut 1 min)
  evaluation_interval: 15s
  # Interval global de timeout (défaut 10s)
  scrape_timeout: 10s

# Gestionnaire d'alertes
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Règles
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# Configuration des data scraper (récupérateurs de données)
scrape_configs:
  # Prometheus lui-même
  # "job_name" est ajouté à chaque donnée récupérée via cette configuration
  - job_name: "Prometheus - Local"
    static_configs:
      # Cible à atteindre
      - targets: ["localhost:9090"]

    # Identifiant et mot de passe pour accéder à Prometheus
    basic_auth:
      username: identifiant
      password: mdp

Nous allons ensuite sécuriser l’accès à Prometheus. Créez un fichier web.yml avec les éléments suivants (pensez à utiliser les mêmes identifiant/mdp dans le fichier précédent : Prometheus doit pouvoir accéder à lui-même pour s’auto-monitorer) :

sudo nano /opt/prometheus/prometheus/web.yml

basic_auth_users:
  # Utilisateur 1 : identifiant: mdp_encrypté
  identifiant: $2a$12$P63ADVOo///fo4HiMm4sYuogjceHfzT3vfShmgAYvEw8v28Bt4GBq

Vous pouvez ajouter autant d’utilisateurs que vous le souhaitez. Le mot de passe doit être spécifié de façon crypté avec bcrypt. Vous pouvez utiliser un crypteur sur le web comme celui-ci.

La récupération des données peut ensuite démarrer en lançant le programme Prometheus via la commande suivante :

/opt/prometheus/prometheus/prometheus --config.file=prometheus.yml --web.config.file=web.yml

Vous pouvez tester le fonctionnement en vous rendant sur l’interface de Prometheus à l’adresse suivante : http://serveur:9090. Vous devriez obtenir la page suivante :

Notez que le port sur lequel Prometheus est disponible peut être modifier avec l’argument --web.listen-address a ajouter lors du démarrage du programme (comme avec Postgres Exporter).

Il faut maintenant mettre en place le service qui gèrera Prometheus.

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

Puis renseignez les éléments suivants :

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

[Service] 
User=prometheus 
Group=prometheus 
Type=simple
Restart=always
RestartSec=1
ExecStart=/opt/prometheus/prometheus/prometheus \
    --config.file=/opt/prometheus/prometheus/prometheus.yml \
    --web.config.file=/opt/prometheus/prometheus/web.yml \
    --web.listen-address=:9090 \
    --storage.tsdb.path=/opt/prometheus/data \
    --storage.tsdb.retention.time=30d


[Install]
WantedBy=multi-user.target

Utilisez les commandes suivantes pour créer et lancer le service :

# Recharger les paramètres des services
sudo systemctl daemon-reload

# Activer le service au démarrage
sudo systemctl enable prometheus.service

# Démarrer le service
sudo systemctl start prometheus

# Tester le démarrage du service
sudo systemctl status prometheus

Pour voir les logs, vous pouvez utiliser la commande suivante :

sudo journalctl -u prometheus.service -f

Liaison Prometheus – Exporter

Pour que Prometheus récupère les données d’un Exporter que vous avez installé, il vous faut éditer le fichier de configuration YAML.

Ajoutez un nouveau « job » dans la partie scrape_configs.

Pour PostgreSQL :

  # PostgreSQL Monitoring avec postgres_exporter
  - job_name: 'PostgreSQL Exporter'
    scrape_interval: 5s
    static_configs:
      # Cible à atteindre
      - targets: ['127.0.0.1:9187']
        labels:
          # "instance" est ajouté à chaque donnée récupérée et prend la valeur du paramètre <targets>, comme on sait qu'il n'y a qu'un PG derrière, on renomme l'instance
          "instance": "127.0.0.1:5431"

Pour Node Exporter :

 # Linux Monitoring with node_exporter
  - job_name: 'Node Exporter'
    scrape_interval: 15s
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          "instance": "Mon serveur XYZ"

Pour Windows Exporter :

 # Windows Monitoring with windows_exporter
  - job_name: 'Windows Exporter'
    scrape_interval: 15s
    static_configs:
      - targets: ['127.0.0.1:9182']
        labels:
          "instance": "Mon serveur ABC"

Vous pouvez ajouter autant de job que nécessaire, afin que votre Prometheus récupère des données de divers services.

Redémarrez le service de Prometheus et rendez-vous dans la page « Status » => « Target » de l’interface, vous devriez voir la connexion avec Postgres Exporter et Node Exporter

Grafana

Installation sur Windows

Commencez par télécharger le logiciel depuis le site de Grafana.

Il suffit ensuite de le dézipper puis de la placer là où vous le souhaitez.

Le logiciel se lance simplement en démarrant le programme grafana-server.exe situé dans le répertoire bin.

Vous pouvez tester le fonctionnement en vous rendant sur l’interface de Grafana à l’adresse suivante : http://serveur:3000.

Notez que le port sur lequel Grafana est disponible peut être modifier dans le fichier de configuration conf/defaults.ini.

Un service peut ainsi être créé pour automatiser le processus. Pour cela vous aurez besoin du logiciel gratuit NSSM qui permet de créer des service Windows pour tout et n’importe quoi. Notez que Grafana embarque NSSM dans le répertoire svc-x.

Une fois récupérer, vous pourrez créer un service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" install "Grafana" "C:\chemin\vers\grafana-server.exe" Start Automatic

Vous pourrez supprimer le service avec la ligne de commande suivante :

"C:\emplacement\nssm.exe" remove "Grafana" confirm

Installation sur Linux

Il existe une multitude de façon d’installer Grafana sur Linux (Ubuntu/Debian).

L’installation sous Linux démarre avec les commandes suivantes :

# Création d'un utilisateur dédié
sudo useradd grafana --shell /bin/bash

# Création d'un répertoire dédié
sudo mkdir /opt/grafana

# Téléchargement de Prometheus
# Attention à la version qu'il vous faudra adapter
sudo wget -P /opt/grafana https://dl.grafana.com/enterprise/release/grafana-enterprise-11.0.0.linux-amd64.tar.gz

# Décrompression
sudo tar xvzf /opt/grafana/grafana-enterprise-11.0.0.linux-amd64.tar.gz -C /opt/grafana

# Nettoyage
sudo rm /opt/grafana/grafana-enterprise-11.0.0.linux-amd64.tar.gz

# Retrait du numero de version dans le nom du répertoire
sudo mv /opt/grafana/grafana-v11.0.0 /opt/grafana/grafana

# Gestion du propriétaire des fichiers
sudo chown grafana:grafana -R /opt/grafana

Le logiciel se lance simplement en démarrant le programme grafana situé dans le répertoire bin :

grafana server

Vous pouvez tester le fonctionnement en vous rendant sur l’interface de Grafana à l’adresse suivante : http://serveur:3000.

Notez que le port sur lequel Grafana est disponible peut être modifier dans le fichier de configuration conf/defaults.ini.

Il faut maintenant mettre en place le service qui gèrera Grafana.

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

Puis renseignez les éléments suivants :

[Unit] 
Description=Grafana
Wants=network-online.target 
After=network-online.target 

[Service] 
User=grafana
Group=grafana
Type=simple
Restart=always
RestartSec=1
WorkingDirectory=/opt/grafana/grafana
ExecStart=/opt/grafana/grafana/bin/grafana server


[Install]
WantedBy=multi-user.target

Utilisez les commandes suivantes pour créer et lancer le service :

# Recharger les paramètres des services
sudo systemctl daemon-reload

# Activer le service au démarrage
sudo systemctl enable grafana.service

# Démarrer le service
sudo systemctl start grafana

# Tester le démarrage du service
sudo systemctl status grafana

Pour voir les logs, vous pouvez utiliser la commande suivante :

sudo journalctl -u grafana.service -f

Paramétrages

Vous pouvez maintenant accéder à Grafana sur l’adresse http://serveur:3000.

Le premier écran vous demande de vous connecter, utilisez l’identifiant admin avec admin pour mot de passe. L’écrans suivant vous demandera de définir un nouveau mot de passe.

Dans l’interface suivante, cliquer sur l’icone pour ouvrir le menu de gauche puis sur « Add new connection » :

Vous pouvez maintenant ajouter une connexion vers Prometheus en renseignant son url d’accès http://serveur:9090 puis en choisissant le type d’authentification « basique ».

Il ne vous reste plus qu’a créer votre tableau de bord ou en récupérer un déjà créé depuis le site de Grafana.

Voici un exemple de tableau de bord :

Voici le code json à télécharger pour importer ce tableau de bord dans votre Grafana :

Métriques importantes

Quelles sont les métriques importantes à surveiller ?

Tout dépends des usages mais en voici quelques unes que j’ai pu choisir pour PostgreSQL :

• pg_up : l’état actif ou non de l’instance.
  C’est un peu la base de tout le monitoring…
• process_start_time_seconds : le délais d’activité (depuis quand la base est-elle démarrée ?)
  Cela permet de repérer les redémarrages de la base.
• pg_stat_activity_count et pg_settings_max_connections : le nombre de connexions par rapport au nombre total de connexions possibles.
  Pour savoir s’il faut augmenter le pool de connexions disponibles.
• pg_database_size_bytes : la taille totale des bases de l’instance
  Pour identifier celle qui pourrait poser problème et/ou anticiper une augmentation de la capacité du serveur.
• pg_stat_database_xact_commit et pg_stat_database_xact_rollback : le taux de COMMIT et de ROLLBACK.
  S’il y a beaucoup de ROLLBACK, il y a peut être un problème avec certaines requêtes.
• process_resident_memory_bytes et process_cpu_seconds_total : les consommations RAM et CPU.
  Il s’agit plus de valeur indicatives de la charge de la base, il n’y a pas de mise en rapport avec la puissance du serveur et donc pas d’information sur l’état de charge de la machine.
  Il faudra plutot surveiller le serveur en lui-même.
• pg_stat_database_tup_fetched et pg_stat_database_tup_returned : le rapport entre le nombre de tuples lus directement dans le stockage (returned) par rapport au nombre de tuples réellement nécessaires (fetched). Cela permet de déceler un manque d’indexation.
  Par exemple, sur une table de 1000 lignes sans index, une requête avec une clause ne renvoyant que 100 lignes aura un nombre de tuples « returned » de 1000 et un nombre de tuples « fetched » de 100 car il aura fallu scanner toutes les lignes pour récupérer le résultat. Avec un index, la valeur de returned aurait été bien moindre (probablement légèrement supérieur à 100).
  Attention, le nombre de tuples « fetched » ne correspond pas forcément au nombre de tuples retournés au clients ce qui est interessant ici c’est bien le rapport entre les deux valeurs.
  Attention, la valeur porte sur la base entière, il conviendra ensuite d’auditer les requêtes pour identifier l’origine du manque d’indexation.
• pg_stat_database_blks_hit et pg_stat_database_blks_read : le nombre de blocs lu sur le disque (read) par rapport au nombre de bloc lu dans la mémoire tampon (hit).
  Cela permet de détecter un éventuel manque de ressources pour la mémoire tampon (paramètre shared buffer).
• pg_stat_user_tables_n_dead_tup : le nombre de tuples mort (dead tuple).
  Cela permet de surveiller le bon fonctionnement du processus de VACUUM.

Attention, Postgres Exporter se focalise sur une seule base de données et ne permet donc pas d’avoir certaines métriques en « multibase », sur l’instance complète (en fait si mais « c’est compliqué » et non recommandé). Il faudrait ainsi avoir plusieurs Postgres Exporter en parallèle, un pour chaque base d’une instance… Je complèterai cet article lorsque j’aurai identifié une solution (sous peu j’espère)…

D’autres métriques sont intéressantes, notamment si vous avez mis en place de la réplication. Voici quelques ressources utiles :

• Une liste détaillée de métriques : https://www.datadoghq.com/blog/postgresql-monitoring
• Une autre liste de métriques : https://sysdig.com/blog/postgresql-monitoring/
• Des exemples de tableaux de bord : https://promcat.io/apps/postgresql/latest
• Les tableau de bord préconstruits pour Grafana : https://grafana.com/grafana/dashboards/?search=postgresql
  On y trouve beaucoup d’exemples et de bonnes idées.

Retrouvez également quelques éléments dans l’article suivant :

PostgreSQL – Vade-mecum SQL – 7/8 – Administration serveur

Pour les serveurs Windows et Linux, cela dépendra également ce que vous faites avec ceux-ci. Voici ce que je surveille à minima :

• La charge CPU
• La consommation de mémoire RAM
• La consommation d’espace disque
• La quantité d’écriture et de lecture sur le disque et leur rapidité (i/o).
• Eventuellement le nombre d’utilisateur connectés pour un Windows.

Cet article vous a plu ?

N'hésitez pas à le partager, il interessera surement certains de vos contacts.

Les thèmes suivants contiennent des articles en lien avec celui-ci, allez faire un tour :

BDDITPostgreSQL grafanalinuxpostgres exporterprometheuswindows