M

MLOG

Français

Découvrez comment l'Event Sourcing peut révolutionner votre implémentation de journaux d'audit, offrant une traçabilité, une intégrité des données et une résilience système inégalées. Explorez des exemples pratiques et des stratégies d'implémentation.

Event Sourcing : Implémentation de journaux d'audit pour des systèmes robustes et traçables

Dans le paysage numérique complexe et interconnecté d'aujourd'hui, le maintien d'un journal d'audit robuste et complet est primordial. Non seulement il s'agit souvent d'une exigence réglementaire, mais il est également crucial pour le débogage, l'analyse de sécurité et la compréhension de l'évolution de votre système. L'Event Sourcing, un modèle architectural qui capture toutes les modifications de l'état d'une application sous forme de séquence d'événements, offre une solution élégante et puissante pour implémenter des journaux d'audit fiables, auditables et extensibles.

Qu'est-ce que l'Event Sourcing ?

Les applications traditionnelles stockent généralement uniquement l'état actuel des données dans une base de données. Cette approche rend difficile la reconstruction des états passés ou la compréhension de la série d'événements qui ont conduit à l'état actuel. L'Event Sourcing, en revanche, se concentre sur la capture de chaque changement significatif de l'état de l'application sous forme d'événement immuable. Ces événements sont stockés dans un event store en mode ajout seulement (append-only), formant un enregistrement complet et chronologique de toutes les actions au sein du système.

Pensez-y comme au grand livre d'un compte bancaire. Au lieu d'enregistrer simplement le solde actuel, chaque dépôt, retrait et transfert est enregistré comme un événement distinct. En rejouant ces événements, vous pouvez reconstruire l'état du compte à tout moment.

Pourquoi utiliser l'Event Sourcing pour les journaux d'audit ?

L'Event Sourcing offre plusieurs avantages convaincants pour l'implémentation de journaux d'audit :

Implémentation de l'Event Sourcing pour les journaux d'audit : Un guide étape par étape

Voici un guide pratique pour implémenter l'Event Sourcing pour les journaux d'audit :

1. Identifier les événements clés

La première étape consiste à identifier les événements clés que vous souhaitez capturer dans votre journal d'audit. Ces événements doivent représenter des changements significatifs dans l'état de l'application. Pensez à des actions telles que :

Exemple : Pour une plateforme de commerce électronique, les événements clés pourraient inclure "CommandeCréée", "PaiementReçu", "CommandeExpédiée", "ProduitAjoutéAuPanier" et "ProfilUtilisateurMisÀJour".

2. Définir la structure des événements

Chaque événement doit avoir une structure bien définie qui inclut les informations suivantes :

Exemple : L'événement "CommandeCréée" pourrait avoir la structure suivante :

{
  "eventType": "OrderCreated",
  "eventData": {
    "orderId": "12345",
    "customerId": "67890",
    "orderDate": "2023-10-27T10:00:00Z",
    "totalAmount": 100.00,
    "currency": "USD",
    "shippingAddress": {
      "street": "123 Main St",
      "city": "Anytown",
      "state": "CA",
      "zipCode": "91234",
      "country": "USA"
    }
  },
  "timestamp": "2023-10-27T10:00:00Z",
  "userId": "user123",
  "transactionId": "tx12345",
  "correlationId": "corr123",
  "metadata": {
    "ipAddress": "192.168.1.1",
    "browser": "Chrome",
    "location": {
       "latitude": 34.0522,
       "longitude": -118.2437
    }
  }
}

3. Choisir un Event Store

L'event store est le dépôt central pour le stockage des événements. Ce devrait être une base de données en mode ajout seulement (append-only) optimisée pour l'écriture et la lecture de séquences d'événements. Plusieurs options sont disponibles :

Lors du choix d'un event store, tenez compte de facteurs tels que :

4. Implémenter la publication d'événements

Lorsqu'un événement se produit, votre application doit le publier dans l'event store. Cela implique généralement les étapes suivantes :

Exemple (en utilisant un service hypothétique EventStoreService) :

public class OrderService {

  private final EventStoreService eventStoreService;

  public OrderService(EventStoreService eventStoreService) {
    this.eventStoreService = eventStoreService;
  }

