TCP와 UDP: 믿을 수 있는 전달과 빠른 전달

IP가 컴퓨터까지 데려다준 데이터를 어느 프로그램에, 어떻게 건넬지 정하는 TCP와 UDP를 비교해요. 실제 소켓으로 TCP가 메시지가 아닌 바이트의 흐름이라는 걸 확인하고, 연결을 맺는 세 번의 인사, 사라진 조각을 다시 보내는 과정, 손실이 나면 속도를 절반으로 줄이는 혼잡 제어를 시뮬레이션으로 따라가요. 창 크기와 왕복 시간이 속도의 한계를 정하는 이유, 연결 오류를 읽는 법, UDP와 QUIC이 쓰이는 곳까지 다뤄요.

중급강의 4 / 6약 17분

IP 주소는 데이터를 어느 컴퓨터까지 데려다줘요. 그런데 한 컴퓨터에서는 브라우저, 메신저, 게임이 동시에 돌아가요. 도착한 데이터를 어느 프로그램에 줄지, 가는 길에 사라지거나 순서가 뒤바뀐 조각은 어떻게 할지 정하는 층이 전송 계층이고, 대표 선수가 TCP와 UDP예요.

  • TCP: 등기 우편이에요. 받았는지 확인하고, 사라지면 다시 보내고, 순서를 맞춰서 건네줘요. 웹(HTTP/1.1, HTTP/2), 메일, 파일 전송, SSH가 써요.
  • UDP: 엽서예요. 보내면 끝이에요. 그 대신 빠르고 단순해요. DNS, 게임, 음성·영상 통화, HTTP/3가 써요.

포트: 컴퓨터 안의 어느 프로그램인지

IP 주소가 아파트 동이라면 포트는 호수예요. 0부터 65535까지의 번호이고, 서버 프로그램은 정해진 번호에서 손님을 기다려요.

포트쓰는 곳
22SSH(원격 접속)
53DNS
80HTTP
443HTTPS(HTTP/3는 같은 번호의 UDP)
3306, 5432MySQL, PostgreSQL 데이터베이스
3000, 5000, 8000, 8080개발용 서버가 자주 쓰는 번호

브라우저 같은 클라이언트 쪽은 연결할 때마다 운영체제가 높은 번호 중에서 빈 것을 골라 줘요(임시 포트). 그래서 연결 하나는 내 IP, 내 포트, 상대 IP, 상대 포트 네 가지 값으로 구별돼요. 서버가 443번 하나로 수만 명을 동시에 받을 수 있는 것도 손님마다 이 네 값의 조합이 다르기 때문이에요.

TCP는 흐름, UDP는 편지

같은 메시지 세 개를 TCP와 UDP로 각각 보내 볼게요.

import socket
import threading
import time

# TCP: 바이트가 이어진 흐름
srv = socket.create_server(("127.0.0.1", 0))
port = srv.getsockname()[1]

def tcp_server():
    conn, _ = srv.accept()
    time.sleep(0.3)                          # 잠깐 기다렸다가 한 번에 읽어요
    print("TCP로 받은 것:", conn.recv(1024))
    conn.close()

t = threading.Thread(target=tcp_server)
t.start()
cli = socket.create_connection(("127.0.0.1", port))
for msg in (b"hello", b"world", b"!"):
    cli.sendall(msg)                         # 세 번 나눠 보냈어요
t.join()
cli.close()
srv.close()

# UDP: 한 통 한 통 따로인 편지
u_srv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
u_srv.bind(("127.0.0.1", 0))
u_cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for msg in (b"hello", b"world", b"!"):
    u_cli.sendto(msg, u_srv.getsockname())
for _ in range(3):
    data, addr = u_srv.recvfrom(1024)
    print("UDP로 받은 것:", data)
u_cli.close()
u_srv.close()

# 아무도 기다리지 않는 포트에 TCP로 연결하면
closed = socket.create_server(("127.0.0.1", 0))
closed_port = closed.getsockname()[1]
closed.close()                               # 방금 쓴 포트를 닫아서 빈 포트로 만들어요
try:
    socket.create_connection(("127.0.0.1", closed_port), timeout=5)
