Monitoring avec Prometheus et Grafana

Dans ce chapitre, nous allons explorer la mise en place d’un système de monitoring complet avec Prometheus et Grafana. Nous verrons comment collecter, stocker et visualiser les métriques de nos microservices.

1. Configuration de Prometheus

Démarrage de Prometheus

docker run -d -p 9090:9090 \
  -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

Configuration de base

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8080']

2. Configuration des Applications

Dépendances

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Configuration Actuator

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      show-details: always
  metrics:
    tags:
      application: ${spring.application.name}
    distribution:
      percentiles-histogram:
        http.server.requests: true
      sla:
        http.server.requests: 10ms, 50ms, 100ms, 200ms, 500ms

3. Métriques Personnalisées

Configuration des métriques

@Configuration
public class MetricsConfig {
    
    @Bean
    public MeterRegistry meterRegistry() {
        return new SimpleMeterRegistry();
    }
    
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

Implémentation des métriques

@Service
public class ProductService {
    
    private final MeterRegistry registry;
    
    public ProductService(MeterRegistry registry) {
        this.registry = registry;
    }
    
    public Product getProduct(Long id) {
        return registry.timer("product.get", "id", id.toString())
            .record(() -> productClient.getProduct(id));
    }
    
    public void recordProductCreation(Product product) {
        registry.counter("product.created", 
            "category", product.getCategory())
            .increment();
    }
}

4. Alertes avec Prometheus

Configuration des règles

# rules.yml
groups:
  - name: spring-boot-app
    rules:
      - alert: HighErrorRate
        expr: rate(http_server_requests_seconds_count{status=~"5.."}[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: High error rate detected
          description: Error rate is above 10% for 5 minutes

Configuration des alertes

# alertmanager.yml
global:
  resolve_timeout: 5m

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

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'alerts@example.com'
        from: 'prometheus@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'prometheus'
        auth_password: 'secret'

5. Configuration de Grafana

Démarrage de Grafana

docker run -d -p 3000:3000 grafana/grafana

Configuration des datasources

{
  "name": "Prometheus",
  "type": "prometheus",
  "url": "http://prometheus:9090",
  "access": "proxy",
  "isDefault": true
}

Dashboard de base

{
  "dashboard": {
    "id": null,
    "title": "Spring Boot Application",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "rate(http_server_requests_seconds_count[5m])",
            "legendFormat": "{{method}} {{uri}}"
          }
        ]
      }
    ]
  }
}

6. Métriques Avancées

Métriques de performance

@Component
public class PerformanceMetrics {
    
    private final MeterRegistry registry;
    
    public PerformanceMetrics(MeterRegistry registry) {
        this.registry = registry;
    }
    
    public void recordMethodExecution(String methodName, long duration) {
        registry.timer("method.execution", "name", methodName)
               .record(duration, TimeUnit.MILLISECONDS);
    }
    
    public void recordDatabaseQuery(String queryType, long duration) {
        registry.timer("database.query", "type", queryType)
               .record(duration, TimeUnit.MILLISECONDS);
    }
}

Métriques de ressources

@Component
public class ResourceMetrics {
    
    private final MeterRegistry registry;
    
    public ResourceMetrics(MeterRegistry registry) {
        this.registry = registry;
    }
    
    public void recordMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
        
        registry.gauge("jvm.memory.used", 
            Tags.of("type", "heap"),
            usedMemory);
    }
    
    public void recordThreadCount() {
        registry.gauge("jvm.threads.count",
            Thread.activeCount());
    }
}

7. Visualisation Avancée

Dashboard personnalisé

{
  "dashboard": {
    "panels": [
      {
        "title": "Service Health",
        "type": "stat",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "up{job=\"spring-boot-app\"}",
            "legendFormat": "{{instance}}"
          }
        ]
      },
      {
        "title": "Error Rate",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "rate(http_server_requests_seconds_count{status=~\"5..\"}[5m])",
            "legendFormat": "{{instance}}"
          }
        ]
      }
    ]
  }
}

Alertes dans Grafana

{
  "alert": {
    "name": "High Error Rate",
    "conditions": [
      {
        "evaluator": {
          "params": [0.1],
          "type": "gt"
        },
        "operator": {
          "type": "and"
        },
        "query": {
          "params": ["A", "5m", "now"]
        },
        "reducer": {
          "type": "avg"
        },
        "type": "query"
      }
    ]
  }
}

8. Exercices pratiques

1. Configuration du monitoring

   • Configurez Prometheus
   • Configurez Grafana
   • Testez la collecte des métriques

2. Création de métriques

   • Implémentez des métriques personnalisées
   • Configurez des alertes
   • Testez les notifications

3. Visualisation des données

   • Créez des dashboards
   • Configurez des alertes dans Grafana
   • Analysez les performances

Conclusion

Dans ce chapitre, nous avons exploré :

• La configuration de Prometheus
• La configuration des applications
• Les métriques personnalisées
• Les alertes
• La configuration de Grafana
• Les métriques avancées
• La visualisation des données

Le monitoring permet :

• La surveillance en temps réel
• La détection des problèmes
• L’analyse des performances
• La planification de la capacité

Dans le prochain chapitre, nous explorerons le déploiement sur Kubernetes.