Monitoring avec Prometheus et Grafana

Dans l'écosystème DevOps moderne, la surveillance et le monitoring des applications sont devenus des aspects critiques pour garantir la fiabilité et la performance des services. Prometheus et Grafana forment un duo puissant pour relever ces défis, offrant une solution complète de collecte de métriques et de visualisation pour les applications .NET. Découvrons comment implémenter efficacement ces outils dans un contexte professionnel.

Fondamentaux du monitoring avec Prometheus et Grafana

Prometheus est un système de monitoring open-source qui excelle dans la collecte et le stockage de métriques temporelles. Grafana complète parfaitement Prometheus en fournissant une interface de visualisation sophistiquée. Ensemble, ils permettent de :

• Collecter des métriques applicatives en temps réel
• Stocker l'historique des données de performance
• Créer des tableaux de bord personnalisés
• Configurer des alertes basées sur des seuils

Intégration avec ASP.NET Core

Voici comment intégrer Prometheus dans une application ASP.NET Core :

// Program.cs
using Prometheus;

var builder = WebApplication.CreateBuilder(args);
// Ajout du middleware Prometheus
builder.Services.AddMetrics();
var app = builder.Build();
// Configuration des endpoints Prometheus
app.UseMetricServer();
app.UseHttpMetrics();

Configuration des métriques personnalisées

Exemple de création de métriques personnalisées :

public class OrderMetrics
{
    private readonly Counter _orderCounter;
    private readonly Histogram _orderProcessingDuration;

    public OrderMetrics()
    {
        _orderCounter = Metrics.CreateCounter("orders_total", "Total number of orders processed");
        _orderProcessingDuration = Metrics.CreateHistogram("order_processing_duration_seconds",
            "Time spent processing orders");
    }
    public void RecordOrder()
    {
        _orderCounter.Inc();
    }
    public void RecordProcessingTime(double seconds)
    {
        _orderProcessingDuration.Observe(seconds);
    }
}

Configuration de Prometheus

Configuration Prometheus dans Docker :

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'netcore-app'
    static_configs:
      - targets: ['localhost:80']

Mise en place de Grafana

Configuration de Grafana avec Docker Compose :

version: '3.8'
services:
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=secret
    depends_on:
      - prometheus

Bonnes pratiques de monitoring

• Définir des métriques significatives pour votre domaine métier
• Implémenter les Four Golden Signals : Latence, Trafic, Erreurs, Saturation
• Configurer des alertes pertinentes avec des seuils appropriés
• Maintenir une documentation claire des métriques

Patterns d'implémentation avancés

Exemple d'implémentation d'un middleware de monitoring :

public class MetricsMiddleware
{
    private readonly RequestDelegate _next;
    private readonly Counter _requestCounter;
    private readonly Histogram _requestDuration;

    public MetricsMiddleware(RequestDelegate next)
    {
        _next = next;
        _requestCounter = Metrics.CreateCounter("http_requests_total", 
            "Total number of HTTP requests");
        _requestDuration = Metrics.CreateHistogram("http_request_duration_seconds",
            "HTTP request duration");
    }
    public async Task InvokeAsync(HttpContext context)
    {
        _requestCounter.Inc();
        using (var timer = _requestDuration.NewTimer())
        {
            await _next(context);
        }
    }
}

Gestion des erreurs et performance

Implémentation d'un circuit breaker avec monitoring :

public class MonitoredCircuitBreaker
{
    private readonly Gauge _circuitState;
    private readonly Counter _failureCounter;

    public MonitoredCircuitBreaker()
    {
        _circuitState = Metrics.CreateGauge("circuit_breaker_state",
            "Circuit breaker state (0=closed, 1=open)");
        _failureCounter = Metrics.CreateCounter("circuit_breaker_failures_total",
            "Total number of circuit breaker failures");
    }
    public async Task ExecuteAsync(Func action)
    {
        try
        {
            _circuitState.Set(0);
            await action();
        }
        catch (Exception)
        {
            _failureCounter.Inc();
            _circuitState.Set(1);
            throw;
        }
    }
}

Tests et validation

Exemple de tests unitaires pour les métriques :

public class MetricsTests
{
    [Fact]
    public async Task Should_Record_Metrics_When_Processing_Order()
    {
        // Arrange
        var metrics = new OrderMetrics();
        
        // Act
        metrics.RecordOrder();
        metrics.RecordProcessingTime(1.5);

        // Assert
        var metricFamily = await Metrics.DefaultRegistry.GetMetricFamilies();
        Assert.Contains(metricFamily, m => m.Name == "orders_total");
    }
}

Conclusion

L'implémentation de Prometheus et Grafana dans une application .NET moderne est essentielle pour maintenir une visibilité complète sur la santé et les performances du système. En suivant les bonnes pratiques et en utilisant les patterns appropriés, vous pouvez créer un système de monitoring robuste et efficace.

Points clés à retenir :

• Utilisez des métriques significatives pour votre domaine
• Automatisez la collecte et la visualisation des données
• Implementez une stratégie d'alerte pertinente
• Testez régulièrement votre système de monitoring