Балансировка нагрузки в Nginx: сравнение round-robin, least_conn, ip_hash и hash с конфигами | AdminWiki

Балансировка нагрузки в Nginx: сравнение round-robin, least_conn, ip_hash и hash с конфигами

08 ноября 2026 11 мин. чтения

Какой алгоритм балансировки в Nginx выбрать: короткий ответ

Начните с round-robin. Это поведение upstream по умолчанию, и для однородных stateless-бэкендов с короткими предсказуемыми запросами его хватает. Меняйте алгоритм под конкретную проблему, а не «на всякий случай»: иначе вы добавляете зависимость от состояния, которую потом придётся обслуживать.

Карта решений на четыре строки:

ЗадачаМетодПочему он
Stateless API, бэкенды одинаковой мощностиround-robinРавномерная очередь без хранения состояния на балансировщике
Время обработки запросов сильно различаетсяleast_connСмотрит на активные соединения, а не на позицию в списке
Сессии живут в памяти бэкендаhash $cookie_sessionid consistentПривязка по cookie переживает NAT и смену IP
Кэш или шардирование по URLhash $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-robinserver без директивы алгоритмаНе учитывает загрузку и время ответаЗапросы сильно различаются по длительности
Stateless API с неравными запросамиleast_connleast_connСчитает соединения, а не CPU и дискВсе запросы короткие и одинаковые
Сессии в памяти бэкендаhash по cookiehash $cookie_sessionid consistentНужна cookie до балансировкиCookie ещё не выставлена на этом слое
Сессии, быстрый компромиссip_haship_hashNAT, CDN и смена IP ломают привязкуКлиенты за общим прокси или CDN
Кэш страниц, шардирование по URLhash по ключуhash $request_uri consistentГорячий ключ собирает трафикМало ключей или один доминирующий URL
Разнородные по мощности бэкендыleast_conn + weightleast_conn, server weightВеса нужно пересматривать при изменении паркаЖелезо и нагрузка одинаковые
Клиенты за NAT или CDNhash по cookieне ip_hashТребуется общее хранилище сессий для отказоустойчивостиПриложение не умеет отдавать cookie

Таблица самодостаточна для первичного выбора: определите тип приложения, возьмите директиву и проверьте колонку ограничений на своём окружении.

Проверка конфига и безопасный ввод в прод

Порядок действий перед reload:

  1. Проверить синтаксис: nginx -t. Конфиг с ошибкой не применится, но и прод не тронет.
  2. Перечитать конфигурацию: nginx -s reload. Процессы завершают текущие соединения и подхватывают новые.
  3. Посмотреть реальное распределение в access.log с полями $upstream_addr и $upstream_response_time, а не полагаться на предположения.
  4. Прогнать серию запросов curl по одному URL и сверить бэкенд. Удобно, если приложение отдаёт заголовок с именем узла.
  5. Для ip_hash проверять с разных IP, а не с одной машины: иначе тест всегда покажет один бэкенд и вы ничего не увидите.
  6. Для 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 для высоконагруженных систем.

Чек-лист выбора из четырёх пунктов:

  1. Приложение хранит состояние? Если нет, берите round-robin и не усложняйте.
  2. Время ответа скачет или бэкенды разной мощности? Ставьте least_conn и проверяйте лог.
  3. Сессии в памяти? Выносите их во внешнее хранилище, а привязку делайте hash по cookie, ip_hash оставьте как временную меру.
  4. Есть кэш или шардирование по ключу? Используйте hash с consistent и следите за горячими ключами.
Поделиться: