Système de surveillance Prometheus : Guide de configuration complet pour la surveillance des infrastructures et des applications

À mesure que l’infrastructure moderne gagne en complexité — couvrant les microservices, les conteneurs et les systèmes distribués — une surveillance robuste n’est plus optionnelle. C’est une exigence fondamentale pour maintenir les performances, la fiabilité et la scalabilité. Prometheus, une boîte à outils de surveillance et d’alertes open source, s’est imposé comme l’une des solutions les plus largement adoptées pour collecter et visualiser des métriques de séries temporelles dans des environnements variés.

Initialement développé par SoundCloud et désormais un projet diplômé de la Cloud Native Computing Foundation (CNCF), Prometheus est approuvé par des équipes d’ingénierie du monde entier. Ce guide complet couvre tout ce que vous devez savoir : ce qu’est Prometheus, comment il fonctionne, ses composants principaux, et un processus de configuration complet étape par étape — incluant Node Exporter, les tableaux de bord Grafana et la configuration des alertes.

Qu’est-ce que Prometheus ?

Prometheus est un système de surveillance puissant et open source conçu pour collecter, stocker et interroger des données de séries temporelles — des mesures ou événements suivis dans le temps avec des horodatages haute résolution. Il permet aux équipes de visualiser l’état du système, d’analyser les tendances et de déclencher des alertes intelligentes avant que de petits problèmes ne se transforment en pannes critiques.

Fonctionnalités clés de Prometheus

Ces capacités font de Prometheus un choix idéal pour les équipes exécutant des charges de travail sur l’Hébergement VPS, une infrastructure bare-metal ou des plateformes conteneurisées.

Comment fonctionne Prometheus

Prometheus suit une architecture claire et bien définie, construite autour de la collecte et du stockage de données de séries temporelles. Comprendre cette architecture est essentiel avant de le déployer en production.

Flux de travail principal

1. Collecte de métriques (Scraping) : Prometheus envoie périodiquement des requêtes HTTP aux points de terminaison cibles configurés — connus sous le nom d’*exporters* — pour collecter des métriques. L’intervalle de scraping est entièrement configurable.

1. Stockage en séries temporelles : Les métriques collectées sont persistées dans la base de données de séries temporelles (TSDB) intégrée de Prometheus. Chaque point de données porte un horodatage Unix et un ensemble de labels clé-valeur pour l’identification.

1. Interrogation avec PromQL : Les ingénieurs utilisent PromQL pour interroger les métriques stockées, générer des graphiques, créer des tableaux de bord ou définir des conditions d’alerte basées sur des données en temps réel et historiques.

1. Pipeline d’alertes : Lorsqu’une métrique dépasse un seuil prédéfini, Prometheus déclenche une alerte vers l’Alertmanager, qui déduplique, regroupe et achemine les notifications vers les canaux appropriés.

Le modèle par extraction (pull) est un choix architectural délibéré. Il simplifie la sécurité réseau (les cibles n’ont pas besoin d’un accès sortant vers un serveur central), rend la configuration transparente et s’adapte bien aux environnements distribués.

Composants principaux de Prometheus

Prometheus est un écosystème modulaire. Chaque composant remplit un rôle spécifique :

1. Serveur Prometheus

Le moteur central responsable de la récupération des cibles, du stockage des métriques dans la TSDB, de l’évaluation des règles d’alerte, et de la fourniture de l’API PromQL et de l’interface web.

2. Exporters

Les exporters sont des agents légers ou des adaptateurs qui exposent les métriques dans un format compatible Prometheus. Les principaux exporters incluent :

• Node Exporter — Collecte les métriques matérielles et au niveau du système d’exploitation : CPU, mémoire, I/O disque, débit réseau, utilisation du système de fichiers
• Blackbox Exporter — Sonde les points de terminaison externes via HTTP, HTTPS, DNS, TCP et ICMP pour la disponibilité et la latence
• Exporters de bases de données — Des exporters dédiés existent pour PostgreSQL, MySQL, Redis, MongoDB, et bien d’autres
• Exporters spécifiques aux applications — La plupart des applications et frameworks modernes exposent nativement un point de terminaison /metrics

3. Alertmanager

Gère le cycle de vie complet des alertes : réception des alertes de Prometheus, déduplication et regroupement, application des silences et des règles d’inhibition, et acheminement des notifications vers des destinataires tels que Slack, l’e-mail, PagerDuty ou OpsGenie.

