서버란 무엇인가: 요청과 응답의 기계

서버는 특별한 컴퓨터가 아니라, 요청을 기다렸다가 처리하고 응답하는 프로그램이에요. 지금까지 따로 배운 HTTP, 데이터베이스, 파이썬을 하나로 묶어 할 일 API 서버를 직접 만들면서 주소별로 처리 함수를 고르는 라우팅, 상태 코드로 답하는 법, 잘못된 입력과 서버 안의 버그를 다루는 법, 동시에 몰리는 요청을 받는 법을 익혀요. 서버 여러 대가 각자 기억하면 로그인이 풀리는 이유, 내 컴퓨터 밖에서 접속하려면 필요한 것, 서버를 어디에 둘지, 1년에 몇 시간까지 멈춰도 되는지까지 다뤄요.

초급강의 1 / 6약 17분

"서버"라고 하면 데이터 센터에 줄지어 선 기계를 떠올리기 쉬워요. 하지만 그 기계들도 우리가 쓰는 컴퓨터와 근본은 같아요. 다른 점은 하는 일이에요. 서버는 요청을 기다렸다가, 처리하고, 응답하는 프로그램이고, 그 프로그램을 쉬지 않고 돌리는 컴퓨터를 서버 컴퓨터라고 불러요. 내 노트북에서 파이썬으로 띄운 작은 프로그램도 요청을 받아 답한다면 어엿한 서버예요.

네트워크 트랙에서 HTTP 서버를 띄워 봤고, 데이터베이스 트랙에서 SQLite로 데이터를 지켜 봤어요. 이번 강의에서는 둘을 묶어, 할 일을 저장하고 돌려주는 API 서버를 처음부터 만들어 볼게요.

요청에서 응답까지

서버가 요청 하나를 처리하는 과정은 어떤 언어, 어떤 프레임워크를 쓰든 비슷해요.

  1. 기다려요. 정해진 포트에서 손님의 연결을 기다려요.
  2. 읽어요. 요청 줄, 헤더, 본문을 읽고, 본문이 JSON이면 파이썬 값으로 바꿔요.
  3. 길을 골라요. 메서드와 주소를 보고 어떤 함수가 처리할지 정해요. 이걸 라우팅이라고 해요.
  4. 일을 해요. 입력을 검사하고, 데이터베이스를 읽거나 쓰고, 결과를 만들어요.
  5. 답해요. 결과를 JSON으로 바꾸고 알맞은 상태 코드와 함께 돌려줘요.
  6. 기록해요. 누가 무엇을 요청했고 어떻게 답했는지 남겨요. 문제가 생겼을 때 이 기록이 유일한 단서가 돼요.

직접 만드는 할 일 API 서버

파이썬 표준 라이브러리만으로 만들어 볼게요. 처리 함수에 @route를 붙이면 라우팅 표에 등록되는 구조예요. 실제 프레임워크(Flask, FastAPI 등)도 겉모습은 거의 이래요.

import json
import re
import sqlite3
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

db = sqlite3.connect(":memory:", check_same_thread=False)
db.execute("CREATE TABLE todos (id INTEGER PRIMARY KEY, text TEXT NOT NULL, done INTEGER NOT NULL DEFAULT 0)")
db_lock = threading.Lock()                         # 연결 하나를 여러 스레드가 나눠 쓰니 차례를 지켜요

ROUTES = []                                        # (메서드, 주소 패턴, 처리 함수)

def route(method, pattern):
    def register(handler):
        ROUTES.append((method, re.compile(f"^{pattern}$"), handler))
        return handler
    return register

@route("GET", "/todos")
def list_todos(body):
    with db_lock:
        rows = db.execute("SELECT id, text, done FROM todos ORDER BY id").fetchall()
    return 200, [{"id": i, "text": t, "done": bool(d)} for i, t, d in rows]

@route("POST", "/todos")
def create_todo(body):
    text = str((body or {}).get("text", "")).strip()
    if not text:
        return 400, {"error": "할 일 내용(text)이 비어 있어요"}
    with db_lock, db:
        todo_id = db.execute("INSERT INTO todos (text) VALUES (?)", (text,)).lastrowid
    return 201, {"id": todo_id, "text": text, "done": False}

