Introducción: por qué el HTTP en streaming a través de proxy se volvió un problema masivo

Imagina esto: enviaste una solicitud a un modelo de lenguaje y, en lugar del habitual "tecleo" de tokens, la pantalla queda muda durante cuarenta segundos y después escupe toda la respuesta de un solo golpe. O un panel de monitoreo que debe actualizarse cada segundo muestra datos con medio minuto de retraso. O un scraper que escucha el flujo de eventos de una plataforma de trading recibe ráfagas de cien eventos en lugar de un chorro continuo. En nueve de cada diez casos, el culpable no es el servidor ni el cliente. El culpable es quien está entre ellos: un proxy, un balanceador, una CDN o una puerta de enlace corporativa que decidió "ayudar" y acumular la respuesta completa antes de entregarla.

El tema de las respuestas HTTP en streaming a través de nodos intermedios estuvo mucho tiempo considerado de nicho. En 2026 se volvió masivo. El streaming de tokens desde APIs de LLM, los eventos del servidor en interfaces web, el long-polling en mensajeros y bots, las barras de progreso de exportaciones largas, la entrega en streaming de resultados de scraping: todo esto funciona sobre HTTP común y corriente, que simplemente no tiene prisa por cerrar la respuesta. Y todo esto se rompe en cuanto aparece un nodo con buffering activado.

En esta guía vamos a desglosar tres mecanismos clásicos —chunked transfer encoding, Server-Sent Events y long-polling— precisamente desde la perspectiva de su paso a través de un proxy. Una aclaración importante desde ya: aquí no habrá WebSocket ni gRPC. A ellos está dedicado un material aparte, y la diferencia es fundamental. Ahí ocurre un upgrade de protocolo o se usa framing binario sobre HTTP/2, y el proxy debe reconocer y permitir ese upgrade. Aquí, en cambio, hay una respuesta HTTP normal, sin encabezado Content-Length, que el servidor mantiene abierta. Sin handshake, sin cambio a otro protocolo. Parecería que no hay nada más simple. Pero justamente esa simplicidad es lo que crea el problema: el proxy no ve nada especial y aplica las reglas estándar de buffering, pensadas para respuestas cortas.

Qué vas a obtener de este material: entender cómo funciona el flujo a nivel de bytes y encabezados; un mapa de todos los lugares donde la respuesta puede atascarse; configuraciones listas para nginx, HAProxy, Envoy y librerías cliente; un marco de decisión entre los tres mecanismos; checklists de diagnóstico; y el desglose de casos reales con números. El material está pensado para desarrolladores, ingenieros DevOps y todos los que usan proxies para trabajar con APIs, scraping y automatización.

Fundamentos: cómo una respuesta HTTP normal se convierte en stream

Dos maneras de comunicar la longitud de la respuesta

En HTTP/1.1 existen dos formas fundamentales de decirle al cliente dónde termina el cuerpo de la respuesta. La primera es el encabezado Content-Length: el servidor anuncia de antemano el número exacto de bytes. La segunda es Transfer-Encoding: chunked: el servidor envía el cuerpo por porciones, cada porción comienza con su tamaño en hexadecimal y todo termina con un chunk de tamaño cero. Existe también una tercera variante arcaica: simplemente cerrar la conexión tras el último byte, pero con keep-alive prácticamente no se usa.

¿Por qué es importante esto para el streaming? Porque Content-Length exige conocer el tamaño de antemano. Si el servidor genera la respuesta de forma gradual —token a token, evento a evento— físicamente no puede calcular la longitud antes de empezar a transmitir. La única opción en HTTP/1.1 es chunked. En HTTP/2 y HTTP/3 el chunked como tal no existe: ahí el cuerpo ya se transmite en tramas DATA y el final se marca con el flag END_STREAM. Pero la lógica es la misma: una respuesta sin longitud declarada que puede durar lo que sea.

Qué significa "no cerrar la respuesta"

Una analogía. Una respuesta HTTP normal es un paquete: recibes una caja con el peso escrito encima, la abres y sabes qué hay dentro. Una respuesta en streaming es una cinta transportadora: las cajas avanzan una tras otra y no sabes cuándo se detendrá la cinta. El servidor envió los encabezados con el estado 200, envió el primer chunk y espera. Aparecieron datos nuevos: envía el siguiente. La conexión permanece abierta minutos, horas, a veces días.

Desde el punto de vista de TCP no ocurre nada raro: el mismo socket, los mismos segmentos. Desde el punto de vista de HTTP, es una única petición y una única respuesta, solo que muy larga. Y aquí está la raíz de todos los problemas con proxies: el nodo intermedio ve el inicio de la respuesta, no ve el final y debe decidir qué hacer con los bytes que ya llegaron. ¿Los reenvía de inmediato? ¿O espera, acumula más y los envía de forma más eficiente? Por defecto, la mayoría de los proxies elige lo segundo.

Tres mecanismos: lo común y las diferencias

  • Chunked streaming — el más de bajo nivel. El servidor simplemente escribe bytes en el cuerpo y hace flush. El formato del contenido es arbitrario: texto, NDJSON, datos binarios. El cliente decide cómo parsearlo.
  • Server-Sent Events — un formato de texto estandarizado sobre un flujo chunked. Content-Type: text/event-stream, eventos separados por líneas vacías, con campos data, event, id, retry. El navegador lo soporta nativamente con EventSource y reconexión automática.
  • Long-polling — estrictamente hablando, no es un stream. El cliente hace una solicitud, el servidor la mantiene abierta hasta que aparecen datos o hasta el timeout, responde y cierra. El cliente hace inmediatamente la siguiente solicitud. Es una imitación de stream mediante una secuencia de respuestas normales, cada una de las cuales puede tener Content-Length.

