Aller au contenu principal

TP11.2 - Monitoring avec Prometheus & Grafana

Objectifs du TP​

Dans ce TP, vous allez:

  1. ✅ Configurer Prometheus pour scraper les métriques
  2. ✅ Créer des dashboards Grafana
  3. ✅ Visualiser les métriques de l'application
  4. ✅ Configurer des alertes

Durée estimée: 1h30

Prérequis: Docker installé, TP11.1 complété

Contexte​

Vous allez mettre en place un stack de monitoring complet pour l'application e-commerce du TP1.

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Spring Boot    │────▶│   Prometheus    │────▶│    Grafana      │
│  /actuator      │     │   (Collecte)    │     │  (Visualisation)│
│  /prometheus    │     │                 │     │                 │
└─────────────────┘     └─────────────────┘     └─────────────────┘

Partie 1: Docker Compose​

Structure du Projet​

project/
├── src/
├── pom.xml
├── docker-compose.yml
├── prometheus/
│   └── prometheus.yml
└── grafana/
    └── provisioning/
        └── datasources/
            └── datasource.yml

docker-compose.yml​

version: '3.8'

services:
  # Votre application Spring Boot
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
    networks:
      - monitoring

  # Prometheus - Collecte des métriques
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
    networks:
      - monitoring

  # Grafana - Visualisation
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on:
      - prometheus
    networks:
      - monitoring

volumes:
  prometheus_data:
  grafana_data:

networks:
  monitoring:
    driver: bridge

Partie 2: Configuration Prometheus​

prometheus/prometheus.yml​

global:
  scrape_interval: 15s      # Fréquence de collecte
  evaluation_interval: 15s  # Fréquence d'évaluation des règles

scrape_configs:
  # Prometheus se scrape lui-même
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # Application Spring Boot
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 10s
    static_configs:
      - targets: ['app:8080']  # 'app' = nom du service Docker
        labels:
          application: 'ecommerce-app'
          environment: 'development'

  # Si vous exécutez l'app en local (hors Docker)
  # - job_name: 'spring-boot-local'
  #   metrics_path: '/actuator/prometheus'
  #   static_configs:
  #     - targets: ['host.docker.internal:8080']

Partie 3: Configuration Grafana​

grafana/provisioning/datasources/datasource.yml​

apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    editable: true

Partie 4: Lancement du Stack​

Démarrer les Services​

# Démarrer le stack
docker-compose up -d

# Vérifier les logs
docker-compose logs -f

# Vérifier que tout fonctionne
curl http://localhost:8080/actuator/prometheus  # App
curl http://localhost:9090/targets              # Prometheus
# Grafana: http://localhost:3000 (admin/admin)

Sans Docker (App locale)​

Si vous exécutez l'app hors Docker:

# prometheus.yml - Modifier le target
- job_name: 'spring-boot-app'
  metrics_path: '/actuator/prometheus'
  static_configs:
    - targets: ['host.docker.internal:8080']

Partie 5: Vérifier Prometheus​

Accéder à Prometheus​

Ouvrez http://localhost:9090

Vérifier les Targets​

Allez dans Status → Targets

Vous devriez voir:

  • spring-boot-app avec état UP

Requêtes PromQL​

Testez ces requêtes dans l'onglet Graph:

# Mémoire JVM utilisée
jvm_memory_used_bytes{area="heap"}

# Requêtes HTTP par seconde
rate(http_server_requests_seconds_count[5m])

# Latence P99
histogram_quantile(0.99, rate(http_server_requests_seconds_bucket[5m]))

# Commandes pending
business_orders_pending

# Produits en rupture
business_products_low_stock

Partie 6: Créer un Dashboard Grafana​

Connexion​

  1. Ouvrez http://localhost:3000
  2. Login: admin / admin
  3. Changez le mot de passe

Créer un Dashboard​

  1. Cliquez sur + → Dashboard
  2. Cliquez sur Add visualization
  3. Sélectionnez Prometheus comme data source

Panel 1: Requêtes/Seconde​

Query:

sum(rate(http_server_requests_seconds_count{application="ecommerce-app"}[5m]))

Settings:

  • Title: "Requests per Second"
  • Type: Stat ou Time series

Panel 2: Latence P95​

Query:

histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket{application="ecommerce-app"}[5m])) by (le))

Settings:

  • Title: "P95 Latency"
  • Unit: seconds (s)

Panel 3: Mémoire JVM​

Query:

jvm_memory_used_bytes{area="heap", application="ecommerce-app"} / 1024 / 1024

Settings:

  • Title: "Heap Memory Used (MB)"
  • Unit: megabytes

Panel 4: Commandes par Status​

Queries:

business_orders_pending
business_orders_completed
business_orders_cancelled

Settings:

  • Title: "Orders by Status"
  • Type: Stat (avec repeat pour chaque query)

Panel 5: Produits Low Stock​

Query:

business_products_low_stock

Settings:

  • Title: "Products with Low Stock"
  • Type: Gauge
  • Thresholds: 0-5 green, 5-10 yellow, 10+ red

Panel 6: Revenue Total​

Query:

business_revenue_total

