Как называется вид балансировки, при которой трафик поступает на один сервер группы?

Как называется вид балансировки, при которой трафик поступает на один сервер группы?

Это называется Sticky Session (липкая сессия) или Session Affinity (сродство сессии) в контексте веб-приложений.

Однако более точный ответ в контексте балансировки нагрузки: Least Connections (наименьшее количество соединений) или Source IP Hash (хеш исходного IP), если речь идёт о том, что конкретный клиент всегда идёт на один и тот же сервер.

Типы балансировки нагрузки

1. Round Robin (Циклическая балансировка)

Трафик распределяется поочередно между серверами:

Программа обычного распределения:
Процесс 1 → Сервер 1
Процесс 2 → Сервер 2
Процесс 3 → Сервер 3
Процесс 4 → Сервер 1 (цикл повторяется)

import itertools

servers = ["server1", "server2", "server3"]
requests = [f"request_{i}" for i in range(10)]

server_cycle = itertools.cycle(servers)
for request in requests:
    server = next(server_cycle)
    print(f"{request} → {server}")

# Вывод:
# request_0 → server1
# request_1 → server2
# request_2 → server3
# request_3 → server1

2. Least Connections (Наименьшее количество соединений)

Трафик идёт на сервер с наименьшим количеством активных соединений:

class LoadBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.connections = {server: 0 for server in servers}
    
    def get_server(self):
        # Выбираем сервер с минимальным количеством соединений
        return min(self.connections, key=self.connections.get)
    
    def add_connection(self):
        server = self.get_server()
        self.connections[server] += 1
        return server
    
    def remove_connection(self, server):
        self.connections[server] -= 1

balancer = LoadBalancer(["server1", "server2", "server3"])

print(balancer.add_connection())  # server1 (0 → 1)
print(balancer.add_connection())  # server2 (0 → 1)
print(balancer.add_connection())  # server3 (0 → 1)
print(balancer.add_connection())  # server1 (1 → 2) - все равны, выбираем first

balancer.remove_connection("server1")
print(balancer.add_connection())  # server1 (1 → 2)

3. Source IP Hash (Хеш исходного IP)

Клиент с одного IP всегда идёт на один и тот же сервер:

import hashlib

class HashBalancer:
    def __init__(self, servers):
        self.servers = servers
    
    def get_server(self, client_ip):
        # Вычисляем хеш IP и выбираем сервер
        hash_value = int(hashlib.md5(client_ip.encode()).hexdigest(), 16)
        server_index = hash_value % len(self.servers)
        return self.servers[server_index]

balancer = HashBalancer(["server1", "server2", "server3"])

# Один и тот же IP всегда идёт на один сервер
print(balancer.get_server("192.168.1.100"))  # server1
print(balancer.get_server("192.168.1.100"))  # server1 (одинаково)
print(balancer.get_server("192.168.1.101"))  # server2 (другой IP)
print(balancer.get_server("192.168.1.101"))  # server2 (одинаково)

4. Weighted Round Robin (Взвешенная циклическая балансировка)

Сервера имеют разные веса (мощность):

class WeightedBalancer:
    def __init__(self, servers_with_weights):
        # servers_with_weights = [("server1", 1), ("server2", 2), ("server3", 3)]
        self.servers = []
        for server, weight in servers_with_weights:
            self.servers.extend([server] * weight)
    
    def __init__(self, servers_with_weights):
        self.servers = []
        for server, weight in servers_with_weights:
            self.servers.extend([server] * weight)
        self.current = 0
    
    def get_server(self):
        server = self.servers[self.current]
        self.current = (self.current + 1) % len(self.servers)
        return server

balancer = WeightedBalancer([
    ("server1", 1),  # Слабый сервер
    ("server2", 2),  # Средний сервер
    ("server3", 3),  # Мощный сервер
])

# server3 получит 3/6 = 50% трафика
for i in range(6):
    print(balancer.get_server())
# Вывод: server1, server2, server2, server3, server3, server3

5. Sticky Sessions (Липкие сессии)

Особенно важна для веб-приложений с состоянием (без распределённого кеша):

class StickySessionBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.sessions = {}  # session_id -> server
    
    def get_server(self, session_id):
        if session_id not in self.sessions:
            # Новая сессия, выбираем случайный сервер
            self.sessions[session_id] = self.servers[
                hash(session_id) % len(self.servers)
            ]
        return self.sessions[session_id]

balancer = StickySessionBalancer(["server1", "server2", "server3"])

# Один пользователь (сессия) всегда идёт на один сервер
print(balancer.get_server("user123"))  # server1
print(balancer.get_server("user123"))  # server1 (одинаково)
print(balancer.get_server("user456"))  # server2 (другой пользователь)
print(balancer.get_server("user456"))  # server2 (одинаково)

Практический пример с Nginx

# Round Robin (по умолчанию)
upstream backend {
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com;
}

# Least Connections
upstream backend_lc {
    least_conn;
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com;
}

# IP Hash (Sticky Sessions)
upstream backend_hash {
    ip_hash;
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com;
}

# Weighted (с весами)
upstream backend_weighted {
    server backend1.example.com weight=1;
    server backend2.example.com weight=2;
    server backend3.example.com weight=3;
}

server {
    listen 80;
    
    location / {
        # Используем нужный upstream
        proxy_pass http://backend_hash;  # IP Hash
    }
}

Сравнение методов

Когда использовать

Round Robin — для однородных серверов Least Connections — для долгоживущих соединений (WebSocket, SSH) IP Hash / Sticky Sessions — для stateful приложений (без распределённого кеша) Weighted — для серверов разной мощности

Ответ на ваш вопрос: Sticky Session / Session Affinity (если речь о том, что трафик от одного клиента идёт на один сервер) или Source IP Hash (если по IP).