¿Qué tienen en común? En los tres casos, la respuesta a una solicitud se retrasa un tiempo indeterminado y el proxy debe sobrevivir a eso: no cortar la conexión por timeout y no retener los datos en un buffer. La diferencia está en cuán dependiente es cada mecanismo de la transparencia del nodo intermedio. Chunked y SSE dependen críticamente. Long-polling, mínimamente, y esa es su principal ventaja.

El rol del proxy en la cadena

Entre el cliente y el servidor rara vez hay vacío en la infraestructura moderna. Cadena típica: aplicación cliente — proxy saliente (por ejemplo, móvil o residencial) — internet — CDN — balanceador en la nube — proxy inverso — aplicación. Cada uno de estos nodos es un punto potencial de buffering. Y cada uno está configurado por defecto para optimizar respuestas cortas: recolectar, comprimir, entregar completo. Para un stream, esa optimización es una catástrofe. Vamos a ir quitando estas capas una por una y ver qué ocurre en cada una.

Inmersión profunda: dónde y por qué el stream se atasca en un nodo intermedio

Por qué los proxies hacen buffering en primer lugar

Antes de criticar el buffering, vale la pena entender su lógica. Un proxy inverso como nginx hace buffering por tres razones. Primera: proteger el backend de un cliente lento; si el cliente en una red móvil lee diez kilobytes por segundo y el backend ya generó la respuesta, conviene recogerlo todo del backend de una, liberar su worker y luego entregárselo al cliente tranquilamente desde el buffer. Segunda: la compresión, gzip y brotli funcionan mejor con bloques grandes. Tercera: la posibilidad de fijar Content-Length y manejar correctamente un error del backend antes de enviar los encabezados al cliente.

Para una API típica con respuestas de unos pocos kilobytes, todo esto es razonable y ahorra recursos. Para un stream, es exactamente lo contrario: retrasar los bytes, el proxy destruye el propio valor del flujo. Ese valor está en la puntualidad, no en el volumen.

Mapa de ocho puntos de buffering

Recorramos la cadena y señalemos cada punto donde los datos pueden atascarse. Ten esta lista a mano al diagnosticar.

  1. La aplicación. El framework puede hacer buffering por sí mismo. Los servidores WSGI, PHP con output_buffering activado, frameworks de Node.js con middleware de compresión. No se llama a flush y los datos se quedan en el buffer del proceso.
  2. Proxy inverso delante de la aplicación. nginx con proxy_buffering on (activado por defecto) acumula la respuesta en los buffers definidos por proxy_buffer_size y proxy_buffers, y cuando se llenan, en un archivo temporal en disco. Apache mod_proxy bufferea menos, pero tiene sus propios ajustes. Caddy no bufferea por defecto, pero hay que revisar flush_interval.
  3. Compresión en el proxy. Incluso con proxy_buffering off, el gzip activado acumula datos hasta el tamaño de la ventana de compresión. Este es uno de los puntos más traicioneros: el buffering está formalmente desactivado, pero el flujo va a sacudidas.
  4. Balanceador L7. HAProxy en modo http transmite los datos a medida que llegan, si no está activado http-buffer-request, pero está limitado por el tamaño de tune.bufsize. Envoy hace streaming por defecto, aunque los filtros de compresión o Lua pueden acumular el cuerpo.
  5. CDN y puertas de enlace en la nube. Muchas CDN bufferean las respuestas para cachearlas y comprimirlas. Algunos proveedores no soportan flujos más allá de cierto tiempo o exigen configuración explícita. Las puertas de enlace API en la nube suelen tener un límite estricto de tiempo de respuesta de unos 30 segundos y a veces no soportan streaming del cuerpo en absoluto.
  6. Proxy saliente del lado del cliente. El proxy HTTP por el que sales a internet —corporativo, móvil, residencial— también es un parser HTTP. Si está construido sobre nginx o Squid y configurado para hacer buffering, el stream se atascará ahí. Los servicios de proxy de calidad dejan pasar las respuestas chunked de forma transparente, pero hay que verificarlo en la práctica.
  7. TLS y TCP. Los datos pueden demorarse en los registros TLS si la librería los agrupa hasta los 16 kilobytes. El algoritmo de Nagle retrasa segmentos TCP pequeños hasta que se confirma el anterior. Para un flujo de chunks pequeños, esto añade decenas de milisegundos a cada uno.
  8. Librería cliente. requests de Python lee todo el cuerpo en memoria si no se pasa stream=True. Varios clientes HTTP bufferean hasta el tamaño de chunk_size.

Ocho puntos. Si al menos uno acumula datos, verás el flujo a sacudidas o en un solo gran bloque al final. Y lo más desagradable: el comportamiento depende del volumen. Con respuestas pequeñas todo parece normal, pero bajo carga o con respuestas largas el buffer se llena, se activa la escritura en archivos temporales y las latencias se disparan. No sorprende que muchos equipos descubran el problema solo en producción.

HTTP/1.1 frente a HTTP/2 en el contexto del streaming

En HTTP/1.1 una conexión es una respuesta por unidad de tiempo. Una respuesta de larga duración ocupa toda la conexión. El navegador limita el número de conexiones simultáneas a un mismo host a seis, por eso seis streams SSE abiertos bloquean el resto de peticiones a ese host. Un proxy que habla HTTP/1.1 con el backend también mantiene una conexión por cada stream.

En HTTP/2 la multiplexación elimina esta limitación: cien flujos viven en una sola conexión TCP. Pero aparece una sutileza: el control de flujo a nivel de protocolo. Si el receptor no amplía la ventana mediante WINDOW_UPDATE, el emisor se detiene. Algunos proxies implementan el reenvío de estas tramas con poca delicadeza y crean pausas artificiales.

