Tiempos de espera del cliente HTTP a través de proxy: connect, read, write y el presupuesto total de la solicitud
Contenido del artículo
- Introducción: por qué los tiempos de espera a través de proxy merecen una conversación aparte
- Fundamentos: qué es un timeout y de qué fases se compone una solicitud
- Inmersión profunda: qué ocurre físicamente cuando se activa cada timeout
- Método 1: configurar el connect timeout considerando dos saltos
- Método 2: read timeout como intervalo de inactividad y protección del primer byte
- Método 3: write timeout y trabajo con cuerpos de solicitud grandes
- Método 4: presupuesto total de la solicitud y propagación del plazo
- Método 5: observabilidad de timeouts y configuración adaptativa
- Errores típicos: qué no hay que hacer
- Herramientas y recursos
- Casos y resultados
- Faq: preguntas complejas sobre timeouts a través de proxy
- Conclusión: los timeouts como disciplina de ingeniería
Introducción: por qué los tiempos de espera a través de proxy merecen una conversación aparte
Imagínate esto: tu scraper lleva tres días funcionando, consume tráfico de proxies móviles, y a la salida tienes la mitad de los registros vacíos y los logs llenos de palabras como timeout, connection reset y remote end closed connection. ¿Te suena? Hemos visto decenas de sistemas así, y casi siempre la raíz del problema es la misma: los tiempos de espera están configurados «a ojo» — un número mágico como 30 segundos para todo a la vez. Por conexión directa esto más o menos funciona. A través de proxy, sobre todo móvil, ya no.
La cosa es que el proxy agrega a la cadena otro tramo de red, otro conjunto de colas y otro nodo que tiene sus propios tiempos de espera. La solicitud no pasa por una sola fase de espera, sino por cinco o seis, y en cada una se puede «colgar» por razones distintas. Un límite general no distingue dónde exactamente te quedaste atascado: en el handshake TCP con el proxy, en el establecimiento del túnel hacia el sitio destino, en el lento primer byte de la respuesta o en la transmisión de un cuerpo grande.
Este artículo trata sobre la arquitectura de la espera. Vamos a desglosar de qué fases se compone una solicitud HTTP a través de proxy, qué timeout responde por cada fase, qué ocurre físicamente cuando se activa, y cómo armar un presupuesto total coherente a partir de límites individuales. Es importante separarnos de inmediato de un tema adyacente: aquí no discutimos códigos de respuesta 429 o 503 ni estrategias de reintentos con retroceso exponencial. Esa es una capa aparte: la reacción a que el servidor ya respondió. Aquí hablamos de situaciones en las que no hay respuesta alguna, y de cuánto tiempo estamos dispuestos a esperarla en cada nivel.
Después de leer esto podrás: descomponer cualquier solicitud en fases y asignarle a cada una su propio límite; explicar por qué el cliente mostró un timeout y el servidor igual ejecutó la acción; coordinar correctamente los tiempos de espera del cliente, del pool de conexiones y del propio proxy; y, sobre todo, dejar de perder datos y dinero en esperas inútiles.
Fundamentos: qué es un timeout y de qué fases se compone una solicitud
El timeout como contrato de espera
Timeout es el tiempo máximo que el cliente acepta esperar a que ocurra un evento determinado antes de reconocer el intento como fallido y liberar recursos. La palabra clave aquí es determinado. No existe el concepto de «timeout de solicitud en general». Existe timeout para establecer la conexión TCP, timeout para el handshake TLS, timeout para esperar datos del socket, timeout para escribir en el socket, timeout para esperar una conexión libre en el pool y, finalmente, el plazo total de toda la operación.
Una buena analogía es un viaje con transbordos. Tienes tiempo para llegar a la estación, tiempo de espera del tren, tiempo de viaje, tiempo de transbordo. Y existe un límite total: a las nueve de la mañana debes estar en la reunión. Si solo controlas el límite total, te enterarás del problema cuando ya llegaste tarde. Si controlas cada etapa, puedes tomar decisiones de antemano: por ejemplo, tomar un taxi porque el autobús no llegó en diez minutos.
Fases de una solicitud HTTP por conexión directa
Incluso sin proxy, una solicitud es una secuencia de pasos:
- Resolución de nombre (DNS). El cliente convierte un nombre de dominio en una dirección IP. Normalmente toma de milisegundos a cientos de milisegundos, pero con problemas en el resolver puede colgarse segundos.
- Conexión TCP. Handshake de tres vías: SYN, SYN-ACK, ACK. Requiere una vuelta completa (RTT) hasta el servidor.
- Handshake TLS para HTTPS. Una o dos vueltas más según la versión del protocolo.
- Envío de la solicitud (write). Cabeceras y cuerpo se escriben en el socket. Para solicitudes pequeñas es instantáneo; para subir archivos, un tiempo notable.
- Espera del primer byte de respuesta (TTFB). El servidor piensa: hace consultas a la base de datos, renderiza la página, llama a sus microservicios.
- Lectura del cuerpo de la respuesta (read). Los datos llegan en porciones; entre porciones hay pausas.
Qué agrega el proxy
El proxy rompe esta cadena en dos partes. El cliente establece conexión con el servidor proxy, y el proxy establece la conexión con el nodo destino. Para HTTPS a través de proxy HTTP se usa el método CONNECT: el cliente le pide al proxy abrir un túnel TCP hasta el host y puerto, el proxy responde con estado 200, y solo entonces el cliente inicia el handshake TLS ya con el servidor destino a través del túnel. Para SOCKS5 la lógica es análoga: hay una fase de saludo y autenticación con el proxy, luego el comando de establecer conexión con el destino, luego la espera de confirmación.
Resulta una lista ampliada de fases:
- Resolución DNS de la dirección del proxy (si está especificado como dominio).
- Conexión TCP con el proxy.
- Autenticación y comando de establecer túnel (CONNECT o solicitud SOCKS).
- Espera de que el proxy resuelva el nombre del host destino y establezca conexión TCP con él — esta fase ocurre del lado del proxy, pero el cliente la espera.
- Handshake TLS con el servidor destino a través del túnel.
- Envío de la solicitud HTTP.
- Espera del primer byte de respuesta.
- Lectura del cuerpo.
Presta atención al cuarto punto. Ahí está la principal trampa de los proxies móviles. El servidor proxy en sí normalmente está en un centro de datos, y la conexión TCP hasta él se establece en decenas de milisegundos. Pero luego el tráfico sale a través del módem celular, donde el RTT es de 40–120 milisegundos, y con una estación base congestionada salta a medio segundo o más. La resolución de nombre y el handshake con el destino en ese tramo fácilmente ocupan uno o dos segundos. Un cliente que considera «connect timeout» solo hasta el proxy estará seguro de que la conexión se estableció al instante, y luego se topará con una espera inexplicable en el paso siguiente.
Inmersión profunda: qué ocurre físicamente cuando se activa cada timeout
Configurar el número es solo la mitad. Mucho más importante es entender en qué estado queda el sistema después de que el límite se activó. Desglosemos por fases.
Activación del connect timeout
El cliente envió un SYN y no recibió SYN-ACK en el tiempo asignado. El sistema operativo por su cuenta reintenta el SYN con esquema exponencial: 1, 2, 4, 8 segundos y así, sumando hasta 60–120 segundos por defecto en los kernels populares. Tu connect timeout interrumpe esa espera antes. El socket se cierra, no se enviaron datos al servidor, el estado del lado remoto no cambió. Es el tipo de timeout más seguro: reintentar este intento se puede sin preocuparse por la idempotencia.
A través de proxy la imagen es un poco más compleja. Si el TCP con el proxy está establecido pero se colgó la fase CONNECT, el cliente ya le envió el comando al proxy y espera el estado. Al activarse, el cliente cierra el socket hacia el proxy. El proxy notará el cierre y, por regla general, interrumpirá su intento de conectar con el destino. Pero no siempre al instante: algunas implementaciones primero esperan su propio timeout de upstream y solo luego liberan recursos. Para el cliente esto es invisible, pero en el servidor proxy se acumulan conexiones semiabiertas, lo que con carga masiva reduce su capacidad de rendimiento.
Matiz importante: en distintas bibliotecas cliente la fase CONNECT se contabiliza de forma diferente. En unas queda dentro del connect timeout, en otras no queda cubierta por nada excepto el plazo total de la solicitud. Si no tienes un plazo total y CONNECT se colgó, la solicitud puede quedar colgada indefinidamente. Verificar esto no es complicado: dirige el cliente a un proxy que acepte TCP pero no responda al CONNECT (puede servir de stub un servidor TCP común sin lógica) y observa en cuántos segundos el cliente se rinde.
Activación del TLS handshake timeout
El túnel TCP a través del proxy está abierto, el cliente envió el ClientHello y el ServerHello no llegó. Causas: canal de módem lento, pérdida de paquete en el tramo móvil, servidor destino congestionado que acepta TCP pero no alcanza a procesar TLS. Al activarse, el socket se cierra, la solicitud HTTP aún no se envió, el estado en el servidor no cambió. También es seguro para reintentar.
Observación práctica: por canales móviles el handshake TLS es un punto frecuente de demoras, porque requiere varias vueltas consecutivas, y cada paquete perdido agrega un segundo de retransmisión. Con el paso a TLS 1.3 la cantidad de vueltas disminuyó, lo que redujo notablemente la proporción de estos timeouts.
Activación del write timeout
El cliente escribe el cuerpo de la solicitud en el socket, pero el búfer de envío está lleno y no se libera: el lado remoto no lee o no confirma la recepción. Al activarse, parte de los datos ya podría haber llegado al servidor. Si es una subida de archivo o el envío de un formulario, el servidor podría haber recibido un fragmento. Normalmente un cuerpo incompleto produce un error de parseo del lado del servidor, pero para protocolos de streaming y subidas de varias partes las consecuencias dependen de la implementación. Reintentar tal solicitud requiere cuidado.
Activación del read timeout
Aquí comienza lo más interesante y lo más peligroso. La solicitud se envió completa. El cliente espera datos, y no llegan en el intervalo asignado. El cliente cierra el socket y lanza una excepción. Pero ¿qué ocurre en el otro extremo?
El proxy ve que el cliente cerró la conexión. Un buen proxy en ese momento cerrará también la conexión upstream hacia el servidor destino. Pero el servidor destino ya recibió la solicitud y ya la está procesando. Si es un POST que crea un pedido, debita un saldo o envía un mensaje, la acción con alta probabilidad se ejecutará. El servidor se enterará de la desconexión solo cuando intente escribir la respuesta y reciba un error. Para ese momento la transacción en la base de datos hace rato que terminó.
Esta es una propiedad fundamental del read timeout: te dice que no esperaste la respuesta, pero no te dice nada sobre si la acción se ejecutó. Por eso para operaciones no idempotentes el read timeout debe manejarse distinto que el connect timeout, y por eso las APIs serias exigen claves de idempotencia.
Otro matiz: dónde exactamente te quedaste atascado. El read timeout se activa tanto al esperar el primer byte (el servidor piensa) como en una pausa entre porciones del cuerpo (el servidor entrega datos en flujo con demoras). Muchas bibliotecas interpretan el read timeout como intervalo de inactividad entre dos lecturas exitosas del socket, y no como tiempo total de lectura. Esto significa que una respuesta de cientos de megabytes que llega a un kilobyte por segundo nunca activará un read timeout de 10 segundos: los datos llegan con regularidad. Sin un plazo total, tal solicitud puede quedar colgada horas.
Qué ve el proxy y qué devuelve
El proxy tiene sus propios tiempos de espera, y estos generan otros síntomas. Si el proxy no logró conectar con el destino en su límite, devolverá al cliente una respuesta al CONNECT con estado 502 o 504 — y desde el punto de vista del cliente no es timeout, sino error del proxy. Si el proxy esperó respuesta del destino y no la recibió, también puede devolver 504 Gateway Timeout dentro de la respuesta HTTP (para HTTP normal sin túnel). Y si el proxy tiene un límite de inactividad en el túnel y se activó, el cliente verá una desconexión repentina — connection reset o respuesta vacía — sin ningún timeout de su parte.
De ahí la regla: el timeout del cliente debe estar coordinado con los timeouts del proxy. Si el proxy corta el túnel a los 60 segundos de inactividad y tu read timeout es de 90 segundos, nunca verás el timeout: verás cortes misteriosos. Si el proxy da 30 segundos para conectar con el destino y tu límite en esa fase es de 10 segundos, te rendirás antes y no sabrás que el proxy podría haber llegado a tiempo.
Método 1: configurar el connect timeout considerando dos saltos
Teoría: qué cubre y qué debería cubrir
El connect timeout limita el establecimiento de la conexión de transporte. A través de proxy esto nos plantea la pregunta: ¿conexión con quién? Formalmente, con el proxy. Prácticamente, nos importa cuándo obtendremos un túnel listo hasta el destino. Por eso recomendamos pensar en dos límites separados, aunque la biblioteca dé un solo parámetro.
Límite del primer salto — TCP hasta el servidor proxy. El proxy está en un centro de datos, el RTT hasta él es estable. Referencia: 5–8 RTT, pero no menos de 2 segundos ni más de 5. Si el proxy no responde al SYN en 3 segundos, está congestionado o inaccesible, y esperar más es inútil; mejor cambiar a otra dirección del pool.
Límite del segundo salto — tiempo desde el envío del CONNECT hasta recibir el estado 200. Aquí trabaja el canal móvil. La referencia depende de dónde esté el destino y de la calidad de la red celular: típicamente 3–10 segundos. Hemos observado que el percentil 95 del tiempo de establecimiento de túnel vía LTE hacia sitios populares cabe en 1,5–2,5 segundos, y el percentil 99 en 4–6 segundos. Poner un límite por debajo del percentil 99 significa perder cada centésima solicitud por iniciativa propia.
Cómo medir tus valores
- Arma una muestra de al menos 500 solicitudes a través de tu proxy hacia los hosts destino en distintos momentos del día.
- Registra por separado el tiempo hasta establecer TCP con el proxy, el tiempo hasta la respuesta al CONNECT y el tiempo del handshake TLS. La mayoría de los clientes saben entregar estas métricas: en curl son las variables time_connect y time_appconnect, en Go son hooks de httptrace, en clientes de Python son eventos de traza o mediciones alrededor de las fases.
- Construye la distribución. Te interesan p50, p95, p99 y el máximo.
- Establece el límite al nivel de p99 más un margen de 30–50 por ciento. No en el máximo: siempre hay valores atípicos, y ajustarse a ellos significa mantener recursos para anomalías aisladas.
- Revísalos cada trimestre o al cambiar de operador, región o tarifa de proxy.
Práctica en distintos clientes
En la biblioteca de Python requests el timeout se define con una tupla donde el primer valor es connect y el segundo read. A través de proxy el primer valor cubre el TCP hasta el proxy y, por regla general, la espera de respuesta al CONNECT, ya que el túnel se establece sobre el mismo socket con el mismo límite. Ejemplo:
resp = session.get(url, proxies=proxies, timeout=(5, 20))En httpx hay un objeto Timeout aparte con cuatro campos: connect, read, write y pool. Es el modelo más claro entre los clientes de Python:
timeout = httpx.Timeout(connect=5.0, read=20.0, write=10.0, pool=3.0)En curl hay dos flags clave: --connect-timeout define el límite de establecimiento de conexión, incluidos CONNECT y TLS, y --max-time es el techo total. En Go el timeout de armado de TCP se define con Dialer en Transport, TLS con TLSHandshakeTimeout, y la fase CONNECT se limita con el contexto de la solicitud. En Java HttpClient connectTimeout se configura en el builder del cliente, y el límite de solicitud en la propia solicitud. En Node.js con undici hay connectTimeout, headersTimeout y bodyTimeout, más AbortSignal para el plazo total.
Checklist del connect timeout
- Valor no menor a 2 ni mayor a 10 segundos para proxy de centro de datos y móvil respectivamente.
- Sabes con certeza si tu cliente cubre la fase CONNECT con este límite.
- Al activarse, cambias a otro proxy del pool en lugar de insistir con el mismo.
- Se tiene en cuenta que el SO reintenta el SYN por su cuenta — tu límite debe ser más corto que el del sistema.
- Para hosts IPv6 está habilitado el fallback a IPv4 (Happy Eyeballs), de lo contrario una ruta IPv6 fallida se comerá todo el límite.
Método 2: read timeout como intervalo de inactividad y protección del primer byte
Dos tareas distintas bajo un mismo nombre
El read timeout resuelve dos tareas, y conviene separarlas mentalmente, aunque la biblioteca dé un solo parámetro.
Espera del primer byte. Es el tiempo de trabajo del servidor sobre tu solicitud. Para páginas estáticas, decenas de milisegundos. Para resultados de búsqueda de un marketplace con filtros, de medio segundo a varios segundos. Para APIs pesadas con reportes, decenas de segundos. A través de proxy móvil se suma la latencia del canal en el camino de vuelta.
Pausa entre porciones del cuerpo. El servidor ya entrega datos, pero con interrupciones: genera la página por partes, hace streaming del resultado o simplemente choca con un canal estrecho. Aquí importa no el tamaño total, sino el silencio máximo.
Algunos clientes tienen parámetros separados. En Go es ResponseHeaderTimeout para el primer byte de cabeceras y mecanismos aparte para el cuerpo. En undici, headersTimeout y bodyTimeout. En la mayoría de los clientes de Python un solo read timeout funciona como intervalo de inactividad en cualquier etapa de la lectura.
Cómo elegir el valor
- Determina el carácter de las respuestas destino. Una página HTML y un JSON en streaming requieren límites distintos.
- Mide el TTFB a través de tu proxy. Toma p99 y multiplícalo por 1,5. Para scraping web típico a través de canal móvil resultan 8–15 segundos.
- Mide la pausa máxima entre chunks en una muestra de respuestas exitosas. Normalmente es varias veces menor que el TTFB: 1–3 segundos. Si el cliente lo permite, define bodyTimeout por separado y más estricto.
- Nunca confíes en el read timeout como protección contra entrega lenta. Para eso está el plazo total (Método 4).
Qué hacer cuando se activa
Aquí surge la pregunta principal: ¿se puede reintentar? La respuesta depende del método y la semántica:
- GET, HEAD, OPTIONS — se puede reintentar, el estado del servidor no cambió (si el sitio no viola la semántica del protocolo).
- PUT con cuerpo completo, DELETE — formalmente idempotentes, el reintento es seguro.
- POST sin clave de idempotencia — el reintento puede crear un duplicado. Reacción correcta: no reintentar a ciegas, sino primero verificar el estado con otra solicitud o marcar la operación como «resultado desconocido» para conciliación posterior.
- POST con clave de idempotencia — reintentar es seguro, el servidor devolverá el resultado de la primera ejecución.
Recomendamos encarecidamente distinguir en logs y métricas read timeout antes del primer byte y read timeout en medio del cuerpo. El primero suele indicar congestión del servidor destino o del proxy; el segundo, problemas de canal. Se tratan de forma distinta: en el primer caso ayuda reducir el paralelismo, en el segundo, cambiar de proxy o región.
Particularidad de los canales móviles
La red celular trabaja con latencia variable. El módem puede «congelarse» uno o dos segundos al cambiar entre sectores de la estación base o al salir del modo de ahorro de energía. Desde el punto de vista del cliente esto parece silencio en el socket. Si tu read timeout es de 2 segundos, capturarás falsos positivos varias veces por hora en cada módem. Hemos observado que subir el límite de 3 a 6 segundos reducía la proporción de timeouts en proxies móviles 4–5 veces sin un aumento notable del tiempo medio de solicitud. Los segundos de inactividad en solicitudes raras salen más baratos que las solicitudes repetidas y el tráfico perdido.
Checklist del read timeout
- El valor se basa en el p99 de TTFB medido a través de tu proxy, no en la intuición.
- Entiendes que el límite es un intervalo de inactividad, no el tiempo total de lectura.
- Para solicitudes no idempotentes, al activarse no hay reintento automático sin verificación.
- En las métricas están separados los timeouts antes del primer byte y dentro del cuerpo.
- El valor es menor que el idle timeout del túnel del lado del proxy.
Método 3: write timeout y trabajo con cuerpos de solicitud grandes
Cuándo la escritura puede colgarse
Para la mayoría de las solicitudes el cuerpo cabe en un segmento TCP y sale al instante: la escritura termina incluso antes de que los datos abandonen físicamente la máquina. El write timeout se vuelve relevante en tres casos: subida de archivos, envío de arreglos JSON grandes y cualquier transmisión por un canal estrecho. El proxy móvil es justamente ese canal estrecho en dirección saliente: la velocidad típica de subida desde un módem es notablemente menor que la de bajada, y los búferes en nodos intermedios son limitados.
La mecánica es así: el cliente llama a la escritura, los datos entran en el búfer de envío del socket, el kernel los envía en porciones a medida que recibe confirmaciones. Si las confirmaciones no llegan, el búfer se llena y la siguiente escritura se bloquea. El write timeout limita el tiempo de ese bloqueo.
Tres estrategias para cuerpos grandes
Estrategia A: límite general de escritura. Enfoque simple: un write timeout para toda la solicitud. Sirve para cuerpos de hasta varios megabytes. El valor se elige a partir de la estimación: tamaño del cuerpo dividido por la velocidad mínima aceptable, más margen. Por ejemplo, 5 megabytes a una velocidad mínima de 500 kilobytes por segundo son 10 segundos; con margen, 15.
Estrategia B: límite por porción. El cliente escribe el cuerpo en chunks y limita el tiempo de cada escritura. Así funciona la mayoría de los clientes asíncronos: ahí el write timeout significa la pausa máxima al enviar una porción. Valor: 3–10 segundos, independientemente del tamaño del archivo. La protección contra entrega lenta recae por completo en el plazo total.
Estrategia C: control de velocidad. El cliente monitorea la velocidad real de subida e interrumpe la solicitud si cae por debajo de un umbral durante N segundos. En curl para esto hay el par de flags --speed-limit y --speed-time. Es la herramienta más precisa: distingue «lento pero avanza» de «atascado».
Qué ocurre cuando se activa
Parte del cuerpo ya está en el servidor. Si subías un archivo en una sola solicitud, el servidor recibirá un cuerpo truncado. Para el protocolo multipart esto normalmente llevará a un error de parseo y rechazo completo, lo cual es seguro. Para APIs con soporte de subidas reanudables (tus, protocolos por chunks de almacenamiento en la nube), la reacción correcta es pedirle al servidor el offset y continuar desde ahí. Justamente las subidas reanudables las recomendamos para cualquier cuerpo superior a 10 megabytes a través de proxies móviles: una sola solicitud larga por canal celular es demasiado vulnerable a cortes.
Configuración paso a paso para subidas a través de proxy
- Estima la velocidad media y mínima de subida a través de tu proxy. Sube un archivo de prueba de 5–10 megabytes veinte veces en distintos momentos.
- Si la variación de velocidad supera el triple, usa la Estrategia B o C, no el límite general.
- Divide los archivos grandes en partes de 1–5 megabytes, si el servicio destino lo soporta.
- Establece el write timeout por porción en 5–10 segundos.
- Compleméntalo obligatoriamente con un plazo total para toda la solicitud, calculado a partir del tamaño y la velocidad mínima.
- Cuando se active, determina qué alcanzó a recibir el servidor, en lugar de repetir todo desde cero.
Método 4: presupuesto total de la solicitud y propagación del plazo
Por qué la suma de límites individuales no es todavía un presupuesto
Supongamos que pusiste connect 5, TLS 5, write 10, read 15 segundos. Parece que la solicitud no puede durar más de 35 segundos. Pero el read timeout es un intervalo de inactividad. Una respuesta que llega a un kilobyte cada 14 segundos nunca lo violará. Una solicitud de 10 megabytes a ese ritmo tomará casi un día. Sin un límite total tus workers estarán ocupados indefinidamente, el pool de conexiones se agotará y el sistema se detendrá, aunque ningún timeout individual se haya activado.
El presupuesto total (deadline, total timeout) es el techo absoluto para toda la operación, desde la primera llamada al sistema hasta el último byte leído. No reemplaza los límites individuales, los complementa: los límites individuales dan diagnóstico rápido y preciso; el total da la garantía de finalización.
Cómo calcular el presupuesto
Vamos de arriba hacia abajo, no al revés. Empieza con la pregunta: ¿cuál es el tiempo máximo de espera de un resultado aceptable para la tarea de negocio? Para un escenario interactivo (el usuario espera), 3–10 segundos. Para scraping en segundo plano, 30–60 segundos. Para subir archivos grandes, se calcula según el tamaño.
Luego este presupuesto se distribuye por fases según las distribuciones medidas:
- Establecimiento del túnel a través del proxy (TCP más CONNECT más TLS): típicamente 15–25 por ciento del presupuesto.
- Escritura de la solicitud: 5–10 por ciento para solicitudes normales.
- Espera del primer byte: 30–40 por ciento.
- Lectura del cuerpo: el resto.
Ejemplo: presupuesto de 30 segundos para scraping a través de proxy móvil. Connect (incluido CONNECT) 6 segundos, TLS 4 segundos, write 3 segundos, read como intervalo de inactividad 10 segundos, plazo total 30 segundos. La suma de los límites individuales, 23 segundos, es menor que el presupuesto: es normal, se activan por separado. El plazo total atrapa los casos de entrega lenta que ningún límite individual capturará.
Propagación del plazo a través de la cadena
En sistemas distribuidos la solicitud rara vez es única. Tu servicio recibió una tarea con límite de 30 segundos, gastó 4 segundos en preparación, luego va a través del proxy al sitio destino. ¿Cuánto tiempo tiene la solicitud HTTP? No 30, sino 26 segundos menos el margen para procesar la respuesta. Esto es la propagación del plazo: cada llamada subsecuente recibe no un timeout fijo, sino el resto del presupuesto.
En Go esto se implementa con un contexto con deadline que se pasa a la solicitud. En Python, con asyncio y transmisión explícita del tiempo restante. En Java, calculando un Duration antes de cada llamada. La regla es una: el timeout de la solicitud HTTP se calcula dinámicamente como el mínimo entre el límite estático y el presupuesto restante.
Sin esto surge el problema clásico: el nivel superior ya se negó a esperar y devolvió un error, mientras el inferior sigue diez segundos más manteniendo la conexión a través del proxy y consumiendo tráfico por un resultado que ya no le importa a nadie. Con el tráfico de pago de proxies móviles, esto es literalmente quemar dinero.
El pool de conexiones y sus propios timeouts
Hay dos límites más que suelen olvidarse. Pool timeout: cuánto esperar una conexión libre del pool si todas están ocupadas. Si no está definido, ante un pico de carga las solicitudes esperarán indefinidamente, y por fuera esto parece un cuelgue del cliente. Pon 1–3 segundos: si en ese tiempo no se liberó una conexión, el sistema está sobrecargado y es mejor rechazar de inmediato.
Idle timeout de la conexión en el pool: cuánto se guarda una conexión keep-alive sin usar antes de cerrarla. Aquí es crítico coordinarlo con el proxy. Si el proxy cierra una conexión inactiva a los 60 segundos y tu pool la guarda 90 segundos, en el segundo 61 tomarás del pool un socket muerto, le enviarás una solicitud y recibirás connection reset — no un timeout, sino una desconexión. Muchas bibliotecas reintentan la solicitud de forma transparente en esa situación, pero solo para métodos idempotentes. Regla: el idle timeout del cliente debe ser estrictamente menor que el idle timeout del proxy, con un margen de al menos 10–20 por ciento.
Marco de trabajo «presupuesto de arriba hacia abajo»
- Fija la restricción de negocio sobre el tiempo de espera del resultado.
- Resta el tiempo de tu propio procesamiento y el margen para reintento, si está previsto.
- El resto obtenido es el plazo total de la solicitud HTTP.
- Distribúyelo por fases según el p99 medido de cada fase a través de tu proxy.
- Verifica que cada límite individual sea menor que el límite correspondiente del lado del proxy.
- Define el pool timeout y el idle timeout del pool, coordinados con el proxy.
- Implementa la transmisión del presupuesto restante a las llamadas anidadas.
- Registra qué límite exacto se activó y el tiempo gastado en cada fase.
Método 5: observabilidad de timeouts y configuración adaptativa
Sin mediciones no hay configuración
Todos los métodos anteriores chocan con una cosa: debes conocer las distribuciones reales de tiempo por fase a través de tu proxy. La única forma de saberlo es medir constantemente. Los clientes modernos ofrecen hooks de traza: momento de inicio del DNS, establecimiento de TCP, recepción de la respuesta al CONNECT, finalización de TLS, envío de la solicitud, primer byte, último byte. Reúne estos eventos en métricas desglosadas por proxy, host destino y tipo de error.
Qué métricas recolectar
- Histogramas de duración de cada fase, separados por endpoint de proxy y operador.
- Proporción de activaciones de cada tipo de timeout respecto del total de solicitudes.
- Proporción de timeouts antes del primer byte frente a dentro del cuerpo.
- Proporción de desconexiones sin timeout (señal de límites idle no coordinados).
- Tiempo promedio gastado en solicitudes que terminaron en timeout: es tu pérdida directa en tráfico y recursos.
Timeouts adaptativos
La tendencia de los últimos años, que para 2026 se volvió estándar en sistemas maduros, son los límites adaptativos. En lugar de un número estático, el cliente mantiene una ventana móvil de observaciones por cada par proxy-destino y establece el timeout como el p99 de la ventana con un coeficiente de margen, limitado por arriba y por abajo con bordes razonables. Cuando el canal se deteriora, el límite sube y hay menos falsos positivos. Cuando el canal se recupera, el límite baja y el sistema reacciona más rápido a problemas reales.
La implementación no es complicada: un búfer circular de 200–500 últimas mediciones por clave, recálculo del cuantil cada pocos segundos, bordes tipo «no menos de 3 ni más de 20 segundos para read». Es importante protegerse de la degradación: si todas las solicitudes empiezan a dar timeout, la ventana se llena de valores al nivel del límite y el límite solo crecerá. Por eso en la ventana entran solo solicitudes exitosas, y el crecimiento del límite está acotado por el borde superior.
Solicitudes con cobertura especulativa (hedged requests)
Para lectura a través de un pool de varios proxies hay una técnica que reduce la influencia de las colas lentas sin aumentar los timeouts: si una solicitud no terminó en el tiempo p95, enviar un duplicado a través de otro proxy y tomar la primera respuesta que llegue. Esto aumenta el tráfico en unos pocos por ciento, pero reduce radicalmente el p99 de latencia. Sirve solo para solicitudes idempotentes y requiere cancelar con cuidado el duplicado perdedor para no gastar tráfico en vano.
Errores típicos: qué no hay que hacer
Un solo número para todo
El error más común. Un timeout único de 30 segundos significa que detectarás un proxy muerto en medio minuto, y una respuesta lenta en medio del cuerpo nunca la detectarás. Separa las fases.
Ausencia de timeouts por defecto
Varias bibliotecas populares no tienen timeouts de fábrica: la solicitud puede quedar colgada indefinidamente. En requests esto sigue siendo así. Cualquier llamada sin timeout explícito a través de proxy es un worker potencialmente bloqueado para siempre.
Read timeout mayor que el límite idle del proxy
No verás timeouts, verás desconexiones de conexión y buscarás el problema donde no está. Averigua los límites de tu proveedor de proxy y configura el cliente estrictamente por debajo.
Reintento ciego tras read timeout en un POST
Camino directo a pedidos duplicados, cargos dobles y mensajes repetidos. Tras un read timeout en una solicitud no idempotente el resultado es desconocido: hay que resolverlo, no adivinar.
Ignorar la fase CONNECT
Suponer que el connect timeout cubre el establecimiento del túnel sin verificarlo en la documentación de la biblioteca concreta. En algunos clientes la fase CONNECT queda colgada hasta el plazo total, y si no lo hay, indefinidamente.
Ajustar al máximo
Viste una solicitud de 45 segundos y pusiste el límite en 60. Ahora cada problema real te cuesta un minuto de espera. Guíate por el p99 con margen, y los valores atípicos déjalos al mecanismo de reintento o cobertura especulativa.
Timeout sin cancelación del trabajo subyacente
El nivel superior lanzó una excepción por su límite, pero la solicitud HTTP sigue viva en una tarea en segundo plano. Error especialmente frecuente en código asíncrono: el wrapper con espera terminó, pero la corrutina no fue cancelada. Asegúrate de que la activación del timeout provoque el cierre real del socket.
Límites idénticos para proxies de centro de datos y móviles
La diferencia en latencia y jitter entre ellos es de varias veces. Un perfil que funciona en un proxy de servidor, en uno móvil genera una lluvia de falsos timeouts. Mantén perfiles de configuración separados.
Ausencia de pool timeout
Ante un pico de carga las solicitudes esperan indefinidamente una conexión libre. Por fuera: un cuelgue de todo el cliente con tráfico de red nulo.
Herramientas y recursos
Diagnóstico desde la línea de comandos
curl sigue siendo la herramienta de referencia para desglosar fases. Los flags --connect-timeout, --max-time, --speed-limit, --speed-time cubren todos los niveles, y el formato de salida -w con variables de tiempo muestra cuánto tomó cada fase:
curl -x http://user:pass@proxy:port --connect-timeout 5 --max-time 30 -o /dev/null -s -w "dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}" https://example.com/Ojo: a través de proxy la variable time_connect muestra el tiempo hasta el proxy, y time_appconnect hasta la finalización de TLS con el destino, es decir, incluye el CONNECT. La diferencia entre ambas es tu segundo salto.
Bibliotecas cliente y sus modelos de timeout
- Python requests: tupla (connect, read). No tiene write ni timeout total; el total se implementa con un wrapper externo o cancelación a nivel de hilo.
- Python httpx: objeto Timeout con connect, read, write, pool. No tiene total, pero en modo asíncrono se agrega fácilmente con una espera con límite y cancelación.
- Python aiohttp: ClientTimeout con campos total, connect, sock_connect, sock_read. El único entre los clientes populares de Python con límite total incorporado.
- Go net/http: Dialer.Timeout, TLSHandshakeTimeout, ResponseHeaderTimeout, ExpectContinueTimeout, IdleConnTimeout en el transporte; Client.Timeout como total; contexto de la solicitud como plazo dinámico.
- Java HttpClient: connectTimeout en el cliente, timeout en la solicitud (cubre hasta recibir las cabeceras). La lectura del cuerpo se limita a nivel de BodyHandler o con un wrapper.
- Node.js undici: connectTimeout, headersTimeout, bodyTimeout, keepAliveTimeout; el total, mediante AbortSignal.timeout.
Análisis de tráfico
tcpdump y Wireshark permiten ver qué ocurrió realmente en el cable: si salió el SYN, si llegó el SYN-ACK, quién envió primero FIN o RST. Es la única forma de responder con certeza a la pregunta «¿quién rompió la conexión: yo, el proxy o el servidor?». Para el contenido HTTPS la visibilidad es limitada, pero las fases de conexión y túnel se ven por completo.
Entornos de reproducción
Para verificar el comportamiento del cliente ante cuelgues es útil tener un conjunto de stubs: un servidor TCP que acepta conexión y calla (verificación de connect y CONNECT); un servidor HTTP que responde con cabeceras y luego calla (verificación de read hasta el cuerpo); un servidor que entrega un byte por segundo (verificación del plazo total). Escribir tales stubs toma media hora de trabajo, y el tiempo ahorrado en depuración en producción se mide en días. También existen herramientas de emulación de red que permiten agregar latencia, jitter y pérdidas en la interfaz, para imitar un canal móvil en laboratorio.
Observabilidad
Se volvió estándar la recolección de métricas y trazas en formato OpenTelemetry con instrumentación automática de clientes HTTP. Histogramas por fases, atributos con identificador del proxy y tipo de límite activado: conjunto mínimo sin el cual la configuración se convierte en adivinanza.
Casos y resultados
Caso 1: scraping de marketplace a través de proxies móviles
El equipo recolectaba fichas de producto a través de un pool de proxies móviles. Configuración inicial: timeout único de 15 segundos, sin plazo total, pool de conexiones estándar. Síntomas: 11 por ciento de las solicitudes terminaban con errores, de las cuales dos tercios eran timeouts y un tercio desconexiones de conexión. Duración promedio de una solicitud fallida: 14 segundos, es decir, cada décima solicitud consumía tiempo y tráfico en vano.
El diagnóstico por fases mostró: p99 de establecimiento de túnel, 4,8 segundos; p99 de TTFB, 6,2 segundos; pausa máxima entre chunks en respuestas exitosas, 2,1 segundos; idle timeout del túnel del proveedor, 60 segundos, y el pool del cliente guardaba conexiones 120 segundos.
Cambios: connect de 7 segundos cubriendo CONNECT, read de 9 segundos, write de 5 segundos, plazo total de 25 segundos, idle del pool de 45 segundos, pool timeout de 2 segundos. Separación de timeouts antes del primer byte y dentro del cuerpo en las métricas.
Resultado tras una semana: la proporción total de errores bajó al 3,4 por ciento, las desconexiones de conexión desaparecieron casi por completo, la duración promedio de una solicitud fallida cayó a 8 segundos. El consumo de tráfico por unidad de datos recolectados se redujo un 19 por ciento. No se hizo ningún cambio en la lógica de reintentos: solo los timeouts.
Caso 2: integración con API de pagos y duplicados
El servicio enviaba solicitudes POST para crear operaciones de pago a través de un proxy corporativo. Read timeout de 10 segundos y reintento automático ante cualquier excepción. Cada pocos días aparecían duplicados de operaciones. El análisis mostró: la API destino en momentos de carga respondía en 11–14 segundos, el cliente se caía por read timeout, reintentaba la solicitud, y ambas operaciones se ejecutaban con éxito.
La solución tuvo tres partes: read timeout subido a 20 segundos sobre la base del p99 medido de 15 segundos; el reintento tras read timeout en POST fue reemplazado por una consulta de estado de la operación por identificador de cliente; se introdujo una clave de idempotencia en la cabecera, que la API soportaba. Los duplicados cesaron por completo. Conclusión aparte del equipo: el read timeout en una solicitud no idempotente no es un error, sino un estado de «resultado desconocido» que requiere una rama de procesamiento aparte.
Caso 3: subida de archivos multimedia por canal móvil
La aplicación subía videos de 50–200 megabytes a través de proxies móviles en una sola solicitud. Write timeout de 30 segundos, sin plazo total. Síntomas: alrededor del 8 por ciento de las subidas se cortaban, cada fallo significaba reintentar desde cero, y el sobregasto diario de tráfico llegaba a decenas de gigabytes.
Transición a subida por chunks de 4 megabytes con reanudación, write timeout por chunk de 8 segundos, control de velocidad mínima de 100 kilobytes por segundo durante 10 segundos, plazo total por chunk de 60 segundos. La proporción de subidas completamente fallidas cayó al 0,3 por ciento, el sobregasto de tráfico en reintentos se redujo 12 veces, porque solo se reintentaba el último chunk fallido.
Caso 4: cuelgue del CONNECT sin plazo total
El recolector asíncrono en una de las bibliotecas de Python periódicamente se «congelaba»: los workers vivos, la red en silencio, la cola sin avanzar. Cada una o dos horas había que reiniciar el recolector manualmente. El análisis mostró: parte de los proxies del pool aceptaban TCP pero no respondían al CONNECT. En la configuración usada esa fase no estaba cubierta por ningún límite. La inclusión de un plazo total para toda la solicitud y de un límite explícito para el establecimiento del túnel eliminó los cuelgues. Adicionalmente se agregó un healthcheck de proxy con verificación específicamente de la fase CONNECT, y no solo de disponibilidad TCP.
FAQ: preguntas complejas sobre timeouts a través de proxy
¿En qué se diferencia el timeout del cliente de una respuesta 504 del proxy?
El timeout del cliente es tu decisión de dejar de esperar; el proxy y el servidor se enteran de ella solo por el cierre de la conexión. La respuesta 504 es una decisión del proxy: él mismo no esperó al servidor destino y te lo comunicó con una respuesta HTTP completa. En el primer caso el socket se cierra con excepción; en el segundo recibes una respuesta normal con código de error. Hay que manejarlos de forma distinta: 504 significa que el proxy está definitivamente vivo y el problema está más abajo en la cadena; el timeout del cliente no dice nada sobre dónde exactamente se atascó.
¿Por qué a través de proxy móvil se necesitan timeouts más largos que a través de uno de centro de datos?
Por el jitter. La latencia promedio del canal celular no es tan grande, pero su dispersión es enorme: cambios entre sectores, modos de ahorro de energía del módem, competencia por el recurso de radio. El timeout se configura según la cola de la distribución, y la cola del canal móvil es varias veces más larga. Al mismo tiempo, límites demasiado largos también son dañinos: retrasan la detección de proxies realmente muertos. El equilibrio se logra midiendo el p99 y agregando un margen del 30–50 por ciento, no duplicando todos los números.
¿Cómo saber qué timeout exacto se activó, si la biblioteca lanza una única excepción general?
Tres formas. Primera, por el tiempo: si la excepción llegó en un tiempo igual al connect timeout y no al read, conoces la fase. Segunda, mediante hooks de traza: si el evento «TLS completado» ocurrió pero «primer byte» no, te atascaste en el TTFB. Tercera, por el texto y el tipo de excepción: muchas bibliotecas distinguen ConnectTimeout y ReadTimeout como clases separadas. Recomendamos siempre registrar qué fases alcanzaron a completarse antes de la excepción: eso convierte un timeout misterioso en un diagnóstico preciso.
¿Se puede reintentar una solicitud tras activarse el write timeout?
Para GET sin cuerpo, sí, no salió nada. Para POST con cuerpo, solo si estás seguro de que el servidor rechaza cuerpos incompletos. La mayoría de los servidores lo hace: un JSON incompleto o un multipart truncado provocan error de parseo. Pero las APIs de streaming, que empiezan a procesar a medida que reciben datos, pueden aplicar cambios parcialmente. Si dudas, verifica el estado antes de reintentar.
¿Cómo coordinar los timeouts del cliente con los del proveedor de proxy?
Pídele al proveedor o busca en la documentación tres valores: límite de conexión con el host destino, idle timeout del túnel y tiempo máximo de vida de la conexión. Tu límite de establecimiento del túnel debe ser no menor que el del proveedor (de lo contrario te rindes antes de que el proxy pudiera llegar a tiempo), y tu read timeout e idle del pool, estrictamente menores que los idle del proveedor. Si no hay documentación, mide empíricamente: abre una conexión, espera N segundos en silencio, intenta enviar una solicitud, encuentra el umbral tras el cual llega la desconexión.
¿Hace falta un plazo total si todos los límites individuales están configurados?
Sí, obligatoriamente. Los límites individuales no limitan el tiempo total: una entrega lenta de cuerpo a un kilobyte con intervalo menor que el read timeout puede durar indefinidamente. El plazo total es la única garantía de que el worker se libere. Además, al propagar el presupuesto a través de una cadena de llamadas, justamente el plazo total es lo que se transmite hacia abajo, mientras los límites individuales quedan como configuración local.
¿Cómo influyen HTTP/2 y HTTP/3 en el modelo de timeouts a través de proxy?
HTTP/2 multiplexa muchas solicitudes en una sola conexión, por lo que el read timeout a nivel de socket deja de ser el timeout de una sola solicitud: el socket recibe datos de otros flujos, y la inactividad de una solicitud concreta no se nota. Se necesitan límites a nivel de flujo: la mayoría de los clientes HTTP/2 los ofrecen mediante el plazo de la solicitud. HTTP/3 sobre QUIC también cambia la fase de conexión: el handshake se combina con el criptográfico, y el connect timeout cubre ambos. A través de un proxy CONNECT clásico, HTTP/3 hacia el destino por regla general no pasa: el túnel está orientado a TCP, y el cliente retrocede a HTTP/2 o HTTP/1.1. Las extensiones para túneles UDP a través de proxy se están desarrollando, pero para 2026 su soporte en clientes masivos es limitado.
¿Qué hacer si después de un timeout la conexión vuelve al pool y la siguiente solicitud falla?
Es señal de que el cliente no cerró el socket correctamente o el pool no marcó la conexión como dañada. Una conexión en la que se activó un read timeout no se puede reutilizar: en ella pueden quedar bytes de una respuesta tardía que se leerán como respuesta a la siguiente solicitud. Asegúrate de que tu cliente, ante un timeout, cierre la conexión en lugar de devolverla al pool. En clientes bien diseñados este comportamiento es por defecto, pero con wrappers propios y trabajo de bajo nivel con sockets el error ocurre con regularidad.
¿Cómo configurar timeouts para proxy SOCKS5 a diferencia de proxy HTTP?
El principio es el mismo, cambian las fases: en lugar de CONNECT hay saludo, autenticación y comando de conexión, lo que suma dos o tres vueltas hasta el proxy más el tiempo de conexión del proxy con el destino. En la mayoría de los clientes el handshake SOCKS completo cae dentro del connect timeout. Asegúrate de que el valor contemple no solo el TCP hasta el proxy, sino también el tiempo de establecimiento de conexión del proxy con el destino a través del canal móvil: esos mismos 3–10 segundos.
Conclusión: los timeouts como disciplina de ingeniería
Resumamos. Una solicitud HTTP a través de proxy no es una sola operación, sino una cadena de siete u ocho fases de espera, cada una con su propia naturaleza de demoras y sus propias consecuencias ante un corte. Los timeouts de connect y TLS son seguros: nada salió hacia el servidor, se puede intentar de nuevo. El write timeout deja al servidor con datos incompletos. El read timeout es el más engañoso: la solicitud fue entregada y, quizás, ejecutada, y tú no lo sabes. El plazo total no reemplaza los límites individuales, sino que protege contra entregas lentas que ellos no capturan.
A través de proxies móviles todo esto se potencia: el segundo salto pasa por un canal con alto jitter, y los límites ajustados en proxies de servidor generan una lluvia de falsos positivos. La única forma de configurarlos bien es medir las distribuciones por fase a través de tu proxy concreto y poner límites según el p99 con margen, coordinándolos con los límites del propio proxy.
Tus próximos pasos:
- Encuentra en tu código cada llamada HTTP a través de proxy y verifica si tiene timeouts explícitos para todas las fases y un plazo total.
- Averigua si tu cliente cubre la fase CONNECT y cómo interpreta el read timeout: como inactividad o como tiempo total.
- Conoce los límites idle y de conexión de tu proveedor de proxy y alinea la configuración del cliente.
- Habilita la traza de fases y recolecta distribuciones durante una semana.
- Recalcula los límites según el p99, separa los perfiles para proxies de centro de datos y móviles.
- Separa el manejo de timeouts para solicitudes idempotentes y no idempotentes.
- Agrega a las métricas el tipo de límite activado y la fase en la que se activó.
Los timeouts no son un parámetro que se configura una vez y se olvida. Son parte del contrato de tu sistema con el mundo exterior, y como todo contrato requiere mediciones, revisión y acuerdo entre las partes. Hazlo una vez de forma sistemática y te sorprenderá cuánto más silenciosos se vuelven tus logs y cuánto más barato, tu tráfico.