except OSError as e:
    print("빈 포트에 연결:", type(e).__name__)
TCP로 받은 것: b'helloworld!'
UDP로 받은 것: b'hello'
UDP로 받은 것: b'world'
UDP로 받은 것: b'!'
빈 포트에 연결: ConnectionRefusedError

TCP로 세 번 나눠 보냈는데 받는 쪽에는 한 덩어리로 왔어요. TCP는 메시지를 주고받는 게 아니라 바이트가 이어진 흐름을 건네줘요. 수도관처럼, 나눠 부은 물이 받는 쪽에서는 그냥 이어진 물로 나와요. 반대로 한 번에 보낸 큰 데이터가 여러 번에 나뉘어 도착하기도 해요. 예제에서는 받는 쪽이 잠깐 기다렸다 읽게 해서 일부러 드러냈지만, 실제로도 언제든 일어나는 일이에요. recv 한 번이 메시지 하나라고 믿고 짠 프로그램은 내 컴퓨터에서는 잘 되다가 느린 네트워크에서 갑자기 깨져요.

UDP는 보낸 단위(데이터그램) 그대로 한 통씩 왔어요. 다만 이 실험은 같은 컴퓨터 안이라 다 도착한 거예요. 실제 네트워크에서는 한 통이 사라지거나 순서가 바뀌어도 UDP는 알려 주지 않아요.

마지막 줄은 아무도 기다리지 않는 포트에 TCP로 연결한 결과예요. 상대 컴퓨터가 "그 번호에는 아무도 없어요"라고 거절(RST)해서 ConnectionRefusedError가 났어요. 서버를 켜지 않았거나 포트 번호를 잘못 적었을 때 만나는 오류예요.

메시지의 경계는 직접 정해요

그래서 TCP 위의 프로토콜은 저마다 메시지의 경계를 정하는 약속이 있어요. HTTP는 빈 줄과 Content-Length로 정하고, 많은 프로그램은 메시지 앞에 길이를 붙여요.

import struct

def pack(msg: bytes) -> bytes:
    return struct.pack("!I", len(msg)) + msg      # 앞 4바이트에 길이를 적어요

def unpack_all(stream: bytes):
    messages = []
    while len(stream) >= 4:
        (n,) = struct.unpack("!I", stream[:4])
        if len(stream) < 4 + n:                   # 아직 덜 왔으면 기다려요
            break
        messages.append(stream[4:4 + n].decode())
        stream = stream[4 + n:]
    return messages, stream

stream = pack(b"hello") + pack(b"world") + pack("한글도 돼요".encode())
print(stream[:13])
got, rest = unpack_all(stream[:-3])               # 마지막 3바이트가 아직 안 왔다면
print(got, "| 남은 바이트:", len(rest))
got, rest = unpack_all(rest + stream[-3:])        # 나머지가 도착했어요
print(got, "| 남은 바이트:", len(rest))
b'\x00\x00\x00\x05hello\x00\x00\x00\x05'
['hello', 'world'] | 남은 바이트: 17
['한글도 돼요'] | 남은 바이트: 0

메시지마다 앞 4바이트에 길이를 적었어요(\x00\x00\x00\x05는 5). 마지막 메시지가 덜 왔을 때는 완성된 두 개만 꺼내고 남은 17바이트는 들고 기다렸다가, 나머지가 오자 마저 꺼냈어요. "!I"의 !는 네트워크 바이트 순서(큰 자리부터)로 적으라는 뜻이에요. 컴퓨터마다 여러 바이트짜리 숫자를 메모리에 놓는 순서가 달라서, 네트워크에서는 큰 자리부터 보내기로 약속했어요.

TCP의 약속 1: 연결을 먼저 맺어요

TCP는 데이터를 보내기 전에 세 번 인사를 나눠요. 이걸 3방향 핸드셰이크라고 해요.

