Einleitung: Warum Streaming-HTTP über Proxys zum Massenproblem geworden ist

Stellen Sie sich vor: Sie senden eine Anfrage an ein Sprachmodell, und statt des gewohnten „Tippens“ der Tokens bleibt der Bildschirm vierzig Sekunden lang stumm – und spuckt dann die gesamte Antwort auf einmal aus. Oder ein Monitoring-Dashboard, das sich jede Sekunde aktualisieren soll, zeigt Daten mit einer halben Minute Verzögerung. Oder ein Parser, der den Event-Stream einer Handelsplattform abhört, bekommt Hundert-Pakete statt eines gleichmäßigen Rinnsals. In neun von zehn Fällen ist weder der Server noch der Client schuld. Schuld ist derjenige dazwischen: ein Proxy, ein Load Balancer, ein CDN oder ein Unternehmens-Gateway, das „helfen“ wollte und die Antwort erst komplett angesammelt hat, bevor es sie weitergibt.

Das Thema Streaming-HTTP-Antworten über Zwischenknoten galt lange als Nische. 2026 ist es massentauglich geworden. Token-Streaming aus LLM-APIs, Server-Events in Web-Oberflächen, Long-Polling in Messengern und Bots, Fortschrittsbalken bei langen Exporten, Streaming-Ausgabe von Parser-Ergebnissen – all das läuft über ganz normales HTTP, das einfach nicht eilig damit ist, die Antwort zu schließen. Und all das bricht zusammen, sobald ein Knoten mit aktivierter Pufferung im Weg steht.

In diesem Leitfaden betrachten wir drei klassische Mechanismen – Chunked Transfer Encoding, Server-Sent Events und Long-Polling – speziell aus der Perspektive der Proxy-Passage. Eine wichtige Einschränkung gleich vorweg: WebSocket und gRPC kommen hier nicht vor. Ihnen ist ein eigener Artikel gewidmet, und der Unterschied ist grundlegend. Dort findet ein Protokoll-Upgrade statt oder es wird binäres Framing über HTTP/2 verwendet, und der Proxy muss dieses Upgrade erkennen und durchlassen. Hier dagegen handelt es sich um eine normale HTTP-Antwort ohne Content-Length-Header, die der Server offen hält. Kein Handshake, kein Übergang zu einem anderen Protokoll. Eigentlich könnte es nicht einfacher sein. Aber genau diese Einfachheit schafft das Problem: Der Proxy sieht nichts Besonderes und wendet Standard-Pufferungsregeln an, die auf kurze Antworten ausgelegt sind.

Was Sie aus diesem Material mitnehmen: ein Verständnis dafür, wie der Stream auf Byte- und Header-Ebene funktioniert; eine Karte aller Stellen, an denen die Antwort hängen bleiben kann; fertige Konfigurationen für nginx, HAProxy, Envoy und Client-Bibliotheken; ein Entscheidungsraster zwischen den drei Mechanismen; Diagnose-Checklisten; Analysen realer Fälle mit Zahlen. Das Material richtet sich an Entwickler, DevOps-Ingenieure und alle, die Proxys für die Arbeit mit APIs, Parsing und Automatisierung einsetzen.

Grundlagen: Wie eine normale HTTP-Antwort zum Stream wird

Zwei Möglichkeiten, die Antwortlänge mitzuteilen

In HTTP/1.1 gibt es zwei grundlegende Möglichkeiten, dem Client mitzuteilen, wo der Antwortkörper endet. Die erste ist der Header Content-Length: Der Server kündigt im Voraus die genaue Byte-Anzahl an. Die zweite ist Transfer-Encoding: chunked: Der Server sendet den Körper in Portionen, jede Portion beginnt mit ihrer Größe in hexadezimaler Form, und alles endet mit einem Null-Chunk. Es gibt noch eine dritte, archaische Variante – einfach die Verbindung nach dem letzten Byte schließen –, aber mit keep-alive wird sie praktisch nicht mehr verwendet.

Warum ist das für Streaming wichtig? Weil Content-Length erfordert, die Größe im Voraus zu kennen. Wenn der Server die Antwort schrittweise generiert – Token für Token, Event für Event –, kann er die Länge vor Beginn der Übertragung physisch nicht berechnen. Die einzige Option in HTTP/1.1 ist chunked. In HTTP/2 und HTTP/3 gibt es die Chunked-Kodierung als solche nicht: Dort wird der Körper ohnehin in DATA-Frames übertragen, und das Ende wird durch das END_STREAM-Flag markiert. Die Logik bleibt jedoch dieselbe: eine Antwort ohne angekündigte Länge, die beliebig lange dauern kann.

Was bedeutet es, die Antwort „nicht zu schließen“?

Eine Analogie. Eine normale HTTP-Antwort ist wie ein Paket: Sie erhalten eine Kiste, auf der das Gewicht steht, öffnen sie und wissen, dass alles drin ist. Eine Streaming-Antwort ist wie ein Fließband: Die Kisten fahren eine nach der anderen, und Sie wissen nicht, wann das Band anhält. Der Server hat die Header mit Status 200 gesendet, den ersten Chunk gesendet – und wartet. Neue Daten sind da – er sendet den nächsten. Die Verbindung bleibt Minuten, Stunden, manchmal Tage offen.

Auf TCP-Ebene passiert nichts Ungewöhnliches: derselbe Socket, dieselben Segmente. Auf HTTP-Ebene ist es eine einzige Anfrage und eine einzige Antwort – nur eine sehr lange. Und hier liegt die Wurzel aller Proxy-Probleme: Der Zwischenknoten sieht den Anfang der Antwort, sieht kein Ende und muss entscheiden, was mit den Bytes zu tun ist, die bereits angekommen sind. Sofort weiterleiten? Oder warten, mehr ansammeln und effizienter senden? Standardmäßig wählen die meisten Proxys die zweite Option.

Drei Mechanismen: Gemeinsamkeiten und Unterschiede

  • Chunked Streaming – der niedrigste Level. Der Server schreibt einfach Bytes in den Körper und ruft flush auf. Das Inhaltsformat ist beliebig: Text, NDJSON, Binärdaten. Der Client entscheidet selbst, wie er parst.
  • Server-Sent Events – ein standardisiertes Textformat über einem Chunked-Stream. Content-Type: text/event-stream, Events sind durch Leerzeilen getrennt, es gibt die Felder data, event, id, retry. Der Browser unterstützt es nativ über EventSource mit automatischer Wiederverbindung.
  • Long-Polling – streng genommen kein Stream. Der Client stellt eine Anfrage, der Server hält sie offen, bis Daten eintreffen oder ein Timeout erreicht ist, antwortet und schließt. Der Client stellt sofort die nächste Anfrage. Das simuliert einen Stream durch eine Abfolge normaler Antworten, von denen jede Content-Length haben kann.