@route("PATCH", r"/todos/(\d+)")
def toggle_todo(body, todo_id):
    with db_lock, db:
        changed = db.execute("UPDATE todos SET done = 1 - done WHERE id = ?", (int(todo_id),)).rowcount
    return (200, {"ok": True}) if changed else (404, {"error": "없는 할 일이에요"})

@route("GET", "/boom")
def boom(body):
    return 1 / 0                                   # 일부러 넣은 버그

access_log = []

class Handler(BaseHTTPRequestHandler):
    def log_message(self, *args):
        pass

    def respond(self, status, payload):
        access_log.append(f"{self.command} {self.path} → {status}")   # 응답을 보내기 전에 기록해요
        data = json.dumps(payload, ensure_ascii=False).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def dispatch(self):
        length = int(self.headers.get("Content-Length") or 0)
        try:
            body = json.loads(self.rfile.read(length)) if length else None
        except json.JSONDecodeError:
            return self.respond(400, {"error": "JSON 형식이 아니에요"})
        path_matched = False
        for method, pattern, handler in ROUTES:
            match = pattern.match(self.path)
            if not match:
                continue
            path_matched = True
            if method == self.command:
                try:
                    return self.respond(*handler(body, *match.groups()))
                except Exception as e:
                    access_log.append(f"  오류 기록: {type(e).__name__}: {e}")   # 자세한 내용은 기록에만
                    return self.respond(500, {"error": "서버 안에서 문제가 생겼어요"})
        if path_matched:
            return self.respond(405, {"error": "이 주소는 그 메서드를 받지 않아요"})
        self.respond(404, {"error": "없는 주소예요"})

    do_GET = do_POST = do_PATCH = do_DELETE = dispatch

server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
port = server.server_address[1]
print("서버가 기다리는 중: 127.0.0.1의 비어 있던 포트 하나")
서버가 기다리는 중: 127.0.0.1의 비어 있던 포트 하나

이제 손님 쪽에서 여러 요청을 보내 볼게요. 정상적인 요청뿐 아니라 일부러 잘못된 요청도 섞었어요.

import urllib.request
from urllib.error import HTTPError

def call(method, path, body=None, raw=None):
    data = raw if raw is not None else (json.dumps(body).encode() if body is not None else None)
    req = urllib.request.Request(f"http://127.0.0.1:{port}{path}", data=data, method=method,
                                 headers={"Content-Type": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=5) as res:
            return res.status, json.loads(res.read())
    except HTTPError as e:
        return e.code, json.loads(e.read())

print(call("POST", "/todos", {"text": "서버 강의 읽기"}))
print(call("POST", "/todos", {"text": "도커 설치하기"}))
print(call("PATCH", "/todos/1"))
print(call("GET", "/todos"))
print(call("POST", "/todos", {"text": "   "}))
print(call("POST", "/todos", raw=b"{text: oops}"))
print(call("PATCH", "/todos/99"))
print(call("DELETE", "/todos"))
print(call("GET", "/boom"))
print(call("GET", "/nothing"))
print("\n".join(access_log))
(201, {'id': 1, 'text': '서버 강의 읽기', 'done': False})
(201, {'id': 2, 'text': '도커 설치하기', 'done': False})
(200, {'ok': True})
(200, [{'id': 1, 'text': '서버 강의 읽기', 'done': True}, {'id': 2, 'text': '도커 설치하기', 'done': False}])
(400, {'error': '할 일 내용(text)이 비어 있어요'})
(400, {'error': 'JSON 형식이 아니에요'})
(404, {'error': '없는 할 일이에요'})
(405, {'error': '이 주소는 그 메서드를 받지 않아요'})
(500, {'error': '서버 안에서 문제가 생겼어요'})
(404, {'error': '없는 주소예요'})
POST /todos → 201
POST /todos → 201
PATCH /todos/1 → 200
GET /todos → 200
POST /todos → 400
POST /todos → 400
PATCH /todos/99 → 404
DELETE /todos → 405
  오류 기록: ZeroDivisionError: division by zero
GET /boom → 500
GET /nothing → 404

열 개의 요청이 모두 알맞은 상태 코드를 받았어요. 하나씩 보면 서버를 만들 때 챙길 것들이 보여요.

  • 만들면 201, 고치면 200. HTTP 강의에서 본 상태 코드를 그대로 써요. 손님은 상태 코드만 보고도 무슨 일이 있었는지 알 수 있어요.
  • 입력은 늘 의심해요. 빈칸뿐인 할 일과 JSON이 아닌 본문은 400으로 돌려보냈어요. 서버는 손님이 보낸 값을 믿지 않아요. 브라우저의 입력칸 검사는 사용자를 돕는 장치일 뿐, 누구나 curl로 아무 값이나 보낼 수 있으니까요.
  • 없는 것은 404, 안 되는 방법은 405. 99번 할 일은 없어서 404예요. /todos라는 주소는 있지만 DELETE는 받지 않으니 405로 구별했어요.
  • 서버의 버그는 500, 그리고 자세한 내용은 기록에만. /boom은 0으로 나누는 버그가 있어요. 손님에게는 "서버 안에서 문제가 생겼어요"라고만 답하고, 오류의 종류와 내용은 서버 기록에 남겼어요. 오류 메시지나 코드 위치를 손님에게 그대로 보여 주면, 공격자에게 서버의 속사정을 알려 주는 셈이에요.
  • 버그가 있어도 서버는 살아 있어요. /boom 다음 요청도 정상적으로 처리됐어요. 요청 하나의 실패가 서버 전체를 멈추지 않게, 처리 함수를 try로 감쌌기 때문이에요.

동시에 몰리는 요청

실제 서버에는 요청이 하나씩 차례로 오지 않아요. 50개를 한꺼번에 보내 볼게요.

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=20) as pool:
    statuses = list(pool.map(lambda i: call("POST", "/todos", {"text": f"동시 요청 {i}"})[0], range(50)))
print("동시에 보낸 50개 중 201:", statuses.count(201))
print("저장된 할 일:", len(call("GET", "/todos")[1]), "개")
server.shutdown()
동시에 보낸 50개 중 201: 50
저장된 할 일: 52 개

앞의 2개와 합쳐 52개가 빠짐없이 저장됐어요. ThreadingHTTPServer는 요청마다 스레드를 하나씩 만들어 동시에 처리해요. 여러 스레드가 데이터베이스 연결 하나를 함께 쓰니, db_lock으로 한 번에 한 스레드만 쓰게 차례를 정했어요. 이 잠금을 빼면 두 스레드가 동시에 연결을 건드려 오류가 나거나 데이터가 꼬일 수 있어요. 데이터베이스 트랙의 트랜잭션 강의에서 본 "동시에 일하면 생기는 문제"가 서버 안에서도 그대로 나타나요.

동시에 많은 요청을 받는 방법은 크게 세 가지예요.

방식생각예
스레드요청마다 일꾼(스레드)을 하나씩 붙여요이 예제, 많은 자바 서버
프로세스 여러 개똑같은 서버 프로그램을 여러 개 띄워 나눠 받아요gunicorn으로 띄운 파이썬 서버
비동기일꾼 하나가 기다리는 동안 다른 요청을 처리해요Node.js, FastAPI와 uvicorn

비동기는 웹 개발 트랙의 비동기 강의에서 본 이벤트 루프와 같은 원리예요. 서버의 일은 대부분 데이터베이스나 다른 서버를 기다리는 시간이라, 기다리는 동안 다른 요청을 받으면 일꾼 하나로도 많은 요청을 감당해요.

이 예제의 http.server는 배우기에는 좋지만, 파이썬 공식 문서도 실제 서비스에는 쓰지 말라고 해요. 보안 점검이 충분하지 않고, 느린 손님 하나가 일꾼을 붙잡는 공격 같은 것에 약해요. 실제로는 Flask, FastAPI, Django 같은 프레임워크로 만들고, gunicorn이나 uvicorn 같은 검증된 서버 프로그램 위에서 돌려요. 그래도 그 속에서 일어나는 일은 방금 만든 것과 똑같아요.

