Odpowiedzi strumieniowe przez proxy: chunked, SSE i long-polling bez buforowania
Spis treści
- Wprowadzenie: dlaczego strumieniowy http przez proxy stał się powszechnym problemem
- Podstawy: jak zwykła odpowiedź http zamienia się w strumień
- Głębokie zanurzenie: gdzie i dlaczego strumień utyka na węźle pośrednim
- Metoda 1: chunked transfer encoding — niskopoziomowy strumień bez opakowania
- Metoda 2: server-sent events — standard dla zdarzeń od serwera do klienta
- Metoda 3: long-polling — strumień z sekwencji zwykłych odpowiedzi
- Metoda 4: konsumpcja odpowiedzi strumieniowych przez proxy wychodzące
- Typowe błędy przy pracy ze strumieniami przez proxy
- Narzędzia i zasoby do konfiguracji i diagnostyki
- Przypadki i wyniki: jak to wygląda w rzeczywistych projektach
- Faq: głębokie pytania o odpowiedzi strumieniowe przez proxy
- Podsumowanie: rezultaty i kolejne kroki
Wprowadzenie: dlaczego strumieniowy HTTP przez proxy stał się powszechnym problemem
Wyobraź sobie: wysyłasz zapytanie do modelu językowego i zamiast znanego „pisania” tokenów ekran milczy przez czterdzieści sekund, a potem wypluwa całą odpowiedź jednym kawałkiem. Albo dashboard monitoringu, który musi odświeżać się co sekundę, pokazuje dane z opóźnieniem pół minuty. Albo parser, który nasłuchuje strumienia zdarzeń giełdy, dostaje paczki po sto zdarzeń zamiast równego strumienia. W dziewięciu przypadkach na dziesięć winny nie jest serwer ani klient. Winny jest ten, kto stoi pomiędzy nimi: proxy, load balancer, CDN lub firmowa brama, która postanowiła „pomóc” i zgromadzić odpowiedź w całości, zanim przekaże ją dalej.
Temat strumieniowych odpowiedzi HTTP przez węzły pośrednie długo uchodził za niszowy. W 2026 roku stał się masowy. Strumieniowanie tokenów z LLM API, zdarzenia serwerowe w interfejsach webowych, long-polling w komunikatorach i botach, paski postępu długich eksportów, strumieniowe wyniki parserów — wszystko to działa na zwykłym HTTP, które po prostu nie spieszy się z zamknięciem odpowiedzi. I wszystko to się psuje, gdy tylko na drodze pojawi się węzeł z włączonym buforowaniem.
W tym przewodniku omówimy trzy klasyczne mechanizmy — chunked transfer encoding, Server-Sent Events i long-polling — właśnie z punktu widzenia przechodzenia przez proxy. Ważne zastrzeżenie od razu: nie będzie tu WebSocket ani gRPC. Im poświęciliśmy osobny materiał i różnica jest zasadnicza. Tam następuje upgrade protokołu lub używane jest binarne ramkowanie na HTTP/2, a proxy musi ten upgrade rozpoznać i przepuścić. Tutaj mamy zwykłą odpowiedź HTTP, która nie ma nagłówka Content-Length i którą serwer trzyma otwartą. Żadnego handshake'u, żadnego przejścia na inny protokół. Wydawałoby się, że prościej się nie da. Ale właśnie ta prostota tworzy problem: proxy nie widzi niczego szczególnego i stosuje standardowe zasady buforowania, stworzone dla krótkich odpowiedzi.
Co z tego wyciągniesz: zrozumienie, jak zbudowany jest strumień na poziomie bajtów i nagłówków; mapę wszystkich miejsc, w których odpowiedź może utknąć; gotowe konfiguracje dla nginx, HAProxy, Envoy i bibliotek klienckich; framework wyboru między trzema mechanizmami; listy kontrolne diagnostyki; analizę rzeczywistych przypadków z liczbami. Materiał jest przeznaczony dla programistów, inżynierów DevOps i wszystkich, którzy używają proxy do pracy z API, scrapingu i automatyzacji.
Podstawy: jak zwykła odpowiedź HTTP zamienia się w strumień
Dwa sposoby na przekazanie długości odpowiedzi
W HTTP/1.1 istnieją dwa fundamentalne sposoby, by powiedzieć klientowi, gdzie kończy się ciało odpowiedzi. Pierwszy — nagłówek Content-Length: serwer z góry ogłasza dokładną liczbę bajtów. Drugi — Transfer-Encoding: chunked: serwer wysyła ciało porcjami, każda porcja zaczyna się od swojego rozmiaru w zapisie szesnastkowym, a całość kończy się zerowym chunkiem. Jest jeszcze trzeci, archaiczny wariant — po prostu zamknąć połączenie po ostatnim bajcie, ale przy keep-alive praktycznie nie jest używany.
Dlaczego to ważne dla strumienia? Ponieważ Content-Length wymaga znajomości rozmiaru z góry. Jeśli serwer generuje odpowiedź stopniowo — token po tokenie, zdarzenie po zdarzeniu — fizycznie nie może policzyć długości przed rozpoczęciem transmisji. Jedyny wariant w HTTP/1.1 to chunked. W HTTP/2 i HTTP/3 kodowanie chunked jako takie nie istnieje: tam ciało i tak jest przesyłane ramkami DATA, a koniec oznaczany jest flagą END_STREAM. Ale logika jest ta sama: odpowiedź bez zadeklarowanej długości, która może trwać dowolnie długo.
Co znaczy „nie zamykać odpowiedzi”
Analogia. Zwykła odpowiedź HTTP to paczka: dostajesz pudełko, na którym napisana jest waga, otwierasz i wiesz, że wszystko jest w środku. Odpowiedź strumieniowa to taśma produkcyjna: pudełka jadą jedno za drugim i nie wiesz, kiedy taśma się zatrzyma. Serwer wysłał nagłówki ze statusem 200, wysłał pierwszy chunk — i czeka. Pojawiły się nowe dane — wysłał następny. Połączenie pozostaje otwarte minuty, godziny, czasem dobę.
Z punktu widzenia TCP nie dzieje się nic niezwykłego: ten sam socket, te same segmenty. Z punktu widzenia HTTP — to jedno jedyne zapytanie i jedna jedyna odpowiedź, po prostu bardzo długa. I tu tkwi źródło wszystkich problemów z proxy: węzeł pośredni widzi początek odpowiedzi, nie widzi końca i musi zdecydować, co zrobić z bajtami, które już przyszły. Przekazać natychmiast? Czy poczekać, nazbierać więcej i wysłać wydajniej? Domyślnie większość proxy wybiera to drugie.
Trzy mechanizmy: wspólne cechy i różnice
- Chunked streaming — najbardziej niskopoziomowy. Serwer po prostu pisze bajty do ciała i wywołuje flush. Format zawartości jest dowolny: tekst, NDJSON, dane binarne. Klient sam decyduje, jak je parsować.
- Server-Sent Events — standaryzowany format tekstowy na wierzchu strumienia chunked. Content-Type: text/event-stream, zdarzenia oddzielone pustymi liniami, są pola data, event, id, retry. Przeglądarka obsługuje go natywnie przez EventSource z automatycznym ponownym połączeniem.
- Long-polling — ściśle mówiąc, to nie strumień. Klient wysyła zapytanie, serwer trzyma je otwarte aż do pojawienia się danych lub do timeoutu, odpowiada i zamyka. Klient natychmiast wysyła kolejne zapytanie. To imitacja strumienia sekwencją zwykłych odpowiedzi, z których każda może mieć Content-Length.
Co je łączy? We wszystkich trzech przypadkach odpowiedź na jedno zapytanie jest opóźniona na nieokreślony czas, a proxy musi to przetrwać: nie przerwać połączenia po timeoucie i nie opóźnić danych w buforze. Różnica polega na tym, jak bardzo każdy mechanizm zależy od przejrzystości węzła pośredniego. Chunked i SSE zależą krytycznie. Long-polling — minimalnie, i to jego główna zaleta.
Rola proxy w łańcuchu
Między klientem a serwerem we współczesnej infrastrukturze rzadko jest pusto. Typowy łańcuch: aplikacja kliencka — proxy wychodzące (na przykład mobilne lub rezydencjalne) — internet — CDN — load balancer w chmurze — reverse proxy — aplikacja. Każdy z tych węzłów to potencjalny punkt buforowania. I każdy domyślnie jest skonfigurowany tak, by optymalizować krótkie odpowiedzi: zebrać, skompresować, oddać w całości. Dla strumienia taka optymalizacja to katastrofa. Będziemy kolejno zdejmować te warstwy i patrzeć, co dzieje się na każdej.
Głębokie zanurzenie: gdzie i dlaczego strumień utyka na węźle pośrednim
Po co proxy w ogóle buforują
Zanim zaczniemy narzekać na buforowanie, warto zrozumieć jego logikę. Reverse proxy typu nginx buforuje z trzech powodów. Pierwszy — ochrona backendu przed wolnym klientem: jeśli klient na łączu mobilnym czyta po dziesięć kilobajtów na sekundę, a backend już wygenerował odpowiedź, korzystniej jest zabrać wszystko od backendu od razu, uwolnić jego workera i potem spokojnie oddawać klientowi z bufora. Drugi — kompresja: gzip i brotli działają wydajniej na większych blokach. Trzeci — możliwość ustawienia Content-Length i poprawnego obsłużenia błędu backendu przed wysłaniem nagłówków do klienta.
Dla typowego API z odpowiedziami kilku kilobajtów wszystko to jest rozsądne i oszczędza zasoby. Dla strumienia — dokładnie odwrotnie: opóźniając bajty, proxy niszczy samą wartość strumienia. Wartością tą jest bowiem terminowość, a nie objętość.
Mapa ośmiu punktów buforowania
Przejdźmy przez łańcuch i zaznaczmy każdy punkt, w którym dane mogą utknąć. Trzymaj tę listę pod ręką podczas diagnostyki.
- Aplikacja. Framework może sam buforować wyjście. Serwery WSGI, PHP z włączonym output_buffering, frameworki Node.js z middleware kompresji. Flush nie jest wywoływany — dane leżą w buforze procesu.
- Reverse proxy przed aplikacją. nginx z proxy_buffering on (domyślnie włączone) gromadzi odpowiedź w buforach określonych przez proxy_buffer_size i proxy_buffers, a przy przepełnieniu — w pliku tymczasowym na dysku. Apache mod_proxy buforuje mniej, ale ma swoje ustawienia. Caddy domyślnie nie buforuje, ale warto sprawdzić flush_interval.
- Kompresja na proxy. Nawet przy proxy_buffering off włączony gzip gromadzi dane do rozmiaru okna kompresji. To jeden z najpodstępniejszych punktów: buforowanie formalnie wyłączone, a strumień idzie szarpnięciami.
- Load balancer L7. HAProxy w trybie http przekazuje dane na bieżąco, o ile nie jest włączone http-buffer-request, ale jest ograniczony rozmiarem tune.bufsize. Envoy domyślnie strumieniuje, jednak filtry kompresji lub Lua mogą gromadzić ciało.
- CDN i bramy chmurowe. Wiele CDN-ów buforuje odpowiedzi na potrzeby cachowania i kompresji. Część dostawców nie obsługuje strumieni dłuższych niż określony czas lub wymaga wyraźnych ustawień. Bramy API w chmurze często mają sztywny limit czasu odpowiedzi około 30 sekund i w ogóle nie obsługują strumieniowania ciała.
- Proxy wychodzące po stronie klienta. Proxy HTTP, przez które wychodzisz do internetu — firmowe, mobilne, rezydencjalne — też jest parserem HTTP. Jeśli jest zbudowane na nginx lub Squid i skonfigurowane do buforowania, strumień utknie tam. Dobre usługi proxy przepuszczają odpowiedzi chunked przejrzyście, ale trzeba to sprawdzić w praktyce.
- TLS i TCP. Dane mogą być opóźniane w rekordach TLS, jeśli biblioteka zbiera je do rozmiaru 16 kilobajtów. Algorytm Nagle'a opóźnia małe segmenty TCP do potwierdzenia poprzedniego. Dla strumienia drobnych chunków dodaje to dziesiątki milisekund na każdy.
- Biblioteka kliencka. requests w Pythonie czyta całe ciało do pamięci, jeśli nie przekazano stream=True. Szereg klientów HTTP buforuje do rozmiaru chunk_size.
Osiem punktów. Jeśli choć jeden gromadzi dane, zobaczysz strumień w postaci szarpnięć lub jednej dużej paczki na końcu. I najgorsze: zachowanie zależy od objętości. Na małych odpowiedziach wszystko wygląda normalnie, a pod obciążeniem lub przy długich odpowiedziach bufor się zapełnia, włącza się zapis do plików tymczasowych i opóźnienia wystrzeliwują. Nic dziwnego, że wiele zespołów odkrywa problem dopiero na produkcji.
HTTP/1.1 kontra HTTP/2 w kontekście strumienia
W HTTP/1.1 jedno połączenie — jedna odpowiedź w danym momencie. Długożyjąca odpowiedź zajmuje całe połączenie. Przeglądarka ogranicza liczbę równoczesnych połączeń do jednego hosta do sześciu, więc sześć otwartych strumieni SSE blokuje wszystkie pozostałe zapytania do tego hosta. Proxy pracujące po HTTP/1.1 z backendem też trzyma po jednym połączeniu na każdy strumień.
W HTTP/2 multipleksowanie znosi to ograniczenie: sto strumieni żyje w jednym połączeniu TCP. Ale pojawia się subtelność — kontrola przepływu na poziomie protokołu. Jeśli odbiorca nie rozszerza okna przez WINDOW_UPDATE, nadawca się zatrzymuje. Niektóre proxy implementują przekazywanie tych ramek nieuważnie i tworzą sztuczne pauzy.
Ważne jest zrozumienie: proxy może przyjąć zapytanie po HTTP/2 od klienta i pójść do backendu po HTTP/1.1. Przepakowuje ramki DATA w chunki i z powrotem. To normalna operacja, ale właśnie na granicy konwersji często gubi się terminowy flush — proxy czeka, aż nazbiera się „wygodny” rozmiar ramki.
Timeouty — drugi zabójca strumieni
Buforowanie opóźnia dane. Timeouty przerywają połączenie. nginx ma proxy_read_timeout — maksymalny czas między dwiema kolejnymi operacjami odczytu od backendu, domyślnie 60 sekund. Jeśli serwer milczy dłużej niż minutę, nginx zamyka połączenie i zwraca klientowi 504. Dla long-pollingu z oczekiwaniem 90 sekund to gwarantowana awaria. HAProxy ma timeout server i timeout tunnel. Load balancery w chmurze — idle timeout, często 60 lub 350 sekund. Operatorzy mobilni — timeouty NAT, resetujące nieaktywne połączenia po kilku minutach.
Stąd żelazna zasada: strumień bez okresowej aktywności jest skazany na porażkę. Wiadomości heartbeat co 15-30 sekund to nie opcja, a obowiązkowy wymóg każdej długożyjącej odpowiedzi.
Macierz wyboru mechanizmu
Zanim przejdziemy do praktyki, ustalmy framework wyboru. Odpowiedz na cztery pytania.
- Czy kontrolujesz cały łańcuch proxy? Tak — nadają się chunked i SSE. Nie, w łańcuchu są nieznane bramy — zaczynaj od long-pollingu lub przewidź degradację do niego.
- Kto jest klientem? Przeglądarka — SSE z EventSource daje ponowne połączenie gratis. Własny kod — chunked z NDJSON jest bardziej elastyczny.
- Jaka jest natura danych? Fragmenty jednej encji (tokeny jednej odpowiedzi) — chunked lub SSE. Dyskretne niezależne zdarzenia — SSE lub long-polling.
- Jaka jest częstotliwość? Dziesiątki zdarzeń na sekundę — chunked lub SSE z batchowaniem. Zdarzenie raz na minutę — long-polling z dużym timeoutem lub SSE z heartbeat.
Metoda 1: chunked transfer encoding — niskopoziomowy strumień bez opakowania
Kiedy wybrać czysty chunked
Czysty strumień chunked jest właściwy, gdy klientem jest twój własny kod, a nie przeglądarka; gdy format danych nie jest tekstowy lub nie pasuje do modelu zdarzeń; gdy potrzebujesz maksymalnej kontroli nad każdym bajtem. Typowe przykłady: strumieniowanie NDJSON z API, strumieniowe wyniki parsera, pobieranie dużych eksportów ze wskaźnikiem postępu, proxywanie odpowiedzi LLM w własnym formacie.
Konfiguracja po stronie serwera krok po kroku
- Upewnij się, że aplikacja pisze porcjami. Po każdej logicznej porcji wywołuj flush. W Pythonie z serwerem ASGI to generator zwracający bajty; w Node.js — res.write, a następnie flush, jeśli użyta jest kompresja; w Go — interfejs http.Flusher po każdym Write.
- Nie ustawiaj Content-Length. Większość frameworków sama przełączy się na chunked, jeśli długość nie jest podana. Sprawdź, czy w odpowiedzi przy HTTP/1.1 występuje Transfer-Encoding: chunked.
- Wyłącz kompresję na poziomie aplikacji dla tras strumieniowych albo upewnij się, że flushuje razem z danymi. Kompromis — gzip z synchronicznym flush po każdym chunku; to działa, ale obniża stopień kompresji.
- Ustaw nagłówek X-Accel-Buffering: no. To specyficzny dla nginx nagłówek wyłączający buforowanie dla konkretnej odpowiedzi bez zmiany globalnej konfiguracji. Rozumieją go też niektóre inne proxy. Dodaj również Cache-Control: no-cache, no-transform — druga wartość prosi węzły pośrednie o nie modyfikowanie ciała.
- Skonfiguruj reverse proxy. Dla nginx w location trasy strumieniowej:
proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;. Dyrektywa proxy_http_version 1.1 jest obowiązkowa: domyślnie nginx łączy się z backendem po HTTP/1.0, gdzie chunked nie istnieje, więc nginx musi buforować do zamknięcia połączenia. - Rozdziel trasy. Jeśli kompresja jest potrzebna dla reszty API, włączaj ją tylko w blokach location niestrumieniowych.
- Sprawdź algorytm Nagle'a. W nginx tcp_nodelay jest domyślnie włączony, ale w aplikacji przy drobnych, częstych chunkach może być potrzebne jawne ustawienie TCP_NODELAY na sockecie.
Konfiguracja HAProxy i Envoy
HAProxy. W sekcji backend nie używaj option http-buffer-request. Upewnij się, że timeout server jest wystarczająco duży dla twojego scenariusza, a dla naprawdę długich strumieni ustaw timeout tunnel. Wyłącz kompresję dla ścieżek strumieniowych przez ACL albo polegaj na nagłówku no-transform: HAProxy respektuje Cache-Control: no-transform i nie kompresuje takich odpowiedzi.
Envoy. Buforowanie jest domyślnie wyłączone, co cieszy. Ale sprawdź dwa timeouty: stream_idle_timeout w HTTP connection manager (domyślnie pięć minut) i route timeout (domyślnie piętnaście sekund — to on najczęściej przerywa strumienie). Dla tras strumieniowych ustaw timeout na 0s, co oznacza brak limitu, i polegaj na idle timeout w połączeniu z heartbeat.
Lista kontrolna weryfikacji strumienia chunked
- W odpowiedzi jest Transfer-Encoding: chunked albo używane jest HTTP/2 bez Content-Length.
- Nagłówek X-Accel-Buffering: no występuje w odpowiedzi aplikacji.
- Content-Encoding nie występuje lub kompresja flushuje razem z danymi.
- Pierwszy bajt ciała przychodzi w ciągu sekundy po nagłówkach.
- Odstępy między chunkami u klienta pokrywają się z odstępami generowania na serwerze z dokładnością do 50 milisekund.
- Połączenie żyje dłużej niż minutę bez zerwania przy obecności heartbeat.
- W logach proxy nie ma wpisów o buforowaniu do pliku tymczasowego.
Metoda 2: Server-Sent Events — standard dla zdarzeń od serwera do klienta
Budowa formatu
SSE to konwencja rozkładania zdarzeń w strumieniu tekstowym. Odpowiedź ma Content-Type: text/event-stream. Każde zdarzenie to zbiór linii w formie „pole: wartość”, zakończony pustą linią. Pola: data — ładunek (może się powtarzać, linie sklejane są znakiem nowej linii); event — nazwa typu zdarzenia; id — identyfikator do wznowienia; retry — zalecane opóźnienie ponownego połączenia w milisekundach. Linia zaczynająca się od dwukropka to komentarz i to idealny heartbeat: przeglądarka go ignoruje, a proxy widzi aktywność na połączeniu.
Piękno SSE tkwi w asymetrii. Złożoność jest wyniesiona do specyfikacji i przeglądarki, a serwer pozostaje trywialny. Żadnego handshake'u, żadnego binarnego ramkowania. Po prostu tekst, który płynie. Właśnie dlatego SSE stał się standardem de facto dla strumieniowania odpowiedzi modeli językowych: zdecydowana większość dużych LLM API oddaje tokeny w formacie text/event-stream. Zaskakujące, że technologia opisana w specyfikacjach ponad piętnaście lat temu przeżywa w 2026 roku drugi rozkwit.
Dlaczego SSE jest szczególnie wrażliwy na buforowanie
Zdarzenie w SSE waży od kilkudziesięciu bajtów do pary kilobajtów. Domyślny bufor nginx — 4 lub 8 kilobajtów na pierwszy blok i osiem bloków po 4-8 kilobajtów dalej. To znaczy, że proxy nazbiera od pięćdziesięciu do kilkuset zdarzeń, zanim odda pierwsze. Dla czatu z modelem wygląda to tak: użytkownik czeka piętnaście sekund, potem cały akapit pojawia się natychmiast. Iluzja pisania na klawiaturze zniszczona, a przecież właśnie dla niej wdrożono strumieniowanie.
Implementacja SSE przez proxy krok po kroku
- Nagłówki odpowiedzi: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, a dla HTTP/1.1 jeszcze Connection: keep-alive.
- Heartbeat. Wysyłaj linię komentarza w formie
: pingco 15-25 sekund. To mniej niż jakikolwiek rozsądny idle timeout i utrzymuje tabele NAT operatorów w aktualnym stanie. - Identyfikatory zdarzeń. Nadawaj każdemu zdarzeniu monotonicznie rosnące id. Przy ponownym połączeniu przeglądarka przyśle nagłówek Last-Event-ID, a serwer będzie mógł dosłać pominięte. Bez tego każde zerwanie na proxy to utrata danych.
- Pole retry. Ustaw rozsądną wartość, na przykład 3000 milisekund, żeby klienci nie urządzali burzy ponownych połączeń przy restarcie serwera.
- Konfiguracja nginx — taka sama jak dla chunked. Dodatkowo upewnij się, że dla text/event-stream nie stosuje się gzip: jeśli gzip_types zawiera text/*, dodaj osobny location z gzip off.
- Planowanie połączeń. Każdy otwarty strumień SSE przy HTTP/1.1 to osobne połączenie między proxy a backendem. Dla tysiąca równoczesnych klientów potrzeba tysiąca połączeń. Używaj HTTP/2 po stronie klienta i asynchronicznego serwera na backendzie.
- Obsługa zamknięcia. Serwer musi wykrywać zerwanie połączenia przez klienta i zatrzymywać generowanie. Przez proxy następuje to z opóźnieniem: serwer dowiaduje się o zerwaniu dopiero przy próbie zapisu. Dla kosztownych operacji typu inferencja modelu to zbędne sekundy pracy GPU. Rozwiązanie — regularne zapisy heartbeat, które wywołują błąd zapisu przy zerwanym połączeniu.
SSE i HTTP/2: niuanse
Przez HTTP/2 SSE działa bez ograniczenia sześciu połączeń — to główny powód, by włączyć HTTP/2 na froncie proxy. Jednak przy translacji HTTP/2 na HTTP/1.1 do backendu niektóre proxy dodają niewielkie opóźnienie z powodu agregacji ramek. Upewnij się, że pierwsze zdarzenie odchodzi natychmiast, a nie czeka na zapełnienie ramki. Jeśli backend też mówi po HTTP/2, opóźnienia są minimalne, ale sprawdź, że proxy poprawnie przekazuje WINDOW_UPDATE i nie dławi strumienia kontrolą okna.
Framework projektowania strumienia SSE
- Określ typy zdarzeń i ich częstotliwość. Rzadkie zdarzenia wymagają heartbeat; częste — batchowania kilku zapisów w ramach jednego zdarzenia.
- Wybierz strategię wznowienia: przechowywać bufor pierścieniowy ostatnich zdarzeń na serwerze do obsługi Last-Event-ID albo polegać na pełnej resynchronizacji przy ponownym połączeniu.
- Ustaw limit czasu trwania jednego strumienia. Dobra praktyka — serwer sam zamyka strumień co 5-10 minut, klient przejrzyście się ponownie łączy. To chroni przed nagromadzeniem stanu i obchodzi ukryte timeouty infrastruktury.
- Przemyśl degradację: jeśli strumień nie przechodzi przez proxy, automatycznie przełącz się na long-polling.
Metoda 3: long-polling — strumień z sekwencji zwykłych odpowiedzi
Jak działa i dlaczego wciąż jest aktualny
Long-polling to najstarszy trik z trzech. Klient wysyła zapytanie, serwer nie odpowiada od razu, ale czeka na zdarzenie do zadanego timeoutu (zwykle 20-60 sekund). Pojawiło się zdarzenie — serwer oddaje odpowiedź i ją zamyka. Nic się nie pojawiło — oddaje pustą odpowiedź. Klient natychmiast wysyła kolejne zapytanie. Z boku wygląda to jak strumień z minimalnym opóźnieniem, ale każda odpowiedź jest zwykła, z Content-Length, w pełni kompatybilna z każdym proxy, każdym cachem i każdą bramą.
Dlaczego w 2026 roku long-polling żyje i ma się dobrze? Bo przechodzi wszędzie. Przez firmowe bramy, które tną chunked. Przez bramy API w chmurze z limitem czasu odpowiedzi. Przez serwery proxy z nieprzewidywalnym buforowaniem. Najbardziej znany przykład — metoda pobierania aktualizacji w Bot API jednego dużego komunikatora, gdzie parametr timeout określa czas oczekiwania. Zdecydowana większość botów od lat pracuje właśnie tak, przez najróżniejsze proxy, i bez problemów.
Pięć zasad projektowania long-pollingu przez proxy
- Timeout serwera mniejszy niż najkrótszy timeout w łańcuchu. Jeśli proxy ma proxy_read_timeout 60 sekund, oczekiwanie serwera — nie więcej niż 50. Jeśli w łańcuchu jest brama chmurowa z 30 sekundami — nie więcej niż 25. Inaczej zamiast pustej odpowiedzi klient dostanie 504, a strumień błędów doprowadzi monitoring do szału.
- Kursor lub offset. Klient przekazuje identyfikator ostatnio odebranego zdarzenia. Serwer oddaje wszystko, co pojawiło się po nim. Protokół staje się idempotentny: utracona odpowiedź po prostu powoduje ponowne wydanie tych samych zdarzeń.
- Jitter przy ponownym połączeniu po błędzie. Wzrost wykładniczy opóźnienia — 1, 2, 4, 8 sekund — plus losowy dodatek. Bez jittera tysiąc klientów po awarii uderzy w serwer jednocześnie.
- Zero pauzy po udanej odpowiedzi. Kolejne zapytanie odchodzi natychmiast. Jakakolwiek pauza tutaj to utracone opóźnienie.
- Keep-alive obowiązkowy. Bez niego każde zapytanie to nowe połączenie TCP i nowy handshake TLS. To dodaje od 50 do 300 milisekund na każdy cykl, a przez zdalne proxy — jeszcze więcej.
Implementacja krok po kroku
- Serwer: endpoint przyjmuje offset i timeout, czeka na zdarzenie w wewnętrznej kolejce lub przez subskrypcję, odpowiada tablicą zdarzeń z nowym offsetem. Pusta tablica — normalna odpowiedź, nie błąd.
- Proxy: standardowa konfiguracja, ale proxy_read_timeout nie mniejszy niż timeout serwera plus dziesięć sekund zapasu. Buforowanie może pozostać włączone — odpowiedź jest krótka i całościowa.
- Klient: pętla z obsługą trzech rezultatów — dane, pusta odpowiedź, błąd. Jedna pula połączeń, keep-alive, timeout klienta większy niż serwera.
- Monitoring: udział pustych odpowiedzi, średni czas oczekiwania, częstość 5xx i timeoutów klienta.
Kiedy long-polling przegrywa
Przy dużej częstotliwości zdarzeń narzut na nagłówki i cykl zapytanie-odpowiedź staje się zauważalny. Przy tysiącach klientów serwer musi trzymać tysiące oczekujących zapytań — bez stosu asynchronicznego się nie obejdzie. I oczywiście long-polling jest niewygodny dla strumieniowania jednej długiej odpowiedzi, gdzie potrzebna jest sekwencja fragmentów jednej encji. Tokeny modelu językowego przez long-polling — teoretycznie możliwe, praktycznie niezgrabne.
Metoda 4: konsumpcja odpowiedzi strumieniowych przez proxy wychodzące
Specyfika scenariusza
Do tej pory patrzyliśmy oczami właściciela serwera. Teraz obróćmy obraz: ty jesteś klientem, łączysz się z cudzym API strumieniowym przez serwer proxy, i zależy od ciebie tylko strona kliencka. Typowe zadania: zbieranie danych z API strumieniowych przez pulę adresów, praca ze strumieniowaniem LLM ze skryptów automatyzacji, rozkładanie obciążenia API po różnych IP, śledzenie zdarzeń na platformach w czasie rzeczywistym, testowanie własnego serwisu z różnych sieci.
Ważne są tu trzy rzeczy. Sam proxy musi przejrzyście przepuszczać odpowiedzi chunked. Biblioteka kliencka musi czytać strumień na bieżąco. I musisz umieć odróżnić problem na proxy od problemu na serwerze docelowym.
Weryfikacja przejrzystości proxy dla strumienia
- Weź endpoint z założenia strumieniowy — publiczną usługę testową oddającą linie z opóźnieniem albo własny endpoint ze znanym rozkładem chunków.
- Wykonaj zapytanie bezpośrednio i przez proxy za pomocą curl z flagą -N (wyłącza buforowanie wyjścia samego curl) i flagą --trace-time dla znaczników czasu. Porównaj momenty przyjścia fragmentów.
- Jeśli przez proxy wszystkie fragmenty przychodzą jednym kawałkiem na końcu — proxy buforuje w całości. Jeśli porcjami po kilka kilobajtów — częściowo. Jeśli pokrywają się z bezpośrednim zapytaniem — jest przejrzyste.
- Sprawdź długi strumień (5-10 minut) z heartbeat. Zerwanie po stałym czasie ujawnia idle timeout proxy.
- Sprawdź HTTPS. Przez proxy z metodą CONNECT tworzony jest tunel i proxy nie rozbiera HTTP w środku — buforowania na poziomie HTTP być nie może, tylko opóźnienia TCP. To jeden z powodów, dlaczego strumieniowe API przez tunel CONNECT zwykle działają równiej niż przez zwykłe HTTP proxy rozbierające zapytania.
Subtelność dotycząca mobilnych proxy: sama sieć komórkowa dodaje jitter, a NAT operatorów agresywnie zamyka nieaktywne połączenia. Dla długich strumieni przez mobilne proxy heartbeat raz na 15-20 sekund to konieczność. Rotacja IP według harmonogramu musi uwzględniać otwarte strumienie: zmiana adresu w środku połączenia SSE gwarantowanie je zrywa. Zsynchronizuj rotację z cyklem życia strumieni — zamknąłeś strumień, zmieniłeś adres, otworzyłeś nowy z kursorem.
Biblioteki klienckie: co włączyć
- Python, requests: stream=True w wywołaniu, następnie iter_lines lub iter_content z małym chunk_size. Timeout ustawiaj krotką (connect, read), gdzie read to dopuszczalny czas między chunkami, a nie całkowity czas odpowiedzi.
- Python, httpx: client.stream i aiter_lines dla kodu asynchronicznego; dla SSE — wyspecjalizowane wrappery parsujące format zdarzeń.
- Python, aiohttp: response.content.iter_any zwraca dane dokładnie w takiej formie, w jakiej przyszły z socketa, bez przepakowywania — idealne do mierzenia rzeczywistych odstępów.
- Node.js: fetch z czytaniem response.body jako ReadableStream; dla SSE — biblioteki parsujące format.
- Go: zwykły http.Client, czytanie resp.Body przez bufio.Scanner z wystarczającym rozmiarem bufora na duże zdarzenia.
We wszystkich przypadkach: nie wywołuj metod czytających ciało w całości — text, json, read bez argumentów. Inaczej klient będzie czekał na zamknięcie połączenia i obwinisz proxy o buforowanie, którego nie ma.
Protokół diagnostyczny „trzech punktów”
Gdy strumień zachowuje się dziwnie, zmierz czas do pierwszego bajtu i rozkład odstępów między chunkami w trzech konfiguracjach: bezpośrednio do serwera z tej samej maszyny; przez proxy do serwera; przez proxy do referencyjnego endpointu strumieniowego. Porównanie jednoznacznie lokalizuje problem. Przez proxy do referencji dobrze, a do serwera docelowego źle — winna jest infrastruktura serwera docelowego. Do referencji źle — winne jest proxy. Bezpośrednio też źle — winien jest twój kod lub sieć. Ten protokół zajmuje dziesięć minut i oszczędza dni dyskusji.
Typowe błędy przy pracy ze strumieniami przez proxy
- Wyłączyli proxy_buffering, zapomnieli o gzip. Najczęstszy błąd. Strumień formalnie nie jest buforowany, ale kompresja gromadzi dane do rozmiaru okna. Objaw: szarpnięcia po kilka kilobajtów.
- Zostawili proxy_http_version 1.0. nginx domyślnie łączy się z backendem po HTTP/1.0, gdzie chunked nie istnieje, i musi doczekać zamknięcia połączenia. Objaw: cała odpowiedź przychodzi na końcu.
- Nie wysyłają heartbeat. Strumień żyje dokładnie do pierwszego idle timeoutu w łańcuchu — 60 sekund w nginx, 15 w Envoy na trasie, kilka minut w NAT. Objaw: zerwania w równych odstępach.
- Timeout long-pollingu większy niż timeout proxy. Klient dostaje 504 zamiast pustej odpowiedzi, monitoring świeci na czerwono, a zdarzenia mogą się dublować.
- Polegają na globalnym ustawieniu proxy. Przy przeprowadzce do nowego środowiska lub zmianie CDN strumieniowanie po cichu się psuje. Rozwiązanie — X-Accel-Buffering i no-transform na poziomie odpowiedzi: zachowanie dyktuje aplikacja, a nie administrator proxy.
- Brak Last-Event-ID i kursorów. Każde zerwanie — utrata danych. Przez proxy zerwania zdarzają się zauważalnie częściej niż bezpośrednio.
- Czytają ciało w całości po stronie klienta. stream=True zapomniane, klient czeka na zakończenie, programista wini proxy.
- Rotacja IP w trakcie otwartego strumienia. Połączenie się zrywa, ponownego połączenia nie ma, dane giną.
- Testują na krótkich odpowiedziach. Bufor nie zdąży się zapełnić, wszystko wygląda świetnie. Na produkcji przy długich odpowiedziach włącza się zapis do pliku tymczasowego i opóźnienia wystrzeliwują.
- Mieszają trasy strumieniowe i zwykłe w jednym location. Albo psują strumieniowanie, albo tracą kompresję i buforowanie dla zwykłych odpowiedzi, co uderza w wydajność całego API.
- Ignorują zerwanie połączenia przez klienta. Przez proxy serwer dowiaduje się o zerwaniu późno i kontynuuje kosztowną generację. Dla inferencji LLM to proste pieniądze.
- Używają chunked tam, gdzie potrzebny jest long-polling. Przez firmową bramę lub bramę API w chmurze z limitem odpowiedzi strumień nie przejdzie, a long-polling przejdzie bez pytań.
Narzędzia i zasoby do konfiguracji i diagnostyki
Reverse proxy i load balancery
- nginx — wzorzec elastyczności. Kluczowe dyrektywy: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, obsługa nagłówka X-Accel-Buffering.
- HAProxy — minimalne buforowanie od razu. Pilnuj timeout server, timeout tunnel i kompresji.
- Envoy — strumieniuje domyślnie. Krytyczne są route timeout i stream_idle_timeout.
- Caddy — nie buforuje domyślnie; flush_interval z wartością -1 ustawia natychmiastowy flush jawnie.
- Traefik — przekazuje strumienie przejrzyście; timeouty konfiguruje się na poziomie entrypoints.
Diagnostyka
- curl z flagami -N, -v i --trace-time pokazuje momenty przyjścia każdego fragmentu. Parametr -w ze zmiennymi time_starttransfer i time_total daje czas pierwszego bajtu i całkowity czas.
- tcpdump i Wireshark — sprawdzić, czy bajty idą z opóźnieniem na poziomie sieci, czy są opóźniane wyżej.
- mitmproxy — podgląd strumieni z zachowaniem struktury chunków. Koniecznie włącz tryb strumieniowania, inaczej sam stanie się punktem buforowania.
- Narzędzia deweloperskie przeglądarki — zakładka EventStream dla SSE pokazuje każde zdarzenie ze znacznikiem czasu.
Endpointy testowe i biblioteki
Publiczne usługi do testowania HTTP mają endpointy oddające zadaną liczbę linii z opóźnieniem — są idealne do sprawdzania przejrzystości proxy. Własny minimalny serwer w dowolnym języku, oddający chunk raz na sekundę ze znacznikiem czasu, jest jeszcze lepszy: kontrolujesz obie strony. Dla SSE na serwerze praktycznie każdy framework asynchroniczny ma gotową klasę odpowiedzi dla text/event-stream. Dla SSE na kliencie poza przeglądarką istnieją parsery formatu dla Python, Node.js i Go. Dla long-pollingu specjalne biblioteki nie są potrzebne — wystarczy klient HTTP z pulą połączeń.
Monitoring
Metryki, które warto zbierać: czas do pierwszego bajtu ciała; rozkład odstępów między chunkami po percentylach 50, 95 i 99; czas życia strumieni i przyczyna zamknięcia; liczba aktywnych strumieni na proxy i na backendzie; udział ponownych połączeń z Last-Event-ID. Gwałtowny wzrost odstępu między chunkami przy jednoczesnym wzroście objętości — pewny sygnał włączonego buforowania.
Przypadki i wyniki: jak to wygląda w rzeczywistych projektach
Przypadek 1. Strumieniowanie LLM przez nginx: z 11 sekund do 310 milisekund
Zespół wdrożył czat oparty na modelu językowym. Lokalnie tokeny pojawiały się płynnie. Po wypuszczeniu za nginx użytkownicy widzieli pusty ekran przez 8-12 sekund, potem całą odpowiedź naraz. Diagnostyka protokołem „trzech punktów” pokazała: bezpośrednio do aplikacji pierwszy token przychodził po 280 milisekundach, przez nginx — po 11 sekundach. Przyczyny klasyczne: proxy_buffering on i proxy_http_version 1.0 domyślnie. Po dodaniu proxy_buffering off, proxy_http_version 1.1, gzip off dla trasy i nagłówka X-Accel-Buffering: no w odpowiedzi aplikacji czas do pierwszego tokenu przez proxy wyniósł 310 milisekund. Efekt uboczny: przy zamknięciu karty inferencja trwała do końca odpowiedzi. Po wdrożeniu heartbeat z wykrywaniem błędu zapisu zużycie czasu GPU na porzucone zapytania spadło o około jedną czwartą.
Przypadek 2. Dashboard na SSE i sieci mobilne
Serwis monitoringu oddawał zdarzenia przez SSE. Na internecie przewodowym wszystko działało, a z urządzeń mobilnych strumienie zrywały się po 2-4 minutach bez błędów na serwerze. Przyczyna — timeouty NAT operatorów na nieaktywnych połączeniach. Rozwiązanie: komentarz heartbeat co 20 sekund plus wymuszone zamknięcie strumienia przez serwer co 10 minut z poprawnym Last-Event-ID. Skargi na „zawieszony dashboard” spadły praktycznie do zera, średni czas trwania nieprzerwanego strumienia wzrósł z 3 do 10 minut (ograniczony już celowym zamknięciem), utraty zdarzeń przy ponownym połączeniu nie odnotowano.
Przypadek 3. Scraping API strumieniowego przez pulę mobilnych proxy
Zespół zbierał zdarzenia z platformy oddającej dane strumieniem NDJSON przez pulę mobilnych proxy. Obserwowano dwa problemy: część strumieni przychodziła szarpnięciami po 8 kilobajtów, część zrywała się przy rotacji adresu. Testy pokazały, że dla niezaszyfrowanych zapytań proxy rozbierało HTTP i buforowało odpowiedzi, a przez tunel CONNECT do endpointu HTTPS przepuszczało strumień przejrzyście. Przejście na HTTPS rozwiązało pierwszy problem całkowicie. Drugi zamknięto synchronizacją: rotacja IP jest wykonywana tylko po poprawnym zamknięciu strumienia, a ponowne połączenie idzie z kursorem ostatniego zdarzenia. Kompletność zbieranych danych wzrosła z około 91 do 99,7 procent.
Przypadek 4. Bot na long-pollingu przez ograniczoną bramę
Programista trzymał bota na infrastrukturze, gdzie zapytania wychodzące szły przez firmową bramę z limitem odpowiedzi 30 sekund. Początkowo używano timeoutu oczekiwania 60 sekund — połowa zapytań kończyła się błędem bramy, aktualizacje się dublowały. Po obniżeniu timeoutu do 25 sekund i dodaniu wykładniczego jittera przy błędach udział błędów spadł z 48 do mniej niż 0,5 procent. Średnie opóźnienie dostarczenia zdarzenia się nie zmieniło — decyduje o nim moment zdarzenia, a nie długość oczekiwania.
Przypadek 5. Przejście na HTTP/2 dla SSE
Aplikacja webowa otwierała 3-4 strumienie SSE na kartę. Przy kilku otwartych kartach przeglądarka wyczerpywała limit sześciu połączeń i zwykłe zapytania stały w kolejce za strumieniami. Włączenie HTTP/2 na froncie proxy przeniosło wszystkie strumienie do jednego połączenia. Czas ładowania strony przy pięciu otwartych kartach spadł z 9 do 1,5 sekundy. Efekt uboczny: po przejściu trzeba było zwiększyć stream_idle_timeout, bo wcześniejsze ustawienia były obliczone na HTTP/1.1.
FAQ: głębokie pytania o odpowiedzi strumieniowe przez proxy
Czym zasadniczo różni się strumieniowy HTTP od WebSocket z punktu widzenia proxy?
WebSocket wymaga upgrade'u protokołu: proxy musi rozpoznać nagłówki Upgrade i Connection, przełączyć się w tryb tunelu i przestać rozbierać HTTP. Strumieniowy HTTP niczego nie wymaga — to zwykła odpowiedź, która długo się nie kończy. Paradoks w tym, że WebSocket przez proxy albo działa, albo nie działa wcale, a strumieniowy HTTP zawsze „działa”, ale może działać źle: dane docierają, ale z opóźnieniem. Dlatego problemy ze strumieniami trudniej zauważyć i zdiagnozować.
Dlaczego X-Accel-Buffering: no nie zawsze pomaga?
Nagłówek rozumie nginx i kompatybilne z nim proxy. CDN, brama chmurowa lub proxy innego typu go zignorują. Poza tym X-Accel-Buffering nie wpływa na gzip — kompresję trzeba wyłączyć osobno. I jeśli między aplikacją a nginx stoi warstwa usuwająca niestandardowe nagłówki, do nginx nie dotrze.
Czy można kompresować odpowiedź strumieniową?
Technicznie tak: gzip obsługuje synchroniczny flush i serwer może kompresować każdy chunk z natychmiastowym oddaniem. Stopień kompresji przy tym spada, bo słownik nie zdąży się zapełnić. W praktyce dla SSE i tokenów LLM kompresję się wyłącza: oszczędność ruchu kilku procent nie usprawiedliwia ryzyka opóźnień. Dla strumieni dużych obiektów JSON kompresja z flushem może dać odczuwalny zysk.
Jak wybrać między SSE a long-pollingiem?
Jeśli klientem jest przeglądarka, zdarzenia idą częściej niż raz na kilka sekund i kontrolujesz przynajmniej reverse proxy — SSE. Jeśli w łańcuchu są niekontrolowane węzły z limitami czasu odpowiedzi, zdarzenia są rzadkie lub potrzebna jest maksymalna kompatybilność — long-polling. Dojrzałe systemy implementują oba warianty i przełączają się automatycznie po wyniku pierwszego połączenia.
Czy HTTP/3 wpływa na problem buforowania?
HTTP/3 działa na QUIC i znosi blokowanie kolejki na poziomie transportu, ale buforowanie leży wyżej — w logice proxy. Proxy z HTTP/3 na wejściu i HTTP/1.1 na wyjściu buforuje dokładnie tak samo. Co naprawdę się zmienia — zachowanie w sieciach mobilnych: QUIC lepiej znosi zmianę sieci i straty, więc strumienie przez HTTP/3 rzadziej zrywają się po stronie klienta.
Jak poznać, że buforuje właśnie proxy wychodzące, a nie serwer docelowy?
Metoda „trzech punktów”: to samo zapytanie bezpośrednio, przez proxy i przez proxy do referencyjnego endpointu strumieniowego. Dodatkowo spróbuj HTTPS przez CONNECT — jeśli strumień się wyrównał, proxy rozbierało i buforowało niezaszyfrowany HTTP.
Jaki interwał heartbeat wybrać?
Mniejszy niż najkrótszy timeout w łańcuchu z dwukrotnym zapasem. Dla typowej infrastruktury — 15-25 sekund, dla sieci mobilnych bliżej 15. Zbyt częsty heartbeat — zbędny ruch i obciążenie tysięcy połączeń, zbyt rzadki — zerwania.
Co zrobić, jeśli strumień musi żyć godzinami?
Nie robić tego. Projektuj wymuszone zamknięcie przez serwer co 5-15 minut z kursorem do wznowienia. To chroni przed nagromadzeniem pamięci, wyciekami i niewidocznymi timeoutami, a także upraszcza deployment: restartujesz serwery, nie myśląc o godzinnych połączeniach.
Jak proxy wpływa na wykrywanie odłączenia klienta?
Między klientem a serwerem są teraz dwa połączenia. Gdy klient się odłącza, proxy dowiaduje się o tym natychmiast, a serwerowi komunikuje przy następnej próbie zapisu lub według własnych reguł. Serwer zauważy zerwanie tylko przy zapisie. Stąd praktyka regularnych zapisów heartbeat dla wczesnego wykrywania zerwania i zatrzymania kosztownych operacji.
Czy potrzebna jest specjalna konfiguracja mobilnego proxy dla strumieni?
Ze strony użytkownika samo proxy zwykle nie jest konfigurowane. Ale trzeba: preferować HTTPS dla przejrzystego tunelu; zsynchronizować rotację IP z cyklem życia strumieni; trzymać heartbeat nie rzadziej niż 15-20 sekund; używać keep-alive i puli połączeń; sprawdzać każdą pulę na przejrzystość przed uruchomieniem produkcyjnym.
Podsumowanie: rezultaty i kolejne kroki
Strumieniowy HTTP to nie egzotyka i nie osobny protokół. To zwykła odpowiedź, która nie spieszy się z zamknięciem. Właśnie dlatego jest tak wrażliwa na węzły pośrednie: proxy nie widzi niczego szczególnego i stosuje reguły wymyślone dla krótkich odpowiedzi. Buforowanie opóźnia dane, timeouty zrywają połączenie, kompresja maskuje buforowanie — i wszystko to w ośmiu różnych punktach łańcucha.
Trzy mechanizmy — chunked, SSE i long-polling — rozwiązują jedno zadanie z różnym stopniem zależności od przejrzystości proxy. Chunked daje maksymalną kontrolę kosztem samodzielnej obsługi po stronie klienta. SSE daje gotowy model zdarzeń i ponowne połączenie w przeglądarce, ale wymaga uwagi na każdym węźle. Long-polling przechodzi przez wszystko, ale płaci za to narzutem na częste zapytania. Wybór określają cztery pytania: czy kontrolujesz łańcuch, kto jest klientem, jaka jest natura danych i jaka jest ich częstotliwość.
Co zrobić już dziś:
- Przejdź po mapie ośmiu punktów buforowania dla swojej infrastruktury i zaznacz, które kontrolujesz.
- Dodaj do odpowiedzi tras strumieniowych X-Accel-Buffering: no i Cache-Control: no-cache, no-transform — niezależnie od obecnej konfiguracji proxy.
- Sprawdź proxy_http_version, proxy_buffering, gzip i proxy_read_timeout w nginx lub ich odpowiedniki w twoim proxy. Wydziel trasy strumieniowe do osobnych bloków.
- Wdróż heartbeat nie rzadziej niż raz na 25 sekund i wymuszone zamknięcie strumienia co 5-15 minut z kursorem.
- Jeśli konsumujesz cudze strumienie przez proxy — przepuść protokół „trzech punktów” na każdej puli adresów i przenieś zapytania strumieniowe na HTTPS.
- Skonfiguruj monitoring czasu pierwszego bajtu i odstępów między chunkami. To jedyny sposób, by dowiedzieć się o buforowaniu wcześniej niż użytkownicy.
Proxy nie jest wrogiem strumienia. Prawidłowo skonfigurowane proxy dodaje do strumienia odporność na awarie, rozkładanie obciążenia i ochronę backendu. Chodzi tylko o to, by wytłumaczyć mu: ta odpowiedź jest wyjątkowa, trzeba ją przekazywać tak, jak przychodzi. Teraz masz wszystko, by to wyjaśnienie zabrzmiało w jego języku.