4. PromQL (Prometheus Query Language)

Un langage de requête fonctionnel conçu spécifiquement pour les données de séries temporelles. PromQL prend en charge les vecteurs instantanés, les vecteurs de plage, les opérateurs d’agrégation, les fonctions mathématiques et les sous-requêtes — vous offrant une puissance analytique approfondie sur vos métriques.

5. Pushgateway

Conçu pour les tâches éphémères ou par lots qui ne peuvent pas être récupérées directement (par exemple, une tâche cron qui s’exécute pendant 30 secondes). Ces tâches envoient leurs métriques au Pushgateway, que Prometheus récupère ensuite à son intervalle régulier.

6. Grafana

Bien qu’il ne fasse pas partie de Prometheus lui-même, Grafana est la couche de visualisation de facto pour les données Prometheus. Il se connecte à Prometheus en tant que source de données et permet la création de tableaux de bord riches et interactifs avec des panneaux, des variables et des annotations.

Configuration étape par étape de Prometheus sur Linux

Le guide suivant vous accompagne dans un déploiement complet de Prometheus sur un serveur Linux, incluant Node Exporter pour les métriques système, Grafana pour la visualisation et Alertmanager pour les notifications.

> Prérequis : Un serveur Linux (Ubuntu 20.04/22.04 ou CentOS/RHEL 8+), un accès sudo ou root, et une familiarité de base avec la ligne de commande. Si vous avez besoin d’un environnement serveur fiable, envisagez l’Hébergement VPS AlexHost pour une base performante et à faible latence.

Étape 1 : Installer Prometheus

Téléchargez et extrayez la dernière version de Prometheus :

wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

> Conseil : Vérifiez toujours la page des versions officielles de Prometheus pour obtenir la dernière version stable avant de télécharger.

Créez un utilisateur système dédié et une structure de répertoires :

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

Créez un service systemd pour Prometheus :

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

Collez le contenu suivant :

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

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus 
  --config.file=/etc/prometheus/prometheus.yml 
  --storage.tsdb.path=/var/lib/prometheus/ 
  --web.console.templates=/etc/prometheus/consoles 
  --web.console.libraries=/etc/prometheus/console_libraries 
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Activez et démarrez Prometheus :

sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus
sudo systemctl status prometheus

Prometheus sera désormais accessible à l’adresse http://your-server-ip:9090.

Étape 2 : Configurer Prometheus

Le fichier de configuration principal est /etc/prometheus/prometheus.yml. Ce fichier définit les paramètres globaux et les cibles de scraping que Prometheus surveille.

Exemple de configuration de base :

global:
  scrape_interval: 15s        # Default scrape frequency
  evaluation_interval: 15s    # How often alerting rules are evaluated
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - localhost:9093

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

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

Après avoir modifié ce fichier, validez toujours la configuration avant de redémarrer :

promtool check config /etc/prometheus/prometheus.yml
sudo systemctl restart prometheus

Étape 3 : Installer Node Exporter pour les métriques système

Node Exporter expose des métriques matérielles et système détaillées depuis le système hôte — essentielles pour surveiller la charge CPU, la pression mémoire, l’utilisation du disque et le débit réseau.

Téléchargez et installez Node Exporter :

wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -xvf node_exporter-1.6.1.linux-amd64.tar.gz
sudo cp node_exporter-1.6.1.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Créez un service systemd pour Node Exporter :

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

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

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

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter

Node Exporter expose désormais les métriques à l’adresse http://your-server-ip:9100/metrics.

Ajoutez Node Exporter comme cible de scraping dans prometheus.yml :

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node_exporter"
    static_configs:
      - targets: ["localhost:9100"]

Redémarrez Prometheus et vérifiez que la cible apparaît comme UP dans l’interface Prometheus sous Status → Targets.

Étape 4 : Visualiser les métriques avec Grafana

Grafana transforme les métriques brutes de Prometheus en tableaux de bord visuellement riches et exploitables. C’est la couche de visualisation standard pour les déploiements Prometheus.

Installez Grafana sur Ubuntu/Debian :

sudo apt-get install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Connectez Prometheus comme source de données :

1. Ouvrez Grafana à l’adresse http://your-server-ip:3000 (identifiants par défaut : admin / admin)
2. Naviguez vers Configuration → Data Sources → Add data source
3. Sélectionnez Prometheus
4. Définissez l’URL sur http://localhost:9090
5. Cliquez sur Save & Test

Importez un tableau de bord préconstruit :

