웹 서버와 리버스 프록시: Nginx로 이해하는 구조
앱 서버 앞에 웹 서버를 하나 더 두는 이유를 Nginx의 구조로 이해해요. 파이썬으로 작은 리버스 프록시를 직접 만들어 정적 파일은 앞에서 바로 답하고, 요청은 앱 서버 두 대에 번갈아 나눠 주고, 죽은 서버는 건너뛰고, 느린 서버에는 504, 모두 죽으면 502로 답하는 모습을 확인해요. 손님이 가짜로 적어 보낸 주소에 속지 않는 법, HTTPS 처리, 요청 크기와 횟수 제한, 멈추지 않고 배포하는 방법을 정리하고, 실제 Nginx 설정을 한 줄씩 읽어 봐요.
첫 강의에서 만든 앱 서버는 요청을 직접 받았어요. 실제 서비스에서는 보통 앱 서버를 인터넷에 바로 드러내지 않고, 그 앞에 웹 서버를 하나 더 둬요. 손님의 요청은 웹 서버가 먼저 받고, 필요한 것만 뒤쪽의 앱 서버로 넘겨요. 이렇게 서버들을 대신해 요청을 받는 앞단을 리버스 프록시라고 하고, 가장 널리 쓰이는 것이 Nginx예요.
왜 앞에 하나를 더 두나
앱 서버는 "할 일 목록을 돌려준다" 같은 서비스의 일을 잘하게 만든 프로그램이에요. 그 밖의 일까지 다 맡기면 비효율적이고 위험해요. 앞단의 웹 서버가 대신 맡는 일은 이래요.
| 앞단이 맡는 일 | 왜 앞단에서 |
|---|---|
| HTTPS 처리 | 인증서와 암호화를 한 곳에서 관리하고, 앱 서버는 평범한 HTTP만 다뤄요 |
| 정적 파일 | 이미지, CSS를 앱 서버보다 훨씬 빠르게, 적은 자원으로 보내요 |
| 요청 나눠 주기 | 앱 서버 여러 대에 고르게 나누고, 죽은 서버는 빼요 |
| 느린 손님 상대 | 느린 회선의 손님을 앞단이 기다려 줘서 앱 서버의 일꾼이 붙잡히지 않아요 |
| 제한과 보호 | 너무 큰 요청, 너무 잦은 요청을 앱 서버에 닿기 전에 막아요 |
| 압축, 캐시, 기록 | 응답 압축과 접속 기록을 한 곳에서 해요 |
리눅스에서는 1024번보다 작은 포트(80, 443)를 열려면 관리자 권한이 필요해요. 웹 서버만 그 포트를 열고, 앱 서버는 권한 없이 8000번 같은 포트에서 돌리면 앱에 보안 구멍이 있어도 피해가 줄어들어요.
참고로 프록시는 "대신해 주는 서버"라는 뜻이에요. 회사 컴퓨터들이 바깥 인터넷에 나갈 때 거치는 프록시는 손님 쪽을 대신해서 포워드 프록시라고 하고, 오늘 다루는 건 서버 쪽을 대신해서 리버스 프록시라고 해요.
직접 만드는 리버스 프록시
먼저 뒤쪽의 앱 서버 두 대(A, B)를 띄워요. 받은 요청을 자기 이름과 함께 돌려주고, /api/slow는 일부러 2초 걸려요.
import http.client
import itertools
import json
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
def start(handler_cls):
srv = ThreadingHTTPServer(("127.0.0.1", 0), handler_cls)
threading.Thread(target=srv.serve_forever, daemon=True).start()
return srv
def send_json(handler, status, payload, extra=()):
data = json.dumps(payload, ensure_ascii=False).encode()
try:
handler.send_response(status)
handler.send_header("Content-Type", "application/json; charset=utf-8")
handler.send_header("Content-Length", str(len(data)))
for k, v in extra:
handler.send_header(k, v)
handler.end_headers()
handler.wfile.write(data)
except ConnectionError:
pass # 상대가 기다리다 포기하고 끊었어요
backend_hits = {"A": 0, "B": 0}
def make_backend(name):
class App(BaseHTTPRequestHandler): # 뒤쪽의 앱 서버: 실제 일을 해요
def log_message(self, *args):
pass
def do_GET(self):
backend_hits[name] += 1
if self.path == "/api/slow":
time.sleep(2)
forwarded = self.headers.get("X-Forwarded-For", "")
send_json(self, 200, {"server": name, "path": self.path,
"손님_주소_기록": forwarded,
"진짜_손님_주소": forwarded.split(",")[-1].strip() if forwarded else None})
return App
app_a, app_b = start(make_backend("A")), start(make_backend("B"))
print("앱 서버 두 대가 각자 포트에서 기다려요(손님에게는 알리지 않아요)")
앱 서버 두 대가 각자 포트에서 기다려요(손님에게는 알리지 않아요)
이제 앞단의 프록시예요. 정적 파일은 직접 답하고, 나머지는 앱 서버에 번갈아 넘겨요. 손님은 프록시의 주소만 알아요.
STATIC = {"/static/style.css": b"body { font-family: sans-serif; }"} # 프록시가 직접 들고 있는 정적 파일
backends = [("A", app_a.server_address[1]), ("B", app_b.server_address[1])]
rotation = itertools.cycle(range(len(backends)))
rotation_lock = threading.Lock()
proxy_log = []
dead_until = {} # 실패한 앱 서버를 잠시 빼 두는 시각
class Proxy(BaseHTTPRequestHandler): # 앞단의 리버스 프록시
def log_message(self, *args):
pass
def do_GET(self):
if self.path in STATIC: # 정적 파일은 앱 서버까지 가지 않고 바로
body = STATIC[self.path]
self.send_response(200)
self.send_header("Content-Type", "text/css")
self.send_header("Content-Length", str(len(body)))
self.send_header("Cache-Control", "public, max-age=2592000")
self.end_headers()
self.wfile.write(body)
proxy_log.append(f"{self.path} → 프록시가 직접 응답")
return
with rotation_lock:
start_at = next(rotation)
client_ip = self.client_address[0]
prior = self.headers.get("X-Forwarded-For")
forwarded = f"{prior}, {client_ip}" if prior else client_ip # 받은 기록 뒤에 실제 연결 주소를 덧붙여요
for i in range(len(backends)): # 순서대로 돌아가며, 죽은 서버는 건너뛰어요
name, port = backends[(start_at + i) % len(backends)]
if dead_until.get(name, 0) > time.monotonic():
continue # 최근에 실패한 서버는 잠시 건너뛰어요
conn = http.client.HTTPConnection("127.0.0.1", port, timeout=5) # 연결은 5초까지
try:
conn.connect()
conn.sock.settimeout(1) # 연결된 뒤 응답은 1초까지만 기다려요
conn.request("GET", self.path, headers={"X-Forwarded-For": forwarded, "X-Forwarded-Proto": "https"})
res = conn.getresponse()
body = res.read()
except ConnectionRefusedError:
dead_until[name] = time.monotonic() + 10
proxy_log.append(f"{self.path} → 앱 서버 {name} 연결 거부, 10초 동안 빼 두고 다음 서버로")
continue
except TimeoutError:
proxy_log.append(f"{self.path} → 앱 서버 {name} 시간 초과")
return send_json(self, 504, {"error": "앱 서버가 제때 답하지 않았어요"})
finally:
conn.close()
proxy_log.append(f"{self.path} → 앱 서버 {name}")
self.send_response(res.status)
self.send_header("Content-Type", res.getheader("Content-Type"))
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
send_json(self, 502, {"error": "살아 있는 앱 서버가 없어요"})
proxy = start(Proxy)
proxy_port = proxy.server_address[1]
def get(path, headers=None):
conn = http.client.HTTPConnection("127.0.0.1", proxy_port, timeout=10)
conn.request("GET", path, headers=headers or {})
res = conn.getresponse()
body = res.read().decode()
conn.close()
return res.status, (json.loads(body) if res.getheader("Content-Type", "").startswith("application/json") else body)
for path in ("/api/orders", "/api/orders", "/api/users", "/static/style.css", "/static/style.css"):
status, body = get(path)
print(status, body if isinstance(body, str) else f"server={body['server']} path={body['path']}")
print("앱 서버가 받은 요청:", backend_hits)
200 server=A path=/api/orders
200 server=B path=/api/orders
200 server=A path=/api/users
200 body { font-family: sans-serif; }
200 body { font-family: sans-serif; }
앱 서버가 받은 요청: {'A': 2, 'B': 1}
- API 요청은 A, B, A 순서로 번갈아 갔어요. 이렇게 차례로 돌리는 방식을 라운드 로빈이라고 해요. 일이 가장 적은 서버에 주는 방식, 같은 손님은 늘 같은 서버로 보내는 방식도 있어요.
- CSS 파일 두 번은 앱 서버가 전혀 몰랐어요. 요청 다섯 번 중 앱 서버가 받은 건 셋이에요. 실제 웹 페이지 하나에는 이미지, CSS, 자바스크립트 요청이 수십 개 딸려 오니, 이걸 앞단이 받아 주는 효과가 커요.
느린 서버, 죽은 서버
이번에는 일부러 문제를 일으켜 볼게요.
status, body = get("/api/slow")
print("느린 요청:", status, body)
app_b.shutdown()
app_b.server_close() # 앱 서버 B가 죽었어요
print("B가 죽은 뒤:", [get("/api/orders")[1]["server"] for _ in range(3)])
app_a.shutdown()
app_a.server_close()
print("둘 다 죽으면:", get("/api/orders"))
print("\n".join(proxy_log))
느린 요청: 504 {'error': '앱 서버가 제때 답하지 않았어요'}
B가 죽은 뒤: ['A', 'A', 'A']
둘 다 죽으면: (502, {'error': '살아 있는 앱 서버가 없어요'})
/api/orders → 앱 서버 A
/api/orders → 앱 서버 B
/api/users → 앱 서버 A
/static/style.css → 프록시가 직접 응답
/static/style.css → 프록시가 직접 응답
/api/slow → 앱 서버 B 시간 초과
/api/orders → 앱 서버 A
/api/orders → 앱 서버 B 연결 거부, 10초 동안 빼 두고 다음 서버로
/api/orders → 앱 서버 A
/api/orders → 앱 서버 A
/api/orders → 앱 서버 A 연결 거부, 10초 동안 빼 두고 다음 서버로
HTTP 강의의 상태 코드 표에서 본 502와 504가 바로 이런 때 나와요.
- 504 Gateway Timeout: 앱 서버에 연결은 됐는데 정해 둔 1초 안에 답이 없었어요. 앞단이 무한정 기다리지 않고 손님에게 알려 줬어요.
- 연결 거부와 건너뛰기: B가 죽자 프록시는 B에 연결하려다 거절당하고, 바로 A에 대신 보냈어요. 손님은 B가 죽은 줄도 몰라요. 그리고 B를 10초 동안 빼 둬서 그다음 요청들은 B를 시도조차 하지 않았어요. Nginx의
max_fails와fail_timeout설정이 같은 일을 해요. - 502 Bad Gateway: 살아 있는 앱 서버가 하나도 없으면 앞단은 답할 방법이 없어요. 웹사이트에서 502를 보면 "앞단은 살아 있는데 그 뒤의 앱이 죽었다"는 뜻이라, 앱 서버 쪽 기록부터 보면 돼요.
예제에서 연결 제한 시간(5초)과 응답 제한 시간(1초)을 따로 둔 데는 이유가 있어요. 처음에는 둘 다 1초로 했더니, 윈도에서 죽은 B가 "연결 거부"가 아니라 "시간 초과"로 판정됐어요. 네트워크 진단 강의에서 봤듯이 윈도는 거절을 받아도 2초쯤 다시 시도하거든요. 실제 운영에서도 "연결을 기다리는 시간"과 "응답을 기다리는 시간"은 따로 정해요.
손님의 주소는 누가 알려 주나
앞단을 두면 앱 서버 입장에서는 모든 요청이 프록시에서 온 것처럼 보여요. 그래서 프록시는 원래 손님의 주소를 X-Forwarded-For 헤더에 적어 넘겨요. 그런데 이 헤더는 손님도 마음대로 적어 보낼 수 있어요.
app_a = start(make_backend("A"))
backends[0] = ("A", app_a.server_address[1])
dead_until.clear() # 다시 살아난 서버를 되돌려 놓아요(실제로는 상태 검사가 해요)
status, body = get("/api/me", headers={"X-Forwarded-For": "1.2.3.4"}) # 손님이 가짜 주소를 적어 보냈어요
print("앱 서버가 받은 기록:", body["손님_주소_기록"])
print("맨 앞을 믿으면:", body["손님_주소_기록"].split(",")[0].strip(), "| 프록시가 덧붙인 맨 뒤를 믿으면:", body["진짜_손님_주소"])
proxy.shutdown()
app_a.shutdown()
앱 서버가 받은 기록: 1.2.3.4, 127.0.0.1
맨 앞을 믿으면: 1.2.3.4 | 프록시가 덧붙인 맨 뒤를 믿으면: 127.0.0.1
손님이 1.2.3.4라고 적어 보냈고, 프록시는 그 뒤에 실제로 연결해 온 주소(127.0.0.1)를 덧붙였어요. 앱 서버가 맨 앞을 믿으면 손님이 꾸민 주소에 속아요. 요청 횟수 제한이나 국가별 차단을 손님 주소로 한다면, 공격자가 헤더 하나로 제한을 피해 가는 셈이에요. 앱 서버는 내가 믿는 프록시가 덧붙인 값, 즉 맨 뒤의 값(프록시가 여러 단계라면 믿는 프록시 수만큼 뒤에서 센 값)만 믿어야 해요. 프레임워크에는 "믿을 프록시가 몇 단계인지"를 정하는 설정이 있어요.
실제 Nginx 설정 읽기
지금까지 파이썬으로 만든 일을 Nginx는 설정 몇 줄로 해요. 예시 설정을 읽어 볼게요.
upstream app_servers { # 뒤쪽 앱 서버 목록
server 127.0.0.1:8001 max_fails=3 fail_timeout=10s;
server 127.0.0.1:8002 max_fails=3 fail_timeout=10s;
}
server {
listen 80;
server_name example.com;
return 301 https://$host$request_uri; # HTTP로 오면 HTTPS로 보내요
}
server {
listen 443 ssl;
server_name example.com;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
client_max_body_size 10m; # 10MB보다 큰 요청은 앱까지 보내지 않아요
gzip on; # 글자 응답을 압축해요
location /static/ { # 정적 파일은 디스크에서 바로
root /srv/app;
expires 30d;
}
location / { # 나머지는 앱 서버로
proxy_pass http://app_servers;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 5s;
proxy_read_timeout 30s;
}
}
upstream은 앱 서버 묶음이에요. 기본으로 라운드 로빈을 하고, 세 번 실패한 서버는 10초 동안 빼요.- 첫
server는 80번(HTTP)으로 온 손님을 443번(HTTPS)으로 보내요. TLS 강의에서 말한 "HTTP는 HTTPS로 보내기"예요. - 둘째
server는 인증서로 HTTPS를 처리해요. 인증서는 Let's Encrypt 같은 곳에서 무료로 받고 자동으로 갱신하게 해 둬요. location /static/은 정적 파일을 디스크에서 바로 보내고,expires로 브라우저 캐시 기간을 정해요.location /의proxy_pass가 앱 서버로 넘기는 부분이에요.$proxy_add_x_forwarded_for는 예제처럼 받은 기록 뒤에 실제 주소를 덧붙여요. 연결과 응답의 제한 시간도 따로 정했어요.
요청 횟수를 제한하는 limit_req, 보안 헤더를 붙이는 add_header 같은 설정도 자주 써요. 설정을 바꾼 뒤에는 nginx -t로 문법을 검사하고, 멈추지 않고 새 설정을 읽게 하는 nginx -s reload로 적용해요.
멈추지 않고 배포하기
앱 서버가 여러 대이고 앞단이 나눠 준다면, 새 버전을 배포할 때 서비스를 멈출 필요가 없어요.
- 앞단에서 앱 서버 A를 잠시 빼요. 새 요청은 B만 받아요.
- A가 하던 요청을 다 끝낼 때까지 기다려요(드레인).
- A를 새 버전으로 바꾸고, 상태 검사 주소(
/health같은)가 정상으로 답하는지 확인해요. - A를 다시 넣고, B도 같은 순서로 바꿔요.
이걸 롤링 배포라고 해요. 첫 강의에서 말한 "서버는 기억하지 않는다"는 원칙이 여기서 빛나요. 서버가 로그인 정보를 들고 있었다면 A를 빼는 순간 A에서 로그인한 사람들이 모두 로그아웃됐을 거예요.
실습
- 프록시 예제에
/health주소를 더해, 앱 서버마다 "살아 있음"을 묻고 결과를 모아 보여 주게 해 보세요. - 라운드 로빈 대신 "지금 처리 중인 요청이 가장 적은 서버"에 보내도록 바꿔 보세요. 처리 중인 요청 수를 어떻게 세면 될까요?
- 프록시에 요청 크기 제한을 더해서,
Content-Length가 1,000바이트를 넘는 요청에는 413으로 답해 보세요. - 앱 서버에서
X-Forwarded-For를 읽을 때 "믿는 프록시 1단계"라는 설정을 두고, 그 수만큼 뒤에서 센 값을 쓰는 함수를 만들어 보세요. - Nginx 설정 예시에서
/api/요청만 앱 서버로 보내고, 나머지는/srv/site의 정적 파일로 답하게 바꿔 보세요.
자주 하는 실수
- 앱 서버를 인터넷에 바로 드러낸다. HTTPS, 정적 파일, 제한, 느린 손님 처리를 앱이 모두 떠안아요.
- 제한 시간을 정하지 않는다. 느린 앱 서버 하나 때문에 앞단의 연결이 줄줄이 묶여요.
X-Forwarded-For의 맨 앞 값을 믿는다. 손님이 꾸민 주소예요. 믿는 프록시가 덧붙인 값만 써요.- 502와 504를 앞단의 문제로 착각한다. 둘 다 뒤쪽 앱 서버의 문제를 앞단이 알려 주는 거예요.
- 설정을 검사하지 않고 다시 읽힌다. 문법이 틀리면 웹 서버 전체가 멈출 수 있어요.
nginx -t부터 해요. - 서버를 빼지 않고 바로 재시작한다. 처리 중이던 요청이 끊겨요. 빼고, 기다리고, 바꾸고, 확인하고, 넣어요.
점검 문제
- 리버스 프록시와 포워드 프록시는 각각 누구를 대신하나요?
- 앱 서버 앞에 웹 서버를 두면 좋은 점 세 가지는?
- 예제에서 CSS 요청이 앱 서버에 가지 않은 것이 왜 중요한가요?
- 504와 502는 각각 어떤 상황에서 나오나요?
- 실패한 앱 서버를 잠시 빼 두는 이유는?
- 연결 제한 시간과 응답 제한 시간을 따로 두는 이유는?
X-Forwarded-For의 맨 앞 값을 믿으면 안 되는 이유와, 대신 믿을 값은?- 롤링 배포의 순서와, 서버가 상태를 기억하지 않아야 하는 이유는?
정답
- 리버스 프록시는 서버 쪽을 대신해 손님의 요청을 받고, 포워드 프록시는 손님 쪽을 대신해 바깥 서버에 요청해요.
- HTTPS와 인증서를 한 곳에서 처리하고, 정적 파일을 빠르게 보내고, 요청을 여러 앱 서버에 나누고 죽은 서버를 빼요. 큰 요청이나 잦은 요청을 앞에서 막고, 느린 손님 때문에 앱 서버가 붙잡히지 않게 하는 것도 장점이에요.
- 페이지 하나에 딸린 수많은 정적 파일 요청을 앞단이 받아 줘서, 앱 서버가 정말 필요한 일만 하게 되기 때문이에요.
- 504는 앱 서버에 연결은 됐지만 정해 둔 시간 안에 답이 없을 때, 502는 앱 서버에 연결할 수 없거나 엉뚱한 응답을 받아 앞단이 답할 방법이 없을 때 나와요.
- 죽은 서버에 매번 연결을 시도하면 그때마다 손님이 기다려야 하기 때문이에요. 잠시 빼 두면 다음 요청은 바로 살아 있는 서버로 가요.
- 연결이 안 되는 상황과 연결은 됐지만 처리가 느린 상황은 원인도 대처도 다르고, 운영체제에 따라 연결 거부를 알아채는 데도 시간이 걸리기 때문이에요.
- 손님이 헤더에 아무 값이나 적어 보낼 수 있어서 맨 앞 값은 꾸민 주소일 수 있기 때문이에요. 내가 믿는 프록시가 덧붙인 값, 즉 믿는 프록시 수만큼 뒤에서 센 값을 써요.
- 앞단에서 서버 하나를 빼고, 하던 요청이 끝나길 기다리고, 새 버전으로 바꾸고, 상태 검사로 확인한 뒤 다시 넣는 일을 한 대씩 반복해요. 서버가 로그인 같은 상태를 기억하고 있으면 그 서버를 빼는 순간 상태가 사라지기 때문에, 상태는 모든 서버가 함께 보는 저장소에 둬야 해요.
다음 강의
앱 서버를 여러 대 띄우려면 서버마다 똑같은 파이썬 버전, 똑같은 라이브러리, 똑같은 설정을 갖춰야 해요. "내 컴퓨터에서는 되는데요"가 생기는 곳이 바로 여기예요. 다음 강의에서는 프로그램과 실행 환경을 통째로 상자에 담아 어디서나 똑같이 실행하는 도커와 컨테이너를 배워요.