Навигация

HTTP-сервер на чистом Node

Любой Node-фреймворк — это надстройка над node:http, но пока не видно, что именно он скрывает, его поведение выглядит магией. Один незакрытый ответ, забытый лимит на тело или неверный таймаут сокета превращают сервис в источник зависших соединений. Разберём, как устроен HTTP-сервер на чистом Node, что приходится делать вручную и где проходит граница, после которой нужен фреймворк и reverse proxy.

Содержание

  1. Почему стоит уметь поднять сервер без фреймворка
  2. createServer и пара req/res
  3. Метод, URL и заголовки
  4. Ответ: статус, заголовки, тело
  5. Чтение тела запроса
  6. Ручной routing и его предел
  7. Практика: первый HTTP-сервер TaskFlow
  8. Ошибки, обрывы и headersSent
  9. Keep-alive и таймауты сокетов
  10. HTTPS и терминация TLS
  11. Зачем нужен reverse proxy
  12. Частые ошибки
  13. Эксперименты
  14. Ключевые тезисы для интервью
  15. Заключение
  16. Полезные ссылки

Почему стоит уметь поднять сервер без фреймворка

Фреймворк не отменяет HTTP, а прячет его детали. Пока детали скрыты, непонятно, откуда берётся 413, почему клиент получает ECONNRESET вместо JSON-ошибки и куда девается память при загрузке файла. На чистом node:http видно каждое решение:

  • что приходит — байты заголовков, поток тела, метод и сырой URL;
  • что уходит — статус, заголовки и тело, которые нельзя изменить после отправки;
  • кто отвечает за ошибку — не фреймворк, а ваш обработчик;
  • сколько живёт соединение — один запрос или серия запросов по keep-alive.

Есть и практическая причина: node:http лежит в основе Express, Fastify и NestJS, а также health-check-серверов, вебхуков и внутренних утилит, где фреймворк избыточен. Понимание нижнего слоя объясняет и поведение верхнего.

Важно и то, чего в node:http нет. Он не парсит тело, не разбирает URL на маршруты, не валидирует JSON, не ограничивает размер запроса и не ловит исключения из обработчика. Всё это — ответственность приложения, и именно поэтому «сервер на 20 строк» в проде обрастает сотнями строк обвязки.


createServer и пара req/res

Сервер создаётся одной функцией, а обработчик вызывается на каждый входящий запрос:

import { createServer } from 'node:http';

const server = createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
  res.end('ok');
});

server.listen(3000, () => {
  console.log('http://localhost:3000');
});

Два объекта в аргументах — это два стрима с разными ролями:

ОбъектКлассРольКлючевое
reqhttp.IncomingMessageчитаемый поток тела запросаметод, URL, заголовки, чанки тела
reshttp.ServerResponseзаписываемый поток ответастатус, заголовки, тело, end()

req — наследник Readable, поэтому тело читают событиями data или через for await. res — наследник Writable: в него пишут write(), а завершают end(). Оба наследуют EventEmitter, и у них есть событие error, о котором легко забыть.

Обработчик вызывается на каждый запрос, а не на соединение. При keep-alive по одному TCP-сокету последовательно проходит несколько запросов, и каждый получает новую пару req/res. Состояние между запросами через эти объекты не переносится: всё, что нужно сохранить, живёт в базе, кеше или явной переменной.

server.on('connection', (socket) => {
  // одно TCP-соединение — может обслужить много запросов
});

server.on('clientError', (err, socket) => {
  // битые заголовки и таймауты до обработчика не доходят
  socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
});

Событие clientError — единственный способ ответить на запрос, который не стал валидным HTTP-запросом. Такие ошибки не попадают в основной обработчик, потому что объекта req ещё нет.


Метод, URL и заголовки

Всё, что пришло в запросе, доступно через свойства req:

req.method;      // 'GET', 'POST' — всегда в верхнем регистре
req.url;         // '/tasks/42?fields=title' — сырая строка, без разбора
req.httpVersion; // '1.1'
req.headers;     // объект, имена в нижнем регистре

req.url — не путь и не URL. Это строка в том виде, в каком её прислал клиент, вместе с query. Разбирать её нужно явно, и лучше через стандартный URL, а не регулярками:

const url = new URL(req.url, `http://${req.headers.host ?? 'localhost'}`);

