Event-Driven Architecture

Systeme über Ereignisse lose koppeln und unabhängig reagieren lassen

Ein Architekturmuster, bei dem Komponenten über Ereignisse (Events) kommunizieren statt direkt miteinander – für lose Kopplung, Skalierbarkeit und Reaktionsfähigkeit.

Fortgeschritten2 Min Lesezeit

Erklärung starten

Auf einen Blick

3 Punkte

  1. Producer sendet Events, Consumer reagieren darauf – ohne direkte Verbindung
  2. Lose Kopplung: Producer weiß nicht, wer seine Events konsumiert
  3. Asynchron: Producer wartet nicht auf Antwort des Consumers

Sofortantwort

Event-Driven Architecture einfach erklärt

Komponenten kommunizieren über Ereignisse statt direkte Aufrufe – lose Kopplung.

Kurz gesagt
Producer sendet Events, Consumer reagieren darauf – ohne direkte Verbindung
Typischer Einsatz
KI-Pipeline-Orchestrierung, Echtzeit-Benachrichtigungen, Audit Logs
Wichtig zu wissen
Asynchron: Producer wartet nicht auf Antwort des Consumers

Event-Driven Architecture im Überblick

In traditionellen Architekturen ruft Service A direkt Service B auf: „Verarbeite diese Bestellung.” Service A wartet, bis B antwortet. Das ist einfach, aber problematisch: Wenn B langsam ist, ist A langsam. Wenn B ausfällt, fällt A aus.

Event-Driven Architecture dreht das um: Service A sendet ein Event – „Bestellung aufgegeben” – und macht sofort weiter. Service B, C und D hören auf dieses Event und reagieren unabhängig voneinander. A weiß nicht einmal, dass B, C und D existieren.

Synchron vs. Asynchron:

AspektRequest-ResponseEvent-Driven
KopplungEng (A kennt B)Lose (A kennt nur Event)
TimingSynchron (warten)Asynchron (fire & forget)
SkalierungGemeinsamUnabhängig pro Consumer
DebuggingEinfachKomplex (verteilt)

Technisch betrachtet

Event-Struktur

{
  "eventId": "evt_01HX...",
  "eventType": "document.uploaded",
  "timestamp": "2026-02-19T18:00:00Z",
  "source": "upload-service",
  "data": {
    "documentId": "doc_123",
    "userId": "usr_456",
    "filename": "report.pdf",
    "sizeBytes": 204800
  }
}

KI-Pipeline mit Events

Upload Service  →  [document.uploaded]  →  Chunking Service
                                        →  Virus Scanner
                                        →  Audit Logger

Chunking Service →  [document.chunked]  →  Embedding Service

Embedding Service → [embeddings.created] → Vector DB Service
                                         → Search Index Service

Python-Beispiel mit Kafka

from kafka import KafkaProducer, KafkaConsumer
import json

# Producer: Event senden
producer = KafkaProducer(bootstrap_servers='kafka:9092')
producer.send('document.uploaded', json.dumps({
    "documentId": "doc_123",
    "filename": "report.pdf"
}).encode())

# Consumer: Event verarbeiten
consumer = KafkaConsumer('document.uploaded', bootstrap_servers='kafka:9092')
for message in consumer:
    event = json.loads(message.value)
    chunk_document(event['documentId'])

Schritt für Schritt

Ereignisgesteuerte Abläufe verlässlich gestalten

Ein Event beschreibt eine eingetretene Tatsache. Der Wert entsteht aus klaren Verträgen, idempotenten Consumern und guter Beobachtbarkeit über verteilte Schritte.

  1. Ereignis fachlich definieren

    Vertrag

    Name, Zeitpunkt, Identität, Version und relevante Daten beschreiben eine Tatsache, die andere Komponenten verstehen sollen.

    document.uploaded v1
  2. Event veröffentlichen

    Publish

    Ein Producer sendet das Ereignis an einen Broker oder Bus, ohne einzelne Consumer direkt aufrufen zu müssen.

    Producer → Event Bus
  3. Consumer unabhängig verarbeiten

    Consume

    Jeder Consumer prüft, speichert seinen Fortschritt und reagiert idempotent auf mögliche Wiederholungen.

    Event → eigener Prozess
  4. Ablauf beobachten und korrigieren

    Operations

    Tracing, Dead-Letter-Queues und Replays helfen, Fehler und verzögerte Verarbeitung transparent zu behandeln.

    Monitoring → Retry oder Replay

Konkretes Beispiel

Beispiel: Ein Dokument für Suche vorbereiten

Nach einem Upload müssen Datei prüfen, Text extrahieren, Chunks erzeugen und Index aktualisieren.

Direkte Kette von Aufrufen

Der Upload wartet auf jeden Folgeschritt. Fällt ein Service aus, bricht die gesamte Nutzeraktion ab.

Ereignisgesteuerter Ablauf

