Какие существуют способы распределения нагрузки на бэкенд-серверы?

Question

Какие существуют способы распределения нагрузки на бэкенд-серверы?

Тип вопроса: Архитектура Вероятность: 10% Категория: Golang Разработчик

Ответ

Распределение нагрузки (Load Balancing) — это ключевая стратегия для повышения производительности, отказоустойчивости и масштабируемости приложений. Основная идея — распределить входящие запросы между несколькими серверами.

Основные алгоритмы балансировки:

Round Robin (Циклический) — самый простой метод. Запросы поочередно отправляются на каждый сервер в списке. Идеально для серверов с одинаковой производительностью.
Least Connections (Наименьшее количество соединений) — новый запрос направляется на сервер, у которого в данный момент меньше всего активных соединений. Эффективно, если запросы имеют разную "тяжесть".
IP Hash — сервер для обработки запроса выбирается на основе хеша IP-адреса клиента. Это гарантирует, что запросы от одного и того же клиента будут попадать на один и тот же сервер, что полезно для поддержания состояния сессии без распределенной системы хранения.

Инструменты:

Программные балансировщики: Nginx, HAProxy, Traefik.
Облачные балансировщики: AWS ALB/NLB, Google Cloud Load Balancer, Yandex Cloud Application Load Balancer.

Реализация простого балансировщика в Go:

Простой Round Robin балансировщик должен быть потокобезопасным. Для этого лучше использовать пакет sync/atomic.

import (
    "sync/atomic"
)

var servers = []string{"http://server1:8080", "http://server2:8080", "http://server3:8080"}
var current uint32

// getNextServer потокобезопасно возвращает следующий сервер из списка
func getNextServer() string {
    // Атомарно увеличиваем счетчик и получаем его новое значение
    // Операция % len(servers) обеспечивает цикличность
    idx := atomic.AddUint32(&current, 1) % uint32(len(servers))
    return servers[idx]
}

Комплексный подход:

Балансировка нагрузки — это часть общей стратегии. Она эффективно работает в связке с горизонтальным масштабированием (добавлением новых серверов) и кэшированием (Redis, Memcached) для снижения нагрузки на основные сервисы.

Ответ 18+ 🔞

А, слушай, распределение нагрузки, ёпта! Это ж такая штука, чтобы твоё приложение не легло, как мудак пьяный, от наплыва народу. Основная идея — не грузить один сервер, пока он не пиздец как задымится, а раскидать запросы по куче других. Чтобы всё летало, не падало и масштабировалось, как сумасшедшее.

Основные алгоритмы, на которых всё держится:

Round Robin (По кругу, блядь) — самый примитивный, но рабочий. Запросы тупо по очереди швыряет на каждый сервер в списке. Работает на ура, если все сервера — близнецы-братья по мощности.
Least Connections (Кому легче живётся) — тут уже умнее. Новый запрос полетит туда, где меньше всего текущих, ебаных, соединений висит. Незаменимо, когда один запрос — пустяк, а другой — целая эпопея.
IP Hash (Привязка к клиенту) — сервер выбирается по хешу от IP-адреса того, кто стучится. Это чтобы один и тот же юзер всегда попадал на одну и ту же машину. Полезная хуйня, если сессию хранить надо, а возиться с распределённым кешем — терпения ноль ебать.

Чем это делают:

Софт на своих серваках: Nginx, HAProxy, Traefik — классика, блядь.
Облачные готовые штуки: AWS ALB, Google Cloud Load Balancer, Yandex Cloud — заплатил и забыл, как страшный сон.

Самый простой балансировщик на Go, смотри:

Если делаешь Round Robin, то надо, чтобы в многопоточке не было пиздеца. Используй sync/atomic, не выёбывайся.

import (
    "sync/atomic"
)

var servers = []string{"http://server1:8080", "http://server2:8080", "http://server3:8080"}
var current uint32

// getNextServer — выдаёт следующий сервер так, чтобы всё было чётко и без гонок
func getNextServer() string {
    // Атомарно плюсуем счётчик, хуяк — и порядок
    // Деление с остатком (% len(servers)) делает из списка бесконечный круг
    idx := atomic.AddUint32(&current, 1) % uint32(len(servers))
    return servers[idx]
}

А вообще, смотри в корень:

Одна балансировка — это как одна подпорка для забора. Нужен комплексный подход, блядь! Её надо юзать вместе с горизонтальным масштабированием (просто плоди сервера, когда жарко) и кэшированием (воткни Redis или Memcached, чтобы одно и то же по сто раз не считать). Тогда будет тебе счастье, а не просто ещё один костыль в архитектуре.