서버는 기억하지 않는 게 좋아요

손님이 늘면 서버를 여러 대로 늘리고, 앞에서 요청을 나눠 주는 장치(로드 밸런서)를 둬요. 그런데 서버마다 로그인 정보를 자기 메모리에 들고 있으면 어떻게 될까요?

sessions_a, sessions_b = {}, {}                    # 서버 두 대가 각자 메모리에 로그인 정보를 들고 있어요
servers = [("서버 A", sessions_a), ("서버 B", sessions_b)]
turn = 0

def next_server():                                 # 앞단에서 요청을 번갈아 나눠 줘요
    global turn
    name, store = servers[turn % 2]
    turn += 1
    return name, store

name, store = next_server()
store["token-123"] = "민지"
print(f"로그인 요청 → {name}: 로그인 정보 저장")
for _ in range(3):
    name, store = next_server()
    print(f"내 정보 요청 → {name}:", store.get("token-123", "로그인하지 않았어요"))

shared = {}                                        # 모든 서버가 함께 보는 저장소(데이터베이스, Redis 등)
shared["token-123"] = "민지"
print("함께 보는 저장소라면:", [shared.get("token-123") for _ in range(3)])
로그인 요청 → 서버 A: 로그인 정보 저장
내 정보 요청 → 서버 B: 로그인하지 않았어요
내 정보 요청 → 서버 A: 민지
내 정보 요청 → 서버 B: 로그인하지 않았어요
함께 보는 저장소라면: ['민지', '민지', '민지']

로그인은 서버 A가 받았는데, 다음 요청이 서버 B로 가면 "로그인하지 않았어요"가 돼요. 새로 고칠 때마다 로그인이 됐다 풀렸다 하는 셈이에요. 그래서 서버는 요청 사이에 아무것도 기억하지 않게(무상태) 만들고, 기억해야 할 것은 데이터베이스나 Redis처럼 모든 서버가 함께 보는 저장소에 두거나, 서명한 토큰에 담아 손님이 들고 다니게 해요. 그러면 서버를 몇 대로 늘리든, 한 대가 고장 나 다른 서버가 대신 받든 문제가 없어요. 서버의 메모리에 둔 것은 언제든 사라질 수 있다고 생각하는 게 안전해요.

내 컴퓨터 밖에서 접속하려면

방금 만든 서버는 주소 127.0.0.1로 열었어요. 이 주소는 "이 컴퓨터 자신"이라서, 같은 컴퓨터 안에서만 접속할 수 있어요. 다른 기기에서 접속하게 하려면 몇 단계가 필요해요.

  1. 모든 주소에서 받기: 0.0.0.0으로 열면 이 컴퓨터의 모든 네트워크 주소에서 연결을 받아요. 같은 와이파이의 휴대폰에서 http://내컴퓨터의사설IP:포트로 접속할 수 있게 돼요. 그만큼 같은 네트워크의 누구나 접속할 수 있다는 뜻이니, 개발 중에는 꼭 필요할 때만 써요.
  2. 방화벽: 운영체제의 방화벽이 그 포트로 들어오는 연결을 허락해야 해요.
  3. 공유기 너머: 집의 컴퓨터는 사설 IP를 쓰고 공유기 뒤에 숨어 있어요(인터넷 구조 강의). 바깥에서 접속하게 하려면 공유기에서 포트를 열어 주는 설정(포트 포워딩)이 필요하고, 집의 공인 IP는 때때로 바뀌기도 해요.
  4. 이름과 암호화: 사람들이 쓰려면 도메인(DNS 강의)과 HTTPS 인증서(TLS 강의)가 필요해요.

집 컴퓨터로 이걸 다 하려면 번거롭고, 컴퓨터를 24시간 켜 둬야 하고, 집 회선이 그대로 공격에 드러나요. 그래서 보통은 서버를 다른 곳에 둬요.

서버는 어디에 둘까

