Prometheus + Grafana — Collecte, dashboards et alertes

Stack de monitoring complète pour un environnement Docker : collecte des métriques via Prometheus, visualisation dans Grafana, alertes via Alertmanager.

Cette page complète Monitoring en apportant la couche Prometheus + Grafana, absente du guide de monitoring basique.

1. Prometheus — installation et configuration

Docker Compose minimal


version: "3.8"
 
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    restart: unless-stopped
 
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    network_mode: host
    pid: host
    volumes:
      - "/:/host:ro,rslave"
    command:
      - "--path.rootfs=/host"
    restart: unless-stopped
 
volumes:
  prometheus-data:

Lancer :


docker compose up -d

Vérifier le statut :


curl -s http://localhost:9090/-/healthy
# → "OK"

Configuration `prometheus.yml`


global:
  scrape_interval: 15s
  evaluation_interval: 15s
 
scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]
 
  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]
 
  - job_name: "spring-boot"
    metrics_path: /actuator/prometheus
    static_configs:
      - targets: ["app:8080"]

Les targets utilisent le nom du service Docker Compose (app), pas localhost. Prometheus résout les noms via le réseau interne de Compose.

Linter de configuration


# Tester la validité de la config Prometheus
docker run --rm -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus:latest --config.check

2. Exposition des métriques Spring Boot

Configuration Actuator

L’endpoint /actuator/prometheus doit être activé dans l’application :


management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus
  metrics:
    tags:
      application: ${spring.application.name}
    export:
      prometheus:
        enabled: true

Voir aussi Spring Boot Actuator pour la configuration complète des endpoints et la sécurité.

Métriques JVM visibles dans Prometheus

Dès l’activation de l’endpoint prometheus, les exporters Micrometer (inclus dans Spring Boot Actuator) exposent :

Métrique	Description
`jvm_memory_used_bytes{area="heap"}`	Mémoire heap utilisée
`jvm_memory_committed_bytes{area="heap"}`	Mémoire heap allouée
`jvm_threads_current`	Nombre de threads actifs
`jvm_threads_daemon`	Nombre de threads daemon
`jvm_gc_pause_seconds{action="end of minor GC"}`	Durée des pauses GC
`jvm_gc_memory_allocated_bytes_total`	Bytes alloués par le GC
`http_server_requests_seconds_count{status="200"}`	Nombre de requêtes par statut
`http_server_requests_seconds{quantile="0.99"}`	Latence p99
`process_cpu_usage`	Utilisation CPU du processus
`system_cpu_usage`	Utilisation CPU système

Connexion dans la config Prometheus

Dans le bloc scrape_configs, ajouter le target app :


  - job_name: "spring-boot"
    metrics_path: /actuator/prometheus
    scrape_interval: 10s
    static_configs:
      - targets: ["app:8080"]
    relabel_configs:
      - source_labels: [__address__]
        target_label: instance

scrape_interval: 10s est plus fréquent que la valeur globale (15 s) pour les applications critiques. relabel_configs ajoute le label instance pour différencier les instances lors du scraping.

3. Grafana — installation et configuration

Docker Compose — ajout du service Grafana


  grafana:
    image: grafana/grafana-oss:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=monitoring
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana-data:/var/lib/grafana
    depends_on:
      - prometheus
    restart: unless-stopped
 
volumes:
  grafana-data:

GF_SECURITY_ADMIN_PASSWORD doit être changé en production. Consulter VPS — Setup serveur, sécurité pour les bonnes pratiques de mots de passe et de rotation de secrets.

Lancer :


docker compose up -d grafana

Interface web : http://localhost:3000 — connexion avec admin / monitoring.

Ajouter la source Prometheus

Dans Grafana :

Configuration → Data Sources → Add data source
Sélectionner Prometheus
URL : http://prometheus:9090 (nom du service Docker Compose)
Cliquer Save & test — le statut doit afficher Data source is working

Dashboards standards

Grafana propose des dashboards communautaires importables via l’ID :

Dashboard	ID	Usage
JVM Basic Monitoring	4701	Mémoire, threads, GC de la JVM
Spring Boot Statistics	7362	Métriques HTTP, hibernate, datasource Spring Boot
Node Exporter Full	1860	CPU, mémoire, disque, réseau de l’hôte

Importer :

Dashboards → Import → Enter dashboard ID
Saisir l’ID (ex. 4701)
Sélectionner la source de données Prometheus
Cliquer Import

4. Alertes — règles Prometheus

Fichier de règles

Créer rules.yml à côté de prometheus.yml :


groups:
  - name: spring-boot-alerts
    rules:
      - alert: HighMemoryUsage
        expr: jvm_memory_used_bytes{area="heap"} / jvm_memory_max_bytes{area="heap"} > 0.9
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Mémoire heap élevée (> 90%)"
          description: "{{ $labels.instance }} — {{ $value | humanizePercentage }} d'utilisation"
 
      - alert: HighErrorRate
        expr: |
          sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m]))
          / sum(rate(http_server_requests_seconds_count[5m])) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Taux d'erreurs HTTP > 5%"
 
      - alert: JVMGCOverhead
        expr: jvm_gc_pause_seconds_sum / jvm_gc_pause_seconds_count > 0.5
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "GC overhead élevé (pause moyenne > 500 ms)"
 
      - alert: NodeCpuUsageHigh
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU hôte > 85%"

Intégrer les règles dans Prometheus

Ajouter à prometheus.yml :


rule_files:
  - "/etc/prometheus/rules.yml"
 
scrape_configs:
  # ... (la configuration existante)

Copier le fichier dans le conteneur via Docker Compose :


  prometheus:
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./rules.yml:/etc/prometheus/rules.yml:ro
      - prometheus-data:/prometheus

Vérifier que les règles sont chargées :


curl -s http://localhost:9090/api/v1/rules | jq '.groups[].name'

Intégration Alertmanager