시스템 설계: 대규모 서비스의 구조 읽기

지금까지 배운 부품을 조립해서 짧은 주소 서비스를 처음부터 설계해요. 요구 사항을 정리하고 하루 100만 개의 링크가 만드는 초당 요청 수와 5년 치 저장 공간을 어림한 뒤, 62가지 글자로 짧은 코드를 만들고 번호를 섞어 다음 주소를 짐작하기 어렵게 해요. 인기 상위 1%만 캐시에 둬도 요청의 68%를 처리하는 이유, 서버를 4대에서 5대로 늘릴 때 나머지 방식은 데이터의 80%가 옮겨 가지만 일관된 해싱은 17%만 옮겨 가는 모습을 계산하고, 리다이렉트 방식과 클릭 통계, 장애와 악용 대비까지 설계를 한 단계씩 키워 가요.

전문가강의 6 / 6약 13분

컴퓨터 과학 심화 트랙의 마지막 강의예요. 지금까지 네트워크, 데이터베이스, 서버, 보안, 알고리즘, 운영체제, 분산 시스템을 하나씩 배웠어요. 시스템 설계는 이 부품들을 조립하는 일이에요. 정답이 하나인 문제가 아니라, 요구 사항과 제약 사이에서 근거를 갖고 고르는 일이에요. 긴 주소를 짧은 주소로 바꿔 주는 서비스를 예로 처음부터 설계해 볼게요.

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. 요구 사항: 무엇을, 얼마나 크게, 얼마나 빠르고 튼튼하게. 무엇은 느슨해도 되는지.
  2. 어림 계산: 초당 요청, 저장 공간, 읽기와 쓰기의 비율. 어디가 병목인지.
  3. 핵심 기능부터 단순하게: 앱 서버 한 대와 데이터베이스 한 대로 되는 설계를 먼저 그려요.
  4. 병목을 하나씩 풀기: 읽기가 많으면 캐시와 팔로워, 느린 일은 큐, 데이터가 크면 샤딩.
  5. 고장과 악용을 상상하기: 부품마다 멈추면 어떻게 되는지, 누가 악용하면 어떻게 되는지.
  6. 잃는 것을 말하기: 캐시는 옛 값의 위험을, 비동기 통계는 지연을, 샤딩은 복잡함을 대가로 줘요.

처음부터 거대한 구조를 그리기보다, 단순한 설계에서 출발해 숫자가 요구할 때만 부품을 더하는 게 좋은 설계예요. 큰 서비스의 구조도 처음부터 그렇게 생겼던 게 아니라 이렇게 한 단계씩 자라난 결과예요. 그래서 낯선 서비스의 구조도를 볼 때도 "이 부품은 어떤 숫자 때문에 생겼을까"를 물으면 읽혀요.

실습

  1. 하루 새 링크가 1억 개로 늘면 어림 계산이 어떻게 바뀌나요? 무엇부터 바꿔야 할까요?
  2. 헷갈리기 쉬운 글자(0, O, l, I)를 빼고 58가지 글자만 쓰면, 5년 치 링크를 담는 데 몇 글자가 필요할까요?
  3. 링크의 인기가 1/k 대신 1/k²에 비례한다면, 상위 1%만 캐시에 둘 때 적중률은 어떻게 될까요?
  4. 일관된 해싱에서 서버마다 찍는 점을 1개, 10개, 100개로 바꿔 가며 서버별 몫이 얼마나 고른지 비교해 보세요.
  5. 1분에 100번까지만 허락하는 토큰 버킷 요청 제한기를 만들어 보세요.

자주 하는 오해

  • 처음부터 크게 만들어야 한다. 숫자가 요구하기 전에는 단순한 설계가 이겨요. 부품이 늘 때마다 고장 날 곳도 늘어요.
  • 어림 계산은 정확해야 한다. 자릿수가 맞으면 충분해요. 10배 차이가 설계를 바꿔요.
  • 캐시를 두면 끝이다. 캐시가 비거나 멈추는 순간 데이터베이스가 버틸 수 있는지까지 설계해야 해요.
  • 번호를 섞으면 안전하다. 짐작을 어렵게 할 뿐이에요. 비밀이 필요하면 무작위 코드와 권한 검사를 써요.
  • 서버 수로 나눈 나머지로 나누면 충분하다. 서버 수가 바뀌는 순간 데이터 대부분이 이사해야 해요.