어디에무엇을 직접 하나어울리는 때
집 컴퓨터, 라즈베리 파이전부(전기, 회선, 보안, 운영체제)배우기, 집 안에서만 쓰는 도구
가상 서버(VPS, 클라우드 VM)운영체제부터 위로 전부마음대로 설정하고 싶을 때, 오래 도는 프로그램
앱 실행 플랫폼(PaaS)내 코드만. 서버 관리는 플랫폼이웹 앱과 API를 빠르게 내놓을 때
서버리스 함수함수 하나만. 요청이 올 때만 실행가끔 오는 요청, 작은 API, 예약 작업
정적 호스팅과 CDNHTML 파일만 올려요블로그, 문서, 이 가이드북 같은 사이트

위로 갈수록 마음대로 할 수 있지만 할 일이 많고, 아래로 갈수록 편하지만 플랫폼의 규칙을 따라야 해요. 많은 플랫폼이 작은 규모는 무료로 쓸 수 있게 해 줘서, 개인 프로젝트는 비용 없이 시작할 수 있는 경우가 많아요. 데이터베이스도 직접 설치하기보다 관리형 서비스를 쓰면 백업과 업데이트를 맡길 수 있어요. 다음 강의에서 정적 사이트와 동적 사이트를 비교하며 이 선택을 더 자세히 다뤄요.

얼마나 오래 살아 있어야 하나

서버가 멈추지 않고 일하는 비율을 가용성이라고 해요. "99.9%"처럼 9의 개수로 말하는데, 숫자가 주는 느낌과 실제 시간은 꽤 달라요.

HOURS_PER_YEAR = 365 * 24
for nines in ("99%", "99.9%", "99.99%", "99.999%"):
    down = HOURS_PER_YEAR * (1 - float(nines.rstrip("%")) / 100)
    text = f"{down:.1f}시간" if down >= 1 else f"{down * 60:.1f}분"
    print(f"가용성 {nines}: 1년에 멈춰도 되는 시간 {text}")
가용성 99%: 1년에 멈춰도 되는 시간 87.6시간
가용성 99.9%: 1년에 멈춰도 되는 시간 8.8시간
가용성 99.99%: 1년에 멈춰도 되는 시간 52.6분
가용성 99.999%: 1년에 멈춰도 되는 시간 5.3분

99%면 괜찮아 보이지만 1년에 사흘 반이 넘게 멈춘다는 뜻이에요. 9를 하나 더할 때마다 멈춰도 되는 시간이 10분의 1로 줄고, 그만큼 비용과 노력이 크게 늘어요. 서버 한 대로는 업데이트하려고 잠깐 끄는 것만으로도 99.99%를 지키기 어려워요. 그래서 높은 가용성이 필요한 서비스는 서버를 여러 대 두고, 한 대가 멈춰도 나머지가 받게 해요. 이때 앞에서 본 "서버는 기억하지 않는다"는 원칙이 필수가 돼요.

내 서비스에 정말 필요한 수준이 어느 정도인지 정하는 게 먼저예요. 개인 블로그는 99%여도 괜찮지만, 결제 서비스는 그럴 수 없어요.

실습

  1. 할 일 서버에 DELETE /todos/숫자를 더해 보세요. 없는 번호를 지우면 404를 돌려줘야 해요.
  2. POST /todos에서 할 일 내용이 100자를 넘으면 400으로 거절해 보세요. 오류 메시지에는 무엇을 적으면 손님에게 도움이 될까요?
  3. 접속 기록에 처리에 걸린 시간(ms)을 더해 보세요. time.perf_counter()를 쓰면 돼요.
  4. db_lock을 빼고 동시 요청 예제를 여러 번 돌려 보세요. 무슨 일이 생기나요? 생기지 않더라도 안전하다고 할 수 없는 이유는 무엇일까요?
  5. 서버를 127.0.0.1 대신 0.0.0.0으로 열고, 같은 와이파이의 휴대폰 브라우저로 /todos에 접속해 보세요. 실습이 끝나면 다시 127.0.0.1로 돌려놓으세요.
  6. 로그인 예제에서 서버를 세 대로 늘리고, 요청 여섯 번 중 몇 번이 "로그인하지 않았어요"가 되는지 세어 보세요.

