Какой алгоритм балансировки в Nginx выбрать: короткий ответ
Начните с round-robin. Это поведение upstream по умолчанию, и для однородных stateless-бэкендов с короткими предсказуемыми запросами его хватает. Меняйте алгоритм под конкретную проблему, а не «на всякий случай»: иначе вы добавляете зависимость от состояния, которую потом придётся обслуживать.
Карта решений на четыре строки:
| Задача | Метод | Почему он |
|---|---|---|
| Stateless API, бэкенды одинаковой мощности | round-robin | Равномерная очередь без хранения состояния на балансировщике |
| Время обработки запросов сильно различается | least_conn | Смотрит на активные соединения, а не на позицию в списке |
| Сессии живут в памяти бэкенда | hash $cookie_sessionid consistent | Привязка по cookie переживает NAT и смену IP |
| Кэш или шардирование по URL | hash $request_uri consistent | Один ключ всегда попадает на один и тот же бэкенд |
Два предупреждения перед копированием конфигов. ip_hash не решает проблему липких сессий полностью: клиенты за общим NAT, корпоративным прокси или CDN приходят с одного адреса и получают один бэкенд, а перезагрузка роутера меняет IP и рвёт сессию. hash без параметра consistent даёт лавину перераспределения при изменении числа серверов: по документации Nginx в этом случае значительная часть ключей может быть переназначена на другие серверы, кэш обнуляется, latency растёт (Module ngx_http_upstream_module).
Примеры ниже опираются на директивы модуля ngx_http_upstream_module, документированные в актуальной документации Nginx open source: upstream, server, least_conn, ip_hash, hash, keepalive (Модуль ngx_http_upstream_module). Отдельные изменения появились в поздних версиях (например, с 1.29.7 кэш keepalive-соединений с upstream включён по умолчанию), поэтому сверяйте поведение с документацией своей версии. Директивы алгоритма вставляются внутрь блока upstream, который объявляется в контексте http. Перед reload проверяйте синтаксис командой nginx -t.
Базовый upstream и как Nginx распределяет запросы
Блок upstream получает имя, на которое ссылается proxy_pass. Минимальная рабочая конфигурация с тремя бэкендами:
http {
upstream backend {
server 10.0.0.1:8080;
server 10.0.0.2:8080;
server 10.0.0.3:8080;
}
server {
listen 80;
server_name app.example.com;
location / {
proxy_pass http://backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
}
Без директивы алгоритма Nginx применяет round-robin ко всему блоку. Директива алгоритма действует на весь upstream и не задаётся для отдельной строки server. Строки server принимают параметры: weight (вес сервера, по умолчанию 1), max_fails (число неудачных попыток, по умолчанию 1), fail_timeout (время, в течение которого сервер считается недоступным, по умолчанию 10s), backup (запасной сервер, на который передаются соединения, если не работают основные) и down (ручное исключение из ротации) (Модуль ngx_http_upstream_module).
Смысл конструкции простой: балансировка распределяет входящий трафик между несколькими серверами, чтобы ни один из них не был перегружен, и для высоконагруженных сайтов это критично (глоссарий по веб-инфраструктуре). Nginx при этом работает как обратный прокси: часто он совмещает распределение запросов с SSL-терминацией и кэшированием ответов. Практическое руководство по связке location, upstream и proxy_pass с готовыми конфигурациями есть в материале о маршрутизации трафика в Nginx.
Применение изменений:
nginx -t nginx -s reload
Первая команда проверяет синтаксис и доступность файлов, вторая перечитывает конфигурацию без разрыва уже установленных соединений. Restart не нужен и на живом трафике вреден.
round-robin: алгоритм по умолчанию и его границы
Конфиг без директивы алгоритма:
upstream backend {
server 10.0.0.1:8080;
server 10.0.0.2:8080;
server 10.0.0.3:8080;
}
Запросы идут по кругу в порядке перечисления. Параметр weight меняет долю: weight=3 против weight=1 даёт примерно три запроса на первый сервер и один на второй. backup добавляется в ротацию только тогда, когда все основные помечены как недоступные по max_fails и fail_timeout.
Сценарий, где метода достаточно: stateless API, бэкенды с одинаковым железом, короткие запросы к БД, одинаковое время ответа. В такой схеме нет состояния на балансировщике, поведение предсказуемо, а отладка сводится к подсчёту строк в логе.
Границы начинаются там, где запросы перестают быть одинаковыми. Round-robin не знает текущую загрузку сервера и не учитывает время обработки: он смотрит только на порядок и веса. Пример из практики расчёта: три бэкенда, один из которых отвечает в пять раз дольше из-за медленного запроса к внешнему API. Доли останутся равными, поэтому медленный узел будет накапливать соединения и первым упрётся в лимит воркеров. Аналогично при разнородных по мощности серверах доли приходится выставлять вручную через weight и пересматривать их при каждом изменении парка.
Проверка распределения через access.log:
log_format balance '$upstream_addr $upstream_response_time $status'; access_log /var/log/nginx/balance.log balance;
awk '{print $1}' /var/log/nginx/balance.log | sort | uniq -c | sort -rn
Вывод покажет, сколько запросов ушло на каждый адрес и насколько ровно лежат доли. Если разброс больше ожидаемого по весам, смотрите на health-состояние узлов и на время ответа во второй колонке.
least_conn: когда он выигрывает у round-robin
Конфиг с весами и пулом keepalive-соединений к бэкендам:
upstream backend {
least_conn;
server 10.0.0.1:8080 weight=3;
server 10.0.0.2:8080 weight=1;
server 10.0.0.3:8080 backup;
keepalive 32;
}
server {
location / {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
}
}
Механика: запрос уходит на сервер с наименьшим числом активных соединений, вес также учитывается. Директива keepalive в upstream держит пул соединений к бэкендам, а proxy_http_version 1.1 и пустой Connection нужны, чтобы пул вообще работал (Модуль ngx_http_upstream_module).
Когда least_conn выигрывает у round-robin:
- Время обработки запросов различается в разы: тяжёлые отчёты, выгрузки, аплоады, запросы к медленной БД.
- Бэкенды разной мощности: соединения сами перетекают на быстрые узлы, ручной weight нужен только как поправка.
- Всплески трафика, при которых часть соединений висит долго, а часть закрывается мгновенно.
- Часть узлов работает в деградированном режиме и отвечает медленнее остальных.
Когда разницы почти нет: одинаковые быстрые stateless-сервисы с запросами по 5-20 мс. В этом режиме число активных соединений на всех узлах колеблется около одного-двух, и least_conn даёт ту же картину, что round-robin, только с дополнительным состоянием на балансировщике.
Ограничение, о котором забывают: least_conn считает соединения, а не реальную загрузку CPU, памяти или диска. Узел с деградировавшим диском может держать мало соединений и продолжать получать запросы. Второй нюанс связан с keepalive: соединение живёт после ответа, счётчик учитывает открытые соединения, а не только обрабатываемые запросы. Поэтому large keepalive-пулы меняют картину распределения. Схему с проверками состояния и таймаутами для отказоустойчивого кластера разбираем в материале о балансировке и проксировании на Nginx.
ip_hash: липкие сессии и почему метод не решает всех задач
Конфиг:
upstream backend {
ip_hash;
server 10.0.0.1:8080;
server 10.0.0.2:8080;
server 10.0.0.3:8080;
}
Механика: в качестве ключа хеширования используются первые три октета IPv4-адреса клиента или IPv6-адрес клиента целиком, и метод гарантирует, что запросы одного и того же клиента всегда передаются на один и тот же сервер (Модуль ngx_http_upstream_module). Для IPv4 это означает, что все клиенты одной подсети /24 дают одинаковый хеш и попадают на один сервер: первые три октета у них совпадают, и оснований для распределения по разным серверам нет (Как избежать 10 частых ошибок в настройке NGINX). Это удобно для быстрого включения липких сессий в приложении, которое хранит сессию в памяти процесса и не имеет внешнего хранилища.
Ограничения перечисляем явно, потому что каждое встречается в продакшене:
- NAT, корпоративный прокси, мобильный оператор или CDN: тысячи клиентов приходят с одного адреса и уезжают на один бэкенд. Распределение превращается в перекос, остальные узлы простаивают.
- Смена IP: переключение с Wi-Fi на LTE, перезагрузка роутера, смена вышки. Хеш считается заново, клиент попадает на другой сервер и теряет сессию.
- Отказ узла: клиенты этого бэкенда теряют сессии. Запросы уйдут на живой сервер, но состояние осталось на упавшем.
- Малое число клиентов: распределение неравномерно по определению, при десяти адресах и трёх серверах возможен перекос 7 к 2 к 1.
- weight с ip_hash работает ограниченно: первична привязка по хешу, а не доли.
- Изменение состава серверов пересобирает соответствия: добавление узла переносит часть клиентов на новые адреса.
Вывод: ip_hash — быстрый компромисс на время, а не архитектурное решение. Правильнее вынести сессии в Redis или БД, а привязку делать по cookie. Вариант с cookie в upstream:
upstream backend {
hash $cookie_sessionid consistent;
server 10.0.0.1:8080;
server 10.0.0.2:8080;
server 10.0.0.3:8080;
}
Такой конфиг требует, чтобы cookie выставлялась до балансировки, например на этом же Nginx или на предыдущем слое. Клиент за NAT перестаёт быть проблемой: ключом становится идентификатор сессии, а не адрес.
hash по ключу: детерминированное распределение для кэша и шардирования
Конфиг:
upstream backend {
hash $request_uri consistent;
server 10.0.0.1:8080;
server 10.0.0.2:8080;
server 10.0.0.3:8080;
}
Выбор ключа задаёт поведение всей схемы:
- $request_uri для кэша страниц и статики: один URL всегда обслуживает один бэкенд.
- $arg_id или другой query-параметр, когда объект определяется параметром запроса.
- $cookie_sessionid для привязки по пользователю без хранения сессии на бэкенде.
- Составной ключ, например $scheme$host$request_uri, когда один и тот же путь на разных доменах должен попадать на разные узлы.
Необязательный параметр consistent включает кетамовскую балансировку с согласованным хешированием: при добавлении или удалении сервера из группы переназначается лишь небольшая часть ключей, что минимизирует промахи кэша (HTTP Load Balancing, NGINX Documentation). Без параметра consistent изменение состава серверов может привести к переназначению большинства ключей на другие серверы; с consistent используется согласованное хеширование и переназначается только несколько ключей (Module ngx_http_upstream_module). Для кэша это разница между аккуратным частичным промахом и лавиной промахов с ростом latency и нагрузкой на источник данных.
Сценарии: кэширующие прокси перед приложением, шардирование по ключу, привязка к бэкенду с локальным кэшем или локальным диском.
Ограничения: распределение неравномерно при малом числе ключей и при «горячем» ключе, который собирает большую долю трафика. Смена ключа меняет бэкенд: добавили в URL query-параметр, и объект переехал на другой сервер. hash не спасает от перегрузки одного горячего ключа, для этого нужны отдельные меры: кэш на стороне клиента, дробление ключа или выделенный пул.
Сравнительная таблица: метод под тип приложения
| Тип приложения | Метод | Ключевая директива | Главное ограничение | Когда не подходит |
|---|---|---|---|---|
| Stateless API, одинаковые бэкенды | round-robin | server без директивы алгоритма | Не учитывает загрузку и время ответа | Запросы сильно различаются по длительности |
| Stateless API с неравными запросами | least_conn | least_conn | Считает соединения, а не CPU и диск | Все запросы короткие и одинаковые |
| Сессии в памяти бэкенда | hash по cookie | hash $cookie_sessionid consistent | Нужна cookie до балансировки | Cookie ещё не выставлена на этом слое |
| Сессии, быстрый компромисс | ip_hash | ip_hash | NAT, CDN и смена IP ломают привязку | Клиенты за общим прокси или CDN |
| Кэш страниц, шардирование по URL | hash по ключу | hash $request_uri consistent | Горячий ключ собирает трафик | Мало ключей или один доминирующий URL |
| Разнородные по мощности бэкенды | least_conn + weight | least_conn, server weight | Веса нужно пересматривать при изменении парка | Железо и нагрузка одинаковые |
| Клиенты за NAT или CDN | hash по cookie | не ip_hash | Требуется общее хранилище сессий для отказоустойчивости | Приложение не умеет отдавать cookie |
Таблица самодостаточна для первичного выбора: определите тип приложения, возьмите директиву и проверьте колонку ограничений на своём окружении.
Проверка конфига и безопасный ввод в прод
Порядок действий перед reload:
- Проверить синтаксис: nginx -t. Конфиг с ошибкой не применится, но и прод не тронет.
- Перечитать конфигурацию: nginx -s reload. Процессы завершают текущие соединения и подхватывают новые.
- Посмотреть реальное распределение в access.log с полями $upstream_addr и $upstream_response_time, а не полагаться на предположения.
- Прогнать серию запросов curl по одному URL и сверить бэкенд. Удобно, если приложение отдаёт заголовок с именем узла.
- Для ip_hash проверять с разных IP, а не с одной машины: иначе тест всегда покажет один бэкенд и вы ничего не увидите.
- Для hash менять ключ и смотреть, как перераспределяются запросы: так проверяется, что выбранный ключ действительно соответствует объекту.
for i in $(seq 1 10); do curl -sI http://app.example.com/ | grep -i x-backend; done
Если бэкенд не отдаёт заголовок с именем, ориентируйтесь на лог: он покажет $upstream_addr для каждого запроса. Для быстрой проверки перед кэшем запросов добавляйте в ключ уникальный параметр, иначе ответ заберёт кэш и тест соврёт.
Защита от мёртвого бэкенда настраивается параметрами server: max_fails и fail_timeout выводят узел из ротации после серии ошибок и возвращают его через заданный интервал. Директива proxy_next_upstream задаёт условия передачи запроса следующему серверу; по умолчанию это error и timeout (модуль ngx_http_proxy_module). Число попыток и суммарное время ретраев ограничиваются директивами proxy_next_upstream_tries и proxy_next_upstream_timeout (Безопасные ретраи в Nginx: proxy_next_upstream). По умолчанию Nginx не повторяет явно неидемпотентные методы; флаг non_idempotent включает такие повторы, и использовать его стоит только если приложение гарантирует безопасную дедупликацию. Для неидемпотентных POST ограничивайте число попыток через proxy_next_upstream_tries, чтобы запрос не создал дубль на двух бэкендах.
Отдельный риск: смена алгоритма на живом трафике меняет привязку клиентов. Для приложений с сессиями в памяти это массовый сброс сессий. Планируйте переключение на окно обслуживания или сначала переносите сессии во внешнее хранилище.
Что дальше: границы Nginx-балансировки
Nginx как L7-обратный прокси закрывает HTTP-балансировку, SSL-терминацию и кэширование: он часто обеспечивает все три функции сразу (глоссарий по веб-инфраструктуре). Для L4/TCP-трафика, сложных активных health checks и очень высоких нагрузок чаще смотрят на HAProxy или облачный балансировщик. Балансировка при этом не убирает задержку: время ответа складывается из DNS-запроса, установки TCP-соединения, TLS-рукопожатия и обработки на сервере, а распределение лишь не даёт одному узлу стать узким местом (разбор терминов latency).
Смежные материалы базы знаний: сравнение алгоритмов балансировки с конфигами для Nginx и HAProxy и балансировка в Nginx и Kubernetes для высоконагруженных систем.
Чек-лист выбора из четырёх пунктов:
- Приложение хранит состояние? Если нет, берите round-robin и не усложняйте.
- Время ответа скачет или бэкенды разной мощности? Ставьте least_conn и проверяйте лог.
- Сессии в памяти? Выносите их во внешнее хранилище, а привязку делайте hash по cookie, ip_hash оставьте как временную меру.
- Есть кэш или шардирование по ключу? Используйте hash с consistent и следите за горячими ключами.