1. 클라이언트 → 서버   SYN       "연결할래요. 내 번호는 1000부터 셀게요."
2. 서버 → 클라이언트   SYN+ACK   "좋아요, 다음엔 1001번을 주세요. 내 번호는 5000부터예요."
3. 클라이언트 → 서버   ACK       "알겠어요, 다음엔 5001번을 주세요."
   (이제부터 데이터를 주고받아요)

세 번인 이유는 양쪽 모두 "내가 보낸 게 상대에게 가고, 상대가 보낸 게 나에게 온다"를 확인하고, 서로 몇 번부터 셀지 맞춰야 하기 때문이에요. 시작 번호는 짐작하기 어렵게 무작위로 정해요. 남이 끼어들어 가짜 조각을 밀어 넣기 어렵게 하려는 거예요.

이 인사에는 왕복 한 번의 시간이 들어요. HTTPS라면 그 위에서 암호화를 위한 인사(TLS)가 한 번 더 필요해요. 첫 응답을 받기까지 걸리는 시간을 대략 계산해 볼게요.

for name, rtt in (("같은 도시", 5), ("서울에서 도쿄", 35), ("서울에서 미국 서부", 150)):
    tcp_tls = 3 * rtt       # TCP 악수 1번 + TLS 1.3 악수 1번 + 요청과 응답 1번
    quic = 2 * rtt          # QUIC은 연결과 암호화 악수를 한 번에 + 요청과 응답 1번
    print(f"{name} (왕복 {rtt}ms): TCP+TLS {tcp_tls}ms, QUIC {quic}ms")
같은 도시 (왕복 5ms): TCP+TLS 15ms, QUIC 10ms
서울에서 도쿄 (왕복 35ms): TCP+TLS 105ms, QUIC 70ms
서울에서 미국 서부 (왕복 150ms): TCP+TLS 450ms, QUIC 300ms

먼 서버는 데이터를 한 글자도 받기 전에 인사에만 0.3초 넘게 써요. 실제 왕복 시간은 앞 강의에서 계산한 빛의 최소 시간보다 길어요(경로가 돌아가고 장비를 여럿 거치니까요). 그래서 브라우저는 한 번 맺은 연결을 여러 요청에 다시 쓰고(keep-alive), 사이트는 CDN으로 서버를 사용자 가까이에 두고, HTTP/3의 QUIC은 연결과 암호화 인사를 한 번에 끝내요. 전에 접속한 적 있는 서버라면 QUIC은 첫 요청을 인사와 함께 실어 보내는 0-RTT도 할 수 있어요.

TCP의 약속 2: 빠짐없이, 순서대로

인터넷은 조각(패킷)을 최선을 다해 나를 뿐, 사라지거나 순서가 바뀌는 일을 막아 주지 않아요. TCP는 조각마다 번호를 붙이고, 받는 쪽은 "여기까지 잘 받았으니 다음엔 몇 번을 주세요"라는 확인 응답(ACK)을 돌려줘요. 조각 하나가 사라지는 상황을 시뮬레이션해 볼게요. 실제 TCP는 조각 번호 대신 바이트 위치로 세지만 원리는 같아요.

from collections import deque

segments = ["HTTP는", " TCP", " 덕분에", " 순서대로", " 빠짐없이", " 도착해요"]
WINDOW = 4                         # 확인을 기다리지 않고 한꺼번에 보낼 수 있는 조각 수
lost = {2}                         # 2번 조각은 처음 보낼 때 사라져요

net = deque()                      # 지금 네트워크 위를 지나는 것들 (보낸 순서대로 도착)
base, next_seq, dup_acks = 0, 0, 0 # 보내는 쪽: 확인 못 받은 첫 번호, 다음에 보낼 번호
buffer, expected, delivered = {}, 0, []   # 받는 쪽

def send(seq, again=False):
    if seq in lost and not again:
        print(f"→ {seq}번 보냄 ... 가는 길에 사라짐")
        return
    print(f"→ {seq}번 보냄" + (" (다시 보냄)" if again else ""))
    net.append(("data", seq))