url.pathname;                  // '/tasks/42'
url.searchParams.get('fields'); // 'title'

Второй аргумент-база обязателен: без него new URL бросит исключение на относительном пути. Для прокси за прокси-сервером req.url иногда приходит в absolute-form (http://host/path), и new URL с базой корректно обрабатывает оба варианта.

Заголовки приходят как объект с именами в нижнем регистре, а повторяющиеся заголовки склеиваются через запятую. Исключение — set-cookie: в req.headers его обычно нет, а в ответе он передаётся массивом. Значения заголовков — всегда строки, поэтому числа и булевы флаги нужно приводить самому.

const auth = req.headers.authorization;   // 'Bearer ...' или undefined
const length = Number(req.headers['content-length'] ?? 0);

Три ограничения, о которых стоит помнить:

  • Размер заголовков ограничен (--max-http-header-size, по умолчанию 16 КБ на весь блок), а их количество — server.maxHeadersCount (по умолчанию 2000).
  • Host не проверен: приложение само решает, доверять ли ему, особенно если от него строятся ссылки.
  • Заголовки прокси не доверенные: x-forwarded-for и x-forwarded-proto можно подделать, если Node доступен напрямую.

Ответ: статус, заголовки, тело

Ответ собирается из трёх частей, и порядок здесь важен: сначала статус и заголовки, потом тело, потом end().

res.statusCode = 201;
res.setHeader('content-type', 'application/json; charset=utf-8');
res.setHeader('location', '/tasks/43');

res.write(JSON.stringify({ id: 43 }));
res.end();

res.writeHead(status, headers) делает то же самое одной операцией и заодно фиксирует заголовки. Смешивать оба способа не стоит: после writeHead любой setHeader бросит ERR_HTTP_HEADERS_SENT.

ЧтоКак задаётсяНюанс
Статусres.statusCode или writeHeadпо умолчанию 200, меняется только до отправки заголовков
Заголовкиres.setHeaderимена регистронезависимы, значения — строка, число или массив
Телоres.write() / res.end()end() обязателен даже при пустом теле
Кодировкаcontent-typeбез charset=utf-8 кириллица может прийти искажённой

Заголовки уходят в сокет при первом write(), end() или явном flushHeaders(). До этого момента их можно менять, после — уже нет. Именно поэтому обработчик ошибки обязан проверять res.headersSent, а не пытаться «дописать» статус 500 поверх уже отправленного 200.

Два частных случая, где тело запрещено:

  • ответы на HEAD должны содержать те же заголовки, что GET, но без тела;
  • статусы 204 и 304 не имеют тела, и content-length для них не отправляют.

Если не задать content-length и не вызвать end() с телом сразу, Node перейдёт на transfer-encoding: chunked. Это нормально для потоковой отдачи, но плохо для клиентов, которым нужен точный размер, — например, для прогресс-бара скачивания.

res.write() возвращает false, когда внутренний буфер заполнен. Для HTTP-ответа это сигнал притормозить поток-источник до события drain; подробнее механизм разобран в статье «Стримы и backpressure». Игнорирование false при отдаче большого файла — прямой путь к росту памяти.


Чтение тела запроса

Тело — это поток, и в обработчик оно не приходит готовым объектом. Простейшее чтение выглядит так:

const chunks = [];
for await (const chunk of req) {
  chunks.push(chunk);
}
const body = Buffer.concat(chunks).toString('utf8');

Три вещи здесь неочевидны. Во-первых, чанки — это Buffer, а не строки, поэтому границы UTF-8 могут разрезать символ: собирать текст нужно после склейки, а не декодировать каждый чанк отдельно. Во-вторых, for await даёт backpressure: пока обработчик не запросил следующий чанк, сокет не читается дальше. В-третьих, у тела нет лимита по умолчанию — всё, что клиент пришлёт, окажется в памяти.

Content-Length — это заявление клиента, а не гарантия. Его можно занизить, а при transfer-encoding: chunked его нет вовсе. Поэтому лимит считают по фактически прочитанным байтам:

const MAX_BODY = 64 * 1024;

async function readJson(req) {
  const declared = Number(req.headers['content-length'] ?? 0);
  if (declared > MAX_BODY) {
    throw Object.assign(new Error('payload too large'), { status: 413 });
  }

  let size = 0;
  const chunks = [];

  for await (const chunk of req) {
    size += chunk.length;
    if (size > MAX_BODY) {
      // прекращаем чтение: поток уничтожается, соединение закрывается
      throw Object.assign(new Error('payload too large'), { status: 413 });
    }
    chunks.push(chunk);
  }

  if (size === 0) return undefined;

  try {
    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
  } catch {
    throw Object.assign(new Error('invalid json'), { status: 400 });
  }
}

Порядок проверок тоже часть контракта: сначала content-type, потом размер, потом разбор. Ответ 415 на text/plain честнее, чем 400 от JSON.parse, а быстрый отказ по content-length экономит чтение мегабайтов, которые всё равно будут отброшены.

Отдельный нюанс — что видит клиент при превышении лимита. Если сразу вызвать req.destroy(), клиент получит ECONNRESET и не прочитает тело ответа 413. Практичнее ответить 413 с connection: close и только потом закрыть соединение:

res.writeHead(413, { 'content-type': 'application/json', connection: 'close' });
res.end(JSON.stringify({ error: 'payload too large' }));
req.destroy();

Для загрузки файлов тело вообще не буферизуют: его сразу передают в pipeline(req, createWriteStream(path)), ограничивая размер счётчиком в Transform. Такой подход экономит память и работает с файлами любого размера.


Ручной routing и его предел

Маршрутизация на чистом Node начинается с разбора req.url и заканчивается таблицей соответствий:

const routes = new Map([
  ['GET /health', () => ({ status: 200, body: { ok: true } })],
  ['GET /tasks', () => ({ status: 200, body: listTasks() })],
]);

function handle(req, res) {
  const url = new URL(req.url, 'http://localhost');
  const handler = routes.get(`${req.method} ${url.pathname}`);

  if (!handler) {
    res.writeHead(404).end();
    return;
  }

  const { status, body } = handler(url.searchParams);
  res.writeHead(status, { 'content-type': 'application/json' });
  res.end(JSON.stringify(body));
}

На десяти статических маршрутах это работает. Проблемы начинаются, когда появляются параметры пути (/tasks/:id), вложенные ресурсы, query-фильтры и разные тела запросов. Каждое требование добавляет код, который фреймворк уже написал:

ЗадачаЧто писать вручную
Параметры путиразбор сегментов, декодирование, конфликты маршрутов
Методы404 против 405, Allow, автоматический OPTIONS
Слэши и регистрнормализация /tasks/ и /tasks
Телолимит, content-type, JSON-ошибки, 413/415
Ошибкиобёртка try/catch вокруг каждого обработчика
HEADтот же маршрут без тела, но с заголовками
СтатикаMIME-типы, кеширование, защита от ..

К этому добавляются CORS, сжатие, cookies, логирование и валидация — и «двадцать строк» превращаются в самодельный фреймворк с собственными багами. Поэтому чистый node:http оправдан для узких задач: health-check, вебхук с одним маршрутом, прокси, минимальный внутренний сервис. Для API с десятком сущностей разумнее взять готовый слой.

Практический признак, что пора переходить: в файле появились регулярки для маршрутов, самописный парсер тела и if (req.method === 'OPTIONS'). Дальше стоимость поддержки растёт быстрее, чем экономия на зависимости.


Практика: первый HTTP-сервер TaskFlow

Соберём минимальный каркас TaskFlow на чистом Node: список задач в памяти, GET /tasks, POST /tasks, JSON-тело с лимитом и корректные ошибки. Этот же сервер в следующей статье переедет на Express, и разница в объёме кода будет видна.

import { createServer } from 'node:http';
import { randomUUID } from 'node:crypto';

const tasks = [];
const MAX_BODY = 16 * 1024;

class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

async function readJson(req) {
  const chunks = [];
  let size = 0;

  for await (const chunk of req) {
    size += chunk.length;
    if (size > MAX_BODY) throw new HttpError(413, 'payload too large');
    chunks.push(chunk);
  }

  try {
    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
  } catch {
    throw new HttpError(400, 'invalid json');
  }
}

function sendJson(res, status, payload) {
  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify(payload));
}