Was haben sie gemeinsam? In allen drei Fällen verzögert sich die Antwort auf eine Anfrage unbestimmt lange, und der Proxy muss das überstehen: die Verbindung nicht wegen eines Timeouts abbrechen und die Daten nicht im Puffer zurückhalten. Der Unterschied liegt darin, wie stark jeder Mechanismus von der Transparenz des Zwischenknotens abhängt. Chunked und SSE hängen kritisch davon ab. Long-Polling nur minimal – das ist sein größter Vorteil.

Die Rolle des Proxys in der Kette

Zwischen Client und Server ist in moderner Infrastruktur selten leer. Eine typische Kette: Client-Anwendung – ausgehender Proxy (z. B. ein mobiler oder residenzieller) – Internet – CDN – Cloud-Loadbalancer – Reverse-Proxy – Anwendung. Jeder dieser Knoten ist ein potenzieller Pufferungspunkt. Und jeder ist standardmäßig darauf ausgelegt, kurze Antworten zu optimieren: sammeln, komprimieren, komplett ausliefern. Für Streaming ist diese Optimierung eine Katastrophe. Wir werden diese Schichten nacheinander abtragen und sehen, was auf jeder passiert.

Tiefenanalyse: Wo und warum der Stream am Zwischenknoten hängen bleibt

Warum Proxys überhaupt puffern

Bevor wir die Pufferung verdammen, sollte man ihre Logik verstehen. Ein Reverse-Proxy wie nginx puffert aus drei Gründen. Erstens – Schutz des Backends vor langsamen Clients: Wenn ein Client im Mobilfunknetz mit zehn Kilobyte pro Sekunde liest und das Backend die Antwort bereits generiert hat, ist es effizienter, alles sofort vom Backend zu holen, dessen Worker freizugeben und dann in Ruhe aus dem Puffer an den Client auszuliefern. Zweitens – Kompression: gzip und brotli arbeiten effizienter mit großen Blöcken. Drittens – die Möglichkeit, Content-Length zu setzen und einen Backend-Fehler korrekt zu behandeln, bevor Header an den Client gesendet werden.

Für eine typische API mit Antworten von einigen Kilobyte ist all das sinnvoll und spart Ressourcen. Für Streaming ist es genau umgekehrt: Indem der Proxy Bytes zurückhält, zerstört er den eigentlichen Wert des Streams. Dieser Wert liegt in der Aktualität, nicht im Volumen.

Karte der acht Pufferungspunkte

Gehen wir die Kette durch und markieren jeden Punkt, an dem Daten hängen bleiben können. Halten Sie diese Liste bei der Diagnose griffbereit.

  1. Anwendung. Das Framework kann die Ausgabe selbst puffern. WSGI-Server, PHP mit aktiviertem output_buffering, Node.js-Frameworks mit Compression-Middleware. Flush wird nicht aufgerufen – die Daten liegen im Prozesspuffer.
  2. Reverse-Proxy vor der Anwendung. nginx mit proxy_buffering on (standardmäßig aktiv) sammelt die Antwort in Puffern, die durch proxy_buffer_size und proxy_buffers festgelegt sind, und bei Überlauf in eine temporäre Datei auf der Festplatte. Apache mod_proxy puffert weniger, hat aber eigene Einstellungen. Caddy puffert standardmäßig nicht, aber flush_interval sollte man prüfen.
  3. Komprimierung am Proxy. Selbst bei proxy_buffering off sammelt ein aktiviertes gzip Daten bis zur Größe des Komprimierungsfensters. Das ist einer der heimtückischsten Punkte: Die Pufferung ist formal deaktiviert, aber der Stream stockt.
  4. L7-Loadbalancer. HAProxy im http-Modus leitet Daten weiter, sobald sie eintreffen, wenn nicht http-buffer-request aktiviert ist, ist aber durch tune.bufsize begrenzt. Envoy streamt standardmäßig, aber Kompressions- oder Lua-Filter können den Körper ansammeln.
  5. CDNs und Cloud-Gateways. Viele CDNs puffern Antworten für Caching und Komprimierung. Einige Anbieter unterstützen keine Streams, die länger als eine bestimmte Zeit dauern, oder erfordern explizite Einstellungen. Cloud-API-Gateways haben oft ein hartes Zeitlimit für Antworten von etwa 30 Sekunden und unterstützen Body-Streaming überhaupt nicht.
  6. Ausgehender Proxy auf Client-Seite. Auch der HTTP-Proxy, über den Sie ins Internet gehen – Firmen-, Mobilfunk-, Residenz-Proxy –, ist ein HTTP-Parser. Wenn er auf nginx oder Squid basiert und auf Pufferung eingestellt ist, bleibt der Stream dort hängen. Hochwertige Proxy-Dienste leiten Chunked-Antworten transparent weiter, aber das muss man in der Praxis überprüfen.
  7. TLS und TCP. Daten können in TLS-Records verzögert werden, wenn die Bibliothek sie bis zur Größe von 16 Kilobyte sammelt. Der Nagle-Algorithmus hält kleine TCP-Segmente zurück, bis das vorherige bestätigt ist. Für einen Stream aus kleinen Chunks bedeutet das Dutzende Millisekunden Verzögerung pro Chunk.
  8. Client-Bibliothek. requests in Python liest den gesamten Body in den Speicher, wenn nicht stream=True übergeben wird. Manche HTTP-Clients puffern bis zur Größe von chunk_size.

Acht Punkte. Wenn auch nur einer davon Daten ansammelt, sehen Sie den Stream als Ruckler oder als einen großen Block am Ende. Und das Unangenehmste: Das Verhalten hängt vom Volumen ab. Bei kleinen Antworten sieht alles normal aus, aber unter Last oder bei langen Antworten füllt sich der Puffer, das Schreiben in temporäre Dateien setzt ein, und die Latenz steigt sprunghaft an. Kein Wunder, dass viele Teams das Problem erst in der Produktion entdecken.

HTTP/1.1 versus HTTP/2 im Streaming-Kontext

In HTTP/1.1 gilt: eine Verbindung – eine Antwort gleichzeitig. Eine langlebige Antwort belegt die Verbindung vollständig. Browser begrenzen die Anzahl gleichzeitiger Verbindungen zu einem Host auf sechs, daher blockieren sechs offene SSE-Streams alle anderen Anfragen an diesen Host. Auch ein Proxy, der mit dem Backend über HTTP/1.1 spricht, hält pro Stream eine Verbindung.

In HTTP/2 hebt Multiplexing diese Einschränkung auf: Hunderte Streams leben in einer TCP-Verbindung. Aber es gibt eine Feinheit – die Flusskontrolle auf Protokollebene. Wenn der Empfänger das Fenster nicht per WINDOW_UPDATE erweitert, stoppt der Sender. Manche Proxys implementieren die Weiterleitung dieser Frames ungenau und erzeugen künstliche Pausen.

