asyncio en producción
Saber async/await lleva una tarde. Operar un servicio asíncrono lleva más, porque los problemas no son de sintaxis: son de tareas que no terminan, esperas sin límite y llamadas que bloquean el bucle. Este capítulo trata las cuatro herramientas que resuelven eso.
En una línea
Sección titulada «En una línea»En producción, la pregunta no es cómo lanzar tareas, es cómo asegurarte de que terminan.
Timeouts: el límite que no se negocia
Sección titulada «Timeouts: el límite que no se negocia»| Escenario | Tiempo |
|---|---|
| Sin timeout | 1.01 s |
Con asyncio.timeout(0.1) |
0.11 s |
TaskGroup con una tarea que falla a los 50 ms |
0.06 s |
python mediciones/06-05-08-async-produccion.py
asyncio.timeout cancela las tareas pendientes y propaga TimeoutError. Sin él, la petición espera lo que tarde la más lenta, y en un servicio eso es una conexión ocupada y un cliente colgado.
La regla: toda operación de red lleva timeout, en el cliente HTTP y en el bloque. El del cliente protege de un servidor lento; el del bloque, de una lógica que se atasca.
TaskGroup: concurrencia estructurada
Sección titulada «TaskGroup: concurrencia estructurada»async with asyncio.TaskGroup() as tg: tg.create_task(descargar(a)) tg.create_task(descargar(b))Tres garantías que gather no da:
- Si una tarea falla, las demás se cancelan (0,06 s en la medición, no 1 s).
- El bloque no termina hasta que todas terminan o se cancelan.
- Los errores se agrupan en un
ExceptionGroup, y se capturan conexcept*.
gather(..., return_exceptions=True) hace lo contrario: espera a todas y devuelve las excepciones como valores. Sirve cuando quieres todos los resultados aunque alguno falle; TaskGroup sirve cuando un fallo invalida el conjunto.
Limitar la concurrencia
Sección titulada «Limitar la concurrencia»Lanzar 10 000 tareas contra una API es un ataque de denegación de servicio hecho por ti mismo. El semáforo acota:
semaforo = asyncio.Semaphore(20)
async def limitada(url): async with semaforo: return await descargar(url)Veinte en vuelo, el resto esperando. Es el equivalente asíncrono de max_workers, y no tiene sustituto: sin él, el límite lo pone el servidor remoto, normalmente con un 429.
La llamada bloqueante
Sección titulada «La llamada bloqueante»async def manejador(): resultado = await asyncio.to_thread(consultar_sincrono, args)asyncio.to_thread (3.9+) mueve la llamada a un hilo y devuelve el control al bucle. Es la forma correcta de usar una biblioteca síncrona desde async, y el último recurso antes de reescribir el cliente.
Lo que no se hace: llamar directamente a la función síncrona. Bloquea el hilo del bucle, y con él todas las tareas.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si el equipo no lo opera. Un servicio asíncrono con llamadas bloqueantes es peor que uno síncrono con hilos.
- Si las dependencias son síncronas y no hay plan para migrarlas.
- Si el tráfico es bajo. Un pool de hilos de 10 resuelve 500 peticiones por segundo sin este vocabulario.
- Si el trabajo es de CPU. El bucle es un solo núcleo.
Ejercicio
Sección titulada «Ejercicio»Un servicio asíncrono consulta 20 APIs por petición. En producción se cuelga a veces y el CPU está al 5 %. Propón tres causas probables y cómo confirmarlas.
Solución
1. Una llamada bloqueante. Con el CPU bajo y las peticiones colgadas, el sospechoso número uno es una biblioteca síncrona (requests, psycopg2, lectura de archivo) que congela el bucle. Confirmación: py-spy dump sobre el proceso; si el hilo principal está en socket.recv de la biblioteca síncrona en lugar del selector del bucle, es eso.
2. Falta de timeout. Una de las 20 APIs deja de responder y la petición espera indefinidamente. Confirmación: métricas por API; la que no tiene latencia registrada es la culpable.
3. Concurrencia sin límite. 20 APIs por petición × 500 peticiones son 10 000 conexiones, y el cliente o el sistema operativo empiezan a encolar. Confirmación: contar tareas activas y conexiones abiertas.
El CPU al 5 % descarta el cálculo y confirma que el problema es de espera mal gestionada. El orden de intervención: timeouts primero (barato y elimina el síntoma), luego detectar la bloqueante, y por último el semáforo.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 21.
- CPython 3.13:
Lib/asyncio/taskgroups.py,Lib/asyncio/timeouts.py. - Mediciones:
mediciones/06-05-08-async-produccion.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 04 · asyncio: el modelo y el bucle.
- 06 · Colas: el patrón productor/consumidor en ambos mundos.
- 07 · Carreras: los fallos que la concurrencia introduce.