• Allez dans Dashboards → Import
• Entrez l’ID de tableau de bord 1860 (Node Exporter Full) depuis la marketplace de Grafana
• Sélectionnez votre source de données Prometheus et cliquez sur Import

Vous disposerez immédiatement d’une vue complète de l’utilisation du CPU, de la consommation mémoire, des I/O disque, des statistiques réseau et de la charge système — le tout dans un seul tableau de bord interactif.

Étape 5 : Configurer les règles d’alerte et Alertmanager

Les alertes Prometheus se composent de deux parties : les règles d’alerte définies dans Prometheus, et l’Alertmanager qui gère le routage et la livraison.

Créez un fichier de règles d’alerte :

sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/system_alerts.yml

groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High CPU usage on {{ $labels.instance }}"
          description: "CPU usage has exceeded 80% for more than 5 minutes. Current value: {{ $value }}%"

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Low disk space on {{ $labels.instance }}"
          description: "Available disk space on / is below 15%. Immediate action required."

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage on {{ $labels.instance }}"
          description: "Memory usage has exceeded 85% for more than 5 minutes."

      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instance {{ $labels.instance }} is down"
          description: "Prometheus target {{ $labels.instance }} has been unreachable for more than 1 minute."

Validez le fichier de règles :

promtool check rules /etc/prometheus/rules/system_alerts.yml

Installez et configurez Alertmanager :

wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
sudo cp alertmanager-0.26.0.linux-amd64/alertmanager /usr/local/bin/
sudo mkdir /etc/alertmanager

Créez la configuration Alertmanager :

sudo nano /etc/alertmanager/alertmanager.yml

global:
  smtp_smarthost: 'smtp.yourdomain.com:587'
  smtp_from: 'alerts@yourdomain.com'
  smtp_auth_username: 'alerts@yourdomain.com'
  smtp_auth_password: 'your_password'

route:
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@yourdomain.com'
        send_resolved: true

> Remarque : Pour une livraison d’e-mails professionnelle dans votre pipeline d’alertes, envisagez d’associer Prometheus à l’Hébergement E-mail AlexHost pour une infrastructure SMTP fiable.

Configuration avancée : Découverte de services

Pour les environnements dynamiques — tels que les clusters Kubernetes ou les flottes de serveurs à mise à l’échelle automatique — les listes de cibles statiques deviennent rapidement ingérables. Prometheus prend en charge plusieurs mécanismes de découverte de services prêts à l’emploi :

scrape_configs:
  - job_name: "kubernetes-pods"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

Les backends de découverte de services pris en charge incluent Kubernetes, Consul, EC2, Azure, GCE, la découverte basée sur DNS et la découverte basée sur des fichiers — rendant Prometheus adaptable à pratiquement n’importe quelle topologie d’infrastructure.

Cas d’utilisation de Prometheus

Prometheus excelle dans un large éventail de scénarios de surveillance :

Surveillance de l’infrastructure

Collectez des métriques au niveau du serveur — CPU, mémoire, disque, réseau — depuis chaque nœud de votre flotte. Que vous exploitiez un seul Serveur Dédié ou un grand cluster, Prometheus offre une visibilité unifiée sur tous les hôtes.

Surveillance des performances applicatives (APM)

Suivez les taux de requêtes, les taux d’erreurs, les latences de réponse (la méthode RED) et la consommation de ressources pour les applications web et les API. Les bibliothèques clientes Prometheus sont disponibles pour Go, Python, Java, Ruby, Node.js, et plus encore.

Surveillance de Kubernetes et des conteneurs

Prometheus s’intègre nativement à Kubernetes via les exporters kube-state-metrics et cAdvisor, offrant une visibilité approfondie sur l’état des pods, les quotas de ressources, l’état des déploiements et les métriques au niveau du cluster.

Surveillance des bases de données

Surveillez les performances des requêtes, l’utilisation du pool de connexions, le décalage de réplication et les taux de succès du cache pour des bases de données comme PostgreSQL, MySQL et Redis à l’aide d’exporters dédiés.

Métriques métier personnalisées

Instrumentez vos propres applications pour exposer des métriques spécifiques au domaine — telles que les commandes traitées par seconde, les sessions utilisateurs actives ou les taux de transactions de paiement — permettant une observabilité au niveau métier en complément des métriques techniques.

Surveillance des charges de travail GPU

Pour les équipes exécutant des charges de travail d’apprentissage automatique ou de calcul haute performance, Prometheus peut s’intégrer aux exporters DCGM pour surveiller l’utilisation du GPU, la mémoire et la température. Cela se marie bien avec l’Hébergement GPU AlexHost pour l’infrastructure IA et ML.

Prometheus vs. solutions de surveillance alternatives

Bonnes pratiques en production

Le déploiement de Prometheus en production nécessite une attention à plusieurs aspects opérationnels :

• Rétention des données : La période de rétention par défaut est de 15 jours. Ajustez --storage.tsdb.retention.time en fonction de votre capacité de stockage et de vos exigences de conformité. Pour un stockage à long terme, envisagez Thanos ou Cortex.
• Sécurité : Restreignez l’accès à l’interface web et à l’API Prometheus en utilisant un proxy inverse (Nginx ou Caddy) avec authentification. Prometheus n’inclut pas d’authentification intégrée.
• Haute disponibilité : Exécutez plusieurs instances Prometheus récupérant les mêmes cibles pour la redondance. Utilisez la fonctionnalité de clustering d’Alertmanager pour éviter les notifications en double.
• Gestion de la cardinalité : Évitez les labels à haute cardinalité (par exemple, les ID utilisateurs, les ID de requêtes) dans les noms de métriques, car ils peuvent provoquer des problèmes de mémoire et de performances.
• Chiffrement TLS : Activez TLS pour les points de terminaison de scraping et l’API Prometheus. Associez cela à un Certificat SSL pour sécuriser toutes les communications entre les composants Prometheus.
• Planification des ressources : Prometheus est gourmand en mémoire. Allouez suffisamment de RAM en fonction du nombre de séries temporelles actives. Une règle générale est d’environ 1 à 2 octets par échantillon en mémoire.

Questions fréquemment posées

Q : Quelle est la différence entre Prometheus et Grafana ?

Prometheus est le backend de surveillance et d’alertes — il collecte, stocke et interroge les métriques. Grafana est un frontend de visualisation qui se connecte à Prometheus (et à d’autres sources de données) pour afficher des tableaux de bord. Ce sont des outils complémentaires, pas des alternatives.

Q : Prometheus peut-il surveiller des serveurs Windows ?

Oui. Le Windows Exporter (anciennement WMI Exporter) expose les métriques système Windows dans un format compatible Prometheus, couvrant le CPU, la mémoire, le disque, le réseau, IIS, et plus encore.

Q : Comment Prometheus gère-t-il la haute disponibilité ?

Prometheus lui-même est conçu pour fonctionner comme une instance unique par cluster. Pour la haute disponibilité, vous exécutez deux serveurs Prometheus identiques récupérant les mêmes cibles. Alertmanager prend en charge le clustering natif pour dédupliquer les alertes entre plusieurs instances Prometheus.

Q : À quoi sert PromQL ?

PromQL (Prometheus Query Language) est utilisé pour interroger les données de séries temporelles stockées dans Prometheus. Il prend en charge les requêtes instantanées, les requêtes de plage, les agrégations, les opérations mathématiques et les fonctions — permettant tout, des simples recherches de métriques aux expressions complexes de détection d’anomalies.

Conclusion

Prometheus est une solution de surveillance éprouvée et de qualité production qui offre une visibilité approfondie et en temps réel sur la santé et les performances de l’ensemble de votre pile d’infrastructure. Son architecture par extraction, son modèle de données multidimensionnel, son puissant langage de requête PromQL et ses intégrations transparentes avec des outils comme Grafana et Alertmanager en font la référence absolue pour l’observabilité moderne.

Que vous surveilliez un seul serveur Linux, une flotte de Serveurs Dédiés, un cluster Kubernetes ou une application microservices complexe, Prometheus s’adapte à vos besoins. En suivant les étapes de ce guide — installation de Prometheus, déploiement de Node Exporter, configuration des tableaux de bord Grafana et mise en place de règles d’alerte intelligentes — vous disposerez d’une base de surveillance robuste qui vous aidera à détecter les anomalies tôt, à répondre plus rapidement aux incidents et à améliorer continuellement la fiabilité du système.

Commencez par les bases, affinez vos tableaux de bord et vos seuils d’alerte au fur et à mesure que vous apprenez le comportement normal de votre système, et étendez progressivement la couverture à chaque couche de votre pile. Prometheus n’est pas seulement un outil de surveillance — c’est une pierre angulaire de l’ingénierie moderne de la fiabilité des sites.