  public void createOrder(Order order, String userId) {
    // ... logique métier pour créer la commande ...

    OrderCreatedEvent event = new OrderCreatedEvent(
        order.getOrderId(),
        order.getCustomerId(),
        order.getOrderDate(),
        order.getTotalAmount(),
        order.getCurrency(),
        order.getShippingAddress()
    );

    eventStoreService.appendEvent("order", order.getOrderId(), event, userId);
  }
}

public class EventStoreService {

  public void appendEvent(String streamName, String entityId, Object event, String userId) {
    // Créer un objet événement
    EventRecord eventRecord = new EventRecord(
        UUID.randomUUID(), // eventId
        streamName,  // streamName
        entityId,   // entityId
        event.getClass().getName(), // eventType
        toJson(event),  // eventData
        Instant.now().toString(), // timestamp
        userId  // userId
    );

    // Sérialiser l'événement
    String serializedEvent = toJson(eventRecord);

    // Ajouter l'événement à l'event store (implémentation spécifique à l'event store choisi)
    storeEventInDatabase(serializedEvent);

    // Publier l'événement aux abonnés (facultatif)
    publishEventToMessageQueue(serializedEvent);
  }

  // Méthodes placeholders pour l'interaction avec la base de données et la file de messages
  private void storeEventInDatabase(String serializedEvent) {
    // Implémentation pour stocker l'événement dans la base de données
    System.out.println("Storing event in database: " + serializedEvent);
  }

  private void publishEventToMessageQueue(String serializedEvent) {
    // Implémentation pour publier l'événement à une file de messages
    System.out.println("Publishing event to message queue: " + serializedEvent);
  }

  private String toJson(Object obj) {
    // Implémentation pour sérialiser l'événement en JSON
    try {
      ObjectMapper mapper = new ObjectMapper();
      return mapper.writeValueAsString(obj);
    } catch (Exception e) {
      throw new RuntimeException("Error serializing event to JSON", e);
    }
  }
}


class EventRecord {
  private final UUID eventId;
  private final String streamName;
  private final String entityId;
  private final String eventType;
  private final String eventData;
  private final String timestamp;
  private final String userId;

  public EventRecord(UUID eventId, String streamName, String entityId, String eventType, String eventData, String timestamp, String userId) {
    this.eventId = eventId;
    this.streamName = streamName;
    this.entityId = entityId;
    this.eventType = eventType;
    this.eventData = eventData;
    this.timestamp = timestamp;
    this.userId = userId;
  }

  // Getters

  @Override
  public String toString() {
    return "EventRecord{"
        + "eventId=" + eventId +
        ", streamName='" + streamName + '\'' +
        ", entityId='" + entityId + '\'' +
        ", eventType='" + eventType + '\'' +
        ", eventData='" + eventData + '\'' +
        ", timestamp='" + timestamp + '\'' +
        ", userId='" + userId + '\'' +
        '}'
  ;
  }
}

class OrderCreatedEvent {
    private final String orderId;
    private final String customerId;
    private final String orderDate;
    private final double totalAmount;
    private final String currency;
    private final String shippingAddress;

    public OrderCreatedEvent(String orderId, String customerId, String orderDate, double totalAmount, String currency, String shippingAddress) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
        this.shippingAddress = shippingAddress;
    }

    // Getters for all fields

    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
    public String getOrderDate() { return orderDate; }
    public double getTotalAmount() { return totalAmount; }
    public String getCurrency() { return currency; }
    public String getShippingAddress() { return shippingAddress; }

    @Override
    public String toString() {
        return "OrderCreatedEvent{"
                + "orderId='" + orderId + '\'' +
                ", customerId='" + customerId + '\'' +
                ", orderDate='" + orderDate + '\'' +
                ", totalAmount=" + totalAmount +
                ", currency='" + currency + '\'' +
                ", shippingAddress='" + shippingAddress + '\'' +
                '}'
    ;
    }
}

class Order {
  private final String orderId;
  private final String customerId;
  private final String orderDate;
  private final double totalAmount;
  private final String currency;
  private final String shippingAddress;

