Devin.KR

웹 서버와 리버스 프록시 - 앞단에서 하는 일

개발자KR 조회 3

이 장에서 배우는 것

앞 장에서 요청의 메서드와 헤더, 응답의 상태 코드를 읽었다. 이번에는 작은 온라인 서점에 도착한 요청을 처음 받는 웹 서버를 살펴본다. 웹 서버는 책 표지를 파일에서 꺼내 보내고, 도서 검색이나 주문 요청은 뒤쪽의 응용 프로그램으로 넘길 수 있다. 클라이언트 대신 뒤쪽 서버에 요청을 보내고 그 응답을 돌려주는 역할을 리버스 프록시(reverse proxy)라고 한다. 이 장에서는 한 앞단이 두 역할을 함께 맡는다.

  • 정적 파일을 직접 보내는 경우와 백엔드에 요청을 넘기는 경우를 구분한다.
  • TLS 종료, 응답 압축, 요청 크기와 시간 제한을 어느 지점에 적용하는지 설명한다.
  • 전달받은 주소를 신뢰할 수 있는 조건과 상태 확인 결과가 분배에 미치는 영향을 설명한다.
  • 경로 분기표를 실행해 경계값을 확인하고, AI가 제안한 수정의 차이를 검토한다.

문제 상황

서점의 첫 화면에서는 책 표지 여러 장을 보여 준다. 표지 주소는 /static/covers/python.jpg처럼 정해져 있다. 반면 /api/books는 검색 조건에 맞는 도서 목록을 만들고, /api/orders는 주문 본문을 받아 처리한다. 표지 파일까지 모두 백엔드가 열어 보내면, 표지 요청이 몰릴 때 검색과 주문을 처리하는 백엔드도 같은 부하를 받는다. 표지를 앞단에서 제공하면 파일 전달과 업무 처리가 서로 다른 경로를 지난다.

운영 중에는 서로 다른 판단이 한 요청 안에서 이어진다. 주문 본문이 서점에서 허용한 크기를 넘으면 주문 서버로 보내기 전에 거절한다. 주문 서버 두 대 중 한 대가 상태 확인에 실패하면 다른 서버에 새 요청을 보낸다. 문의를 받은 운영자가 접속 주소를 확인할 때는 바로 앞에서 연결한 장비가 어떤 장비인지도 함께 살펴야 한다. 주소를 적은 헤더 한 줄만으로는 그 값을 누가 넣었는지 알 수 없기 때문이다.

연결을 받고 경로를 고르는 앞단

브라우저가 서점에 HTTPS로 접속하면 앞단이 인증서를 제시하고 전송 계층 보안(TLS) 연결을 맺는다. 브라우저와 맺은 암호화 연결이 앞단에서 끝나는 것을 TLS 종료라고 한다. 앞단은 복호화한 요청에서 경로와 헤더를 읽어 처리 대상을 고른다. 백엔드까지 암호화할 필요가 있는 배치에서는 앞단과 백엔드 사이에도 별도의 TLS 연결을 맺고 백엔드 인증서를 검증한다. 브라우저가 본 인증서와 앞단이 검증하는 뒤쪽 인증서는 각 연결에서 확인할 대상이다.

앞단은 브라우저의 TLS 연결을 끝내고 경로에 따라 표지를 직접 보내거나 검색과 주문을 백엔드에 넘긴다.

경로를 나눌 때는 접두어의 끝을 어디로 볼지 정한다. 이 서점에서 /api 규칙은 /api 자체와 /api/ 아래 경로에 적용한다. /apiary는 다른 경로다. /api/orders처럼 더 구체적인 규칙이 있으면 먼저 적용하고, 마지막에 기본 규칙을 둔다. 앞단과 백엔드가 같은 경로를 같은 방식으로 해석하도록 실제 설정에서는 경로 정규화 방식과 질의 문자열 처리도 확인한다. 아래 코드는 질의 문자열을 떼어 낸 경로를 입력으로 받는다.

정적 파일 규칙은 공개하기로 한 디렉터리에만 연결한다. 예를 들어 /static/covers/python.jpg에 대응하는 표지 파일이 있으면 앞단이 그 파일을 image/jpeg로 보낸다. 파일이 없으면 그 자리에서 404를 반환한다. 설정을 검토할 때는 공개 경로를 어떤 디렉터리에 연결하는지, 그 안에 어떤 파일이 들어가는지 함께 본다. 완성 코드에서는 파일 목록을 경로 집합으로 표현한다.

응답 압축은 전송량을 줄이는 데 쓰인다. 앞단은 클라이언트가 Accept-Encoding으로 허용한 인코딩과 응답의 종류를 보고 압축 여부를 정한다. 예를 들어 서점의 HTML이나 도서 목록 JSON은 gzip 압축 대상으로 두고, 이미 압축된 JPEG 표지는 그대로 보낸다. 실제 운영에서는 응답 크기와 압축 비용도 고려한다. gzip으로 보낸 응답에는 Content-Encoding: gzip을 붙이고, 같은 URL에서 압축 여부가 요청 헤더에 따라 달라지면 Vary: Accept-Encoding을 사용해 캐시가 응답을 구분하게 한다. 백엔드가 이미 압축한 응답은 기존 인코딩을 확인해 전달한다.

요청을 제한하고 접속 주소를 판단하기

요청 본문 크기 제한은 앞단이 받아들일 바이트 수를 정한다. 주문 API가 받는 JSON과 읽기 위주의 도서 API에 서로 다른 한도를 둘 수 있다. 한도를 넘으면 이 예제는 413을 반환한다. 실제 앞단에서는 Content-Length에 선언된 값이 한도를 넘을 때 일찍 거절할 수 있다. 선언값만 확인하고 읽기를 끝내면 실제로 받은 바이트 수를 놓치므로, 본문을 읽는 동안에도 한도를 적용한다. 완성 코드에 넘기는 크기는 실제로 받은 본문 바이트 수를 나타내는 예제 값이다.

시간 제한도 어느 구간에서 재는지 먼저 정한다. 클라이언트가 본문을 모두 보내는 데 허용하는 시간과, 앞단이 백엔드 연결을 맺거나 응답을 기다리는 시간은 각각 다른 설정이다. 같은 이름의 제한이라도 전체 경과 시간을 재는 설정과 읽기 사이의 대기 시간을 재는 설정이 있을 수 있다. 이 장의 코드는 본문을 읽는 데 걸린 전체 시간과 뒤쪽 서버의 응답을 기다린 전체 시간을 정수 밀리초로 받는다. 앞의 시간이 한도를 넘으면 408, 뒤의 시간이 한도를 넘으면 504를 출력한다. 두 경우 모두 한도와 같은 값은 허용한다.

앞단이 연결에서 직접 확인한 상대 주소는 바로 앞 장비의 주소다. 브라우저가 앞단에 직접 연결하면 브라우저 쪽에서 연결을 맺은 주소가 보이고, 중간에 다른 프록시가 있으면 그 프록시 주소가 보인다. 뒤쪽 서버에 접속 주소를 알려 줄 때는 신뢰 경계를 정한다. 예제에는 바로 앞 장비가 하나만 있다고 가정하고, 지정된 프록시만 X-Forwarded-For로 주소 하나를 전달하도록 구성한다. 그 장비는 외부 요청에 붙어 있던 전달 헤더를 자신이 확인한 접속 주소로 덮어쓴다.

앞단은 신뢰 목록에 있는 바로 앞 프록시가 전달한 주소만 채택하고 그 밖의 연결에는 직접 확인한 주소를 사용한다.

앞단은 직접 연결한 상대가 신뢰 목록에 있고 헤더 값이 유효한 단일 IP 주소일 때 그 값을 채택한다. 그 밖의 경우에는 연결에서 확인한 주소를 사용한다. 실제 배치에서는 신뢰 목록에 등록한 주소로 연결할 수 있는 장비를 제어하고, 외부 요청이 주소를 확정하는 앞단을 건너뛰어 백엔드에 직접 도착하지 않게 한다. 이 예제의 단일 주소 규칙을 여러 프록시가 만드는 주소 목록에 그대로 적용하면 원하는 주소를 얻을 수 없다. 그런 배치에서는 각 장비가 헤더를 덮어쓰는지 이어 붙이는지 먼저 확인하고, 연결 지점에서 시작해 확인 가능한 프록시를 따라 주소를 해석한다.

상태 확인 결과로 요청을 분배하기