Es importante entender: un proxy puede recibir una petición HTTP/2 del cliente e ir al backend por HTTP/1.1. Reempaqueta las tramas DATA en chunks y viceversa. Es una operación normal, pero justo en la frontera de la conversión suele perderse el flush oportuno: el proxy espera a acumular un tamaño "cómodo" de trama.

Los timeouts, el segundo asesino de streams

El buffering retrasa los datos. Los timeouts cortan la conexión. En nginx existe proxy_read_timeout: el tiempo máximo entre dos operaciones de lectura consecutivas del backend, por defecto 60 segundos. Si el servidor calla más de un minuto, nginx cierra la conexión y devuelve un 504 al cliente. Para un long-polling con espera de 90 segundos, es un fallo garantizado. En HAProxy están timeout server y timeout tunnel. En los balanceadores en la nube, el idle timeout, a menudo de 60 o 350 segundos. En los operadores móviles, los timeouts NAT que tiran conexiones inactivas en unos minutos.

De ahí la regla de hierro: un stream sin actividad periódica está condenado. Los mensajes heartbeat cada 15-30 segundos no son una opción, son un requisito obligatorio de cualquier respuesta de larga duración.

Matriz de selección de mecanismo

Antes de pasar a la práctica, fijemos el marco de decisión. Responde cuatro preguntas.

  • ¿Controlas toda la cadena de proxies? Sí: sirven chunked y SSE. No, hay puertas de enlace desconocidas en la cadena: empieza por long-polling o prevé una degradación a él.
  • ¿Quién es el cliente? Un navegador: SSE con EventSource brinda reconexión gratis. Código propio: chunked con NDJSON es más flexible.
  • ¿Cuál es la naturaleza de los datos? Fragmentos de una misma entidad (tokens de una misma respuesta): chunked o SSE. Eventos discretos e independientes: SSE o long-polling.
  • ¿Cuál es la frecuencia? Decenas de eventos por segundo: chunked o SSE con batching. Un evento por minuto: long-polling con timeout grande o SSE con heartbeat.

Método 1: chunked transfer encoding — el stream de bajo nivel sin envoltorio

Cuándo elegir chunked puro

El stream chunked puro es apropiado cuando el cliente es tu propio código y no un navegador; cuando el formato de los datos no es textual o no encaja en el modelo de eventos; cuando necesitas el máximo control sobre cada byte. Ejemplos típicos: streaming NDJSON desde una API, entrega en streaming de resultados de scraping, descarga de exportaciones grandes con indicador de progreso, proxy de respuestas de LLM en un formato propio.

Configuración paso a paso del lado del servidor

  1. Asegúrate de que la aplicación escribe por partes. Tras cada porción lógica, llama a flush. En Python con servidor ASGI es un generador que entrega bytes; en Node.js, res.write seguido de flush si hay compresión; en Go, la interfaz http.Flusher después de cada Write.
  2. No fijes Content-Length. La mayoría de los frameworks cambian solos a chunked si no se especifica la longitud. Verifica que en la respuesta por HTTP/1.1 aparezca Transfer-Encoding: chunked.
  3. Desactiva la compresión a nivel de aplicación para rutas de streaming o asegúrate de que hace flush junto con los datos. El compromiso es gzip con flush sincrónico tras cada chunk; funciona, pero reduce el ratio de compresión.
  4. Establece el encabezado X-Accel-Buffering: no. Es un encabezado específico de nginx que desactiva el buffering para una respuesta concreta sin modificar la configuración global. También lo entienden algunos otros proxies. Añade además Cache-Control: no-cache, no-transform; el segundo valor pide a los nodos intermedios que no modifiquen el cuerpo.
  5. Configura el proxy inverso. Para nginx, en el location de la ruta de streaming: proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;. La directiva proxy_http_version 1.1 es obligatoria: por defecto nginx se comunica con el backend por HTTP/1.0, donde chunked no existe, y nginx se ve forzado a buffear hasta que se cierre la conexión.
  6. Separa las rutas. Si necesitas compresión para el resto de la API, actívala solo en bloques location que no sean de streaming.
  7. Revisa el algoritmo de Nagle. En nginx tcp_nodelay está activado por defecto, pero en la aplicación, con chunks pequeños y frecuentes, puede ser necesaria la activación explícita de TCP_NODELAY en el socket.

Configuración de HAProxy y Envoy

HAProxy. En la sección backend no uses option http-buffer-request. Asegúrate de que timeout server sea lo bastante grande para tu escenario, y para flujos realmente largos define timeout tunnel. Desactiva la compresión para rutas de streaming mediante ACL o confía en el encabezado no-transform: HAProxy respeta Cache-Control: no-transform y no comprime esas respuestas.

Envoy. El buffering está desactivado por defecto, lo cual es una alegría. Pero revisa dos timeouts: stream_idle_timeout en el HTTP connection manager (por defecto cinco minutos) y el route timeout (por defecto quince segundos, y es el que más suele cortar los streams). Para rutas de streaming pon el timeout en 0s, lo que significa sin límite, y confía en el idle timeout combinado con heartbeat.

Checklist de verificación del chunked stream

  • En la respuesta hay Transfer-Encoding: chunked, o se usa HTTP/2 sin Content-Length.
  • El encabezado X-Accel-Buffering: no está presente en la respuesta de la aplicación.
  • Content-Encoding no está o la compresión hace flush junto con los datos.
  • El primer byte del cuerpo llega dentro del segundo siguiente a los encabezados.
  • Los intervalos entre chunks en el cliente coinciden con los intervalos de generación en el servidor con un margen de hasta 50 milisegundos.
  • La conexión dura más de un minuto sin cortarse si hay heartbeat.
  • En los logs del proxy no hay registros de buffering en archivo temporal.

