blog.dopana

Quay lại

Bạn mở ChatGPT, gõ một câu hỏi, và chữ hiện ra từng từ như ai đó đang gõ trực tiếp. Cảm giác “nhanh” đó đến từ đâu?

Hầu hết mọi người đoán: “chắc WebSocket nhanh nhất”. Nhưng sự thật bất ngờ hơn: phần lớn LLM API hiện nay (OpenAI, Anthropic, DeepSeek) stream token bằng SSE (Server-Sent Events) — công nghệ đơn giản hơn WebSocket rất nhiều.

Vậy khi nào SSE thắng? Khi nào WebSocket thắng? Và nếu bạn muốn scale lên 10k, 100k hay 1 triệu connections thì cái nào mới là nút thắt thật sự?

Bài này trả lời dưới góc nhìn Software Architect chuyên về realtime systems và high-performance backend.

1. Giải thích như bạn 10 tuổi (ELI5)#

Tưởng tượng hai kiểu liên lạc:

  • SSE giống loa phát thanh của trường học: chỉ thầy hiệu trưởng (server) nói, cả trường (client) nghe. Một chiều, đơn giản, ai cũng nghe rõ. Học sinh muốn nói lại thì phải giơ tay, đi lên phòng riêng (gửi HTTP request khác).
  • WebSocket giống điện thoại gọi video hai chiều: cả hai bên nói qua nói lại liên tục trên cùng một đường dây. Linh hoạt hơn, nhưng phải thiết lập cuộc gọi (handshake), giữ máy, tự lo mất sóng (reconnect thủ công).

[!NOTE] SSE = một chiều (server → client), chạy trên HTTP thuần. WebSocket = hai chiều (client ↔ server) trên một TCP connection duy trì.

2. Cách chúng hoạt động#

SSE: HTTP connection treo lơ lửng#

Client gửi một GET request bình thường, server không trả lời ngay mà giữ connection mở và tuôn text xuống dần:

loop[mỗi token]GET /api/chat/stream (HTTP)HTTP 200 text/event-streamdata: {"token": "xin"} data: {"token": " chào"} data: [DONE] "Client (EventSource)"Server"Client (EventSource)"Server

Điểm mạnh:

  • Chạy qua mọi proxy, CDN, load balancer vì bản chất là HTTP.
  • Browser tự reconnect + gửi Last-Event-ID để resume.
  • Debug dễ: mở tab Network là thấy text chảy xuống.

Điểm yếu:

  • Chỉ server → client. Muốn client → server phải gọi HTTP endpoint khác.
  • Chỉ text (UTF-8), muốn gửi binary phải base64.

WebSocket: bắt tay một lần, nói mãi mãi#

Client upgrade từ HTTP lên WebSocket một lần duy nhất, sau đó hai bên gửi frame nhị phân cho nhau:

loop[hai chiều]GET /ws (Upgrade: websocket)101 Switching Protocolsframe(token)frame(cancel / approve / position)frame(token)ClientServerClientServer

Điểm mạnh:

  • Hai chiều native trên cùng một connection.
  • Frame overhead chỉ 2–6 bytes (so với ~600 bytes HTTP headers mỗi request).
  • Hỗ trợ cả text lẫn binary.

Điểm yếu:

  • Tự lo reconnect, heartbeat, resume, auth lại.
  • Một số proxy/CDN cần cấu hình riêng cho upgrade handshake.
  • HTTP/2 multiplexing không giúp được WebSocket như giúp SSE.

3. Bảng so sánh nhanh (TL;DR)#

Tiêu chíSSEWebSocket
Latency🟢 Rất thấp🟢 Rất thấp, thường thấp hơn chút
Server → client🟢 Rất tốt🟢 Rất tốt
Client → server🟡 Phải dùng HTTP khác🟢 Native
Protocol overhead🟢 Thấp🟢 Rất thấp (frame 2–6 bytes)
CPU backend🟢 Thường đơn giản hơn🟡 Cao hơn chút
Memory🟢 Tốt🟢 Tốt
10k connections🟢 Có thể tốt🟢 Có thể tốt
100k+ connections🟡 Phụ thuộc stack/proxy🟢 Thường phù hợp hơn
Streaming LLM🟢 Rất phù hợp🟢
Realtime 2 chiều❌🟢 Phù hợp

[!TIP] Quy tắc ngón tay cái: chỉ cần server đẩy xuống → chọn SSE. Cần hai bên nói liên tục → chọn WebSocket.

4. Trường hợp 1: chỉ stream một chiều (LLM chat)#

Server gửi:

token 1
token 2
token 3
token 4
...
text

Với SSE:

Server ───────────────────────> Client
       stream data continuously
text

Rất hiệu quả. Code server Node.js chỉ vài dòng:

Client browser không cần thư viện:

client-sse.js
const es = new EventSource('/api/chat/stream');
es.onmessage = (e) => {
  if (e.data === '[DONE]') return es.close();
  appendToChat(JSON.parse(e.data).token);
};
javascript

WebSocket cũng làm được:

WebSocket frame
WebSocket frame
WebSocket frame
...
text

Cũng rất nhanh, nhưng bạn không tận dụng được lợi thế bidirectional — khác nào mua điện thoại xịn chỉ để nghe đài.

5. Trường hợp 2: message cực nhỏ, rất nhiều, hai chiều#

Ví dụ game, vị trí chuột, collaborative editing:

Client → position
Server → position
Client → position
Server → position
...
text

100–1000 messages/giây/client chẳng hạn.

WebSocket thường phù hợp hơn, vì connection được thiết kế cho communication hai chiều liên tục, frame overhead thấp, không phải mở HTTP request mới cho mỗi chiều gửi lên.

Mỗi HTTP request mang ~600 bytes headers. WebSocket frame chỉ 2–6 bytes. Nhân với 100 msg/s × 10k clients, chênh lệch băng thông là rất thật.

client-ws.js
// WebSocket: một connection, gửi nhận thoải mái
const ws = new WebSocket('wss://example.com/agent');
ws.onmessage = (e) => renderAgentEvent(JSON.parse(e.data));
// Huỷ giữa chừng, approve tool call, gửi vị trí — cùng đường dây
ws.send(JSON.stringify({ type: 'cancel' }));
ws.send(JSON.stringify({ type: 'approve-tool-call', id: 'tool-123' }));
javascript

6. Điểm quan trọng: đừng kỳ vọng nhanh hơn 10x#

Đừng kỳ vọng:

WebSocket nhanh hơn SSE 10x.

Trong application thực tế, latency thường bị chi phối bởi:

LLM generation
    ↓
database
    ↓
business logic
    ↓
network
    ↓
browser rendering
text

chứ không phải bản thân SSE/WebSocket.

Ví dụ LLM mất 500ms để sinh token đầu tiên thì việc WebSocket nhanh hơn SSE vài ms không đáng kể. Benchmark localhost cho thấy WebSocket latency trung bình ~18ms vs SSE cao hơn chút ở 1000 connections — nhưng broadcast thuần server → client với nhiều passive clients thì SSE lại gọn nhẹ hơn nhờ HTTP semantics.

[!WARNING] Tối ưu sai chỗ là bệnh phổ biến: đổi protocol mà không đo LLM TTFT (time-to-first-token), DB query, hay render cost thì hiếm khi cải thiện UX.

7. Với project AI của bạn: chọn gì?#

Nếu mục tiêu là AI chat / LLM streaming, mình sẽ chọn:

POST /api/chat
       ▼
     Server
       ▼
SSE /api/chat/stream
       ├─token
       ├─token
       ├─token
       ├─token
       └─done
text

Thay vì WebSocket. Lý do: đơn giản, qua được mọi hạ tầng, auto-reconnect, đủ nhanh.

Còn nếu sau này bạn có:

AI Agent
   ↕
Browser
   ↕
Tool execution
   ↕
Terminal
   ↕
Agent events
text

với nhiều event hai chiều realtime (cancel generation, approve tool call, steering giữa chừng, multi-device sync), lúc đó WebSocket bắt đầu có nhiều ý nghĩa hơn.

Checklist quyết định:

  • Chỉ stream token xuống? → SSE.
  • Cần cancel/steer/approve từ client ngay giữa stream? → WebSocket (hoặc SSE + HTTP POST phụ, nhưng càng nhiều tương tác thì càng rối).
  • Cần binary (audio/video realtime)? → WebSocket (hoặc WebRTC).
  • Chạy sau CDN/proxy cũ? → SSE an toàn hơn.

8. Scale 10k / 100k / 1 triệu connections#

Nếu mục tiêu của bạn là 10k / 100k / 1 triệu concurrent connections, thì câu chuyện khác khá nhiều — lúc đó SSE vs WebSocket chỉ là một phần nhỏ. Quan trọng hơn là:

  • Connection architecture: event loop (Node.js, Go, Elixir), sticky session, sharding.
  • Proxy/load balancer: Nginx, ALB, Cloudflare có giữ được keep-alive + upgrade không?
  • Kernel/socket limits: file descriptors, TCP tuning, TIME_WAIT.
  • Backpressure: server gửi nhanh hơn client đọc thì buffer ở đâu?
  • Resume/reconnect chiến lược khi drop hàng loạt.

Tóm lại:

SSE = performance rất tốt + đơn giản hơn cho one-way streaming. WebSocket = performance tốt hơn cho high-frequency bidirectional realtime.

Tài liệu tham khảo#