M

MLOG

Polski

Dowiedz się, jak Event Sourcing może zrewolucjonizować implementację ścieżek audytu, oferując niezrównaną identyfikowalność, integralność danych i odporność systemu. Poznaj praktyczne przykłady i strategie wdrożenia.

Event Sourcing: Implementacja ścieżek audytu dla solidnych i identyfikowalnych systemów

W dzisiejszym złożonym i połączonym cyfrowym świecie utrzymanie solidnej i kompleksowej ścieżki audytu jest sprawą nadrzędną. Jest to nie tylko często wymóg regulacyjny, ale także kluczowe dla debugowania, analizy bezpieczeństwa i zrozumienia ewolucji systemu. Event Sourcing, wzorzec architektoniczny, który przechwytuje wszystkie zmiany w stanie aplikacji jako sekwencję zdarzeń, oferuje eleganckie i potężne rozwiązanie do implementacji ścieżek audytu, które są niezawodne, audytowalne i rozszerzalne.

Czym jest Event Sourcing?

Tradycyjne aplikacje zazwyczaj przechowują w bazie danych tylko bieżący stan danych. Takie podejście utrudnia odtworzenie przeszłych stanów lub zrozumienie serii zdarzeń, które doprowadziły do obecnego stanu. Event Sourcing, w przeciwieństwie do tego, skupia się na przechwytywaniu każdej znaczącej zmiany w stanie aplikacji jako niezmiennego zdarzenia. Zdarzenia te są przechowywane w magazynie zdarzeń typu append-only, tworząc kompletny i chronologiczny zapis wszystkich działań w systemie.

Pomyśl o tym jak o księdze rachunku bankowego. Zamiast po prostu rejestrować bieżące saldo, każda wpłata, wypłata i przelew są rejestrowane jako osobne zdarzenie. Odtwarzając te zdarzenia, można zrekonstruować stan konta w dowolnym momencie.

Dlaczego warto używać Event Sourcing do tworzenia ścieżek audytu?

Event Sourcing oferuje kilka istotnych zalet przy implementacji ścieżek audytu:

Implementacja Event Sourcing dla ścieżek audytu: Przewodnik krok po kroku

Oto praktyczny przewodnik po implementacji Event Sourcing dla ścieżek audytu:

1. Zidentyfikuj kluczowe zdarzenia

Pierwszym krokiem jest zidentyfikowanie kluczowych zdarzeń, które chcesz przechwycić w swojej ścieżce audytu. Zdarzenia te powinny reprezentować znaczące zmiany w stanie aplikacji. Rozważ takie działania jak:

Przykład: Dla platformy e-commerce kluczowe zdarzenia mogą obejmować "OrderCreated" (ZamówienieUtworzone), "PaymentReceived" (PłatnośćOtrzymana), "OrderShipped" (ZamówienieWysłane), "ProductAddedToCart" (ProduktDodanyDoKoszyka) i "UserProfileUpdated" (ProfilUżytkownikaZaktualizowany).

2. Zdefiniuj strukturę zdarzenia

Każde zdarzenie powinno mieć dobrze zdefiniowaną strukturę, która zawiera następujące informacje:

Przykład: Zdarzenie "OrderCreated" może mieć następującą strukturę:

{
  "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. Wybierz magazyn zdarzeń (Event Store)

Magazyn zdarzeń jest centralnym repozytorium do przechowywania zdarzeń. Powinna to być baza danych typu append-only, zoptymalizowana do zapisu i odczytu sekwencji zdarzeń. Dostępnych jest kilka opcji:

Wybierając magazyn zdarzeń, należy wziąć pod uwagę takie czynniki jak:

4. Zaimplementuj publikowanie zdarzeń

Gdy wystąpi zdarzenie, aplikacja musi je opublikować w magazynie zdarzeń. Zazwyczaj obejmuje to następujące kroki:

Przykład (używając hipotetycznego EventStoreService):

public class OrderService {

  private final EventStoreService eventStoreService;

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

  public void createOrder(Order order, String userId) {
    // ... logika biznesowa tworzenia zamówienia ...

    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) {
    // Utwórz obiekt zdarzenia
    EventRecord eventRecord = new EventRecord(
        UUID.randomUUID(), // idZdarzenia
        streamName,  // nazwaStrumienia
        entityId,   // idEncji
        event.getClass().getName(), // typZdarzenia
        toJson(event),  // daneZdarzenia
        Instant.now().toString(), // znacznikCzasu
        userId  // idUżytkownika
    );

    // Serializuj zdarzenie
    String serializedEvent = toJson(eventRecord);

    // Dołącz zdarzenie do magazynu zdarzeń (implementacja specyficzna dla wybranego magazynu)
    storeEventInDatabase(serializedEvent);

    // Opublikuj zdarzenie dla subskrybentów (opcjonalnie)
    publishEventToMessageQueue(serializedEvent);
  }

  // Metody zastępcze dla interakcji z bazą danych i kolejką komunikatów
  private void storeEventInDatabase(String serializedEvent) {
    // Implementacja do przechowywania zdarzenia w bazie danych
    System.out.println("Zapisywanie zdarzenia w bazie danych: " + serializedEvent);
  }

  private void publishEventToMessageQueue(String serializedEvent) {
    // Implementacja do publikowania zdarzenia w kolejce komunikatów
    System.out.println("Publikowanie zdarzenia w kolejce komunikatów: " + serializedEvent);
  }

  private String toJson(Object obj) {
    // Implementacja do serializacji zdarzenia do formatu JSON
    try {
      ObjectMapper mapper = new ObjectMapper();
      return mapper.writeValueAsString(obj);
    } catch (Exception e) {
      throw new RuntimeException("Błąd podczas serializacji zdarzenia do formatu 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;
  }

  // Gettery

  @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;
    }

    // Gettery dla wszystkich pól

    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;
    }

    // Gettery dla wszystkich pól

    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. Zbuduj modele odczytu (projekcje)

Chociaż magazyn zdarzeń zapewnia pełną historię wszystkich zmian, często nie jest wydajne odpytywanie go bezpośrednio w celu operacji odczytu. Zamiast tego można budować modele odczytu, znane również jako projekcje, które są zoptymalizowane pod kątem określonych wzorców zapytań. Te modele odczytu pochodzą ze strumienia zdarzeń i są aktualizowane asynchronicznie w miarę publikowania nowych zdarzeń.

Przykład: Możesz utworzyć model odczytu, który zawiera listę wszystkich zamówień dla określonego klienta, lub model odczytu, który podsumowuje dane sprzedaży dla danego produktu.

Aby zbudować model odczytu, subskrybujesz strumień zdarzeń i przetwarzasz każde zdarzenie. Dla każdego zdarzenia odpowiednio aktualizujesz model odczytu.

Przykład:

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);
    }

    // Inne handlery zdarzeń dla PaymentReceivedEvent, OrderShippedEvent, itd.
}

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;
    }
    //Gettery
}

6. Zabezpiecz magazyn zdarzeń

Magazyn zdarzeń zawiera wrażliwe dane, dlatego kluczowe jest jego odpowiednie zabezpieczenie. Rozważ następujące środki bezpieczeństwa:

7. Zaimplementuj audyt i raportowanie

Po zaimplementowaniu Event Sourcing możesz używać strumienia zdarzeń do generowania raportów audytowych i przeprowadzania analizy bezpieczeństwa. Możesz odpytywać magazyn zdarzeń, aby znaleźć wszystkie zdarzenia związane z określonym użytkownikiem, transakcją lub encją. Możesz również użyć strumienia zdarzeń, aby zrekonstruować stan systemu w dowolnym momencie.

Przykład: Możesz wygenerować raport, który pokazuje wszystkie zmiany wprowadzone w profilu określonego użytkownika w danym okresie, lub raport, który pokazuje wszystkie transakcje zainicjowane przez danego użytkownika.

Rozważ następujące możliwości raportowania:

Wyzwania związane z Event Sourcing

Chociaż Event Sourcing oferuje wiele korzyści, stwarza również pewne wyzwania:

Najlepsze praktyki w Event Sourcing

Aby złagodzić wyzwania związane z Event Sourcing, postępuj zgodnie z tymi najlepszymi praktykami:

Przykłady zastosowania Event Sourcing w świecie rzeczywistym

Event Sourcing jest używany w różnych branżach i zastosowaniach, w tym:

Podsumowanie

Event Sourcing to potężny wzorzec architektoniczny, który może zrewolucjonizować implementację ścieżek audytu. Zapewnia niezrównaną identyfikowalność, integralność danych i odporność systemu. Chociaż stwarza pewne wyzwania, korzyści płynące z Event Sourcing często przewyższają koszty, zwłaszcza w przypadku złożonych i krytycznych systemów. Postępując zgodnie z najlepszymi praktykami opisanymi w tym przewodniku, można z powodzeniem wdrożyć Event Sourcing i budować solidne i audytowalne systemy.

Dalsza lektura

Event Sourcing: Implementacja ścieżek audytu dla solidnych i identyfikowalnych systemów | MLOG