Навигация

WebSocket и SSE на сервере

Realtime начинается как «просто push в браузер», а заканчивается вопросами про аутентификацию рукопожатия, мёртвые сокеты, потерянные при переподключении сообщения и рассылку между инстансами. В отличие от обычного HTTP-запроса, здесь соединение живёт минутами и часами, и всё, что в REST решал фреймворк, приходится решать вручную. Разберём серверную часть: ws, Socket.IO, SSE, heartbeat, гарантии доставки и масштабирование через Redis.

Клиентская сторона — EventSource, переподключения с backoff, интеграция с React и Vue — разобрана в разделе «API и коммуникация»; здесь только то, что происходит на сервере.

Содержание

  1. Почему HTTP-запроса недостаточно
  2. WebSocket: рукопожатие и кадры
  3. Сервер на ws: соединения и heartbeat
  4. Комнаты и адресация сообщений
  5. Socket.IO: что даёт поверх WebSocket
  6. Аутентификация и авторизация подключения
  7. SSE на сервере
  8. Переподключение и гарантии доставки
  9. Масштабирование на несколько инстансов
  10. Практика: realtime в TaskFlow
  11. Частые ошибки
  12. Ключевые тезисы для интервью
  13. Заключение
  14. Полезные ссылки

Почему 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 или subprotocol Origin не отменяет.
  • 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ничего не хранить в JSCSWSH, нужна проверка Origin, не работает для сторонних доменов
Subprotocolтокен не в URL и не в логах доступазначение попадает в заголовки, которые иногда логируются; список протоколов ограничен
Ticket в queryодноразовость и короткий TTLURL попадает в логи; тикет надо гасить после использования

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 плюс дедупликация:

  1. У каждого события есть монотонный id в рамках потока (проект, пользователь, комната). В Redis это XADD в стрим с MAXLEN, в базе — bigserial.
  2. Клиент запоминает последний применённый id.
  3. При переподключении клиент присылает его: ?lastEventId= для WebSocket-подписки или заголовок Last-Event-ID для SSE.
  4. Сервер дочитывает хвост из стрима и отправляет всё, что новее.
  5. Клиент отбрасывает уже виденные 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 и отдельный шлюз для сокетов.

Полезные ссылки