Qu’est-ce que Prometheus et pourquoi devrais-je l’utiliser ?

Prometheus est un système de surveillance et d’alerte open source conçu pour la fiabilité et l’évolutivité. Il excelle dans la collecte de métriques en série temporelle provenant de diverses cibles, leur stockage efficace, ainsi que dans la fourniture de capacités de requête puissantes via PromQL. Il est idéal pour les microservices, les conteneurs et les applications natives du cloud.

Quelle est la différence entre Prometheus et les outils de monitoring traditionnels ?

Prometheus utilise un modèle basé sur le pull, au cours duquel il extrait des métriques depuis des cibles à des intervalles réguliers, contrairement aux systèmes basés sur le push. Il possède un modèle de données dimensionnel avec des étiquettes, ce qui le rend flexible pour des requêtes complexes. Il a été conçu pour des environnements cloud dynamiques et s’intègre naturellement avec Kubernetes et les plateformes de orchestration de conteneurs.

Qu’est-ce qu’un exporteur Prometheus ?

Les exporters sont des composants qui exposent des métriques provenant de systèmes tiers au format que Prometheus peut scraper. Parmi les exporters populaires figurent le Node Exporter pour les métriques matérielles/OS, le Blackbox Exporter pour le sondage d’extrémités, ainsi que des exporters spécifiques aux bases de données comme ceux pour MySQL, PostgreSQL, etc. Ils agissent comme des ponts entre Prometheus et les systèmes qui n’exposent pas nativement des métriques.

Le monitoring avec Prometheus peut-il être utilisé pour le journalisation et le traçage ?

Prometheus se concentre spécifiquement sur les métriques. Pour une pile d’observabilité complète, combinez-la avec Loki pour les journaux et Jaeger ou Tempo pour le traçage distribué. Cette combinaison offre des capacités de surveillance, de journalisation et de traçage complètes pour les applications modernes.

Comment échelle-t-on Prometheus pour de grandes déploiements ?

Pour les déploiements à grande échelle, utilisez la fédération Prometheus pour créer des configurations hiérarchiques, implémentez Thanos ou Cortex pour le stockage à long terme et les requêtes globales, ou utilisez des solutions de stockage distant. Mettez en place des politiques de conservation appropriées et utilisez des règles d’enregistrement pour agréger en amont les données fréquemment consultées.

Qu’est-ce que PromQL et à quel point est-il difficile à apprendre ?

PromQL (Prometheus Query Language) est un langage de requête fonctionnel pour sélectionner et agréger des données de séries temporelles. Bien qu’il présente une courbe d’apprentissage, les requêtes de base sont simples. Commencez par des requêtes de métriques simples, puis apprenez progressivement les opérateurs d’agrégation, les fonctions et le filtrage avancé. La documentation officielle propose d’excellents exemples.

Surveillance Prometheus : Configuration complète et bonnes pratiques

Mettez en place une surveillance d'infrastructure robuste avec Prometheus

Sommaire

Prometheus est devenu le standard de facto pour la surveillance des applications et des infrastructures cloud-native, offrant la collecte de métriques, la requête et l’intégration avec des outils de visualisation.

diagramme-technique

Qu’est-ce que Prometheus ?

Prometheus est un outil open source de surveillance et d’alerte initialement développé chez SoundCloud en 2012 et désormais un projet gradué de la Cloud Native Computing Foundation (CNCF). Il est spécifiquement conçu pour la fiabilité et l’évolutivité dans des environnements cloud dynamiques, en devenant ainsi la solution de prédilection pour surveiller les microservices, les conteneurs et les clusters Kubernetes.

Fonctionnalités clés

Base de données en série temporelle : Prometheus stocke toutes les données sous forme de séries temporelles, identifiées par des noms de métriques et des paires clé-valeur (étiquettes), permettant des capacités de requête flexibles et puissantes.

Modèle basé sur le pull : Contrairement aux systèmes traditionnels basés sur le push, Prometheus extrait activement les métriques depuis les cibles configurées à des intervalles spécifiés, ce qui le rend plus fiable et plus facile à configurer.

Langage de requête PromQL : Un langage de requête fonctionnel puissant vous permet de manipuler vos données de métriques en temps réel, effectuant des agrégations, des transformations et des calculs complexes.

Découverte de services : Découverte automatique des cibles de surveillance via divers mécanismes, notamment Kubernetes, Consul, EC2 et les configurations statiques.

Aucune dépendance externe : Prometheus fonctionne comme un seul binaire sans dépendances externes requises, simplifiant le déploiement et réduisant la complexité opérationnelle.

Alertes intégrées : AlertManager gère les alertes provenant de Prometheus, offrant une déduplication, un regroupement et un routage vers des canaux de notification tels que l’e-mail, PagerDuty ou Slack.

