Потоковые ответы через прокси: chunked, SSE и long-polling без буферизации
Содержание статьи
- Введение: почему потоковый http через прокси стал массовой проблемой
- Основы: как обычный http-ответ превращается в поток
- Глубокое погружение: где и почему поток застревает на промежуточном узле
- Метод 1: chunked transfer encoding — низкоуровневый поток без обвязки
- Метод 2: server-sent events — стандарт для событий от сервера к клиенту
- Метод 3: long-polling — поток из последовательности обычных ответов
- Метод 4: потребление потоковых ответов через исходящий прокси
- Типичные ошибки при работе с потоками через прокси
- Инструменты и ресурсы для настройки и диагностики
- Кейсы и результаты: как это выглядит в реальных проектах
- Faq: глубокие вопросы о потоковых ответах через прокси
- Заключение: резюме и следующие шаги
Введение: почему потоковый HTTP через прокси стал массовой проблемой
Представьте: вы отправили запрос к языковой модели, и вместо привычного «печатания» токенов экран молчит сорок секунд, а потом выплёвывает весь ответ одним куском. Или дашборд мониторинга, который обязан обновляться каждую секунду, показывает данные с опозданием в полминуты. Или парсер, который слушает поток событий торговой площадки, получает пачки по сто событий вместо ровного ручейка. В девяти случаях из десяти виноват не сервер и не клиент. Виноват тот, кто стоит между ними: прокси, балансировщик, CDN или корпоративный шлюз, который решил «помочь» и накопить ответ целиком, прежде чем отдать дальше.
Тема потоковых HTTP-ответов через промежуточные узлы долго считалась нишевой. В 2026 году она стала массовой. Стриминг токенов из LLM-API, серверные события в веб-интерфейсах, long-polling в мессенджерах и ботах, прогресс-бары длинных экспортов, потоковая выдача результатов парсинга — всё это работает поверх самого обычного HTTP, который просто не торопится закрывать ответ. И всё это ломается, стоит на пути появиться узлу с включённой буферизацией.
В этом руководстве мы разберём три классических механизма — chunked transfer encoding, Server-Sent Events и long-polling — именно с точки зрения прохождения через прокси. Важная оговорка сразу: здесь не будет WebSocket и gRPC. Им посвящён отдельный материал, и разница принципиальная. Там происходит апгрейд протокола или используется бинарный фрейминг поверх HTTP/2, и прокси должен уметь этот апгрейд распознать и пропустить. Здесь же — обычный HTTP-ответ, у которого нет заголовка Content-Length и который сервер держит открытым. Никакого рукопожатия, никакого перехода на другой протокол. Казалось бы, проще некуда. Но именно эта простота и создаёт проблему: прокси не видит ничего особенного и применяет стандартные правила буферизации, заточенные под короткие ответы.
Что вы получите из этого материала: понимание, как устроен поток на уровне байтов и заголовков; карту всех мест, где ответ может застрять; готовые конфигурации для nginx, HAProxy, Envoy и клиентских библиотек; фреймворк выбора между тремя механизмами; чек-листы диагностики; разбор реальных кейсов с цифрами. Материал рассчитан на разработчиков, DevOps-инженеров и всех, кто использует прокси для работы с API, парсинга и автоматизации.
Основы: как обычный HTTP-ответ превращается в поток
Два способа сообщить длину ответа
В HTTP/1.1 существует два фундаментальных способа сказать клиенту, где заканчивается тело ответа. Первый — заголовок Content-Length: сервер заранее объявляет точное число байтов. Второй — Transfer-Encoding: chunked: сервер отправляет тело порциями, каждая порция начинается со своего размера в шестнадцатеричном виде, а завершается всё нулевым чанком. Есть и третий, архаичный вариант — просто закрыть соединение после последнего байта, но с keep-alive он практически не используется.
Почему это важно для потока? Потому что Content-Length требует знать размер заранее. Если сервер генерирует ответ постепенно — токен за токеном, событие за событием — он физически не может посчитать длину до начала передачи. Единственный вариант в HTTP/1.1 — chunked. В HTTP/2 и HTTP/3 chunked-кодирование как таковое отсутствует: там тело и так передаётся фреймами DATA, а конец обозначается флагом END_STREAM. Но логика та же: ответ без объявленной длины, который может длиться сколько угодно.
Что значит «не закрывать ответ»
Аналогия. Обычный HTTP-ответ — это посылка: вы получаете коробку, на которой написан вес, вскрываете и знаете, что внутри всё. Потоковый ответ — это конвейерная лента: коробки едут одна за другой, и вы не знаете, когда лента остановится. Сервер отправил заголовки со статусом 200, отправил первый чанк — и ждёт. Появились новые данные — отправил следующий. Соединение остаётся открытым минуты, часы, иногда сутки.
С точки зрения TCP ничего необычного не происходит: тот же сокет, те же сегменты. С точки зрения HTTP — это один-единственный запрос и один-единственный ответ, просто очень долгий. И вот здесь кроется корень всех проблем с прокси: промежуточный узел видит начало ответа, не видит конца и должен решить, что делать с байтами, которые уже пришли. Передать немедленно? Или подождать, накопить побольше и отправить эффективнее? По умолчанию большинство прокси выбирают второе.
Три механизма: общее и различия
- Chunked streaming — самый низкоуровневый. Сервер просто пишет байты в тело и вызывает flush. Формат содержимого произвольный: текст, NDJSON, бинарные данные. Клиент сам решает, как разбирать.
- Server-Sent Events — стандартизированный текстовый формат поверх chunked-потока. Content-Type: text/event-stream, события разделены пустыми строками, есть поля data, event, id, retry. Браузер поддерживает нативно через EventSource с автоматическим переподключением.
- Long-polling — строго говоря, не поток. Клиент делает запрос, сервер держит его открытым до появления данных или до таймаута, отвечает и закрывает. Клиент немедленно делает следующий запрос. Это имитация потока последовательностью обычных ответов, каждый из которых может иметь Content-Length.
Что у них общего? Во всех трёх случаях ответ на один запрос задерживается на неопределённое время, и прокси должен это пережить: не оборвать соединение по таймауту и не задержать данные в буфере. Различие в том, насколько каждый механизм зависит от прозрачности промежуточного узла. Chunked и SSE зависят критически. Long-polling — минимально, и это его главное преимущество.
Роль прокси в цепочке
Между клиентом и сервером в современной инфраструктуре редко бывает пусто. Типичная цепочка: клиентское приложение — исходящий прокси (например, мобильный или резидентный) — интернет — CDN — облачный балансировщик — обратный прокси — приложение. Каждый из этих узлов — потенциальная точка буферизации. И каждый по умолчанию настроен так, чтобы оптимизировать короткие ответы: собрать, сжать, отдать целиком. Для потока такая оптимизация — катастрофа. Мы будем последовательно снимать эти слои и смотреть, что происходит на каждом.
Глубокое погружение: где и почему поток застревает на промежуточном узле
Зачем прокси вообще буферизуют
Прежде чем ругать буферизацию, стоит понять её логику. Обратный прокси вроде nginx буферизует по трём причинам. Первая — защита бэкенда от медленного клиента: если клиент на мобильном канале читает по десять килобайт в секунду, а бэкенд уже сгенерировал ответ, выгоднее забрать всё у бэкенда сразу, освободить его воркер и потом спокойно отдавать клиенту из буфера. Вторая — сжатие: gzip и brotli работают эффективнее на крупных блоках. Третья — возможность выставить Content-Length и корректно обработать ошибку бэкенда до отправки заголовков клиенту.
Для типичного API с ответами в несколько килобайт всё это разумно и экономит ресурсы. Для потока — ровно наоборот: задерживая байты, прокси уничтожает саму ценность потока. Ценность эта — в своевременности, а не в объёме.
Карта восьми точек буферизации
Пройдём по цепочке и отметим каждую точку, где данные могут застрять. Держите этот список под рукой при диагностике.
- Приложение. Фреймворк может буферизовать вывод сам. WSGI-серверы, PHP с включённым output_buffering, Node.js-фреймворки с middleware сжатия. Flush не вызывается — данные лежат в буфере процесса.
- Обратный прокси перед приложением. nginx с proxy_buffering on (включено по умолчанию) копит ответ в буферы, заданные proxy_buffer_size и proxy_buffers, а при переполнении — во временный файл на диске. Apache mod_proxy буферизует меньше, но имеет свои настройки. Caddy по умолчанию не буферизует, но flush_interval стоит проверить.
- Сжатие на прокси. Даже при proxy_buffering off включённый gzip накапливает данные до размера окна сжатия. Это одна из самых коварных точек: буферизация формально выключена, а поток идёт рывками.
- Балансировщик L7. HAProxy в режиме http передаёт данные по мере поступления, если не включён http-buffer-request, но ограничен размером tune.bufsize. Envoy по умолчанию стримит, однако фильтры компрессии или Lua могут накапливать тело.
- CDN и облачные шлюзы. Многие CDN буферизуют ответы для кеширования и сжатия. Часть провайдеров не поддерживает потоки дольше определённого времени или требует явных настроек. Облачные API-шлюзы часто имеют жёсткий лимит времени ответа около 30 секунд и вовсе не поддерживают стриминг тела.
- Исходящий прокси на стороне клиента. HTTP-прокси, через который вы ходите в интернет — корпоративный, мобильный, резидентный — тоже является HTTP-парсером. Если он построен на nginx или Squid и настроен на буферизацию, поток застрянет там. Качественные прокси-сервисы пропускают chunked-ответы прозрачно, но это нужно проверять на практике.
- TLS и TCP. Данные могут задерживаться в TLS-записях, если библиотека собирает их до размера 16 килобайт. Алгоритм Нейгла задерживает мелкие TCP-сегменты до подтверждения предыдущего. Для потока из мелких чанков это добавляет десятки миллисекунд на каждый.
- Клиентская библиотека. requests в Python читает всё тело в память, если не передан stream=True. Ряд HTTP-клиентов буферизует до размера chunk_size.
Восемь точек. Если хотя бы одна накапливает данные, вы увидите поток в виде рывков или одной большой пачки в конце. И самое неприятное: поведение зависит от объёма. На маленьких ответах всё выглядит нормально, а под нагрузкой или на длинных ответах буфер заполняется, включается запись во временные файлы, и задержки взлетают. Не удивительно, что многие команды обнаруживают проблему только в продакшене.
HTTP/1.1 против HTTP/2 в контексте потока
В HTTP/1.1 одно соединение — один ответ в единицу времени. Долгоживущий ответ занимает соединение целиком. Браузер ограничивает число одновременных соединений к одному хосту шестью, поэтому шесть открытых SSE-потоков блокируют все остальные запросы к этому хосту. Прокси, работающий по HTTP/1.1 с бэкендом, тоже держит по одному соединению на каждый поток.
В HTTP/2 мультиплексирование снимает это ограничение: сотня потоков живёт в одном TCP-соединении. Но появляется тонкость — управление потоком на уровне протокола. Если получатель не расширяет окно через WINDOW_UPDATE, отправитель останавливается. Некоторые прокси реализуют пересылку этих фреймов неаккуратно и создают искусственные паузы.
Важно понимать: прокси может принять запрос по HTTP/2 от клиента и пойти к бэкенду по HTTP/1.1. Он переупаковывает фреймы DATA в чанки и обратно. Это нормальная операция, но именно на границе преобразования часто теряется своевременный flush — прокси ждёт, пока накопится «удобный» размер фрейма.
Таймауты — второй убийца потоков
Буферизация задерживает данные. Таймауты обрывают соединение. У nginx есть proxy_read_timeout — максимальное время между двумя последовательными операциями чтения от бэкенда, по умолчанию 60 секунд. Если сервер молчит дольше минуты, nginx закрывает соединение и отдаёт клиенту 504. Для long-polling с ожиданием в 90 секунд это гарантированный сбой. У HAProxy — timeout server и timeout tunnel. У облачных балансировщиков — idle timeout, часто 60 или 350 секунд. У мобильных операторов — NAT-таймауты, сбрасывающие неактивные соединения через несколько минут.
Отсюда железное правило: поток без периодической активности обречён. Heartbeat-сообщения каждые 15-30 секунд — не опция, а обязательное требование любого долгоживущего ответа.
Матрица выбора механизма
Прежде чем переходить к практике, зафиксируем фреймворк выбора. Ответьте на четыре вопроса.
- Контролируете ли вы всю цепочку прокси? Да — подходят chunked и SSE. Нет, в цепочке есть неизвестные шлюзы — начинайте с long-polling или предусмотрите деградацию к нему.
- Кто клиент? Браузер — SSE с EventSource даёт переподключение бесплатно. Собственный код — chunked с NDJSON гибче.
- Какова природа данных? Фрагменты одной сущности (токены одного ответа) — chunked или SSE. Дискретные независимые события — SSE или long-polling.
- Какова частота? Десятки событий в секунду — chunked или SSE с батчингом. Событие раз в минуту — long-polling с большим таймаутом или SSE с heartbeat.
Метод 1: chunked transfer encoding — низкоуровневый поток без обвязки
Когда выбирать чистый chunked
Чистый chunked-поток уместен, когда клиент — ваш собственный код, а не браузер; когда формат данных не текстовый или не укладывается в модель событий; когда нужен максимальный контроль над каждым байтом. Типичные примеры: стриминг NDJSON из API, потоковая выдача результатов парсинга, скачивание больших экспортов с индикатором прогресса, проксирование ответов LLM в собственном формате.
Пошаговая настройка серверной стороны
- Убедитесь, что приложение пишет по частям. После каждой логической порции вызывайте flush. В Python с ASGI-сервером это генератор, отдающий байты; в Node.js — res.write с последующим flush, если задействовано сжатие; в Go — интерфейс http.Flusher после каждого Write.
- Не выставляйте Content-Length. Большинство фреймворков сами переключатся на chunked, если длина не задана. Проверьте, что в ответе при HTTP/1.1 присутствует Transfer-Encoding: chunked.
- Отключите сжатие на уровне приложения для потоковых маршрутов или убедитесь, что оно флашит вместе с данными. Компромисс — gzip с синхронным flush после каждого чанка; это работает, но снижает степень сжатия.
- Установите заголовок X-Accel-Buffering: no. Это специфичный для nginx заголовок, отключающий буферизацию для конкретного ответа без изменения глобальной конфигурации. Его понимают и некоторые другие прокси. Добавьте также Cache-Control: no-cache, no-transform — второе значение просит промежуточные узлы не модифицировать тело.
- Настройте обратный прокси. Для nginx в location потокового маршрута:
proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;. Директива proxy_http_version 1.1 обязательна: по умолчанию nginx обращается к бэкенду по HTTP/1.0, где chunked не существует, и nginx вынужден буферизовать до закрытия соединения. - Разделите маршруты. Если сжатие нужно для остального API, включайте его только в нестриминговых location-блоках.
- Проверьте алгоритм Нейгла. В nginx tcp_nodelay включён по умолчанию, но в приложении при мелких частых чанках может потребоваться явная установка TCP_NODELAY на сокете.
Конфигурация HAProxy и Envoy
HAProxy. В секции backend не используйте option http-buffer-request. Убедитесь, что timeout server достаточно велик для вашего сценария, а для действительно долгих потоков задайте timeout tunnel. Компрессию отключите для потоковых путей через ACL или положитесь на заголовок no-transform: HAProxy уважает Cache-Control: no-transform и не сжимает такие ответы.
Envoy. Буферизация по умолчанию выключена, что радует. Но проверьте два таймаута: stream_idle_timeout в HTTP connection manager (по умолчанию пять минут) и route timeout (по умолчанию пятнадцать секунд — именно он чаще всего и обрывает потоки). Для потоковых маршрутов установите timeout равным 0s, что означает отсутствие лимита, и полагайтесь на idle timeout в сочетании с heartbeat.
Чек-лист проверки chunked-потока
- В ответе есть Transfer-Encoding: chunked, либо используется HTTP/2 без Content-Length.
- Заголовок X-Accel-Buffering: no присутствует в ответе приложения.
- Content-Encoding отсутствует или сжатие флашится вместе с данными.
- Первый байт тела приходит в течение секунды после заголовков.
- Интервалы между чанками у клиента совпадают с интервалами генерации на сервере с погрешностью до 50 миллисекунд.
- Соединение живёт дольше минуты без обрыва при наличии heartbeat.
- В логах прокси нет записей о буферизации во временный файл.
Метод 2: Server-Sent Events — стандарт для событий от сервера к клиенту
Устройство формата
SSE — это соглашение о том, как раскладывать события в текстовом потоке. Ответ имеет Content-Type: text/event-stream. Каждое событие — набор строк вида «поле: значение», завершающийся пустой строкой. Поля: data — полезная нагрузка (может повторяться, строки склеиваются переводом строки); event — имя типа события; id — идентификатор для возобновления; retry — рекомендуемая задержка переподключения в миллисекундах. Строка, начинающаяся с двоеточия, — комментарий, и это идеальный heartbeat: браузер его игнорирует, а прокси видит активность на соединении.
Красота SSE — в асимметрии. Сложность вынесена в спецификацию и браузер, а сервер остаётся тривиальным. Никакого рукопожатия, никакого бинарного фрейминга. Просто текст, который течёт. Именно поэтому SSE стал стандартом де-факто для стриминга ответов языковых моделей: подавляющее большинство крупных LLM-API отдают токены в формате text/event-stream. Удивительно, что технология, описанная в спецификациях больше пятнадцати лет назад, переживает в 2026 году второй расцвет.
Почему SSE особенно чувствителен к буферизации
Событие в SSE весит от нескольких десятков байт до пары килобайт. Буфер nginx по умолчанию — 4 или 8 килобайт на первый блок и восемь блоков по 4-8 килобайт дальше. Значит, прокси накопит от пятидесяти до нескольких сотен событий, прежде чем отдаст первое. Для чата с моделью это выглядит так: пользователь ждёт пятнадцать секунд, потом весь абзац появляется мгновенно. Иллюзия набора текста разрушена, а ведь ради неё стриминг и внедряли.
Пошаговая реализация SSE через прокси
- Заголовки ответа: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, а для HTTP/1.1 ещё и Connection: keep-alive.
- Heartbeat. Отправляйте строку-комментарий вида
: pingкаждые 15-25 секунд. Это меньше любого разумного idle-таймаута и поддерживает NAT-таблицы операторов в актуальном состоянии. - Идентификаторы событий. Присваивайте каждому событию монотонно растущий id. При переподключении браузер пришлёт заголовок Last-Event-ID, и сервер сможет доотправить пропущенное. Без этого любой обрыв на прокси — потеря данных.
- Поле retry. Установите разумное значение, например 3000 миллисекунд, чтобы клиенты не устраивали шторм переподключений при перезапуске сервера.
- Конфигурация nginx — та же, что для chunked. Дополнительно убедитесь, что для text/event-stream не применяется gzip: если gzip_types включает text/*, добавьте отдельный location с gzip off.
- Планирование соединений. Каждый открытый SSE-поток при HTTP/1.1 — это отдельное соединение между прокси и бэкендом. Для тысячи одновременных клиентов нужна тысяча соединений. Используйте HTTP/2 на стороне клиента и асинхронный сервер на бэкенде.
- Обработка закрытия. Сервер должен обнаруживать разрыв соединения клиентом и останавливать генерацию. Через прокси это происходит с задержкой: сервер узнаёт о разрыве только при попытке записи. Для дорогих операций вроде инференса модели это лишние секунды работы GPU. Решение — регулярные записи heartbeat, которые провоцируют ошибку записи при разорванном соединении.
SSE и HTTP/2: нюансы
Через HTTP/2 SSE работает без ограничения в шесть соединений — это главная причина включать HTTP/2 на фронтовом прокси. Однако при трансляции HTTP/2 в HTTP/1.1 к бэкенду некоторые прокси добавляют небольшую задержку из-за агрегации фреймов. Убедитесь, что первое событие уходит немедленно, а не ждёт заполнения фрейма. Если бэкенд тоже говорит по HTTP/2, задержки минимальны, но проверьте, что прокси корректно пересылает WINDOW_UPDATE и не душит поток управлением окна.
Фреймворк дизайна SSE-потока
- Определите типы событий и их частоту. Редкие события требуют heartbeat; частые — батчинга нескольких записей внутри одного события.
- Выберите стратегию возобновления: хранить кольцевой буфер последних событий на сервере для обработки Last-Event-ID или полагаться на полную ресинхронизацию при переподключении.
- Задайте лимит длительности одного потока. Хорошая практика — сервер сам закрывает поток каждые 5-10 минут, клиент прозрачно переподключается. Это защищает от накопления состояния и обходит скрытые таймауты инфраструктуры.
- Продумайте деградацию: если поток не проходит через прокси, автоматически переключайтесь на long-polling.
Метод 3: long-polling — поток из последовательности обычных ответов
Как работает и почему всё ещё актуален
Long-polling — старейший приём из трёх. Клиент отправляет запрос, сервер не отвечает сразу, а ждёт события до заданного таймаута (обычно 20-60 секунд). Появилось событие — сервер отдаёт ответ и закрывает его. Ничего не появилось — отдаёт пустой ответ. Клиент сразу же отправляет следующий запрос. Со стороны это выглядит как поток с минимальной задержкой, но каждый ответ — обычный, с Content-Length, полностью совместимый с любым прокси, любым кешем и любым шлюзом.
Почему в 2026 году long-polling жив и здоров? Потому что он проходит везде. Через корпоративные шлюзы, которые режут chunked. Через облачные API-шлюзы с лимитом времени ответа. Через прокси-серверы с непредсказуемой буферизацией. Известнейший пример — метод получения обновлений в Bot API одного крупного мессенджера, где параметр timeout задаёт длительность ожидания. Подавляющее большинство ботов годами работает именно так, через самые разные прокси, и без проблем.
Пять правил проектирования long-polling через прокси
- Серверный таймаут меньше самого короткого таймаута в цепочке. Если у прокси proxy_read_timeout 60 секунд, серверное ожидание — не более 50. Если в цепочке облачный шлюз с 30 секундами — не более 25. Иначе вместо пустого ответа клиент получит 504, а поток ошибок сведёт с ума мониторинг.
- Курсор или offset. Клиент передаёт идентификатор последнего полученного события. Сервер отдаёт всё, что появилось после него. Протокол становится идемпотентным: потерянный ответ просто приводит к повторной выдаче тех же событий.
- Джиттер при переподключении после ошибки. Экспоненциальный рост задержки — 1, 2, 4, 8 секунд — плюс случайная добавка. Без джиттера тысяча клиентов после сбоя ударит по серверу одновременно.
- Ноль паузы после успешного ответа. Следующий запрос уходит немедленно. Любая пауза здесь — потерянная латентность.
- Keep-alive обязателен. Без него каждый запрос — новое TCP-соединение и новое TLS-рукопожатие. Это добавляет от 50 до 300 миллисекунд на каждый цикл, а через удалённый прокси — ещё больше.
Пошаговая реализация
- Сервер: эндпоинт принимает offset и timeout, ждёт события на внутренней очереди или через подписку, отвечает массивом событий с новым offset. Пустой массив — нормальный ответ, не ошибка.
- Прокси: стандартная конфигурация, но proxy_read_timeout не меньше серверного таймаута плюс десять секунд запаса. Буферизация может оставаться включённой — ответ короткий и целостный.
- Клиент: цикл с обработкой трёх исходов — данные, пустой ответ, ошибка. Единый пул соединений, keep-alive, клиентский таймаут больше серверного.
- Мониторинг: доля пустых ответов, среднее время ожидания, частота 5xx и клиентских таймаутов.
Когда long-polling проигрывает
При высокой частоте событий накладные расходы на заголовки и цикл запрос-ответ становятся заметными. При тысячах клиентов серверу нужно держать тысячи ожидающих запросов — без асинхронного стека не обойтись. И, разумеется, long-polling неудобен для стриминга одного длинного ответа, где нужна последовательность фрагментов одной сущности. Токены языковой модели через long-polling — теоретически возможно, практически неуклюже.
Метод 4: потребление потоковых ответов через исходящий прокси
Особенности сценария
До сих пор мы смотрели глазами владельца сервера. Теперь развернём картину: вы — клиент, обращаетесь к чужому потоковому API через прокси-сервер, и от вас зависит только клиентская сторона. Типичные задачи: сбор данных из потоковых API через пул адресов, работа с LLM-стримингом из скриптов автоматизации, распределение нагрузки на API по разным IP, отслеживание событий на площадках в реальном времени, тестирование собственного сервиса из разных сетей.
Здесь важны три вещи. Сам прокси должен прозрачно пропускать chunked-ответы. Клиентская библиотека должна читать поток по мере поступления. И вы должны уметь отличить проблему на прокси от проблемы на целевом сервере.
Проверка прокси на прозрачность потока
- Возьмите заведомо потоковый эндпоинт — публичный тестовый сервис, отдающий строки с задержкой, или собственный эндпоинт с известным расписанием чанков.
- Выполните запрос напрямую и через прокси с помощью curl с флагом -N (отключает буферизацию вывода самого curl) и флагом --trace-time для временных меток. Сравните моменты прихода фрагментов.
- Если через прокси все фрагменты приходят одним куском в конце — прокси буферизует полностью. Если порциями по несколько килобайт — частично. Если совпадают с прямым запросом — прозрачен.
- Проверьте длинный поток (5-10 минут) с heartbeat. Обрыв через фиксированное время выявляет idle-таймаут прокси.
- Проверьте HTTPS. Через прокси с методом CONNECT создаётся туннель, и прокси не разбирает HTTP внутри — буферизации на уровне HTTP быть не может, только TCP-задержки. Это одна из причин, почему потоковые API через CONNECT-туннель обычно работают ровнее, чем через обычный HTTP-прокси, разбирающий запросы.
Тонкость про мобильные прокси: сотовая сеть сама добавляет джиттер, а NAT операторов агрессивно закрывает неактивные соединения. Для длинных потоков через мобильный прокси heartbeat раз в 15-20 секунд — необходимость. Ротация IP по расписанию должна учитывать открытые потоки: смена адреса посреди SSE-соединения гарантированно его обрывает. Согласуйте ротацию с жизненным циклом потоков — закрыли поток, сменили адрес, открыли новый с курсором.
Клиентские библиотеки: что включить
- Python, requests: stream=True в вызове, затем iter_lines или iter_content с небольшим chunk_size. Таймаут задавайте кортежем (connect, read), где read — допустимое время между чанками, а не общее время ответа.
- Python, httpx: client.stream и aiter_lines для асинхронного кода; для SSE — специализированные обёртки, разбирающие формат событий.
- Python, aiohttp: response.content.iter_any возвращает данные ровно в том виде, в каком они пришли из сокета, без переупаковки — идеально для измерения реальных интервалов.
- Node.js: fetch с чтением response.body как ReadableStream; для SSE — библиотеки-парсеры формата.
- Go: обычный http.Client, чтение resp.Body через bufio.Scanner с достаточным размером буфера под крупные события.
Во всех случаях: не вызывайте методы, читающие тело целиком — text, json, read без аргументов. Иначе клиент будет ждать закрытия соединения, и вы обвините прокси в буферизации, которой нет.
Диагностический протокол «три точки»
Когда поток ведёт себя странно, измерьте время до первого байта и распределение интервалов между чанками в трёх конфигурациях: напрямую к серверу с той же машины; через прокси к серверу; через прокси к эталонному потоковому эндпоинту. Сравнение однозначно локализует проблему. Через прокси к эталону хорошо, а к целевому серверу плохо — виновата инфраструктура целевого сервера. К эталону плохо — виноват прокси. Напрямую тоже плохо — виноват ваш код или сеть. Этот протокол занимает десять минут и экономит дни споров.
Типичные ошибки при работе с потоками через прокси
- Отключили proxy_buffering, забыли про gzip. Самая частая ошибка. Поток формально не буферизуется, но сжатие накапливает данные до размера окна. Симптом: рывки по несколько килобайт.
- Оставили proxy_http_version 1.0. nginx по умолчанию ходит к бэкенду по HTTP/1.0, где chunked не существует, и вынужден дождаться закрытия соединения. Симптом: весь ответ приходит в конце.
- Не отправляют heartbeat. Поток живёт ровно до первого idle-таймаута в цепочке — 60 секунд у nginx, 15 у Envoy по маршруту, несколько минут у NAT. Симптом: обрывы через одинаковые интервалы.
- Таймаут long-polling больше таймаута прокси. Клиент получает 504 вместо пустого ответа, мониторинг горит красным, а события могут дублироваться.
- Полагаются на глобальную настройку прокси. При переезде в новое окружение или смене CDN стриминг молча ломается. Решение — X-Accel-Buffering и no-transform на уровне ответа: поведение задаёт приложение, а не администратор прокси.
- Нет Last-Event-ID и курсоров. Любой обрыв — потеря данных. Через прокси обрывы случаются заметно чаще, чем напрямую.
- Читают тело целиком на клиенте. stream=True забыт, клиент ждёт завершения, разработчик винит прокси.
- Ротация IP во время открытого потока. Соединение рвётся, переподключения нет, данные теряются.
- Тестируют на коротких ответах. Буфер не успевает заполниться, всё выглядит отлично. В продакшене на длинных ответах включается запись во временный файл, и задержки взлетают.
- Смешивают потоковые и обычные маршруты в одном location. Либо ломают стриминг, либо теряют сжатие и буферизацию для обычных ответов, что бьёт по производительности всего API.
- Игнорируют разрыв соединения клиентом. Через прокси сервер узнаёт о разрыве поздно и продолжает дорогую генерацию. Для LLM-инференса это прямые деньги.
- Используют chunked там, где нужен long-polling. Через корпоративный шлюз или облачный API-gateway с лимитом ответа поток не пройдёт, а long-polling пройдёт без вопросов.
Инструменты и ресурсы для настройки и диагностики
Обратные прокси и балансировщики
- nginx — эталон гибкости. Ключевые директивы: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, поддержка заголовка X-Accel-Buffering.
- HAProxy — минимальная буферизация из коробки. Следите за timeout server, timeout tunnel и компрессией.
- Envoy — стримит по умолчанию. Критичны route timeout и stream_idle_timeout.
- Caddy — не буферизует по умолчанию; flush_interval со значением -1 задаёт немедленный флаш явно.
- Traefik — передаёт потоки прозрачно; таймауты настраиваются на уровне entrypoints.
Диагностика
- curl с флагами -N, -v и --trace-time показывает моменты прихода каждого фрагмента. Параметр -w с переменными time_starttransfer и time_total даёт время первого байта и общее время.
- tcpdump и Wireshark — проверить, идут ли байты с задержкой на сетевом уровне или задерживается выше.
- mitmproxy — просмотр потоков с сохранением структуры чанков. Обязательно включите режим стриминга, иначе он сам станет точкой буферизации.
- Инструменты разработчика браузера — вкладка EventStream для SSE показывает каждое событие с временной меткой.
Тестовые эндпоинты и библиотеки
Публичные сервисы для тестирования HTTP имеют эндпоинты, отдающие заданное число строк с задержкой — они идеальны для проверки прозрачности прокси. Собственный минимальный сервер на любом языке, отдающий чанк раз в секунду с временной меткой, ещё лучше: вы контролируете обе стороны. Для SSE на сервере практически любой асинхронный фреймворк имеет готовый класс ответа для text/event-stream. Для SSE на клиенте вне браузера существуют парсеры формата для Python, Node.js и Go. Для long-polling специальных библиотек не требуется — достаточно HTTP-клиента с пулом соединений.
Мониторинг
Метрики, которые стоит собирать: время до первого байта тела; распределение интервалов между чанками по перцентилям 50, 95 и 99; длительность жизни потоков и причина закрытия; число активных потоков на прокси и на бэкенде; доля переподключений с Last-Event-ID. Резкий рост интервала между чанками при одновременном росте объёма — верный сигнал включившейся буферизации.
Кейсы и результаты: как это выглядит в реальных проектах
Кейс 1. Стриминг LLM через nginx: от 11 секунд до 310 миллисекунд
Команда внедрила чат на базе языковой модели. Локально токены появлялись плавно. После выкатки за nginx пользователи видели пустой экран 8-12 секунд, затем весь ответ разом. Диагностика по протоколу «три точки» показала: напрямую к приложению первый токен приходил через 280 миллисекунд, через nginx — через 11 секунд. Причины классические: proxy_buffering on и proxy_http_version 1.0 по умолчанию. После добавления proxy_buffering off, proxy_http_version 1.1, gzip off для маршрута и заголовка X-Accel-Buffering: no в ответе приложения время до первого токена через прокси составило 310 миллисекунд. Побочная находка: при закрытии вкладки инференс продолжался до конца ответа. После внедрения heartbeat с проверкой ошибки записи расход GPU-времени на брошенные запросы снизился примерно на четверть.
Кейс 2. Дашборд на SSE и мобильные сети
Сервис мониторинга отдавал события через SSE. На проводном интернете всё работало, а с мобильных устройств потоки обрывались через 2-4 минуты без ошибок на сервере. Причина — NAT-таймауты операторов на неактивных соединениях. Решение: heartbeat-комментарий каждые 20 секунд плюс серверное принудительное закрытие потока каждые 10 минут с корректным Last-Event-ID. Жалобы на «зависший дашборд» упали практически до нуля, средняя длительность непрерывного потока выросла с 3 до 10 минут (ограниченная уже намеренным закрытием), потерь событий при переподключении не фиксировалось.
Кейс 3. Парсинг потокового API через пул мобильных прокси
Команда собирала события с площадки, отдающей данные потоком NDJSON, через пул мобильных прокси. Наблюдались две проблемы: часть потоков приходила рывками по 8 килобайт, часть обрывалась при ротации адреса. Тестирование показало, что для нешифрованных запросов прокси разбирал HTTP и буферизовал ответы, а через CONNECT-туннель к HTTPS-эндпоинту пропускал поток прозрачно. Переход на HTTPS решил первую проблему полностью. Вторую закрыли синхронизацией: ротация IP выполняется только после корректного закрытия потока, а переподключение идёт с курсором последнего события. Полнота собираемых данных выросла с примерно 91 до 99,7 процента.
Кейс 4. Бот на long-polling через ограниченный шлюз
Разработчик держал бота на инфраструктуре, где исходящие запросы шли через корпоративный шлюз с лимитом ответа в 30 секунд. Изначально использовался таймаут ожидания 60 секунд — половина запросов заканчивалась ошибкой шлюза, обновления дублировались. После снижения таймаута до 25 секунд и добавления экспоненциального джиттера при ошибках доля ошибок упала с 48 до менее 0,5 процента. Средняя задержка доставки события не изменилась — она определяется моментом события, а не длиной ожидания.
Кейс 5. Переход на HTTP/2 для SSE
Веб-приложение открывало по 3-4 SSE-потока на вкладку. При нескольких открытых вкладках браузер исчерпывал лимит в шесть соединений, и обычные запросы вставали в очередь за потоками. Включение HTTP/2 на фронтовом прокси перевело все потоки в одно соединение. Время загрузки страницы при пяти открытых вкладках снизилось с 9 до 1,5 секунды. Побочная находка: после перехода потребовалось увеличить stream_idle_timeout, поскольку прежние настройки были рассчитаны на HTTP/1.1.
FAQ: глубокие вопросы о потоковых ответах через прокси
Чем принципиально потоковый HTTP отличается от WebSocket с точки зрения прокси?
WebSocket требует апгрейда протокола: прокси должен распознать заголовки Upgrade и Connection, переключиться в режим туннеля и перестать разбирать HTTP. Потоковый HTTP ничего не требует — это обычный ответ, который долго не заканчивается. Парадокс в том, что WebSocket через прокси либо работает, либо не работает вовсе, а потоковый HTTP всегда «работает», но может работать плохо: данные доходят, но с задержкой. Поэтому проблемы с потоками сложнее заметить и диагностировать.
Почему X-Accel-Buffering: no не всегда помогает?
Заголовок понимает nginx и совместимые с ним прокси. CDN, облачный шлюз или прокси другого типа его проигнорируют. Кроме того, X-Accel-Buffering не влияет на gzip — сжатие нужно отключать отдельно. И если между приложением и nginx стоит слой, удаляющий нестандартные заголовки, до nginx он не дойдёт.
Можно ли сжимать потоковый ответ?
Технически да: gzip поддерживает синхронный флаш, и сервер может сжимать каждый чанк с немедленной отдачей. Степень сжатия при этом падает, поскольку словарь не успевает наполниться. На практике для SSE и токенов LLM сжатие отключают: экономия трафика в несколько процентов не оправдывает риска задержек. Для потоков крупных JSON-объектов сжатие с флашем может дать ощутимый выигрыш.
Как выбрать между SSE и long-polling?
Если клиент — браузер, события идут чаще раза в несколько секунд и вы контролируете хотя бы обратный прокси — SSE. Если в цепочке есть неконтролируемые узлы с лимитами времени ответа, события редкие или нужна максимальная совместимость — long-polling. Зрелые системы реализуют оба варианта и переключаются автоматически по результату первого подключения.
Влияет ли HTTP/3 на проблему буферизации?
HTTP/3 работает поверх QUIC и устраняет блокировку очереди на транспортном уровне, но буферизация лежит выше — в логике прокси. Прокси с HTTP/3 на входе и HTTP/1.1 на выходе буферизует ровно так же. Что действительно меняется — поведение в мобильных сетях: QUIC лучше переживает смену сети и потери, поэтому потоки через HTTP/3 реже обрываются на стороне клиента.
Как понять, что буферизует именно исходящий прокси, а не целевой сервер?
Метод «трёх точек»: тот же запрос напрямую, через прокси и через прокси к эталонному потоковому эндпоинту. Дополнительно попробуйте HTTPS через CONNECT — если поток стал ровным, прокси разбирал и буферизовал незашифрованный HTTP.
Какой интервал heartbeat выбрать?
Меньше самого короткого таймаута в цепочке с двукратным запасом. Для типичной инфраструктуры — 15-25 секунд, для мобильных сетей ближе к 15. Слишком частый heartbeat — лишний трафик и нагрузка на тысячи соединений, слишком редкий — обрывы.
Что делать, если поток должен жить часами?
Не делать этого. Проектируйте принудительное закрытие сервером каждые 5-15 минут с курсором для возобновления. Это защищает от накопления памяти, утечек и невидимых таймаутов, а также упрощает деплой: вы перезапускаете серверы, не думая о часовых соединениях.
Как прокси влияет на обнаружение отключения клиента?
Между клиентом и сервером теперь два соединения. Когда клиент отключается, прокси узнаёт об этом сразу, а серверу сообщает при следующей попытке записи или по собственным правилам. Сервер заметит обрыв только при записи. Отсюда практика регулярных записей heartbeat для раннего обнаружения разрыва и остановки дорогих операций.
Нужна ли особая настройка мобильного прокси для потоков?
Со стороны пользователя сам прокси обычно не настраивается. Но нужно: предпочитать HTTPS для прозрачного туннеля; согласовать ротацию IP с жизненным циклом потоков; держать heartbeat не реже 15-20 секунд; использовать keep-alive и пул соединений; проверять каждый пул на прозрачность до запуска в продакшен.
Заключение: резюме и следующие шаги
Потоковый HTTP — это не экзотика и не отдельный протокол. Это обычный ответ, который не спешит закрываться. Именно поэтому он так уязвим перед промежуточными узлами: прокси не видит ничего особенного и применяет правила, придуманные для коротких ответов. Буферизация задерживает данные, таймауты обрывают соединение, сжатие маскирует буферизацию — и всё это в восьми разных точках цепочки.
Три механизма — chunked, SSE и long-polling — решают одну задачу с разной степенью зависимости от прозрачности прокси. Chunked даёт максимальный контроль ценой самостоятельной обработки на клиенте. SSE даёт готовую модель событий и переподключение в браузере, но требует внимания к каждому узлу. Long-polling проходит через что угодно, но платит за это накладными расходами на частые запросы. Выбор определяется четырьмя вопросами: контролируете ли вы цепочку, кто клиент, какова природа данных и какова их частота.
Что сделать уже сегодня:
- Пройдите по карте восьми точек буферизации для вашей инфраструктуры и отметьте, какие вы контролируете.
- Добавьте в ответы потоковых маршрутов X-Accel-Buffering: no и Cache-Control: no-cache, no-transform — независимо от текущей конфигурации прокси.
- Проверьте proxy_http_version, proxy_buffering, gzip и proxy_read_timeout в nginx или их аналоги в вашем прокси. Вынесите потоковые маршруты в отдельные блоки.
- Внедрите heartbeat не реже чем раз в 25 секунд и принудительное закрытие потока каждые 5-15 минут с курсором.
- Если вы потребляете чужие потоки через прокси — прогоните протокол «три точки» на каждом пуле адресов и переведите потоковые запросы на HTTPS.
- Настройте мониторинг времени первого байта и интервалов между чанками. Это единственный способ узнать о буферизации раньше пользователей.
Прокси — не враг потока. Правильно настроенный прокси добавляет к потоку отказоустойчивость, распределение нагрузки и защиту бэкенда. Задача лишь в том, чтобы объяснить ему: этот ответ особенный, его нужно передавать так, как он приходит. Теперь у вас есть всё, чтобы это объяснение прозвучало на его языке.