Load balacer info

info.txt

Есть несколько алгоритмов балансировки нагрузки, которые могут быть использованы в балансировщиках нагрузки. Вот несколько примеров:

Round Robin (циклический):
Балансировщик нагрузки последовательно отправляет запросы к каждому серверу в циклическом порядке.
Каждый следующий запрос отправляется на следующий сервер в списке.
Этот алгоритм прост в реализации, но не учитывает текущую нагрузку серверов.
Least Connection (с наименьшим количеством соединений):
Балансировщик нагрузки направляет запросы к серверу с наименьшим количеством активных соединений.
Это позволяет распределить нагрузку равномерно между серверами в зависимости от их текущей загрузки.
Однако этот алгоритм требует отслеживания состояния каждого соединения на всех серверах.
IP Hashing (хэширование IP-адреса):
Балансировщик нагрузки хэширует IP-адрес клиента и использует полученное значение для определения сервера, на который будет отправлен запрос.
Это позволяет обеспечить стабильность маршрутизации для клиентов с одним и тем же IP-адресом.
Однако, если количество клиентов с одним IP-адресом невелико, нагрузка может быть неравномерно распределена.
Weighted Round Robin (взвешенный циклический):
Каждому серверу присваивается вес, который указывает его пропорцию получаемой нагрузки.
Балансировщик нагрузки отправляет запросы в соответствии с весами серверов.
Это позволяет учитывать различные возможности серверов и более точно распределять нагрузку.
Random (случайный):
Балансировщик нагрузки выбирает случайный сервер из доступного списка и отправляет запрос на него.
Этот алгоритм прост в реализации, но не обеспечивает равномерное распределение нагрузки.
Это только некоторые алгоритмы балансировки нагрузки. Фактический выбор алгоритма зависит от требований конкретной системы и ее характеристик.

load_balacer.cpp

#include <iostream>
#include <boost/asio.hpp>
#include <vector>

using boost::asio::ip::tcp;

class LoadBalancer {
public:
  LoadBalancer(boost::asio::io_context& io_context, const std::vector<std::string>& servers)
    : io_context_(io_context), server_index_(0), servers_(servers)
  {
    for (const auto& server : servers_) {
      tcp::resolver resolver(io_context_);
      tcp::resolver::results_type endpoints = resolver.resolve(server, "80");
      tcp::socket socket(io_context_);
      boost::asio::connect(socket, endpoints);
      server_sockets_.push_back(std::move(socket));
    }
  }

  void run() {
    tcp::acceptor acceptor(io_context_, tcp::endpoint(tcp::v4(), 8080));
    acceptor.async_accept(
        [this](boost::system::error_code ec, tcp::socket socket) {
          if (!ec) {
            handle_request(std::move(socket));
          }

          run();
        });
  }

private:
  void handle_request(tcp::socket socket) {
    if (server_index_ >= servers_.size()) {
      server_index_ = 0;
    }

    tcp::socket& server_socket = server_sockets_[server_index_];
    server_index_++;

    boost::asio::async_write(
        server_socket, boost::asio::buffer("Hello from Load Balancer"),
        [this, &socket](boost::system::error_code ec, std::size_t length) {
          if (!ec) {
            boost::asio::streambuf response_buffer;
            boost::asio::async_read_until(
                server_socket, response_buffer, "\r\n",
                [this, &socket, &response_buffer](boost::system::error_code ec, std::size_t length) {
                  if (!ec) {
                    std::istream response_stream(&response_buffer);
                    std::string response;
                    std::getline(response_stream, response);
                    std::cout << "Response from server: " << response << std::endl;
                    boost::asio::async_write(
                        socket, boost::asio::buffer(response),
                        [this](boost::system::error_code ec, std::size_t length) {
                          // Handle completion of writing response to client
                        });
                  }
                });
          }
        });
  }

  boost::asio::io_context& io_context_;
  std::size_t server_index_;
  std::vector<std::string> servers_;
  std::vector<tcp::socket> server_sockets_;
};

int main() {
  boost::asio::io_context io_context;
  std::vector<std::string> servers = {"localhost", "127.0.0.1"};

  LoadBalancer load_balancer(io_context, servers);
  load_balancer.run();

  io_context.run();

  return 0;
}