같은 주문 프로그램을 둘 이상 실행하면 앞단은 요청마다 보낼 대상을 고를 수 있다. 운영에서는 앞단이나 별도 구성요소가 주기적으로 준비 상태를 확인하고, 요청을 받을 수 있는 서버 목록을 갱신한다. 응답이 왔다는 이유로 주문을 맡길 수 있다고 판단하기 전에, 그 확인 경로가 어떤 조건을 검사하는지 살핀다. 이 서점이라면 주문을 처리하는 데 꼭 필요한 저장소 연결이 준비 상태 판단에 포함될 수 있다. 상태가 잠깐 흔들릴 때 서버가 목록에서 반복해 빠졌다 들어오지 않도록 연속 실패 횟수와 복귀 조건도 설정할 수 있다.

완성 코드에서는 요청 처리 시점에 이미 상태 확인이 끝났다고 가정한다. 분배기는 준비된 대상만 골라 그룹별로 순서대로 선택한다. 주문 서버 두 대 중 하나만 준비됐으면 그 서버를 택한다. 준비된 대상이 없으면 503을 반환한다. 준비 상태 확인과 실제 요청 사이에 장애가 생길 수도 있다. 예제에서 504를 받은 주문은 응답을 제때 받지 못했다는 뜻이다. 뒤쪽에서 주문 처리가 끝났는지는 그 상태 코드만으로 판단할 수 없으므로, 시뮬레이터는 다른 서버에 주문을 다시 보내지 않는다.

서점 앞단의 경로별 규칙과 제한
경로와 대상본문 한도본문 읽기백엔드 응답 대기
/static 아래의 공개 파일0바이트1,000밀리초해당 없음
/api/orders 아래의 주문 그룹2,048바이트2,000밀리초800밀리초
/api 아래의 도서 그룹512바이트1,000밀리초500밀리초
나머지 경로의 화면 그룹0바이트1,000밀리초500밀리초

표의 수치는 실행 결과를 확인하기 위해 정한 예제 설정값이다. 이 코드에서 본문 읽기와 응답 대기 값은 이미 측정된 값으로 주어지므로, 바로 같은 테이블을 사용해 크기·시간 제한의 경계를 확인할 수 있다.

완성 코드

main.py

요청과 상태 확인 결과를 코드 안에서 준비한 뒤 처리 함수를 직접 호출한다. 표지 파일 경로와 백엔드 이름은 시뮬레이션에 쓰는 값이다. TLS 연결과 응답 압축은 앞에서 설명한 운영 설정에 해당한다.

from dataclasses import dataclass
from ipaddress import ip_address


@dataclass(frozen=True)
class Rule:
    prefix: str
    target: str
    max_body: int
    read_limit_ms: int
    reply_limit_ms: int


@dataclass(frozen=True)
class Request:
    path: str
    body_bytes: int = 0
    read_ms: int = 0
    reply_ms: int = 0
    peer: str = "198.51.100.20"
    forwarded_for: str = ""


@dataclass(frozen=True)
class Backend:
    name: str
    ready: bool = True


@dataclass(frozen=True)
class Result:
    status: int
    destination: str
    client: str


RULES = (
    Rule("/static", "files", 0, 1000, 0),
    Rule("/api/orders", "orders", 2048, 2000, 800),
    Rule("/api", "books", 512, 1000, 500),
    Rule("/", "pages", 0, 1000, 500),
)
PUBLIC_FILES = {"/static/covers/python.jpg"}
TRUSTED_PROXIES = {"192.0.2.10"}


def matches(path, prefix):
    return prefix == "/" or path == prefix or path.startswith(prefix + "/")


def client_address(request):
    if request.peer in TRUSTED_PROXIES and request.forwarded_for:
        try:
            return str(ip_address(request.forwarded_for.strip()))
        except ValueError:
            return request.peer
    return request.peer


class Front:
    def __init__(self, groups):
        self.groups = groups
        self.next_index = dict.fromkeys(groups, 0)

    def choose_backend(self, group):
        ready = [node for node in self.groups[group] if node.ready]
        if not ready:
            return None
        index = self.next_index[group] % len(ready)
        self.next_index[group] = index + 1
        return ready[index]

    def handle(self, request):
        rule = next(rule for rule in RULES if matches(request.path, rule.prefix))
        client = client_address(request)

        if request.body_bytes > rule.max_body:
            return Result(413, "front", client)
        if request.read_ms > rule.read_limit_ms:
            return Result(408, "front", client)

        if rule.target == "files":
            if request.path in PUBLIC_FILES:
                return Result(200, "files", client)
            return Result(404, "files", client)

        backend = self.choose_backend(rule.target)
        if backend is None:
            return Result(503, rule.target, client)
        if request.reply_ms > rule.reply_limit_ms:
            return Result(504, backend.name, client)
        return Result(200, backend.name, client)