async function handle(req, res) {
  const url = new URL(req.url, 'http://localhost');

  if (req.method === 'GET' && url.pathname === '/health') {
    return sendJson(res, 200, { ok: true });
  }

  if (req.method === 'GET' && url.pathname === '/tasks') {
    return sendJson(res, 200, tasks);
  }

  if (req.method === 'POST' && url.pathname === '/tasks') {
    if (!req.headers['content-type']?.startsWith('application/json')) {
      throw new HttpError(415, 'expected application/json');
    }

    const body = await readJson(req);
    if (typeof body?.title !== 'string' || body.title.trim() === '') {
      throw new HttpError(422, 'title is required');
    }

    const task = { id: randomUUID(), title: body.title.trim(), done: false };
    tasks.push(task);
    return sendJson(res, 201, task);
  }

  throw new HttpError(404, 'not found');
}

const server = createServer((req, res) => {
  handle(req, res).catch((err) => {
    if (res.headersSent) {
      res.destroy();
      return;
    }
    const status = err.status ?? 500;
    sendJson(res, status, {
      error: status === 500 ? 'internal error' : err.message,
    });
    if (status === 500) console.error(err);
  });
});

server.listen(3000);

Что здесь уже пришлось написать самим: класс ошибки, чтение и лимит тела, проверку content-type, разбор маршрутов, обработку 404 и защиту от падения обработчика. Каждый пункт — кандидат на то, чтобы отдать его фреймворку.