  public Order(String orderId, String customerId, String orderDate, double totalAmount, String currency, String shippingAddress) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
        this.shippingAddress = shippingAddress;
    }

    // Getters for all fields

    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
    public String getOrderDate() { return orderDate; }
    public double getTotalAmount() { return totalAmount; }
    public String getCurrency() { return currency; }
    public String getShippingAddress() { return shippingAddress; }

    @Override
    public String toString() {
        return "Order{"
                + "orderId='" + orderId + '\'' +
                ", customerId='" + customerId + '\'' +
                ", orderDate='" + orderDate + '\'' +
                ", totalAmount=" + totalAmount +
                ", currency='" + currency + '\'' +
                ", shippingAddress='" + shippingAddress + '\'' +
                '}'
    ;
    }
}

5. Créer des modèles de lecture (projections)

Bien que l'event store fournisse un historique complet de toutes les modifications, il n'est souvent pas efficace d'interroger directement pour les opérations de lecture. Au lieu de cela, vous pouvez créer des modèles de lecture, également appelés projections, qui sont optimisés pour des modèles de requête spécifiques. Ces modèles de lecture sont dérivés du flux d'événements et sont mis à jour de manière asynchrone à mesure que de nouveaux événements sont publiés.

Exemple : Vous pourriez créer un modèle de lecture qui contient une liste de toutes les commandes pour un client spécifique, ou un modèle de lecture qui résume les données de vente pour un produit particulier.

Pour créer un modèle de lecture, vous vous abonnez au flux d'événements et traitez chaque événement. Pour chaque événement, vous mettez à jour le modèle de lecture en conséquence.

Exemple :

public class OrderSummaryReadModelUpdater {

    private final OrderSummaryRepository orderSummaryRepository;

    public OrderSummaryReadModelUpdater(OrderSummaryRepository orderSummaryRepository) {
        this.orderSummaryRepository = orderSummaryRepository;
    }

    public void handle(OrderCreatedEvent event) {
        OrderSummary orderSummary = new OrderSummary(
                event.getOrderId(),
                event.getCustomerId(),
                event.getOrderDate(),
                event.getTotalAmount(),
                event.getCurrency()
        );

        orderSummaryRepository.save(orderSummary);
    }

    // Autres gestionnaires d'événements pour PaymentReceivedEvent, OrderShippedEvent, etc.
}

interface OrderSummaryRepository {
    void save(OrderSummary orderSummary);
}

class OrderSummary {
    private final String orderId;
    private final String customerId;
    private final String orderDate;
    private final double totalAmount;
    private final String currency;

    public OrderSummary(String orderId, String customerId, String orderDate, double totalAmount, String currency) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
    }
    //Getters
}

6. Sécuriser l'Event Store

L'event store contient des données sensibles, il est donc crucial de le sécuriser correctement. Envisagez les mesures de sécurité suivantes :

7. Implémenter l'audit et le reporting

Une fois que vous avez implémenté l'Event Sourcing, vous pouvez utiliser le flux d'événements pour générer des rapports d'audit et effectuer des analyses de sécurité. Vous pouvez interroger l'event store pour trouver tous les événements liés à un utilisateur, une transaction ou une entité spécifique. Vous pouvez également utiliser le flux d'événements pour reconstruire l'état du système à tout moment.

Exemple : Vous pourriez générer un rapport qui montre toutes les modifications apportées au profil d'un utilisateur spécifique sur une période donnée, ou un rapport qui montre toutes les transactions initiées par un utilisateur particulier.

Envisagez les capacités de reporting suivantes :

Défis de l'Event Sourcing

Bien que l'Event Sourcing offre de nombreux avantages, il présente également certains défis :

Bonnes pratiques pour l'Event Sourcing

Pour atténuer les défis de l'Event Sourcing, suivez ces bonnes pratiques :

Exemples concrets d'Event Sourcing

L'Event Sourcing est utilisé dans une variété d'industries et d'applications, notamment :

Conclusion

L'Event Sourcing est un modèle architectural puissant qui peut révolutionner votre implémentation de journaux d'audit. Il offre une traçabilité, une intégrité des données et une résilience système inégalées. Bien qu'il présente certains défis, les avantages de l'Event Sourcing l'emportent souvent sur les coûts, en particulier pour les systèmes complexes et critiques. En suivant les bonnes pratiques décrites dans ce guide, vous pouvez implémenter avec succès l'Event Sourcing et construire des systèmes robustes et auditable.

Lectures complémentaires