🔌

gRPC 시작하기 - HTTP/1.1의 한계와 HTTP/2.0

최민석·2026-04-14

gRPC 시작하기 - HTTP/1.1의 한계와 HTTP/2.0

gRPC

🔌 gRPC with Go 시리즈

개요

gRPC는 Google이 만든 고성능 RPC 프레임워크로, HTTP/2.0과 Protocol Buffers를 기반으로 동작합니다. 이번 포스팅 시리즈에서는 gRPC의 배경 지식부터 Go를 활용한 실전 구현까지를 다룹니다. 첫 번째 글에서는 gRPC가 왜 HTTP/2.0 위에서 동작하는지 이해하기 위해, HTTP/1.1의 한계와 HTTP/2.0이 이를 어떻게 해결하는지를 살펴봅니다.


HTTP/1.1의 한계

HTTP/1.1은 1997년에 표준화된 프로토콜입니다. 20년 넘게 웹의 기반을 지탱해왔지만, 현대의 마이크로서비스 아키텍처에서는 명확한 한계가 드러납니다.

텍스트 기반 프로토콜

HTTP/1.1의 요청과 응답은 사람이 읽을 수 있는 텍스트 형태입니다.

GET /api/todos HTTP/1.1\r\n
Host: api.example.com\r\n
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...\r\n
Content-Type: application/json\r\n
Accept: application/json\r\n
\r\n

디버깅에는 편리하지만, 기계 입장에서는 비효율적입니다.

  • 파싱 비용: 줄바꿈(\r\n)을 찾아가며 텍스트를 해석해야 합니다. 바이너리라면 고정 크기 필드를 바로 읽을 수 있습니다.
  • 공간 낭비: 헤더 이름(Content-Type, Authorization 등)이 매번 문자열 그대로 전송됩니다.

HOL(Head-of-Line) 블로킹

하나의 TCP 커넥션에서 요청과 응답은 순서대로 처리됩니다.

sequenceDiagram participant C as 클라이언트 participant S as 서버 C->>S: 요청 A Note right of S: A 처리 중... 3초 소요 S-->>C: 응답 A C->>S: 요청 B Note right of S: B 처리 중... 1ms S-->>C: 응답 B

요청 A의 처리가 3초 걸리면, 1ms 만에 끝나는 요청 B도 A가 끝날 때까지 기다려야 합니다. 이것이 HOL(Head-of-Line) 블로킹입니다.

커넥션 하나에서 요청이 "줄을 서서" 처리되기 때문에, 앞의 요청이 느리면 뒤의 모든 요청이 지연됩니다.

다중 커넥션으로의 우회

브라우저는 이 문제를 우회하기 위해 같은 서버에 6~8개의 TCP 커넥션을 동시에 엽니다.

sequenceDiagram participant C as 클라이언트 participant S as 서버 par 커넥션 1 C->>S: 요청 A S-->>C: 응답 A and 커넥션 2 C->>S: 요청 B S-->>C: 응답 B and 커넥션 3 C->>S: 요청 C S-->>C: 응답 C end

A가 느려도 B는 다른 커넥션에서 처리되므로 영향을 받지 않습니다. 하지만 이 접근에는 문제가 있습니다.

  • 핸드셰이크 비용: TCP 커넥션마다 3-way 핸드셰이크가 필요합니다. TLS를 사용한다면 TLS 핸드셰이크까지 추가됩니다.
  • 서버 자원 소모: 커넥션 수만큼 서버의 소켓과 메모리를 점유합니다. 클라이언트가 수천 대라면 커넥션 수는 기하급수적으로 늘어납니다.
  • 근본 해결이 아님: 커넥션 수에는 한계가 있으므로, 동시 요청이 그 수를 넘으면 다시 같은 문제가 발생합니다.

헤더 중복

같은 서버에 요청을 보낼 때마다, 거의 동일한 헤더가 매번 반복 전송됩니다.

-- 요청 1 --
GET /todos HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
Accept: application/json
User-Agent: Mozilla/5.0 (Macintosh; ...)
Cookie: session=abc123; theme=dark