while base < len(segments):
    while next_seq < len(segments) and next_seq < base + WINDOW:
        send(next_seq)
        next_seq += 1
    kind, n = net.popleft()
    if kind == "data":                                   # 받는 쪽
        buffer[n] = segments[n]
        ready = []
        while expected in buffer:                        # 빈칸 없이 이어진 만큼만 앱에 넘겨요
            ready.append(expected)
            delivered.append(buffer.pop(expected))
            expected += 1
        note = f"앱에 넘김 {ready}" if ready else f"{expected}번이 비어서 보관"
        print(f"    {n}번 받음, {note}, ACK {expected}")
        net.append(("ack", expected))
    elif n > base:                                       # 보내는 쪽: 새 확인
        base, dup_acks = n, 0
    else:                                                # 보내는 쪽: 같은 확인이 또 옴
        dup_acks += 1
        if dup_acks == 3:
            print(f"← 같은 확인(ACK {n})이 세 번 더 옴: {n}번을 바로 다시 보내요")
            send(n, again=True)

print("받은 글:", "".join(delivered))
→ 0번 보냄
→ 1번 보냄
→ 2번 보냄 ... 가는 길에 사라짐
→ 3번 보냄
    0번 받음, 앱에 넘김 [0], ACK 1
    1번 받음, 앱에 넘김 [1], ACK 2
    3번 받음, 2번이 비어서 보관, ACK 2
→ 4번 보냄
→ 5번 보냄
    4번 받음, 2번이 비어서 보관, ACK 2
    5번 받음, 2번이 비어서 보관, ACK 2
← 같은 확인(ACK 2)이 세 번 더 옴: 2번을 바로 다시 보내요
→ 2번 보냄 (다시 보냄)
    2번 받음, 앱에 넘김 [2, 3, 4, 5], ACK 6
받은 글: HTTP는 TCP 덕분에 순서대로 빠짐없이 도착해요
  • 창: 보내는 쪽은 확인을 기다리지 않고 4조각까지 한꺼번에 보내요. 하나 보내고 확인을 기다리기를 반복하면 왕복 한 번에 한 조각밖에 못 보내니까요. 확인이 올 때마다 창이 앞으로 밀려서 4번, 5번을 이어 보냈어요.
  • 2번이 사라지자 받는 쪽은 3, 4, 5번을 받고도 계속 "ACK 2", 즉 "2번을 주세요"라고 답해요. 3, 4, 5번은 버리지 않고 보관해 둬요.
  • 보내는 쪽은 같은 확인이 세 번 더 오자, 시간 초과를 기다리지 않고 2번을 바로 다시 보내요. 이걸 빠른 재전송이라고 해요. 2번이 도착하는 순간 보관해 둔 3, 4, 5번까지 한꺼번에 앱으로 넘어가고, 확인은 ACK 6으로 껑충 뛰어요.
  • 뒤따르는 조각이 없어서 중복 확인조차 오지 않으면, 보내는 쪽은 정해 둔 시간(재전송 타이머)이 지나서야 다시 보내요. 이때는 훨씬 오래 걸려요.

여기서 TCP의 약점도 보여요. 3, 4, 5번은 일찍 도착했는데도 2번 하나 때문에 앱으로 넘어가지 못하고 기다렸어요. 맨 앞이 막혀서 뒤가 다 기다리는 이 현상을 HOL 블로킹(head-of-line blocking)이라고 해요. HTTP/2는 연결 하나에 여러 요청을 섞어 보내기 때문에, 조각 하나가 사라지면 그 연결의 모든 요청이 함께 멈춰요. HTTP/3의 QUIC은 요청마다 흐름을 따로 관리해서, 사라진 조각과 상관없는 요청은 기다리지 않게 했어요.

TCP의 약속 3: 속도를 조절해요

보내는 쪽이 무작정 빠르게 보내면 두 군데서 넘쳐요.

  • 받는 쪽: 받는 프로그램이 처리하는 속도보다 빨리 오면 버퍼가 넘쳐요. 그래서 받는 쪽은 ACK마다 "지금 이만큼 더 받을 수 있어요"(수신 창)를 알려 줘요. 이게 흐름 제어예요.
  • 네트워크: 중간의 공유기와 회선이 감당하지 못하면 조각이 버려져요. 보내는 쪽은 네트워크 상태를 직접 볼 수 없으니 조심스럽게 늘려 보다가 손실이 생기면 줄여요. 이게 혼잡 제어예요.