Método 2: Server-Sent Events — el estándar para eventos del servidor al cliente

Cómo está armado el formato

SSE es una convención sobre cómo colocar eventos en un flujo de texto. La respuesta tiene Content-Type: text/event-stream. Cada evento es un conjunto de líneas con la forma "campo: valor", terminando en una línea vacía. Los campos son: data — la carga útil (puede repetirse, las líneas se concatenan con salto de línea); event — el nombre del tipo de evento; id — el identificador para reanudar; retry — el retardo recomendado de reconexión en milisegundos. Una línea que empieza con dos puntos es un comentario, y es el heartbeat ideal: el navegador lo ignora y el proxy ve actividad en la conexión.

La belleza de SSE está en su asimetría. La complejidad se delega a la especificación y al navegador, y el servidor queda trivial. Sin handshake, sin framing binario. Simplemente texto que fluye. Por eso SSE se convirtió en el estándar de facto para el streaming de respuestas de modelos de lenguaje: la gran mayoría de las APIs de LLM entregan tokens en formato text/event-stream. Sorprende que una tecnología descrita en las especificaciones hace más de quince años viva en 2026 un segundo apogeo.

Por qué SSE es especialmente sensible al buffering

Un evento SSE pesa desde unas decenas de bytes hasta un par de kilobytes. El buffer de nginx por defecto es de 4 u 8 kilobytes para el primer bloque y ocho bloques de 4-8 kilobytes después. Es decir, el proxy acumulará entre cincuenta y varios cientos de eventos antes de entregar el primero. Para un chat con el modelo, esto se ve así: el usuario espera quince segundos y luego todo el párrafo aparece de golpe. La ilusión del tecleo quedó destruida, y para eso precisamente se implementó el streaming.