Wichtig zu verstehen: Der Proxy kann eine Anfrage per HTTP/2 vom Client annehmen und per HTTP/1.1 zum Backend gehen. Er packt DATA-Frames in Chunks um und zurück. Das ist eine normale Operation, aber genau an der Konvertierungsgrenze geht oft der rechtzeitige Flush verloren – der Proxy wartet, bis sich eine „bequeme“ Framegröße angesammelt hat.

Timeouts – der zweite Killer von Streams

Pufferung verzögert Daten. Timeouts brechen die Verbindung ab. nginx hat proxy_read_timeout – die maximale Zeit zwischen zwei aufeinanderfolgenden Leseoperationen vom Backend, standardmäßig 60 Sekunden. Wenn der Server länger als eine Minute schweigt, schließt nginx die Verbindung und liefert dem Client ein 504. Für Long-Polling mit 90 Sekunden Wartezeit ist das ein garantierter Fehlschlag. HAProxy hat timeout server und timeout tunnel. Cloud-Loadbalancer haben Idle-Timeouts, oft 60 oder 350 Sekunden. Mobilfunkbetreiber haben NAT-Timeouts, die inaktive Verbindungen nach einigen Minuten zurücksetzen.

Daher die eiserne Regel: Ein Stream ohne periodische Aktivität ist verloren. Heartbeat-Nachrichten alle 15–30 Sekunden sind keine Option, sondern eine zwingende Voraussetzung für jede langlebige Antwort.

Entscheidungsmatrix für den Mechanismus

Bevor wir zur Praxis übergehen, legen wir das Auswahlraster fest. Beantworten Sie vier Fragen.

  • Kontrollieren Sie die gesamte Proxy-Kette? Ja – Chunked und SSE eignen sich. Nein, es gibt unbekannte Gateways in der Kette – beginnen Sie mit Long-Polling oder sehen Sie eine Degradierung dorthin vor.
  • Wer ist der Client? Browser – SSE mit EventSource bietet Wiederverbindung kostenlos. Eigener Code – Chunked mit NDJSON ist flexibler.
  • Wie ist die Natur der Daten? Fragmente einer Entität (Tokens einer Antwort) – Chunked oder SSE. Diskrete, unabhängige Events – SSE oder Long-Polling.
  • Wie hoch ist die Frequenz? Dutzende Events pro Sekunde – Chunked oder SSE mit Batching. Ein Event pro Minute – Long-Polling mit großem Timeout oder SSE mit Heartbeat.

Methode 1: Chunked Transfer Encoding – Low-Level-Stream ohne Drumherum

Wann reines Chunked die richtige Wahl ist

Reines Chunked-Streaming ist sinnvoll, wenn der Client Ihr eigener Code ist und kein Browser; wenn das Datenformat nicht textuell ist oder nicht ins Event-Modell passt; wenn maximale Kontrolle über jedes Byte nötig ist. Typische Beispiele: Streaming von NDJSON aus einer API, Streaming-Ausgabe von Parser-Ergebnissen, Herunterladen großer Exporte mit Fortschrittsanzeige, Weiterleiten von LLM-Antworten in eigenem Format.

Schritt-für-Schritt-Einrichtung der Serverseite

  1. Stellen Sie sicher, dass die Anwendung in Teilen schreibt. Rufen Sie nach jeder logischen Portion flush auf. In Python mit einem ASGI-Server ist das ein Generator, der Bytes liefert; in Node.js res.write mit anschließendem flush, wenn Komprimierung im Spiel ist; in Go das Interface http.Flusher nach jedem Write.
  2. Setzen Sie kein Content-Length. Die meisten Frameworks wechseln selbst zu Chunked, wenn die Länge nicht angegeben ist. Prüfen Sie, dass in der Antwort bei HTTP/1.1 Transfer-Encoding: chunked vorhanden ist.
  3. Deaktivieren Sie die Komprimierung auf Anwendungsebene für Streaming-Routen oder stellen Sie sicher, dass sie zusammen mit den Daten flusht. Ein Kompromiss ist gzip mit synchronem Flush nach jedem Chunk; das funktioniert, reduziert aber die Komprimierungsrate.
  4. Setzen Sie den Header X-Accel-Buffering: no. Das ist ein nginx-spezifischer Header, der die Pufferung für eine bestimmte Antwort deaktiviert, ohne die globale Konfiguration zu ändern. Auch einige andere Proxys verstehen ihn. Fügen Sie außerdem Cache-Control: no-cache, no-transform hinzu – der zweite Wert bittet Zwischenknoten, den Body nicht zu verändern.
  5. Konfigurieren Sie den Reverse-Proxy. Für nginx im location der Streaming-Route: proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;. Die Direktive proxy_http_version 1.1 ist zwingend: Standardmäßig spricht nginx das Backend über HTTP/1.0 an, wo Chunked nicht existiert, und nginx muss bis zum Verbindungsende puffern.
  6. Trennen Sie die Routen. Wenn Komprimierung für die übrige API nötig ist, aktivieren Sie sie nur in Nicht-Streaming-location-Blöcken.
  7. Prüfen Sie den Nagle-Algorithmus. In nginx ist tcp_nodelay standardmäßig aktiv, aber in der Anwendung kann bei kleinen häufigen Chunks eine explizite Einstellung von TCP_NODELAY am Socket erforderlich sein.

Konfiguration von HAProxy und Envoy

HAProxy. Verwenden Sie im Backend-Abschnitt nicht option http-buffer-request. Stellen Sie sicher, dass timeout server für Ihr Szenario ausreicht, und setzen Sie für wirklich lange Streams timeout tunnel. Deaktivieren Sie die Komprimierung für Streaming-Pfade per ACL oder verlassen Sie sich auf den Header no-transform: HAProxy respektiert Cache-Control: no-transform und komprimiert solche Antworten nicht.

Envoy. Die Pufferung ist standardmäßig deaktiviert, was erfreulich ist. Prüfen Sie aber zwei Timeouts: stream_idle_timeout im HTTP Connection Manager (standardmäßig fünf Minuten) und das Route-Timeout (standardmäßig fünfzehn Sekunden – genau das bricht Streams am häufigsten ab). Setzen Sie für Streaming-Routen das Timeout auf 0s, was kein Limit bedeutet, und verlassen Sie sich auf das Idle-Timeout in Kombination mit Heartbeat.