Der Upload veröffentlicht ein Ereignis. Die nachgelagerten Dienste arbeiten unabhängig, können wiederholen und ihren Fortschritt sichtbar machen.

EDA verbessert Entkopplung und Skalierung, verlangt aber mehr Disziplin bei Verträgen, Fehlerbehandlung und Transparenz.

Einordnung

Vorteile und Grenzen

Das spricht dafür

  • Entkoppelt Producer von Verbrauchern und ihren Laufzeiten.
  • Erlaubt unabhängige Skalierung und parallele Reaktionen.
  • Unterstützt robuste asynchrone Workflows und Auditierbarkeit.
  • Erleichtert das Hinzufügen weiterer Consumer ohne Producer-Änderung.

Das solltest du beachten

  • Verteilte Fehler und zeitliche Reihenfolgen sind schwieriger zu verstehen.
  • Consumer müssen Duplikate, Wiederholungen und Versionen behandeln.
  • End-to-End-Transaktionen brauchen bewusstes Konsistenzdesign.
  • Monitoring und Debugging benötigen mehr als klassische Request-Logs.
Vertiefung · für Fortgeschrittene

Ereignisse zwischen unabhängigen Komponenten

Ein Broker vermittelt den Datenfluss, ohne fachliche Verantwortung der Consumer zu übernehmen.

Wissenskarte

Ereignisse verteilen

Der Nutzen der losen Kopplung entsteht nur, wenn Ereignisse stabil versioniert und Fehlerfälle ausdrücklich modelliert sind. Event Bus gliedert sich in: Producer, Schema, Broker, Consumer, State Store, Observability.

01Einsatzbereiche

Wann ist Event-Driven Architecture sinnvoll?

Geeignet für

  • KI-Pipeline-OrchestrierungNeues Dokument hochgeladen → Event → Chunking → Embedding → Vektordatenbank – jeder Schritt unabhängig skalierbar
  • Echtzeit-BenachrichtigungenBestellung aufgegeben → Events an Lager, Zahlung, E-Mail-Service – alle parallel, ohne Abhängigkeiten
  • Audit LogsJede Aktion erzeugt ein Event – unveränderlicher Verlauf aller Systemereignisse

↑ Inhalt

02Werkzeuge

Womit Event-Driven Architecture umgesetzt wird

↑ Inhalt

Merksatz

Event-Driven Architecture ist wie ein Nachrichtensystem in einer Redaktion

Ein Reporter schreibt einen Artikel (Event) und legt ihn in den Posteingang. Alle Abteilungen, die sich dafür interessieren (Druck, Online, Social Media), holen ihn sich selbst ab. Der Reporter muss nicht wissen, wer den Artikel verwendet.

  1. Producer sendet Events, Consumer reagieren darauf – ohne direkte Verbindung
  2. Lose Kopplung: Producer weiß nicht, wer seine Events konsumiert
  3. Asynchron: Producer wartet nicht auf Antwort des Consumers

04Redaktion

Herkunft und Stand

Redaktion und Aktualität

Ebenex RedaktionRedaktion

Veröffentlicht
Aktualisiert

Dieses Feld entwickelt sich schnell. Oben stehen Veröffentlichung und letzte Änderung; ein Prüfdatum kommt dazu, sobald die Erklärung nach ihrer letzten Änderung geprüft wurde.

↑ Inhalt

05FAQ

Häufige Fragen zu Event-Driven Architecture

Was ist der Unterschied zwischen Event-Driven und Request-Response?

Request-Response (REST): Service A ruft Service B auf und wartet auf Antwort – synchron, direkte Kopplung. Event-Driven: Service A sendet ein Event und macht weiter – asynchron, lose Kopplung. Service B reagiert, wenn es bereit ist. EDA ist besser für Skalierung, aber schwieriger zu debuggen.

Was ist der Unterschied zwischen Event und Message?

Ein Event beschreibt etwas, das passiert ist: 'Bestellung aufgegeben' (Vergangenheit, unveränderlich). Eine Message ist eine Anweisung: 'Verarbeite diese Bestellung' (Gegenwart, Aufforderung). Events sind oft unveränderlich und können von mehreren Consumern gelesen werden.

Was ist Event Sourcing?

Ein Muster, bei dem der Zustand eines Systems nicht als aktueller Snapshot gespeichert wird, sondern als Folge aller Events, die zu diesem Zustand geführt haben. Der aktuelle Zustand wird durch Replay aller Events rekonstruiert. Vollständige Auditierbarkeit, aber höhere Komplexität.

↑ Inhalt

06Weiterlernen

Was möchtest du als Nächstes verstehen?

  • Grundlage nachholen

    CQRS

    Trennung von Lese- und Schreibmodellen für gezielte Optimierung.

  • Technisch vertiefen

    Message Queue

    Warteschlange für asynchrone Service-Kommunikation.

↑ Inhalt