Мне один раз прилетел p99 в четыреста миллисекунд при среднем в двенадцать. Среднее было красивое, дашборд зелёный, а люди жаловались. Я тогда полез в код, переписал два хендлера, выжал из них ещё немного — и p99 не сдвинулся вообще. Потому что стоял не в коде. Стоял в очереди к базе, которую никто не мерил. С тех пор я сначала считаю, потом оптимизирую, и эта тема ровно об этом.
Спор «Fastify или Nest» я слышал раз сто в разных формулировках. Обычно он звучит как выбор веры, и обычно за ним нет ни одной цифры, кроме чужого бенчмарка из статьи двухлетней давности. Я решил померить сам. Заодно проверить главный тезис: под 10k rps упираешься не в фреймворк.
Что реально стояло на машине
Тут сразу надо сказать неудобное, иначе весь текст ниже будет врать. На этой машине нет npm. npm install fastify не проходит — политика выполнения скриптов в PowerShell режет npm.ps1, а обойти её без прав администратора нечем. Значит настоящих пакетов в замере нет. Есть Node 24.21.0, четыре ядра и стандартная библиотека.
Поэтому я собрал не сами фреймворки, а их форму — тот конвейер, который они прогоняют вокруг хендлера, на node:http. У Fastify это таблица роутов, цепочка onRequest → preHandler, компилируемая по схеме валидация и сериализатор ответа. У Nest — DI-контейнер, контроллер, два guard-а, два interceptor-а, обёрнутых вокруг результата, два pipe-а на параметр и фильтр исключений сверху. Порядок вызовов и стоимость на запрос — те же. Пакетов нет, форма есть.
Это не то же самое, что поставить fastify@5 и @nestjs/core@11, и я не буду делать вид, что то же. Но если вопрос «сколько стоит конвейер на запрос», форма на него отвечает честно. Если вопрос «насколько быстрый именно Fastify», ответа у меня нет, и я его не выдумываю.
Три сервера, один набор маршрутов
Маршрута три: /ping — отдать JSON и ничего больше, /db — сходить в пул соединений, /stats — выдать внутреннее состояние. Пул настоящий: десять соединений, время «запроса» две миллисекунды через setTimeout, потому что базы здесь нет и поднимать Postgres без демона Docker я не могу. Важна не база, важна дисциплина очереди.
class DbPool {
constructor({ size = 10, serviceMs = 2 } = {}) {
this.size = size;
this.serviceMs = serviceMs;
this.active = 0;
this.queue = [];
this.maxQueue = 0;
}
query() {
this.total += 1;
return new Promise((resolve) => {
this.queue.push(resolve);
if (this.queue.length > this.maxQueue) this.maxQueue = this.queue.length;
this.pump();
});
}
pump() {
while (this.active < this.size && this.queue.length > 0) {
const resolve = this.queue.shift();
this.active += 1;
setTimeout(() => {
this.active -= 1;
resolve();
this.pump();
}, this.serviceMs);
}
}
stats() {
return {
size: this.size,
serviceMs: this.serviceMs,
active: this.active,
waiting: this.queue.length,
maxQueue: this.maxQueue,
ceiling_rps: Math.round(this.size / (this.serviceMs / 1000)),
};
}
}Двадцать строк, а вся суть темы внутри. ceiling_rps считается как соединения, делённые на время запроса. При десяти соединениях и двух миллисекундах это пять тысяч запросов в секунду — и это потолок для bare, для fastify-подобного и для nest-подобного одинаково, потому что он ниже конвейера и ему всё равно, что там сверху.
Первая попытка мерить была неправильной
Первый прогон дал на /ping полторы тысячи rps и p99 в сто пятьдесят миллисекунд. Я почти обрадовался — вот, фреймворки тормозят. Потом посмотрел на загрузку CPU и увидел, что генератор нагрузки жрёт больше, чем сервер. Один процесс Node с keep-alive агентом на восемьдесят сокетов упирается в свой event loop раньше, чем удалённая сторона. Я мерил клиент.
Вторая ошибка была тише. Я сделал последовательный замер через сокет — одно соединение, запрос за запросом — и получил восемьсот микросекунд на запрос у всех трёх, включая пустой сервер. Восемьсот микросекунд на loopback — это не фреймворк, это ядро, Nagle и переключения контекста. Разница между bare и nest в этих условиях тонет в шуме.
Тогда я вынес измерение из сокета совсем. Хендлер вызывается прямо в процессе, двести тысяч раз подряд, после двадцати тысяч прогрева. Из замера уходит сеть целиком, остаётся только то, что фреймворк делает между «запрос пришёл» и «ответ готов».
for (const [name, file] of modules) {
const mod = require(path.join(__dirname, file));
const fn = mod.handlePing;
for (let i = 0; i < warmup; i += 1) await fn(i);
const start = process.hrtime.bigint();
for (let i = 0; i < iters; i += 1) await fn(i);
const ns = Number(process.hrtime.bigint() - start);
out.push({ server: name, mean_us: Number((ns / iters / 1000).toFixed(3)) });
}Что получилось
Bare — 1,023 микросекунды на запрос. Fastify-подобный — 1,604. Nest-подобный — 4,613. Разница между формами почти в четыре с половиной раза, и это честное число: DI-контейнер, обёртки интерсепторов и guard-ы действительно стоят денег.
Дальше арифметика, без которой эти микросекунды ничего не значат. Умножаем на десять тысяч запросов в секунду. Bare съест 10,2 миллисекунды CPU в секунду. Fastify-подобный — 16. Nest-подобный — 46,1. В пересчёте на ядро это 1,2%, 1,6% и 4,6%. Разница между самой лёгкой и самой тяжёлой формой — 35,9 миллисекунды процессорного времени в секунду при нагрузке в десять тысяч запросов.
Тридцать шесть миллисекунд в секунду. Один лишний поход в базу за сотню запросов стоит дороже. Один запрос, который не попал в кэш и сходил на диск, стоит дороже. Вот и весь ответ на «что выбрать под 10k rps» — при таком масштабе оба варианта бесплатны, а бутылочное горлышко живёт в другом месте.
Потолок пула, или где действительно падает
Пул на десять соединений с запросом в две миллисекунды даёт пять тысяч rps. Не «примерно пять тысяч», а ровно: 10 / 0,002. Выше этой цифры запросы не начинают выполняться быстрее, они начинают стоять в очереди. В моём прогоне очередь доросла до сорока двух — при том, что реальный throughput был всего две тысячи. То есть сервер уже стоял в пробке, до потолка не дойдя, и стоял не из-за фреймворка.
Считается это в одну строчку на салфетке: сколько запросов в секунду вы хотите, умножить на сколько миллисекунд длится запрос, разделить на тысячу. Десять тысяч rps при запросе в одну миллисекунду — десять соединений. При пяти миллисекундах — пятьдесят. При двадцати — двести. Хотите двести соединений к Postgres? Postgres их не очень хочет, у него на каждое свой процесс и своя память, и на двухстах он начнёт задыхаться раньше, чем вы упрётесь в сеть.
Отсюда pgbouncer, и отсюда же правило, которое я выучил дорого: пул приложения и пул базы — это два разных пула, и считать надо оба. Приложение открывает двести соединений к pgbouncer, pgbouncer держит двадцать к Postgres в режиме транзакций. Всё влезает, ничего не падает.
Если всё равно падает — порядок действий
Первое: пересчитать пул. Не «поставлю сто на всякий случай», а rps × время запроса. Второе: pgbouncer, когда соединений нужно больше, чем база держит. Третье: кэш, потому что одинаковый SELECT на каждом запросе — это не нагрузка, это недоработка. Четвёртое: кластер, все ядра, SO_REUSEPORT, а в контейнере — один процесс на контейнер вместо cluster внутри. Пятое: убрать pm2, если он там есть, потому что рестартом в контейнере занимается оркестратор, и два менеджера процессов на один сервис — это два способа убить его одновременно.
Фреймворк в этой лестнице не встречается ни на одной ступени. Он не стена. Стена — это очередь, которую никто не посчитал, и p99, который никто не смотрел, потому что среднее было красивое.
Чего тут нет
Нет настоящих fastify и @nestjs/core — про причину я написал в начале, и повторять не буду. Нет Postgres и нет autocannon: первое не поднять без демона Docker, второе не поставить без npm. Нет десяти тысяч rps в живом прогоне — эта машина на четырёх ядрах выжимает около двух тысяч, и я не стал рисовать красивый график, которого не было.
Есть три сервера, которые запускаются, есть замер стоимости конвейера без сокета, есть арифметика, которая переносится на любую машину, и есть пул, в котором видно очередь. Схема на картинке парсит числа из transcript.txt — если прогон изменится, схема изменится вместе с ним, руками я туда ничего не вписывал.
В архиве: все три сервера, load.js с генератором, micro_inproc.js, bench.py с прогоном и медианами по трём повторам, capacity.py с таблицей на десять тысяч, results.json как есть и транскрипт. Запускается python bench.py, полный прогон — минуты три.