Settings:

  • Title: "Total Revenue"
  • Unit: Currency ($)

Partie 7: Dashboard JSON (Import)​

Vous pouvez importer ce dashboard pré-configuré:

{
  "title": "E-Commerce Application",
  "panels": [
    {
      "title": "Requests/sec",
      "type": "stat",
      "targets": [
        {
          "expr": "sum(rate(http_server_requests_seconds_count[5m]))",
          "refId": "A"
        }
      ],
      "gridPos": {"h": 4, "w": 6, "x": 0, "y": 0}
    },
    {
      "title": "P95 Latency",
      "type": "gauge",
      "targets": [
        {
          "expr": "histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket[5m])) by (le))",
          "refId": "A"
        }
      ],
      "fieldConfig": {
        "defaults": {"unit": "s", "thresholds": {"steps": [{"value": 0, "color": "green"}, {"value": 0.5, "color": "yellow"}, {"value": 1, "color": "red"}]}}
      },
      "gridPos": {"h": 4, "w": 6, "x": 6, "y": 0}
    },
    {
      "title": "Heap Memory (MB)",
      "type": "timeseries",
      "targets": [
        {
          "expr": "jvm_memory_used_bytes{area=\"heap\"} / 1024 / 1024",
          "refId": "A"
        }
      ],
      "fieldConfig": {"defaults": {"unit": "decmbytes"}},
      "gridPos": {"h": 8, "w": 12, "x": 12, "y": 0}
    },
    {
      "title": "Orders Pending",
      "type": "stat",
      "targets": [{"expr": "business_orders_pending", "refId": "A"}],
      "gridPos": {"h": 4, "w": 4, "x": 0, "y": 4}
    },
    {
      "title": "Low Stock Products",
      "type": "stat",
      "targets": [{"expr": "business_products_low_stock", "refId": "A"}],
      "fieldConfig": {
        "defaults": {"thresholds": {"steps": [{"value": 0, "color": "green"}, {"value": 5, "color": "yellow"}, {"value": 10, "color": "red"}]}}
      },
      "gridPos": {"h": 4, "w": 4, "x": 4, "y": 4}
    },
    {
      "title": "Total Revenue",
      "type": "stat",
      "targets": [{"expr": "business_revenue_total", "refId": "A"}],
      "fieldConfig": {"defaults": {"unit": "currencyUSD"}},
      "gridPos": {"h": 4, "w": 4, "x": 8, "y": 4}
    }
  ],
  "refresh": "10s",
  "time": {"from": "now-1h", "to": "now"}
}

Pour importer:

  1. Dashboard → Import
  2. Coller le JSON
  3. Select Prometheus datasource
  4. Import

Partie 8: Générer du Trafic​

Script de Test​

#!/bin/bash
# generate-traffic.sh

API_URL="http://localhost:8080"

# Créer des commandes
for i in {1..20}; do
  curl -X POST "$API_URL/api/orders" \
    -H "Content-Type: application/json" \
    -d "{\"customerEmail\":\"user$i@test.com\",\"total\":$((RANDOM % 500 + 100))}"
  sleep 0.5
done

# Consulter les produits
for i in {1..50}; do
  curl "$API_URL/api/products" > /dev/null 2>&1
  sleep 0.2
done

echo "Traffic generated!"

Exécutez le script et observez les métriques dans Grafana.

Partie 9: Alertes (Bonus)​

Ajouter des Alertes dans Grafana​

  1. Allez dans un panel (ex: Low Stock Products)
  2. Cliquez sur Alert → Create alert rule
  3. Configurez:
    • Condition: query A > 10
    • Evaluate every: 1m
    • For: 5m (doit être vrai pendant 5 min)
  4. Ajoutez une notification (email, Slack, etc.)

Alertes dans Prometheus​

Créez prometheus/alert.rules.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: "High memory usage detected"
          description: "Heap memory is above 90%"

      - alert: HighErrorRate
        expr: sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m])) / sum(rate(http_server_requests_seconds_count[5m])) > 0.05
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "High error rate"
          description: "Error rate is above 5%"

      - alert: LowStock
        expr: business_products_low_stock > 10
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Many products with low stock"

Checklist Finale​

  • Docker Compose démarre sans erreur
  • Prometheus scrape l'application (Target UP)
  • Métriques visibles dans Prometheus
  • Dashboard Grafana fonctionnel
  • Métriques métier (orders, products) affichées
  • Refresh automatique du dashboard

🎯 Module Terminé!​

Félicitations! Vous avez complété le Module 11 - Spring Boot Actuator et Monitoring.

Récapitulatif:

  • Chapitre 1: Introduction Actuator
  • Chapitre 2: Endpoints
  • Chapitre 3: Métriques Micrometer
  • Chapitre 4: Health Checks
  • TP1: Configuration Actuator
  • TP2: Prometheus & Grafana

Compétences acquises:

  • ✅ Configuration Actuator complète
  • ✅ Health checks personnalisés
  • ✅ Métriques métier avec Micrometer
  • ✅ Stack de monitoring Prometheus/Grafana
  • ✅ Dashboards et visualisations

➡️ Retour au Module 11

⬅️ Retour au Plan de Cours