def main():
    front = Front({
        "pages": (Backend("pages-a"),),
        "books": (Backend("books-a"), Backend("books-b")),
        "orders": (Backend("orders-a", ready=False), Backend("orders-b")),
    })
    requests = (
        Request("/static/covers/python.jpg"),
        Request("/static/covers/missing.jpg"),
        Request("/api/books", peer="192.0.2.10",
                forwarded_for="203.0.113.7"),
        Request("/api/books", forwarded_for="203.0.113.7"),
        Request("/api/orders", body_bytes=2048, read_ms=2000, reply_ms=800),
        Request("/api/orders", body_bytes=2049),
        Request("/api/orders", body_bytes=64, read_ms=2001),
        Request("/api/orders", body_bytes=64, reply_ms=801),
        Request("/apiary"),
    )

    for request in requests:
        result = front.handle(request)
        print(f"{request.path} -> {result.status} {result.destination}"
              f" ip={result.client}")

    front.groups["orders"] = (Backend("orders-b", ready=False),)
    result = front.handle(Request("/api/orders"))
    print(f"/api/orders -> {result.status} {result.destination}"
          f" ip={result.client}")


if __name__ == "__main__":
    main()

줄별 해설

  1. Rule에서 경로 접두어, 처리 대상, 세 제한값을 한 줄의 데이터로 묶는다. RULES에서 /api/orders를 /api보다 앞에 둔다. handle의 next는 위에서부터 검사해 처음 일치하는 규칙을 잡는다. 마지막 / 규칙이 나머지 요청을 받는다.
  2. Request의 peer에는 연결 상대 주소를, forwarded_for에는 전달 헤더 값을 나누어 넣는다. client_address는 먼저 상대가 신뢰 목록에 있는지 본다. 이어 ip_address로 단일 IP 주소를 해석한다. 헤더가 비어 있거나 해석에 실패하면 peer를 반환한다.
  3. handle은 크기 검사, 본문 읽기 시간 검사 순서로 진행한다. 두 조건을 모두 위반한 입력에는 먼저 검사한 413을 반환한다. 조건식이 >이므로 한도에 도달한 요청은 다음 검사로 넘어간다. 이 우선순위는 이 모형의 규칙이다. 실제 서버에서 읽기 중 먼저 확인한 위반은 입력 도착 시점에 따라 달라질 수 있다.
  4. rule.target == "files"인 분기는 공개 목록에서 파일 경로를 찾고 결과를 반환한다. 이 분기에서 처리가 끝나므로 /static/covers/missing.jpg가 화면 그룹으로 넘어가지 않는다.
  5. choose_backend는 준비된 대상만 목록에 남긴다. next_index를 그룹마다 따로 두므로 도서 그룹에서 차례가 바뀌어도 주문 그룹의 차례는 그대로다. 나머지 연산으로 현재 목록에서 쓸 위치를 구한다. 구성원이나 상태가 바뀌면 새 목록의 크기로 위치를 다시 계산한다.
  6. handle은 준비된 대상이 없으면 뒤쪽 서버 이름 대신 그룹 이름을 결과에 넣는다. 대상이 있는 경우에만 응답 시간을 확인한다. 504 결과에는 실제로 선택한 서버 이름이 남는다. main의 마지막 요청은 주문 그룹에 준비된 서버가 하나도 없는 상태를 재현한다.

실행 결과

코드를 main.py로 저장하고 아래 명령을 실행한다. 첫 명령은 경고를 오류로 처리하며 문법을 검사한다. 성공하면 아무것도 출력하지 않는다. 두 번째 명령은 요청 열 건의 처리 결과를 출력하고 끝난다.

python3 -W error -m py_compile main.py
python3 main.py
/static/covers/python.jpg -> 200 files ip=198.51.100.20
/static/covers/missing.jpg -> 404 files ip=198.51.100.20
/api/books -> 200 books-a ip=203.0.113.7
/api/books -> 200 books-b ip=198.51.100.20
/api/orders -> 200 orders-b ip=198.51.100.20
/api/orders -> 413 front ip=198.51.100.20
/api/orders -> 408 front ip=198.51.100.20
/api/orders -> 504 orders-b ip=198.51.100.20
/apiary -> 200 pages-a ip=198.51.100.20
/api/orders -> 503 orders ip=198.51.100.20

