Введение: почему потоковый 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 с ответами в несколько килобайт всё это разумно и экономит ресурсы. Для потока — ровно наоборот: задерживая байты, прокси уничтожает саму ценность потока. Ценность эта — в своевременности, а не в объёме.

Карта восьми точек буферизации

Пройдём по цепочке и отметим каждую точку, где данные могут застрять. Держите этот список под рукой при диагностике.

  1. Приложение. Фреймворк может буферизовать вывод сам. WSGI-серверы, PHP с включённым output_buffering, Node.js-фреймворки с middleware сжатия. Flush не вызывается — данные лежат в буфере процесса.
  2. Обратный прокси перед приложением. nginx с proxy_buffering on (включено по умолчанию) копит ответ в буферы, заданные proxy_buffer_size и proxy_buffers, а при переполнении — во временный файл на диске. Apache mod_proxy буферизует меньше, но имеет свои настройки. Caddy по умолчанию не буферизует, но flush_interval стоит проверить.
  3. Сжатие на прокси. Даже при proxy_buffering off включённый gzip накапливает данные до размера окна сжатия. Это одна из самых коварных точек: буферизация формально выключена, а поток идёт рывками.
  4. Балансировщик L7. HAProxy в режиме http передаёт данные по мере поступления, если не включён http-buffer-request, но ограничен размером tune.bufsize. Envoy по умолчанию стримит, однако фильтры компрессии или Lua могут накапливать тело.
  5. CDN и облачные шлюзы. Многие CDN буферизуют ответы для кеширования и сжатия. Часть провайдеров не поддерживает потоки дольше определённого времени или требует явных настроек. Облачные API-шлюзы часто имеют жёсткий лимит времени ответа около 30 секунд и вовсе не поддерживают стриминг тела.
  6. Исходящий прокси на стороне клиента. HTTP-прокси, через который вы ходите в интернет — корпоративный, мобильный, резидентный — тоже является HTTP-парсером. Если он построен на nginx или Squid и настроен на буферизацию, поток застрянет там. Качественные прокси-сервисы пропускают chunked-ответы прозрачно, но это нужно проверять на практике.
  7. TLS и TCP. Данные могут задерживаться в TLS-записях, если библиотека собирает их до размера 16 килобайт. Алгоритм Нейгла задерживает мелкие TCP-сегменты до подтверждения предыдущего. Для потока из мелких чанков это добавляет десятки миллисекунд на каждый.
  8. Клиентская библиотека. 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 в собственном формате.

