Zurück zum Blog

Game-Backend-Events unter Last verloren? Die Lösung: eine durable Streaming-Architektur

Veröffentlicht am 6. Oktober 2026
Game-Backend-Events unter Last verloren? Die Lösung: eine durable Streaming-Architektur Mit Hilfe von KI generiert

Kurz und knapp

Erfahre, wie du mit einem durable Event Stream Event-Verluste im Game-Backend verhinderst, Consumer entkoppelst und stille Datenverluste erkennst.

Deine Analytics-Pipeline hat während eines Wochenend-Peaks 40 % der Player-Death-Events verloren. Leaderboards sind veraltet. Crash-Reports sind nie angekommen. Drei Tage lang hat es niemand bemerkt.

Das ist der stille Killer für die Zuverlässigkeit von Game-Backends: gekoppelte Producer-Consumer-Architekturen, die bei 100 Requests pro Sekunde einwandfrei funktionieren und bei 10.000 Requests pro Sekunde ausbluten. Der RPC-Aufruf von deinem Game-Server an deinen Analytics-Consumer läuft in einen Timeout, die Verbindung wird zurückgesetzt, und das Event verschwindet einfach – ohne Fehler, ohne Retry, ohne Aufzeichnung.

Dieses Runbook behandelt, was kaputtgeht, wie du es erkennst, welches Architekturmuster es behebt und wie du ein erneutes Auftreten verhinderst.

Was kaputtgeht: Der Fehlermodus der gekoppelten Producer-Consumer-Architektur

Traditionelle RPC-Architekturen zwingen Producer und Consumer dazu, sowohl in der Skalierung als auch in der Zeit übereinzustimmen. Wenn dein Game-Server ein player_killed-Event per HTTP direkt an einen Analytics-Dienst sendet:

  1. Skalierungs-Mismatch: Wenn während eines Server-Events 5.000 Spieler gleichzeitig sterben, erhält dein Analytics-Endpoint einen Burst, den er nicht verarbeiten kann. Die HTTP-Verbindung läuft nach 30 Sekunden in einen Timeout. Events werden verworfen.
  2. Zeitliche Kopplung: Wenn dein Fraud-Detection-Dienst eine neue Version deployed und für 90 Sekunden offline geht, verschwindet jedes Event, das in diesem Zeitraum erzeugt wird.
  3. Multi-Consumer-Fan-out: Dasselbe player_killed-Event muss drei unabhängige Systeme erreichen – einen Leaderboard-Updater, eine Analytics-Pipeline und ein Live-Ops-Dashboard. Jeder Consumer hat einen anderen Durchsatz. Der langsamste wird zum Flaschenhals für den Producer.

So sieht das in der Praxis aus:

[Game Server] --HTTP POST--> [Analytics Service]     ✓ works at 200 req/s
[Game Server] --HTTP POST--> [Analytics Service]     ✗ 40% drops at 8,000 req/s
[Game Server] --HTTP POST--> [Fraud Detection]       ✗ offline during deploy

Das Ergebnis: stiller, partieller Datenverlust, der Analytics korrumpiert, Leaderboards veralten lässt und Crash-Muster unsichtbar macht. Du entdeckst es erst Wochen später, wenn deine Funnel-Zahlen nicht aufgehen.

Konkrete Ausfallzahlen

In einem typischen Indie-Multiplayer-Backend mit 5.000 gleichzeitigen Spielern:

  • ~2.400 Gameplay-Events/Sekunde im Peak (Kills, Score-Updates, Inventaränderungen, Zonenwechsel)
  • Durchschnittliche Event-Payload: ~200 Bytes
  • Direkter HTTP-Fan-out an 3 Consumer: 7.200 ausgehende Requests/Sekunde
  • Consumer-Timeout-Schwelle: 30 Sekunden
  • Beobachtete Drop-Rate im Peak: 15–45 % je nach Consumer-Gesundheit

Die Rechnung ist brutal. Ein einzelner Consumer, der 60 Sekunden lang unhealthy ist, verliert 72.000 Events. Diese Events sind weg, wenn du keinen Puffer gebaut hast.

So erkennst du stillen Event-Verlust

Stiller Event-Verlust ist per Definition schwer zu erkennen. Hier ist ein Runbook zur Erkennung:

Schritt 1: Sequenznummern einbauen

Jeder Producer sollte jedes Event mit einer monoton steigenden Sequenznummer pro Quell-Entity versehen. Wenn dein Game-Server Events für player_abc sendet, läuft die Sequenz 1, 2, 3, 4 ...

