Logging centralisé avec ELK Stack

Dans le monde du DevOps moderne, la capacité à centraliser et analyser efficacement les logs est devenue cruciale pour maintenir et monitorer des applications distribuées. ELK Stack (Elasticsearch, Logstash, Kibana) s'est imposé comme une solution de référence pour répondre à ce besoin. Découvrons comment implémenter cette stack puissante dans un environnement .NET enterprise.

Comprendre l'architecture ELK Stack

ELK Stack se compose de trois composants principaux :

• Elasticsearch : Moteur de recherche distribuée pour le stockage et l'indexation des logs
• Logstash : Pipeline de traitement des données pour la collecte et transformation des logs
• Kibana : Interface web pour la visualisation et l'analyse des données

Installation et Configuration

Configuration Docker

# docker-compose.yml
version: '3.7'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.11.0
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"
  
  logstash:
    image: docker.elastic.co/logstash/logstash:8.11.0
    ports:
      - "5000:5000"
    
  kibana:
    image: docker.elastic.co/kibana/kibana:8.11.0
    ports:
      - "5601:5601"

Intégration avec .NET

Pour intégrer ELK Stack dans une application .NET, nous utiliserons Serilog comme framework de logging.

Installation des packages NuGet

dotnet add package Serilog
dotnet add package Serilog.Sinks.Elasticsearch
dotnet add package Serilog.Settings.Configuration

Configuration dans Program.cs

using Serilog;
using Serilog.Sinks.Elasticsearch;

var builder = WebApplication.CreateBuilder(args);
// Configuration du logger
Log.Logger = new LoggerConfiguration()
    .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri("http://localhost:9200"))
    {
        IndexFormat = $"app-logs-{DateTime.UtcNow:yyyy-MM}",
        AutoRegisterTemplate = true,
        NumberOfShards = 2,
        NumberOfReplicas = 1
    })
    .Enrich.WithEnvironmentName()
    .Enrich.WithMachineName()
    .CreateLogger();
builder.Host.UseSerilog();

Structuration des Logs

Pour maximiser l'utilité des logs, il est important de les structurer de manière cohérente.

public class OrderService
{
    private readonly ILogger _logger;

    public async Task ProcessOrder(Order order)
    {
        try
        {
            _logger.LogInformation(
                "Processing order {OrderId} for customer {CustomerId}",
                order.Id,
                order.CustomerId);
            // Traitement de la commande
            
            _logger.LogInformation(
                "Order {OrderId} processed successfully",
                order.Id);
        }
        catch (Exception ex)
        {
            _logger.LogError(
                ex,
                "Error processing order {OrderId}",
                order.Id);
            throw;
        }
    }
}

Bonnes Pratiques

• Utilisez des log levels appropriés (Debug, Info, Warning, Error)
• Incluez des identifiants de corrélation pour tracer les requêtes
• Structurez vos logs avec des propriétés nommées
• Évitez de logger des données sensibles

Monitoring et Alerting

// Configuration des alertes dans Kibana
{
  "trigger": {
    "schedule": {
      "interval": "5m"
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": ["app-logs-"],
        "body": {
          "query": {
            "bool": {
              "must": [
                { "match": { "level": "Error" } }
              ]
            }
          }
        }
      }
    }
  }
}

// Configuration du buffering
var options = new ElasticsearchSinkOptions(new Uri("http://localhost:9200"))
{
    BufferBaseFilename = "/var/log/buffer",
    BufferFileSizeLimitBytes = 5242880,
    BufferLogShippingInterval = TimeSpan.FromSeconds(5)
};

[Fact]
public async Task LoggingSystem_ShouldSendLogsToElasticsearch()
{
    // Arrange
    var logger = new LoggerConfiguration()
        .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri("http://localhost:9200")))
        .CreateLogger();

    // Act
    logger.Information("Test log message");
    await Task.Delay(1000); // Attendre la propagation
    // Assert
    var client = new ElasticClient(new Uri("http://localhost:9200"));
    var searchResponse = await client.SearchAsync(s => s
        .Query(q => q
            .Match(m => m
                .Field(f => f.Message)
                .Query("Test log message")
            )
        )
    );
    Assert.True(searchResponse.Documents.Any());
}