cwnd, ssthresh = 1, 16
for rnd in range(1, 15):
    loss = rnd == 9
    print(f"{rnd:2}  cwnd {cwnd:2}  " + "■" * cwnd + ("  ← 손실! 절반으로" if loss else ""))
    if loss:
        ssthresh = cwnd // 2
        cwnd = ssthresh
    elif cwnd < ssthresh:
        cwnd *= 2              # 느린 시작: 왕복마다 두 배
    else:
        cwnd += 1              # 혼잡 회피: 왕복마다 하나씩
 1  cwnd  1  ■
 2  cwnd  2  ■■
 3  cwnd  4  ■■■■
 4  cwnd  8  ■■■■■■■■
 5  cwnd 16  ■■■■■■■■■■■■■■■■
 6  cwnd 17  ■■■■■■■■■■■■■■■■■
 7  cwnd 18  ■■■■■■■■■■■■■■■■■■
 8  cwnd 19  ■■■■■■■■■■■■■■■■■■■
 9  cwnd 20  ■■■■■■■■■■■■■■■■■■■■  ← 손실! 절반으로
10  cwnd 10  ■■■■■■■■■■
11  cwnd 11  ■■■■■■■■■■■
12  cwnd 12  ■■■■■■■■■■■■
13  cwnd 13  ■■■■■■■■■■■■■
14  cwnd 14  ■■■■■■■■■■■■■■

혼잡 창(cwnd)은 확인 없이 한꺼번에 보낼 수 있는 양이에요. 처음에는 왕복마다 두 배로 늘리고(느린 시작, 이름과 달리 빠르게 늘어요), 기준선(ssthresh, 여기서는 16)에 닿으면 왕복마다 하나씩만 늘려요. 9번째 왕복에서 손실이 생기자 절반으로 줄이고 다시 천천히 늘려요. 이걸 오래 그리면 톱니 모양이 돼요. 손실을 혼잡의 신호로 읽고 "조금씩 늘리고, 문제가 생기면 크게 줄이는" 이 방식 덕분에 수많은 사람이 같은 회선을 나눠 써도 인터넷이 무너지지 않아요.

실제로는 처음부터 10조각 정도로 시작하고, 요즘 운영체제는 CUBIC처럼 더 다듬은 방식을 써요. 구글의 BBR처럼 손실 대신 대역폭과 지연을 재서 속도를 정하는 방식도 있어요. 재전송 타이머가 끝날 만큼 심각한 손실이면 창을 처음 크기로 되돌리기도 해요.

창 크기와 왕복 시간이 정하는 속도

확인을 기다리지 않고 보낼 수 있는 양이 정해져 있으니, 한 연결의 속도는 회선이 아무리 빨라도 창 크기를 왕복 시간으로 나눈 값을 넘지 못해요.

window = 65_535                                # 바이트
for rtt_ms in (10, 100, 200):
    mbps = window * 8 / (rtt_ms / 1000) / 1_000_000
    print(f"창 64KB, 왕복 {rtt_ms}ms → 최대 {mbps:.1f}Mbps")
need = 1_000_000_000 / 8 * 0.1
print(f"왕복 100ms에서 1Gbps를 채우려면 창이 {need / 1_000_000:.1f}MB 필요해요")
창 64KB, 왕복 10ms → 최대 52.4Mbps
창 64KB, 왕복 100ms → 최대 5.2Mbps
창 64KB, 왕복 200ms → 최대 2.6Mbps
왕복 100ms에서 1Gbps를 채우려면 창이 12.5MB 필요해요

TCP 머리말의 창 칸은 원래 16비트라 최대 64KB였어요. 이대로라면 기가 인터넷을 쓰더라도 먼 서버에서는 몇 Mbps밖에 안 나와요. 그래서 지금은 창 크기에 배수를 곱하는 옵션(window scaling)으로 몇 MB가 넘는 창을 써요. "인터넷은 빠른데 해외 서버에서 받는 것만 느리다"면 회선보다 왕복 시간과 창 크기, 손실을 의심해 볼 만해요. 여러 연결로 나눠 받는 다운로드 프로그램이 빠른 이유도 여기에 있어요.