Event 1: { seq: 1, player: "abc", type: "kill", ts: 1719432000 }
Event 2: { seq: 2, player: "abc", type: "death", ts: 1719432001 }
Event 3: { seq: 4, player: "abc", type: "score", ts: 1719432005 }  // seq 3 missing!

Eine Lücke in den Sequenznummern auf der Consumer-Seite bedeutet bestätigter Event-Verlust.

Schritt 2: Consumer-Lag überwachen

Verfolge die Differenz zwischen der zuletzt produzierten und der zuletzt konsumierten Sequenz für jeden Consumer. Alert-Schwellenwerte:

  • Lag < 1.000 Events: Gesund
  • Lag 1.000–10.000 Events: Warnung – der Consumer fällt zurück
  • Lag > 10.000 Events: Kritisch – der Consumer ist praktisch offline oder überlastet

Schritt 3: Summen gegenseitig validieren

Vergleiche stündlich die Event-Zahlen aus den Producer-Logs mit den vom Consumer aufgenommenen Zahlen. Eine Abweichung von mehr als 1 % rechtfertigt eine Untersuchung.

// Producer-side counter (emit to your monitoring system every 60s)
public class EventProducerMetrics
{
    private long _producedCount = 0;

    public void RecordProduced()
    {
        Interlocked.Increment(ref _producedCount);
    }

    public long GetAndResetCount()
    {
        return Interlocked.Exchange(ref _producedCount, 0);
    }
}

Wenn deine produzierte Anzahl pro Stunde 8.400.000 beträgt und dein Analytics-Consumer 5.100.000 aufgenommen hat, hast du 39 % der Events verloren. Das ist dein Signal.

Die architektonische Lösung: Entkopplung mit einem durable Event Log

Die Lösung besteht darin, Producer von Consumer zu entkoppeln, indem du einen durable Puffer zwischen sie schaltest. Statt:

Game Server --direct HTTP--> Analytics
Game Server --direct HTTP--> Leaderboard Service
Game Server --direct HTTP--> Crash Reporter

schreibst du auf:

Game Server --single write--> [Durable Event Stream] --independent reads--> Analytics
                                                    --independent reads--> Leaderboard Service
                                                    --independent reads--> Crash Reporter

Der durable Stream nimmt Schreibvorgänge mit Producer-Geschwindigkeit auf. Jeder Consumer liest in seinem eigenen Tempo. Wenn ein Consumer für 5 Minuten offline geht, sammeln sich die Events im Stream, und der Consumer setzt bei seiner Rückkehr genau dort fort, wo er aufgehört hat. Kein Datenverlust.

Kerneigenschaften eines durable Event Streams

Ein produktionsreifer Event Stream für Game-Backends braucht diese Eigenschaften:

Eigenschaft Warum sie für Games wichtig ist
Innerhalb einer Partition geordnet Alle Events eines Spielers müssen in der richtigen Reihenfolge verarbeitet werden – ein Kill vor einem Score-Update, nicht danach
Durable Storage Events überleben Consumer-Neustarts, Deploy-Fenster und Infrastrukturfehler
Unabhängige Consumer-Offsets Dein Analytics-Consumer und dein Leaderboard-Consumer lesen mit unterschiedlichen Geschwindigkeiten, ohne sich gegenseitig zu blockieren
Ordering auf Partitionsebene Du bekommst Parallelität über Spieler hinweg (verschiedene Partitionen) und Konsistenz innerhalb eines Spielers (gleiche Partition)

Partitionierungsstrategie für Game-Backends

Der Partitionsschlüssel bestimmt, welche Events in welchem geordneten Log landen. Für Game-Backends ist der natürliche Partitionsschlüssel playerId:

Partition 0: [player_abc kill#1] [player_abc death#2] [player_abc score#3]
Partition 1: [player_def zone#1] [player_def kill#2] [player_def loot#3]
Partition 2: [player_ghi death#1] [player_ghi spawn#2]

Das garantiert, dass alle Events eines einzelnen Spielers von jedem Consumer in exakter Reihenfolge verarbeitet werden, während Events verschiedener Spieler parallel verarbeitet werden können.

Durable Event Streaming implementieren: Ein praktischer Leitfaden

Hier ist ein konkretes Implementierungsmuster. Du kannst das auf Object Storage (wie S3/R2), einem verwalteten Streaming-Dienst oder einem datenbankgestützten Log aufbauen.

Der Producer: Single-Write-Fan-out

Dein Game-Server schreibt ein einziges Event. Die Streaming-Infrastruktur übernimmt die Zustellung an alle Consumer.

public class GameEventProducer
{
    private readonly IEventStreamClient _stream;
    private readonly ILogger _logger;

    public GameEventProducer(IEventStreamClient stream, ILogger logger)
    {
        _stream = stream;
        _logger = logger;
    }

    public async Task EmitAsync(string playerId, string eventType, 
                                 Dictionary&lt;string, object> payload)
    {
        var gameEvent = new GameEvent
        {
            Id = Guid.NewGuid().ToString(),
            PlayerId = playerId,        // partition key
            EventType = eventType,
            Payload = payload,
            Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
        };

        try
        {
            // Single write — the stream handles fan-out to all consumers
            await _stream.AppendAsync(
                partitionKey: playerId,
                eventData: JsonSerializer.Serialize(gameEvent)
            );
        }
        catch (EventStreamException ex)
        {
            // Events that fail to write should be queued locally 
            // and retried, not silently dropped
            _logger.LogWarning(ex, 
                "Failed to emit event {EventType} for {Player}, queueing retry", 
                eventType, playerId);
            await _retryQueue.EnqueueAsync(gameEvent);
        }
    }
}

Wichtige Design-Entscheidungen in diesem Code:

  • Partitionsschlüssel ist playerId: Sorgt für Ordering pro Spieler über alle Event-Typen hinweg.
  • Ein einziger Schreibaufruf: Der Producer weiß nicht und kümmert sich nicht darum, wie viele Consumer existieren. Einen neuen Consumer hinzuzufügen (z. B. einen Tracker für saisonale Events) erfordert null Änderungen am Producer.
  • Lokale Retry-Queue: Wenn der Stream vorübergehend nicht verfügbar ist, werden Events lokal in eine Queue gelegt und bei wiederhergestellter Verbindung abgespült. Das verhindert Datenverlust bei kurzen Netzwerkstörungen.

Der Consumer: Unabhängiges Offset-Tracking

Jeder Consumer führt einen eigenen Lese-Offset pro Partition. Das ist der Kernmechanismus, der unabhängige Verarbeitungsgeschwindigkeiten ermöglicht.

public class LeaderboardConsumer
{
    private readonly IEventStreamClient _stream;
    private readonly ILeaderboardService _leaderboard;
    private readonly IOffsetStore _offsets;

    public async Task ProcessEventsAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            // Read the next batch from where we left off
            var lastOffset = await _offsets.GetOffsetAsync(
                consumerName: "leaderboard-updater",
                partitionId: 0
            );

            var batch = await _stream.ReadBatchAsync(
                partitionId: 0,
                fromOffset: lastOffset,
                maxBatchSize: 500
            );

            foreach (var evt in batch.Events)
            {
                var gameEvent = JsonSerializer.Deserialize&lt;GameEvent>(evt.Data);

                if (gameEvent.EventType == "player_killed")
                {
                    await _leaderboard.IncrementKillsAsync(
                        gameEvent.PlayerId, 
                        amount: 1
                    );
                }
                else if (gameEvent.EventType == "score_updated")
                {
                    await _leaderboard.UpdateScoreAsync(
                        gameEvent.PlayerId, 
                        gameEvent.Payload["score"].GetInt32()
                    );
                }

                // Advance offset AFTER successful processing
                await _offsets.SetOffsetAsync(
                    consumerName: "leaderboard-updater",
                    partitionId: 0,
                    offset: evt.Offset + 1
                );
            }

            await Task.Delay(100, ct); // Poll interval
        }
    }
}

Kritische Implementierungsdetails:

  • Der Offset wird nach der Verarbeitung erhöht, nicht davor. Wenn der Consumer mitten in einem Batch abstürzt, verarbeitet er beim Neustart dieselben Events erneut. Deine Handler müssen idempotent sein – dasselbe Kill-Event zweimal zu verarbeiten, darf den Leaderboard-Eintrag nicht doppelt zählen.
  • Batch-Größe von 500 balanciert Durchsatz und Speicher. Bei 200-Byte-Events sind das ~100 KB pro Batch – vernachlässigbar.
  • 100-ms-Poll-Intervall bedeutet eine Worst-Case-Latenz von ~100 ms von der Event-Erzeugung bis zum Leaderboard-Update. Für die meisten Leaderboard-Anwendungsfälle ist das völlig akzeptabel. Wenn du Latenzen unter 10 ms brauchst, bist du im Bereich des Echtzeit-Transports – das ist eine ganz andere Architektur.

Idempotenz: Das Sicherheitsnetz des Consumers

Idempotenz ist in dieser Architektur nicht verhandelbar. Hier ist ein konkreter idempotenter Handler:

public class IdempotentKillCounter
{
    private readonly IDatabase _db;

    public async Task ProcessKillAsync(string playerId, string eventId)
    {
        // Check if we already processed this event
        var alreadyProcessed = await _db.ExecuteScalarAsync&lt;bool>(
            "SELECT COUNT(*) > 0 FROM processed_events WHERE event_id = @id",
            new { id = eventId }
        );

        if (alreadyProcessed)
        {
            return; // Skip duplicate — this is the idempotency guard
        }

        // Process and record in a transaction
        await _db.ExecuteInTransactionAsync(async tx =>
        {
            await tx.ExecuteAsync(
                "UPDATE leaderboard SET kills = kills + 1 WHERE player_id = @pid",
                new { pid = playerId }
            );
            await tx.ExecuteAsync(
                "INSERT INTO processed_events (event_id, processed_at) VALUES (@id, @now)",
                new { id = eventId, now = DateTime.UtcNow }
            );
        });
    }
}

Die Tabelle processed_events fungiert als Deduplizierungs-Store. Sie kostet einen zusätzlichen Write pro Event, garantiert aber, dass Consumer-Neustarts deine Daten niemals korrumpieren.

Umgang mit Consumer-Ausfällen: Die Puffer-Garantie

Der Hauptgrund für durable Event Streaming ist, Consumer-Ausfälle ohne Datenverlust zu überstehen. So funktioniert die Puffer-Rechnung:

Producer rate:           2,400 events/second
Consumer offline window: 5 minutes (300 seconds)
Events buffered:         720,000 events
Storage required:        720,000 × 200 bytes = ~144 MB

Bei 144 MB passt das problemlos in jedes moderne Speichersystem. Die entscheidende Erkenntnis: Deine Puffergröße ist proportional zu deiner Event-Rate multipliziert mit deiner maximalen Ausfalltoleranz, nicht zu deinen gesamten historischen Daten.

Für die langfristige Aufbewahrung (30 Tage Events für Replay oder erneute Verarbeitung) wachsen die Zahlen:

30 days × 86,400 seconds × 2,400 events/sec × 200 bytes = ~1.24 TB

Das liegt gut im Rahmen der Kapazität von Object-Storage-Backends. Die Partitionsstruktur hält die Leseleistung selbst in dieser Größenordnung vorhersehbar – du durchsuchst nie das gesamte Log, sondern liest aus bestimmten Partitionen an bestimmten Offsets.

Was horizOn in einer Event-Driven Architecture bietet

Sobald dein Event Stream Daten zuverlässig zustellt, brauchst du Dienste, die diese Events konsumieren. horizOn bietet verwaltete Backend-Dienste, in die deine Consumer über die SDKs oder die REST API schreiben können:

  • Leaderboards führen die Rangliste für Scores, die deine Consumer aus Kill-, Score- und Abschluss-Events einreichen
  • User-Logs speichern Log-Einträge, die du schreibst, sodass du bei "mein Score wurde zurückgesetzt" in den Logs des Spielers nachsehen kannst
  • Crash-Reports sammeln Crash- und Non-Fatal-Reports aus den SDKs, gruppiert zur Auswertung

Der Punkt: Der Event Stream bringt Daten zuverlässig zu deinen Consumern. horizOn ersetzt den Stream nicht, sondern deckt die Dienste ab, die hinter deinen Consumern stehen.

Runbook: Event-Verlust dauerhaft verhindern

Wenn du einmal Event-Verlust erlebt hast, ist hier die Checkliste, um das erneute Auftreten zu verhindern:

1. Jede Producer-Consumer-Kopplung prüfen

Gehe deine Codebase durch und identifiziere jede Stelle, an der ein Game-Server einen direkten synchronen HTTP-Aufruf an einen Backend-Dienst macht. Jede davon ist ein potenzieller Drop-Punkt unter Last. Liste sie auf:

GameServer → AnalyticsService      (HTTP POST, no retry)     ← RISK
GameServer → LeaderboardService    (HTTP POST, no retry)     ← RISK
GameServer → CrashReporter         (UDP, fire-and-forget)    ← RISK

2. Den Event Stream als Vermittler einführen

Ersetze jeden direkten Aufruf durch einen einzelnen Write in den durable Event Stream. Jeder nachgelagerte Dienst wird zu einem unabhängigen Consumer mit eigenem Offset.

3. Consumer-Health-Monitoring implementieren

Für jeden Consumer überwache:

  • Lag (Events hinter dem Producer)
  • Verarbeitungsrate (konsumierte Events pro Sekunde)
  • Fehlerrate (Events, die pro Sekunde nicht verarbeitet werden konnten)
  • Letzter erfolgreicher Offset (Erkennung von Veraltung)

Alarmiere bei einem Lag, der dein berechnetes Pufferfenster überschreitet. Wenn dein Stream 7 Tage aufbewahrt und dein Consumer 6 Tage lang ausgefallen ist, bleiben dir 24 Stunden, bevor der Datenverlust beginnt.

4. Consumer-Neustart-Wiederherstellung testen

Nimm einen Consumer absichtlich für 5 Minuten offline, bring ihn zurück und stelle sicher, dass er ohne Duplikate aufholt. Das ist dein Vertrauenstest, dass die Architektur funktioniert. Automatisiere ihn in CI:

[Test]
public async Task ConsumerResumesAfterDowntime()
{
    // Produce 10,000 events
    await ProduceEvents(count: 10_000);

    // Simulate consumer offline — skip reads for 30 seconds
    await Task.Delay(TimeSpan.FromSeconds(30));

    // Resume consumer
    var processed = await Consumer.ProcessUntilCaughtUp();

    // Verify: all events processed, no duplicates
    Assert.AreEqual(10_000, processed.UniqueEventCount);
    Assert.AreEqual(0, processed.DuplicateCount);
}

5. Eine Dead-Letter-Queue einrichten

Events, die nach N Retries (typischerweise 3–5) nicht verarbeitet werden können, wandern in eine Dead-Letter-Queue. Überwache die DLQ-Größe. Eine wachsende DLQ bedeutet, dass dein Consumer einen Bug hat – keinen transienten Fehler.

Best Practices für Game-Backend-Event-Streaming

  1. Wähle playerId als Partitionsschlüssel. Das liefert dir Ordering pro Spieler (kritisch für Inventar-, Score- und State-Events) und erlaubt gleichzeitig Parallelität über Spieler hinweg. Partitioniere nicht nach Event-Typ – ein kill und ein score_update für denselben Spieler müssen geordnet bleiben.

  2. Halte Events klein und selbstbeschreibend. Jedes Event sollte 100–500 Bytes groß sein. Enthalte den Event-Typ, die Spieler-ID, den Zeitstempel und die minimal benötigte Payload. Bette keinen vollständigen Game-State ein – referenziere ihn per ID.

  3. Designe Consumer von Anfang an idempotent. Verwende Event-IDs und einen Deduplizierungs-Store. Geh davon aus, dass jedes Event mindestens einmal zugestellt wird – und bei Failover möglicherweise mehr als einmal.

  4. Bemesse dein Aufbewahrungsfenster an der maximal akzeptablen Consumer-Ausfallzeit. Wenn dein längstes Deployment 15 Minuten dauert, bewahre mindestens 30 Minuten heiße Events auf. Halte 7–30 Tage Cold Storage für Replay und Debugging vor.

  5. Überwache Consumer-Lag als First-Class-Metrik. Lag ist der Herzschlag deiner Event-Driven Architecture. Ein Consumer, der mehr als 50 % seines Aufbewahrungsfensters hinterherhinkt, ist ein Datenverlust-Notfall – kein „Das fixen wir im nächsten Sprint“-Thema.

Nächste Schritte

Wenn du aktuell direkte RPC-Aufrufe von Game-Servern an Backend-Dienste betreibst, prüfe diese Verbindungen noch diese Woche. Zähle, wie viele bei einem 10-fachen Lastanstieg still Events verlieren würden. Prototype danach einen durable Event Stream zwischen deinen Producern und Consumern – selbst ein einfaches datenbankgestütztes Log ist besser als direkte Kopplung.

Wenn deine Consumer in Leaderboards, Crash-Reports oder User-Logs schreiben, stellt horizOn diese als verwaltete Dienste bereit, damit du nicht jeden einzelnen selbst bauen musst. Du kannst direkt mit dem Quickstart loslegen.


Quelle: Ankündigung von Cloudflare K2: serverlose Event-Streams