시스템 설계: 대규모 서비스의 구조 읽기
지금까지 배운 부품을 조립해서 짧은 주소 서비스를 처음부터 설계해요. 요구 사항을 정리하고 하루 100만 개의 링크가 만드는 초당 요청 수와 5년 치 저장 공간을 어림한 뒤, 62가지 글자로 짧은 코드를 만들고 번호를 섞어 다음 주소를 짐작하기 어렵게 해요. 인기 상위 1%만 캐시에 둬도 요청의 68%를 처리하는 이유, 서버를 4대에서 5대로 늘릴 때 나머지 방식은 데이터의 80%가 옮겨 가지만 일관된 해싱은 17%만 옮겨 가는 모습을 계산하고, 리다이렉트 방식과 클릭 통계, 장애와 악용 대비까지 설계를 한 단계씩 키워 가요.
컴퓨터 과학 심화 트랙의 마지막 강의예요. 지금까지 네트워크, 데이터베이스, 서버, 보안, 알고리즘, 운영체제, 분산 시스템을 하나씩 배웠어요. 시스템 설계는 이 부품들을 조립하는 일이에요. 정답이 하나인 문제가 아니라, 요구 사항과 제약 사이에서 근거를 갖고 고르는 일이에요. 긴 주소를 짧은 주소로 바꿔 주는 서비스를 예로 처음부터 설계해 볼게요.
1단계: 요구 사항 정하기
설계는 무엇을 만들지 정하는 데서 시작해요. 기능만이 아니라 얼마나 크고, 빠르고, 튼튼해야 하는지도요.
- 기능: 긴 주소를 받아 짧은 코드를 만들어 준다. 짧은 주소로 들어오면 원래 주소로 보내 준다. 링크마다 클릭 수를 보여 준다. 만료 날짜를 정할 수 있다.
- 규모와 품질: 하루에 새 링크 100만 개. 짧은 주소로 이동하는 건 빨라야 한다(기다린다고 느끼지 않게 수십 밀리초 안). 이동 기능은 멈추면 안 된다(링크가 걸린 모든 곳이 깨지니까). 클릭 수는 조금 늦게 반영돼도 괜찮다.
마지막 두 줄이 설계를 크게 좌우해요. "이동은 빠르고 늘 되어야 하지만 통계는 늦어도 된다"는 결정이 뒤의 선택들을 정해요.
2단계: 어림 계산
정확한 숫자보다 자릿수를 아는 게 중요해요. 초당 10번인지 1만 번인지에 따라 서버 한 대로 될지 수십 대가 필요할지가 갈리거든요.
new_links_per_day = 1_000_000
clicks_per_link = 100 # 링크 하나가 평균 100번 열린다고 치면
seconds_per_day = 24 * 60 * 60
writes = new_links_per_day / seconds_per_day
reads = writes * clicks_per_link
print(f"초당 쓰기 약 {writes:,.0f}번, 초당 읽기 약 {reads:,.0f}번 (몰리는 시간에 5배면 {reads * 5:,.0f}번)")
total_links = new_links_per_day * 365 * 5
bytes_per_link = 500 # 원래 주소, 짧은 코드, 만든 시각, 만든 사람 등
print(f"5년 동안 링크 {total_links / 1e8:,.2f}억 개, 저장 공간 약 {total_links * bytes_per_link / 1e12:.2f}TB")
초당 쓰기 약 12번, 초당 읽기 약 1,157번 (몰리는 시간에 5배면 5,787번)
5년 동안 링크 18.25억 개, 저장 공간 약 0.91TB
- 쓰기는 초당 12번 정도라 데이터베이스 한 대로 넉넉해요.
- 읽기는 초당 1,000번 남짓이고, 몰리는 시간에는 6천 번 가까이 돼요. 데이터베이스가 버틸 수는 있지만 여유가 없으니, 읽기를 덜어 줄 장치가 필요해요.
- 5년 치 데이터가 1TB가 안 돼요. 디스크 한 장에 들어가는 크기라, 처음부터 데이터를 여러 대로 나눌 필요는 없어요.
결론은 "쓰기와 저장은 쉽고, 읽기가 핵심"이에요. 설계의 힘을 어디에 쏟을지가 정해졌어요.
3단계: 짧은 코드 만들기
코드에는 숫자 10개와 영문 대소문자 52개, 모두 62가지 글자를 써요. 몇 글자면 될까요? 링크마다 번호를 매기고 그 번호를 62진법으로 바꾸면 코드끼리 겹칠 일이 없는데, 그대로 쓰면 문제가 하나 있어요.
import string
ALPHABET = string.digits + string.ascii_lowercase + string.ascii_uppercase # 62글자
for length in (6, 7, 8):
print(f"{length}글자로 만들 수 있는 코드: {62**length:,}개")
def to_base62(n, length=7):
chars = []
for _ in range(length):
n, r = divmod(n, 62)
chars.append(ALPHABET[r])
return "".join(reversed(chars))
def from_base62(code):
n = 0
for ch in code:
n = n * 62 + ALPHABET.index(ch)
return n
P = 3_521_614_606_199 # 62의 7제곱보다 9 작은 소수
A = 2_176_477_521_733 # P보다 작은 큰 수(여기서는 P의 약 0.618배)
A_INV = pow(A, -1, P) # 되돌릴 때 곱하는 수(곱셈의 역원)
for link_id in (1, 2, 3, 1_000_000):
plain, mixed = to_base62(link_id), to_base62(link_id * A % P)
back = from_base62(mixed) * A_INV % P
print(f"번호 {link_id:>9,}: 그대로 {plain} | 섞으면 {mixed} | 되돌리면 {back:,}")
6글자로 만들 수 있는 코드: 56,800,235,584개
7글자로 만들 수 있는 코드: 3,521,614,606,208개
8글자로 만들 수 있는 코드: 218,340,105,584,896개
번호 1: 그대로 0000001 | 섞으면 CjINSkZ | 되돌리면 1
번호 2: 그대로 0000002 | 섞으면 eDrBKG7 | 되돌리면 2
번호 3: 그대로 0000003 | 섞으면 QXapD16 | 되돌리면 3
번호 1,000,000: 그대로 0004c92 | 섞으면 ZiyRWxr | 되돌리면 1,000,000
- 6글자로도 568억 개라 5년 치 18억 개는 담지만, 서비스가 커질 여유와 짐작을 어렵게 할 빈 공간까지 생각해서 7글자(3.5조 개)로 해요.
- 번호를 그대로 바꾸면 0000001, 0000002처럼 다음 코드를 쉽게 짐작할 수 있어요. 누군가 차례로 열어 보며 남들이 만든 링크를 모두 훑을 수 있죠.
- 그래서 번호를 섞어요. 소수 P로 나눈 나머지 위에서 큰 수 A를 곱하면, 되돌리는 수가 있으니 서로 다른 번호는 반드시 서로 다른 값이 되고, 순서는 뒤섞여요. 겹칠 걱정 없이 짐작하기 어려운 코드가 돼요.
- 다만 이건 짐작을 어렵게 할 뿐 암호는 아니에요. 코드를 여러 개 모으면 규칙을 알아낼 수 있어요. 비공개 문서처럼 정말 숨겨야 하는 링크라면 충분히 긴 무작위 코드(
secrets모듈)를 쓰고 접근 권한도 함께 검사해요.
번호는 앱 서버가 여러 대여도 겹치지 않아야 하니, 데이터베이스의 자동 증가 번호를 쓰거나 서버마다 번호 구간을 미리 나눠 줘요. 번호 대신 원래 주소를 해시해서 앞 7글자를 쓰는 방법도 있어요. 번호를 나눠 주는 장치가 필요 없지만, 해시 테이블 강의의 생일 문제처럼 링크가 많아지면 코드가 겹칠 수 있어서, 겹침을 확인하고 다시 만드는 처리가 필요해요.
4단계: 구조 그리기
사용자 → 로드 밸런서 → 앱 서버 여러 대(상태 없음) → 캐시
→ 데이터베이스(리더 1대 + 팔로워들)
클릭 기록 → 큐 → 통계 일꾼 → 통계 저장소
- 로드 밸런서와 앱 서버: 앱 서버는 요청 사이에 기억하는 게 없게(무상태) 만들어서 몇 대든 늘리고 줄일 수 있게 해요. 서버 트랙의 프록시 강의에서 본 구조예요.
- 읽기 경로: 짧은 코드로 요청이 오면 캐시에서 먼저 찾고, 없으면 데이터베이스에서 읽어 캐시에 넣어 둬요. 링크는 한 번 만들면 거의 바뀌지 않아서 캐시와 아주 잘 맞아요.
- 쓰기 경로: 새 링크는 리더 데이터베이스에 쓰고, 읽기는 팔로워에 나눠요. 방금 만든 링크를 바로 열 때 복제 지연에 걸리지 않도록(분산 시스템 강의), 만들자마자 캐시에도 넣어 둬요.
- 통계 경로: 클릭할 때마다 통계를 데이터베이스에 바로 쓰면 이동이 느려져요. 클릭 기록은 큐에 넣고 사용자는 바로 이동시킨 뒤, 따로 도는 일꾼이 모아서 집계해요. "통계는 늦어도 된다"는 요구 사항이 이 선택을 허락해요.
캐시는 얼마나 효과가 있을까
링크의 인기는 고르지 않아요. 소수의 링크가 클릭 대부분을 받아요. k번째로 인기 있는 링크가 1/k에 비례해서 열린다고 치고(지프의 법칙), 인기 상위 몇 %를 캐시에 두면 요청의 몇 %를 처리하는지 계산해 볼게요.
def harmonic(n):
return sum(1 / k for k in range(1, n + 1))
N = 1_000_000 # 링크 100만 개, k번째로 인기 있는 링크는 1/k에 비례해 열려요
H_N = harmonic(N)
for percent in (0.1, 1, 10, 20):
k = int(N * percent / 100)
print(f"인기 상위 {percent}%({k:,}개)만 캐시에 두면: 요청의 {harmonic(k) / H_N:.0%}를 캐시에서 처리")
인기 상위 0.1%(1,000개)만 캐시에 두면: 요청의 52%를 캐시에서 처리
인기 상위 1%(10,000개)만 캐시에 두면: 요청의 68%를 캐시에서 처리
인기 상위 10%(100,000개)만 캐시에 두면: 요청의 84%를 캐시에서 처리
인기 상위 20%(200,000개)만 캐시에 두면: 요청의 89%를 캐시에서 처리
상위 1%만 캐시에 둬도 요청의 3분의 2를 처리하고, 10%면 84%예요. 링크 10만 개를 캐시에 두는 데는 500바이트씩 쳐도 50MB면 충분해요. 캐시 서버 한 대로 데이터베이스가 받는 읽기를 6분의 1 남짓으로 줄일 수 있어요. 실제 분포는 서비스마다 다르니, 운영하면서 캐시 적중률을 꼭 재야 해요(서버 트랙의 관측 가능성 강의).
데이터를 여러 대로 나눌 때
5년 치는 한 대에 들어가지만, 서비스가 커지면 데이터를 여러 대로 나눠야 할 때가 와요. 이걸 샤딩이라고 해요. 가장 쉬운 방법은 "코드의 해시를 서버 수로 나눈 나머지"로 서버를 정하는 거예요. 그런데 서버를 늘리면 어떻게 될까요?
import hashlib
from bisect import bisect
def h(text): # 어디서 돌려도 같은 값이 나오는 해시
return int(hashlib.md5(text.encode()).hexdigest(), 16)
keys = [f"link{i}" for i in range(10_000)]
def make_ring(n, vnodes=100): # 서버마다 고리 위에 점을 100개씩 찍어요
ring = sorted((h(f"server{s}-{v}"), s) for s in range(n) for v in range(vnodes))
return [p for p, _ in ring], [s for _, s in ring]
def ring_shard(key, ring): # 키의 자리에서 시계 방향으로 처음 만나는 서버
points, owners = ring
return owners[bisect(points, h(key)) % len(points)]
moved_mod = sum(h(k) % 4 != h(k) % 5 for k in keys) / len(keys)
ring4, ring5 = make_ring(4), make_ring(5)
moved_ring = sum(ring_shard(k, ring4) != ring_shard(k, ring5) for k in keys) / len(keys)
print(f"서버 4대에서 5대로: 나머지 방식은 키의 {moved_mod:.0%}가 이사, 일관된 해싱은 {moved_ring:.0%}가 이사")
share = [sum(ring_shard(k, ring5) == s for k in keys) / len(keys) for s in range(5)]
print("일관된 해싱에서 서버별 몫:", [f"{x:.0%}" for x in share])
서버 4대에서 5대로: 나머지 방식은 키의 80%가 이사, 일관된 해싱은 17%가 이사
일관된 해싱에서 서버별 몫: ['20%', '21%', '21%', '20%', '17%']
나머지 방식은 서버를 4대에서 5대로 늘리는 순간 데이터의 80%가 다른 서버로 옮겨 가야 해요. 나누는 수가 바뀌니 거의 모든 키의 자리가 바뀌거든요. 일관된 해싱은 서버와 키를 모두 하나의 고리 위에 점으로 찍고, 키는 시계 방향으로 처음 만나는 서버에 맡겨요. 새 서버가 들어오면 고리의 일부 구간만 새 서버로 넘어가서, 꼭 옮겨야 하는 몫(5분의 1) 근처인 17%만 옮겨 가요. 서버마다 점을 여러 개 찍는(가상 노드) 건 몫을 고르게 나누기 위해서예요. Cassandra 같은 분산 데이터베이스와, 여러 캐시 서버에 키를 나누는 도구들이 이 방식을 써요. 해시로는 파이썬의 hash() 대신 hashlib을 썼어요. 해시 테이블 강의에서 본 것처럼 hash()는 실행할 때마다 문자열의 해시 값이 달라지니까요.
마지막으로 챙길 것들
- 리다이렉트 방식: 301(영구 이동)이면 브라우저가 기억해 두고 다음부터 서버에 묻지 않아서 서버 부담은 줄지만 클릭을 셀 수 없어요. 302(임시 이동)면 매번 서버를 거쳐서 클릭을 셀 수 있어요. 통계가 기능이니 302를 써요(네트워크 트랙의 HTTP 강의).
- 악용 막기: 악성 사이트로 보내는 링크를 만들지 못하게 주소를 검사하고, 한 사람이 링크를 너무 많이 만들지 못하게 요청 제한을 둬요. 바구니에 토큰을 일정한 속도로 채우고 요청마다 하나씩 꺼내 쓰게 하는 토큰 버킷 방식이 흔해요.
- 장애 대비: 앱 서버는 여러 대, 데이터베이스는 복제로 두고, 캐시가 통째로 멈춰도 데이터베이스가 잠시 버틸 수 있는지 확인해요. 캐시가 비는 순간 같은 링크의 조회가 한꺼번에 데이터베이스로 몰리지 않도록, 같은 키는 하나만 데이터베이스로 보내고 나머지는 그 결과를 기다리게 하기도 해요.
- 관측: 이동 지연, 캐시 적중률, 오류율, 큐에 쌓인 클릭 수에 알림을 걸어요.
- 만료와 정리: 만료된 링크는 바로 지우기보다 표시해 두고 한가한 시간에 정리해요.
설계를 읽는 순서
- 요구 사항: 무엇을, 얼마나 크게, 얼마나 빠르고 튼튼하게. 무엇은 느슨해도 되는지.
- 어림 계산: 초당 요청, 저장 공간, 읽기와 쓰기의 비율. 어디가 병목인지.
- 핵심 기능부터 단순하게: 앱 서버 한 대와 데이터베이스 한 대로 되는 설계를 먼저 그려요.
- 병목을 하나씩 풀기: 읽기가 많으면 캐시와 팔로워, 느린 일은 큐, 데이터가 크면 샤딩.
- 고장과 악용을 상상하기: 부품마다 멈추면 어떻게 되는지, 누가 악용하면 어떻게 되는지.
- 잃는 것을 말하기: 캐시는 옛 값의 위험을, 비동기 통계는 지연을, 샤딩은 복잡함을 대가로 줘요.
처음부터 거대한 구조를 그리기보다, 단순한 설계에서 출발해 숫자가 요구할 때만 부품을 더하는 게 좋은 설계예요. 큰 서비스의 구조도 처음부터 그렇게 생겼던 게 아니라 이렇게 한 단계씩 자라난 결과예요. 그래서 낯선 서비스의 구조도를 볼 때도 "이 부품은 어떤 숫자 때문에 생겼을까"를 물으면 읽혀요.
실습
- 하루 새 링크가 1억 개로 늘면 어림 계산이 어떻게 바뀌나요? 무엇부터 바꿔야 할까요?
- 헷갈리기 쉬운 글자(0, O, l, I)를 빼고 58가지 글자만 쓰면, 5년 치 링크를 담는 데 몇 글자가 필요할까요?
- 링크의 인기가 1/k 대신 1/k²에 비례한다면, 상위 1%만 캐시에 둘 때 적중률은 어떻게 될까요?
- 일관된 해싱에서 서버마다 찍는 점을 1개, 10개, 100개로 바꿔 가며 서버별 몫이 얼마나 고른지 비교해 보세요.
- 1분에 100번까지만 허락하는 토큰 버킷 요청 제한기를 만들어 보세요.
자주 하는 오해
- 처음부터 크게 만들어야 한다. 숫자가 요구하기 전에는 단순한 설계가 이겨요. 부품이 늘 때마다 고장 날 곳도 늘어요.
- 어림 계산은 정확해야 한다. 자릿수가 맞으면 충분해요. 10배 차이가 설계를 바꿔요.
- 캐시를 두면 끝이다. 캐시가 비거나 멈추는 순간 데이터베이스가 버틸 수 있는지까지 설계해야 해요.
- 번호를 섞으면 안전하다. 짐작을 어렵게 할 뿐이에요. 비밀이 필요하면 무작위 코드와 권한 검사를 써요.
- 서버 수로 나눈 나머지로 나누면 충분하다. 서버 수가 바뀌는 순간 데이터 대부분이 이사해야 해요.
점검 문제
- 시스템 설계에서 기능 말고 반드시 정해야 하는 요구 사항은?
- 어림 계산으로 짧은 주소 서비스에 대해 알게 된 핵심은?
- 번호를 62진법으로 그대로 바꿔 코드로 쓰면 생기는 문제와 해결책은?
- 원래 주소를 해시해서 코드를 만드는 방식의 장단점은?
- 상위 1%의 링크만 캐시에 둬도 효과가 큰 이유는?
- 클릭 통계를 큐로 처리하는 이유와, 그걸 허락하는 요구 사항은?
- 서버를 늘릴 때 나머지 방식보다 일관된 해싱이 나은 이유는?
- 통계가 필요한 짧은 주소 서비스가 301보다 302를 쓰는 이유는?
정답
- 규모(하루 몇 개, 초당 몇 번), 속도(얼마나 빨리 답해야 하는지), 튼튼함(얼마나 멈추면 안 되는지), 그리고 무엇은 느슨해도 되는지예요.
- 쓰기는 초당 십여 번, 저장은 5년에 1TB가 안 돼서 쉽지만, 읽기가 초당 수천 번이라 읽기를 덜어 주는 게 핵심이라는 거예요.
- 다음 코드를 쉽게 짐작해서 남의 링크를 차례로 훑을 수 있어요. 소수로 나눈 나머지 위에서 큰 수를 곱해 번호를 섞으면, 겹치지 않으면서 짐작하기 어려운 코드가 돼요. 정말 비밀이어야 하면 무작위 코드와 권한 검사를 써요.
- 번호를 나눠 주는 장치 없이 만들 수 있다는 장점이 있지만, 링크가 많아지면 생일 문제처럼 코드가 겹칠 수 있어서 겹침을 확인하고 다시 만드는 처리가 필요해요.
- 인기가 고르지 않아서 소수의 링크가 클릭 대부분을 받기 때문이에요. k번째 링크가 1/k에 비례해 열린다면 상위 1%가 요청의 3분의 2쯤을 차지해요.
- 클릭할 때마다 통계를 바로 쓰면 이동이 느려지니, 큐에 넣고 바로 이동시킨 뒤 따로 집계해요. "통계는 조금 늦어도 된다"는 요구 사항이 이걸 허락해요.
- 나머지 방식은 나누는 수가 바뀌면 거의 모든 키의 자리가 바뀌지만, 일관된 해싱은 새 서버가 맡는 고리의 일부 구간만 옮겨 가서 이사하는 데이터가 꼭 필요한 몫 근처로 줄어요.
- 301은 브라우저가 기억해 두고 다음부터 서버에 묻지 않아서 클릭을 셀 수 없지만, 302는 매번 서버를 거쳐서 클릭을 셀 수 있기 때문이에요.
마치며
컴퓨터 과학 심화 트랙을 마쳤어요. 전체 코스와 컴퓨터공학 코스도 여기서 끝나요. 캐시와 파이프라인에서 시작해 운영체제, 컴파일러, 동시성, 분산 시스템을 지나 서비스 전체의 설계까지 왔어요. 이제 남은 건 직접 만들어 보는 일이에요. 개발자로 성장하기 트랙의 프로젝트 강의를 참고해서, 이번 강의의 짧은 주소 서비스처럼 작게 시작해 숫자가 요구할 때마다 한 단계씩 키워 보세요. 막히는 곳이 생기면 그 주제의 강의로 돌아와 다시 읽으면, 처음 읽을 때보다 훨씬 많은 것이 보일 거예요.