두 도서 요청의 전달 헤더 값은 같다. 첫 번째 요청의 연결 상대는 신뢰 목록에 있으므로 헤더 값이 채택된다. 두 번째 요청은 직접 연결한 상대의 주소를 유지한다. 주문 요청에서는 크기와 두 시간 값이 각각 한도와 같은 첫 입력이 통과한다. 마지막 줄의 orders는 준비된 서버가 없어 그 그룹에 전달할 수 없었다는 표시다.

실무에서 자주 틀리는 것

문자열 접두어를 경로 경계로 사용한다

틀린 함수는 /apiary도 도서 API의 경로로 분류한다. 고친 함수에는 일치해야 할 경로 자체와 그 아래에 오는 슬래시 경계를 각각 적는다. 다음 코드는 두 함수에 같은 입력을 넣어 판단 차이를 검사한다.

def wrong_match(path, prefix):
    return path.startswith(prefix)


def fixed_match(path, prefix):
    return prefix == "/" or path == prefix or path.startswith(prefix + "/")


assert wrong_match("/apiary", "/api")
assert not fixed_match("/apiary", "/api")
assert fixed_match("/api", "/api")
assert fixed_match("/api/books", "/api")

한도에 닿은 요청을 거절한다

크기 설정을 ‘2,048바이트까지 허용’으로 합의했는데 >=로 거절 여부를 검사하면 정확히 2,048바이트인 주문도 거절한다. 한도 바로 아래, 한도, 한도 바로 위에 있는 본문을 검사하면 이 차이가 드러난다.

def wrong_reject(size, limit):
    return size >= limit


def fixed_reject(size, limit):
    return size > limit


assert wrong_reject(2048, 2048)
assert [fixed_reject(size, 2048) for size in (2047, 2048, 2049)] == [
    False, False, True
]

전달 헤더를 연결 상대보다 먼저 믿는다

틀린 함수는 전달 헤더에 값이 있으면 그 값의 출처를 살피지 않는다. 고친 함수는 신뢰하는 장비가 바로 앞에 있는지 검사하고, 주소가 하나의 IP로 해석되는지도 확인한다. 같은 헤더를 신뢰 목록에 포함된 상대와 포함되지 않은 상대의 입력으로 사용한다.

from ipaddress import ip_address


def wrong_ip(peer, forwarded, trusted):
    return forwarded or peer


def fixed_ip(peer, forwarded, trusted):
    if peer in trusted and forwarded:
        try:
            return str(ip_address(forwarded.strip()))
        except ValueError:
            return peer
    return peer


trusted = {"192.0.2.10"}
direct = "198.51.100.20"
forwarded = "203.0.113.7"
assert wrong_ip(direct, forwarded, trusted) == forwarded
assert fixed_ip(direct, forwarded, trusted) == direct
assert fixed_ip("192.0.2.10", forwarded, trusted) == forwarded
assert fixed_ip("192.0.2.10", "unknown", trusted) == "192.0.2.10"

한눈에 보기

AI에게 수정 사항을 맡길 때에는 적용 범위, 현재 동작, 경계값에서 기대하는 결과를 함께 적는다. 예를 들어 서점의 주문 본문 한도만 바꾸는 요청은 다음과 같이 쓸 수 있다.

main.py에서 주문 그룹의 본문 허용 한도를 4,096바이트로 올려 달라. 예제의 주문 크기 입력을 바꿔 4,096바이트는 통과하고 4,097바이트는 413이 나오도록 해 달라. 경로 선택 순서와 두 시간 제한도 변경 전후 비교에서 확인할 수 있게 설명해 달라.

수정본을 받으면 먼저 변경 전후의 코드 차이(diff)를 읽어 요청한 규칙과 예제 입력이 바뀌었는지 확인한다. 그런 다음 문법 검사 명령과 실행 명령을 다시 실행해 주문 두 건의 결과와 기존 시간 초과 결과를 비교한다. 실제 앞단 설정을 검토할 때는 코드의 모의 실행 결과와 별도로, 관리하는 환경에서 응답 헤더와 대상 선택 기록을 확인한다.

