fullstack.org.ua

Load Balancer · fullstack.org.ua

Середній21 хв· Fullstack Team

Load Balancer

Розберете алгоритми балансування навантаження, health checks і розподіл трафіку між екземплярами сервісу.

Що таке Load Balancer

Load balancer, або балансувальник навантаження, розподіляє вхідні запити між кількома екземплярами одного сервісу.

Замість того щоб клієнти зверталися безпосередньо до конкретного сервера:

text

Клієнт → Сервер 1

вони звертаються до єдиної адреси балансувальника:

text

Клієнт → Load Balancer → Сервер 1
                         Сервер 2
                         Сервер 3

text

Сервер 1: 8 активних з’єднань
Сервер 2: 3 активних з’єднання
Сервер 3: 5 активних з’єднань

Новий запит → Сервер 2

javascript

const http = require('node:http');

const backends = [
  {
    name: 'backend-1',
    port: 3001,
    healthy: false,
  },
  {
    name: 'backend-2',
    port: 3002,
    healthy: false,
  },
];

let nextBackendIndex = 0;

function startBackend(backend) {
  const server = http.createServer((request, response) => {
    if (request.url === '/health') {
      response.writeHead(200, { 'Content-Type': 'application/json' });
      response.end(JSON.stringify({ status: 'ok' }));
      return;
    }

    response.writeHead(200, { 'Content-Type': 'application/json' });
    response.end(
      JSON.stringify({
        backend: backend.name,
        path: request.url,
      }),
    );
  });

  server.listen(backend.port, () => {
    console.log(`${backend.name} слухає порт ${backend.port}`);
  });
}

function checkBackend(backend) {
  return new Promise((resolve) => {
    const request = http.get(
      {
        hostname: '127.0.0.1',
        port: backend.port,
        path: '/health',
        timeout: 500,
      },
      (response) => {
        // Health check вважається успішним лише для статусів 2xx.
        const isHealthy =
          response.statusCode >= 200 && response.statusCode < 300;

        response.resume();
        resolve(isHealthy);
      },
    );

    request.on('timeout', () => {
      request.destroy();
      resolve(false);
    });

    request.on('error', () => {
      resolve(false);
    });
  });
}

async function updateHealthStatuses() {
  for (const backend of backends) {
    backend.healthy = await checkBackend(backend);
  }

  const statuses = backends
    .map((backend) => `${backend.name}: ${backend.healthy ? 'UP' : 'DOWN'}`)
    .join(', ');

  console.log(`Стан екземплярів: ${statuses}`);
}

function chooseBackend() {
  const healthyBackends = backends.filter((backend) => backend.healthy);

  if (healthyBackends.length === 0) {
    return null;
  }

  // Round robin виконується лише серед доступних екземплярів.
  const backend = healthyBackends[nextBackendIndex % healthyBackends.length];
  nextBackendIndex = (nextBackendIndex + 1) % healthyBackends.length;

  return backend;
}

const loadBalancer = http.createServer((request, response) => {
  const backend = chooseBackend();

  if (!backend) {
    response.writeHead(503, { 'Content-Type': 'application/json' });
    response.end(
      JSON.stringify({
        error: 'Усі екземпляри сервісу недоступні',
      }),
    );
    return;
  }

  const proxyRequest = http.request(
    {
      hostname: '127.0.0.1',
      port: backend.port,
      path: request.url,
      method: request.method,
      headers: request.headers,
    },
    (backendResponse) => {
      response.writeHead(
        backendResponse.statusCode,
        backendResponse.headers,
      );

      backendResponse.pipe(response);
    },
  );

  proxyRequest.on('error', () => {
    // У production тут також потрібні метрики та обмежене повторне виконання.
    if (!response.headersSent) {
      response.writeHead(502, { 'Content-Type': 'application/json' });
      response.end(
        JSON.stringify({
          error: 'Помилка з’єднання з backend',
        }),
      );
    } else {
      response.destroy();
    }
  });

  request.pipe(proxyRequest);
});

for (const backend of backends) {
  startBackend(backend);
}

setTimeout(async () => {
  await updateHealthStatuses();

  setInterval(updateHealthStatuses, 2000);

  loadBalancer.listen(3000, () => {
    console.log('Load balancer слухає порт 3000');
    console.log('Перевірка: curl http://localhost:3000/orders');
  });
}, 100);