자주 하는 실수

  • 손님이 보낸 값을 그대로 믿는다. 브라우저에서 검사했어도 서버에서 다시 검사해요.
  • 오류의 자세한 내용을 응답에 그대로 보낸다. 손님에게는 간단히, 자세한 내용은 서버 기록에 남겨요.
  • 모든 실패에 200이나 500만 쓴다. 손님의 잘못(4xx)과 서버의 잘못(5xx)을 구별해 알려 줘요.
  • 기록을 남기지 않는다. 문제가 생기면 무슨 일이 있었는지 알 길이 없어요.
  • 서버 메모리에 로그인 정보 같은 상태를 둔다. 서버를 늘리거나 다시 시작하면 사라져요.
  • 공부용 서버를 그대로 서비스에 쓴다. 검증된 프레임워크와 서버 프로그램을 써요.
  • 개발용 서버를 0.0.0.0으로 열어 둔 채 잊는다. 같은 네트워크의 누구나 접속할 수 있어요.

점검 문제

  1. 서버를 "특별한 컴퓨터"보다 "프로그램"으로 보는 이유는?
  2. 서버가 요청 하나를 처리하는 여섯 단계는?
  3. 라우팅이란 무엇인가요?
  4. 404와 405, 400과 500은 각각 어떻게 다른가요?
  5. 서버 안에서 오류가 났을 때 손님에게 자세한 내용을 보여 주면 안 되는 이유는?
  6. 여러 스레드가 데이터베이스 연결 하나를 함께 쓸 때 잠금이 필요한 이유는?
  7. 서버 여러 대가 각자 메모리에 로그인 정보를 두면 생기는 문제와 해결책은?
  8. 127.0.0.1로 연 서버에 같은 와이파이의 휴대폰이 접속할 수 없는 이유는?
  9. 가용성 99.9%와 99.99%는 1년에 각각 얼마나 멈춰도 되나요?

정답

  1. 요청을 기다렸다가 처리하고 응답하는 일을 하면, 어떤 컴퓨터에서 돌든 서버이기 때문이에요. 서버 컴퓨터는 그런 프로그램을 쉬지 않고 돌리는 컴퓨터일 뿐이에요.
  2. 연결을 기다리고, 요청을 읽고, 처리할 함수를 고르고, 일을 하고, 응답하고, 기록을 남겨요.
  3. 요청의 메서드와 주소를 보고 어떤 처리 함수가 맡을지 정하는 일이에요.
  4. 404는 주소나 대상이 없을 때, 405는 주소는 있지만 그 메서드를 받지 않을 때예요. 400은 손님이 보낸 요청이 잘못됐을 때, 500은 서버 안의 문제일 때예요.
  5. 오류 내용과 코드 위치가 공격자에게 서버의 구조와 약점을 알려 주기 때문이에요. 손님에게는 간단히 알리고 자세한 내용은 서버 기록에 남겨요.
  6. 여러 스레드가 동시에 같은 연결을 건드리면 오류가 나거나 데이터가 꼬일 수 있어서, 한 번에 한 스레드만 쓰도록 차례를 정해야 하기 때문이에요.
  7. 로그인을 받은 서버가 아닌 다른 서버로 다음 요청이 가면 로그인하지 않은 것으로 보여요. 서버는 무상태로 두고, 로그인 정보는 모든 서버가 함께 보는 저장소에 두거나 서명한 토큰으로 손님이 들고 다니게 해요.
  8. 127.0.0.1은 그 컴퓨터 자신만을 뜻하는 주소라서, 그 주소로 연 서버는 같은 컴퓨터 안의 연결만 받기 때문이에요.
  9. 99.9%는 약 8.8시간, 99.99%는 약 52.6분이에요.

다음 강의

서버를 직접 만들어 봤으니, 이번에는 "꼭 서버가 필요할까?"를 물어볼 차례예요. 다음 강의에서는 미리 만들어 둔 파일을 나눠 주기만 하는 정적 사이트와, 요청마다 내용을 만드는 동적 사이트를 비교하고, 전 세계 사용자에게 빠르게 전하는 CDN의 원리를 배워요.