-- 요청 2 --
GET /todos/1 HTTP/1.1
Host: api.example.com                        ← 동일
Authorization: Bearer eyJhbGciOiJIUzI1NiIs... ← 동일
Accept: application/json                      ← 동일
User-Agent: Mozilla/5.0 (Macintosh; ...)     ← 동일
Cookie: session=abc123; theme=dark            ← 동일

경로만 다르고 나머지는 전부 같은데 매번 전송합니다. JWT 토큰이나 쿠키가 큰 경우, 헤더만으로 수백 바이트에서 수 KB에 달할 수 있습니다. 마이크로서비스 간의 통신에서 초당 수천 건의 요청이 오갈 때 이 중복은 무시할 수 없는 오버헤드가 됩니다.

단방향 통신

HTTP/1.1은 항상 클라이언트가 요청하고 서버가 응답하는 구조입니다. 서버가 먼저 클라이언트에게 데이터를 보낼 수 없습니다.

이를 우회하기 위해 여러 방법이 사용되어 왔습니다.

방법 동작 단점
폴링(Polling) 클라이언트가 주기적으로 "새 데이터 있어?" 요청 데이터가 없어도 요청을 보내므로 낭비
롱 폴링(Long Polling) 서버가 데이터가 생길 때까지 응답을 지연 커넥션을 오래 점유. 타임아웃 관리 필요
WebSocket HTTP를 WebSocket 프로토콜로 업그레이드 HTTP가 아닌 별도 프로토콜. 인프라 호환성 문제

어느 방법이든 HTTP/1.1의 요청-응답 모델을 벗어나기 위한 우회이며, 각각의 트레이드오프가 있습니다.


HTTP/2.0이 해결한 것

2015년에 표준화된 HTTP/2.0은 위의 한계들을 프로토콜 수준에서 해결합니다. 기존 HTTP의 의미(메서드, 상태 코드, 헤더 등)는 그대로 유지하면서, 전송 방식을 근본적으로 바꾸었습니다.

바이너리 프레이밍 (Binary Framing)

HTTP/2.0은 텍스트 대신 바이너리 프레임 단위로 데이터를 전송합니다.

HTTP/1.1 (텍스트):
GET /todos HTTP/1.1\r\n
Host: api.example.com\r\n
\r\n

HTTP/2.0 (바이너리 프레임):
┌──────────┬────────┬──────────┐
│ Length(3)│Type(1) │ Flags(1) │  ← 9바이트 고정 헤더
├──────────┴────────┴──────────┤
│ Stream Identifier (4)        │
├──────────────────────────────┤
│ Frame Payload (가변)          │
└──────────────────────────────┘
  • 파싱이 빠름: 고정 크기 필드를 바로 읽으면 됩니다. 줄바꿈을 찾아다닐 필요가 없습니다.
  • 효율적: 바이너리이므로 텍스트보다 공간을 적게 차지합니다.

프레임의 Type 필드로 이 프레임이 헤더인지(HEADERS), 본문인지(DATA), 설정인지(SETTINGS) 등을 구분합니다.

멀티플렉싱 (Multiplexing)

HTTP/2.0의 핵심 기능입니다. 하나의 TCP 커넥션에서 여러 요청과 응답을 동시에 주고받을 수 있습니다.

HTTP/1.1 — 커넥션당 순차 처리:

sequenceDiagram participant C as 클라이언트 participant S as 서버 rect rgb(255, 230, 230) Note over C,S: 커넥션 1 C->>S: 요청 A S-->>C: 응답 A C->>S: 요청 B S-->>C: 응답 B end rect rgb(230, 230, 255) Note over C,S: 커넥션 2 C->>S: 요청 C S-->>C: 응답 C end

HTTP/2.0 — 하나의 커넥션에서 멀티플렉싱:

sequenceDiagram participant C as 클라이언트 participant S as 서버 Note over C,S: 단일 커넥션 par 스트림 1 C->>S: 요청 A and 스트림 2 C->>S: 요청 B and 스트림 3 C->>S: 요청 C end S-->>C: 응답 A (스트림 1) S-->>C: 응답 C (스트림 3) Note right of S: B보다 C가 먼저 올 수 있음 S-->>C: 응답 B (스트림 2)

