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:
| Aspekt | Request-Response | Event-Driven |
|---|---|---|
| Kopplung | Eng (A kennt B) | Lose (A kennt nur Event) |
| Timing | Synchron (warten) | Asynchron (fire & forget) |
| Skalierung | Gemeinsam | Unabhängig pro Consumer |
| Debugging | Einfach | Komplex (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.
Ereignis fachlich definieren
Vertrag
Name, Zeitpunkt, Identität, Version und relevante Daten beschreiben eine Tatsache, die andere Komponenten verstehen sollen.
document.uploaded v1Event veröffentlichen
Publish
Ein Producer sendet das Ereignis an einen Broker oder Bus, ohne einzelne Consumer direkt aufrufen zu müssen.
Producer → Event BusConsumer unabhängig verarbeiten
Consume
Jeder Consumer prüft, speichert seinen Fortschritt und reagiert idempotent auf mögliche Wiederholungen.
Event → eigener ProzessAblauf 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 FortgeschritteneEreignisse zwischen unabhängigen Komponenten
Ein Broker vermittelt den Datenfluss, ohne fachliche Verantwortung der Consumer zu übernehmen.
Ereignisse verteilen