Introduction : pourquoi le HTTP en streaming via proxy est devenu un problème de masse

Imaginez : vous envoyez une requête à un modèle de langage, et au lieu du « tapement » familier des tokens, l'écran reste muet pendant quarante secondes, puis recrache toute la réponse d'un seul bloc. Ou un tableau de bord de monitoring, censé se rafraîchir chaque seconde, affiche des données avec trente secondes de retard. Ou un parser qui écoute un flux d'événements d'une place de marché et reçoit des paquets de cent événements au lieu d'un ruisseau régulier. Dans neuf cas sur dix, ce n'est ni le serveur ni le client qui est en cause. C'est celui qui se trouve entre les deux : un proxy, un load balancer, un CDN ou une passerelle d'entreprise qui a décidé de « rendre service » en accumulant toute la réponse avant de la transmettre.

Le sujet des réponses HTTP en streaming à travers des nœuds intermédiaires a longtemps été considéré comme de niche. En 2026, il est devenu massif. Le streaming de tokens depuis les API de LLM, les événements serveur dans les interfaces web, le long-polling dans les messageries et les bots, les barres de progression des longs exports, la restitution en flux des résultats de parsing — tout cela fonctionne au-dessus d'un HTTP tout à fait ordinaire, qui simplement ne se presse pas pour fermer la réponse. Et tout cela casse dès qu'un nœud avec mise en tampon activée apparaît sur le chemin.

Dans ce guide, nous allons examiner trois mécanismes classiques — chunked transfer encoding, Server-Sent Events et long-polling — précisément du point de vue de leur traversée d'un proxy. Une précision importante d'emblée : il ne sera pas question de WebSocket ni de gRPC. Ils font l'objet d'un article séparé, et la différence est fondamentale. Là-bas, il y a un upgrade de protocole ou un framing binaire par-dessus HTTP/2, et le proxy doit savoir reconnaître et laisser passer cet upgrade. Ici, il s'agit d'une réponse HTTP ordinaire, sans en-tête Content-Length, que le serveur garde ouverte. Aucun handshake, aucun passage à un autre protocole. On pourrait croire que c'est simple. Mais c'est justement cette simplicité qui crée le problème : le proxy ne voit rien de particulier et applique les règles de mise en tampon standard, pensées pour des réponses courtes.

Ce que vous retirerez de ce contenu : une compréhension du fonctionnement du flux au niveau des octets et des en-têtes ; une carte de tous les endroits où la réponse peut se bloquer ; des configurations prêtes à l'emploi pour nginx, HAProxy, Envoy et les bibliothèques clientes ; un cadre de choix entre les trois mécanismes ; des checklists de diagnostic ; des cas réels chiffrés. Ce contenu s'adresse aux développeurs, aux ingénieurs DevOps et à tous ceux qui utilisent un proxy pour travailler avec des API, faire du scraping et de l'automatisation.

Bases : comment une réponse HTTP ordinaire devient un flux

Deux façons d'indiquer la longueur d'une réponse

En HTTP/1.1, il existe deux manières fondamentales d'indiquer au client où se termine le corps de la réponse. La première — l'en-tête Content-Length : le serveur annonce à l'avance le nombre exact d'octets. La seconde — Transfer-Encoding: chunked : le serveur envoie le corps par morceaux, chaque morceau commence par sa taille en hexadécimal, et le tout se termine par un chunk nul. Il existe aussi une troisième option archaïque — simplement fermer la connexion après le dernier octet —, mais avec keep-alive, elle n'est pratiquement plus utilisée.

Pourquoi est-ce important pour le streaming ? Parce que Content-Length exige de connaître la taille à l'avance. Si le serveur génère la réponse progressivement — token par token, événement par événement —, il ne peut physiquement pas calculer la longueur avant le début de la transmission. La seule option en HTTP/1.1, c'est le chunked. En HTTP/2 et HTTP/3, le chunked en tant que tel n'existe pas : le corps est de toute façon transmis par trames DATA, et la fin est signalée par le flag END_STREAM. Mais la logique est la même : une réponse sans longueur déclarée, qui peut durer aussi longtemps qu'on veut.

Que signifie « ne pas fermer la réponse »

Une analogie. Une réponse HTTP ordinaire, c'est un colis : vous recevez une boîte sur laquelle le poids est inscrit, vous l'ouvrez et vous savez ce qu'il y a dedans. Une réponse en streaming, c'est un tapis roulant : les colis défilent l'un après l'autre, et vous ne savez pas quand le tapis s'arrêtera. Le serveur a envoyé les en-têtes avec un statut 200, envoyé le premier chunk — et il attend. De nouvelles données arrivent — il envoie le suivant. La connexion reste ouverte pendant des minutes, des heures, parfois des jours.

Du point de vue de TCP, rien d'inhabituel ne se produit : le même socket, les mêmes segments. Du point de vue de HTTP, c'est une seule et unique requête et une seule et unique réponse, simplement très longue. Et c'est là que se trouve la racine de tous les problèmes avec les proxies : le nœud intermédiaire voit le début de la réponse, ne voit pas la fin, et doit décider quoi faire des octets déjà arrivés. Les transmettre immédiatement ? Ou attendre, en accumuler davantage et envoyer plus efficacement ? Par défaut, la plupart des proxies choisissent la seconde option.

Trois mécanismes : points communs et différences

  • Chunked streaming — le plus bas niveau. Le serveur écrit simplement des octets dans le corps et appelle flush. Le format du contenu est libre : texte, NDJSON, données binaires. Le client décide lui-même comment parser.
  • Server-Sent Events — un format texte standardisé par-dessus un flux chunked. Content-Type : text/event-stream, les événements sont séparés par des lignes vides, avec les champs data, event, id, retry. Le navigateur le supporte nativement via EventSource avec reconnexion automatique.
  • Long-polling — à proprement parler, ce n'est pas un flux. Le client fait une requête, le serveur la garde ouverte jusqu'à l'arrivée de données ou jusqu'au timeout, répond et ferme. Le client enchaîne immédiatement avec la requête suivante. C'est une imitation de flux par une séquence de réponses ordinaires, chacune pouvant avoir un Content-Length.