연결 끊기와 흔한 오류

  • 정상 종료: 양쪽이 각각 "더 보낼 게 없어요"(FIN)를 보내고 확인을 받아요. 먼저 끊은 쪽은 늦게 도착할지 모르는 조각을 위해 잠시 TIME_WAIT 상태로 기다려요.
  • 강제 종료: 프로그램이 죽거나 연결을 받을 수 없을 때는 RST로 바로 끊어요. 파이썬에서는 ConnectionResetError(연결 중에 끊김)나 ConnectionRefusedError(처음부터 거절)로 보여요.
  • 응답 없음: 방화벽이 조각을 조용히 버리면 거절도 없이 기다리기만 해요. 그래서 타임아웃이 필요해요. 거절이면 "서버 프로그램이 안 떠 있다", 무응답이면 "방화벽이나 경로 문제"일 가능성이 커서, 둘을 구별하면 원인을 빨리 좁힐 수 있어요.
  • 포트가 이미 사용 중: 서버를 켤 때 Address already in use(윈도는 WinError 10048)가 나면, 그 포트를 다른 프로그램이나 아직 살아 있는 예전 실행이 쓰고 있는 거예요.

지금 열린 연결과 기다리는 포트는 이렇게 확인해요.

$ ss -tlnp                       # 리눅스: 기다리는(LISTEN) TCP 포트와 프로그램
$ ss -tan                        # 리눅스: 모든 TCP 연결과 상태
$ lsof -iTCP:8000 -sTCP:LISTEN   # 맥: 8000번에서 기다리는 프로그램
netstat -ano | findstr :8000     # 윈도 명령 프롬프트: 8000번 연결과 프로세스 번호(PID)

상태 이름으로는 LISTEN(손님 기다리는 중), ESTABLISHED(연결됨), TIME_WAIT(끊고 잠시 대기)를 자주 보게 돼요.

UDP는 언제 쓰나요

구분TCPUDP
연결먼저 맺어요없어요, 바로 보내요
도착 보장사라지면 다시 보내요없어요
순서맞춰서 건네줘요도착한 대로
메시지 경계없어요(바이트 흐름)보낸 단위 그대로
속도 조절흐름 제어, 혼잡 제어없어요(앱이 알아서)
머리말 크기20바이트 이상8바이트

UDP가 어울리는 곳은 늦게 온 데이터가 쓸모없는 곳이에요.

  • 음성·영상 통화, 게임: 0.5초 전의 목소리나 캐릭터 위치를 다시 받아 봤자 소용없어요. 사라진 조각은 건너뛰고 최신 데이터를 보내는 편이 나아요. 다시 보내느라 모두가 기다리는 TCP는 오히려 끊김을 만들어요.
  • DNS: 질문 하나, 답 하나로 끝나는 짧은 대화라 연결을 맺는 비용이 아까워요. 답이 안 오면 다시 물으면 돼요. 답이 너무 크면 TCP로 바꿔서 물어요.
  • QUIC(HTTP/3): UDP 위에 재전송, 순서, 혼잡 제어를 직접 다시 만들었어요. 운영체제 깊숙이 들어 있는 TCP를 바꾸는 일은 아주 느리지만, UDP 위의 프로그램은 앱과 함께 빠르게 고쳐 나갈 수 있기 때문이에요.

UDP를 쓴다고 신뢰성이 필요 없는 게 아니에요. 필요한 만큼만 앱이 직접 챙기는 거예요.