Пошаговая настройка серверной стороны

  1. Убедитесь, что приложение пишет по частям. После каждой логической порции вызывайте flush. В Python с ASGI-сервером это генератор, отдающий байты; в Node.js — res.write с последующим flush, если задействовано сжатие; в Go — интерфейс http.Flusher после каждого Write.
  2. Не выставляйте Content-Length. Большинство фреймворков сами переключатся на chunked, если длина не задана. Проверьте, что в ответе при HTTP/1.1 присутствует Transfer-Encoding: chunked.
  3. Отключите сжатие на уровне приложения для потоковых маршрутов или убедитесь, что оно флашит вместе с данными. Компромисс — gzip с синхронным flush после каждого чанка; это работает, но снижает степень сжатия.
  4. Установите заголовок X-Accel-Buffering: no. Это специфичный для nginx заголовок, отключающий буферизацию для конкретного ответа без изменения глобальной конфигурации. Его понимают и некоторые другие прокси. Добавьте также Cache-Control: no-cache, no-transform — второе значение просит промежуточные узлы не модифицировать тело.
  5. Настройте обратный прокси. Для 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 вынужден буферизовать до закрытия соединения.
  6. Разделите маршруты. Если сжатие нужно для остального API, включайте его только в нестриминговых location-блоках.
  7. Проверьте алгоритм Нейгла. В 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 через прокси

  1. Заголовки ответа: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, а для HTTP/1.1 ещё и Connection: keep-alive.
  2. Heartbeat. Отправляйте строку-комментарий вида : ping каждые 15-25 секунд. Это меньше любого разумного idle-таймаута и поддерживает NAT-таблицы операторов в актуальном состоянии.
  3. Идентификаторы событий. Присваивайте каждому событию монотонно растущий id. При переподключении браузер пришлёт заголовок Last-Event-ID, и сервер сможет доотправить пропущенное. Без этого любой обрыв на прокси — потеря данных.
  4. Поле retry. Установите разумное значение, например 3000 миллисекунд, чтобы клиенты не устраивали шторм переподключений при перезапуске сервера.
  5. Конфигурация nginx — та же, что для chunked. Дополнительно убедитесь, что для text/event-stream не применяется gzip: если gzip_types включает text/*, добавьте отдельный location с gzip off.
  6. Планирование соединений. Каждый открытый SSE-поток при HTTP/1.1 — это отдельное соединение между прокси и бэкендом. Для тысячи одновременных клиентов нужна тысяча соединений. Используйте HTTP/2 на стороне клиента и асинхронный сервер на бэкенде.
  7. Обработка закрытия. Сервер должен обнаруживать разрыв соединения клиентом и останавливать генерацию. Через прокси это происходит с задержкой: сервер узнаёт о разрыве только при попытке записи. Для дорогих операций вроде инференса модели это лишние секунды работы GPU. Решение — регулярные записи heartbeat, которые провоцируют ошибку записи при разорванном соединении.

SSE и HTTP/2: нюансы

Через HTTP/2 SSE работает без ограничения в шесть соединений — это главная причина включать HTTP/2 на фронтовом прокси. Однако при трансляции HTTP/2 в HTTP/1.1 к бэкенду некоторые прокси добавляют небольшую задержку из-за агрегации фреймов. Убедитесь, что первое событие уходит немедленно, а не ждёт заполнения фрейма. Если бэкенд тоже говорит по HTTP/2, задержки минимальны, но проверьте, что прокси корректно пересылает WINDOW_UPDATE и не душит поток управлением окна.

Фреймворк дизайна SSE-потока

  1. Определите типы событий и их частоту. Редкие события требуют heartbeat; частые — батчинга нескольких записей внутри одного события.
  2. Выберите стратегию возобновления: хранить кольцевой буфер последних событий на сервере для обработки Last-Event-ID или полагаться на полную ресинхронизацию при переподключении.
  3. Задайте лимит длительности одного потока. Хорошая практика — сервер сам закрывает поток каждые 5-10 минут, клиент прозрачно переподключается. Это защищает от накопления состояния и обходит скрытые таймауты инфраструктуры.
  4. Продумайте деградацию: если поток не проходит через прокси, автоматически переключайтесь на long-polling.

Метод 3: long-polling — поток из последовательности обычных ответов

Как работает и почему всё ещё актуален

Long-polling — старейший приём из трёх. Клиент отправляет запрос, сервер не отвечает сразу, а ждёт события до заданного таймаута (обычно 20-60 секунд). Появилось событие — сервер отдаёт ответ и закрывает его. Ничего не появилось — отдаёт пустой ответ. Клиент сразу же отправляет следующий запрос. Со стороны это выглядит как поток с минимальной задержкой, но каждый ответ — обычный, с Content-Length, полностью совместимый с любым прокси, любым кешем и любым шлюзом.

Почему в 2026 году long-polling жив и здоров? Потому что он проходит везде. Через корпоративные шлюзы, которые режут chunked. Через облачные API-шлюзы с лимитом времени ответа. Через прокси-серверы с непредсказуемой буферизацией. Известнейший пример — метод получения обновлений в Bot API одного крупного мессенджера, где параметр timeout задаёт длительность ожидания. Подавляющее большинство ботов годами работает именно так, через самые разные прокси, и без проблем.

Пять правил проектирования long-polling через прокси

  1. Серверный таймаут меньше самого короткого таймаута в цепочке. Если у прокси proxy_read_timeout 60 секунд, серверное ожидание — не более 50. Если в цепочке облачный шлюз с 30 секундами — не более 25. Иначе вместо пустого ответа клиент получит 504, а поток ошибок сведёт с ума мониторинг.
  2. Курсор или offset. Клиент передаёт идентификатор последнего полученного события. Сервер отдаёт всё, что появилось после него. Протокол становится идемпотентным: потерянный ответ просто приводит к повторной выдаче тех же событий.
  3. Джиттер при переподключении после ошибки. Экспоненциальный рост задержки — 1, 2, 4, 8 секунд — плюс случайная добавка. Без джиттера тысяча клиентов после сбоя ударит по серверу одновременно.
  4. Ноль паузы после успешного ответа. Следующий запрос уходит немедленно. Любая пауза здесь — потерянная латентность.
  5. Keep-alive обязателен. Без него каждый запрос — новое TCP-соединение и новое TLS-рукопожатие. Это добавляет от 50 до 300 миллисекунд на каждый цикл, а через удалённый прокси — ещё больше.

Пошаговая реализация

  1. Сервер: эндпоинт принимает offset и timeout, ждёт события на внутренней очереди или через подписку, отвечает массивом событий с новым offset. Пустой массив — нормальный ответ, не ошибка.
  2. Прокси: стандартная конфигурация, но proxy_read_timeout не меньше серверного таймаута плюс десять секунд запаса. Буферизация может оставаться включённой — ответ короткий и целостный.
  3. Клиент: цикл с обработкой трёх исходов — данные, пустой ответ, ошибка. Единый пул соединений, keep-alive, клиентский таймаут больше серверного.
  4. Мониторинг: доля пустых ответов, среднее время ожидания, частота 5xx и клиентских таймаутов.

Когда long-polling проигрывает

При высокой частоте событий накладные расходы на заголовки и цикл запрос-ответ становятся заметными. При тысячах клиентов серверу нужно держать тысячи ожидающих запросов — без асинхронного стека не обойтись. И, разумеется, long-polling неудобен для стриминга одного длинного ответа, где нужна последовательность фрагментов одной сущности. Токены языковой модели через long-polling — теоретически возможно, практически неуклюже.

Метод 4: потребление потоковых ответов через исходящий прокси

Особенности сценария

До сих пор мы смотрели глазами владельца сервера. Теперь развернём картину: вы — клиент, обращаетесь к чужому потоковому API через прокси-сервер, и от вас зависит только клиентская сторона. Типичные задачи: сбор данных из потоковых API через пул адресов, работа с LLM-стримингом из скриптов автоматизации, распределение нагрузки на API по разным IP, отслеживание событий на площадках в реальном времени, тестирование собственного сервиса из разных сетей.

Здесь важны три вещи. Сам прокси должен прозрачно пропускать chunked-ответы. Клиентская библиотека должна читать поток по мере поступления. И вы должны уметь отличить проблему на прокси от проблемы на целевом сервере.

Проверка прокси на прозрачность потока

  1. Возьмите заведомо потоковый эндпоинт — публичный тестовый сервис, отдающий строки с задержкой, или собственный эндпоинт с известным расписанием чанков.
  2. Выполните запрос напрямую и через прокси с помощью curl с флагом -N (отключает буферизацию вывода самого curl) и флагом --trace-time для временных меток. Сравните моменты прихода фрагментов.
  3. Если через прокси все фрагменты приходят одним куском в конце — прокси буферизует полностью. Если порциями по несколько килобайт — частично. Если совпадают с прямым запросом — прозрачен.
  4. Проверьте длинный поток (5-10 минут) с heartbeat. Обрыв через фиксированное время выявляет idle-таймаут прокси.
  5. Проверьте 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 без аргументов. Иначе клиент будет ждать закрытия соединения, и вы обвините прокси в буферизации, которой нет.

Диагностический протокол «три точки»

Когда поток ведёт себя странно, измерьте время до первого байта и распределение интервалов между чанками в трёх конфигурациях: напрямую к серверу с той же машины; через прокси к серверу; через прокси к эталонному потоковому эндпоинту. Сравнение однозначно локализует проблему. Через прокси к эталону хорошо, а к целевому серверу плохо — виновата инфраструктура целевого сервера. К эталону плохо — виноват прокси. Напрямую тоже плохо — виноват ваш код или сеть. Этот протокол занимает десять минут и экономит дни споров.

Типичные ошибки при работе с потоками через прокси

  1. Отключили proxy_buffering, забыли про gzip. Самая частая ошибка. Поток формально не буферизуется, но сжатие накапливает данные до размера окна. Симптом: рывки по несколько килобайт.
  2. Оставили proxy_http_version 1.0. nginx по умолчанию ходит к бэкенду по HTTP/1.0, где chunked не существует, и вынужден дождаться закрытия соединения. Симптом: весь ответ приходит в конце.
  3. Не отправляют heartbeat. Поток живёт ровно до первого idle-таймаута в цепочке — 60 секунд у nginx, 15 у Envoy по маршруту, несколько минут у NAT. Симптом: обрывы через одинаковые интервалы.
  4. Таймаут long-polling больше таймаута прокси. Клиент получает 504 вместо пустого ответа, мониторинг горит красным, а события могут дублироваться.
  5. Полагаются на глобальную настройку прокси. При переезде в новое окружение или смене CDN стриминг молча ломается. Решение — X-Accel-Buffering и no-transform на уровне ответа: поведение задаёт приложение, а не администратор прокси.
  6. Нет Last-Event-ID и курсоров. Любой обрыв — потеря данных. Через прокси обрывы случаются заметно чаще, чем напрямую.
  7. Читают тело целиком на клиенте. stream=True забыт, клиент ждёт завершения, разработчик винит прокси.
  8. Ротация IP во время открытого потока. Соединение рвётся, переподключения нет, данные теряются.
  9. Тестируют на коротких ответах. Буфер не успевает заполниться, всё выглядит отлично. В продакшене на длинных ответах включается запись во временный файл, и задержки взлетают.
  10. Смешивают потоковые и обычные маршруты в одном location. Либо ломают стриминг, либо теряют сжатие и буферизацию для обычных ответов, что бьёт по производительности всего API.
  11. Игнорируют разрыв соединения клиентом. Через прокси сервер узнаёт о разрыве поздно и продолжает дорогую генерацию. Для LLM-инференса это прямые деньги.
  12. Используют 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 проходит через что угодно, но платит за это накладными расходами на частые запросы. Выбор определяется четырьмя вопросами: контролируете ли вы цепочку, кто клиент, какова природа данных и какова их частота.

Что сделать уже сегодня:

  1. Пройдите по карте восьми точек буферизации для вашей инфраструктуры и отметьте, какие вы контролируете.
  2. Добавьте в ответы потоковых маршрутов X-Accel-Buffering: no и Cache-Control: no-cache, no-transform — независимо от текущей конфигурации прокси.
  3. Проверьте proxy_http_version, proxy_buffering, gzip и proxy_read_timeout в nginx или их аналоги в вашем прокси. Вынесите потоковые маршруты в отдельные блоки.
  4. Внедрите heartbeat не реже чем раз в 25 секунд и принудительное закрытие потока каждые 5-15 минут с курсором.
  5. Если вы потребляете чужие потоки через прокси — прогоните протокол «три точки» на каждом пуле адресов и переведите потоковые запросы на HTTPS.
  6. Настройте мониторинг времени первого байта и интервалов между чанками. Это единственный способ узнать о буферизации раньше пользователей.

Прокси — не враг потока. Правильно настроенный прокси добавляет к потоку отказоустойчивость, распределение нагрузки и защиту бэкенда. Задача лишь в том, чтобы объяснить ему: этот ответ особенный, его нужно передавать так, как он приходит. Теперь у вас есть всё, чтобы это объяснение прозвучало на его языке.