점검 문제

  1. 시스템 설계에서 기능 말고 반드시 정해야 하는 요구 사항은?
  2. 어림 계산으로 짧은 주소 서비스에 대해 알게 된 핵심은?
  3. 번호를 62진법으로 그대로 바꿔 코드로 쓰면 생기는 문제와 해결책은?
  4. 원래 주소를 해시해서 코드를 만드는 방식의 장단점은?
  5. 상위 1%의 링크만 캐시에 둬도 효과가 큰 이유는?
  6. 클릭 통계를 큐로 처리하는 이유와, 그걸 허락하는 요구 사항은?
  7. 서버를 늘릴 때 나머지 방식보다 일관된 해싱이 나은 이유는?
  8. 통계가 필요한 짧은 주소 서비스가 301보다 302를 쓰는 이유는?

정답

  1. 규모(하루 몇 개, 초당 몇 번), 속도(얼마나 빨리 답해야 하는지), 튼튼함(얼마나 멈추면 안 되는지), 그리고 무엇은 느슨해도 되는지예요.
  2. 쓰기는 초당 십여 번, 저장은 5년에 1TB가 안 돼서 쉽지만, 읽기가 초당 수천 번이라 읽기를 덜어 주는 게 핵심이라는 거예요.
  3. 다음 코드를 쉽게 짐작해서 남의 링크를 차례로 훑을 수 있어요. 소수로 나눈 나머지 위에서 큰 수를 곱해 번호를 섞으면, 겹치지 않으면서 짐작하기 어려운 코드가 돼요. 정말 비밀이어야 하면 무작위 코드와 권한 검사를 써요.
  4. 번호를 나눠 주는 장치 없이 만들 수 있다는 장점이 있지만, 링크가 많아지면 생일 문제처럼 코드가 겹칠 수 있어서 겹침을 확인하고 다시 만드는 처리가 필요해요.
  5. 인기가 고르지 않아서 소수의 링크가 클릭 대부분을 받기 때문이에요. k번째 링크가 1/k에 비례해 열린다면 상위 1%가 요청의 3분의 2쯤을 차지해요.
  6. 클릭할 때마다 통계를 바로 쓰면 이동이 느려지니, 큐에 넣고 바로 이동시킨 뒤 따로 집계해요. "통계는 조금 늦어도 된다"는 요구 사항이 이걸 허락해요.
  7. 나머지 방식은 나누는 수가 바뀌면 거의 모든 키의 자리가 바뀌지만, 일관된 해싱은 새 서버가 맡는 고리의 일부 구간만 옮겨 가서 이사하는 데이터가 꼭 필요한 몫 근처로 줄어요.
  8. 301은 브라우저가 기억해 두고 다음부터 서버에 묻지 않아서 클릭을 셀 수 없지만, 302는 매번 서버를 거쳐서 클릭을 셀 수 있기 때문이에요.

마치며

컴퓨터 과학 심화 트랙을 마쳤어요. 전체 코스와 컴퓨터공학 코스도 여기서 끝나요. 캐시와 파이프라인에서 시작해 운영체제, 컴파일러, 동시성, 분산 시스템을 지나 서비스 전체의 설계까지 왔어요. 이제 남은 건 직접 만들어 보는 일이에요. 개발자로 성장하기 트랙의 프로젝트 강의를 참고해서, 이번 강의의 짧은 주소 서비스처럼 작게 시작해 숫자가 요구할 때마다 한 단계씩 키워 보세요. 막히는 곳이 생기면 그 주제의 강의로 돌아와 다시 읽으면, 처음 읽을 때보다 훨씬 많은 것이 보일 거예요.