¿Cómo manejas trabajos en segundo plano y colas?

Question

Accepted Answer

Para **trabajos en segundo plano** (trabajo que no debe bloquear la respuesta HTTP), NestJS se integra con **BullMQ** (una cola respaldada por Redis) a través de `@nestjs/bullmq`. Añades trabajos a una cola y los procesas de manera asíncrona en workers separados — manteniendo las solicitudes rápidas y manejando trabajo pesado o diferido de manera confiable.

## Por qué es importante

```text
Some work is too slow or shouldn't block the request:
  ✗ sending emails, processing images/video, generating reports, calling slow APIs
  → doing it inline makes the user wait and risks timeouts/failures
  ✓ QUEUE the work → respond immediately → a worker processes it in the background
```

## Configurar una cola

```ts
@Module({
  imports: [
    BullModule.forRoot({ connection: { host: "localhost", port: 6379 } }),  // Redis
    BullModule.registerQueue({ name: "email" }),                            // a named queue
  ],
})
export class AppModule {}
```

## Agregar trabajos a la cola (el productor)

```ts
@Injectable()
export class NotificationService {
  constructor(@InjectQueue("email") private emailQueue: Queue) {}

async register(user: User) {
    await this.saveUser(user);
    // queue the email INSTEAD of sending it inline → respond to the user immediately
    await this.emailQueue.add("welcome", { userId: user.id }, {
      attempts: 3,                          // retry up to 3 times on failure
      backoff: { type: "exponential", delay: 5000 },
      delay: 60000,                          // optionally delay the job
    });
  }
}
```

El productor añade un trabajo (con opciones como reintentos, backoff, retardo) y regresa inmediatamente — el usuario no espera a que se envíe el correo.

## Procesar trabajos (el worker/consumidor)

```ts
@Processor("email")
export class EmailProcessor extends WorkerHost {
  async process(job: Job) {
    switch (job.name) {
      case "welcome":
        await this.sendWelcomeEmail(job.data.userId);   // the actual work, in the background
        break;
    }
  }
}
```

Un worker `@Processor` consume trabajos de la cola y realiza el trabajo real de manera asíncrona — separado del ciclo request/response (e incluso puede ejecutarse en un proceso separado).

## Qué proporcionan las colas

```text
✓ Async processing — offload slow work, respond to users instantly
✓ Retries & backoff — failed jobs retry automatically (reliability)
✓ Delayed/scheduled jobs — run work later or on a schedule (repeatable jobs)
✓ Rate limiting & concurrency control — bound how fast/many jobs run
✓ Persistence (via Redis) — jobs survive restarts; not lost if the app crashes
✓ Decoupling — producers and workers scale independently
```

## Por qué es importante

El procesamiento de trabajos en segundo plano con colas es esencial para construir back-ends robustos, responsivos y escalables — y entender la integración de BullMQ en NestJS es conocimiento importante de nivel senior.

El valor principal es descargar trabajo que no debe bloquear la respuesta HTTP: enviar correos, procesar imágenes/vídeo, generar reportes, sincronizar datos, o llamar a servicios externos lentos.

Realizar tal trabajo de manera inline hace que los usuarios esperen, arriesga tiempos de espera de solicitudes, y pierde el trabajo si falla — mientras que **encolarlo** te permite responder inmediatamente mientras un **worker** en segundo plano lo procesa de manera confiable.

Más allá del desplazamiento asíncrono, las colas proporcionan características críticas de producción: **reintentos automáticos con backoff** (resiliencia contra fallos transitorios), **trabajos programados y diferidos**, **control de concurrencia/limitación de velocidad**, y **persistencia** (los trabajos respaldados por Redis sobreviven fallos/reinicios, así que el trabajo no se pierde).

También **desacoplan** productores de consumidores, permitiendo escalado independiente.

Saber cómo configurar colas, agregar trabajos con opciones apropiadas (reintentos, retardos), y procesarlos en workers es valioso para arquitectar aplicaciones reales que manejen trabajo pesado o diferido elegantemente.

Este es un patrón común e importante en sistemas NestJS de producción y refleja una comprensión madura de construir back-ends responsivos y confiables que van más allá del manejo simple de request-response.