분산 시스템 기초: 복제, 합의, CAP
컴퓨터 여러 대가 네트워크로 협력할 때 생기는 문제를 하나씩 시뮬레이션해요. 비동기 복제 때문에 바꾼 닉네임이 어떤 서버에서는 옛 값으로 읽히는 모습, 몇 대에 쓰고 몇 대에서 읽어야 최신 값을 보장하는지 따지는 정족수, 과반수 투표로 리더를 뽑는 합의와 네트워크가 끊겼을 때 한쪽만 일하게 되는 이유를 확인해요. 분할 중에는 일관성과 가용성 중 하나를 골라야 한다는 CAP 정리, 벽시계 대신 램포트 시계로 순서를 정하는 법, 재시도해도 결제가 한 번만 되게 하는 멱등 키까지 다뤄요.
지난 강의에서는 한 컴퓨터 안에서 여러 흐름이 메모리를 함께 쓰는 문제를 봤어요. 서비스가 커지면 컴퓨터 한 대로는 감당할 수 없어서 여러 대가 네트워크로 협력해요. 이걸 분산 시스템이라고 해요. 한 대일 때는 없던 어려움이 생겨요. 메시지가 늦게 오거나 사라지고, 일부 컴퓨터만 멈추고, 컴퓨터마다 시계가 조금씩 달라요. 이번 강의에서는 실제 서비스가 이 어려움을 어떻게 다루는지 작은 시뮬레이션으로 하나씩 확인해요.
왜 여러 대로 나눌까
- 규모: 요청이나 데이터가 한 대의 한계를 넘어요.
- 고장 견디기: 한 대가 멈춰도 서비스는 계속돼야 해요. 컴퓨터가 수천 대면 어딘가는 늘 고장 나 있어요.
- 거리: 서울과 미국을 오가는 데는 빛으로도 시간이 걸려요. 사용자 가까이에 서버를 두면 빨라져요.
분산 시스템을 처음 만들 때 흔히 믿는 잘못된 가정들이 있어요. "네트워크는 믿을 만하다", "지연은 0이다", "대역폭은 끝이 없다", "네트워크 구성은 바뀌지 않는다" 같은 것들이에요. 1990년대에 분산 컴퓨팅의 오류라는 이름으로 정리된 목록인데, 실제로는 하나도 맞지 않아요.
느린 것과 죽은 것은 구별할 수 없어요
한 대 안에서 함수를 부르면 답이 오거나 오류가 나요. 네트워크 너머의 서버에 요청하면 세 번째 경우가 생겨요. 답이 안 와요. 요청이 가는 길에 사라졌는지, 서버가 처리하다 멈췄는지, 처리는 했는데 응답이 돌아오다 사라졌는지, 그냥 아주 느린 건지 알 방법이 없어요. 그래서 분산 시스템은 타임아웃으로 "이만큼 기다려서 안 오면 실패로 친다"고 정할 수밖에 없어요. 서버 트랙의 프록시 강의에서 연결과 응답에 시간 제한을 따로 두고, 응답 없는 서버를 잠시 빼 두었던 것도 이 때문이에요. 그런데 타임아웃이 났다고 그 요청이 실행되지 않았다는 보장은 없어요. 이 문제는 마지막 절에서 다시 다뤄요.
복제: 같은 데이터를 여러 곳에
데이터를 여러 서버에 똑같이 두는 걸 복제라고 해요. 한 대가 멈춰도 다른 곳에 데이터가 남고, 읽기 요청을 나눠 받을 수 있어요. 흔한 방식은 쓰기는 리더 한 대만 받고, 리더가 쓰기 기록을 팔로워들에게 보내 그대로 따라 하게 하는 거예요. 팔로워가 기록을 받아 반영하는 데 시간이 걸리면 어떻게 될까요?
class Replica:
def __init__(self, name):
self.name, self.data, self.applied = name, {}, 0
log = [] # 리더가 받은 쓰기를 차례로 적어 두는 기록
leader = Replica("리더")
followers = [Replica("팔로워 1"), Replica("팔로워 2")]
def write(key, value): # 쓰기는 리더만 받아요
leader.data[key] = value
log.append((key, value))
leader.applied = len(log)
def catch_up(replica): # 팔로워가 기록을 따라잡아요(비동기라 언제 할지는 몰라요)
for key, value in log[replica.applied:]:
replica.data[key] = value
replica.applied = len(log)
write("닉네임", "민지")
for f in followers:
catch_up(f)
write("닉네임", "민지짱") # 닉네임을 바꿨는데
catch_up(followers[0]) # 팔로워 1만 따라잡았어요
for r in [leader] + followers:
print(f"{r.name}에서 읽으면: {r.data['닉네임']} (기록 {r.applied}/{len(log)}까지 반영)")
리더에서 읽으면: 민지짱 (기록 2/2까지 반영)
팔로워 1에서 읽으면: 민지짱 (기록 2/2까지 반영)
팔로워 2에서 읽으면: 민지 (기록 1/2까지 반영)
닉네임을 바꿨는데 팔로워 2는 아직 옛 기록까지만 반영했어요. 사용자가 닉네임을 바꾸고 새로 고침했는데 그 읽기가 팔로워 2로 가면 바꾼 닉네임이 보이지 않아요. "저장이 안 됐나?" 싶어서 다시 바꾸게 되죠. 팔로워가 리더를 뒤쫓는 이 시간 차이를 복제 지연이라고 해요.
- 동기 복제: 리더가 팔로워들이 반영했다는 확인을 받은 뒤에야 쓰기를 끝내요. 늘 최신이지만, 팔로워 하나가 느리거나 멈추면 쓰기 전체가 느려지거나 멈춰요.
- 비동기 복제: 리더는 바로 쓰기를 끝내고 기록은 나중에 보내요. 빠르지만 팔로워가 옛 값을 보여 줄 수 있고, 리더가 갑자기 죽으면 아직 보내지 못한 쓰기를 잃을 수 있어요.
실무에서는 "자기가 쓴 것은 바로 보이게" 같은 약속만 따로 챙기는 경우가 많아요. 방금 쓴 사용자의 읽기는 잠시 리더로 보내거나, 같은 사용자를 늘 같은 서버로 보내는 식이에요. 지금은 어긋나도 쓰기가 멈추면 언젠가는 모든 복제본이 같아진다는 약속을 최종 일관성이라고 해요.
정족수: 몇 대에 쓰고 몇 대에서 읽을까
리더 없이 여러 대에 함께 쓰고 읽는 방식도 있어요. 복제본이 N대일 때, 쓰기는 W대에 성공하면 끝으로 치고, 읽기는 R대에서 받아 그중 가장 최신 값을 써요. 쓰기를 받은 서버와 읽어 온 서버가 겹쳐야 최신 값을 볼 수 있겠죠. 가능한 경우를 모두 세어 볼게요.
from itertools import combinations
def fresh_ratio(n, w, r): # 쓰기를 받은 W대와 읽어 온 R대가 겹치는 경우의 비율
pairs = [(set(ws), set(rs)) for ws in combinations(range(n), w) for rs in combinations(range(n), r)]
return sum(1 for ws, rs in pairs if ws & rs) / len(pairs)
for w, r in [(1, 1), (2, 1), (2, 2), (3, 1), (1, 3)]:
print(f"N=3, W={w}, R={r} (R+W={r + w}): 최신 값을 읽을 확률 {fresh_ratio(3, w, r):.0%}")
N=3, W=1, R=1 (R+W=2): 최신 값을 읽을 확률 33%
N=3, W=2, R=1 (R+W=3): 최신 값을 읽을 확률 67%
N=3, W=2, R=2 (R+W=4): 최신 값을 읽을 확률 100%
N=3, W=3, R=1 (R+W=4): 최신 값을 읽을 확률 100%
N=3, W=1, R=3 (R+W=4): 최신 값을 읽을 확률 100%
R + W가 N보다 크면 쓰기를 받은 집합과 읽은 집합이 반드시 한 대 이상 겹쳐서 늘 최신 값을 읽어요. 비둘기집 원리예요. N=3이면 W=2, R=2가 흔한 설정이에요. 한 대가 멈춰도 쓰기와 읽기가 모두 되거든요. W를 키우면 쓰기가 무거워지고 읽기가 가벼워지고, R을 키우면 그 반대예요. 아마존의 Dynamo 논문으로 널리 알려진 방식이고, Cassandra 같은 데이터베이스는 이 값을 요청마다 고를 수 있게 해 줘요.
합의: 여러 대가 하나의 결정을 내리기
리더를 두는 방식에서는 "지금 리더가 누구인가"를 모든 서버가 똑같이 알아야 해요. 리더가 멈추면 새 리더를 뽑아야 하는데, 네트워크가 불안정하면 서로 자기가 리더라고 믿는 두 리더(스플릿 브레인)가 생길 수 있어요. 둘이 각자 쓰기를 받으면 데이터가 엇갈려 버려요. 이걸 막는 게 합의 알고리즘이에요. 널리 쓰이는 Raft는 이렇게 동작해요.
- 리더는 주기적으로 "살아 있다"는 신호를 보내요. 신호가 끊기면 팔로워가 후보로 나서서 투표를 요청해요.
- 과반의 표를 받은 후보만 리더가 돼요. 투표마다 번호(임기)를 매기고, 한 서버는 한 임기에 한 표만 던져요.
- 쓰기도 과반의 서버가 기록했다고 확인해야 확정돼요.
과반끼리는 반드시 한 대 이상 겹치니, 서로 다른 두 후보가 같은 임기에 과반을 받을 수 없어요. 정족수와 같은 원리예요.
def majority(total):
return total // 2 + 1
for total in (3, 4, 5, 7):
print(f"{total}대: 과반은 {majority(total)}대, 동시에 {total - majority(total)}대까지 멈춰도 계속 일해요")
for total, sides in [(5, (3, 2)), (4, (2, 2))]:
verdict = ", ".join(f"{s}대 쪽은 {'리더를 뽑고 계속 일해요' if s >= majority(total) else '멈춰요'}" for s in sides)
print(f"{total}대가 {sides[0]}대와 {sides[1]}대로 끊기면: {verdict}")
3대: 과반은 2대, 동시에 1대까지 멈춰도 계속 일해요
4대: 과반은 3대, 동시에 1대까지 멈춰도 계속 일해요
5대: 과반은 3대, 동시에 2대까지 멈춰도 계속 일해요
7대: 과반은 4대, 동시에 3대까지 멈춰도 계속 일해요
5대가 3대와 2대로 끊기면: 3대 쪽은 리더를 뽑고 계속 일해요, 2대 쪽은 멈춰요
4대가 2대와 2대로 끊기면: 2대 쪽은 멈춰요, 2대 쪽은 멈춰요
- 5대가 3대와 2대로 끊기면, 과반을 모을 수 있는 3대 쪽만 리더를 두고 일하고 2대 쪽은 멈춰요. 두 리더가 생기지 않아요.
- 동시에 f대가 멈춰도 견디려면 2f + 1대가 필요해요. 3대면 1대, 5대면 2대까지 견뎌요.
- 짝수는 손해예요. 4대는 3대와 똑같이 1대까지만 견디고, 2대와 2대로 끊기면 양쪽 다 멈춰요. 그래서 합의를 쓰는 묶음은 보통 3대나 5대로 꾸려요.
합의 알고리즘은 직접 구현하기보다 검증된 도구를 써요. 쿠버네티스는 모든 설정을 Raft를 쓰는 etcd에 저장하고, ZooKeeper와 Consul도 비슷한 역할을 해요. 참고로 메시지가 얼마나 늦을지 한계가 없는 네트워크에서는, 서버 하나만 멈출 수 있어도 반드시 끝나는 합의 알고리즘이 존재할 수 없다는 증명(FLP 불가능성)이 있어요. 실제 알고리즘은 타임아웃으로 이 벽을 비켜 가서, 네트워크가 안정된 동안에는 결정을 내려요.
CAP 정리: 끊겼을 때 무엇을 포기할까
네트워크가 끊겨서 서버들이 두 무리로 갈라진 상황(분할)을 생각해 봐요. 한쪽 무리에 요청이 왔을 때 할 수 있는 일은 둘뿐이에요.
- 거절한다: 다른 쪽과 확인할 수 없으니 답하지 않아요. 데이터는 일관되지만(C, 일관성) 요청이 실패해요.
- 답한다: 가진 데이터로 답해요. 서비스는 계속되지만(A, 가용성) 다른 쪽에서 바뀐 내용을 모르니 옛 값이거나 엇갈린 값일 수 있어요.
분할(P)은 막을 수 없는 현실이라, 분할이 일어난 동안에는 일관성과 가용성 중 하나를 골라야 한다는 게 CAP 정리예요. 위의 Raft는 소수 쪽을 멈추니 일관성을 고른 쪽이고, 장바구니처럼 "일단 담기게 하고 나중에 합치는" 서비스는 가용성을 고른 쪽이에요. 분할이 없을 때도 선택은 남아요. 복제본들과 확인하고 답하면 일관되지만 느리고, 가까운 한 대가 바로 답하면 빠르지만 옛 값일 수 있어요. 이 확장을 PACELC라고 불러요. 무엇을 고를지는 기술보다 서비스가 정할 문제예요. 은행 잔액에는 일관성이, 좋아요 수에는 가용성이 맞겠죠.
시계를 믿을 수 없어요
여러 서버의 로그를 시간순으로 합쳐 보면 원인과 결과가 뒤바뀌어 보일 때가 있어요. 컴퓨터마다 시계가 조금씩 다르기 때문이에요. NTP로 맞춰도 몇 밀리초는 어긋나고, 나쁘면 그 이상이에요. A 서버에서 쓴 글에 B 서버에서 댓글을 달았는데 B의 시계가 1초쯤 늦다면 어떻게 될까요?
class Node:
def __init__(self, name):
self.name, self.clock = name, 0
def event(self): # 일이 하나 일어날 때마다 1씩 올려요
self.clock += 1
return self.clock
def receive(self, sent_clock): # 받은 메시지보다 반드시 뒤의 시각이 되게
self.clock = max(self.clock, sent_clock) + 1
return self.clock
a, b = Node("A"), Node("B")
events = [] # (이름, 그 서버의 벽시계 시각, 램포트 시각)
sent = a.event()
events.append(("글 작성(A 서버)", "10:00:00.000", sent))
b.receive(sent) # B가 글을 받았어요
events.append(("댓글 작성(B 서버)", "09:59:59.600", b.event())) # B의 시계는 1초쯤 늦어요
print("벽시계로 줄 세우면:", [e[0] for e in sorted(events, key=lambda e: e[1])])
print("램포트 시계로 줄 세우면:", [e[0] for e in sorted(events, key=lambda e: e[2])])
벽시계로 줄 세우면: ['댓글 작성(B 서버)', '글 작성(A 서버)']
램포트 시계로 줄 세우면: ['글 작성(A 서버)', '댓글 작성(B 서버)']
벽시계로 줄을 세우면 댓글이 글보다 먼저 달린 것처럼 보여요. 램포트 시계는 실제 시각 대신 일어난 순서만 세요. 서버마다 일이 생길 때 숫자를 1씩 올리고, 메시지를 보낼 때 그 숫자를 함께 보내요. 받는 쪽은 자기 숫자와 받은 숫자 중 큰 쪽에 1을 더해요. 그러면 원인(글 작성)은 언제나 결과(댓글)보다 작은 숫자를 가져서, 인과 관계가 있는 사건의 순서가 뒤집히지 않아요. 분산 데이터베이스는 이런 논리 시계와, 그것을 넓힌 벡터 시계로 어떤 수정이 먼저인지, 동시에 일어나 충돌한 건지를 가려요.
재시도와 멱등성
둘째 절의 문제로 돌아와 볼게요. 결제 요청을 보냈는데 타임아웃이 났어요. 다시 보내야 할까요? 응답만 사라진 거라면 결제가 두 번 될 수 있어요. 네트워크 트랙의 HTTP 강의에서 개념만 본 멱등 키를 직접 만들어서, 응답이 두 번 사라져 세 번 보내는 상황을 흉내 내 볼게요.
class PaymentServer:
def __init__(self):
self.charged, self.done = [], {}
def pay(self, amount, key=None):
if key is not None and key in self.done: # 같은 열쇠로 다시 온 요청은 처음 결과를 그대로 돌려줘요
return self.done[key]
self.charged.append(amount)
receipt = f"영수증 {len(self.charged)}"
if key is not None:
self.done[key] = receipt
return receipt
def client(server, key, lost=2): # 응답이 두 번 사라져서 세 번 보내는 상황
for attempt in range(1, lost + 2):
receipt = server.pay(39_000, key)
if attempt > lost: # 앞의 응답들은 돌아오는 길에 사라졌어요
return receipt, attempt
for key in (None, "order-1042"):
server = PaymentServer()
receipt, attempts = client(server, key)
print(f"멱등 키 {'없이' if key is None else '붙여서'}: {attempts}번 보냄 → 실제 결제 {len(server.charged)}번, 받은 것은 {receipt}")
멱등 키 없이: 3번 보냄 → 실제 결제 3번, 받은 것은 영수증 3
멱등 키 붙여서: 3번 보냄 → 실제 결제 1번, 받은 것은 영수증 1
멱등 키 없이 다시 보내면 결제가 세 번 돼요. 요청마다 고유한 멱등 키를 붙여 보내고, 서버가 같은 키로 처리한 결과를 기억해 두었다가 그대로 돌려주면, 몇 번을 다시 보내도 결제는 한 번이에요. 몇 번 실행해도 결과가 같은 이 성질이 멱등성이에요. 네트워크로 "정확히 한 번 전달"을 보장하기는 사실상 불가능해서, 실무에서는 "적어도 한 번 보내고(재시도), 받는 쪽을 멱등하게 만든다"로 같은 효과를 내요. 메시지 큐에서 같은 메시지가 두 번 배달될 수 있다고 가정하고 처리하는 것도 같은 생각이에요.
실습
catch_up이 기록을 한 번에 하나씩만 반영하게 바꾸고, 리더에 쓰기 5개를 넣은 뒤 팔로워들이 몇 번 만에 따라잡는지 보세요.fresh_ratio로 N=5일 때 늘 최신 값을 읽는 (W, R) 조합을 모두 찾아보세요. 그중 2대가 멈춰도 쓰기와 읽기가 모두 되는 조합은 무엇인가요?- 6대로 꾸린 묶음은 동시에 몇 대까지 멈춰도 견디나요? 5대와 비교하면 무엇이 나아지고 무엇이 그대로인가요?
Node로 서버 세 대가 메시지를 주고받는 상황을 만들고, 램포트 시각으로 줄 세운 순서가 인과 관계를 지키는지 확인해 보세요.PaymentServer의done이 끝없이 커지지 않도록 24시간이 지난 멱등 키를 지운다면, 그 뒤에 같은 키로 요청이 오면 어떻게 해야 할까요?
자주 하는 오해
- 타임아웃이 났으면 요청은 실행되지 않았다. 실행됐는데 응답만 사라졌을 수도 있어요. 재시도는 멱등하게 설계해야 안전해요.
- 복제본이 많을수록 늘 최신 값을 읽는다. 비동기 복제라면 팔로워는 옛 값을 보여 줄 수 있어요. 읽기와 쓰기의 정족수를 맞춰야 해요.
- 서버를 4대로 늘리면 3대보다 튼튼하다. 과반 합의에서는 4대도 1대까지만 견디고, 반반으로 끊기면 전체가 멈춰요.
- CAP에서 셋 중 둘을 골라 늘 지키면 된다. 분할은 고르는 게 아니라 언젠가 일어나는 현실이에요. 분할이 일어난 동안 일관성과 가용성 중 무엇을 지킬지를 고르는 거예요.
- 서버 시각으로 정렬하면 사건 순서가 된다. 시계가 어긋나면 원인과 결과가 뒤집혀 보여요.
점검 문제
- 네트워크 너머로 요청할 때, 한 대 안에서는 없던 세 번째 결과는?
- 비동기 복제에서 바꾼 값이 보이지 않는 이유와 실무의 해결책은?
- N=3에서 W=2, R=2면 늘 최신 값을 읽는 이유는?
- 합의에서 과반을 요구하면 두 리더가 생기지 않는 이유는?
- f대의 고장을 견디려면 몇 대가 필요하고, 짝수 대가 손해인 이유는?
- CAP 정리가 말하는 선택은 정확히 무엇인가요?
- 램포트 시계는 어떻게 인과 관계의 순서를 지키나요?
- 결제 재시도를 안전하게 만드는 방법은?
정답
- 답이 오지 않는 경우예요. 요청이 사라졌는지, 서버가 멈췄는지, 응답만 사라졌는지, 그냥 느린지 구별할 수 없어서 타임아웃으로 정할 수밖에 없어요.
- 리더에 쓴 값을 팔로워가 아직 반영하지 못한 상태에서 읽기가 그 팔로워로 가기 때문이에요. 방금 쓴 사용자의 읽기를 잠시 리더로 보내거나, 같은 사용자를 늘 같은 서버로 보내요.
- R + W가 N보다 크면 쓰기를 받은 서버들과 읽은 서버들이 반드시 한 대 이상 겹쳐서, 읽어 온 값 중에 최신 값이 들어 있기 때문이에요.
- 과반끼리는 반드시 한 대 이상 겹치는데, 한 서버는 한 임기에 한 표만 던지니 서로 다른 두 후보가 같은 임기에 과반을 받을 수 없기 때문이에요.
- 2f + 1대가 필요해요. 4대는 과반이 3대라 3대와 똑같이 1대까지만 견디고, 2대와 2대로 끊기면 어느 쪽도 과반이 안 돼서 전체가 멈추기 때문이에요.
- 네트워크 분할이 일어난 동안, 요청을 거절해서 일관성을 지킬지, 옛 값일 수 있어도 답해서 가용성을 지킬지를 골라야 한다는 거예요.
- 일이 생길 때마다 숫자를 올리고, 메시지에 그 숫자를 실어 보내고, 받는 쪽은 자기 숫자와 받은 숫자 중 큰 쪽에 1을 더해요. 그래서 원인이 된 사건은 늘 결과보다 작은 숫자를 가져요.
- 요청마다 고유한 멱등 키를 붙이고, 서버가 같은 키의 처리 결과를 기억해 두었다가 그대로 돌려주게 해요. 그러면 몇 번을 다시 보내도 결제는 한 번만 돼요.
다음 강의
복제, 정족수, 합의, 캐시, 큐, 타임아웃과 재시도까지 대규모 서비스의 부품을 거의 다 모았어요. 마지막 강의에서는 이 부품들을 조립해서, 짧은 주소 서비스 같은 실제 서비스의 구조를 처음부터 설계해 봐요. 요구 사항에서 출발해 트래픽을 어림하고, 병목을 찾고, 하나씩 키워 나가는 과정을 따라가요.