실습

  1. 첫 번째 예제에서 서버의 time.sleep(0.3)을 지우고 여러 번 실행해 보세요. TCP로 받은 결과가 매번 같나요?
  2. 손실 시뮬레이션에서 lost = {2}를 {5}로 바꿔 보세요. 마지막 조각이 사라지면 중복 확인이 오지 않아서, 네트워크가 비어 버린 채 IndexError가 나요. 아무 확인도 오지 않는 바로 그 상황이에요. 네트워크가 비면 base번을 다시 보내는 시간 초과 처리를 넣어 보세요.
  3. 혼잡 제어 시뮬레이션에서 손실이 4번째와 11번째 왕복에 생기도록 바꿔 보세요. 처음 기준선을 8로 바꾸면 그래프가 어떻게 달라지나요?
  4. ss -tan이나 netstat -an으로 지금 내 컴퓨터의 연결을 보세요. ESTABLISHED인 연결의 상대 포트는 주로 몇 번인가요?
  5. 길이 붙이기 방식으로 첫 번째 예제의 TCP 서버가 세 메시지를 정확히 나눠 읽도록 고쳐 보세요.

자주 하는 오해

  • "send 한 번이 recv 한 번이다." TCP는 흐름이라 붙거나 쪼개져서 와요. 경계는 직접 정해요.
  • "UDP는 믿을 수 없으니 쓰면 안 된다." 늦은 데이터가 쓸모없는 곳에서는 UDP가 더 나아요. 필요한 신뢰성은 앱이 챙겨요.
  • "회선이 빠르면 어느 서버에서든 빠르다." 한 연결의 속도는 창 크기, 왕복 시간, 손실이 함께 정해요.
  • "연결 거부와 무응답은 같은 오류다." 거부는 상대가 포트가 닫혔다고 답한 것이고, 무응답은 중간에서 막혔을 가능성이 커요.

점검 문제

  1. 연결 하나를 구별하는 네 가지 값은?
  2. 첫 번째 예제에서 TCP는 한 덩어리로, UDP는 세 통으로 받은 이유는?
  3. 3방향 핸드셰이크가 필요한 이유는?
  4. 시뮬레이션에서 보내는 쪽이 2번을 다시 보내기로 한 신호는? 그 신호가 오지 않으면 어떻게 되나요?
  5. HOL 블로킹이란 무엇이고, HTTP/3는 이를 어떻게 줄였나요?
  6. 흐름 제어와 혼잡 제어의 차이는?
  7. 창 64KB, 왕복 200ms인 연결의 최대 속도는 대략 얼마인가요?
  8. 음성 통화에 UDP가 어울리는 이유는?

정답

  1. 내 IP, 내 포트, 상대 IP, 상대 포트예요.
  2. TCP는 메시지 경계 없이 바이트를 이어진 흐름으로 건네주고, UDP는 보낸 단위(데이터그램)를 그대로 지키기 때문이에요.
  3. 양쪽이 서로 보내고 받을 수 있는지 확인하고, 각자 몇 번부터 셀지 맞추기 위해서예요.
  4. 같은 확인(ACK 2)이 세 번 더 온 것이에요. 그 신호가 오지 않으면 재전송 타이머가 끝날 때까지 기다렸다가 다시 보내요.
  5. 앞 조각 하나가 사라지면 이미 도착한 뒤 조각들까지 앱으로 넘어가지 못하고 기다리는 현상이에요. HTTP/3의 QUIC은 요청마다 흐름을 따로 관리해서 상관없는 요청은 기다리지 않게 했어요.
  6. 흐름 제어는 받는 쪽이 감당할 만큼만 보내게 하는 것(수신 창)이고, 혼잡 제어는 네트워크가 감당할 만큼만 보내게 하는 것(혼잡 창)이에요.
  7. 65,535바이트 × 8 ÷ 0.2초로 약 2.6Mbps예요.
  8. 늦게 도착한 목소리는 쓸모가 없어서, 다시 보내며 기다리는 것보다 사라진 조각을 건너뛰고 최신 데이터를 보내는 편이 낫기 때문이에요.

다음 강의

지금까지 본 TCP 조각은 지나가는 길의 누구든 열어 볼 수 있어요. 카페 와이파이에서 비밀번호가 그대로 보인다면 큰일이겠죠. 다음 강의에서는 HTTPS를 만드는 TLS가 상대가 진짜인지 어떻게 확인하고(인증서), 엿볼 수 없게 어떻게 감싸는지(암호화) 직접 확인해요.