Checkliste zur Überprüfung des Chunked-Streams

  • Die Antwort enthält Transfer-Encoding: chunked oder verwendet HTTP/2 ohne Content-Length.
  • Der Header X-Accel-Buffering: no ist in der Antwort der Anwendung vorhanden.
  • Content-Encoding fehlt oder die Komprimierung wird zusammen mit den Daten geflusht.
  • Das erste Body-Byte kommt innerhalb einer Sekunde nach den Headern.
  • Die Intervalle zwischen den Chunks beim Client entsprechen den Generierungsintervallen auf dem Server mit einer Abweichung von bis zu 50 Millisekunden.
  • Die Verbindung hält länger als eine Minute ohne Abbruch, wenn ein Heartbeat vorhanden ist.
  • In den Proxy-Logs gibt es keine Einträge über Pufferung in temporäre Dateien.

Methode 2: Server-Sent Events – der Standard für Events vom Server zum Client

Aufbau des Formats

SSE ist eine Konvention, wie Events in einem Textstream angeordnet werden. Die Antwort hat Content-Type: text/event-stream. Jedes Event ist eine Reihe von Zeilen der Form „Feld: Wert“, abgeschlossen durch eine Leerzeile. Felder: data – die Nutzlast (kann wiederholt werden, Zeilen werden mit Zeilenumbruch verbunden); event – der Event-Typname; id – die Kennung zur Wiederaufnahme; retry – die empfohlene Wiederverbindungsverzögerung in Millisekunden. Eine Zeile, die mit einem Doppelpunkt beginnt, ist ein Kommentar – und das ist der ideale Heartbeat: Der Browser ignoriert ihn, aber der Proxy sieht Aktivität auf der Verbindung.

Die Schönheit von SSE liegt in der Asymmetrie. Die Komplexität ist in die Spezifikation und den Browser ausgelagert, und der Server bleibt trivial. Kein Handshake, kein binäres Framing. Nur Text, der fließt. Genau deshalb ist SSE zum De-facto-Standard für das Streaming von Antworten von Sprachmodellen geworden: Die überwiegende Mehrheit der großen LLM-APIs liefert Tokens im Format text/event-stream. Erstaunlich, dass eine Technologie, die vor mehr als fünfzehn Jahren spezifiziert wurde, 2026 eine zweite Blüte erlebt.

Warum SSE besonders empfindlich auf Pufferung reagiert

Ein SSE-Event wiegt zwischen ein paar Dutzend Byte und ein paar Kilobyte. Der nginx-Puffer beträgt standardmäßig 4 oder 8 Kilobyte für den ersten Block und acht Blöcke à 4–8 Kilobyte danach. Das bedeutet, der Proxy sammelt fünfzig bis mehrere hundert Events, bevor er das erste ausliefert. Für einen Chat mit einem Modell sieht das so aus: Der Nutzer wartet fünfzehn Sekunden, dann erscheint der ganze Absatz auf einmal. Die Illusion des Tippens ist zerstört – und genau dafür wurde Streaming doch eingeführt.