Ошибки, обрывы и headersSent

Node не ловит исключения из обработчика. Синхронный throw внутри createServer((req, res) => ...) становится uncaughtException и роняет процесс, а отклонённый промис в async-обработчике — unhandledRejection. Поэтому обёртка с .catch() обязательна:

createServer((req, res) => {
  handle(req, res).catch((err) => sendError(res, err));
});

В sendError есть два разных сценария:

function sendError(res, err) {
  if (res.headersSent) {
    res.destroy(); // статус уже ушёл, честно оборвать соединение
    return;
  }

  const status = err.status ?? 500;
  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify({ error: status === 500 ? 'internal error' : err.message }));
}

Если заголовки уже отправлены, изменить статус нельзя: клиент получил 200 и начал читать тело. Единственный корректный выход — оборвать соединение, чтобы клиент увидел незавершённый ответ, а не «успешный» обрезанный JSON. Наружу при этом не отдают текст внутренней ошибки: 500 должен быть одинаковым для всех, а детали — в логах.

Отдельно обрабатывают уход клиента. Если он закрыл соединение, запись в res может выбросить ERR_STREAM_DESTROYED или EPIPE, а работа — продолжаться зря:

res.on('close', () => {
  if (!res.writableEnded) {
    // клиент ушёл до конца ответа: отменяем внешние вызовы
  }
});

Событие close на res срабатывает и при нормальном завершении, и при обрыве, поэтому проверка writableEnded отделяет одно от другого. Это же место — точка отмены AbortController для запросов в базу и внешние сервисы.

Наконец, ошибка чтения самого req (обрыв на середине тела) приходит событием error на потоке. Без слушателя она станет необработанным исключением, поэтому for await в try/catch — не формальность, а обязательная часть чтения тела.


Keep-alive и таймауты сокетов

HTTP/1.1 по умолчанию держит соединение открытым после ответа, чтобы следующий запрос не платил за TCP- и TLS-рукопожатие. Для сервера это значит, что сокет живёт дольше одного обработчика, а значит, нужны таймауты — иначе тысячи полуоткрытых соединений займут память и файловые дескрипторы.

НастройкаПо умолчаниюЧто ограничивает
server.keepAliveTimeout5000 мспростой между запросами на одном соединении
server.headersTimeout60000 мсвремя на приход всех заголовков
server.requestTimeout300000 мсвсё время обработки запроса
server.maxRequestsPerSocket0 (без лимита)число запросов на одном соединении
server.maxHeadersCount2000количество заголовков

headersTimeout — защита от slowloris: клиент, который присылает заголовки по байту в минуту, иначе держал бы соединение бесконечно. requestTimeout ограничивает уже принятый запрос, но не мешает обработчику продолжать работу после того, как клиент получил таймаут. keepAliveTimeout освобождает простаивающие соединения, и именно он чаще всего конфликтует с прокси.

