En una aplicación web, no todas las operaciones pueden completarse en unos cuantos milisegundos. Generar un reporte, procesar un video, importar miles de registros o consultar un servicio de inteligencia artificial son ejemplos de tareas cuya duración puede extenderse durante varios segundos o incluso minutos.
Cuando estas operaciones se ejecutan directamente dentro de una petición HTTP, el cliente debe esperar hasta que el servidor termine. Esto puede ocasionar tiempos de respuesta elevados, conexiones prolongadas y errores de timeout.
Una solución es implementar un patrón de procesamiento asíncrono de tareas, que permite separar la recepción de una solicitud de su ejecución, sin obligar al cliente a mantener una conexión abierta mientras se completa el trabajo.
1. El problema de las operaciones de larga duración
El modelo tradicional de comunicación HTTP sigue un ciclo relativamente sencillo:
- Un cliente envía una petición al servidor.
- El servidor ejecuta la operación solicitada.
- El servidor devuelve una respuesta con el resultado.
Este modelo es apropiado para operaciones rápidas, como consultar un producto, autenticar un usuario o recuperar información de una base de datos.
Sin embargo, consideremos una aplicación que permite generar reportes de ventas. El proceso podría requerir consultar millones de registros, realizar cálculos y construir un archivo PDF.
Si el servidor tarda 60 segundos en generar el documento, la petición HTTP debe permanecer abierta durante todo ese tiempo.
El problema es que distintas partes de la infraestructura pueden establecer límites de espera: el navegador, un proxy inverso, un balanceador de carga, el servidor de aplicaciones o algún servicio externo.
Si se supera alguno de estos límites, el cliente puede recibir un error aunque la operación continúe ejecutándose.
Aumentar los timeouts puede ser necesario en determinados escenarios, pero no siempre constituye una solución adecuada.
El problema fundamental es que la duración del trabajo está condicionando la duración de la petición HTTP.
2. El patrón de procesamiento asíncrono
Una forma de resolver este problema es desacoplar la solicitud del procesamiento.
Imaginemos una cafetería. Cuando un cliente pide una bebida, probablemente puede recibirla directamente en el mostrador. Pero si solicita sesenta postres y bebidas para llevar, sería poco práctico mantenerlo ahí esperando hasta que la cocina termine.
Una alternativa es recibir la orden, entregar un número de seguimiento y permitir que el cliente consulte cuándo estará lista.
En software podemos aplicar la misma idea.
En lugar de ejecutar toda la operación durante la petición HTTP, el servidor registra una tarea pendiente y devuelve inmediatamente un identificador. Posteriormente, otro proceso se encarga de ejecutarla.
Este diseño separa tres responsabilidades:
- Recepción: validar la solicitud y registrar el trabajo.
- Procesamiento: ejecutar la tarea independientemente de la petición original.
- Entrega: permitir al cliente recuperar el resultado o recibir una notificación.
La ejecución no necesariamente será más rápida, pero el cliente deja de depender de una conexión HTTP prolongada y el servidor puede gestionar mejor sus recursos.
Una distinción importante
En programación también utilizamos el término asíncrono para describir operaciones que no bloquean el hilo de ejecución, como sucede con async/await en JavaScript.
Sin embargo, utilizar async/await para consultar una API externa no significa que hayamos implementado procesamiento en segundo plano.
Si el servidor mantiene la petición HTTP abierta hasta que finaliza la operación, el cliente continúa esperando, aunque internamente la espera sea no bloqueante.
El patrón que estamos estudiando busca que el trabajo pueda continuar después de que haya terminado la petición HTTP original.
3. Colas de tareas, jobs y workers
Una arquitectura habitual para implementar este patrón utiliza tres componentes principales.
Jobs: las unidades de trabajo
Un job representa una tarea que el sistema debe ejecutar.
Por ejemplo, una aplicación puede generar un trabajo denominado GenerateSalesReport, acompañado de los parámetros necesarios para producir el reporte.
Generalmente, cada trabajo cuenta con un identificador y un estado que permite conocer su progreso.
Colas: organizar el trabajo pendiente
Una cola de tareas (task queue) almacena o distribuye trabajos que esperan ser ejecutados.
En lugar de procesar inmediatamente una solicitud, el servidor envía el trabajo a la cola para que posteriormente sea consumido.
Algunas tecnologías utilizadas para implementar este mecanismo son Redis, RabbitMQ y Amazon SQS, normalmente acompañadas de bibliotecas o frameworks que gestionan los trabajos.
Las colas también permiten regular la cantidad de tareas que pueden ejecutarse simultáneamente.
Workers: ejecutar los trabajos
Los workers son procesos independientes que consumen tareas de una cola y ejecutan su lógica.
Por ejemplo, un worker encargado de generar reportes podría:
- Recuperar un trabajo pendiente.
- Consultar los registros necesarios.
- Construir el archivo PDF.
- Almacenar el documento.
- Actualizar el estado de la tarea.
Si existen muchos trabajos pendientes, es posible incorporar más workers para procesarlos concurrentemente, siempre que los recursos disponibles y las dependencias externas lo permitan.
Esta separación también ofrece una ventaja operativa: los procesos que atienden peticiones HTTP no necesitan realizar directamente todo el trabajo pesado.
4. Diseñar una API para operaciones asíncronas
Volvamos al ejemplo del generador de reportes.
En una implementación tradicional, el cliente podría solicitar el documento y mantener la conexión abierta hasta recibir el archivo.
Con procesamiento asíncrono, la interacción cambia.
Paso 1. Registrar el trabajo
El cliente envía una petición:
POST /api/reports
Content-Type: application/json
{
"type": "sales",
"period": "2026-09"
}
El servidor valida los parámetros, registra la tarea y programa su ejecución.
En lugar de devolver el PDF, responde:
HTTP/1.1 202 Accepted
Location: /api/reports/8472
Content-Type: application/json
{
"id": 8472,
"status": "pending"
}
El código HTTP 202 Accepted indica que la solicitud fue aceptada para su procesamiento, pero que todavía no se ha completado.
Es importante comprender que este código no garantiza que el trabajo terminará correctamente. Únicamente informa que su procesamiento fue aceptado.
Paso 2. Ejecutar la tarea
Un worker obtiene el trabajo pendiente y comienza a generar el documento.
Durante su ejecución, el sistema puede registrar distintos estados:
| Estado | Significado |
|---|---|
pending | La tarea está esperando ser procesada. |
processing | Un worker está ejecutándola. |
completed | El trabajo terminó correctamente. |
failed | No fue posible completar el trabajo. |
Estos estados forman parte del modelo de la aplicación, no de HTTP.
Paso 3. Consultar el resultado
El cliente puede recuperar el estado del trabajo mediante otra petición:
GET /api/reports/8472
Mientras el reporte continúa generándose, la respuesta podría ser:
{
"id": 8472,
"status": "processing"
}
Una vez terminado:
{
"id": 8472,
"status": "completed",
"download_url": "/api/reports/8472/download"
}
El cliente puede entonces descargar el documento.
De esta manera, ninguna de las peticiones HTTP necesita permanecer abierta durante toda la generación del reporte.
5. ¿Cómo sabe el cliente cuándo termina la tarea?
Desacoplar el procesamiento de la petición HTTP introduce una nueva necesidad: comunicar el estado de ejecución al cliente.
Existen tres estrategias habituales.
Polling
El polling consiste en consultar periódicamente el estado de una tarea.
Por ejemplo, el navegador podría solicitar GET /api/reports/8472 cada cinco segundos hasta que el estado cambie a completed o failed.
Su principal ventaja es la simplicidad. No requiere mantener conexiones persistentes ni incorporar infraestructura adicional de comunicación en tiempo real.
Sin embargo, las consultas periódicas pueden generar tráfico innecesario, especialmente cuando existen muchos clientes.
También existe un pequeño retraso entre el momento en que termina el trabajo y la siguiente consulta.
Server-Sent Events (SSE)
SSE permite que el servidor envíe eventos al navegador a través de una conexión HTTP mantenida abierta.
Resulta útil cuando el cliente necesita recibir cambios de estado o actualizaciones de progreso sin consultar repetidamente al servidor.
A diferencia del polling, el servidor puede informar cuando ocurre un cambio relevante.
SSE utiliza comunicación unidireccional: del servidor hacia el cliente. Esto suele ser suficiente para notificaciones y seguimiento de tareas.
No obstante, requiere gestionar la conexión, las posibles desconexiones y la recuperación del estado.
WebSockets
WebSocket permite mantener un canal de comunicación bidireccional entre el cliente y el servidor.
Es apropiado cuando ambos necesitan intercambiar mensajes continuamente, como ocurre en aplicaciones colaborativas, chats o sistemas interactivos.
También puede utilizarse para notificar la finalización de tareas, aunque introduce complejidad adicional que no siempre se justifica.
¿Cuál conviene elegir?
| Mecanismo | Característica principal | Uso habitual |
|---|---|---|
| Polling | Consultas periódicas | Procesos simples o poco frecuentes |
| SSE | Eventos del servidor al cliente | Progreso y notificaciones |
| WebSocket | Comunicación bidireccional | Interacciones continuas |
Para muchas aplicaciones, polling es un buen punto de partida. SSE o WebSockets pueden incorporarse cuando la necesidad de actualizaciones inmediatas o comunicación continua justifique su complejidad.
Estos mecanismos no reemplazan el procesamiento en segundo plano. Su responsabilidad es comunicar el estado o el resultado.
6. Manejo de errores y confiabilidad
Separar una operación de su petición HTTP resuelve el problema de la espera, pero introduce otros desafíos que deben contemplarse en el diseño.
Timeouts
Un timeout determina cuánto tiempo está dispuesto a esperar un componente antes de considerar que una operación no respondió oportunamente.
Aunque utilicemos workers, estos todavía pueden depender de bases de datos, APIs externas o servicios que dejan de responder.
Por eso siguen siendo necesarios los límites de tiempo.
Conviene distinguir entre el timeout de la petición HTTP original, el tiempo máximo de ejecución del job y los timeouts de las operaciones externas que realiza el worker.
Además, un timeout no siempre significa que una operación haya fallado. Es posible que un servicio externo haya terminado correctamente el trabajo, pero su respuesta no haya llegado a tiempo.
Reintentos
Cuando una tarea falla por un problema temporal, puede resultar conveniente ejecutarla nuevamente.
Por ejemplo, si una API externa devuelve un error 503 Service Unavailable, reintentar después de unos segundos podría permitir completar el trabajo.
No obstante, los reintentos deben diseñarse cuidadosamente.
Una estrategia habitual es el exponential backoff, que aumenta progresivamente el tiempo entre intentos. También puede añadirse una variación aleatoria (jitter) para evitar que muchos workers reintenten simultáneamente.
No todos los errores deben reintentarse. Un parámetro inválido difícilmente se solucionará repitiendo la misma petición.
Idempotencia
Una operación es idempotente cuando ejecutarla repetidamente produce el mismo efecto previsto que ejecutarla una sola vez.
Este concepto es especialmente importante porque algunas infraestructuras de colas pueden entregar un mismo trabajo más de una vez.
Por ejemplo, un worker podría terminar de procesar una tarea, pero fallar antes de confirmar su finalización. El sistema podría entonces entregarla nuevamente.
Si se trataba de enviar una notificación, el usuario podría recibirla dos veces. Si se trataba de registrar un pago, las consecuencias podrían ser más graves.
Para prevenirlo, pueden utilizarse identificadores únicos, restricciones en la base de datos, comprobaciones del estado de ejecución o claves de idempotencia cuando el servicio externo las soporte.
Los reintentos aumentan la capacidad de recuperación, mientras que la idempotencia ayuda a evitar efectos duplicados. Ambos conceptos deben considerarse conjuntamente.
Límites de concurrencia
Agregar workers no significa que debamos ejecutar un número ilimitado de tareas.
Es necesario considerar la capacidad del servidor y los límites de los servicios externos.
Por ejemplo, si una API permite un máximo de diez solicitudes simultáneas, incorporar cincuenta workers que consulten esa API puede ocasionar rechazos en lugar de mejorar el rendimiento.
Las colas permiten controlar la velocidad a la que se consumen trabajos, establecer prioridades y distribuir la carga de manera más predecible.
7. ¿Cuándo conviene utilizar este patrón?
El procesamiento asíncrono es especialmente útil cuando una operación cumple una o varias de estas características:
- Duración elevada o impredecible: generación de reportes, procesamiento multimedia o consultas complejas.
- Dependencia de servicios externos: APIs cuya latencia o disponibilidad no controla nuestra aplicación.
- Procesamiento masivo: importación de archivos, envío de correos o actualización de grandes conjuntos de registros.
- Ejecución diferida: tareas que no necesitan completarse inmediatamente.
- Necesidad de controlar la carga: operaciones costosas que deben limitarse o distribuirse entre varios procesos.
Las integraciones con modelos de inteligencia artificial son un buen ejemplo. Algunas consultas pueden responder en pocos segundos, mientras que la transcripción de audios, el análisis de documentos o la ejecución de procesos compuestos pueden tardar mucho más.
Sin embargo, no todas las operaciones con IA necesitan una cola.
Un chatbot que muestra la respuesta progresivamente puede utilizar streaming mediante SSE, manteniendo abierta la conexión mientras recibe los tokens generados. Esto permite mostrar resultados parciales, pero no equivale a ejecutar un trabajo independiente de la petición.
Si necesitamos que una operación continúe incluso cuando el usuario cierre la aplicación, el procesamiento persistente en segundo plano suele ser una alternativa más apropiada.
¿Cuándo no conviene?
Implementar colas, workers y seguimiento de estados añade componentes que deben administrarse, supervisarse y mantener.
Para una operación rápida y predecible, una petición HTTP convencional generalmente será más sencilla.
Incluso para operaciones relativamente lentas, puede ser suficiente emplear streaming si el usuario necesita consumir el resultado conforme se genera y no es indispensable que el trabajo sobreviva a una desconexión.
El objetivo no es convertir todas las peticiones en tareas asíncronas, sino aplicar el patrón cuando sus beneficios superan la complejidad añadida.
8. Consideraciones para una implementación en producción
Una implementación funcional no necesariamente es una implementación confiable.
Antes de utilizar este patrón en producción conviene resolver algunas cuestiones adicionales:
- Persistencia: ¿dónde se almacenan el estado, los parámetros y los resultados del trabajo?
- Recuperación: ¿qué ocurre cuando un worker se detiene inesperadamente?
- Reintentos: ¿cuántas veces puede repetirse una tarea y qué errores justifican hacerlo?
- Seguridad: ¿cómo se evita que un usuario consulte trabajos o resultados que pertenecen a otro?
- Supervisión: ¿cómo se detectan tareas atascadas, colas saturadas o workers que dejaron de funcionar?
- Retención: ¿durante cuánto tiempo deben conservarse los resultados y los registros de ejecución?
También debe contemplarse la consistencia entre el registro de la tarea y su publicación en la cola. Si la base de datos confirma la creación del trabajo, pero falla su encolado, el sistema podría dejar una tarea pendiente que nunca llegue a ejecutarse. Patrones como Transactional Outbox permiten abordar este problema en arquitecturas que requieren mayores garantías.
No todas las aplicaciones necesitan implementar estas soluciones desde el principio, pero es importante conocer los riesgos y evolucionar la arquitectura conforme aumentan sus requisitos.
Conclusión
El patrón de procesamiento asíncrono permite separar la recepción de una solicitud de su ejecución, evitando que las operaciones de larga duración dependan de mantener abierta una petición HTTP.
Las colas organizan los trabajos pendientes, los workers ejecutan las operaciones y mecanismos como polling, SSE o WebSockets permiten comunicar su progreso y resultados.
La arquitectura también exige considerar aspectos como timeouts, reintentos, idempotencia y control de concurrencia para garantizar un comportamiento confiable.
No es un patrón exclusivo de aplicaciones de inteligencia artificial ni una solución que deba aplicarse indiscriminadamente. Es una herramienta de diseño que resulta especialmente valiosa cuando una aplicación necesita realizar operaciones lentas, diferidas o de duración impredecible.
La idea central es sencilla: recibir una solicitud no significa que debamos completar todo su trabajo antes de responder al cliente.