앞단 구성요소별 역할과 AI 수정본 검토 항목
구성요소맡길 일직접 확인할 것
TLS 종료인증서를 쓰는 연결 지점과 뒤쪽 연결 방식을 표시한다.브라우저와 앞단, 앞단과 백엔드의 연결을 각각 검토하고 암호화가 필요한 구간의 인증서 검증 설정을 확인한다.
정적 파일과 경로 분기공개 파일과 도서·주문 API의 경로 규칙을 작성한다.표지 경로의 200과 404, 주문 규칙의 우선순위, /apiary의 대상이 각각 예상과 일치하는지 실행한다.
압축압축할 응답 종류와 협상에 쓰는 헤더를 정리한다.gzip을 허용한 도서 목록과 JPEG 표지의 응답을 읽고 인코딩 및 캐시 구분 헤더를 확인한다.
크기와 시간 제한경로마다 값과 단위, 측정 구간을 적는다.변경 전후의 차이를 읽고 한도와 같은 입력 및 한도를 넘는 입력을 실행해 413, 408, 504를 구분한다.
접속 주소 전달헤더를 작성하는 장비와 그 장비의 주소를 명시한다.같은 헤더를 두 종류의 연결 상대에서 넣어 신뢰 목록에 따라 주소 선택이 달라지는지 검사한다.
상태 확인과 분배준비 상태를 확인할 기준과 그룹별 분배 규칙을 적는다.두 대가 준비된 상태, 한 대만 준비된 상태, 모두 빠진 상태를 실행해 대상 이름과 503을 비교한다.

연습 문제

  1. RULES에서 /api 규칙을 /api/orders 규칙 바로 앞으로 옮긴다. 2,048바이트인 주문 요청의 결과가 어떻게 바뀌는지 설명한다.
  2. /api/orders에 본문이 64바이트이고 본문 읽기에 2,001밀리초, 뒤쪽 응답 대기에 801밀리초가 걸린 입력을 넣는다. 결과의 상태 코드와 처리 위치를 예측한다.
  3. 신뢰하는 프록시 192.0.2.10이 203.0.113.7, 192.0.2.11이라는 전달 헤더 값을 보냈다. 이 코드가 채택할 주소와 이유를 설명한다.
  4. 저장소에 연결할 수 없는 주문 서버 한 대가 계속 준비 상태를 반환한다. 상태 확인에 어떤 조건을 추가할지 정하고, 두 대가 준비됐을 때부터 둘 다 준비되지 않을 때까지 확인할 예상 결과를 적는다.

정답과 해설

  1. 결과는 413 front로 바뀐다. /api/orders는 /api/로 시작한다. 첫 일치가 도서 규칙이 되면 본문 한도 512바이트가 적용된다. 규칙을 원래 순서로 돌린 뒤 같은 요청이 200 orders-b가 되는지 확인한다.
  2. 408 front가 나온다. 본문 크기는 한도 안에 있지만 읽기 시간이 2,000밀리초를 넘는다. 함수는 대상 선택 전에 반환한다. 읽기 값만 2,000으로 낮춰 다시 실행하면 선택한 주문 서버에서 응답 대기 한도를 넘긴 것으로 판단해 504 orders-b가 나온다.
  3. 192.0.2.10을 채택한다. 바로 앞 장비가 신뢰 목록에 있으므로 헤더 해석을 시도하지만, 쉼표로 연결된 주소 목록은 단일 IP 주소로 해석할 수 없다. 예외 처리에서 연결 상대 주소를 반환한다.
  4. 주문 처리에 필요한 저장소 연결을 확인한 결과를 준비 상태에 반영한다. 주문 그룹에 orders-a, orders-b 순서로 두 대를 준비시키고 새 분배기에 정상 요청 두 건을 넣으면 각각 200 orders-a, 200 orders-b가 나온다. orders-a만 준비 상태에서 빼면 다음 정상 요청은 200 orders-b가 된다. 두 대 모두 빼면 503 orders가 된다.

여기까지 살펴본 앞단은 주문을 받을 뒤쪽 서버를 고른다. 다음 장에서는 그 서버 안에서 주문 요청을 읽고, 업무 규칙을 적용하고, 데이터를 저장하는 코드를 어떻게 나눌지 살펴본다.

댓글 0

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

댓글을 남기려면 로그인이 필요합니다.