각 요청-응답 쌍은 스트림(Stream) 이라는 논리적 채널에 배정됩니다. 각 스트림은 고유 ID를 가지며, 프레임에 스트림 ID가 포함되어 있어 서로 구분됩니다.

이것이 가능한 이유는 바이너리 프레이밍 덕분입니다. 프레임 단위로 잘게 쪼개져 있으므로, 서로 다른 스트림의 프레임을 인터리빙(interleaving) 하여 하나의 커넥션에 섞어 보낼 수 있습니다.

이로써:

  • HOL 블로킹 해결: 요청 A가 느려도 B, C는 독립적으로 처리됩니다.
  • 다중 커넥션 불필요: 하나의 커넥션으로 충분합니다. 핸드셰이크 비용과 서버 자원 소모가 대폭 줄어듭니다.

헤더 압축 (HPACK)

HTTP/2.0은 HPACK이라는 헤더 압축 알고리즘을 사용합니다.

클라이언트와 서버가 헤더 테이블을 공유하며, 이전에 보낸 헤더를 기억합니다.

-- 첫 번째 요청 --
:method: GET
:path: /todos
authorization: Bearer eyJhbGci...
(전체 전송)

-- 두 번째 요청 --
:path: /todos/1
(나머지는 "이전과 동일" → 인덱스 번호만 전송)

변경된 헤더만 전송하고, 나머지는 인덱스 번호로 참조합니다. Kafka에서 Avro + Schema Registry가 스키마 ID만 전송하여 페이로드를 줄이는 것과 비슷한 발상입니다.

이를 통해 헤더 중복 문제가 해결되며, 특히 JWT 토큰처럼 큰 헤더가 반복될 때 효과가 극대화됩니다.

서버 푸시 (Server Push)

서버가 클라이언트의 요청 없이 데이터를 먼저 보낼 수 있습니다.

sequenceDiagram participant C as 클라이언트 participant S as 서버 C->>S: GET /index.html S-->>C: 응답: index.html S-->>C: 푸시: style.css S-->>C: 푸시: main.js Note left of C: 요청하지 않았지만<br/>서버가 미리 전송

🌱 단, 서버 푸시는 실제로는 브라우저 환경에서 기대만큼 효과적이지 않아 Chrome 등에서 비활성화되기도 했습니다. gRPC에서는 서버 푸시 대신 스트리밍 패턴으로 이 요구를 해결합니다.


HTTP/1.1 vs HTTP/2.0 정리

HTTP/1.1 HTTP/2.0
인코딩 텍스트 바이너리 프레임
동시 처리 커넥션당 하나씩 (HOL 블로킹) 멀티플렉싱 (하나의 커넥션에서 다수)
커넥션 여러 개 필요 하나로 충분
헤더 매번 전체 전송 HPACK 압축 (중복 제거)
서버 → 클라이언트 불가 (폴링/WebSocket 우회) 서버 푸시 / 스트리밍

왜 gRPC는 HTTP/2.0 위에서 동작하는가

gRPC가 HTTP/2.0을 선택한 이유가 바로 위의 특성들 때문입니다.

  • 멀티플렉싱 → 하나의 커넥션에서 수백 개의 RPC를 동시에 처리
  • 바이너리 프레이밍 → Protocol Buffers의 바이너리 메시지와 자연스럽게 결합
  • 스트리밍 → 서버 스트리밍, 클라이언트 스트리밍, 양방향 스트리밍을 프로토콜 수준에서 지원
  • 헤더 압축 → 메타데이터 오버헤드 최소화

마이크로서비스 간에 초당 수천~수만 건의 RPC가 오가는 환경에서, 이런 특성들은 성능에 직접적인 차이를 만들어냅니다.

다음 글에서는 gRPC의 직렬화 포맷인 Protocol Buffers에 대해 다뤄보겠습니다.

관련 포스트