Wat is het grote voordeel van Event Sourcing?

Voordat we in de details duiken, laten we eens kijken wat event sourcing is en waarom het zoveel aandacht krijgt:

  • 📜 Historisch Archief: Elke verandering is een gebeurtenis, opgeslagen in volgorde.
  • 🔄 Staat Heropbouw: Huidige staat? Speel gewoon de gebeurtenissen opnieuw af.
  • 🔍 Audit Trail: Wie deed wat en wanneer? Het staat er allemaal.
  • 🚀 Schaalbaarheid: Gebeurtenissen zijn onveranderlijk, waardoor ze gemakkelijk te distribueren en te schalen zijn.

Combineer dit met serverloze architectuur, en je hebt een perfecte match in de cloud.

Maak kennis met AWS EventBridge: Jouw Serverloze Event Bus

AWS EventBridge is als de coole gast op het serverloze feestje. Het is een serverloze event bus die het eenvoudig maakt om applicaties te verbinden met data van je eigen apps, geïntegreerde SaaS-apps en AWS-diensten.

Dit is waarom het perfect is voor ons event sourcing systeem:

  • 🔌 Plug-and-Play: Eenvoudige integratie met andere AWS-diensten.
  • 🎯 Event Filtering: Routeer gebeurtenissen naar de juiste plek zonder complexe logica.
  • 📊 Schema Registry: Definieer en beheer je gebeurtenisstructuur.
  • 🔒 Beveiliging: AWS-kwaliteit beveiliging en encryptie standaard.

Ons Serverloze Event Sourcing Systeem Bouwen

Laten we aan de slag gaan en dit ding bouwen! We maken een eenvoudig e-commerce systeem dat orderstatuswijzigingen bijhoudt.

Stap 1: EventBridge Instellen

Eerst moeten we een aangepaste event bus maken. Dit kan via de AWS Console of met AWS CLI:

aws events create-event-bus --name "OrderEventBus"

Stap 2: Ons Event Schema Definiëren

Laten we een schema definiëren voor onze orderstatuswijzigingen:

{
  "OrderId": "string",
  "Status": "string",
  "Timestamp": "string",
  "Details": {
    "CustomerId": "string",
    "Amount": "number"
  }
}

Je kunt dit schema maken in de EventBridge Schema Registry voor betere governance en vindbaarheid.

Stap 3: Gebeurtenissen Verzenden

Nu gaan we een gebeurtenis verzenden wanneer een orderstatus verandert. Hier is hoe je dat zou kunnen doen met AWS SDK voor JavaScript:

const AWS = require('aws-sdk');
const eventbridge = new AWS.EventBridge();

async function sendOrderStatusChangeEvent(orderId, status, customerId, amount) {
  const params = {
    Entries: [
      {
        Source: 'com.myecommerce.orders',
        EventBusName: 'OrderEventBus',
        DetailType: 'OrderStatusChange',
        Time: new Date(),
        Detail: JSON.stringify({
          OrderId: orderId,
          Status: status,
          Timestamp: new Date().toISOString(),
          Details: {
            CustomerId: customerId,
            Amount: amount
          }
        })
      }
    ]
  };

  try {
    const result = await eventbridge.putEvents(params).promise();
    console.log('Event succesvol verzonden:', result);
  } catch (error) {
    console.error('Fout bij het verzenden van de gebeurtenis:', error);
  }
}

// Gebruik
sendOrderStatusChangeEvent('ORD-123', 'VERZONDEN', 'CUST-456', 99.99);

Stap 4: Gebeurtenissen Verwerken

Om deze gebeurtenissen te verwerken, gebruiken we AWS Lambda. Maak een Lambda-functie en stel een EventBridge-regel in om deze te activeren:

exports.handler = async (event) => {
  console.log('Ontvangen gebeurtenis:', JSON.stringify(event, null, 2));
  
  const orderEvent = event.detail;
  
  // Hier zou je kunnen:
  // 1. De gebeurtenis opslaan in een duurzame opslag (bijv. DynamoDB)
  // 2. Een leesmodel bijwerken voor query's
  // 3. Andere bedrijfsprocessen activeren

  return {
    statusCode: 200,
    body: JSON.stringify('Gebeurtenis succesvol verwerkt'),
  };
};

Stap 5: De EventBridge Regel Maken

Stel een regel in om gebeurtenissen naar je Lambda-functie te routeren:

aws events put-rule \
  --name "OrderStatusChangeRule" \
  --event-bus-name "OrderEventBus" \
  --event-pattern "{\"source\":[\"com.myecommerce.orders\"],\"detail-type\":[\"OrderStatusChange\"]}"

aws lambda add-permission \
  --function-name YourLambdaFunctionName \
  --statement-id EventBridgeInvoke \
  --action 'lambda:InvokeFunction' \
  --principal events.amazonaws.com \
  --source-arn arn:aws:events:YOUR_REGION:YOUR_ACCOUNT_ID:rule/OrderEventBus/OrderStatusChangeRule

aws events put-targets \
  --rule OrderStatusChangeRule \
  --event-bus-name OrderEventBus \
  --targets "Id"="1","Arn"="arn:aws:lambda:YOUR_REGION:YOUR_ACCOUNT_ID:function:YourLambdaFunctionName"

De Voordelen, Nadelen en Gebeurtenissen

Nu we ons serverloze event sourcing systeem hebben gebouwd, laten we de voor- en nadelen bespreken:

Voordelen:

  • 🚀 Schaalbaarheid: EventBridge schaalt automatisch met je gebeurtenisvolume.
  • 💸 Kosteneffectief: Betaal alleen voor de gebeurtenissen die je verwerkt.
  • 🔗 Losse Koppeling: Eenvoudig nieuwe consumenten toevoegen zonder producenten te beïnvloeden.
  • 🕰️ Tijdreizen Debugging: Speel gebeurtenissen opnieuw af om elke vorige staat te recreëren.

Nadelen:

  • 🧠 Mentale Verandering: Event-gedreven denken kan in het begin uitdagend zijn.
  • 🐢 Eventuele Consistentie: Real-time query's kunnen lastig zijn.
  • 🗃️ Event Opslag: Je hebt een strategie nodig voor langdurige opslag en beheer van gebeurtenissen.

Samenvatting: Waarom Serverless met Event Sourcing?

Serverloze event sourcing met AWS EventBridge is niet zomaar een manier om je architectuur te compliceren. Het is een krachtige aanpak die kan bieden:

  • 📈 Verbeterde Schaalbaarheid: Omgaan met pieken in verkeer zonder problemen.
  • 💡 Betere Inzichten: Leg elke verandering vast voor geavanceerde analyses en debugging.
  • 🛠️ Flexibiliteit: Pas je systeem eenvoudig aan als zakelijke vereisten veranderen.

Onthoud, zoals bij elke architecturale beslissing, is het geen oplossing die voor iedereen werkt. Maar voor systemen die staatveranderingen nauwkeurig moeten bijhouden, vooral in een gedistribueerde omgeving, kan deze aanpak een game-changer zijn.

"De beste manier om de toekomst te voorspellen is om deze te implementeren." - Alan Kay

Dus, ben je klaar om je toekomst te implementeren met serverloze event sourcing? Probeer het eens, en je zult je misschien afvragen hoe je ooit zonder hebt gekund. Veel programmeerplezier, en moge je gebeurtenissen altijd hun weg vinden! 🚀

Verder Lezen en Bronnen

Onthoud, de reis naar het beheersen van serverloze event sourcing is een marathon, geen sprint. Blijf experimenteren, blijf leren, en vooral, houd die gebeurtenissen in beweging! 🌊