Aperçu de l’architecture

Comprendre l’architecture de Prometheus est crucial pour un déploiement efficace. Les composants principaux comprennent :

Serveur Prometheus : Extrait et stocke les métriques, évalue les règles et sert les requêtes
Bibliothèques client : Instrumente le code d’application pour exposer des métriques
Exporters : Pont entre les systèmes tiers et le format Prometheus
AlertManager : Gère les alertes et les notifications
Pushgateway : Accepte des métriques provenant de tâches à courte durée de vie qui ne peuvent pas être extraites

Le flux typique des données : Les applications exposent des points de terminaison de métriques → Prometheus extrait ces points de terminaison → Les données sont stockées dans une base de données en série temporelle → Les requêtes PromQL récupèrent et analysent les données → Des alertes sont générées en fonction des règles → AlertManager traite et route les notifications.

Lors du déploiement d’infrastructures sur Ubuntu 24.04, Prometheus fournit une excellente base pour une surveillance complète.

Installation de Prometheus sur Ubuntu

Passons en revue l’installation de Prometheus sur un système Linux. Nous utiliserons Ubuntu comme exemple, mais le processus est similaire pour d’autres distributions.

Télécharger et installer

Créez d’abord un utilisateur dédié à Prometheus :

sudo useradd --no-create-home --shell /bin/false prometheus

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

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Copiez les binaires et créez des répertoires :

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Pour la gestion des paquets sur Ubuntu, consultez notre guide complet Ubuntu Package Management.

Configurer Prometheus

Éditez /etc/prometheus/prometheus.yml :

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

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

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

Créer un service systemd

Créez /etc/systemd/system/prometheus.service :

[Unit]
Description=Prometheus
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

Démarrer et activer Prometheus :

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

Accédez à l’interface web de Prometheus à http://localhost:9090.

Mise en place de Node Exporter

Node Exporter expose des métriques matérielles et du système d’exploitation pour les systèmes Linux. Installez-le pour surveiller vos serveurs :

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Créez le service systemd /etc/systemd/system/node_exporter.service :

[Unit]
Description=Node Exporter
After=network.target

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

[Install]
WantedBy=multi-user.target

Démarrer Node Exporter :

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

Node Exporter expose maintenant des métriques sur le port 9100.

Comprendre PromQL

PromQL (Prometheus Query Language) est le cœur de la requête de données Prometheus. Voici quelques modèles de requêtes essentiels :

Requêtes de base

Sélectionner toutes les séries temporelles pour une métrique :

node_cpu_seconds_total

Filtrer par étiquette :

node_cpu_seconds_total{mode="idle"}

Filtrer par plusieurs étiquettes :

node_cpu_seconds_total{mode="idle",cpu="0"}

Vecteurs de plage et agrégations

Calculer le taux au fil du temps :

rate(node_cpu_seconds_total{mode="idle"}[5m])

Somme sur tous les processeurs :

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Grouper par étiquette :

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Exemples pratiques

Pourcentage d’utilisation du processeur :

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Utilisation de la mémoire :

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Utilisation du disque :

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Taux de trafic réseau :

rate(node_network_receive_bytes_total[5m])

Déploiement Docker

Lancer Prometheus dans des conteneurs Docker offre de la flexibilité et une gestion plus facile :

Créez docker-compose.yml :

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Démarrer le stack :

docker-compose up -d

Surveillance Kubernetes

Prometheus excelle dans la surveillance des clusters Kubernetes. Le chart Helm kube-prometheus-stack fournit une solution complète de surveillance.

Installez avec Helm :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Cela installe :

Prometheus Operator
Instance Prometheus
AlertManager
Grafana
Node Exporter
kube-state-metrics
Tableaux de bord et alertes préconfigurés

Accédez à Grafana :

kubectl port-forward svc/prometheus-grafana 3000:80

Identifiants par défaut : admin/prom-operator

Pour diverses distributions Kubernetes, le processus de déploiement est similaire avec des ajustements mineurs pour les fonctionnalités spécifiques à la plateforme.

Mise en place des alertes

AlertManager gère les alertes envoyées par Prometheus. Configurez les règles d’alerte et les canaux de notification.

Règles d’alerte

Créez /etc/prometheus/alert_rules.yml :

groups:
  - name: system_alerts
    interval: 30s
    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: "Utilisation élevée du processeur sur {{ $labels.instance }}"
          description: "L'utilisation du processeur dépasse 80% (valeur actuelle : {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilisation élevée de la mémoire sur {{ $labels.instance }}"
          description: "L'utilisation de la mémoire dépasse 85% (valeur actuelle : {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Espace disque faible sur {{ $labels.instance }}"
          description: "L'espace disque disponible est inférieur à 15% sur {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "L'instance {{ $labels.instance }} est hors ligne"
          description: "L'instance {{ $labels.job }} {{ $labels.instance }} est hors ligne depuis plus de 2 minutes"

Configuration d’AlertManager

Créez /etc/prometheus/alertmanager.yml :

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Alerte: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Intégration avec Grafana

Bien que Prometheus ait une interface web basique, Grafana offre une visualisation supérieure pour créer des tableaux de bord complets.

Ajouter Prometheus comme source de données

Ouvrez Grafana et accédez à Configuration → Sources de données
Cliquez sur “Ajouter une source de données”
Sélectionnez “Prometheus”
Définissez l’URL sur http://localhost:9090 (ou votre serveur Prometheus)
Cliquez sur “Enregistrer et tester”

Identifiants de tableaux de bord populaires

Importez des tableaux de bord prédéfinis depuis grafana.com :

Node Exporter Full (ID : 1860) : Métriques Linux complètes
Kubernetes Cluster Monitoring (ID : 7249) : Aperçu de K8s
Docker Container Monitoring (ID : 193) : Métriques conteneurs
Prometheus Stats (ID : 2) : Métriques internes de Prometheus

Créer des tableaux de bord personnalisés

Créez des panneaux à l’aide de requêtes PromQL :

{
  "title": "Utilisation du processeur",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Exporters populaires

Étendez la surveillance Prometheus avec des exporteurs spécialisés :

Blackbox Exporter

Teste les points de terminaison via HTTP, HTTPS, DNS, TCP et ICMP :

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Exporters de base de données

mysqld_exporter : Métriques MySQL/MariaDB
postgres_exporter : Métriques PostgreSQL
mongodb_exporter : Métriques MongoDB
redis_exporter : Métriques Redis

Exporters d’applications

nginx_exporter : Métriques du serveur web NGINX
apache_exporter : Métriques du serveur HTTP Apache
haproxy_exporter : Métriques du balanceur de charge HAProxy

Exporters de cloud

cloudwatch_exporter : Métriques AWS CloudWatch
stackdriver_exporter : Métriques Google Cloud
azure_exporter : Métriques Azure Monitor

Bonnes pratiques

Conservation des données

Configurez une conservation appropriée selon vos besoins :

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Règles d’enregistrement

Précalculez les expressions fréquemment requises :

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Gestion des étiquettes

Gardez la cardinalité des étiquettes basse
Utilisez des conventions de nommage cohérentes
Évitez les étiquettes à haute cardinalité (identifiants d’utilisateurs, horodatages)

Sécurité

Activez l’authentification et HTTPS
Limitez l’accès à l’API Prometheus
Utilisez des politiques réseau dans Kubernetes
Implémentez RBAC pour les métriques sensibles

Haute disponibilité

Exécutez plusieurs instances de Prometheus
Utilisez Thanos ou Cortex pour le stockage à long terme
Implémentez la fédération pour les configurations hiérarchiques

Dépannage des problèmes courants

Utilisation élevée de la mémoire

Réduisez la fréquence d’extraction
Diminuez la période de conservation
Optimisez les requêtes PromQL
Implémentez des règles d’enregistrement

Métriques manquantes

Vérifiez l’état des cibles dans /targets
Vérifiez la connectivité réseau
Validez la configuration d’extraction
Vérifiez les journaux de l’exporter

Requêtes lentes

Utilisez des règles d’enregistrement pour les agrégations complexes
Optimisez les filtres d’étiquettes
Réduisez la plage de temps
Ajoutez des index si vous utilisez un stockage distant

Optimisation des performances

Optimisation des requêtes

# Mauvais : Haute cardinalité
sum(rate(http_requests_total[5m]))

# Bon : Groupe par étiquettes pertinentes
sum by (status, method) (rate(http_requests_total[5m]))

Limites de ressources

Pour les déploiements Kubernetes :

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Conclusion

Prometheus fournit une solution de surveillance robuste et évolutive pour l’infrastructure moderne. Son architecture basée sur le pull, son langage de requête puissant et son écosystème étendu d’exporters le rendent idéal pour surveiller tout, des serveurs physiques aux clusters Kubernetes complexes.

En combinant Prometheus avec Grafana pour la visualisation et AlertManager pour les notifications, vous créez une plateforme d’observabilité complète capable de gérer les exigences de surveillance à grande échelle d’entreprises. La communauté active et le soutien de la CNCF assurent un développement et un support continus.

Commencez par la collecte de métriques de base, ajoutez progressivement des exporteurs pour vos services spécifiques et affinez vos règles d’alerte en fonction de l’expérience réelle. Prometheus s’adapte à votre infrastructure, des déploiements à un seul serveur aux architectures de surveillance multi-centres de données.