WebSocket и SSE на сервере
Realtime начинается как «просто push в браузер», а заканчивается вопросами про аутентификацию рукопожатия, мёртвые сокеты, потерянные при переподключении сообщения и рассылку между инстансами. В отличие от обычного HTTP-запроса, здесь соединение живёт минутами и часами, и всё, что в REST решал фреймворк, приходится решать вручную. Разберём серверную часть: ws, Socket.IO, SSE, heartbeat, гарантии доставки и масштабирование через Redis.
Клиентская сторона — EventSource, переподключения с backoff, интеграция с React и Vue — разобрана в разделе «API и коммуникация»; здесь только то, что происходит на сервере.
Содержание
- Почему HTTP-запроса недостаточно
- WebSocket: рукопожатие и кадры
- Сервер на ws: соединения и heartbeat
- Комнаты и адресация сообщений
- Socket.IO: что даёт поверх WebSocket
- Аутентификация и авторизация подключения
- SSE на сервере
- Переподключение и гарантии доставки
- Масштабирование на несколько инстансов
- Практика: realtime в TaskFlow
- Частые ошибки
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Почему HTTP-запроса недостаточно
Обычный запрос-ответ заканчивается вместе с ответом. Если серверу нужно сообщить клиенту о новом событии, он не может инициировать соединение — инициатор всегда клиент. Отсюда несколько способов «протолкнуть» данные:
| Способ | Направление | Соединение | Цена |
|---|---|---|---|
| Короткий polling | сервер → клиент | новый запрос каждые N секунд | пустые запросы, задержка до N секунд |
| Long polling | сервер → клиент | запрос висит до события | одно висящее соединение на клиента, повтор после каждого ответа |
| SSE | сервер → клиент | один HTTP-ответ на всё время | текст, односторонне, занимает HTTP-сокет |
| WebSocket | в обе стороны | один TCP после 101 | свой протокол, heartbeat, масштабирование |
Выбор начинается не с моды, а с вопроса: нужно ли клиенту отправлять сообщения серверу вне HTTP-запроса. Если нет — уведомления, прогресс задачи, тикер, лента событий — SSE почти всегда дешевле в разработке и эксплуатации. Если да — чат, совместное редактирование, игры, двусторонние команды — нужен WebSocket.
Long polling остаётся рабочим вариантом для редких событий и для окружений, где WebSocket блокируется прокси. Его механика и клиентская реализация — в статье «Long polling».
WebSocket: рукопожатие и кадры
WebSocket начинается как обычный HTTP-запрос с просьбой сменить протокол:
GET /ws HTTP/1.1
Host: api.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://app.example.com
Sec-WebSocket-Protocol: taskflow.v1
Сервер отвечает 101 Switching Protocols и вычисляет Sec-WebSocket-Accept — base64 от SHA-1 ключа клиента, склеенного с фиксированным GUID. С этого момента HTTP заканчивается: дальше по тому же TCP идут кадры WebSocket, а не запросы и ответы.
Что из этого следует:
- Нет статусов и заголовков на каждое сообщение. Ошибку нельзя выразить
400; есть только закрытие соединения с кодом (1000— нормально,1008— нарушение политики,1011— внутренняя ошибка,4000–4999— на усмотрение приложения). - Нет CORS. Браузер не блокирует кросс-доменный WebSocket по правилам CORS, но присылает
Originв рукопожатии — проверять его обязан сервер. - Нет встроенного формата данных. Текст или бинарь, всё остальное — ваш протокол: JSON, MessagePack, protobuf, собственный framing.
- Нет HTTP/2. Классический WebSocket работает поверх HTTP/1.1; расширение RFC 8441 поверх HTTP/2 поддержано редко, поэтому за HTTP/2-прокси соединение обычно идёт через отдельный
Upgrade-путь.
Кадр состоит из opcode (text, binary, ping, pong, close), флага FIN и длины. Клиентские кадры обязательно маскируются, серверные — нет. Большое сообщение может фрагментироваться, а ping/pong позволяют проверять живость соединения на уровне протокола, не сочиняя свой heartbeat.
Важная деталь для эксплуатации: wss:// — это тот же WebSocket поверх TLS. Прокси, балансировщик и CDN должны поддерживать Upgrade и не буферизовать соединение; иначе клиент увидит 400 или зависание вместо 101.
Сервер на ws: соединения и heartbeat
Библиотека ws — минимальный сервер WebSocket для Node. Есть два способа подключить её к HTTP-серверу:
import { createServer } from 'node:http';
import { WebSocketServer } from 'ws';
const server = createServer(app);
const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
Режим noServer: true важнее, чем кажется. Он оставляет рукопожатие вам: в обработчике upgrade можно проверить Origin, аутентифицировать пользователя и только потом отдать сокет библиотеке.
server.on('upgrade', async (req, socket, head) => {
try {
req.user = await authenticateUpgrade(req); // cookie, ticket или subprotocol
if (!isAllowedOrigin(req.headers.origin)) throw new Error('origin');
} catch {
socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
socket.destroy();
return;
}
wss.handleUpgrade(req, socket, head, (ws) => {
wss.emit('connection', ws, req);
});
});
До 101 ещё можно ответить обычным HTTP-статусом — это единственное место, где у вас есть привычные коды ошибок. После handleUpgrade остаётся только close(code, reason).
Дальше — соединение и его жизненный цикл:
wss.on('connection', (ws, req) => {
ws.user = req.user;
ws.isAlive = true;
ws.on('pong', () => { ws.isAlive = true; });
ws.on('message', (raw) => {
// недоверенный ввод: лимит размера уже дал maxPayload, но JSON ещё надо разобрать
let msg;
try {
msg = JSON.parse(raw.toString());
} catch {
return ws.close(1003, 'invalid payload');
}
handleMessage(ws, msg);
});
ws.on('error', () => ws.terminate());
});
Heartbeat решает проблему, которой нет в HTTP: оборванное соединение не всегда присылает close. Мобильный клиент ушёл в метро, NAT сбросил таблицу, кабель выдернули — TCP-соединение на сервере остаётся в состоянии ESTABLISHED, а память, подписки и запись в комнате продолжают жить. Поэтому сервер сам проверяет клиентов:
const HEARTBEAT_MS = 30_000;
const timer = setInterval(() => {
for (const ws of wss.clients) {
if (ws.isAlive === false) {
ws.terminate(); // close() будет ждать ответа, который уже не придёт
continue;
}
ws.isAlive = false;
ws.ping();
}
}, HEARTBEAT_MS);
wss.on('close', () => clearInterval(timer));
Таймаут выбирают с запасом: слишком агрессивный ping рвёт соединения на медленной сети, слишком редкий — долго держит зомби. Прокси и балансировщики обычно рвут idle-соединения за 60 секунд, поэтому heartbeat в 20–30 секунд заодно не даёт им закрыть сокет «сверху».
Ещё два ограничителя на уровне сервера:
maxPayload. По умолчаниюwsпринимает сообщения до 100 МиБ — этого хватает, чтобы один клиент съел память. Ставят 16–64 КиБ и валидируют схему сообщения, как тело HTTP-запроса (см. «Конфигурация и валидация»).perMessageDeflate. Сжатие экономит трафик, но тратит CPU на каждое сообщение и открывает дорогу zip-бомбам. Включают осознанно и с лимитом, а не «потому что можно».
Комнаты и адресация сообщений
WebSocket не знает про «комнаты» — это надстройка приложения. Минимальная реализация — словарь room → Set<WebSocket>:
const rooms = new Map();
function join(room, ws) {
if (!rooms.has(room)) rooms.set(room, new Set());
rooms.get(room).add(ws);
ws.rooms ??= new Set();
ws.rooms.add(room);
}
function leaveAll(ws) {
for (const room of ws.rooms ?? []) {
const members = rooms.get(room);
members?.delete(ws);
if (members?.size === 0) rooms.delete(room); // иначе словарь растёт бесконечно
}
ws.rooms?.clear();
}
ws.on('close', () => leaveAll(ws));
Правила, которые легко нарушить:
- Чистить комнаты на
close. ЗабытыйSetс мёртвыми сокетами — классическая утечка: соединений уже нет, а ссылки на объекты и их буферы остаются. - Проверять право на вход в комнату. Подписка на
project:42— такая же авторизация, какGET /projects/42. Проверять её нужно на каждоеsubscribe, а не только при подключении: права могли отозвать. - Не доверять имени комнаты от клиента.
roomприходит из сообщения, поэтомуadmin:*илиuser:*должны проходить серверную проверку, а не подставляться вjoin()как есть. - Помнить, что комнаты живут в памяти инстанса. После рестарта или переподключения на другой инстанс подписки нужно восстановить — обычно клиент присылает список комнат после
open.
В Socket.IO комнаты встроены: socket.join('project:42'), io.to('project:42').emit(...), socket.to(...) — всем, кроме отправителя. Но семантика та же: это локальная структура процесса плюс адаптер для межпроцессной рассылки.
Socket.IO: что даёт поверх WebSocket
Socket.IO — не «библиотека WebSocket», а свой протокол поверх Engine.IO. Он решает те задачи, которые в ws пишут руками:
- Транспорт с fallback. Начинает с HTTP long-polling и апгрейдится до WebSocket; если WebSocket блокируется, соединение продолжает работать на polling.
- Именованные события и acknowledgements.
socket.emit('task:create', data, (ack) => ...)— request/response поверх постоянного соединения. - Комнаты и namespace.
io.of('/admin'),socket.join(...),io.to(...). - Автопереподключение с backoff на клиенте и восстановление сессии (
connectionStateRecoveryв 4.6+). - Middleware на подключение:
io.use((socket, next) => ...), токен доступен вsocket.handshake.auth. - Адаптеры для горизонтального масштабирования:
@socket.io/redis-adapter, Redis Streams adapter.
Цена тоже конкретная:
- Свой протокол. Это не чистый WebSocket: отладка через
wscatи сторонние клиенты не работают без клиентской библиотеки. - Вес на клиенте. Порядка 40 КБ, что для лендинга с одним счётчиком уведомлений избыточно.
- Sticky sessions. Long-polling-фаза требует, чтобы все запросы одной сессии попадали на один инстанс; иначе апгрейд теряет сессию.
- Скрытая сложность. Fallback, апгрейд и адаптер — это больше движущихся частей, чем
wsплюс собственный JSON-протокол.
Практическое правило: если оба конца ваши, нужны комнаты, ack и переподключение «из коробки» — Socket.IO экономит недели. Если нужен стандартный протокол, минимальный оверхед или интеграция с не-браузерным клиентом — ws.
Аутентификация и авторизация подключения
Рукопожатие — это HTTP-запрос, поэтому в него приходят cookie. Это одновременно удобно и опасно:
- Cookie браузер прикладывает автоматически на кросс-сайтовый WebSocket. CORS тут не защищает, и получается CSWSH (cross-site WebSocket hijacking): чужой сайт открывает соединение от имени пользователя и читает всё, что сервер ему присылает.
- Защита — проверка
Originпо allowlist наupgrade, до101. Токен в query или subprotocolOriginне отменяет. Authorizationиз браузера не передать. НативныйWebSocketне даёт задать заголовки, поэтому остаются варианты:
// 1. Cookie + проверка Origin — самый простой путь для same-origin приложения
// 2. Subprotocol: сервер видит Sec-WebSocket-Protocol и обязан выбрать одно из значений
const ws = new WebSocket('wss://api.example.com/ws', ['taskflow.v1', `bearer.${token}`]);
// 3. Ticket: обычный HTTP-запрос выдаёт одноразовый короткоживущий пропуск
const { ticket } = await fetch('/realtime/ticket', { method: 'POST' }).then((r) => r.json());
const socket = new WebSocket(`wss://api.example.com/ws?ticket=${ticket}`);
У каждого варианта есть нюанс:
| Способ | Плюс | Минус |
|---|---|---|
| Cookie | ничего не хранить в JS | CSWSH, нужна проверка Origin, не работает для сторонних доменов |
| Subprotocol | токен не в URL и не в логах доступа | значение попадает в заголовки, которые иногда логируются; список протоколов ограничен |
| Ticket в query | одноразовость и короткий TTL | URL попадает в логи; тикет надо гасить после использования |
Ticket — самый аккуратный вариант для API с несколькими клиентами: он живёт 30–60 секунд, одноразовый и не даёт долгоживущего секрета ни в URL, ни в заголовках. Проверка выполняется в upgrade, а не в connection, потому что отказ должен быть HTTP-статусом.
Второй слой — жизнь соединения после подключения:
- Срок токена. Если access-токен живёт 15 минут, соединение не должно жить на нём неделю. Сервер хранит
expвws.userи закрывает соединение по таймеру (4001), а клиент переподключается с новым токеном. - Права на каждое действие. Подключился — не значит «можно всё»: подписка на комнату и каждая мутирующая команда проверяются отдельно.
- Лимиты. Максимум соединений на пользователя и на IP, максимум сообщений в секунду, максимальный размер сообщения. Без этого один клиент открывает тысячи сокетов или заливает сервер мусором.
SSE на сервере
SSE — это не отдельный протокол, а долгоживущий HTTP-ответ с типом text/event-stream. Сервер отправляет текстовые блоки, разделённые пустой строкой:
id: 1042
event: task.updated
data: {"id":"42","status":"done"}
: ping
id запоминается браузером и приходит обратно заголовком Last-Event-ID, event задаёт имя для addEventListener, data — полезная нагрузка, строка с : в начале — комментарий (удобно для heartbeat), retry: задаёт паузу перед переподключением.
Серверная реализация на Express выглядит так:
app.get('/projects/:id/events', authenticate, async (req, res) => {
res.set({
'Content-Type': 'text/event-stream; charset=utf-8',
'Cache-Control': 'no-cache, no-transform',
Connection: 'keep-alive',
'X-Accel-Buffering': 'no', // nginx: не буферизуй ответ
});
res.flushHeaders();
const write = ({ id, event, data }) => {
if (id) res.write(`id: ${id}\n`);
if (event) res.write(`event: ${event}\n`);
res.write(`data: ${JSON.stringify(data)}\n\n`);
};
write({ event: 'ready', data: { ok: true } });
const heartbeat = setInterval(() => res.write(': ping\n\n'), 15_000);
const unsubscribe = subscribeToProject(req.params.id, write);
req.on('close', () => {
clearInterval(heartbeat);
unsubscribe();
});
});
Что здесь важно и чего нет в учебных примерах:
X-Accel-Buffering: noи отключённый gzip. Прокси и компрессия любят накопить ответ и отдать его целиком — тогда «realtime» приходит пачкой через минуту. На nginx дополнительно нуженproxy_buffering off.- Heartbeat обязателен. Он не даёт балансировщику закрыть соединение по idle-таймауту и вместе с TCP keepalive помогает заметить мёртвого клиента: запись в сокет, который уже получил
RST, вернёт ошибку. - Backpressure.
res.write()возвращаетfalse, когда буфер сокета заполнен. Если продолжать писать,res.writableLengthрастёт в памяти процесса. Для SSE проверяют возврат и при переполнении рвут соединение — медленный клиент не должен стоить серверу гигабайт. Last-Event-ID. Без него переподключение начинает поток с нуля и теряет всё, что произошло за время обрыва. С ним сервер дочитывает события из Redis Stream или таблицы.
Ограничения SSE, о которых нужно помнить до выбора технологии:
- Только сервер → клиент. Команды клиента идут обычными HTTP-запросами.
- Только текст. Бинарь нужно кодировать в base64, что раздувает трафик.
- HTTP/1.1: шесть соединений на домен. Браузер держит лимит на origin, и несколько вкладок с SSE начинают конкурировать с обычными запросами. HTTP/2 снимает это ограничение, но требует поддержки на всём пути.
- Каждое соединение — это сокет, память и запись в структуре подписок. Тысячи клиентов — это тысячи открытых ответов, а не «бесплатный» канал.
Аутентификация SSE повторяет историю WebSocket: EventSource не умеет заголовки, поэтому либо cookie + проверка Origin, либо ticket в query. Токен в query без TTL — плохая идея: он останется в логах прокси и в истории.
Переподключение и гарантии доставки
TCP гарантирует порядок байт внутри одного соединения. Переподключение создаёт новое соединение, и всё, что произошло между разрывом и open, для клиента не существует. Отсюда три уровня гарантий:
| Гарантия | Что делает сервер | Что делает клиент |
|---|---|---|
| At-most-once | отправляет и забывает | может потерять события |
| At-least-once | хранит события с id и отдаёт пропущенное | дедуплицирует по id |
| Exactly-once | не существует как свойство сети | эмулируется дедупликацией |
Практическая схема — at-least-once плюс дедупликация:
- У каждого события есть монотонный
idв рамках потока (проект, пользователь, комната). В Redis этоXADDв стрим сMAXLEN, в базе —bigserial. - Клиент запоминает последний применённый
id. - При переподключении клиент присылает его:
?lastEventId=для WebSocket-подписки или заголовокLast-Event-IDдля SSE. - Сервер дочитывает хвост из стрима и отправляет всё, что новее.
- Клиент отбрасывает уже виденные
id.
Для WebSocket то же самое делается сообщением resume после open:
{ "type": "resume", "stream": "project:42", "lastId": "1042" }
Отдельная проблема — команды клиента. Если клиент отправил task.complete и не получил ack, он повторит отправку; сервер обязан обработать дубль идемпотентно. Помогает clientMessageId, который клиент генерирует один раз, а сервер хранит короткое время и возвращает тот же результат на повтор.
Чего делать не стоит:
- Буферизовать всё подряд «на всякий случай». Очередь на каждого клиента без лимита — это OOM. Буфер ограничивают по времени (последние N минут) и по количеству, а при переполнении честно закрывают соединение с кодом, чтобы клиент переподключился и дочитал.
- Считать, что порядок сохранится между инстансами. Два издателя в Redis pub/sub могут доставить сообщения в разном порядке; монотонный
idнужен именно для того, чтобы клиент мог восстановить логику, а не полагаться на сеть. - Обещать «exactly-once». Сеть теряет пакеты и дублирует их; единственный рабочий вариант — идемпотентная обработка.
Масштабирование на несколько инстансов
Пока сервер один, комнаты — это Map в памяти, и всё работает. С двумя инстансами появляются три проблемы: соединения распределены, комнаты локальны, а событие, опубликованное на инстансе A, не видят клиенты инстанса B.
Sticky sessions. Балансировщик должен отправлять клиента на тот же инстанс, где живёт его соединение. Для чистого WebSocket это нужно не всегда: после open соединение уже привязано к процессу на уровне TCP, а auth можно сделать stateless. Но как только появляется состояние в памяти (комнаты, черновики, presence) или HTTP long-polling (Socket.IO), привязка становится обязательной. На практике используют cookie-affinity; ip_hash плох за NAT, где тысячи клиентов выглядят одним адресом.
Backplane для рассылки. Каждый инстанс подписывается на канал и передаёт полученное своим сокетам:
// src/realtime/bus.js
import { createClient } from 'redis';
const pub = createClient({ url: config.REDIS_URL });
const sub = pub.duplicate();
await Promise.all([pub.connect(), sub.connect()]);
const CHANNEL = 'taskflow:realtime';
await sub.subscribe(CHANNEL, (raw) => {
const { room, event, data, id } = JSON.parse(raw);
broadcastLocal(room, { event, data, id }); // только локальные сокеты
});
export function publish(room, event, data, id) {
// публикуем один раз: сообщение придёт всем подписчикам, включая этот инстанс
return pub.publish(CHANNEL, JSON.stringify({ room, event, data, id }));
}
Ключевой момент: не рассылать локально и публиковать одновременно — иначе инстанс-издатель доставит событие дважды. Либо публикация, либо локальная доставка, но не оба.
С Socket.IO то же самое делает адаптер:
import { createAdapter } from '@socket.io/redis-adapter';
io.adapter(createAdapter(pub, sub));
Что нужно понимать про адаптер:
- Pub/sub — fire-and-forget. Инстанс, который в момент публикации перезапускался или потерял связь с Redis, сообщение не получит. Для важных событий нужен журнал (Redis Stream, Kafka) и дочитывание по
idпри переподключении. - Адаптер не ускоряет fan-out. Одно событие в комнату на 10 000 сокетов — это 10 000 записей в сокеты, распределённых по инстансам. Считать нужно именно объём доставки, а не количество публикаций.
- Presence тоже требует состояния. «Кто онлайн» хранят в Redis с TTL, который продлевает heartbeat; иначе после падения инстанса пользователи останутся «онлайн» навсегда.
- Свой протокол поверх
ws— это свой backplane. Придётся написать и подписку, и формат сообщений, и обработку рестартов. Socket.IO даёт это из коробки, но тем же fire-and-forget.
Когда соединений становятся десятки тысяч, realtime выносят в отдельный сервис-шлюз: он держит сокеты, а бизнес-логика публикует события в шину. Тогда деплой API не рвёт соединения, а шлюз масштабируется отдельно от остального бэкенда.
Практика: realtime в TaskFlow
Добавим к TaskFlow из статей «HTTP-сервер на чистом Node» и «Аутентификация в API» обновления задач в реальном времени: WebSocket для двусторонних действий и SSE для уведомлений.
1. Одноразовый ticket. Обычный HTTP-эндпоинт под проверенной сессией:
// src/routes/realtime.js
import { Router } from 'express';
import { randomBytes } from 'node:crypto';
export const realtimeRouter = Router();
realtimeRouter.post('/ticket', authenticate, async (req, res) => {
const ticket = randomBytes(24).toString('base64url');
await redis.set(`rt:ticket:${ticket}`, req.user.id, { EX: 60, NX: true });
res.status(201).json({ ticket });
});
2. WebSocket-сервер с комнатами проекта.
// src/realtime/server.js
import { WebSocketServer } from 'ws';
export function attachRealtime(server) {
const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
server.on('upgrade', async (req, socket, head) => {
const url = new URL(req.url, 'http://localhost');
const ticket = url.searchParams.get('ticket');
const userId = ticket && (await redis.getDel(`rt:ticket:${ticket}`));
if (!userId || !isAllowedOrigin(req.headers.origin)) {
socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
return socket.destroy();
}
req.user = { id: userId };
wss.handleUpgrade(req, socket, head, (ws) => wss.emit('connection', ws, req));
});
wss.on('connection', (ws, req) => {
ws.user = req.user;
ws.isAlive = true;
ws.rooms = new Set();
ws.on('pong', () => { ws.isAlive = true; });
ws.on('message', async (raw) => {
const msg = parseClientMessage(raw); // zod-схема из статьи «Конфигурация и валидация»
if (msg.type === 'subscribe') {
const room = `project:${msg.projectId}`;
if (!(await canReadProject(ws.user.id, msg.projectId))) {
return ws.close(1008, 'forbidden');
}
joinRoom(room, ws);
ws.send(JSON.stringify({ type: 'subscribed', projectId: msg.projectId }));
}
});
ws.on('close', () => leaveAllRooms(ws));
ws.on('error', () => ws.terminate());
});
const heartbeat = setInterval(() => {
for (const ws of wss.clients) {
if (!ws.isAlive) { ws.terminate(); continue; }
ws.isAlive = false;
ws.ping();
}
}, 30_000);
wss.on('close', () => clearInterval(heartbeat));
return wss;
}
3. Публикация изменения задачи — из сервиса, а не из обработчика WebSocket:
// src/services/tasks.js
export async function updateTask({ taskId, user, patch }) {
const task = await db.task.update({ where: { id: taskId, ownerId: user.id }, data: patch });
await publish(`project:${task.projectId}`, 'task.updated', toTaskResponse(task), task.version);
return task;
}
task.version — тот самый монотонный id для восстановления после переподключения.
4. SSE-поток уведомлений с дочитыванием по Last-Event-ID:
// src/routes/notifications.js
notificationsRouter.get('/stream', authenticate, async (req, res) => {
res.set({
'Content-Type': 'text/event-stream; charset=utf-8',
'Cache-Control': 'no-cache, no-transform',
Connection: 'keep-alive',
'X-Accel-Buffering': 'no',
});
res.flushHeaders();
const stream = `notify:${req.user.id}`;
const lastId = req.get('last-event-id') ?? '0-0';
for (const entry of await redis.xRange(stream, `(${lastId}`, '+', { COUNT: 100 })) {
res.write(`id: ${entry.id}\nevent: notification\ndata: ${entry.message.body}\n\n`);
}
const heartbeat = setInterval(() => res.write(': ping\n\n'), 15_000);
const stop = subscribeStream(stream, (entry) => {
res.write(`id: ${entry.id}\nevent: notification\ndata: ${entry.message.body}\n\n`);
});
req.on('close', () => { clearInterval(heartbeat); stop(); });
});
Что закрыто: одноразовый ticket вместо долгого токена в URL, проверка Origin, авторизация подписки на комнату, heartbeat и уборка комнат, восстановление пропущенных событий по id.
Что добавляют в проде: лимит соединений на пользователя, rate limit входящих сообщений, метрики по числу соединений и задержке доставки, отдельный backplane вместо локального Map, а также тесты на обрыв соединения и повторную подписку.
Частые ошибки
new WebSocketServer({ server })без проверкиOriginи авторизации. Любой сайт открывает соединение с cookie пользователя.- Токен в query без TTL. Утекает в логи прокси, историю и
Referer; живёт вечно. - Нет heartbeat. Мёртвые соединения копятся, комнаты и буферы не освобождаются.
- Нет
maxPayloadи валидации сообщений. Одно сообщение на 100 МиБ илиJSON.parseмусора роняет процесс. - Бесконечная очередь медленному клиенту.
bufferedAmountрастёт, процесс падает по OOM. - Комнаты не чистятся на
close.Setс мёртвыми сокетами — утечка памяти и лишняя работа при рассылке. - Проверка прав только на
connection. Подписка на чужой проект черезsubscribeотдаёт данные. - Локальная рассылка плюс публикация в Redis. Клиент получает каждое событие дважды.
- SSE без
X-Accel-Buffering: noи с включённым gzip. События приходят пачками или не приходят вовсе. - Обещание «ничего не потеряется» без журнала событий. Pub/sub теряет сообщения при рестарте инстанса, и клиент об этом не узнает.
socket.ioбез sticky sessions. Long-polling-запросы попадают на разные инстансы, апгрейд ломается.close()вместоterminate()для зомби.close()ждёт ответа, которого не будет, и висит до таймаута.
Ключевые тезисы для интервью
- WebSocket — это HTTP-
Upgradeи101, после которого соединение перестаёт быть HTTP: статусов, заголовков и CORS на каждое сообщение нет, поэтомуOrigin, auth, лимиты и heartbeat переносятся на рукопожатие и кадры. - Браузерный
WebSocketне даёт задатьAuthorization, поэтому используют cookie с обязательной проверкойOrigin, subprotocol или одноразовый ticket; права проверяют при подписке на комнату и на каждое действие, а не только при подключении. - SSE — обычный HTTP-ответ
text/event-stream: он проще, сам переподключается и проходит через прокси, но работает только сервер → клиент, только с текстом и занимает по сокету на клиента. - TCP гарантирует порядок внутри соединения, но не между переподключениями: at-least-once требует монотонного
id, журнала событий и дедупликации на клиенте, а команды клиента должны быть идемпотентны. - Медленный клиент без backpressure превращается в неограниченную очередь в памяти: ограничивают
bufferedAmount/writableLength,maxPayloadи рвут соединение при переполнении. - Каждый инстанс держит свои сокеты, поэтому рассылка идёт через Redis pub/sub или другую шину; адаптер не даёт гарантий доставки, а sticky sessions обязательны там, где есть long-polling-фаза Socket.IO.
- Heartbeat —
ping/pongили SSE-комментарий — единственный способ заметить оборванное соединение, о котором не пришёлclose, и не держать зомби-сокеты за прокси.
Заключение
Realtime в Node — это не «библиотека на 20 строк», а набор решений о жизненном цикле долгого соединения. WebSocket даёт двусторонний канал, но забирает HTTP-обвязку: авторизацию рукопожатия, Origin, лимиты сообщений, heartbeat и восстановление после разрыва нужно строить самому. SSE закрывает более узкий сценарий дешевле и надёжнее, но только в одну сторону и только текстом. Гарантии доставки в сети не бесплатны: рабочая схема — монотонные id, журнал событий и дедупликация, а не обещание «exactly-once». И последнее: пока инстанс один, всё выглядит просто; настоящее проектирование начинается на втором инстансе, когда появляются sticky sessions, backplane и отдельный шлюз для сокетов.
Полезные ссылки
- RFC 6455: The WebSocket Protocol — рукопожатие, кадры, коды закрытия
- ws — WebSocket-сервер и клиент для Node
- MDN: WebSocket API — браузерный API и ограничения
- MDN: Server-sent events — формат
text/event-streamиEventSource - Socket.IO: Adaptors — Redis adapter и масштабирование
- WebSocket: двусторонний real-time — клиентская часть, переподключения и состояние
- Server-Sent Events: real-time через HTTP —
EventSource, формат событий и ограничения