Implementación paso a paso de SSE a través de proxy

  1. Encabezados de respuesta: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no y, para HTTP/1.1, también Connection: keep-alive.
  2. Heartbeat. Envía una línea de comentario como : ping cada 15-25 segundos. Es menos que cualquier idle timeout razonable y mantiene frescas las tablas NAT de los operadores.
  3. Identificadores de eventos. Asigna a cada evento un id creciente de forma monótona. Al reconectar, el navegador enviará el encabezado Last-Event-ID y el servidor podrá reenviar lo perdido. Sin esto, cualquier corte en el proxy es pérdida de datos.
  4. Campo retry. Establece un valor razonable, por ejemplo 3000 milisegundos, para que los clientes no armen una tormenta de reconexiones si el servidor se reinicia.
  5. Configuración de nginx — la misma que para chunked. Además, asegúrate de que para text/event-stream no se aplique gzip: si gzip_types incluye text/*, añade un location aparte con gzip off.
  6. Planificación de conexiones. Cada stream SSE abierto en HTTP/1.1 es una conexión aparte entre el proxy y el backend. Para mil clientes simultáneos hacen falta mil conexiones. Usa HTTP/2 del lado del cliente y un servidor asíncrono en el backend.
  7. Manejo del cierre. El servidor debe detectar que el cliente cortó la conexión y detener la generación. A través del proxy esto ocurre con retraso: el servidor se entera del corte solo al intentar escribir. Para operaciones caras como la inferencia de un modelo, son segundos extra de uso de GPU. La solución son escrituras regulares de heartbeat que provoquen un error de escritura si la conexión está cortada.

SSE y HTTP/2: matices

A través de HTTP/2, SSE funciona sin la limitación de seis conexiones, y esa es la razón principal para activar HTTP/2 en el proxy frontal. Sin embargo, al traducir HTTP/2 a HTTP/1.1 hacia el backend, algunos proxies añaden un pequeño retraso por la agregación de tramas. Asegúrate de que el primer evento salga de inmediato y no espere a completar una trama. Si el backend también habla HTTP/2, los retrasos son mínimos, pero verifica que el proxy reenvíe correctamente los WINDOW_UPDATE y no ahogue el flujo con el control de ventana.

Marco de diseño del flujo SSE

  1. Define los tipos de eventos y su frecuencia. Los eventos raros requieren heartbeat; los frecuentes, batching de varias escrituras dentro de un evento.
  2. Elige la estrategia de reanudación: guardar un buffer circular de los últimos eventos en el servidor para manejar Last-Event-ID o confiar en una resincronización completa al reconectar.
  3. Fija un límite de duración de cada flujo. Es buena práctica que el servidor cierre el flujo cada 5-10 minutos y que el cliente reconecte sin notarlo. Esto protege contra la acumulación de estado y sortea timeouts ocultos de la infraestructura.
  4. Piensa en la degradación: si el flujo no pasa por el proxy, cambia automáticamente a long-polling.

Método 3: long-polling — un stream hecho de respuestas normales en secuencia

Cómo funciona y por qué sigue siendo relevante

Long-polling es la técnica más antigua de las tres. El cliente envía una solicitud, el servidor no responde de inmediato, sino que espera a un evento hasta un timeout dado (normalmente 20-60 segundos). Apareció un evento: el servidor entrega la respuesta y la cierra. No apareció nada: entrega una respuesta vacía. El cliente envía de inmediato la siguiente solicitud. Visto desde fuera, parece un stream con latencia mínima, pero cada respuesta es normal, con Content-Length, totalmente compatible con cualquier proxy, cualquier caché y cualquier puerta de enlace.

¿Por qué en 2026 long-polling sigue vivo y coleando? Porque pasa por todas partes. Por puertas de enlace corporativas que cortan chunked. Por gateways API en la nube con límite de tiempo de respuesta. Por servidores proxy con buffering impredecible. El ejemplo más conocido es el método de obtención de actualizaciones del Bot API de un mensajero importante, donde el parámetro timeout define la duración de la espera. La gran mayoría de los bots lleva años funcionando así, a través de los proxies más variados, y sin problemas.

Cinco reglas de diseño de long-polling a través de proxy

  1. El timeout del servidor debe ser menor que el timeout más corto de la cadena. Si el proxy tiene proxy_read_timeout 60 segundos, la espera en el servidor no debe pasar de 50. Si hay un gateway en la nube con 30 segundos, no más de 25. De lo contrario, en lugar de una respuesta vacía el cliente recibirá un 504 y el flujo de errores volverá loco al monitoreo.
  2. Cursor u offset. El cliente transmite el identificador del último evento recibido. El servidor entrega todo lo aparecido después. El protocolo se vuelve idempotente: una respuesta perdida simplemente provoca la reemisión de los mismos eventos.
  3. Jitter al reconectar tras un error. Crecimiento exponencial del retardo —1, 2, 4, 8 segundos— más un añadido aleatorio. Sin jitter, mil clientes golpearán el servidor a la vez tras un fallo.
  4. Cero pausa tras una respuesta exitosa. La siguiente solicitud sale de inmediato. Cualquier pausa aquí es latencia perdida.
  5. Keep-alive obligatorio. Sin él, cada solicitud es una nueva conexión TCP y un nuevo handshake TLS. Esto añade entre 50 y 300 milisegundos a cada ciclo, y a través de un proxy remoto, aún más.

Implementación paso a paso

  1. Servidor: el endpoint acepta offset y timeout, espera un evento en una cola interna o por suscripción, responde con un arreglo de eventos y el nuevo offset. Un arreglo vacío es una respuesta normal, no un error.
  2. Proxy: configuración estándar, pero proxy_read_timeout no menor que el timeout del servidor más diez segundos de margen. El buffering puede quedar activado: la respuesta es corta y completa.
  3. Cliente: bucle que maneja tres desenlaces: datos, respuesta vacía, error. Pool de conexiones único, keep-alive, timeout de cliente mayor que el del servidor.
  4. Monitoreo: proporción de respuestas vacías, tiempo medio de espera, frecuencia de 5xx y timeouts de cliente.

Cuándo el long-polling pierde

Con alta frecuencia de eventos, el costo de los encabezados y del ciclo solicitud-respuesta se vuelve notable. Con miles de clientes, el servidor necesita mantener miles de solicitudes en espera; sin un stack asíncrono no se puede. Y, por supuesto, long-polling es incómodo para hacer streaming de una sola respuesta larga donde se necesita una secuencia de fragmentos de una misma entidad. Los tokens de un modelo de lenguaje vía long-polling son teóricamente posibles, en la práctica torpes.

Método 4: consumir respuestas de streaming a través de un proxy de salida

Particularidades del escenario

Hasta ahora mirábamos con los ojos del dueño del servidor. Ahora demos vuelta la escena: tú eres el cliente, accedes a la API en streaming de un tercero a través de un servidor proxy, y solo depende de ti el lado del cliente. Tareas típicas: recolección de datos de APIs en streaming a través de un pool de direcciones, trabajo con streaming de LLM desde scripts de automatización, distribución de carga sobre una API entre distintas IP, seguimiento de eventos en plataformas en tiempo real, pruebas de tu propio servicio desde distintas redes.

Aquí importan tres cosas. El propio proxy debe dejar pasar de forma transparente las respuestas chunked. La librería cliente debe leer el stream a medida que llega. Y debes poder distinguir un problema del proxy de un problema del servidor de destino.

Verificar que el proxy es transparente para el stream

  1. Toma un endpoint claramente de streaming: un servicio público de pruebas que entregue líneas con retardo, o tu propio endpoint con un calendario conocido de chunks.
  2. Ejecuta la solicitud directamente y a través del proxy con curl usando el flag -N (desactiva el buffering de salida del propio curl) y el flag --trace-time para marcas de tiempo. Compara los momentos de llegada de los fragmentos.
  3. Si a través del proxy todos los fragmentos llegan en un solo bloque al final, el proxy bufferea por completo. Si llegan en porciones de varios kilobytes, bufferea parcialmente. Si coinciden con la solicitud directa, es transparente.
  4. Prueba un flujo largo (5-10 minutos) con heartbeat. Un corte tras un tiempo fijo delata el idle timeout del proxy.
  5. Prueba HTTPS. A través de un proxy con método CONNECT se crea un túnel y el proxy no parsea el HTTP interior: no puede haber buffering a nivel HTTP, solo retardos TCP. Es una de las razones por las que las APIs de streaming a través de un túnel CONNECT suelen funcionar más parejo que a través de un proxy HTTP normal que parsea las solicitudes.

Un matiz sobre los proxies móviles: la red celular ya añade jitter por sí sola y el NAT de los operadores cierra agresivamente las conexiones inactivas. Para flujos largos a través de un proxy móvil, un heartbeat cada 15-20 segundos es una necesidad. La rotación de IP según un calendario debe tener en cuenta los flujos abiertos: cambiar de dirección en medio de una conexión SSE la corta garantizadamente. Coordina la rotación con el ciclo de vida de los flujos: cerraste el flujo, cambiaste de dirección, abriste uno nuevo con el cursor.

Librerías cliente: qué activar

  • Python, requests: stream=True en la llamada y luego iter_lines o iter_content con un chunk_size pequeño. Define el timeout como una tupla (connect, read), donde read es el tiempo admisible entre chunks, no el tiempo total de la respuesta.
  • Python, httpx: client.stream y aiter_lines para código asíncrono; para SSE, envoltorios especializados que parsean el formato de eventos.
  • Python, aiohttp: response.content.iter_any entrega los datos exactamente como llegaron del socket, sin reempaquetar: ideal para medir intervalos reales.
  • Node.js: fetch leyendo response.body como ReadableStream; para SSE, librerías que parsean el formato.
  • Go: el http.Client habitual, leyendo resp.Body con bufio.Scanner con un tamaño de buffer suficiente para eventos grandes.

En todos los casos: no llames a métodos que leen el cuerpo completo —text, json, read sin argumentos—. De lo contrario, el cliente esperará el cierre de la conexión y culparás al proxy de un buffering que no existe.

Protocolo de diagnóstico de "tres puntos"

Cuando el flujo se comporta raro, mide el tiempo hasta el primer byte y la distribución de intervalos entre chunks en tres configuraciones: directamente al servidor desde la misma máquina; a través del proxy al servidor; a través del proxy a un endpoint de streaming de referencia. La comparación localiza el problema sin ambigüedad. A través del proxy al de referencia va bien, pero al servidor de destino va mal: la culpa es de la infraestructura del servidor de destino. Al de referencia va mal: la culpa es del proxy. Directamente también va mal: la culpa es de tu código o de la red. Este protocolo toma diez minutos y ahorra días de discusiones.

Errores típicos al trabajar con streams a través de proxy

  1. Desactivaron proxy_buffering y se olvidaron del gzip. El error más frecuente. El flujo formalmente no se bufferea, pero la compresión acumula datos hasta el tamaño de la ventana. Síntoma: sacudidas de varios kilobytes.
  2. Dejaron proxy_http_version 1.0. nginx por defecto se comunica con el backend por HTTP/1.0, donde chunked no existe, y se ve obligado a esperar el cierre de la conexión. Síntoma: toda la respuesta llega al final.
  3. No envían heartbeat. El flujo vive justo hasta el primer idle timeout de la cadena: 60 segundos en nginx, 15 en Envoy por ruta, unos minutos en NAT. Síntoma: cortes a intervalos idénticos.
  4. Timeout de long-polling mayor que el del proxy. El cliente recibe un 504 en vez de una respuesta vacía, el monitoreo se pone en rojo y los eventos pueden duplicarse.
  5. Confiar en la configuración global del proxy. Al mudar a un entorno nuevo o al cambiar de CDN, el streaming se rompe en silencio. La solución es X-Accel-Buffering y no-transform a nivel de respuesta: el comportamiento lo define la aplicación, no el administrador del proxy.
  6. Sin Last-Event-ID ni cursores. Cualquier corte es pérdida de datos. A través de un proxy los cortes ocurren notablemente más seguido que directamente.
  7. Leer el cuerpo completo en el cliente. Se olvidó stream=True, el cliente espera el cierre y el desarrollador culpa al proxy.
  8. Rotación de IP durante un flujo abierto. La conexión se rompe, no hay reconexión y los datos se pierden.
  9. Probar con respuestas cortas. El buffer no alcanza a llenarse y todo se ve perfecto. En producción, con respuestas largas, se activa la escritura en archivo temporal y las latencias se disparan.
  10. Mezclar rutas de streaming y rutas normales en un mismo location. O rompes el streaming, o pierdes compresión y buffering para las respuestas normales, lo que golpea el rendimiento de toda la API.
  11. Ignorar que el cliente cortó la conexión. A través del proxy el servidor se entera tarde del corte y sigue con la generación costosa. Para inferencia de LLM, eso es dinero directo.
  12. Usar chunked donde hace falta long-polling. A través de una puerta de enlace corporativa o un gateway API en la nube con límite de respuesta, el stream no pasa, y long-polling pasa sin problema.

Herramientas y recursos para configurar y diagnosticar

Proxies inversos y balanceadores

  • nginx — el referente en flexibilidad. Directivas clave: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, soporte del encabezado X-Accel-Buffering.
  • HAProxy — buffering mínimo de fábrica. Vigila timeout server, timeout tunnel y la compresión.
  • Envoy — hace streaming por defecto. Críticos: route timeout y stream_idle_timeout.
  • Caddy — no bufferea por defecto; flush_interval con valor -1 fija el flush inmediato de forma explícita.
  • Traefik — transmite los streams de forma transparente; los timeouts se configuran a nivel de entrypoints.

Diagnóstico

  • curl con los flags -N, -v y --trace-time muestra los momentos de llegada de cada fragmento. El parámetro -w con las variables time_starttransfer y time_total da el tiempo hasta el primer byte y el tiempo total.
  • tcpdump y Wireshark — para verificar si los bytes salen con retardo a nivel de red o se retienen más arriba.
  • mitmproxy — visualización de flujos preservando la estructura de chunks. Activa obligatoriamente el modo streaming, o él mismo se convertirá en punto de buffering.
  • Herramientas de desarrollo del navegador — la pestaña EventStream para SSE muestra cada evento con su marca de tiempo.

Endpoints de prueba y librerías

Los servicios públicos para probar HTTP tienen endpoints que entregan un número dado de líneas con retardo: son ideales para verificar la transparencia de un proxy. Un servidor mínimo propio en cualquier lenguaje, que entregue un chunk por segundo con marca de tiempo, es incluso mejor: controlas ambos lados. Para SSE en el servidor, prácticamente cualquier framework asíncrono tiene una clase de respuesta lista para text/event-stream. Para SSE en el cliente fuera del navegador existen parsers del formato para Python, Node.js y Go. Para long-polling no se necesitan librerías especiales: basta un cliente HTTP con pool de conexiones.

Monitoreo

Métricas que vale la pena recolectar: tiempo hasta el primer byte del cuerpo; distribución de intervalos entre chunks en los percentiles 50, 95 y 99; duración de los flujos y motivo de cierre; número de flujos activos en el proxy y en el backend; proporción de reconexiones con Last-Event-ID. Un aumento brusco del intervalo entre chunks junto con un aumento del volumen es señal clara de que se activó el buffering.

Casos y resultados: cómo se ve esto en proyectos reales

Caso 1. Streaming de LLM a través de nginx: de 11 segundos a 310 milisegundos

Un equipo implementó un chat basado en un modelo de lenguaje. Localmente los tokens aparecían suavemente. Tras el despliegue detrás de nginx, los usuarios veían una pantalla vacía durante 8-12 segundos y luego toda la respuesta de golpe. El diagnóstico por el protocolo de "tres puntos" mostró: directamente contra la aplicación, el primer token llegaba a los 280 milisegundos; a través de nginx, a los 11 segundos. Causas clásicas: proxy_buffering on y proxy_http_version 1.0 por defecto. Tras añadir proxy_buffering off, proxy_http_version 1.1, gzip off para la ruta y el encabezado X-Accel-Buffering: no en la respuesta de la aplicación, el tiempo hasta el primer token a través del proxy quedó en 310 milisegundos. Hallazgo colateral: al cerrar la pestaña, la inferencia continuaba hasta el final de la respuesta. Tras implementar heartbeat con verificación del error de escritura, el consumo de tiempo de GPU en solicitudes abandonadas bajó cerca de una cuarta parte.

Caso 2. Panel con SSE y redes móviles

Un servicio de monitoreo entregaba eventos por SSE. En internet cableado todo funcionaba, pero desde dispositivos móviles los flujos se cortaban a los 2-4 minutos sin errores en el servidor. Causa: los timeouts NAT de los operadores sobre conexiones inactivas. Solución: un comentario de heartbeat cada 20 segundos más un cierre forzado del flujo por el servidor cada 10 minutos con Last-Event-ID correcto. Las quejas de "panel congelado" cayeron casi a cero, la duración media del flujo continuo subió de 3 a 10 minutos (limitada ya por el cierre intencional) y no se registraron pérdidas de eventos en la reconexión.

Caso 3. Scraping de una API en streaming a través de un pool de proxies móviles

Un equipo recolectaba eventos de una plataforma que entrega datos en flujo NDJSON a través de un pool de proxies móviles. Se observaban dos problemas: parte de los flujos llegaba a sacudidas de 8 kilobytes y otra parte se cortaba con la rotación de dirección. Las pruebas mostraron que para solicitudes sin cifrar el proxy parseaba el HTTP y buffereaba las respuestas, mientras que a través de un túnel CONNECT a un endpoint HTTPS dejaba pasar el flujo de forma transparente. El paso a HTTPS resolvió el primer problema por completo. El segundo se cerró con sincronización: la rotación de IP se ejecuta solo tras el cierre correcto del flujo y la reconexión va con el cursor del último evento. La completitud de los datos recolectados subió de aproximadamente 91 a 99,7 por ciento.

Caso 4. Bot en long-polling a través de una puerta de enlace restrictiva

Un desarrollador tenía un bot en una infraestructura donde las solicitudes salientes pasaban por una puerta de enlace corporativa con límite de respuesta de 30 segundos. Al principio se usaba un timeout de espera de 60 segundos: la mitad de las solicitudes terminaba con error de la puerta de enlace y las actualizaciones se duplicaban. Tras bajar el timeout a 25 segundos y añadir jitter exponencial ante errores, la proporción de errores cayó del 48 a menos del 0,5 por ciento. La latencia media de entrega de eventos no cambió: la define el momento del evento, no la duración de la espera.

Caso 5. Paso a HTTP/2 para SSE

Una aplicación web abría 3-4 flujos SSE por pestaña. Con varias pestañas abiertas, el navegador agotaba el límite de seis conexiones y las solicitudes normales se ponían en cola detrás de los flujos. Activar HTTP/2 en el proxy frontal pasó todos los flujos a una sola conexión. El tiempo de carga de la página con cinco pestañas abiertas bajó de 9 a 1,5 segundos. Hallazgo colateral: tras el cambio hubo que aumentar stream_idle_timeout, porque los ajustes anteriores estaban pensados para HTTP/1.1.

FAQ: preguntas profundas sobre respuestas en streaming a través de proxy

¿En qué se diferencia fundamentalmente el HTTP en streaming del WebSocket desde el punto de vista del proxy?

WebSocket requiere un upgrade de protocolo: el proxy debe reconocer los encabezados Upgrade y Connection, pasar a modo túnel y dejar de parsear HTTP. El HTTP en streaming no requiere nada: es una respuesta normal que tarda mucho en terminar. La paradoja es que WebSocket a través de un proxy o funciona o no funciona en absoluto, mientras que el HTTP en streaming siempre "funciona", pero puede funcionar mal: los datos llegan, pero con retraso. Por eso los problemas con los streams son más difíciles de notar y diagnosticar.

¿Por qué X-Accel-Buffering: no no siempre ayuda?

El encabezado lo entiende nginx y los proxies compatibles. Una CDN, un gateway en la nube o un proxy de otro tipo lo ignorarán. Además, X-Accel-Buffering no afecta al gzip: la compresión hay que desactivarla aparte. Y si entre la aplicación y nginx hay una capa que elimina encabezados no estándar, no llegará hasta nginx.

¿Se puede comprimir una respuesta en streaming?

Técnicamente sí: gzip soporta flush sincrónico y el servidor puede comprimir cada chunk con entrega inmediata. El ratio de compresión cae, porque el diccionario no alcanza a llenarse. En la práctica, para SSE y tokens de LLM se desactiva la compresión: ahorrar unos pocos por ciento de tráfico no justifica el riesgo de retrasos. Para flujos de objetos JSON grandes, la compresión con flush puede dar una ganancia notable.

¿Cómo elegir entre SSE y long-polling?

Si el cliente es un navegador, los eventos llegan más seguido que cada pocos segundos y controlas al menos el proxy inverso: SSE. Si en la cadena hay nodos no controlados con límites de tiempo de respuesta, los eventos son raros o necesitas máxima compatibilidad: long-polling. Los sistemas maduros implementan ambas variantes y cambian automáticamente según el resultado de la primera conexión.

¿Influye HTTP/3 en el problema del buffering?

HTTP/3 funciona sobre QUIC y elimina el bloqueo de cabeza de cola a nivel de transporte, pero el buffering está más arriba, en la lógica del proxy. Un proxy con HTTP/3 en la entrada y HTTP/1.1 en la salida bufferea exactamente igual. Lo que sí cambia es el comportamiento en redes móviles: QUIC sobrevive mejor a los cambios de red y a las pérdidas, por eso los flujos por HTTP/3 se cortan menos del lado del cliente.

¿Cómo saber si bufferea el proxy de salida y no el servidor de destino?

Con el método de "tres puntos": la misma solicitud directamente, a través del proxy y a través del proxy a un endpoint de streaming de referencia. Además, prueba HTTPS con CONNECT: si el flujo se vuelve parejo, el proxy parseaba y buffereaba el HTTP sin cifrar.

¿Qué intervalo de heartbeat conviene elegir?

Menor que el timeout más corto de la cadena, con el doble de margen. Para una infraestructura típica, 15-25 segundos; para redes móviles, más cerca de 15. Un heartbeat demasiado frecuente es tráfico extra y carga sobre miles de conexiones; demasiado espaciado, cortes.

¿Qué hacer si el flujo debe vivir horas?

No hacerlo. Diseña un cierre forzado por el servidor cada 5-15 minutos con un cursor para reanudar. Esto protege contra la acumulación de memoria, fugas y timeouts invisibles, y además simplifica el despliegue: reinicias los servidores sin pensar en conexiones de horas.

¿Cómo influye el proxy en la detección de la desconexión del cliente?

Entre el cliente y el servidor ahora hay dos conexiones. Cuando el cliente se desconecta, el proxy se entera de inmediato, pero al servidor se lo comunica en el siguiente intento de escritura o según sus propias reglas. El servidor notará el corte solo al escribir. De ahí la práctica de escrituras regulares de heartbeat para detectar temprano la ruptura y detener operaciones costosas.

¿Hace falta una configuración especial del proxy móvil para streams?

Desde el lado del usuario, el proxy en sí normalmente no se configura. Pero hay que: preferir HTTPS para un túnel transparente; coordinar la rotación de IP con el ciclo de vida de los flujos; mantener un heartbeat no más espaciado que 15-20 segundos; usar keep-alive y pool de conexiones; y verificar cada pool por transparencia antes de lanzar a producción.

Conclusión: resumen y próximos pasos

El HTTP en streaming no es una excentricidad ni un protocolo aparte. Es una respuesta normal que no tiene prisa por cerrarse. Precisamente por eso es tan vulnerable ante los nodos intermedios: el proxy no ve nada especial y aplica reglas pensadas para respuestas cortas. El buffering retrasa los datos, los timeouts cortan la conexión, la compresión enmascara el buffering, y todo eso en ocho puntos distintos de la cadena.

Los tres mecanismos —chunked, SSE y long-polling— resuelven una misma tarea con distinto grado de dependencia de la transparencia del proxy. Chunked da el máximo control a cambio de manejar todo del lado del cliente. SSE da un modelo de eventos listo y reconexión en el navegador, pero exige atención a cada nodo. Long-polling pasa por lo que sea, pero paga con el costo de solicitudes frecuentes. La elección la determinan cuatro preguntas: si controlas la cadena, quién es el cliente, cuál es la naturaleza de los datos y cuál es su frecuencia.

Qué hacer ya hoy:

  1. Recorre el mapa de los ocho puntos de buffering para tu infraestructura y marca cuáles controlas.
  2. Añade en las respuestas de las rutas de streaming X-Accel-Buffering: no y Cache-Control: no-cache, no-transform, independientemente de la configuración actual del proxy.
  3. Revisa proxy_http_version, proxy_buffering, gzip y proxy_read_timeout en nginx o sus equivalentes en tu proxy. Separa las rutas de streaming en bloques aparte.
  4. Implementa heartbeat al menos cada 25 segundos y cierre forzado del flujo cada 5-15 minutos con cursor.
  5. Si consumes flujos de terceros a través de un proxy, corre el protocolo de "tres puntos" en cada pool de direcciones y pasa las solicitudes de streaming a HTTPS.
  6. Configura monitoreo del tiempo hasta el primer byte y de los intervalos entre chunks. Es la única manera de enterarte del buffering antes que los usuarios.

El proxy no es enemigo del stream. Bien configurado, añade al flujo tolerancia a fallos, distribución de carga y protección del backend. La tarea es solo explicarle: esta respuesta es especial, hay que entregarla tal como llega. Ahora tienes todo para que esa explicación suene en su idioma.