Классическая гонка выглядит так: балансировщик считает соединение живым 60 секунд, а Node закрывает его через 5. Прокси отправляет запрос в сокет, который Node уже закрыл, и клиент получает 502 или ECONNRESET. Правило простое: серверный keepAliveTimeout должен быть больше idle-таймаута прокси, а headersTimeout — больше keepAliveTimeout.

server.keepAliveTimeout = 65_000;  // больше idle-таймаута nginx или ALB
server.headersTimeout = 66_000;    // больше keepAliveTimeout

Симметричное правило для клиента разобрано в статье «HTTP-клиенты в Node.js»: клиентский idle-таймаут держат меньше серверного.

Остановка сервера тоже связана с соединениями. server.close() перестаёт принимать новые подключения, но ждёт завершения текущих, а keep-alive-сокеты могут висеть до keepAliveTimeout. Для управляемого завершения есть closeIdleConnections() (закрыть простаивающие) и closeAllConnections() (оборвать все):

process.on('SIGTERM', () => {
  server.close(() => process.exit(0)); // ждём активные запросы
  server.closeIdleConnections();       // keep-alive не держит процесс
});

Без этого контейнер убивает процесс по таймауту, и часть запросов обрывается на середине ответа. Подробнее про дренаж и SIGTERM — в статье «Таймауты, ретраи и graceful shutdown».


HTTPS и терминация TLS

node:https — тот же сервер с TLS-слоем:

import { createServer } from 'node:https';
import { readFileSync } from 'node:fs';

const server = createServer(
  {
    key: readFileSync('certs/key.pem'),
    cert: readFileSync('certs/cert.pem'),
  },
  handler,
);

server.listen(443);

Разница не только в сертификатах. TLS-рукопожатие — дорогая операция: она тратит CPU, добавляет RTT и требует обновления сертификатов. Если сертификат истечёт, сервер продолжит работать, но клиенты получат ошибку проверки цепочки, поэтому сроки продления — часть эксплуатации, а не деталь конфигурации.

node:https умеет HTTP/1.1 поверх TLS. Для HTTP/2 нужен отдельный модуль node:http2 (createSecureServer), а ALPN согласует протокол с клиентом. Мультиплексирование в h2 меняет модель соединений: одно TCP-соединение несёт много параллельных запросов, и настройки keep-alive для него выглядят иначе.

На практике TLS почти всегда завершается до Node — на балансировщике, CDN или ingress. Приложение получает обычный HTTP на внутреннем порту и узнаёт исходную схему из x-forwarded-proto. Отсюда два следствия: сертификаты живут рядом с прокси, а приложение должно явно доверять заголовкам прокси и не строить абсолютные ссылки по req.headers.host, не проверив его.


Зачем нужен reverse proxy

Поставить nginx или ingress перед Node — не ритуал, а разделение обязанностей. Прокси берёт на себя то, что либо не относится к приложению, либо требует другого уровня контроля:

ЗадачаПочему не в Node
TLS-терминациясертификаты, OCSP, обновление — инфраструктурная задача
Медленные атакидержать тысячи полуоткрытых сокетов дешевле вне процесса приложения
Сжатие и кешобщие для всех инстансов, не тратят event loop
Статикаотдаётся с диска или CDN без запуска JS
Балансировканесколько инстансов приложения за одним адресом
Буферизация теламедленный клиент не занимает обработчик
Лимиты заголовков и размераединая политика до попадания в приложение

Для Node это ещё и защита единственного потока: если приложение само терминирует TLS и принимает медленные соединения, CPU уходит на рукопожатия, а не на бизнес-логику. За прокси Node занимается запросами, которые уже прошли проверку и буферизацию.

Обратная сторона — доверие к заголовкам. За прокси req.socket.remoteAddress всегда указывает на прокси, а реальный адрес приходит в x-forwarded-for. Этот заголовок можно подделать, если Node доступен напрямую, поэтому приложение либо слушает только внутренний интерфейс, либо явно ограничивает список доверенных прокси. То же касается x-forwarded-proto и x-request-id: они становятся доверенными только после проверки источника.


