HTTP-сервер на чистом Node
Любой Node-фреймворк — это надстройка над node:http, но пока не видно, что именно он скрывает, его поведение выглядит магией. Один незакрытый ответ, забытый лимит на тело или неверный таймаут сокета превращают сервис в источник зависших соединений. Разберём, как устроен HTTP-сервер на чистом Node, что приходится делать вручную и где проходит граница, после которой нужен фреймворк и reverse proxy.
Содержание
- Почему стоит уметь поднять сервер без фреймворка
- createServer и пара req/res
- Метод, URL и заголовки
- Ответ: статус, заголовки, тело
- Чтение тела запроса
- Ручной routing и его предел
- Практика: первый HTTP-сервер TaskFlow
- Ошибки, обрывы и headersSent
- Keep-alive и таймауты сокетов
- HTTPS и терминация TLS
- Зачем нужен reverse proxy
- Частые ошибки
- Эксперименты
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Почему стоит уметь поднять сервер без фреймворка
Фреймворк не отменяет 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');
});
Два объекта в аргументах — это два стрима с разными ролями:
| Объект | Класс | Роль | Ключевое |
|---|---|---|---|
req | http.IncomingMessage | читаемый поток тела запроса | метод, URL, заголовки, чанки тела |
res | http.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.keepAliveTimeout | 5000 мс | простой между запросами на одном соединении |
server.headersTimeout | 60000 мс | время на приход всех заголовков |
server.requestTimeout | 300000 мс | всё время обработки запроса |
server.maxRequestsPerSocket | 0 (без лимита) | число запросов на одном соединении |
server.maxHeadersCount | 2000 | количество заголовков |
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, где та же логика собирается из готовых частей.
Полезные ссылки
- node:http —
createServer,IncomingMessage,ServerResponse, таймауты - node:https — TLS-сервер и опции сертификатов
- Anatomy of an HTTP Transaction — как Node обрабатывает запрос от сокета до ответа
- HTTP/1.1: Message Syntax and Routing — заголовки,
content-length, chunked и keep-alive - Стримы и backpressure —
pipeline,highWaterMarkи потоковая отдача ответа - Встроенные модули Node.js —
Buffer,processи работа с файлами