Qu'ont-ils en commun ? Dans les trois cas, la réponse à une requête est retardée d'une durée indéterminée, et le proxy doit survivre à cela : ne pas couper la connexion sur timeout et ne pas retenir les données dans un tampon. La différence tient à la dépendance de chaque mécanisme à la transparence du nœud intermédiaire. Le chunked et le SSE en dépendent de manière critique. Le long-polling — de façon minimale, et c'est son principal avantage.

Le rôle du proxy dans la chaîne

Entre le client et le serveur, il est rare dans l'infrastructure moderne qu'il n'y ait rien. Chaîne typique : application cliente — proxy sortant (par exemple mobile ou résidentiel) — internet — CDN — load balancer cloud — proxy inverse — application. Chacun de ces nœuds est un point de mise en tampon potentiel. Et chacun est configuré par défaut pour optimiser les réponses courtes : collecter, compresser, livrer en bloc. Pour un flux, cette optimisation est une catastrophe. Nous allons démonter ces couches une par une et regarder ce qui se passe à chaque niveau.

Plongée en profondeur : où et pourquoi le flux se bloque sur un nœud intermédiaire

Pourquoi les proxies mettent-ils en tampon

Avant de critiquer la mise en tampon, il vaut la peine d'en comprendre la logique. Un proxy inverse comme nginx met en tampon pour trois raisons. Première — protéger le backend d'un client lent : si un client sur un réseau mobile lit à dix kilo-octets par seconde, alors que le backend a déjà généré la réponse, il est plus avantageux de tout récupérer du backend d'un coup, de libérer son worker, puis de servir tranquillement le client depuis le tampon. Deuxième — la compression : gzip et brotli fonctionnent mieux sur de gros blocs. Troisième — la possibilité de définir un Content-Length et de gérer proprement une erreur backend avant d'envoyer les en-têtes au client.

Pour une API typique avec des réponses de quelques kilo-octets, tout cela est raisonnable et économise des ressources. Pour un flux — exactement l'inverse : en retenant les octets, le proxy détruit la valeur même du flux. Cette valeur réside dans la promptitude, pas dans le volume.

Carte des huit points de mise en tampon

Parcourons la chaîne et marquons chaque point où les données peuvent se bloquer. Gardez cette liste sous la main lors du diagnostic.

  1. L'application. Le framework peut mettre en tampon sa propre sortie. Les serveurs WSGI, PHP avec output_buffering activé, les frameworks Node.js avec middleware de compression. Le flush n'est pas appelé — les données restent dans le tampon du processus.
  2. Le proxy inverse devant l'application. nginx avec proxy_buffering on (activé par défaut) accumule la réponse dans les tampons définis par proxy_buffer_size et proxy_buffers, et en cas de débordement — dans un fichier temporaire sur disque. Apache mod_proxy met moins en tampon, mais a ses propres réglages. Caddy ne met pas en tampon par défaut, mais flush_interval mérite vérification.
  3. La compression sur le proxy. Même avec proxy_buffering off, un gzip activé accumule les données jusqu'à la taille de la fenêtre de compression. C'est l'un des points les plus sournois : la mise en tampon est formellement désactivée, mais le flux arrive par saccades.
  4. Le load balancer L7. HAProxy en mode http transmet les données à mesure, si http-buffer-request n'est pas activé, mais il est limité par tune.bufsize. Envoy streame par défaut, mais les filtres de compression ou Lua peuvent accumuler le corps.
  5. Les CDN et passerelles cloud. Beaucoup de CDN mettent en tampon les réponses pour la mise en cache et la compression. Certains fournisseurs ne supportent pas les flux dépassant une certaine durée ou exigent des réglages explicites. Les passerelles API cloud ont souvent une limite stricte de temps de réponse autour de 30 secondes et ne supportent pas du tout le streaming du corps.
  6. Le proxy sortant côté client. Le proxy HTTP par lequel vous accédez à internet — d'entreprise, mobile, résidentiel — est lui aussi un parseur HTTP. S'il est bâti sur nginx ou Squid et configuré pour la mise en tampon, le flux se bloquera là. Les services proxy de qualité laissent passer les réponses chunked de façon transparente, mais cela se vérifie en pratique.
  7. TLS et TCP. Les données peuvent être retenues dans les enregistrements TLS si la bibliothèque les accumule jusqu'à 16 kilo-octets. L'algorithme de Nagle retient les petits segments TCP jusqu'à l'acquittement du précédent. Pour un flux de petits chunks, cela ajoute des dizaines de millisecondes à chaque fois.
  8. La bibliothèque cliente. requests en Python lit tout le corps en mémoire si stream=True n'est pas passé. Plusieurs clients HTTP mettent en tampon jusqu'à la taille de chunk_size.

Huit points. Si ne serait-ce qu'un seul accumule les données, vous verrez le flux par saccades ou en un gros paquet final. Et le plus désagréable : le comportement dépend du volume. Sur les petites réponses, tout semble normal, mais sous charge ou sur des réponses longues, le tampon se remplit, l'écriture dans des fichiers temporaires s'enclenche, et les latences explosent. Pas étonnant que beaucoup d'équipes ne découvrent le problème qu'en production.

HTTP/1.1 contre HTTP/2 dans le contexte du streaming

En HTTP/1.1, une connexion correspond à une réponse à la fois. Une réponse longue occupe toute la connexion. Le navigateur limite le nombre de connexions simultanées vers un même hôte à six, donc six flux SSE ouverts bloquent toutes les autres requêtes vers cet hôte. Un proxy qui travaille en HTTP/1.1 avec le backend tient lui aussi une connexion par flux.

En HTTP/2, le multiplexage supprime cette limitation : une centaine de flux vivent dans une seule connexion TCP. Mais une subtilité apparaît — le contrôle de flux au niveau du protocole. Si le destinataire n'élargit pas la fenêtre via WINDOW_UPDATE, l'émetteur s'arrête. Certains proxies relaient ces trames maladroitement et créent des pauses artificielles.

