M

MLOG

Slovenčina

Zistite, ako môže Event Sourcing revolučne zmeniť implementáciu vašich auditných záznamov, ponúkajúc neprekonateľnú sledovateľnosť, integritu dát a odolnosť systému. Preskúmajte praktické príklady a implementačné stratégie.

Event Sourcing: Implementácia auditných záznamov pre robustné a sledovateľné systémy

V dnešnom komplexnom a prepojenom digitálnom svete je udržiavanie robustného a komplexného auditného záznamu prvoradé. Nielenže je to často regulačná požiadavka, ale je to tiež kľúčové pre ladenie, bezpečnostnú analýzu a pochopenie vývoja vášho systému. Event Sourcing, architektonický vzor, ktorý zachytáva všetky zmeny stavu aplikácie ako sekvenciu udalostí, ponúka elegantné a výkonné riešenie pre implementáciu auditných záznamov, ktoré sú spoľahlivé, auditovateľné a rozšíriteľné.

Čo je Event Sourcing?

Tradičné aplikácie zvyčajne ukladajú do databázy iba aktuálny stav dát. Tento prístup sťažuje rekonštrukciu minulých stavov alebo pochopenie série udalostí, ktoré viedli k súčasnému stavu. Event Sourcing sa naopak zameriava na zachytenie každej významnej zmeny stavu aplikácie ako nemeniteľnej udalosti. Tieto udalosti sa ukladajú v úložisku udalostí s možnosťou iba pridávania (append-only), čím vytvárajú kompletný a chronologický záznam všetkých akcií v systéme.

Predstavte si to ako účtovnú knihu bankového účtu. Namiesto jednoduchého zaznamenávania aktuálneho zostatku sa každý vklad, výber a prevod zaznamenáva ako samostatná udalosť. Prehraním týchto udalostí môžete rekonštruovať stav účtu v ktoromkoľvek časovom bode.

Prečo používať Event Sourcing pre auditné záznamy?

Event Sourcing ponúka niekoľko presvedčivých výhod pre implementáciu auditných záznamov:

Implementácia Event Sourcing pre auditné záznamy: Sprievodca krok za krokom

Tu je praktický sprievodca implementáciou Event Sourcingu pre auditné záznamy:

1. Identifikujte kľúčové udalosti

Prvým krokom je identifikovať kľúčové udalosti, ktoré chcete zachytiť vo svojom auditnom zázname. Tieto udalosti by mali predstavovať významné zmeny stavu aplikácie. Zvážte akcie ako:

Príklad: Pre e-commerce platformu môžu kľúčové udalosti zahŕňať "OrderCreated," "PaymentReceived," "OrderShipped," "ProductAddedToCart," a "UserProfileUpdated."

2. Definujte štruktúru udalosti

Každá udalosť by mala mať dobre definovanú štruktúru, ktorá obsahuje nasledujúce informácie:

Príklad: Udalosť "OrderCreated" by mohla mať nasledujúcu štruktúru:

{
  "eventType": "OrderCreated",
  "eventData": {
    "orderId": "12345",
    "customerId": "67890",
    "orderDate": "2023-10-27T10:00:00Z",
    "totalAmount": 100.00,
    "currency": "USD",
    "shippingAddress": {
      "street": "Hlavná 123",
      "city": "Mestečko",
      "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. Vyberte úložisko udalostí

Úložisko udalostí je centrálny repozitár na ukladanie udalostí. Malo by to byť databáza s možnosťou iba pridávania (append-only), ktorá je optimalizovaná na zápis a čítanie sekvencií udalostí. K dispozícii je niekoľko možností:

Pri výbere úložiska udalostí zvážte faktory ako:

4. Implementujte publikovanie udalostí

Keď nastane udalosť, vaša aplikácia ju musí publikovať do úložiska udalostí. To zvyčajne zahŕňa nasledujúce kroky:

Príklad (s použitím hypotetickej EventStoreService):

public class OrderService {

  private final EventStoreService eventStoreService;

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

  public void createOrder(Order order, String userId) {
    // ... obchodná logika na vytvorenie objednávky ...

    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) {
    // Vytvorenie objektu udalosti
    EventRecord eventRecord = new EventRecord(
        UUID.randomUUID(), // eventId
        streamName,  // streamName
        entityId,   // entityId
        event.getClass().getName(), // eventType
        toJson(event),  // eventData
        Instant.now().toString(), // timestamp
        userId  // userId
    );

    // Serializácia udalosti
    String serializedEvent = toJson(eventRecord);

    // Pridanie udalosti do úložiska udalostí (implementácia špecifická pre zvolené úložisko)
    storeEventInDatabase(serializedEvent);

    // Publikovanie udalosti odberateľom (voliteľné)
    publishEventToMessageQueue(serializedEvent);
  }

  // Zástupné metódy pre interakciu s databázou a frontou správ
  private void storeEventInDatabase(String serializedEvent) {
    // Implementácia pre uloženie udalosti do databázy
    System.out.println("Ukladanie udalosti do databázy: " + serializedEvent);
  }

  private void publishEventToMessageQueue(String serializedEvent) {
    // Implementácia pre publikovanie udalosti do fronty správ
    System.out.println("Publikovanie udalosti do fronty správ: " + serializedEvent);
  }

  private String toJson(Object obj) {
    // Implementácia pre serializáciu udalosti do JSON
    try {
      ObjectMapper mapper = new ObjectMapper();
      return mapper.writeValueAsString(obj);
    } catch (Exception e) {
      throw new RuntimeException("Chyba pri serializácii udalosti do 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 pre všetky polia

    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 pre všetky polia

    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. Vytvorte modely na čítanie (Projekcie)

Zatiaľ čo úložisko udalostí poskytuje kompletnú históriu všetkých zmien, často nie je efektívne dopytovať sa ho priamo pre operácie čítania. Namiesto toho môžete vytvoriť modely na čítanie, známe aj ako projekcie, ktoré sú optimalizované pre špecifické vzory dopytov. Tieto modely na čítanie sú odvodené z prúdu udalostí a sú aktualizované asynchrónne pri publikovaní nových udalostí.

Príklad: Môžete vytvoriť model na čítanie, ktorý obsahuje zoznam všetkých objednávok pre konkrétneho zákazníka, alebo model na čítanie, ktorý sumarizuje údaje o predaji pre konkrétny produkt.

Na vytvorenie modelu na čítanie sa prihlásite na odber prúdu udalostí a spracujete každú udalosť. Pre každú udalosť aktualizujete model na čítanie.

Príklad:

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

    // Ostatné handlery udalostí pre PaymentReceivedEvent, OrderShippedEvent, atď.
}

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. Zabezpečte úložisko udalostí

Úložisko udalostí obsahuje citlivé údaje, preto je kľúčové ho riadne zabezpečiť. Zvážte nasledujúce bezpečnostné opatrenia:

7. Implementujte auditovanie a reporting

Po implementácii Event Sourcingu môžete použiť prúd udalostí na generovanie auditných reportov a vykonávanie bezpečnostnej analýzy. Môžete sa dopytovať v úložisku udalostí, aby ste našli všetky udalosti súvisiace s konkrétnym používateľom, transakciou alebo entitou. Môžete tiež použiť prúd udalostí na rekonštrukciu stavu systému v ktoromkoľvek časovom bode.

Príklad: Môžete vygenerovať report, ktorý zobrazuje všetky zmeny vykonané na konkrétnom profile používateľa za určité časové obdobie, alebo report, ktorý zobrazuje všetky transakcie iniciované konkrétnym používateľom.

Zvážte nasledujúce možnosti reportingu:

Výzvy Event Sourcingu

Hoci Event Sourcing ponúka mnoho výhod, prináša aj niekoľko výziev:

Najlepšie postupy pre Event Sourcing

Na zmiernenie výziev Event Sourcingu dodržiavajte tieto najlepšie postupy:

Príklady Event Sourcingu z reálneho sveta

Event Sourcing sa používa v rôznych odvetviach a aplikáciách, vrátane:

Záver

Event Sourcing je výkonný architektonický vzor, ktorý môže revolučne zmeniť vašu implementáciu auditných záznamov. Poskytuje neprekonateľnú sledovateľnosť, integritu dát a odolnosť systému. Hoci prináša niekoľko výziev, výhody Event Sourcingu často prevyšujú náklady, najmä pre komplexné a kritické systémy. Dodržiavaním najlepších postupov uvedených v tomto sprievodcovi môžete úspešne implementovať Event Sourcing a budovať robustné a auditovateľné systémy.

Ďalšie čítanie