Event Sourcing: Implementera granskningsspår för robusta och spårbara system

I dagens komplexa och sammankopplade digitala landskap är det av största vikt att upprätthålla ett robust och omfattande granskningsspår. Det är inte bara ofta ett lagstadgat krav, utan det är också avgörande för felsökning, säkerhetsanalys och förståelse av systemets utveckling. Event Sourcing, ett arkitektoniskt mönster som fångar alla ändringar i en applikations tillstånd som en sekvens av händelser, erbjuder en elegant och kraftfull lösning för att implementera granskningsspår som är pålitliga, granskningsbara och utbyggbara.

Vad är Event Sourcing?

Traditionella applikationer lagrar vanligtvis bara det aktuella tillståndet för data i en databas. Detta tillvägagångssätt gör det svårt att rekonstruera tidigare tillstånd eller förstå den serie av händelser som ledde till det aktuella tillståndet. Event Sourcing, i motsats till detta, fokuserar på att fånga varje betydande ändring av applikationens tillstånd som en oföränderlig händelse. Dessa händelser lagras i en händelselagringsplats där man endast kan lägga till (append-only), vilket bildar en komplett och kronologisk registrering av alla åtgärder inom systemet.

Tänk på det som en bankkontos reskontra. Istället för att bara registrera det aktuella saldot registreras varje insättning, uttag och överföring som en separat händelse. Genom att spela upp dessa händelser kan du rekonstruera kontots tillstånd vid vilken tidpunkt som helst.

Varför använda Event Sourcing för granskningsspår?

Event Sourcing erbjuder flera övertygande fördelar för att implementera granskningsspår:

• Komplett och oföränderlig historik: Varje ändring fångas som en händelse, vilket ger en komplett och oföränderlig registrering av systemets utveckling. Detta säkerställer att granskningsspåret är korrekt och manipulationssäkert.
• Temporär frågeställning: Du kan enkelt rekonstruera systemets tillstånd vid vilken tidpunkt som helst genom att spela upp händelserna fram till den punkten. Detta möjliggör kraftfulla temporära frågefunktioner för granskning och analys.
• Granskningsbart och spårbart: Varje händelse innehåller vanligtvis metadata som tidsstämpel, användar-ID och transaktions-ID, vilket gör det enkelt att spåra ursprunget och effekten av varje ändring.
• Frikoppling och skalbarhet: Event Sourcing främjar frikoppling mellan olika delar av systemet. Händelser kan konsumeras av flera prenumeranter, vilket möjliggör skalbarhet och flexibilitet.
• Repeterbarhet för felsökning och återställning: Händelser kan spelas upp för att återskapa tidigare tillstånd för felsökningsändamål eller för att återställa från fel.
• Stöd för CQRS: Event Sourcing används ofta i kombination med Command Query Responsibility Segregation (CQRS)-mönstret, som separerar läs- och skrivoperationer, vilket ytterligare förbättrar prestanda och skalbarhet.

Implementera Event Sourcing för granskningsspår: En steg-för-steg-guide

Här är en praktisk guide för att implementera Event Sourcing för granskningsspår:

1. Identifiera nyckelhändelser

Det första steget är att identifiera de nyckelhändelser som du vill fånga i ditt granskningsspår. Dessa händelser bör representera betydande ändringar av applikationens tillstånd. Tänk på åtgärder som:

• Användarautentisering (inloggning, utloggning)
• Skapande, modifiering och radering av data
• Initiering och slutförande av transaktioner
• Konfigurationsändringar
• Säkerhetsrelaterade händelser (t.ex. ändringar i åtkomstkontrollen)

Exempel: För en e-handelsplattform kan nyckelhändelser inkludera "OrderCreated", "PaymentReceived", "OrderShipped", "ProductAddedToCart" och "UserProfileUpdated."

2. Definiera händelsestruktur

Varje händelse bör ha en väldefinierad struktur som inkluderar följande information:

• Händelsetyp: En unik identifierare för typen av händelse (t.ex. "OrderCreated").
• Händelsedata: De data som är associerade med händelsen, såsom order-ID, produkt-ID, kund-ID och betalningsbelopp.
• Tidsstämpel: Datum och tid då händelsen inträffade. Överväg att använda UTC för konsistens över olika tidszoner.
• Användar-ID: ID för användaren som initierade händelsen.
• Transaktions-ID: En unik identifierare för transaktionen som händelsen tillhör. Detta är avgörande för att säkerställa atomicitet och konsistens över flera händelser.
• Korrelations-ID: En identifierare som används för att spåra relaterade händelser över olika tjänster eller komponenter. Detta är särskilt användbart i mikrotjänstarkitekturer.
• Orsaks-ID: (Valfritt) ID för händelsen som orsakade denna händelse. Detta hjälper till att spåra den kausala kedjan av händelser.
• Metadata: Ytterligare kontextuell information, såsom användarens IP-adress, webbläsartyp eller geografiska plats. Var noga med dataskyddsbestämmelser som GDPR när du samlar in och lagrar metadata.

Exempel: Händelsen "OrderCreated" kan ha följande 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. Välj en händelselagring

Händelselagringen är det centrala lagret för att lagra händelser. Det bör vara en databas där man endast kan lägga till (append-only) som är optimerad för att skriva och läsa sekvenser av händelser. Flera alternativ är tillgängliga:

• Dedikerade händelselagringsdatabaser: Dessa är databaser som är specifikt utformade för Event Sourcing, såsom EventStoreDB och AxonDB. De erbjuder funktioner som händelseströmmar, projektioner och prenumerationer.
• Relationsdatabaser: Du kan använda en relationsdatabas som PostgreSQL eller MySQL som en händelselagring. Du måste dock implementera semantiken för att endast lägga till (append-only) och hanteringen av händelseströmmar själv. Överväg att använda en dedikerad tabell för händelser med kolumner för händelse-ID, händelsetyp, händelsedata, tidsstämpel och metadata.
• NoSQL-databaser: NoSQL-databaser som MongoDB eller Cassandra kan också användas som händelselagringar. De erbjuder flexibilitet och skalbarhet men kan kräva mer ansträngning för att implementera de nödvändiga funktionerna.
• Molnbaserade lösningar: Molnleverantörer som AWS, Azure och Google Cloud erbjuder hanterade tjänster för händelseströmning som Kafka, Kinesis och Pub/Sub, som kan användas som händelselagringar. Dessa tjänster ger skalbarhet, tillförlitlighet och integration med andra molntjänster.

När du väljer en händelselagring, överväg faktorer som:

• Skalbarhet: Kan händelselagringen hantera den förväntade volymen av händelser?
• Hållbarhet: Hur pålitlig är händelselagringen när det gäller att förhindra dataförlust?
• Frågemöjligheter: Stöder händelselagringen de typer av frågor du behöver för granskning och analys?
• Transaktionsstöd: Stöder händelselagringen ACID-transaktioner för att säkerställa datakonsistens?
• Integration: Integreras händelselagringen väl med din befintliga infrastruktur och verktyg?
• Kostnad: Vad kostar det att använda händelselagringen, inklusive lagring, beräkning och nätverkskostnader?

4. Implementera händelsepublicering

När en händelse inträffar måste din applikation publicera den till händelselagringen. Detta innebär vanligtvis följande steg:

• Skapa ett händelseobjekt: Skapa ett händelseobjekt som innehåller händelsetyp, händelsedata, tidsstämpel, användar-ID och annan relevant metadata.
• Serialisera händelsen: Serialisera händelseobjektet till ett format som kan lagras i händelselagringen, till exempel JSON eller Avro.
• Lägg till händelsen i händelselagringen: Lägg till den serialiserade händelsen i händelselagringen. Se till att denna operation är atomisk för att förhindra datakorruption.
• Publicera händelsen till prenumeranter: (Valfritt) Publicera händelsen till alla prenumeranter som är intresserade av att ta emot den. Detta kan göras med hjälp av en meddelandekö eller ett publicerings- och prenumerationsmönster.

Exempel (med en hypotetisk EventStoreService):

public class OrderService {

  private final EventStoreService eventStoreService;

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

  public void createOrder(Order order, String userId) {
    // ... business logic to create the order ...

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

    // Serialize the event
    String serializedEvent = toJson(eventRecord);

    // Append the event to the event store (implementation specific to the chosen event store)
    storeEventInDatabase(serializedEvent);

    // Publish the event to subscribers (optional)
    publishEventToMessageQueue(serializedEvent);
  }

  // Placeholder methods for database and message queue interaction
  private void storeEventInDatabase(String serializedEvent) {
    // Implementation to store the event in the database
    System.out.println("Storing event in database: " + serializedEvent);
  }