Il est important de comprendre : un proxy peut recevoir une requête en HTTP/2 du client et se connecter au backend en HTTP/1.1. Il reconditionne les trames DATA en chunks et inversement. C'est une opération normale, mais c'est justement à la frontière de la conversion que se perd souvent le flush opportun — le proxy attend qu'une taille de trame « commode » se soit accumulée.

Les timeouts — le second tueur de flux

La mise en tampon retarde les données. Les timeouts coupent la connexion. nginx possède proxy_read_timeout — le temps maximal entre deux opérations de lecture consécutives depuis le backend, par défaut 60 secondes. Si le serveur reste silencieux plus d'une minute, nginx ferme la connexion et renvoie un 504 au client. Pour un long-polling avec une attente de 90 secondes, c'est un échec garanti. HAProxy a timeout server et timeout tunnel. Les load balancers cloud ont un idle timeout, souvent de 60 ou 350 secondes. Les opérateurs mobiles ont des timeouts NAT qui réinitialisent les connexions inactives après quelques minutes.

D'où une règle de fer : un flux sans activité périodique est condamné. Les messages heartbeat toutes les 15-30 secondes ne sont pas une option, mais une exigence obligatoire de toute réponse longue.

Matrice de choix du mécanisme

Avant de passer à la pratique, fixons le cadre de choix. Répondez à quatre questions.

  • Contrôlez-vous toute la chaîne de proxies ? Oui — le chunked et le SSE conviennent. Non, il y a des passerelles inconnues dans la chaîne — commencez par le long-polling ou prévoyez une dégradation vers lui.
  • Qui est le client ? Navigateur — le SSE avec EventSource offre la reconnexion gratuitement. Code propriétaire — le chunked avec NDJSON est plus flexible.
  • Quelle est la nature des données ? Fragments d'une même entité (tokens d'une même réponse) — chunked ou SSE. Événements discrets indépendants — SSE ou long-polling.
  • Quelle est la fréquence ? Dizaines d'événements par seconde — chunked ou SSE avec batching. Événement une fois par minute — long-polling avec grand timeout ou SSE avec heartbeat.

Méthode 1 : chunked transfer encoding — le flux de bas niveau sans habillage

Quand choisir le chunked pur

Un flux chunked pur est approprié quand le client est votre propre code, pas un navigateur ; quand le format des données n'est pas textuel ou ne rentre pas dans le modèle d'événements ; quand on veut un contrôle maximal sur chaque octet. Exemples typiques : streaming NDJSON depuis une API, restitution en flux de résultats de parsing, téléchargement de gros exports avec indicateur de progression, proxyfication de réponses LLM dans son propre format.

Configuration côté serveur, étape par étape

  1. Assurez-vous que l'application écrit par morceaux. Après chaque portion logique, appelez flush. En Python avec un serveur ASGI, c'est un générateur qui émet des octets ; en Node.js — res.write suivi de flush si la compression est en jeu ; en Go — l'interface http.Flusher après chaque Write.
  2. Ne définissez pas de Content-Length. La plupart des frameworks basculeront d'eux-mêmes en chunked si la longueur n'est pas définie. Vérifiez qu'en HTTP/1.1 la réponse présente bien Transfer-Encoding: chunked.
  3. Désactivez la compression au niveau de l'application pour les routes en streaming, ou assurez-vous qu'elle flushe en même temps que les données. Le compromis — gzip avec flush synchrone après chaque chunk ; cela fonctionne, mais réduit le taux de compression.
  4. Définissez l'en-tête X-Accel-Buffering: no. C'est un en-tête spécifique à nginx, qui désactive la mise en tampon pour une réponse donnée sans modifier la configuration globale. Certains autres proxies le comprennent aussi. Ajoutez également Cache-Control: no-cache, no-transform — la seconde valeur demande aux nœuds intermédiaires de ne pas modifier le corps.
  5. Configurez le proxy inverse. Pour nginx dans le location de la route en streaming : proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;. La directive proxy_http_version 1.1 est obligatoire : par défaut, nginx s'adresse au backend en HTTP/1.0, où le chunked n'existe pas, et nginx est obligé de mettre en tampon jusqu'à la fermeture de la connexion.
  6. Séparez les routes. Si la compression est nécessaire pour le reste de l'API, activez-la uniquement dans les blocs location non-streaming.
  7. Vérifiez l'algorithme de Nagle. Dans nginx, tcp_nodelay est activé par défaut, mais dans l'application, pour de petits chunks fréquents, une activation explicite de TCP_NODELAY sur le socket peut être nécessaire.

Configuration HAProxy et Envoy

HAProxy. Dans la section backend, n'utilisez pas option http-buffer-request. Assurez-vous que timeout server est suffisamment grand pour votre scénario, et pour les flux vraiment longs, définissez timeout tunnel. Désactivez la compression pour les chemins en streaming via une ACL ou fiez-vous à l'en-tête no-transform : HAProxy respecte Cache-Control: no-transform et ne compresse pas de telles réponses.

