두 개의 티켓 예매 시스템 사이에 좌석 상태를 비동기로 동기화해야 하는 상황을 상상해 봅니다. 한쪽은 좌석 상태의 원본을 관리하는 본 시스템이고, 다른 한쪽은 외부 채널이나 디스플레이를 위한 미러 시스템입니다. 본 시스템에서 좌석을 예매(reserve)하거나 취소(cancel)할 때마다 이벤트가 발행되고, 미러는 그 이벤트를 받아 자기 쪽 좌석 상태를 갱신합니다.
처음 설계할 때만 해도 흐름은 단순합니다. "본 시스템에서 이벤트가 나가면 미러가 받아서 반영하면 끝." 그런데 운영을 시작하고 며칠 지나면 바로 체감합니다. 순서가 뒤집히는 순간은 거의 반드시 한 번 옵니다. 보통은 행사 직전처럼 가장 곤란한 타이밍입니다. 좌석 하나가 두 사람에게 동시에 잡힌 것처럼 보이는 바로 그 순간입니다.
이 글에서는 그 "순서 뒤집힘"이 왜 생기는지, 그리고 LWW(Last Write Wins)와 RabbitMQ로 어떻게 다룰 수 있는지 살펴봅니다. 비슷한 분산 동기화 문제를 이전 Spring에서 Redis 분산락 적용하기 글에서도 다뤘는데, 그때가 "동시에 들어오는 것"을 막는 이야기였다면 이번은 "이미 흩어진 것"을 다시 맞추는 이야기입니다.
먼저 모델을 단순화하겠습니다. 두 시스템을 A(본), B(미러)라 하고, 좌석 S-42에 대해 다음 두 이벤트가 차례로 발생했다고 합시다.
| 시각 | 이벤트 | 좌석 상태(A 기준) |
|---|---|---|
t1 |
reserve(S-42, userX) |
RESERVED |
t2 > t1 |
cancel(S-42, userX) |
AVAILABLE |
이 두 이벤트가 RabbitMQ를 거쳐 B에 도착하면 B의 최종 상태도 AVAILABLE이어야 합니다. 정상 경로에서는 당연히 그렇게 됩니다.
문제는 정상 경로가 아닐 때 생깁니다. B가 잠시 느려서 reserve ack가 늦게 오거나, B와 RabbitMQ 사이 네트워크가 순간 끊길 수 있습니다. 그러면 A는 reserve가 실패한 것으로 보고 Exponential Backoff로 재시도합니다.
재시도 간격은 보통 아래처럼 잡습니다.
base=1s, cap=30s 정도로 잡으면 1, 2, 4, 8, 16, 30, 30 … 간격으로 재시도가 이어집니다. Jitter는 동시에 재시도가 몰리는 상황을 줄여 주지만, 도착 순서를 더 예측하기 어렵게 만들기도 합니다.
reserve의 첫 시도가 실패해 backoff 큐에 들어간 사이, A에서 cancel이 발생해 정상 경로로 먼저 B에 도착할 수 있습니다. 이후 backoff에서 풀린 reserve가 늦게 들어오면, B의 최종 상태가 AVAILABLE이 아니라 RESERVED로 고정됩니다. 원본은 A가 맞는데 미러만 잘못된 상태를 오래 들고 있게 되는 겁니다.
여기서 보통 먼저 떠올리는 방법은 "큐 전체 순서를 엄격히 보장하자"입니다. 그런데 이 방식은 운영에서 금방 한계를 드러냅니다.
S-42와 S-99의 순서는 사실 아무 상관이 없습니다.그래서 보통은 방향을 바꿉니다. "전역 순서는 포기하고, 좌석 단위로만 순서를 보장하자." 그리고 좌석 단위에서 최종 상태를 고르는 기준으로 LWW를 둡니다.
LWW는 이름 그대로입니다. 같은 키에서 충돌하는 쓰기 둘이 있으면, 나중에 온 쓰기를 우선하는 규칙입니다. 분산 데이터베이스에서 오래 써 온 충돌 해결 전략이고, Cassandra, DynamoDB, CRDT 계열 LWW-register에서도 익숙하게 등장합니다.
이걸 좌석 이벤트로 옮겨 오면 정의가 짧아집니다.
같은 좌석 키에 대해 도착한 이벤트는, 자기보다 더 새로운 버전을 가진 상태를 덮어쓰지 못한다.
여기서 중요한 건 "새로움"을 무엇으로 판단하느냐입니다. 보통 후보는 세 가지입니다.
| 기준 | 장점 | 단점 |
|---|---|---|
발신자 wall clock(t1, t2) |
직관적 | 시스템 간 clock skew, NTP drift에 약함 |
단조 증가 시퀀스(version) |
clock과 무관, 비교가 단순 | 발신자가 좌석별 카운터를 들고 있어야 함 |
| 하이브리드(논리시계 + wall clock) | 분산 정렬에 강함 | 구현 비용이 상대적으로 큼 |
티켓 시스템처럼 원본 시스템이 A 하나인 구조에서는 단조 증가 시퀀스가 가장 단순하고 안전합니다. A가 좌석 S-42의 쓰기를 직렬화할 수 있으니, 좌석 단위 카운터 v를 붙여 보내면 됩니다.
이벤트 페이로드는 대략 이런 모양이 됩니다.
{
"seatId": "S-42",
"type": "RESERVE",
"version": 17,
"occurredAt": "2026-05-26T20:10:11.412Z",
"actor": "userX"
}
B의 컨슈머는 단 하나의 규칙만 지키면 됩니다.
reserve(v=17)을 뒤늦게 받았어도 좌석 상태가 이미 cancel(v=18)로 갱신돼 있다면, reserve는 조용히 버리면 됩니다. 미러는 더 이상 도착 순서가 아니라 버전 순서만 보고 처리하게 됩니다.
LWW는 충돌이 났을 때 쓰는 결정 규칙입니다. 하지만 라우팅이 엉성하면 같은 좌석 이벤트가 여러 컨슈머로 흩어져 race condition이 생깁니다. 그래서 RabbitMQ 쪽에서도 장치가 필요합니다. 핵심은 같은 좌석은 항상 같은 큐, 같은 컨슈머로 보낸다는 점입니다.
이 용도에는 rabbitmq_consistent_hash_exchange 플러그인의 Consistent Hash Exchange가 잘 맞습니다.
라우팅 키를 seatId로 잡으면, S-42 이벤트는 항상 같은 샤드 큐로 들어갑니다. 각 큐를 단일 컨슈머가 처리하면, 그 컨슈머 안에서 좌석 상태를 읽고 쓰는 흐름이 직렬화됩니다.
실제로는 이 지점에서 자주 문제가 납니다. 같은 큐에 컨슈머를 두 개 이상 붙이면 RabbitMQ가 round-robin으로 메시지를 분배합니다. 그러면 같은 좌석의 reserve와 cancel이 다른 컨슈머에 떨어져 race가 생깁니다. 좌석 단위 순서를 노린다면 샤드 큐 = 단일 active consumer를 유지하는 편이 가장 안전합니다. 가용성을 위해 x-single-active-consumer를 켜고 다중 인스턴스를 hot/standby로 두는 패턴이 잘 맞습니다.
Kafka에 익숙한 분이라면 "이거 그냥 파티션 키 아닌가?"라고 느끼실 텐데, 같은 사고입니다. 정렬은 전역에서 보장하는 게 아니라 샤딩 키 단위로만 보장한다 — RabbitMQ든 Kafka든 이 지점에서는 똑같이 갈립니다.
이제 남은 문제는 "B에서 실패한 메시지를 어떻게 재처리할 것인가"입니다. basic.nack(requeue=true)로 즉시 되돌리면, 실패 원인이 풀리기 전에 같은 메시지가 같은 자리에서 계속 재시도됩니다. 그 사이 뒤따라온 cancel이 앞서 처리되면 순서가 다시 뒤집힐 수 있습니다.
RabbitMQ에서 Exponential Backoff를 구현할 때 많이 쓰는 방식은 DLX(Dead Letter Exchange) + TTL이 다른 다단 지연 큐입니다. 별도 플러그인 없이도 동작하고, 재시도 의도가 토폴로지에 직접 드러난다는 장점이 있습니다.
핵심 동작은 다음과 같습니다.
seat.shard.N 컨슈머가 실패하면 requeue=false로 reject합니다. 메시지는 큐에 머리로 돌아오지 않고, 큐의 DLX인 retry-router로 흘러갑니다.retry-router는 x-death 헤더의 시도 횟수를 보고 해당 단계의 retry 큐(retry.1s, retry.4s, …)로 라우팅합니다. 단계별 큐의 TTL이 곧 backoff 간격이 됩니다.seat-events로 다시 게시되어 원래 샤드로 복귀합니다.park.queue로 분리해 사람이 들여다보게 합니다.중요한 점은 이 토폴로지만으로는 순서가 자동으로 보장되지 않는다는 것입니다. 같은 좌석 S-42의 reserve가 backoff를 도는 동안 cancel이 메인 큐를 먼저 통과해 처리될 수 있고, 그게 앞에서 봤던 역전 시나리오입니다. 그래서 LWW를 반드시 함께 둬야 합니다.
토폴로지는 재시도가 같은 자리에서 계속 앞을 막지 않도록 떼어 주는 역할만 합니다. 도착한 이벤트를 적용할지 말지는 컨슈머의 LWW 규칙이 결정합니다. 둘이 같이 있어야 동기화가 안정됩니다.
RabbitMQ는 기본적으로 at-least-once 전달 모델입니다. Publisher confirm과 ack 흐름을 잘 구성해도, 컨슈머가 처리 직후 ack 전에 죽으면 같은 메시지를 다시 받을 수 있습니다. 그래서 LWW와 함께 멱등성도 필요합니다. 같은 version 이벤트가 두 번 들어와도 결과가 같아야 한다는 조건입니다.
LWW와 멱등성을 같이 적용하면 컨슈머 로직은 다음처럼 단순해집니다.
@Transactional
public void onSeatEvent(SeatEvent e) {
SeatState s = seatRepo.findForUpdate(e.getSeatId());
if (s == null) {
seatRepo.insert(new SeatState(e.getSeatId(), e.getVersion(), e.toState()));
return;
}
if (e.getVersion() <= s.getVersion()) {
// 더 오래된 또는 동일 버전 → 조용히 스킵 (idempotent)
return;
}
s.applyFrom(e);
seatRepo.save(s);
}
코드에서 핵심은 findForUpdate와 version 비교입니다. 앞은 같은 좌석의 동시 수정을 막고, 뒤는 LWW를 강제합니다. 그래서 중복 메시지와 역전된 도착 순서를 같이 흡수할 수 있습니다.
운영에서는 occurredAt을 보조로 함께 저장해 두는 편이 좋습니다. version은 적용 여부를 결정하고, occurredAt은 "왜 이 시각에 도착한 메시지가 거부됐는지"를 추적할 때 도움이 됩니다. LWW 결과가 사용자 인식과 어긋나는 순간이 가끔 생기는데, 이 두 필드가 있으면 인시던트 분석 시간이 줄어듭니다.
지금까지 설명한 내용을 한 흐름으로 모으면 다음과 같습니다.
각 구성 요소의 역할을 한 줄씩 보면 다음과 같습니다.
| 구성 요소 | 책임 |
|---|---|
| A의 version 채번 | 좌석 단위 단조 증가 시퀀스 발급 — LWW 비교의 기준 |
| x-consistent-hash exchange | 같은 좌석은 같은 샤드 큐로 — 좌석 단위 직렬화의 라우팅 층 |
| seat.shard.N + single active consumer | 큐 안에서의 FIFO + 컨슈머 단위의 직렬 처리 |
| LWW Consumer | version 비교로 늦은 도착 / 중복을 흡수 |
| retry-router(DLX) + retry.*s | NACK된 메시지를 backoff 간격을 두고 다시 흐르게 함 |
| park.queue | 자동 복구에 실패한 메시지의 격리 — 사람이 들여다볼 자리 |
이 흐름의 장점은 각 층의 역할이 분명하다는 점입니다. 라우팅, 재시도, 결정을 나눠 두면 한 부분을 바꿔도 다른 층으로 영향이 크게 번지지 않습니다.
여기까지 적용하면 대부분의 좌석 동기화는 안정적으로 돌아갑니다. 다만 LWW가 만능은 아닙니다. 운영하다 보면 경계가 분명히 보이니, 도입할 때부터 같이 고려하는 편이 좋습니다.
첫째, "더 늦은 쓰기 = 더 옳은 쓰기"가 항상 참은 아닙니다. LWW는 정답을 완벽히 계산한다기보다, 마지막 쓰기를 우선하는 실용적 규칙에 가깝습니다. 그래서 잘못된 취소가 더 늦게 들어오면 기존의 정상 예매를 덮어버릴 수도 있습니다. 권위가 한쪽(A)에 있는 모델에서는 위험이 크지 않지만, 양방향 동기화로 가면 LWW만으로 부족해집니다. 그때는 vector clock이나 CRDT 같은 방식까지 검토하게 됩니다.
둘째, version 채번 자체가 새로운 임계 영역이 됩니다. 좌석 단위 단조 증가 시퀀스를 안전하게 발급하려면 A 내부에 좌석별 락이 필요합니다. 결국 분산락이 다시 필요해집니다. LWW가 미러 쪽 race를 정리한다면, 분산락은 발신 쪽 race를 정리하는 역할입니다.
셋째, backoff가 길어질수록 stale window가 늘어납니다. 재시도 간격을 64초까지 늘려 두면, 그 시간만큼 B는 잘못된 좌석 상태를 들고 있게 됩니다. 사용자 화면에 좌석 상태를 그대로 노출한다면 이 윈도우가 곧바로 사용자 경험으로 새어 나옵니다. 잘 알려진 대응은 두 가지 정도입니다.
넷째, park.queue를 만들었으면 들여다보는 흐름까지 만들어야 합니다. park 큐는 정말 사람이 봐야 하는 메시지만 모이게 관리해야 의미가 있습니다. 길이가 0이 아니면 알람이 오도록 묶어 두지 않으면, 어느 순간 수천 건이 쌓인 채로 잊히기 쉽습니다. 재투입 스크립트나 어드민 UI까지 같이 준비해 두지 않으면, park 큐는 만든 그 시점부터 사실상 휴지통이 됩니다.
결론은 단순합니다.
전역 순서 보장을 포기하는 대신, 좌석 단위 순서 + LWW + Exponential Backoff를 RabbitMQ 토폴로지와 컨슈머 규칙에 나눠 심었다.
처음에는 "큐가 순서만 지켜주면 되지 않을까?"라고 생각하기 쉽습니다. 하지만 책임을 큐에 다 몰아주면 처리량과 가용성이 같이 떨어집니다. 큐는 같은 키를 같은 컨슈머로 보내는 일까지만 맡고, 최종 상태 판단은 이벤트 메타데이터를 기준으로 컨슈머가 처리하는 구조가 현실적입니다. LWW의 version은 그중 가장 단순한 형태고, 시스템이 복잡해지면 vector clock이나 CRDT 같은 방식으로 확장할 수 있습니다.
출발은 좌석 하나에 이벤트 둘인 작은 시나리오였지만, 실무에서 오래 버티는 패턴도 대개 이렇게 단순한 구조였습니다. 시스템이 커져도 필요한 층만 추가하면 되고, 각 층의 책임만 유지하면 LWW라는 결정 규칙은 그대로 가져갈 수 있습니다. 비동기 동기화에서는 토폴로지 모양보다 이런 결정 규칙이 더 오래 남는 경우가 많았습니다.