Частые ошибки

  • Нет res.end(). Клиент висит, сокет занят, keep-alive-пул исчерпывается.
  • res.setHeader после writeHead. ERR_HTTP_HEADERS_SENT и потерянный статус ошибки.
  • Нет лимита тела. Один запрос на гигабайт кладёт процесс в OOM.
  • Доверие content-length. Занижённое значение обходит проверку, chunked обходит её полностью.
  • JSON.parse без try/catch. 400 превращается в 500 и uncaughtException.
  • Нет обёртки для async-обработчика. Отклонённый промис не ловится Node.
  • Игнорирование false из res.write(). Буфер ответа растёт быстрее, чем сокет отправляет.
  • readFile для больших файлов. Память линейна по размеру файла и числу запросов.
  • keepAliveTimeout меньше, чем у прокси. Случайные 502 и ECONNRESET на ровном месте.
  • Node слушает публичный интерфейс без прокси. Нет лимитов, TLS и защиты от slowloris.
  • Доверие x-forwarded-for. Клиент подставляет любой адрес и обходит rate limit.
  • server.close() без закрытия idle-соединений. Деплой ждёт keepAliveTimeout и убивает процесс.

Эксперименты

Три запуска, которые показывают поведение сервера лучше любого описания.

1. Забытый res.end()

import { createServer } from 'node:http';

createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'text/plain' });
  res.write('partial'); // end() забыт
}).listen(3000);

curl -v http://localhost:3000 покажет заголовки и partial, но соединение не закроется: без content-length ответ идёт chunked, а завершающего чанка нет. Клиент будет ждать до своего таймаута, а сервер — держать сокет. Если добавить res.end(), ответ завершится сразу.

2. Поддельный Content-Length

import { createServer } from 'node:http';

createServer(async (req, res) => {
  const chunks = [];
  for await (const chunk of req) chunks.push(chunk);
  res.end(`received ${Buffer.concat(chunks).length} bytes`);
}).listen(3000);
curl -X POST http://localhost:3000 \
  -H 'content-type: text/plain' \
  -H 'content-length: 5' \
  --data 'hello world'

Node прочитает всё, что прислал клиент, и сервер ответит 11 bytes, хотя заголовок обещал 5. Вывод: content-length — подсказка для оптимизации, а реальный лимит считается по чанкам.

3. Один поток на всех

import { createServer } from 'node:http';

createServer((req, res) => {
  if (req.url === '/block') {
    const end = Date.now() + 3000;
    while (Date.now() < end) {} // синхронная работа
    res.end('blocked');
    return;
  }
  res.end('fast');
}).listen(3000);

Запустите два запроса параллельно: curl localhost:3000/block и сразу curl localhost:3000/. Второй ответ придёт только после того, как закончится цикл, — хотя / не делает ничего тяжёлого. Так выглядит блокировка event loop; чем занимать поток правильно — в статьях «Event Loop в Node.js» и «Worker Threads и cluster».


Ключевые тезисы для интервью

  • createServer вызывает обработчик на каждый запрос; req — читаемый поток тела, res — записываемый поток ответа, и res.end() обязателен всегда.
  • node:http не парсит тело, не маршрутизирует и не ловит исключения: лимит размера, JSON.parse, 404/405 и обёртка try/catch — ответственность приложения.
  • Content-Length — заявление клиента, а не гарантия; реальный лимит считают по прочитанным байтам, иначе chunked-запрос обходит проверку.
  • После первого write() заголовки зафиксированы; при ошибке с headersSent остаётся только res.destroy(), а не смена статуса.
  • Keep-alive продлевает жизнь сокета, поэтому таймауты согласуют с прокси: keepAliveTimeout больше idle-таймаута прокси, headersTimeout больше keepAliveTimeout.
  • Node обслуживает запросы в одном потоке, но неблокирующий I/O позволяет ждать сотням клиентов; синхронная работа в обработчике блокирует всех.
  • TLS и защиту от медленных атак чаще отдают reverse proxy, а Node за ним занимается только приложением и доверяет заголовкам прокси лишь после проверки источника.

Заключение

HTTP-сервер на чистом Node — это пара стримов и набор решений, которые фреймворк обычно скрывает: лимит тела, разбор маршрута, обработка ошибок, таймауты и завершение соединений. Понимание этих решений объясняет и 413, и зависшие запросы, и 502 после деплоя. Для узких задач чистого node:http достаточно, а для API с маршрутами и валидацией разумнее взять готовый слой — но уже осознанно, зная, что именно он делает за вас. Следующий шаг — Express и middleware, где та же логика собирается из готовых частей.

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