게임 백엔드 이벤트 유실? 내구성 있는 스트리밍 아키텍처 도입
핵심 요약
게임 백엔드의 부하 시 이벤트 유실 문제를 해결하는 내구성 있는 스트리밍 아키텍처와 구현 방법을 확인하세요.
주말 피크타임에 분석 파이프라인에서 플레이어 사망 이벤트의 40%가 유실되었습니다. 리더보드는 갱신되지 않았고, 크래시 리포트는 도착조차 하지 않았습니다. 아무도 사흘 동안 이 사실을 눈치채지 못했습니다.
이것이 바로 게임 백엔드 안정성을 갉아먹는 보이지 않는 주범입니다. 초당 100건의 요청에서는 정상적으로 작동하다가 10,000건에서 데이터를 쏟아내는 **결합된 프로듀서-컨슈머 아키텍처(coupled producer-consumer architectures)**입니다. 게임 서버에서 분석 컨슈머로 향하는 RPC 호출 타임아웃이 발생하고, 연결이 재설정되며, 이벤트가 단순히 증발합니다. 에러도, 재시도도, 기록도 남지 않습니다.
본 런북에서는 어떤 부분이 깨지는지, 어떻게 감지하는지, 이를 해결하는 아키텍처 패턴은 무엇이며 재발 방지 대책은 어떻게 세워야 하는지 다룹니다.
무엇이 깨지는가: 결합된 프로듀서-컨슈머 장애 모드
전통적인 RPC 아키텍처는 프로듀서와 컨슈머가 스케일과 시간 양쪽 모두에서 일치할 것을 강제합니다. 게임 서버가 HTTP를 통해 "player_killed"벤트를 분석 서비스로 직접 전송할 때 다음과 같은 일이 발생합니다.
- 스케일 불일치: 서버 이벤트 도중 5,000명의 플레이어가 동시에 사망하면 분석 엔드포인트는 처리할 수 없는 폭주(burst)를 받게 됩니다. HTTP 연결은 30초 후 타임아웃됩니다. 이벤트는 유실됩니다.
- 시간 결합: 사기 탐지(fraud detection) 서비스가 새 버전을 배포하느라 90초 동안 오프라인 상태가 되면, 해당 창구에서 생성된 모든 이벤트가 사라집니다.
- 멀티 컨슈머 팬아웃: 동일한 "player_killed" 이벤트가 리더보드 업데이터, 분석 파이프라인, 라이브오즈 대시보드라는 세 개의 독립된 시스템에 도달해야 합니다. 각 컨슈머마다 처리량(throughput)이 다릅니다. 가장 느린 컨슈머가 프로듀서의 병목 현상이 됩니다.
실제로는 다음과 같은 모습입니다.
[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
그 결과는 조용한 부분적 데이터 유실로 이어져 분석 데이터를 망가뜨리고, 리더보드를 낡게 만들며, 보이지 않는 크래시 패턴을 낳습니다. 퍼널 수치가 맞지 않다는 것을 몇 주가 지나서야 깨닫게 됩니다.
구체적인 장애 수치
5,000명의 동시 접속자를 처리하는 전형적인 인디 멀티플레이어 백엔드 기준:
- 피크타임 기준 초당 약 2,400개의 게임플레이 이벤트 (킬, 점수 갱신, 인벤토리 변경, 구역 이동)
- 평균 이벤트 페이로드: 약 200바이트
- 3개 컨슈머로의 다이렉트 HTTP 팬아웃: 초당 7,200회의 아웃바운드 요청
- 컨슈머 타임아웃 임계값: 30초
- 피크타임 관측 유실률: 컨슈머 상태에 따라 15~45%
산술적 수치는 가혹합니다. 단일 컨슈머가 60초 동안 비정상 상태가 되면 72,000개의 이벤트가 유실됩니다. 버퍼를 구축해 두지 않았다면 이 이벤트들은 영영 사라집니다.
조용한 이벤트 유실을 감지하는 방법
이벤트 유실은 정의상 포착하기 어렵습니다. 다음은 감지 런북입니다.
1단계: 시퀀스 번호 기입하기
모든 프로듀서는 소스 엔티티별로 단조 증가하는 시퀀스 번호를 각 이벤트에 스탬프처럼 찍어야 합니다. 게임 서버가 player_abc에 대한 이벤트를 보낸다면 시퀀스는 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!
컨슈머 측에서 시퀀스 번호가 비어 있다면 이벤트 유실이 확정된 것입니다.
2단계: 컨슈머 래그 모니터링
각 컨슈머에 대해 최신 생성된 시퀀스와 최신 소비된 시퀀스의 차이를 추적합니다. 경보 임계값:
- 래그 < 1,000 이벤트: 정상
- 래그 1,000~10,000 이벤트: 경고 — 컨슈머가 뒤처지고 있음
- 래그 > 10,000 이벤트: 위험 — 컨슈머가 사실상 오프라인이거나 과부하 상태임
3단계: 총합 교차 검증
프로듀서 로그와 컨슈머 수집 카운트 간의 이벤트 수를 매시간 비교합니다. 1%를 초과하는 불일치가 발생하면 조사가 필요합니다.
// 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);
}
}
시간당 생성된 카운트가 8,400,000개인데 분석 컨슈머가 수집한 카운트가 5,100,000개라면 39%의 이벤트가 유실된 것입니다. 이것이 바로 신호입니다.
아키텍처 수정: 내구성 있는 이벤트 로그로 결합 해제하기
해결책은 프로듀서와 컨슈머 사이에 **내구성 있는 버퍼(durable buffer)를 삽입하여 결합을 해제(decouple)**하는 것입니다. 기존 방식:
Game Server --direct HTTP--> Analytics
Game Server --direct HTTP--> Leaderboard Service
Game Server --direct HTTP--> Crash Reporter
변경 후 방식:
Game Server --single write--> [Durable Event Stream] --independent reads--> Analytics
--independent reads--> Leaderboard Service
--independent reads--> Crash Reporter
내구성 있는 스트림은 프로듀서의 속도로 쓰기 작업을 흡수합니다. 각 컨슈머는 자신의 속도에 맞춰 읽어갑니다. 컨슈머가 5분 동안 오프라인 상태가 되더라도 이벤트들은 스트림에 누적되며, 컨슈머가 복구되면 중단된 지점부터 다시 읽기 시작합니다. 데이터 유실은 없습니다.
내구성 있는 이벤트 스트림의 핵심 속성
게임 백엔드를 위한 프로덕션 급 이벤트 스트림은 다음과 같은 속성을 갖춰야 합니다.
| 속성 | 게임에서 중요한 이유 |
|---|---|
| 파티션 내 순서 보장 | 한 플레이어의 모든 이벤트는 순서대로 처리되어야 함 — 점수 갱신보다 킬이 먼저, 그 반대가 아님 |
| 내구성 있는 저장소 | 컨슈머 재시작, 배포 창구, 인프라 장애 속에서도 이벤트가 생존함 |
| 독립적인 컨슈머 오프셋 | 분석 컨슈머와 리더보드 컨슈머가 서로를 차단하지 않고 각자의 속도로 읽음 |
| 파티션 레벨 순서화 | 플레이어 간 병렬성(다른 파티션)과 플레이어 내 일관성(동일 파티션)을 동시에 획득함 |
게임 백엔드를 위한 파티셔닝 전략
파티션 키는 어떤 이벤트가 어떤 순서화된 로그에 들어갈지를 결정합니다. 게임 백엔드의 경우 자연스러운 파티션 키는 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]
이를 통해 단일 플레이어의 모든 이벤트는 모든 컨슈머에 의해 정확한 순서대로 처리되는 동시에, 서로 다른 플레이어들의 이벤트는 병렬로 처리될 수 있습니다.
내구성 있는 이벤트 스트리밍 구현: 실전 가이드
구체적인 구현 패턴입니다. 객체 저장소(S3/R2 등), 관리형 스트리밍 서비스, 또는 데이터베이스 기반 로그 위에 구축할 수 있습니다.
프로듀서: 싱글 라이트 팬아웃
게임 서버는 하나의 이벤트를 씁니다. 스트리밍 인프라가 모든 컨슈머에게 전달하는 작업을 처리합니다.
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<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);
}
}
}
이 코드의 핵심 설계 결정:
- 파티션 키는
playerId: 모든 이벤트 타입에 걸쳐 플레이어별 순서화를 보장합니다. - 단일 쓰기 호출: 프로듀서는 컨슈머가 몇 개나 존재하는지 알 필요도 없고 신경 쓰지 않아도 됩니다. 새로운 컨슈머(예: 시즌 이벤트 트래커)를 추가해도 프로듀서 코드를 변경할 필요가 전혀 없습니다.
- 로컬 재시도 큐: 스트림을 일시적으로 사용할 수 없는 경우, 이벤트가 로컬에 큐잉되었다가 연결이 복원되면 플러시됩니다. 이를 통해 네트워크 장애 시 데이터 유실을 방지합니다.
컨슈머: 독립적인 오프셋 추적
각 컨슈머는 파티션별로 자신만의 읽기 오프셋을 유지합니다. 이것이 바로 독립적인 처리 속도를 가능하게 하는 핵심 메커니즘입니다.
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<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
}
}
}
핵심 구현 세부사항:
- 처리가 끝난 후에 오프셋이 전진합니다(전에가 아님). 컨슈머가 배치 처리 중간에 크래시가 나면, 재시작 시 동일한 이벤트를 다시 처리합니다. 핸들러는 **멱등성(idempotent)**을 가져야 합니다. 동일한 킬 이벤트를 두 번 처리하더라도 리더보드 항목이 두 번 카운트되어서는 안 됩니다.
- 500개의 배치 크기는 처리량과 메모리 사이의 균형을 맞춥니다. 200바이트 이벤트 기준 배치당 약 100KB로 무시할 만한 수준입니다.
- 100ms 폴링 간격은 이벤트 생성부터 리더보드 갱신까지의 최악의 경우 지연 시간이 약 100ms임을 의미합니다. 대부분의 리더보드 유스케이스에서는 완전히 수용 가능한 수준입니다. 만약 10ms 미만의 지연 시간이 필요하다면 실시간 전송 영역에 속하므로 완전히 다른 아키텍처가 필요합니다.
멱등성: 컨슈머 안전망
이 아키텍처에서 멱등성은 타협할 수 없는 요소입니다. 다음은 구체적인 멱등성 핸들러입니다.
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<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 }
);
});
}
}
processed_events 테이블은 중복 제거 저장소 역할을 합니다. 이벤트당 한 번의 추가 쓰기 비용이 들지만, 컨슈머 재시작으로 인해 데이터가 손상되지 않음을 보장합니다.
컨슈머 다운타임 처리: 버퍼링 보장
내구성 있는 이벤트 스트리밍을 사용하는 주된 이유는 데이터 유실 없이 컨슈머 다운타임을 견디는 것입니다. 버퍼링 산식은 다음과 같습니다.
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
144MB는 현대의 어떤 스토리지 시스템에서든 쉽게 수용할 수 있는 용량입니다. 핵심 통찰: 버퍼 크기는 전체 히스토리 데이터가 아니라 이벤트 발생률과 최대 다운타임 허용치의 곱에 비례합니다.
장기 보존(리플레이 또는 재처리를 위한 30일치 이벤트)의 경우 수치는 다음과 같이 증가합니다.
30 days × 86,400 seconds × 2,400 events/sec × 200 bytes = ~1.24 TB
이는 객체 저장소 백엔드의 용량 범위 내에 충분히 들어옵니다. 파티션 구조 덕분에 이러한 규모에서도 읽기 성능이 예측 가능하게 유지됩니다. 전체 로그를 스캔하는 일이 없으며, 특정 파티션의 특정 오프셋에서 읽어오기 때문입니다.
이벤트 기반 아키텍처에서 horizOn이 제공하는 기능
이벤트 스트림이 데이터를 안정적으로 전달하기 시작하면, 해당 이벤트를 소비하는 서비스들이 필요해집니다. horizOn은 SDK나 REST API를 통해 컨슈머가 쓸 수 있는 관리형 백엔드 서비스를 제공합니다.
- 리더보드는 킬, 점수, 완료 이벤트 등 컨슈머가 제출한 점수에 대한 순위를 유지합니다.
- 유저 로그는 작성한 로그 엔터티를 저장하므로, 플레이어가 "점수가 초기화되었다"고 말할 때 해당 로그를 조회할 수 있습니다.
- 크래시 리포트는 SDK에서 수집된 치명적 및 비치명적 리포트를 수집하고 검토용으로 그룹화합니다.
핵심 요약: 이벤트 스트림은 데이터를 컨슈머에게 안정적으로 전달합니다. horizOn이 스트림 자체를 대체하는 것은 아니며, 컨슈머 뒤쪽에 위치한 서비스들을 커버합니다.
런북: 이벤트 유실 재발 방지
이벤트 유실을 한 번 경험했다면, 다시 발생하지 않도록 다음 체크리스트를 확인하세요.
1. 모든 프로듀서-컨슈머 결합 감사하기
코드베이스를 훑어보며 게임 서버가 백엔드 서비스로 동기식 HTTP 호출을 직접 수행하는 모든 지점을 파악하세요. 각각은 부하 발생 시 유실이 일어날 수 있는 잠재적 지점입니다. 목록화하세요:
GameServer → AnalyticsService (HTTP POST, no retry) ← RISK
GameServer → LeaderboardService (HTTP POST, no retry) ← RISK
GameServer → CrashReporter (UDP, fire-and-forget) ← RISK
2. 매개체로서 이벤트 스트림 도입하기
직접 호출 방식을 내구성 있는 이벤트 스트림으로 향하는 단일 쓰기 작업으로 교체하세요. 각 다운스트림 서비스는 각자의 오프셋을 가진 독립된 컨슈머가 됩니다.
3. 컨슈머 헬스 모니터링 구현하기
각 컨슈머에 대해 다음 항목을 추적하세요.
- 래그 (프로듀서 뒤처짐 정도)
- 처리율 (초당 소비된 이벤트 수)
- 에러율 (초당 처리 실패한 이벤트 수)
- 마지막 성공 오프셋 (정체 감지)
산출된 버퍼 윈도우를 초과하는 래그 발생 시 경보를 울립니다. 스트림이 7일치를 보존하고 있는데 컨슈머가 6일 동안 다운되어 있다면 데이터 유실이 시작되기까지 24시간이 남은 것입니다.
4. 컨슈머 재시작 복구 테스트하기
컨슈머를 고의로 5분 동안 오프라인 상태로 만들었다가 복구한 뒤, 중복 없이 따라잡는지 검증하세요. 이것이 바로 아키텍처가 정상 작동한다는 신뢰 테스트입니다. 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. 데드 레터 큐(DLQ) 설정하기
N회(일반적으로 3~5회) 재시도 후에도 처리에 실패한 이벤트는 데드 레터 큐로 이동시킵니다. DLQ 크기를 모니터링하세요. DLQ가 커진다는 것은 일시적인 장애가 아니라 컨슈머에 버그가 있음을 의미합니다.
게임 백엔드 이벤트 스트리밍 모범 사례
playerId를 파티션 키로 선택하세요. 이를 통해 플레이어별 순서화(인벤토리, 점수, 상태 이벤트에 매우 중요)를 보장하는 동시에 플레이어 간 병렬성을 확보할 수 있습니다. 이벤트 타입별로 파티셔닝하지 마세요. 동일 플레이어의 "kill"과 "score_update"는 순서가 유지되어야 합니다.이벤트를 작고 자가 설명적(self-describing)으로 유지하세요. 각 이벤트는 100~500바이트여야 합니다. 이벤트 타입, 플레이어 ID, 타임스탬프, 그리고 최소한의 페이로드만 포함하세요. 전체 게임 상태를 임베드하지 말고 ID로 참조하세요.
컨슈머를 첫날부터 멱등성 있게 설계하세요. 이벤트 ID와 중복 제거 저장소를 사용하세요. 모든 이벤트는 최소한 한 번, 그리고 장애 조치(failover) 중에는 둘 이상 전달될 수 있다고 가정하세요.
보존 윈도우를 최대 허용 컨슈머 다운타임에 맞춰 설정하세요. 가장 긴 배포가 15분 걸린다면, 최소 30분 분량의 핫 이벤트를 보존하세요. 리플레이 및 디버깅을 위해 7~30일치의 콜드 스토리지를 유지하세요.
컨슈머 래그를 일급 메트릭으로 모니터링하세요. 래그는 이벤트 기반 아키텍처의 심장박동입니다. 보존 윈도우의 50%를 초과하여 뒤처지는 컨슈머는 "다음 스프린트에 고치자" 할 일이 아니라 데이터 유실 비상사태입니다.
다음 단계
현재 게임 서버에서 백엔드 서비스로 직접 RPC 호출을 실행하고 있다면, 이번 주에 해당 연결들을 감사(audit)해 보세요. 10배 부하 급증 시 얼마나 많은 연결이 이벤트를 조용히 유실할지 세어보세요. 그런 다음 프로듀서와 컨슈머 사이에 내구성 있는 이벤트 스트림을 프로토타이핑해 보세요. 단순한 데이터베이스 기반 로그조차도 직접 결합보다는 훨씬 낫습니다.
컨슈머가 리더보드, 크래시 리포트, 유저 로그에 쓰기 작업을 수행한다면 horizOn에서 이를 관리형 서비스로 제공하므로 처음부터 일일이 구축할 필요가 없습니다. 여기서 시작하세요.