Envoy. La mise en tampon est désactivée par défaut, ce qui est réjouissant. Mais vérifiez deux timeouts : stream_idle_timeout dans le HTTP connection manager (par défaut cinq minutes) et le route timeout (par défaut quinze secondes — c'est lui qui coupe le plus souvent les flux). Pour les routes en streaming, fixez timeout à 0s, ce qui signifie aucune limite, et reposez-vous sur l'idle timeout combiné au heartbeat.

Checklist de vérification d'un flux chunked

  • La réponse contient Transfer-Encoding: chunked, ou bien utilise HTTP/2 sans Content-Length.
  • L'en-tête X-Accel-Buffering: no est présent dans la réponse de l'application.
  • Content-Encoding est absent ou la compression flushe avec les données.
  • Le premier octet du corps arrive dans la seconde qui suit les en-têtes.
  • Les intervalles entre chunks chez le client correspondent aux intervalles de génération côté serveur à 50 millisecondes près.
  • La connexion vit plus d'une minute sans coupure en présence d'un heartbeat.
  • Les logs du proxy ne comportent pas d'entrées de mise en tampon dans un fichier temporaire.

Méthode 2 : Server-Sent Events — le standard des événements serveur vers client

Structure du format

SSE est une convention sur la manière de disposer des événements dans un flux texte. La réponse a pour Content-Type: text/event-stream. Chaque événement est un ensemble de lignes de la forme « champ: valeur », se terminant par une ligne vide. Les champs : data — la charge utile (peut se répéter, les lignes sont concaténées avec un saut de ligne) ; event — le nom du type d'événement ; id — l'identifiant pour la reprise ; retry — le délai de reconnexion recommandé en millisecondes. Une ligne commençant par deux-points est un commentaire, et c'est le heartbeat idéal : le navigateur l'ignore, mais le proxy voit de l'activité sur la connexion.

La beauté de SSE réside dans son asymétrie. La complexité est portée par la spécification et le navigateur, tandis que le serveur reste trivial. Aucun handshake, aucun framing binaire. Juste du texte qui s'écoule. C'est précisément pour cela que SSE est devenu le standard de facto du streaming des réponses de modèles de langage : la grande majorité des grandes API de LLM émettent les tokens au format text/event-stream. Il est étonnant qu'une technologie décrite dans les spécifications il y a plus de quinze ans connaisse en 2026 un second essor.

Pourquoi SSE est particulièrement sensible à la mise en tampon

Un événement SSE pèse de quelques dizaines d'octets à quelques kilo-octets. Le tampon nginx par défaut — 4 ou 8 kilo-octets pour le premier bloc, puis huit blocs de 4-8 kilo-octets. Le proxy va donc accumuler de cinquante à plusieurs centaines d'événements avant de livrer le premier. Pour un chat avec un modèle, cela se traduit ainsi : l'utilisateur attend quinze secondes, puis tout le paragraphe apparaît d'un coup. L'illusion de la frappe est détruite, alors que c'est justement pour elle que le streaming a été adopté.

Mise en œuvre de SSE à travers un proxy, étape par étape

  1. En-têtes de réponse : Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, et pour HTTP/1.1 également Connection: keep-alive.
  2. Heartbeat. Envoyez une ligne de commentaire du type : ping toutes les 15-25 secondes. C'est inférieur à tout idle timeout raisonnable et cela maintient les tables NAT des opérateurs à jour.
  3. Identifiants d'événements. Attribuez à chaque événement un id croissant de manière monotone. Lors de la reconnexion, le navigateur enverra l'en-tête Last-Event-ID, et le serveur pourra renvoyer ce qui a été manqué. Sans cela, toute coupure sur le proxy est une perte de données.
  4. Le champ retry. Fixez une valeur raisonnable, par exemple 3000 millisecondes, pour que les clients ne déclenchent pas une tempête de reconnexions lors d'un redémarrage du serveur.
  5. Configuration nginx — la même que pour le chunked. Vérifiez en outre que gzip ne s'applique pas à text/event-stream : si gzip_types inclut text/*, ajoutez un location distinct avec gzip off.
  6. Planification des connexions. Chaque flux SSE ouvert en HTTP/1.1 est une connexion distincte entre le proxy et le backend. Pour mille clients simultanés, il faut mille connexions. Utilisez HTTP/2 côté client et un serveur asynchrone côté backend.
  7. Gestion de la fermeture. Le serveur doit détecter la rupture de connexion par le client et arrêter la génération. À travers un proxy, cela se produit avec un délai : le serveur n'apprend la rupture qu'à la tentative d'écriture. Pour des opérations coûteuses comme l'inférence d'un modèle, cela représente des secondes de travail GPU inutiles. La solution — des écritures heartbeat régulières, qui provoquent une erreur d'écriture sur une connexion rompue.

SSE et HTTP/2 : nuances

Via HTTP/2, SSE fonctionne sans la limite des six connexions — c'est la principale raison d'activer HTTP/2 sur le proxy frontal. Cependant, lors de la traduction d'HTTP/2 en HTTP/1.1 vers le backend, certains proxies introduisent un léger délai dû à l'agrégation des trames. Assurez-vous que le premier événement part immédiatement, sans attendre le remplissage d'une trame. Si le backend parle aussi HTTP/2, les délais sont minimes, mais vérifiez que le proxy retransmet correctement les WINDOW_UPDATE et n'étouffe pas le flux par le contrôle de fenêtre.

Cadre de conception d'un flux SSE

  1. Définissez les types d'événements et leur fréquence. Les événements rares exigent un heartbeat ; les événements fréquents — un batching de plusieurs écritures dans un même événement.
  2. Choisissez une stratégie de reprise : conserver un tampon circulaire des derniers événements côté serveur pour traiter Last-Event-ID, ou s'en remettre à une resynchronisation complète lors de la reconnexion.
  3. Fixez une limite de durée pour un flux. Une bonne pratique — le serveur ferme lui-même le flux toutes les 5-10 minutes, le client se reconnecte de manière transparente. Cela protège contre l'accumulation d'état et contourne les timeouts cachés de l'infrastructure.
  4. Prévoyez la dégradation : si le flux ne passe pas à travers le proxy, basculez automatiquement vers le long-polling.

Méthode 3 : long-polling — un flux fait d'une séquence de réponses ordinaires

Comment cela fonctionne et pourquoi c'est encore pertinent

Le long-polling est la plus ancienne des trois techniques. Le client envoie une requête, le serveur ne répond pas immédiatement mais attend un événement jusqu'à un timeout donné (généralement 20-60 secondes). Un événement survient — le serveur renvoie une réponse et la ferme. Rien n'est survenu — il renvoie une réponse vide. Le client envoie aussitôt la requête suivante. De l'extérieur, cela ressemble à un flux avec un délai minimal, mais chaque réponse est ordinaire, avec un Content-Length, totalement compatible avec n'importe quel proxy, n'importe quel cache et n'importe quelle passerelle.

Pourquoi le long-polling est-il bien vivant en 2026 ? Parce qu'il passe partout. À travers les passerelles d'entreprise qui coupent le chunked. À travers les passerelles API cloud avec limite de temps de réponse. À travers les serveurs proxy à la mise en tampon imprévisible. L'exemple le plus célèbre — la méthode de récupération des mises à jour dans l'API Bot d'une grande messagerie, où le paramètre timeout définit la durée d'attente. La grande majorité des bots fonctionne ainsi depuis des années, à travers toutes sortes de proxies, et sans problème.

Cinq règles de conception du long-polling à travers un proxy

  1. Le timeout serveur est inférieur au plus court timeout de la chaîne. Si le proxy a un proxy_read_timeout de 60 secondes, l'attente serveur — pas plus de 50. Si la chaîne comporte une passerelle cloud à 30 secondes — pas plus de 25. Sinon, au lieu d'une réponse vide, le client recevra un 504, et un flux d'erreurs affolera le monitoring.
  2. Un curseur ou un offset. Le client transmet l'identifiant du dernier événement reçu. Le serveur renvoie tout ce qui est apparu après. Le protocole devient idempotent : une réponse perdue entraîne simplement une réémission des mêmes événements.
  3. Du jitter lors de la reconnexion après erreur. Croissance exponentielle du délai — 1, 2, 4, 8 secondes — plus un ajout aléatoire. Sans jitter, mille clients frapperont le serveur simultanément après une panne.
  4. Zéro pause après une réponse réussie. La requête suivante part immédiatement. Toute pause ici est de la latence perdue.
  5. Keep-alive obligatoire. Sans lui, chaque requête est une nouvelle connexion TCP et un nouveau handshake TLS. Cela ajoute de 50 à 300 millisecondes par cycle, et via un proxy distant — encore plus.

Mise en œuvre étape par étape

  1. Serveur : un endpoint qui accepte un offset et un timeout, attend un événement sur une file interne ou via un abonnement, répond avec un tableau d'événements et un nouvel offset. Un tableau vide — une réponse normale, pas une erreur.
  2. Proxy : configuration standard, mais proxy_read_timeout au moins égal au timeout serveur plus dix secondes de marge. La mise en tampon peut rester activée — la réponse est courte et complète.
  3. Client : une boucle gérant trois issues — données, réponse vide, erreur. Un pool de connexions unifié, keep-alive, un timeout client supérieur au timeout serveur.
  4. Monitoring : part des réponses vides, temps d'attente moyen, fréquence des 5xx et des timeouts clients.

Quand le long-polling perd la partie

À haute fréquence d'événements, les frais généraux des en-têtes et du cycle requête-réponse deviennent perceptibles. Avec des milliers de clients, le serveur doit tenir des milliers de requêtes en attente — impossible sans une pile asynchrone. Et, bien sûr, le long-polling est peu pratique pour le streaming d'une seule longue réponse, où il faut une séquence de fragments d'une même entité. Les tokens d'un modèle de langage en long-polling — théoriquement possible, pratiquement maladroit.

Méthode 4 : consommer des réponses en streaming via un proxy sortant

Particularités du scénario

Jusqu'ici, nous regardions du point de vue du propriétaire du serveur. Retournons maintenant la situation : vous êtes le client, vous vous adressez à l'API en streaming d'un tiers à travers un serveur proxy, et seul le côté client dépend de vous. Tâches typiques : collecte de données depuis des API en streaming via un pool d'adresses, travail avec le streaming LLM depuis des scripts d'automatisation, répartition de la charge sur une API entre différentes IP, suivi d'événements sur des plateformes en temps réel, test de son propre service depuis différents réseaux.

Trois choses comptent ici. Le proxy lui-même doit laisser passer de façon transparente les réponses chunked. La bibliothèque cliente doit lire le flux à mesure. Et vous devez savoir distinguer un problème sur le proxy d'un problème sur le serveur cible.

Vérifier la transparence d'un proxy vis-à-vis des flux

  1. Prenez un endpoint résolument streamé — un service de test public qui émet des lignes avec délai, ou votre propre endpoint avec un calendrier de chunks connu.
  2. Exécutez la requête en direct et via le proxy avec l'outil curl et le flag -N (désactive la mise en tampon de la sortie de curl lui-même) et le flag --trace-time pour les horodatages. Comparez les instants d'arrivée des fragments.
  3. Si, à travers le proxy, tous les fragments arrivent d'un bloc à la fin — le proxy met en tampon entièrement. Si par paquets de plusieurs kilo-octets — partiellement. Si cela correspond à la requête directe — il est transparent.
  4. Testez un flux long (5-10 minutes) avec heartbeat. Une coupure au bout d'un temps fixe révèle l'idle timeout du proxy.
  5. Testez HTTPS. À travers un proxy avec la méthode CONNECT, un tunnel se crée, et le proxy ne décompose pas le HTTP à l'intérieur — aucune mise en tampon au niveau HTTP n'est possible, seulement des délais TCP. C'est l'une des raisons pour lesquelles les API en streaming via un tunnel CONNECT fonctionnent généralement plus régulièrement que via un proxy HTTP ordinaire qui décompose les requêtes.

Subtilité concernant les proxies mobiles : le réseau cellulaire ajoute lui-même du jitter, et le NAT des opérateurs ferme agressivement les connexions inactives. Pour les flux longs via un proxy mobile, un heartbeat toutes les 15-20 secondes est une nécessité. La rotation d'IP selon un calendrier doit prendre en compte les flux ouverts : changer d'adresse au milieu d'une connexion SSE la coupe immanquablement. Synchronisez la rotation avec le cycle de vie des flux — flux fermé, adresse changée, nouveau flux ouvert avec un curseur.

Bibliothèques clientes : quoi activer

  • Python, requests : stream=True dans l'appel, puis iter_lines ou iter_content avec un petit chunk_size. Définissez le timeout sous forme de tuple (connect, read), où read est le temps admissible entre chunks, et non le temps total de la réponse.
  • Python, httpx : client.stream et aiter_lines pour le code asynchrone ; pour SSE — des enveloppes spécialisées qui parsent le format des événements.
  • Python, aiohttp : response.content.iter_any renvoie les données exactement telles qu'elles sont arrivées du socket, sans reconditionnement — idéal pour mesurer les intervalles réels.
  • Node.js : fetch avec lecture de response.body en tant que ReadableStream ; pour SSE — des bibliothèques de parsing du format.
  • Go : un http.Client ordinaire, lecture de resp.Body via bufio.Scanner avec une taille de tampon suffisante pour les gros événements.

Dans tous les cas : n'appelez pas les méthodes qui lisent tout le corps — text, json, read sans argument. Sinon, le client attendra la fermeture de la connexion, et vous accuserez le proxy d'une mise en tampon qui n'existe pas.

Protocole de diagnostic « trois points »

Quand un flux se comporte bizarrement, mesurez le temps jusqu'au premier octet et la distribution des intervalles entre chunks dans trois configurations : en direct vers le serveur depuis la même machine ; via le proxy vers le serveur ; via le proxy vers un endpoint de streaming de référence. La comparaison localise sans ambiguïté le problème. Via le proxy vers la référence c'est bon, mais vers le serveur cible c'est mauvais — c'est l'infrastructure du serveur cible qui est en cause. Vers la référence c'est mauvais — c'est le proxy. En direct aussi c'est mauvais — c'est votre code ou le réseau. Ce protocole prend dix minutes et économise des jours de débats.

Erreurs classiques avec les flux à travers un proxy

  1. On a désactivé proxy_buffering, on a oublié gzip. L'erreur la plus fréquente. Le flux n'est formellement pas mis en tampon, mais la compression accumule les données jusqu'à la taille de la fenêtre. Symptôme : des saccades de plusieurs kilo-octets.
  2. On a laissé proxy_http_version 1.0. nginx s'adresse par défaut au backend en HTTP/1.0, où le chunked n'existe pas, et est obligé d'attendre la fermeture de la connexion. Symptôme : toute la réponse arrive à la fin.
  3. On n'envoie pas de heartbeat. Le flux vit exactement jusqu'au premier idle timeout de la chaîne — 60 secondes chez nginx, 15 chez Envoy par route, quelques minutes chez le NAT. Symptôme : des coupures à intervalles réguliers.
  4. Le timeout du long-polling est supérieur à celui du proxy. Le client reçoit un 504 au lieu d'une réponse vide, le monitoring est dans le rouge, et les événements peuvent être dupliqués.
  5. On se fie au réglage global du proxy. Lors d'une migration vers un nouvel environnement ou d'un changement de CDN, le streaming casse silencieusement. Solution — X-Accel-Buffering et no-transform au niveau de la réponse : le comportement est défini par l'application, pas par l'administrateur du proxy.
  6. Pas de Last-Event-ID ni de curseurs. Toute coupure — perte de données. À travers un proxy, les coupures surviennent nettement plus souvent qu'en direct.
  7. On lit tout le corps côté client. stream=True est oublié, le client attend la fin, le développeur accuse le proxy.
  8. Rotation d'IP pendant un flux ouvert. La connexion se coupe, pas de reconnexion, les données sont perdues.
  9. On teste sur des réponses courtes. Le tampon n'a pas le temps de se remplir, tout semble parfait. En production, sur des réponses longues, l'écriture dans un fichier temporaire s'enclenche, et les latences explosent.
  10. On mélange routes streamées et ordinaires dans un même location. Soit on casse le streaming, soit on perd la compression et la mise en tampon pour les réponses ordinaires, ce qui pénalise les performances de toute l'API.
  11. On ignore la rupture de connexion par le client. À travers un proxy, le serveur apprend la rupture tard et poursuit une génération coûteuse. Pour l'inférence LLM, c'est de l'argent en direct.
  12. On utilise le chunked là où il faudrait du long-polling. À travers une passerelle d'entreprise ou un API-gateway cloud avec limite de réponse, le flux ne passera pas, tandis que le long-polling passera sans problème.

Outils et ressources pour la configuration et le diagnostic

Proxies inverses et load balancers

  • nginx — la référence en matière de flexibilité. Directives clés : proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, prise en charge de l'en-tête X-Accel-Buffering.
  • HAProxy — une mise en tampon minimale en sortie de boîte. Surveillez timeout server, timeout tunnel et la compression.
  • Envoy — streame par défaut. Les points critiques sont le route timeout et stream_idle_timeout.
  • Caddy — ne met pas en tampon par défaut ; flush_interval avec la valeur -1 impose un flush immédiat explicite.
  • Traefik — transmet les flux de manière transparente ; les timeouts se configurent au niveau des entrypoints.

Diagnostic

  • curl avec les flags -N, -v et --trace-time montre les instants d'arrivée de chaque fragment. Le paramètre -w avec les variables time_starttransfer et time_total donne le temps du premier octet et le temps total.
  • tcpdump et Wireshark — pour vérifier si les octets arrivent avec retard au niveau réseau ou s'ils sont retenus plus haut.
  • mitmproxy — inspection des flux en conservant la structure des chunks. Activez impérativement le mode streaming, sinon il deviendra lui-même un point de mise en tampon.
  • Outils de développement du navigateur — l'onglet EventStream pour SSE affiche chaque événement avec un horodatage.

Endpoints de test et bibliothèques

Les services publics de test HTTP disposent d'endpoints qui émettent un nombre donné de lignes avec délai — ils sont parfaits pour vérifier la transparence d'un proxy. Votre propre serveur minimal dans n'importe quel langage, émettant un chunk par seconde avec un horodatage, est encore mieux : vous contrôlez les deux côtés. Pour SSE côté serveur, pratiquement tout framework asynchrone possède une classe de réponse prête pour text/event-stream. Pour SSE côté client hors navigateur, il existe des parseurs du format pour Python, Node.js et Go. Pour le long-polling, aucune bibliothèque spéciale n'est nécessaire — un client HTTP avec pool de connexions suffit.

Monitoring

Métriques à collecter : temps jusqu'au premier octet du corps ; distribution des intervalles entre chunks aux percentiles 50, 95 et 99 ; durée de vie des flux et cause de fermeture ; nombre de flux actifs sur le proxy et sur le backend ; part des reconnexions avec Last-Event-ID. Une forte hausse de l'intervalle entre chunks accompagnée d'une hausse simultanée du volume est un signal sûr de mise en tampon enclenchée.

Cas et résultats : à quoi cela ressemble dans de vrais projets

Cas 1. Streaming LLM via nginx : de 11 secondes à 310 millisecondes

Une équipe a déployé un chat basé sur un modèle de langage. En local, les tokens apparaissaient en douceur. Après la mise en production derrière nginx, les utilisateurs voyaient un écran vide pendant 8-12 secondes, puis toute la réponse d'un coup. Le diagnostic par le protocole « trois points » a montré : en direct vers l'application, le premier token arrivait en 280 millisecondes, via nginx — en 11 secondes. Causes classiques : proxy_buffering on et proxy_http_version 1.0 par défaut. Après l'ajout de proxy_buffering off, proxy_http_version 1.1, gzip off pour la route et de l'en-tête X-Accel-Buffering: no dans la réponse de l'application, le temps jusqu'au premier token à travers le proxy est passé à 310 millisecondes. Découverte annexe : à la fermeture de l'onglet, l'inférence se poursuivait jusqu'à la fin de la réponse. Après la mise en place d'un heartbeat avec vérification d'erreur d'écriture, la consommation de temps GPU sur les requêtes abandonnées a baissé d'environ un quart.

Cas 2. Tableau de bord en SSE et réseaux mobiles

Un service de monitoring émettait des événements via SSE. Sur internet filaire, tout fonctionnait, mais depuis des appareils mobiles, les flux se coupaient au bout de 2-4 minutes sans erreur côté serveur. Cause — les timeouts NAT des opérateurs sur les connexions inactives. Solution : un commentaire heartbeat toutes les 20 secondes plus une fermeture forcée du flux par le serveur toutes les 10 minutes avec un Last-Event-ID correct. Les plaintes de « tableau de bord figé » ont pratiquement disparu, la durée moyenne d'un flux continu est passée de 3 à 10 minutes (limitée désormais par la fermeture volontaire), et aucune perte d'événements lors de la reconnexion n'a été constatée.

Cas 3. Parsing d'une API en streaming via un pool de proxies mobiles

Une équipe collectait des événements sur une plateforme émettant des données en flux NDJSON, via un pool de proxies mobiles. Deux problèmes étaient observés : une partie des flux arrivait par saccades de 8 kilo-octets, une partie se coupait lors de la rotation d'adresse. Les tests ont montré que, pour les requêtes non chiffrées, le proxy décomposait le HTTP et mettait en tampon les réponses, tandis qu'à travers un tunnel CONNECT vers un endpoint HTTPS, il laissait passer le flux de manière transparente. Le passage à HTTPS a entièrement résolu le premier problème. Le second a été résolu par synchronisation : la rotation d'IP ne s'exécute qu'après la fermeture propre du flux, et la reconnexion se fait avec un curseur sur le dernier événement. La complétude des données collectées est passée d'environ 91 à 99,7 pour cent.

Cas 4. Bot en long-polling via une passerelle restrictive

Un développeur faisait tourner un bot sur une infrastructure où les requêtes sortantes passaient par une passerelle d'entreprise avec une limite de réponse de 30 secondes. Au départ, un timeout d'attente de 60 secondes était utilisé — la moitié des requêtes se terminaient par une erreur de la passerelle, les mises à jour étaient dupliquées. Après réduction du timeout à 25 secondes et ajout d'un jitter exponentiel sur les erreurs, la part d'erreurs est tombée de 48 à moins de 0,5 pour cent. Le délai moyen de livraison des événements n'a pas changé — il est déterminé par le moment de l'événement, pas par la durée de l'attente.

Cas 5. Passage à HTTP/2 pour SSE

Une application web ouvrait 3-4 flux SSE par onglet. Avec plusieurs onglets ouverts, le navigateur épuisait la limite de six connexions, et les requêtes ordinaires s'empilaient derrière les flux. L'activation d'HTTP/2 sur le proxy frontal a fait passer tous les flux dans une seule connexion. Le temps de chargement de la page avec cinq onglets ouverts est passé de 9 à 1,5 seconde. Découverte annexe : après la migration, il a fallu augmenter stream_idle_timeout, car les réglages précédents étaient pensés pour HTTP/1.1.

FAQ : questions approfondies sur les réponses en streaming via proxy

En quoi le HTTP en streaming diffère-t-il fondamentalement de WebSocket du point de vue du proxy ?

WebSocket exige un upgrade de protocole : le proxy doit reconnaître les en-têtes Upgrade et Connection, basculer en mode tunnel et cesser de décomposer le HTTP. Le HTTP en streaming n'exige rien — c'est une réponse ordinaire qui ne se termine pas pendant longtemps. Le paradoxe, c'est que WebSocket à travers un proxy soit fonctionne, soit ne fonctionne pas du tout, tandis que le HTTP en streaming « fonctionne » toujours, mais peut fonctionner mal : les données arrivent, mais avec du retard. C'est pourquoi les problèmes de flux sont plus difficiles à repérer et à diagnostiquer.

Pourquoi X-Accel-Buffering: no n'aide-t-il pas toujours ?

L'en-tête est compris par nginx et les proxies compatibles. Un CDN, une passerelle cloud ou un proxy d'un autre type l'ignoreront. De plus, X-Accel-Buffering n'affecte pas gzip — la compression doit être désactivée séparément. Et si, entre l'application et nginx, se trouve une couche qui supprime les en-têtes non standard, il n'atteindra pas nginx.

Peut-on compresser une réponse en streaming ?

Techniquement oui : gzip supporte le flush synchrone, et le serveur peut compresser chaque chunk avec émission immédiate. Le taux de compression baisse alors, car le dictionnaire n'a pas le temps de se remplir. En pratique, pour SSE et les tokens de LLM, on désactive la compression : une économie de trafic de quelques pour cent ne justifie pas le risque de délais. Pour des flux de gros objets JSON, une compression avec flush peut apporter un gain sensible.

Comment choisir entre SSE et long-polling ?

Si le client est un navigateur, que les événements arrivent plus d'une fois toutes quelques secondes et que vous contrôlez au moins le proxy inverse — SSE. Si la chaîne comporte des nœuds non contrôlés avec limites de temps de réponse, que les événements sont rares ou qu'une compatibilité maximale est nécessaire — long-polling. Les systèmes matures implémentent les deux et basculent automatiquement selon le résultat de la première connexion.

HTTP/3 change-t-il le problème de la mise en tampon ?

HTTP/3 fonctionne au-dessus de QUIC et élimine le blocage de file au niveau transport, mais la mise en tampon se situe plus haut — dans la logique du proxy. Un proxy avec HTTP/3 en entrée et HTTP/1.1 en sortie met en tampon exactement de la même manière. Ce qui change réellement — le comportement dans les réseaux mobiles : QUIC résiste mieux au changement de réseau et aux pertes, donc les flux en HTTP/3 se coupent moins souvent côté client.

Comment savoir que c'est bien le proxy sortant qui met en tampon, et non le serveur cible ?

Méthode des « trois points » : la même requête en direct, via le proxy, et via le proxy vers un endpoint de streaming de référence. En complément, essayez HTTPS via CONNECT — si le flux devient régulier, le proxy décomposait et mettait en tampon le HTTP non chiffré.

Quel intervalle de heartbeat choisir ?

Inférieur au plus court timeout de la chaîne, avec une marge d'un facteur deux. Pour une infrastructure typique — 15-25 secondes, pour les réseaux mobiles plutôt 15. Un heartbeat trop fréquent — trafic et charge inutiles sur des milliers de connexions, trop rare — des coupures.

Que faire si un flux doit vivre pendant des heures ?

Ne pas le faire. Concevez une fermeture forcée par le serveur toutes les 5-15 minutes avec un curseur pour la reprise. Cela protège contre l'accumulation de mémoire, les fuites et les timeouts invisibles, et simplifie aussi le déploiement : vous redémarrez les serveurs sans penser à des connexions d'une heure.

Comment le proxy influence-t-il la détection de la déconnexion du client ?

Entre le client et le serveur, il y a désormais deux connexions. Quand le client se déconnecte, le proxy l'apprend immédiatement, mais ne le signale au serveur qu'à la prochaine tentative d'écriture ou selon ses propres règles. Le serveur ne remarquera la rupture qu'à l'écriture. D'où la pratique d'écritures heartbeat régulières pour détecter tôt la rupture et arrêter les opérations coûteuses.

Faut-il une configuration spéciale du proxy mobile pour les flux ?

Du côté utilisateur, le proxy lui-même ne se configure généralement pas. Mais il faut : préférer HTTPS pour un tunnel transparent ; synchroniser la rotation d'IP avec le cycle de vie des flux ; maintenir un heartbeat au moins toutes les 15-20 secondes ; utiliser keep-alive et un pool de connexions ; vérifier chaque pool pour la transparence avant la mise en production.

Conclusion : résumé et prochaines étapes

Le HTTP en streaming n'est ni une exotisme ni un protocole à part. C'est une réponse ordinaire qui ne se presse pas de se fermer. C'est précisément pour cela qu'il est si vulnérable face aux nœuds intermédiaires : le proxy ne voit rien de particulier et applique des règles conçues pour des réponses courtes. La mise en tampon retarde les données, les timeouts coupent la connexion, la compression masque la mise en tampon — et tout cela en huit points différents de la chaîne.

Les trois mécanismes — chunked, SSE et long-polling — résolvent une même tâche avec un degré de dépendance variable à la transparence du proxy. Le chunked offre un contrôle maximal au prix d'un traitement autonome côté client. Le SSE offre un modèle d'événements prêt à l'emploi et la reconnexion dans le navigateur, mais exige de l'attention à chaque nœud. Le long-polling passe à travers n'importe quoi, mais le paie par des frais généraux sur des requêtes fréquentes. Le choix est déterminé par quatre questions : contrôlez-vous la chaîne, qui est le client, quelle est la nature des données et quelle est leur fréquence.

Ce qu'il faut faire dès aujourd'hui :

  1. Parcourez la carte des huit points de mise en tampon pour votre infrastructure et notez ceux que vous contrôlez.
  2. Ajoutez dans les réponses des routes streamées X-Accel-Buffering: no et Cache-Control: no-cache, no-transform — indépendamment de la configuration actuelle du proxy.
  3. Vérifiez proxy_http_version, proxy_buffering, gzip et proxy_read_timeout dans nginx ou leurs équivalents dans votre proxy. Placez les routes streamées dans des blocs séparés.
  4. Mettez en place un heartbeat au moins toutes les 25 secondes et une fermeture forcée du flux toutes les 5-15 minutes avec un curseur.
  5. Si vous consommez des flux tiers via un proxy — faites tourner le protocole « trois points » sur chaque pool d'adresses et faites passer les requêtes streamées en HTTPS.
  6. Configurez un monitoring du temps jusqu'au premier octet et des intervalles entre chunks. C'est le seul moyen d'apprendre la mise en tampon avant les utilisateurs.

Le proxy n'est pas l'ennemi du flux. Correctement configuré, il ajoute au flux la tolérance aux pannes, la répartition de charge et la protection du backend. La seule tâche est de lui expliquer : cette réponse est particulière, il faut la transmettre telle qu'elle arrive. Maintenant, vous avez tout pour que cette explication soit formulée dans sa langue.