SSE vs WebSocket: Hiệu năng Realtime
So sánh SSE vs WebSocket dưới góc nhìn Software Architect: latency, overhead, LLM streaming, realtime 2 chiều và scale 100k connections.
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:
Đ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:
Đ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í | SSE | WebSocket |
|---|---|---|
| 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
...textVới SSE:
Server ───────────────────────> Client
stream data continuouslytextRất hiệu quả. Code server Node.js chỉ vài dòng:
import express from 'express';
const app = express();
app.get('/api/chat/stream', async (req, res) => {
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
res.flushHeaders();
for await (const token of generateLLMResponse('Xin chào')) {
res.write(`data: ${JSON.stringify({ token })}\n\n`);
}
res.write('data: [DONE]\n\n');
res.end();
});
async function* generateLLMResponse(_prompt: string) {
for (const t of ['Xin', ' chào', ' bạn', '!']) {
await new Promise((r) => setTimeout(r, 50));
yield t;
}
}
app.listen(3000);typescriptClient browser không cần thư viện:
const es = new EventSource('/api/chat/stream');
es.onmessage = (e) => {
if (e.data === '[DONE]') return es.close();
appendToChat(JSON.parse(e.data).token);
};javascriptWebSocket cũng làm được:
WebSocket frame
WebSocket frame
WebSocket frame
...textCũ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
...text100–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.
// 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' }));javascript6. Đ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 renderingtextchứ 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
└─donetextThay 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 eventstextvớ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#
- WebSocket vs SSE: Which One Should You Use? — WebSocket.org ↗
- WebSockets and AI: Why LLMs Are Moving Beyond SSE — WebSocket.org ↗
- AI Token Streaming: From SSE to Durable Sessions — WebSocket.org ↗
- WebSocket vs SSE vs HTTP: Which Should You Use? — WebSocket.org ↗
- How We Used SSE to Stream LLM Responses at Scale — Dan A ↗
- Realtime Benchmark: SSE vs WebSockets — GitHub muratdemirci ↗
- SSE vs WebSockets for LLM streaming: which to use in 2026 — n4n.ai ↗