Введение
Привет, Хабр! Я снова на связи — продолжаю серию статей про то, как мы прятали сервер за цепочкой прокси.
В первой части разобрали, как эта задача решается через чистый iptables, и уткнулись в главную проблему: SNAT/MASQUERADE подменяет source IP пакета, и на бэкенде вместо IP клиента виден IP прокси-узла. Для большей части трафика это было не критично, но для HTTP — критично, потому что реальный IP клиента нужен приложению для логов, антифрода и гео-детекции.
Напомню контекст: есть сервер, принимающий HTTPS на 443 порту и произвольный TCP/UDP на других портах, нужно скрыть его реальный IP и уметь выстраивать цепочку прокси-узлов для гео-распределения трафика. Реальный IP клиента был важен только для HTTP-трафика.
Что делаем в этой части
Раз IP клиента был важен только для HTTP, не было смысла переделывать всю схему проксирования целиком. Логичный шаг — оставить iptables как есть для TCP/UDP-портов (там всё работало нормально, IP не требовался), а для 443 порта точечно решить проблему с помощью HTTP-прокси, который умеет разбирать протокол на уровне приложения и передавать бэкенду информацию о реальном клиенте.
В этой части разберём, как устроен http-модуль Nginx, как с его помощью решить задачу с сохранением IP — в том числе при выстраивании цепочки из нескольких узлов, — и какие новые сложности это принесло по сравнению с чистым iptables.
Что такое Nginx и какие задачи он может решать
Nginx — это веб-сервер и одновременно универсальный прокси-сервер, который умеет работать в нескольких режимах:
Веб-сервер — отдаёт статические файлы напрямую клиенту.
Reverse-прокси на уровне HTTP (
http-модуль) — принимает HTTP/HTTPS-запросы и перенаправляет их на один или несколько бэкендов, при необходимости модифицируя запрос или ответ. Именно этот режим нас интересует в этой части.Балансировщик нагрузки — распределяет запросы между несколькими бэкендами по разным алгоритмам (round-robin, по весу, по наименьшему числу соединений и т.д.) — это частный случай reverse-прокси с несколькими серверами в группе.
TCP/UDP-прокси (
stream-модуль) — работает на уровень ниже, без разбора HTTP; про него подробно поговорим в следующей, третьей части серии.Почтовый прокси (
mail-модуль) — отдельный узкоспециализированный режим для проксирования SMTP/IMAP/POP3, в нашей задаче не используется.
Для задачи из этой статьи нас интересует именно reverse-прокси на http-модуле — как раз то, что позволяет разобрать HTTPS-запрос, добавить туда данные о клиенте и переслать дальше.
Как устроен http-модуль
На каком уровне OSI это работает
В отличие от iptables, который работает на сетевом и транспортном уровнях (L3/L4) и оперирует только IP-адресами и портами, HTTP-прокси работает на уровне приложения (L7). Это значит, что он не просто перенаправляет пакеты — он терминирует TLS-соединение, разбирает HTTP-запрос как структурированные данные (метод, заголовки, тело), и может модифицировать этот запрос перед тем, как отправить его дальше на бэкенд.
Именно эта способность “заглянуть внутрь” запроса и позволяет решить проблему с IP — прокси может добавить в запрос дополнительные заголовки с информацией о клиенте, которых в исходном запросе не было.
Как Nginx проксирует HTTP-запрос
Общая механика работы http-модуля Nginx как reverse-прокси:
Клиент устанавливает TLS-соединение с прокси-узлом (Nginx). Прокси предъявляет свой сертификат и расшифровывает трафик — то есть TLS терминируется именно здесь, а не долетает до бэкенда в исходном виде.
Nginx разбирает расшифрованный HTTP-запрос: метод, URI, заголовки, тело.
Директива
proxy_passуказывает, на какой бэкенд переслать запрос. Nginx открывает новое соединение к бэкенду (или переиспользует уже открытое, если настроен keepalive) и формирует новый HTTP-запрос на основе исходного.Перед отправкой запроса на бэкенд можно добавить произвольные заголовки директивой
proxy_set_header— в частности, туда можно записать реальный IP клиента, который Nginx знает из своего собственного TCP-соединения с клиентом (переменная$remote_addr).Бэкенд получает уже новый запрос — с точки зрения бэкенда, “клиентом” является сам Nginx (соединение пришло с его IP), но в заголовках лежит и реальный IP исходного клиента.
Ключевое отличие от iptables: там пакет просто перенаправлялся с подменой адресов на уровне сетевого стека, здесь же по сути создаётся новый HTTP-запрос — с новым TCP/TLS-соединением до бэкенда, но с сохранением нужной информации об исходном клиенте внутри самого запроса, на уровне протокола приложения.
Заголовки для передачи реального IP
Два основных заголовка, которые используются для этого:
X-Real-IP— содержит один IP-адрес: адрес клиента, который подключился именно к текущему прокси-узлу.X-Forwarded-For— содержит цепочку IP-адресов через запятую, если запрос уже прошёл через несколько прокси до этого. Nginx умеет автоматически дописывать в конец существующего значения этого заголовка текущий$remote_addrчерез переменную$proxy_add_x_forwarded_for, сохраняя всю историю прохождения запроса.
Примеры конфигураций
Базовый HTTP-прокси для 443 порта
server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; location / { proxy_pass https://10.0.0.10; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $host; } }
Разберём директивы:
ssl_certificate/ssl_certificate_key— сертификат и ключ для TLS-терминации именно на этом узле;proxy_pass https://10.0.0.10— куда пересылать запрос после разбора. Обратите внимание: тут снова HTTPS — то есть Nginx устанавливает новое, отдельное TLS-соединение уже до бэкенда;proxy_set_header Host $host— без этой строки бэкенд получит заголовокHost, равный своему собственному адресу (10.0.0.10), а не исходному домену запроса — это может сломать виртуальный хостинг или проверки на стороне приложения.
Приём заголовков на стороне бэкенда
На бэкенде для чтения реального IP из заголовка обычно тоже используется Nginx (или само приложение читает заголовок напрямую):
server { listen 443 ssl; server_name example.com; set_real_ip_from 10.0.0.0/24; real_ip_header X-Real-IP; location / { # $remote_addr здесь уже равен значению из X-Real-IP, # если запрос пришёл с доверенного адреса из set_real_ip_from proxy_pass http://backend_app; } }
set_real_ip_from ограничивает круг доверенных источников — иначе любой клиент сможет сам подставить произвольный X-Real-IP и обмануть логику на бэкенде.
Балансировка и выбор бэкенда: upstream и map
На практике редко бывает так, что за прокси-узлом стоит ровно один сервер без резервирования — да и в цепочке вполне может быть не единственный следующий узел, а несколько для отказоустойчивости. Для этого в Nginx есть блок upstream, а для условного выбора между разными вариантами — директива map.
Блок upstream описывает именованную группу бэкендов, которую потом можно указать в proxy_pass вместо конкретного IP:
upstream backend_pool { server 10.0.0.10:443 weight=3; server 10.0.0.11:443 weight=1; server 10.0.0.12:443 backup; keepalive 32; } server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; location / { proxy_pass https://backend_pool; proxy_http_version 1.1; proxy_set_header Connection ""; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $host; } }
Что здесь происходит:
weight— задаёт вес сервера при балансировке по умолчанию (round-robin с учётом веса):10.0.0.10будет получать в три раза больше запросов, чем10.0.0.11;backup— сервер, который получает трафик только если все основные (не помеченные какbackup) недоступны — удобно для резервного узла на случай отказа основных;keepalive 32— Nginx будет держать до 32 постоянных соединений с бэкендами открытыми и переиспользовать их для новых запросов, вместо того чтобы устанавливать новое TCP/TLS-соединение на каждый запрос — заметно снижает накладные расходы при высокой частоте запросов. Чтобыkeepaliveреально работал, вlocationнужныproxy_http_version 1.1и очистка заголовкаConnection(две строки в примере выше): по умолчанию Nginx ходит к бэкенду по HTTP/1.0 и закрывает соединение после каждого запроса.
Директива map позволяет вычислить значение переменной на основе другой переменной — и потом использовать её, например, для выбора upstream динамически. Пригодится, если один и тот же прокси-узел на 443 порту должен обслуживать несколько разных доменов, каждый со своим бэкендом:
map $host $backend { example.com backend_pool_ru; api.example.com backend_pool_api; default backend_pool_ru; } upstream backend_pool_ru { server 10.0.0.10:443; server 10.0.0.11:443 backup; } upstream backend_pool_api { server 10.0.1.10:443; } server { listen 443 ssl; server_name example.com api.example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; location / { proxy_pass https://$backend; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $host; } }
Здесь map смотрит на заголовок Host ($host) входящего запроса и в зависимости от домена подставляет в переменную $backend нужный upstream. Это удобно, когда несколько логически разных сервисов скрыты за одним и тем же набором прокси-узлов — не нужно заводить отдельный server-блок и отдельную группу узлов под каждый домен, если сама цепочка узлов у них общая, а различается только конечный бэкенд.
map можно использовать не только по домену — тем же приёмом можно выбирать бэкенд по любому доступному в конфиге признаку запроса (например, по кастомному заголовку), если для конкретной задачи требуется более сложная логика маршрутизации, чем просто разбор Host.
Basic Auth на прокси
Если сервис нужно закрыть от посторонних (админка, внутренний API, тестовый стенд), а поднимать полноценную систему аутентификации не хочется, хватит HTTP Basic Auth прямо на прокси. Запрос без правильной пары логин/пароль до бэкенда просто не доходит — для схемы со скрытым сервером это удобно: отсечка происходит на крайнем узле.
Файл с пользователями создаётся утилитой htpasswd:
# Debian/Ubuntu: apt install apache2-utils, RHEL-семейство: httpd-tools htpasswd -B -c /etc/nginx/.htpasswd admin # первый пользователь; -c создаёт файл htpasswd -B /etc/nginx/.htpasswd operator # следующие — уже без -c
Флаг -c нужен только при создании файла: если указать его повторно, файл будет перезаписан и все прежние пользователи пропадут. Флаг -B включает bcrypt вместо MD5-варианта по умолчанию. Nginx читает хеши через системную crypt(), так что на современных дистрибутивах bcrypt работает, но стоит проверить на своём.
Права на файл — только для root и пользователя, от которого работают воркеры Nginx (www-data на Debian/Ubuntu, nginx на RHEL):
chown root:www-data /etc/nginx/.htpasswd chmod 640 /etc/nginx/.htpasswd
Сама настройка:
server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; auth_basic "Restricted"; auth_basic_user_file /etc/nginx/.htpasswd; # эндпоинт для внешнего мониторинга — без пароля location = /healthz { auth_basic off; return 200 "ok\n"; } location / { proxy_pass https://backend_pool; proxy_http_version 1.1; proxy_set_header Connection ""; proxy_set_header Authorization ""; # бэкенду учётные данные не нужны proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $host; } }
Что здесь важно не упустить:
Только поверх HTTPS. Логин и пароль в Basic Auth передаются в base64, а это кодирование, а не шифрование. В нашей схеме TLS терминируется на узле, так что всё в порядке, но на порту 80 без редиректа на HTTPS включать Basic Auth нельзя.
Заголовок
Authorizationпо умолчанию уходит на бэкенд. Если бэкенду он не нужен, его лучше убрать (proxy_set_header Authorization ""). Если у бэкенда своя авторизация, Basic Auth на прокси с ней конфликтует: оба используют один и тот же заголовок.В цепочке проверяем пароль только на первом узле. Если требовать его на каждом хопе, придётся прокидывать учётные данные дальше, а это лишняя поверхность. Остальным узлам лучше пускать трафик только от предыдущего узла, причём на уровне сети, тем же
iptables:allow/denyв Nginx здесь не подойдут, потому что после подмены адреса модулемrealipони проверяют уже адрес клиента, а не предыдущего узла.Защита от перебора. Basic Auth не ограничивает число попыток, поэтому нужен внешний ограничитель:
limit_reqнаlocation(лимит подбирают так, чтобы он не мешал обычной нагрузке) либоfail2banсо штатным фильтромnginx-http-auth.Кто вошёл — в логах. Имя пользователя доступно в переменной
$remote_user, её удобно добавить вlog_format.
Проверка:
curl -I https://example.com/ # ожидаем 401 и заголовок WWW-Authenticate curl -I -u admin:пароль https://example.com/ # ожидаем ответ бэкенда
Проксирование WebSocket
WebSocket начинается как обычный HTTP-запрос с заголовком Upgrade: websocket, после чего соединение превращается в двунаправленный поток. Заголовки Upgrade и Connection относятся к hop-by-hop: Nginx не передаёт их бэкенду сам, да ещё и ходит к нему по HTTP/1.0. Без настройки рукопожатие просто не проходит.
Рабочая конфигурация:
# http-контекст, вне server map $http_upgrade $connection_upgrade { default upgrade; '' ''; } server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; location /ws/ { proxy_pass https://backend_pool; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection $connection_upgrade; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_read_timeout 3600s; proxy_send_timeout 3600s; } }
Разберём ключевые места:
proxy_http_version 1.1— дляUpgradeнужен HTTP/1.1.map $http_upgrade $connection_upgrade— это та же директиваmap, что и выше. Для запросов сUpgradeвConnectionуйдётupgrade, для обычных — пустое значение, поэтомуkeepaliveк бэкенду продолжает работать. Если жёстко прописатьConnection "upgrade"для всегоlocation, обычные запросы на нём тоже будут уходить сupgrade.proxy_read_timeout— по умолчанию 60 секунд. Если от бэкенда за это время ничего не пришло, Nginx закрывает соединение, и «тихий» WebSocket рвётся примерно раз в минуту. Либо поднимаем таймаут, как в примере, либо (лучше) делаем на уровне приложения ping/pong чаще, чем срабатывает таймаут.
Для цепочки узлов важны два момента:
Рукопожатие — это обычный HTTP-запрос, поэтому
X-Real-IP,X-Forwarded-Forиreal_ip_headerработают так же, как и раньше. Basic Auth тоже проверяется один раз, на этапе рукопожатия.Настройка с
Upgradeдолжна быть на каждом узле цепочки, иначе соединение оборвётся на первом же узле, где её забыли. Таймауты тоже действуют на каждом хопе, и срабатывает самый короткий, поэтому их нужно выровнять на всех узлах.
Проверить можно без браузера:
curl -i -N https://example.com/ws/ \ -H "Connection: Upgrade" \ -H "Upgrade: websocket" \ -H "Sec-WebSocket-Version: 13" \ -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=="
Ожидаем HTTP/1.1 101 Switching Protocols. После этого соединение остаётся открытым, прервать его можно по Ctrl+C.
Забегая вперёд: когда проксирование идёт на уровне TCP (третья часть), WebSocket не требует никакой отдельной настройки, потому что для stream это просто байты внутри TLS-соединения. Обратная сторона та же: stream не разбирает HTTP, поэтому Basic Auth там недоступен, и аутентификацию придётся оставить на конечном сервере.
Остальные TCP/UDP-порты, где реальный IP не был нужен, остались на iptables без изменений, как в первой части:
iptables -t nat -A PREROUTING -p tcp --dport 9000 \ -j DNAT --to-destination 10.0.0.10:9000 iptables -t nat -A PREROUTING -p udp --dport 27015 \ -j DNAT --to-destination 10.0.0.10:27015 iptables -t nat -A POSTROUTING -j MASQUERADE
Как строить цепочки
Пока речь шла об одном прокси-узле перед бэкендом. Но задача требовала цепочку — клиент подключается к ближайшему географически узлу (назовём его узел A), тот проксирует на следующий узел (B), и так далее, вплоть до конечного сервера. Важно, чтобы конечный сервер видел IP исходного клиента, а не IP предпоследнего узла цепочки.
Почему X-Real-IP сам по себе не подходит для цепочки
X-Real-IP — это одиночное значение. Если каждый узел в цепочке будет просто писать в него $remote_addr (то есть IP того, кто к нему подключился), то при прохождении через два и более узлов заголовок будет каждый раз перезаписываться:
Узел A получает запрос от клиента, ставит
X-Real-IP: <IP клиента>.Узел B получает запрос от узла A. Если он слепо выполнит
proxy_set_header X-Real-IP $remote_addr, то перезапишет заголовок на IP узла A — информация об исходном клиенте потеряется.
Поэтому для цепочки нужен либо X-Forwarded-For (который по своей природе как раз накапливает список адресов), либо аккуратная ручная передача уже существующего X-Real-IP дальше по цепочке без его перезаписи.
Настройка на промежуточном узле (не первом в цепочке)
На первом узле (A, к которому подключается клиент напрямую) конфиг остаётся таким же, как был показан выше — $remote_addr там действительно равен IP клиента.
На всех последующих узлах (B, C, …) важно не переписывать X-Real-IP, а прокидывать значение, которое уже пришло от предыдущего узла:
server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/example.com.crt; ssl_certificate_key /etc/nginx/ssl/example.com.key; # доверяем только предыдущему узлу цепочки set_real_ip_from 10.0.1.5; # IP узла A real_ip_header X-Real-IP; location / { proxy_pass https://10.0.2.10; # следующий узел или конечный бэкенд proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $host; } }
Ключевой момент здесь — директивы set_real_ip_from и real_ip_header. Они указывают Nginx: если запрос пришёл с доверенного IP (в данном случае — с узла A), то нужно взять значение $remote_addr не из фактического TCP-соединения, а из заголовка X-Real-IP, который уже содержит IP исходного клиента. После этого на самом узле B переменная $remote_addr внутри конфига уже “переопределена” — то есть proxy_set_header X-Real-IP $remote_addr на следующей строке отправит дальше не IP узла A, а изначальный IP клиента.
Тот же принцип действует для X-Forwarded-For, только там ничего специально прокидывать не нужно — $proxy_add_x_forwarded_for сам берёт значение уже существующего заголовка (если он был) и дописывает к нему через запятую текущий $remote_addr. Если на каждом узле включена директива real_ip_header X-Real-IP (как показано выше), то этот “текущий” $remote_addr — уже тоже настоящий IP клиента, а не IP предыдущего узла, поэтому итоговый X-Forwarded-For не размножает лишние промежуточные адреса.
На конечном сервере
Конечный сервер (или последний узел перед приложением) настраивается точно так же — доверяет только предыдущему узлу цепочки:
server { listen 443 ssl; server_name example.com; set_real_ip_from 10.0.2.10; # IP предпоследнего узла цепочки real_ip_header X-Real-IP; location / { # $remote_addr здесь — уже настоящий IP исходного клиента proxy_pass http://backend_app; } }
Важный нюанс безопасности
set_real_ip_from обязательно должен быть ограничен конкретным IP (или подсетью) предыдущего узла, а не оставлен широким (например, 0.0.0.0/0). Иначе любой внешний клиент сможет напрямую обратиться к любому узлу цепочки, подделать заголовок X-Real-IP, и заставить приложение думать, что запрос пришёл с произвольного, подставного IP — это открывает дорогу к обходу антифрода, rate-limiting’а или гео-ограничений на уровне приложения.
Отличие от iptables
iptables (часть 1) | http-прокси Nginx (эта часть) | |
|---|---|---|
Уровень OSI | L3/L4 (IP, порты) | L7 (разбор HTTP-запроса) |
Что происходит с пакетом | Перенаправление с подменой адресов | Терминация TLS + формирование нового запроса |
Сохранение IP клиента | Невозможно без костылей (TPROXY) | Стандартными заголовками (X-Real-IP, X-Forwarded-For) |
Накладные расходы | Минимальные (уровень ядра) | Выше — расшифровка TLS, разбор протокола, новое соединение до бэкенда |
Поддержка произвольного TCP/UDP | Да, из коробки | Нет — понимает только HTTP/HTTPS |
TLS-сертификат нужен на узле | Нет | Да |
Балансировка и маршрутизация по содержимому запроса | Недоступно |
|
Главный вывод из этой таблицы: iptables и http-модуль Nginx закрывают разные по своей природе задачи. iptables — это прозрачная пересылка пакетов без понимания протокола внутри, а http-прокси — полноценная обработка запроса на уровне приложения ценой дополнительных накладных расходов и необходимости держать TLS-сертификат на каждом узле, который расшифровывает трафик.
Грабли при настройке
TLS-сертификаты на каждом промежуточном узле
Раз мы используем http-модуль, а не просто пробрасываем TCP-пакеты, Nginx обязан расшифровать TLS, чтобы разобрать HTTP-запрос и добавить заголовки. Это значит, что сертификат должен лежать не только на конечном сервере, но и на каждом прокси-узле в цепочке.
На практике это принесло сразу несколько проблем:
Нужно было распространять сертификат (и его приватный ключ) на все промежуточные узлы, а не только на конечный сервер — это дополнительная поверхность, где приватный ключ вообще существует и потенциально может быть скомпрометирован.
Обновление сертификата (например, через
certbotпри истечении срока действия) нужно было теперь синхронизировать по всем узлам цепочки одновременно, а не в одном месте — иначе часть узлов начинала отдавать клиентам устаревший сертификат.При добавлении нового узла в цепочку появился ещё один обязательный шаг в чеклисте разворачивания — доставить и установить сертификат, который легко забыть, особенно если разворачивание частично автоматизировано, а этот шаг остался ручным.
Сложность администрирования из-за двух разных механизмов
Инфраструктура теперь состояла из двух принципиально разных вещей: HTTP-прокси на уровне приложения для 443 порта и DNAT на уровне сетевого стека для всего остального. На практике это ощущалось так:
Два разных файла конфигурации, которые нужно было держать в голове одновременно и не забывать синхронизировать при изменении топологии (например, при смене IP бэкенда его нужно было поменять и в
proxy_pass, и в правиле DNAT);Два разных подхода к логированию и мониторингу — у Nginx подробные access-логи по каждому запросу, у
iptablesв лучшем случае счётчики пакетов по правилам (iptables -L -v) без какой-либо детализации по отдельным соединениям;При инцидентах отладка шла по двум разным путям в зависимости от того, что сломалось: для HTTP — в логи Nginx, для остального трафика — снова в
conntrackи правилаiptables, и эти два подхода к диагностике никак не пересекались между собой;Выстраивание цепочки из нескольких узлов требовало повторять оба механизма конфигурации на каждом новом узле — то есть двойная работа и двойной шанс на рассинхронизацию.
Стало ясно: раз уж проблема с IP решена только для части трафика, а инфраструктура при этом усложнилась в целом, — нужен один унифицированный механизм проксирования, который одинаково хорошо работает и с HTTP, и с произвольным TCP/UDP, но при этом сохраняет возможность передавать IP клиента именно там, где это нужно.
Плюсы и минусы
Плюсы:
Проблема с реальным IP клиента для HTTP-трафика решена полностью и стандартными средствами (заголовки
X-Real-IP/X-Forwarded-Forпонимает подавляющее большинство веб-приложений и фреймворков “из коробки”).Изменения точечные — не нужно было переделывать уже рабочую схему для TCP/UDP-портов.
HTTP-часть получает все преимущества
http-модуля Nginx: подробное логирование запросов, гибкая маршрутизация поlocation/map, балансировка черезupstream, Basic Auth, проксирование WebSocket и любая другая логика на уровне L7.
Минусы:
Два разных механизма проксирования вместо одного — рост сложности администрирования и поверхности для ошибок при синхронизации.
TLS терминируется на каждом промежуточном узле цепочки — нужно распространять и обновлять сертификаты на всех узлах, а не только на конечном сервере.
Каждый промежуточный узел технически может расшифровать TLS-сессию клиента — то есть в цепочке появляется больше точек, где потенциально можно скомпрометировать трафик.
Выстраивание цепочки из нескольких узлов требует дублировать гибридную схему целиком на каждом узле — оба механизма конфигурации сразу.
Заключение
Гибридная схема закрыла главную боль — сохранение IP клиента там, где это было нужно, — стандартными средствами HTTP-прокси, без сложных конструкций поверх iptables вроде TPROXY. Но ценой этого стало усложнение инфраструктуры: два механизма проксирования вместо одного, TLS-терминация на каждом промежуточном узле, дублирование настройки при масштабировании цепочки.
В следующей, финальной части — как переход на Nginx Stream позволил унифицировать всю схему в одном инструменте: сохранить IP клиента только там, где он реально нужен, избавиться от лишней TLS-терминации на промежуточных узлах, и работать с HTTP и произвольным TCP/UDP через один и тот же механизм.
