Monitoring moderne avec Prometheus et Grafana

Dans le monde des applications distribuées et des microservices, le monitoring est devenu une composante essentielle de toute infrastructure. Prometheus et Grafana forment un duo puissant qui s’est imposé comme la solution de référence pour la collecte de métriques et leur visualisation. Voyons comment ces outils fonctionnent et comment les mettre en place.

Pourquoi le monitoring est crucial

Avant de plonger dans les outils, rappelons pourquoi le monitoring est si important :

Détection proactive des problèmes : Identifiez les problèmes avant qu’ils n’affectent vos utilisateurs
Compréhension des performances : Analysez comment votre système se comporte sous charge
Planification des capacités : Anticipez les besoins en ressources
Validation des changements : Vérifiez l’impact des déploiements
Amélioration continue : Identifiez les goulots d’étranglement et optimisez votre système

Prometheus : collecte et stockage de métriques

Qu’est-ce que Prometheus ?

Prometheus est un système de monitoring open-source qui collecte et stocke des métriques sous forme de séries temporelles. Ses principales caractéristiques sont :

Modèle de données multidimensionnel (métriques avec labels)
Langage de requête flexible (PromQL)
Architecture autonome sans dépendances
Collecte de métriques via HTTP pull
Support de la découverte de services
Stockage local efficace

Types de métriques dans Prometheus

Prometheus supporte quatre types de métriques :

Counter : Valeur qui ne peut qu’augmenter (ex: nombre de requêtes)
Gauge : Valeur qui peut augmenter et diminuer (ex: température, utilisation mémoire)
Histogram : Échantillons de mesures et leur distribution (ex: latence des requêtes)
Summary : Similaire à l’histogram mais avec des quantiles calculés côté client

Architecture de Prometheus

L’architecture de Prometheus se compose de plusieurs composants :

Serveur Prometheus : Collecte et stocke les métriques
Exporters : Exposent les métriques des systèmes tiers
Pushgateway : Permet le push de métriques pour les jobs de courte durée
Alertmanager : Gère les alertes et les notifications

Configuration de base de Prometheus

Voici un exemple de configuration Prometheus simple :

global:
  scrape_interval: 15s

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

Grafana : visualisation et tableaux de bord

Qu’est-ce que Grafana ?

Grafana est une plateforme open-source de visualisation et d’analyse. Elle permet de :

Créer des tableaux de bord riches et interactifs
Visualiser des données de multiples sources
Configurer des alertes
Annoter des événements
Partager et collaborer sur des tableaux de bord

Sources de données dans Grafana

Grafana supporte de nombreuses sources de données, dont :

Prometheus
InfluxDB
Elasticsearch
MySQL/PostgreSQL
CloudWatch
Et bien d’autres…

Création de tableaux de bord

Les tableaux de bord Grafana sont composés de panneaux qui peuvent afficher :

Des graphiques
Des tableaux
Des métriques uniques
Des heatmaps
Des diagrammes de Gantt
Et plus encore…

Mise en place de Prometheus et Grafana avec Docker

Voici comment déployer rapidement Prometheus et Grafana avec Docker Compose :

version: '3'

services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    ports:
      - "9100:9100"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    restart: unless-stopped
    depends_on:
      - prometheus

volumes:
  grafana-data:

Exemples de requêtes PromQL utiles

PromQL est le langage de requête de Prometheus. Voici quelques exemples utiles :

# Utilisation CPU par nœud
100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Utilisation mémoire
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

# Taux de requêtes HTTP par code de statut
sum by(status_code) (rate(http_requests_total[5m]))

# 95e percentile de latence
histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))

Alertes et notifications

Configuration des alertes dans Prometheus

Les règles d’alerte sont définies dans un fichier YAML :

groups:
- name: example
  rules:
  - alert: HighCPULoad
    expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU load (instance {{ $labels.instance }})"
      description: "CPU load is > 80%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"

Configuration de l’Alertmanager

L’Alertmanager gère l’envoi des notifications :

global:
  resolve_timeout: 5m

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'slack'

receivers:
- name: 'slack'
  slack_configs:
  - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
    channel: '#monitoring'
    send_resolved: true

Bonnes pratiques pour le monitoring

Métriques à surveiller

Voici les métriques essentielles à surveiller :

Utilisation des ressources : CPU, mémoire, disque, réseau
Métriques applicatives : Latence, taux d’erreur, saturation, trafic (méthode RED)
Métriques métier : Inscriptions, transactions, etc.

Structure des tableaux de bord

Organisez vos tableaux de bord selon la méthode USE pour les ressources :

Utilisation : Pourcentage de temps où la ressource est occupée
Saturation : Quantité de travail que la ressource ne peut pas traiter
Erreurs : Nombre d’événements d’échec

Et la méthode RED pour les services :

Rate : Nombre de requêtes par seconde
Errors : Nombre d’erreurs par seconde
Duration : Temps de réponse des requêtes

Conclusion

Prometheus et Grafana forment une solution de monitoring puissante et flexible qui s’intègre parfaitement dans un environnement DevOps moderne. En mettant en place ces outils, vous gagnerez en visibilité sur vos systèmes et pourrez réagir plus rapidement aux problèmes.

Chez Whims, nous aidons nos clients à mettre en place des solutions de monitoring adaptées à leurs besoins spécifiques. Que vous souhaitiez surveiller une infrastructure cloud, des applications conteneurisées ou des services traditionnels, nous pouvons vous accompagner dans cette démarche.

N’hésitez pas à nous contacter pour discuter de vos besoins en matière de monitoring et d’observabilité !