  private void publishEventToMessageQueue(String serializedEvent) {
    // Implementation to publish the event to a message queue
    System.out.println("Publishing event to message queue: " + serializedEvent);
  }

  private String toJson(Object obj) {
    // Implementation to serialize the event to 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. Bygg läsmodeller (projektioner)

Medan händelselagringen ger en fullständig historik över alla ändringar, är det ofta inte effektivt att fråga den direkt för läsoperationer. Istället kan du bygga läsmodeller, även kända som projektioner, som är optimerade för specifika frågemönster. Dessa läsmodeller härleds från händelseströmmen och uppdateras asynkront när nya händelser publiceras.

Exempel: Du kan skapa en läsmodell som innehåller en lista över alla order för en specifik kund, eller en läsmodell som sammanfattar försäljningsdata för en viss produkt.

För att bygga en läsmodell prenumererar du på händelseströmmen och bearbetar varje händelse. För varje händelse uppdaterar du läsmodellen i enlighet därmed.

Exempel:

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

    // Other event handlers for 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äkra händelselagringen

Händelselagringen innehåller känslig data, så det är avgörande att säkra den ordentligt. Överväg följande säkerhetsåtgärder:

• Åtkomstkontroll: Begränsa åtkomsten till händelselagringen till endast auktoriserade användare och applikationer. Använd starka autentiserings- och auktoriseringsmekanismer.
• Kryptering: Kryptera data i händelselagringen i vila och under överföring för att skydda den från obehörig åtkomst. Överväg att använda krypteringsnycklar som hanteras av en Hardware Security Module (HSM) för ökad säkerhet.
• Granskning: Granska all åtkomst till händelselagringen för att upptäcka och förhindra obehörig aktivitet.
• Datamaskering: Maskera känslig data i händelselagringen för att skydda den från obehörig avslöjande. Du kan till exempel maskera personligt identifierbar information (PII) som kreditkortsnummer eller personnummer.
• Regelbundna säkerhetskopior: Säkerhetskopiera händelselagringen regelbundet för att skydda mot dataförlust. Lagra säkerhetskopior på en säker plats.
• Katastrofåterställning: Implementera en katastrofåterställningsplan för att säkerställa att du kan återställa händelselagringen i händelse av en katastrof.

7. Implementera granskning och rapportering

När du har implementerat Event Sourcing kan du använda händelseströmmen för att generera granskningsrapporter och utföra säkerhetsanalys. Du kan fråga händelselagringen för att hitta alla händelser relaterade till en specifik användare, transaktion eller entitet. Du kan också använda händelseströmmen för att rekonstruera systemets tillstånd vid vilken tidpunkt som helst.

Exempel: Du kan generera en rapport som visar alla ändringar som gjorts i en specifik användarprofil under en tidsperiod, eller en rapport som visar alla transaktioner som initierats av en viss användare.

Överväg följande rapporteringsfunktioner:

• Användaraktivitetsrapporter: Spåra användarinloggningar, utloggningar och andra aktiviteter.
• Rapporter om dataändringar: Övervaka ändringar av viktiga dataentiteter.
• Rapporter om säkerhetshändelser: Varna för misstänkt aktivitet, till exempel misslyckade inloggningsförsök eller obehöriga åtkomstförsök.
• Efterlevnadsrapporter: Generera rapporter som krävs för regelefterlevnad (t.ex. GDPR, HIPAA).

Utmaningar med Event Sourcing

Medan Event Sourcing erbjuder många fördelar, presenterar det också vissa utmaningar:

• Komplexitet: Event Sourcing lägger till komplexitet i systemarkitekturen. Du måste utforma händelsestrukturen, välja en händelselagring och implementera händelsepublicering och konsumtion.
• Eventuell konsistens: Läsmodeller är så småningom konsistenta med händelseströmmen. Detta innebär att det kan finnas en fördröjning mellan när en händelse inträffar och när läsmodellen uppdateras. Detta kan leda till inkonsekvenser i användargränssnittet.
• Händelseversionering: När din applikation utvecklas kan du behöva ändra strukturen på dina händelser. Detta kan vara utmanande, eftersom du måste se till att befintliga händelser fortfarande kan bearbetas korrekt. Överväg att använda tekniker som händelseuppgradering för att hantera olika händelseversioner.
• Eventuell konsistens och distribuerade transaktioner: Att implementera distribuerade transaktioner med Event Sourcing kan vara komplext. Du måste se till att händelser publiceras och konsumeras på ett konsekvent sätt över flera tjänster.
• Driftkostnader: Att hantera en händelselagring och dess tillhörande infrastruktur kan öka driftkostnaderna. Du måste övervaka händelselagringen, säkerhetskopiera den och se till att den körs smidigt.

Bästa metoder för Event Sourcing

För att mildra utmaningarna med Event Sourcing, följ dessa bästa metoder:

• Börja smått: Börja med att implementera Event Sourcing i en liten del av din applikation. Detta gör att du kan lära dig koncepten och få erfarenhet innan du tillämpar det på mer komplexa områden.
• Använd ett ramverk: Använd ett ramverk som Axon Framework eller Spring Cloud Stream för att förenkla implementeringen av Event Sourcing. Dessa ramverk tillhandahåller abstraktioner och verktyg som kan hjälpa dig att hantera händelser, projektioner och prenumerationer.
• Utforma händelser noggrant: Utforma dina händelser noggrant för att säkerställa att de fångar all information du behöver. Undvik att inkludera för mycket information i händelserna, eftersom detta kan göra dem svåra att bearbeta.
• Implementera händelseuppgradering: Implementera händelseuppgradering för att hantera ändringar i strukturen på dina händelser. Detta gör att du kan bearbeta befintliga händelser även efter att händelsestrukturen har ändrats.
• Övervaka systemet: Övervaka systemet noggrant för att upptäcka och förhindra fel. Övervaka händelselagringen, händelsepubliceringsprocessen och läsmodelluppdateringarna.
• Hantera idempotens: Se till att dina händelsehanterare är idempotenta. Detta innebär att de kan bearbeta samma händelse flera gånger utan att orsaka någon skada. Detta är viktigt eftersom händelser kan levereras mer än en gång i ett distribuerat system.
• Överväg kompenserande transaktioner: Om en operation misslyckas efter att en händelse har publicerats kan du behöva utföra en kompenserande transaktion för att ångra ändringarna. Om till exempel en order skapas men betalningen misslyckas kan du behöva avbryta ordern.

Verkliga exempel på Event Sourcing

Event Sourcing används i en mängd olika branscher och applikationer, inklusive:

• Finansiella tjänster: Banker och finansinstitut använder Event Sourcing för att spåra transaktioner, hantera konton och upptäcka bedrägerier.
• E-handel: E-handelsföretag använder Event Sourcing för att hantera order, spåra lager och anpassa kundupplevelsen.
• Gaming: Spelutvecklare använder Event Sourcing för att spåra speltillstånd, hantera spelarframsteg och implementera flerspelarfunktioner.
• Supply Chain Management: Supply chain-företag använder Event Sourcing för att spåra varor, hantera lager och optimera logistik.
• Hälso- och sjukvård: Hälso- och sjukvårdsleverantörer använder Event Sourcing för att spåra patientjournaler, hantera möten och förbättra patientvården.
• Global logistik: Företag som Maersk eller DHL kan använda event sourcing för att spåra försändelser över hela världen och fånga händelser som "ShipmentDepartedPort", "ShipmentArrivedPort", "CustomsClearanceStarted" och "ShipmentDelivered". Detta skapar ett komplett granskningsspår för varje försändelse.
• Internationell bankverksamhet: Banker som HSBC eller Standard Chartered kan använda event sourcing för att spåra internationella penningöverföringar och fånga händelser som "TransferInitiated", "CurrencyExchangeExecuted", "FundsSentToBeneficiaryBank" och "FundsReceivedByBeneficiary". Detta hjälper till att säkerställa regelefterlevnad och underlättar bedrägeribekämpning.

Slutsats

Event Sourcing är ett kraftfullt arkitektoniskt mönster som kan revolutionera din implementering av granskningsspår. Det ger oöverträffad spårbarhet, dataintegritet och systemåterhämtning. Även om det presenterar vissa utmaningar, uppväger fördelarna med Event Sourcing ofta kostnaderna, särskilt för komplexa och kritiska system. Genom att följa de bästa metoderna som beskrivs i den här guiden kan du framgångsrikt implementera Event Sourcing och bygga robusta och granskningsbara system.

Vidare läsning

• Event Sourcing av Martin Fowler
• EventStoreDB
• Axon Framework