Schritt-für-Schritt-Umsetzung von SSE über Proxy

  1. Antwort-Header: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no und für HTTP/1.1 zusätzlich Connection: keep-alive.
  2. Heartbeat. Senden Sie alle 15–25 Sekunden eine Kommentarzeile wie : ping. Das ist weniger als jedes vernünftige Idle-Timeout und hält die NAT-Tabellen der Betreiber aktuell.
  3. Event-IDs. Vergeben Sie jedem Event eine monoton steigende id. Bei der Wiederverbindung sendet der Browser den Header Last-Event-ID, und der Server kann Verpasstes nachliefern. Ohne das bedeutet jeder Abbruch am Proxy Datenverlust.
  4. Das Feld retry. Setzen Sie einen vernünftigen Wert, etwa 3000 Millisekunden, damit Clients bei einem Serverneustart keinen Wiederverbindungssturm auslösen.
  5. nginx-Konfiguration – dieselbe wie für Chunked. Stellen Sie zusätzlich sicher, dass für text/event-stream kein gzip angewendet wird: Wenn gzip_types text/* enthält, fügen Sie einen separaten location mit gzip off hinzu.
  6. Verbindungsplanung. Jeder offene SSE-Stream ist bei HTTP/1.1 eine eigene Verbindung zwischen Proxy und Backend. Für tausend gleichzeitige Clients braucht man tausend Verbindungen. Verwenden Sie HTTP/2 auf Client-Seite und einen asynchronen Server im Backend.
  7. Behandlung von Schließungen. Der Server muss erkennen, wenn der Client die Verbindung trennt, und die Generierung stoppen. Über einen Proxy geschieht das mit Verzögerung: Der Server erfährt vom Abbruch erst beim Schreibversuch. Für teure Operationen wie Modell-Inferenz sind das überflüssige Sekunden GPU-Arbeit. Die Lösung sind regelmäßige Heartbeat-Schreibvorgänge, die bei getrennter Verbindung einen Schreibfehler auslösen.

SSE und HTTP/2: Feinheiten

Über HTTP/2 funktioniert SSE ohne die Sechs-Verbindungen-Begrenzung – das ist der Hauptgrund, HTTP/2 am Frontend-Proxy zu aktivieren. Bei der Übersetzung von HTTP/2 nach HTTP/1.1 zum Backend fügen manche Proxys jedoch eine kleine Verzögerung durch Frame-Aggregation hinzu. Stellen Sie sicher, dass das erste Event sofort rausgeht und nicht auf das Füllen eines Frames wartet. Wenn auch das Backend über HTTP/2 spricht, sind die Verzögerungen minimal, aber prüfen Sie, dass der Proxy WINDOW_UPDATE korrekt weiterleitet und den Stream nicht durch Flusskontrolle ausbremst.

Raster für das Design eines SSE-Streams

  1. Bestimmen Sie Event-Typen und ihre Häufigkeit. Seltene Events erfordern Heartbeat; häufige erfordern Batching mehrerer Einträge in einem Event.
  2. Wählen Sie eine Wiederaufnahmestrategie: einen Ringpuffer der letzten Events auf dem Server für die Behandlung von Last-Event-ID oder eine vollständige Resynchronisierung bei Wiederverbindung.
  3. Legen Sie ein Limit für die Dauer eines Streams fest. Gute Praxis ist, dass der Server den Stream alle 5–10 Minuten selbst schließt, der Client verbindet sich transparent neu. Das schützt vor Zustandsakkumulation und umgeht versteckte Infrastruktur-Timeouts.
  4. Denken Sie an Degradierung: Wenn der Stream nicht durch den Proxy kommt, wechseln Sie automatisch auf Long-Polling.

Methode 3: Long-Polling – der Stream aus einer Abfolge normaler Antworten

Wie es funktioniert und warum es noch relevant ist

Long-Polling ist die älteste der drei Techniken. Der Client sendet eine Anfrage, der Server antwortet nicht sofort, sondern wartet auf ein Event bis zu einem festgelegten Timeout (typischerweise 20–60 Sekunden). Tritt ein Event ein, liefert der Server die Antwort und schließt sie. Passiert nichts, liefert er eine leere Antwort. Der Client sendet sofort die nächste Anfrage. Von außen sieht das wie ein Stream mit minimaler Verzögerung aus, aber jede Antwort ist normal, mit Content-Length, vollständig kompatibel mit jedem Proxy, jedem Cache und jedem Gateway.

Warum ist Long-Polling 2026 noch gesund? Weil es überall durchkommt. Durch Firmen-Gateways, die Chunked blockieren. Durch Cloud-API-Gateways mit Antwortzeitlimit. Durch Proxy-Server mit unvorhersehbarer Pufferung. Das bekannteste Beispiel ist die Update-Methode in der Bot-API eines großen Messengers, bei der ein Parameter timeout die Wartezeit angibt. Die überwiegende Mehrheit der Bots arbeitet seit Jahren genau so, über die verschiedensten Proxys, und ohne Probleme.

Fünf Design-Regeln für Long-Polling über Proxy

  1. Das Server-Timeout ist kleiner als das kürzeste Timeout in der Kette. Wenn der Proxy proxy_read_timeout 60 Sekunden hat, beträgt die serverseitige Wartezeit höchstens 50. Wenn in der Kette ein Cloud-Gateway mit 30 Sekunden steht – höchstens 25. Andernfalls erhält der Client statt einer leeren Antwort ein 504, und eine Fehlerflut bringt das Monitoring zum Durchdrehen.
  2. Cursor oder Offset. Der Client übergibt die Kennung des zuletzt erhaltenen Events. Der Server liefert alles, was danach aufgetreten ist. Das Protokoll wird idempotent: Eine verlorene Antwort führt einfach zur erneuten Auslieferung derselben Events.
  3. Jitter bei der Wiederverbindung nach Fehlern. Exponentielles Wachstum der Verzögerung – 1, 2, 4, 8 Sekunden – plus eine zufällige Zugabe. Ohne Jitter treffen nach einem Ausfall tausend Clients gleichzeitig auf den Server.
  4. Keine Pause nach erfolgreicher Antwort. Die nächste Anfrage geht sofort raus. Jede Pause hier ist verlorene Latenz.
  5. Keep-alive ist Pflicht. Ohne es ist jede Anfrage eine neue TCP-Verbindung und ein neuer TLS-Handshake. Das fügt jedem Zyklus 50 bis 300 Millisekunden hinzu, über einen entfernten Proxy noch mehr.

Schritt-für-Schritt-Umsetzung

  1. Server: Der Endpunkt nimmt offset und timeout entgegen, wartet auf ein Event in einer internen Queue oder per Subscription und antwortet mit einem Array von Events samt neuem offset. Ein leeres Array ist eine normale Antwort, kein Fehler.
  2. Proxy: Standardkonfiguration, aber proxy_read_timeout nicht kleiner als das Server-Timeout plus zehn Sekunden Reserve. Die Pufferung kann aktiviert bleiben – die Antwort ist kurz und vollständig.
  3. Client: Eine Schleife mit Behandlung von drei Ergebnissen – Daten, leere Antwort, Fehler. Ein einheitlicher Verbindungspool, keep-alive, Client-Timeout größer als das Server-Timeout.
  4. Monitoring: Anteil leerer Antworten, durchschnittliche Wartezeit, Häufigkeit von 5xx und Client-Timeouts.

Wann Long-Polling verliert

Bei hoher Event-Frequenz werden die Overhead-Kosten für Header und den Anfrage-Antwort-Zyklus spürbar. Bei Tausenden von Clients muss der Server Tausende wartende Anfragen halten – ohne asynchronen Stack geht das nicht. Und natürlich ist Long-Polling unbequem für das Streaming einer einzigen langen Antwort, bei der eine Sequenz von Fragmenten einer Entität nötig ist. Tokens eines Sprachmodells über Long-Polling – theoretisch möglich, praktisch ungeschickt.

Methode 4: Konsumieren von Streaming-Antworten über einen ausgehenden Proxy

Besonderheiten des Szenarios

Bisher haben wir aus der Perspektive des Serverbetreibers geschaut. Jetzt drehen wir das Bild um: Sie sind der Client, rufen eine fremde Streaming-API über einen Proxy-Server auf, und nur die Client-Seite liegt in Ihrer Hand. Typische Aufgaben: Sammeln von Daten aus Streaming-APIs über einen Adresspool, Arbeit mit LLM-Streaming aus Automatisierungsskripten, Lastverteilung auf APIs über verschiedene IPs, Echtzeit-Verfolgung von Events auf Plattformen, Testen des eigenen Dienstes aus verschiedenen Netzwerken.

Hier sind drei Dinge wichtig. Der Proxy selbst muss Chunked-Antworten transparent weiterleiten. Die Client-Bibliothek muss den Stream beim Eintreffen lesen. Und Sie müssen unterscheiden können, ob das Problem am Proxy oder am Zielserver liegt.

Proxy auf Stream-Transparenz prüfen

  1. Nehmen Sie einen bekanntermaßen streamenden Endpunkt – einen öffentlichen Testdienst, der Zeilen mit Verzögerung liefert, oder Ihren eigenen Endpunkt mit bekanntem Chunk-Zeitplan.
  2. Führen Sie die Anfrage direkt und über den Proxy mit curl und dem Flag -N (deaktiviert die Ausgabepufferung von curl selbst) sowie dem Flag --trace-time für Zeitstempel aus. Vergleichen Sie die Ankunftszeitpunkte der Fragmente.
  3. Wenn über den Proxy alle Fragmente als ein Block am Ende ankommen – der Proxy puffert vollständig. Wenn in Portionen von einigen Kilobyte – teilweise. Wenn sie mit der direkten Anfrage übereinstimmen – transparent.
  4. Testen Sie einen langen Stream (5–10 Minuten) mit Heartbeat. Ein Abbruch nach einer festen Zeit entlarvt ein Idle-Timeout des Proxys.
  5. Prüfen Sie HTTPS. Über einen Proxy mit der CONNECT-Methode entsteht ein Tunnel, und der Proxy parst das HTTP darin nicht – auf HTTP-Ebene kann keine Pufferung stattfinden, nur TCP-Verzögerungen. Das ist einer der Gründe, warum Streaming-APIs über einen CONNECT-Tunnel normalerweise ruhiger laufen als über einen gewöhnlichen HTTP-Proxy, der Anfragen parst.

Eine Feinheit zu mobilen Proxys: Das Mobilfunknetz fügt selbst Jitter hinzu, und die NATs der Betreiber schließen inaktive Verbindungen aggressiv. Für lange Streams über einen mobilen Proxy ist ein Heartbeat alle 15–20 Sekunden Pflicht. Die IP-Rotation nach Zeitplan muss offene Streams berücksichtigen: Ein Adresswechsel mitten in einer SSE-Verbindung bricht sie garantiert ab. Synchronisieren Sie die Rotation mit dem Lebenszyklus der Streams – Stream geschlossen, Adresse gewechselt, neuen Stream mit Cursor geöffnet.

Client-Bibliotheken: Was zu aktivieren ist

  • Python, requests: stream=True im Aufruf, dann iter_lines oder iter_content mit kleinem chunk_size. Setzen Sie das Timeout als Tupel (connect, read), wobei read die zulässige Zeit zwischen Chunks ist, nicht die Gesamtantwortzeit.
  • Python, httpx: client.stream und aiter_lines für asynchronen Code; für SSE spezialisierte Wrapper, die das Event-Format parsen.
  • Python, aiohttp: response.content.iter_any liefert Daten genau so, wie sie aus dem Socket kamen, ohne Umpacken – ideal zur Messung realer Intervalle.
  • Node.js: fetch mit Lesen von response.body als ReadableStream; für SSE Parser-Bibliotheken für das Format.
  • Go: der normale http.Client, Lesen von resp.Body über bufio.Scanner mit ausreichender Puffergröße für große Events.

In allen Fällen: Rufen Sie keine Methoden auf, die den Body komplett lesen – text, json, read ohne Argumente. Sonst wartet der Client auf das Schließen der Verbindung, und Sie beschuldigen den Proxy einer Pufferung, die es nicht gibt.

Diagnoseprotokoll „drei Punkte“

Wenn sich der Stream seltsam verhält, messen Sie die Zeit bis zum ersten Byte und die Verteilung der Intervalle zwischen Chunks in drei Konfigurationen: direkt zum Server von derselben Maschine; über den Proxy zum Server; über den Proxy zu einem Referenz-Streaming-Endpunkt. Der Vergleich lokalisiert das Problem eindeutig. Über den Proxy zum Referenzendpunkt gut, aber zum Zielserver schlecht – die Infrastruktur des Zielservers ist schuld. Zum Referenzendpunkt schlecht – der Proxy ist schuld. Auch direkt schlecht – Ihr Code oder das Netzwerk ist schuld. Dieses Protokoll dauert zehn Minuten und spart Tage voller Diskussionen.

Typische Fehler bei der Arbeit mit Streams über Proxys

  1. proxy_buffering deaktiviert, gzip vergessen. Der häufigste Fehler. Der Stream wird formal nicht gepuffert, aber die Komprimierung sammelt Daten bis zur Fenstergröße. Symptom: Ruckler von einigen Kilobyte.
  2. proxy_http_version 1.0 belassen. nginx spricht das Backend standardmäßig über HTTP/1.0 an, wo Chunked nicht existiert, und muss das Verbindungsende abwarten. Symptom: Die gesamte Antwort kommt am Ende.
  3. Kein Heartbeat gesendet. Der Stream lebt genau bis zum ersten Idle-Timeout in der Kette – 60 Sekunden bei nginx, 15 bei Envoy pro Route, ein paar Minuten bei NAT. Symptom: Abbrüche in gleichmäßigen Intervallen.
  4. Long-Polling-Timeout größer als das Proxy-Timeout. Der Client erhält ein 504 statt einer leeren Antwort, das Monitoring leuchtet rot, und Events können dupliziert werden.
  5. Verlassen auf die globale Proxy-Einstellung. Beim Umzug in eine neue Umgebung oder beim CDN-Wechsel bricht das Streaming still zusammen. Die Lösung ist X-Accel-Buffering und no-transform auf Antwortebene: Das Verhalten gibt die Anwendung vor, nicht der Proxy-Administrator.
  6. Keine Last-Event-ID und Cursor. Jeder Abbruch bedeutet Datenverlust. Über einen Proxy passieren Abbrüche deutlich häufiger als direkt.
  7. Body wird auf Client-Seite komplett gelesen. stream=True vergessen, der Client wartet auf das Ende, der Entwickler beschuldigt den Proxy.
  8. IP-Rotation während eines offenen Streams. Die Verbindung bricht ab, es gibt keine Wiederverbindung, Daten gehen verloren.
  9. Tests mit kurzen Antworten. Der Puffer füllt sich nicht, alles sieht super aus. In der Produktion setzt bei langen Antworten das Schreiben in temporäre Dateien ein, und die Latenz steigt sprunghaft an.
  10. Streaming- und normale Routen im selben location vermischt. Entweder bricht das Streaming, oder man verliert Komprimierung und Pufferung für normale Antworten, was die Leistung der gesamten API beeinträchtigt.
  11. Trennung der Verbindung durch den Client wird ignoriert. Über einen Proxy erfährt der Server spät vom Abbruch und setzt die teure Generierung fort. Für LLM-Inferenz ist das bares Geld.
  12. Chunked dort verwendet, wo Long-Polling nötig wäre. Durch ein Firmen-Gateway oder Cloud-API-Gateway mit Antwortlimit kommt der Stream nicht durch, Long-Polling dagegen ohne Weiteres.

Werkzeuge und Ressourcen für Einrichtung und Diagnose

Reverse-Proxys und Loadbalancer

  • nginx – der Maßstab für Flexibilität. Schlüsseldirektiven: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, Unterstützung für den Header X-Accel-Buffering.
  • HAProxy – minimale Pufferung out of the box. Achten Sie auf timeout server, timeout tunnel und Komprimierung.
  • Envoy – streamt standardmäßig. Kritisch sind Route-Timeout und stream_idle_timeout.
  • Caddy – puffert standardmäßig nicht; flush_interval mit dem Wert -1 erzwingt explizit sofortiges Flushen.
  • Traefik – leitet Streams transparent weiter; Timeouts werden auf Ebene der Entrypoints konfiguriert.

Diagnose

  • curl mit den Flags -N, -v und --trace-time zeigt die Ankunftszeitpunkte jedes Fragments. Der Parameter -w mit den Variablen time_starttransfer und time_total liefert die Zeit bis zum ersten Byte und die Gesamtzeit.
  • tcpdump und Wireshark – prüfen, ob Bytes auf Netzwerkebene verzögert kommen oder weiter oben zurückgehalten werden.
  • mitmproxy – Anzeige von Streams unter Beibehaltung der Chunk-Struktur. Aktivieren Sie unbedingt den Streaming-Modus, sonst wird es selbst zum Pufferungspunkt.
  • Entwicklertools im Browser – der Tab EventStream für SSE zeigt jedes Event mit Zeitstempel.

Test-Endpunkte und Bibliotheken

Öffentliche HTTP-Testdienste haben Endpunkte, die eine bestimmte Anzahl von Zeilen mit Verzögerung liefern – ideal, um die Transparenz eines Proxys zu prüfen. Ein eigener minimaler Server in einer beliebigen Sprache, der jede Sekunde einen Chunk mit Zeitstempel liefert, ist noch besser: Sie kontrollieren beide Seiten. Für SSE auf dem Server hat praktisch jedes asynchrone Framework eine fertige Antwortklasse für text/event-stream. Für SSE auf dem Client außerhalb des Browsers gibt es Format-Parser für Python, Node.js und Go. Für Long-Polling braucht man keine speziellen Bibliotheken – ein HTTP-Client mit Verbindungspool genügt.

Monitoring

Metriken, die man sammeln sollte: Zeit bis zum ersten Body-Byte; Verteilung der Intervalle zwischen Chunks nach Perzentilen 50, 95 und 99; Lebensdauer von Streams und Schließgrund; Anzahl aktiver Streams am Proxy und am Backend; Anteil der Wiederverbindungen mit Last-Event-ID. Ein starker Anstieg des Intervalls zwischen Chunks bei gleichzeitigem Anstieg des Volumens ist ein sicheres Signal für einsetzende Pufferung.

Fälle und Ergebnisse: Wie es in realen Projekten aussieht

Fall 1. LLM-Streaming über nginx: von 11 Sekunden auf 310 Millisekunden

Ein Team führte einen Chat auf Basis eines Sprachmodells ein. Lokal erschienen die Tokens flüssig. Nach dem Rollout hinter nginx sahen die Nutzer 8–12 Sekunden lang einen leeren Bildschirm und dann die gesamte Antwort auf einmal. Die Diagnose nach dem „Drei-Punkte“-Protokoll zeigte: Direkt an die Anwendung kam das erste Token nach 280 Millisekunden, über nginx nach 11 Sekunden. Die Ursachen waren klassisch: proxy_buffering on und proxy_http_version 1.0 per Standard. Nach dem Hinzufügen von proxy_buffering off, proxy_http_version 1.1, gzip off für die Route und dem Header X-Accel-Buffering: no in der Antwort der Anwendung betrug die Zeit bis zum ersten Token über den Proxy 310 Millisekunden. Ein Nebenbefund: Beim Schließen des Tabs lief die Inferenz bis zum Ende der Antwort weiter. Nach der Einführung eines Heartbeats mit Prüfung auf Schreibfehler sank der GPU-Zeitaufwand für abgebrochene Anfragen um etwa ein Viertel.

Fall 2. Dashboard mit SSE und Mobilfunknetze

Ein Monitoring-Dienst lieferte Events über SSE. Im Festnetz funktionierte alles, aber von mobilen Geräten brachen Streams nach 2–4 Minuten ohne Serverfehler ab. Die Ursache waren NAT-Timeouts der Betreiber bei inaktiven Verbindungen. Die Lösung: ein Heartbeat-Kommentar alle 20 Sekunden plus ein serverseitiges erzwungenes Schließen des Streams alle 10 Minuten mit korrekter Last-Event-ID. Die Beschwerden über ein „hängendes Dashboard“ gingen praktisch auf null zurück, die durchschnittliche Dauer eines ununterbrochenen Streams stieg von 3 auf 10 Minuten (begrenzt nun durch absichtliches Schließen), und bei der Wiederverbindung wurden keine Event-Verluste festgestellt.

Fall 3. Parsing einer Streaming-API über einen Pool mobiler Proxys

Ein Team sammelte Events von einer Plattform, die Daten als NDJSON-Stream liefert, über einen Pool mobiler Proxys. Zwei Probleme traten auf: Ein Teil der Streams kam in Acht-Kilobyte-Schüben, ein Teil brach bei der Adressrotation ab. Tests zeigten, dass der Proxy bei unverschlüsselten Anfragen HTTP parste und Antworten puffert, über einen CONNECT-Tunnel zu einem HTTPS-Endpunkt aber den Stream transparent durchließ. Der Wechsel zu HTTPS löste das erste Problem vollständig. Das zweite wurde durch Synchronisierung geschlossen: Die IP-Rotation erfolgt nur nach ordnungsgemäßem Schließen des Streams, und die Wiederverbindung erfolgt mit dem Cursor des letzten Events. Die Vollständigkeit der gesammelten Daten stieg von etwa 91 auf 99,7 Prozent.

Fall 4. Bot mit Long-Polling über ein eingeschränktes Gateway

Ein Entwickler betrieb einen Bot in einer Infrastruktur, in der ausgehende Anfragen über ein Firmen-Gateway mit einem Antwortlimit von 30 Sekunden liefen. Anfangs wurde ein Warte-Timeout von 60 Sekunden verwendet – die Hälfte der Anfragen endete mit einem Gateway-Fehler, Updates wurden dupliziert. Nach der Senkung des Timeouts auf 25 Sekunden und der Hinzufügung von exponentiellem Jitter bei Fehlern sank die Fehlerquote von 48 auf unter 0,5 Prozent. Die durchschnittliche Zustellverzögerung eines Events blieb unverändert – sie wird vom Zeitpunkt des Events bestimmt, nicht von der Wartezeit.

Fall 5. Umstieg auf HTTP/2 für SSE

Eine Web-Anwendung öffnete 3–4 SSE-Streams pro Tab. Bei mehreren geöffneten Tabs erschöpfte der Browser das Limit von sechs Verbindungen, und normale Anfragen stellten sich hinter den Streams in die Warteschlange. Die Aktivierung von HTTP/2 am Frontend-Proxy führte alle Streams in eine Verbindung über. Die Seitenladezeit bei fünf geöffneten Tabs sank von 9 auf 1,5 Sekunden. Ein Nebenbefund: Nach dem Umstieg musste stream_idle_timeout erhöht werden, da die vorherigen Einstellungen auf HTTP/1.1 ausgelegt waren.

FAQ: Tiefgehende Fragen zu Streaming-Antworten über Proxys

Worin unterscheidet sich HTTP-Streaming grundsätzlich von WebSocket aus Proxy-Sicht?

WebSocket erfordert ein Protokoll-Upgrade: Der Proxy muss die Header Upgrade und Connection erkennen, in den Tunnelmodus wechseln und aufhören, HTTP zu parsen. HTTP-Streaming erfordert nichts – es ist eine normale Antwort, die lange nicht endet. Das Paradoxe daran ist, dass WebSocket über einen Proxy entweder funktioniert oder gar nicht – aber HTTP-Streaming „funktioniert“ immer, nur möglicherweise schlecht: Die Daten kommen an, aber mit Verzögerung. Deshalb sind Streaming-Probleme schwerer zu bemerken und zu diagnostizieren.

Warum hilft X-Accel-Buffering: no nicht immer?

Der Header wird von nginx und kompatiblen Proxys verstanden. Ein CDN, ein Cloud-Gateway oder ein Proxy eines anderen Typs ignorieren ihn. Außerdem beeinflusst X-Accel-Buffering nicht gzip – die Komprimierung muss separat deaktiviert werden. Und wenn zwischen Anwendung und nginx eine Schicht steht, die nicht-standardisierte Header entfernt, erreicht er nginx nicht.

Kann man eine Streaming-Antwort komprimieren?

Technisch ja: gzip unterstützt synchrones Flushen, und der Server kann jeden Chunk mit sofortiger Auslieferung komprimieren. Die Komprimierungsrate sinkt dabei, weil das Wörterbuch sich nicht füllen kann. In der Praxis deaktiviert man die Komprimierung für SSE und LLM-Tokens: Eine Traffic-Einsparung von einigen Prozent rechtfertigt das Risiko von Verzögerungen nicht. Für Streams großer JSON-Objekte kann Komprimierung mit Flush einen spürbaren Gewinn bringen.

Wie wählt man zwischen SSE und Long-Polling?

Wenn der Client ein Browser ist, Events häufiger als einmal alle paar Sekunden eintreten und Sie mindestens den Reverse-Proxy kontrollieren – SSE. Wenn in der Kette unkontrollierbare Knoten mit Antwortzeitlimits sind, die Events selten sind oder maximale Kompatibilität nötig ist – Long-Polling. Reife Systeme implementieren beide Varianten und wechseln automatisch je nach Ergebnis der ersten Verbindung.

Beeinflusst HTTP/3 das Pufferungsproblem?

HTTP/3 arbeitet über QUIC und beseitigt Head-of-Line-Blocking auf Transportebene, aber Pufferung liegt höher – in der Proxy-Logik. Ein Proxy mit HTTP/3 am Eingang und HTTP/1.1 am Ausgang puffert genauso. Was sich wirklich ändert, ist das Verhalten in mobilen Netzen: QUIC übersteht Netzwerkwechsel und Verluste besser, daher brechen Streams über HTTP/3 seltener auf Client-Seite ab.

Wie erkennt man, dass der ausgehende Proxy puffert und nicht der Zielserver?

Die „Drei-Punkte“-Methode: dieselbe Anfrage direkt, über den Proxy und über den Proxy zu einem Referenz-Streaming-Endpunkt. Probieren Sie zusätzlich HTTPS über CONNECT – wenn der Stream gleichmäßig wird, hat der Proxy unverschlüsseltes HTTP geparst und gepuffert.

Welches Heartbeat-Intervall sollte man wählen?

Kleiner als das kürzeste Timeout in der Kette mit doppeltem Sicherheitsabstand. Für typische Infrastruktur 15–25 Sekunden, für mobile Netze eher 15. Zu häufiger Heartbeat bedeutet zusätzlichen Traffic und Last bei Tausenden Verbindungen, zu seltener bedeutet Abbrüche.

Was tun, wenn der Stream stundenlang leben soll?

Das nicht tun. Planen Sie ein erzwungenes Schließen durch den Server alle 5–15 Minuten mit Cursor zur Wiederaufnahme. Das schützt vor Speicheransammlung, Lecks und unsichtbaren Timeouts und vereinfacht das Deployment: Sie starten Server neu, ohne an stundenlange Verbindungen zu denken.

Wie beeinflusst der Proxy die Erkennung einer Client-Trennung?

Zwischen Client und Server gibt es nun zwei Verbindungen. Wenn der Client sich trennt, erfährt der Proxy es sofort, teilt es dem Server aber erst beim nächsten Schreibversuch oder nach eigenen Regeln mit. Der Server bemerkt den Abbruch erst beim Schreiben. Daher die Praxis regelmäßiger Heartbeat-Schreibvorgänge zur frühen Erkennung eines Abbruchs und zum Stoppen teurer Operationen.

Braucht man eine besondere Konfiguration mobiler Proxys für Streams?

Von Nutzerseite wird der Proxy selbst normalerweise nicht konfiguriert. Aber man muss: HTTPS für einen transparenten Tunnel bevorzugen; die IP-Rotation mit dem Lebenszyklus der Streams synchronisieren; einen Heartbeat mindestens alle 15–20 Sekunden halten; keep-alive und einen Verbindungspool verwenden; jeden Pool vor dem Produktivstart auf Transparenz prüfen.

Fazit: Zusammenfassung und nächste Schritte

Streaming-HTTP ist keine Exotik und kein separates Protokoll. Es ist eine normale Antwort, die es nicht eilig hat, sich zu schließen. Genau deshalb ist es so anfällig gegenüber Zwischenknoten: Der Proxy sieht nichts Besonderes und wendet Regeln an, die für kurze Antworten erdacht wurden. Pufferung verzögert Daten, Timeouts brechen Verbindungen ab, Komprimierung maskiert Pufferung – und all das an acht verschiedenen Punkten der Kette.

Die drei Mechanismen – Chunked, SSE und Long-Polling – lösen dieselbe Aufgabe mit unterschiedlich starker Abhängigkeit von der Transparenz des Proxys. Chunked gibt maximale Kontrolle um den Preis eigener Client-Behandlung. SSE gibt ein fertiges Event-Modell und Wiederverbindung im Browser, erfordert aber Aufmerksamkeit für jeden Knoten. Long-Polling kommt durch alles durch, bezahlt dies aber mit Overhead durch häufige Anfragen. Die Wahl bestimmt sich durch vier Fragen: Kontrollieren Sie die Kette, wer ist der Client, wie ist die Natur der Daten und wie hoch ist ihre Frequenz.

Was Sie noch heute tun sollten:

  1. Gehen Sie die Karte der acht Pufferungspunkte für Ihre Infrastruktur durch und markieren Sie, welche Sie kontrollieren.
  2. Fügen Sie den Antworten von Streaming-Routen X-Accel-Buffering: no und Cache-Control: no-cache, no-transform hinzu – unabhängig von der aktuellen Proxy-Konfiguration.
  3. Prüfen Sie proxy_http_version, proxy_buffering, gzip und proxy_read_timeout in nginx oder deren Äquivalente in Ihrem Proxy. Legen Sie Streaming-Routen in separate Blöcke.
  4. Führen Sie einen Heartbeat mindestens alle 25 Sekunden und ein erzwungenes Schließen des Streams alle 5–15 Minuten mit Cursor ein.
  5. Wenn Sie fremde Streams über einen Proxy konsumieren – führen Sie das „Drei-Punkte“-Protokoll für jeden Adresspool durch und stellen Sie Streaming-Anfragen auf HTTPS um.
  6. Richten Sie Monitoring für die Zeit bis zum ersten Byte und die Intervalle zwischen Chunks ein. Das ist der einzige Weg, von Pufferung früher als die Nutzer zu erfahren.

Der Proxy ist nicht der Feind des Streams. Ein richtig konfigurierter Proxy fügt dem Stream Ausfallsicherheit, Lastverteilung und Backend-Schutz hinzu. Die Aufgabe besteht nur darin, ihm zu erklären: Diese Antwort ist besonders, sie muss so weitergegeben werden, wie sie ankommt. Jetzt haben Sie alles, um diese Erklärung in seiner Sprache vorzubringen.