Високопродуктивні сервери HTTP/2 та HTTP/3: Fastify, Node HTTP та keep-alive

Конвеєр обробки вхідного HTTP-запиту в Node.js:

[Мережевий пакет TCP SYN/ACK]
         │
         ▼
[Ядро ОС: Стек TCP/IP та буфер прийому сокета]
         │  (epoll_wait / kqueue сповіщення про готовність дескриптора)
         ▼
[libuv: uv_tcp_t -> uv_read_cb]
         │  (Виділення пам'яті через Buffer.allocUnsafe)
         ▼
[C++ Binding: node::StreamWrap / TCPWrap]
         │
         ▼
[llhttp Parser]: Потоковий аналіз байтів (URL, Заголовки, Чанки тіла)
         │
         ▼
[node:http: net.Socket та IncomingMessage]
         │  (Генерація події 'request' на екземплярі http.Server)
         ▼
[HTTP Framework Routing Engine]: Маршрутизація та виконання плагінів
         │  Fastify: Radix Tree (O(k)) ── проти ── Express: Лінійний масив (O(n))
         ▼
[V8 Serialization]: Відправка відповіді клієнту
         Fastify: fast-json-stringify (AOT-компільована конкатенація рядків)
         Express: JSON.stringify (Runtime C++ рефлексія властивостей об'єкта)

Порівняння диспетчеризації: Express (Лінійний список) проти Fastify (Radix Tree)

EXPRESS (Linear Middleware Pipeline - O(N)):
URL: /api/v1/users/42/orders
[Router] 
   │
   ├── Layer 0: match('/')? ──────────> Ні
   ├── Layer 1: match('/health')? ────> Ні
   ├── Layer 2: match('/auth/*')? ────> Ні
   ├── Layer 3: match('/api/v1/posts')> Ні
   └── Layer N: match('/api/v1/users/:id/orders') ──> Співпадіння (Після N регулярних виразів)

FASTIFY (find-my-way Radix Tree - O(k)):
URL: /api/v1/users/42/orders
[Root Node: "/api/v1/"]
       │
       ├── Node: "posts"
       └── Node: "users/"
              │
              └── Node: [param: id] (users/:id)
                     │
                     ├── Node: "/profile"
                     └── Node: "/orders" ───────> Обробник знайдено за 4 переходи!

import Fastify, { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";

// Інтерфейс корисного навантаження DTO
interface CreateOrderBody {
  userId: string;
  items: Array<{
    productId: string;
    quantity: number;
    price: number;
  }>;
  priority: boolean;
}

interface OrderParams {
  orderId: string;
}

// 1. Ініціалізація Fastify з тюнінгом мережевого ядра
const app: FastifyInstance = Fastify({
  logger: {
    level: "info",
    serializers: {
      req(req) {
        return { method: req.method, url: req.url, hostname: req.hostname };
      },
    },
  },
  // Захист від вичерпання дескрипторів та Slowloris атак
  connectionTimeout: 10000,
  keepAliveTimeout: 65000, // Узгоджено з таймаутами L7 балансувальника
  maxParamLength: 128,
  bodyLimit: 1048576, // Жорсткий ліміт тіла: 1 MB
});

// 2. Декларативна JSON-схема для компіляції в AJV та fast-json-stringify
const orderResponseSchema = {
  type: "object",
  properties: {
    id: { type: "string" },
    status: { type: "string" },
    totalAmount: { type: "number" },
    processedAt: { type: "string" },
  },
  required: ["id", "status", "totalAmount", "processedAt"],
} as const;

const createOrderSchema = {
  body: {
    type: "object",
    required: ["userId", "items", "priority"],
    properties: {
      userId: { type: "string", format: "uuid" },
      priority: { type: "boolean" },
      items: {
        type: "array",
        minItems: 1,
        items: {
          type: "object",
          required: ["productId", "quantity", "price"],
          properties: {
            productId: { type: "string" },
            quantity: { type: "integer", minimum: 1 },
            price: { type: "number", minimum: 0 },
          },
        },
      },
    },
  },
  response: {
    201: orderResponseSchema,
  },
} as const;

// 3. Реєстрація маршруту зі скомпільованою схемою
app.post<{ Body: CreateOrderBody }>(
  "/api/v1/orders",
  { schema: createOrderSchema },
  async (request: FastifyRequest<{ Body: CreateOrderBody }>, reply: FastifyReply) => {
    const { userId, items } = request.body;

    const totalAmount = items.reduce(
      (sum, item) => sum + item.quantity * item.price,
      0
    );

    // Fastify серіалізує відповідь через скомпільовану функцію fast-json-stringify
    reply.status(201);
    return {
      id: "ord_9873491823",
      status: "CONFIRMED",
      totalAmount,
      processedAt: new Date().toISOString(),
    };
  }
);

// 4. Запуск сервера з коректним життєвим циклом завершення (Graceful Shutdown)
async function bootstrap() {
  try {
    const address = await app.listen({ port: 3000, host: "0.0.0.0" });
    console.log(`[Fastify] Вузол кластера слухає ${address}`);
  } catch (err) {
    app.log.error(err);
    process.exit(1);
  }
}

const signals: NodeJS.Signals[] = ["SIGINT", "SIGTERM"];
for (const signal of signals) {
  process.on(signal, async () => {
    console.log(`\n[Fastify] Отримано сигнал ${signal}, закриття пулу з'єднань...`);
    await app.close();
    process.exit(0);
  });
}

bootstrap();

import http2, { Http2Server, Http2Stream, IncomingHttpHeaders } from "node:http2";
import fs from "node:fs";
import path from "node:path";

// Завантаження сертифікатів для взаємної mTLS аутентифікації
const certPath = path.resolve(process.cwd(), "certs");

const server: Http2Server = http2.createSecureServer({
  key: fs.readFileSync(path.join(certPath, "server-key.pem")),
  cert: fs.readFileSync(path.join(certPath, "server-cert.pem")),
  ca: fs.readFileSync(path.join(certPath, "ca-cert.pem")),
  // Вимагаємо взаємну аутентифікацію клієнта (mTLS)
  requestCert: true,
  rejectUnauthorized: true,
  // Тюнінг специфікації HTTP/2
  settings: {
    maxConcurrentStreams: 1000,
    initialWindowSize: 1048576, // 1 MB Window Size для Flow Control
    maxHeaderListSize: 16384,
    enablePush: false, // Server Push вимкнено за рекомендаціями RFC 9113
  },
});

server.on("error", (err) => {
  console.error("[HTTP2 Server Error]:", err);
});

// Керування сесіями мультиплексування
server.on("session", (session) => {
  session.on("error", (err) => {
    console.error("[HTTP2 Session Error]:", err);
  });
});

// Обробка логічних потоків (Streams) усередині одного TCP-з'єднання
server.on("stream", (stream: Http2Stream, headers: IncomingHttpHeaders) => {
  const method = headers[":method"];
  const pathHeader = headers[":path"];

  console.log(`[HTTP2 Stream ${stream.id}] Запит: ${method} ${pathHeader}`);

  if (method === "GET" && pathHeader === "/api/v2/stream-data") {
    // Відправка заголовків через бінарний HEADERS фрейм із HPACK-стисненням
    stream.respond({
      ":status": 200,
      "content-type": "application/json; charset=utf-8",
      "x-protocol-transport": "h2-multiplexed",
    });

    // Потокова відправка даних через фрагментовані DATA фрейми
    let counter = 0;
    const interval = setInterval(() => {
      counter++;
      const payload = JSON.stringify({
        sequence: counter,
        timestamp: Date.now(),
        nodeAllocatedMemory: process.memoryUsage().heapUsed,
      });

      // Передача даних без закриття потоку (endStream = false)
      stream.write(payload + "\n");

      if (counter >= 10) {
        clearInterval(interval);
        // Завершення стриму відправкою фінального фрейма з прапорцем END_STREAM
        stream.end();
      }
    }, 50);

    stream.on("close", () => {
      clearInterval(interval);
    });
  } else {
    stream.respond({ ":status": 404 });
    stream.end(JSON.stringify({ error: "Route not found" }));
  }
});

server.listen(8443, "0.0.0.0", () => {
  console.log("[HTTP2 mTLS] Високопродуктивний сервер HTTP/2 слухає порт 8443");
});

Схема Race Condition при невідповідності KeepAliveTimeout:

[Балансувальник AWS ALB / NGINX]                 [Сервер Node.js]
(KeepAliveTimeout = 60s)                          (KeepAliveTimeout = 60s)
          │                                                 │
          │ ─── 59.99s: Повторний запит у сокет ─────────> │
          │                                                 │ ── 60.00s: Спрацьовує таймаут!
          │                                                 │ ── Node.js закриває сокет (FIN/RST)
          │ <─── Пакет TCP RST (Connection Reset) ───────── │
          │
    [HTTP 502 Bad Gateway!]

// Конфігурація для запобігання стану перегонів
const server = http.createServer(app);

// Якщо таймаут NGINX/ALB дорівнює 60 секундам:
server.keepAliveTimeout = 65000; // 65 секунд (> 60s)
server.headersTimeout = 66000;   // 66 секунд (> keepAliveTimeout)
server.requestTimeout = 120000;  // 120 секунд загальний таймаут тіла