Como você gerencia jobs em background e filas?

Question

Accepted Answer

Para **background jobs** (trabalho que não deve bloquear a resposta HTTP), NestJS se integra com **BullMQ** (uma fila baseada em Redis) via `@nestjs/bullmq`. Você adiciona jobs a uma fila e os processa de forma assíncrona em workers separados — mantendo requisições rápidas e tratando trabalho pesado ou diferido de forma confiável.

## O problema que filas resolvem

```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
```

## Configurando uma fila

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

## Adicionando jobs à fila (o produtor)

```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
    });
  }
}
```

O produtor adiciona um job (com opções como retentativas, backoff, delay) e retorna imediatamente — o usuário não espera pelo envio do email.

## Processando jobs (o 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;
    }
  }
}
```

Um worker `@Processor` consome jobs da fila e faz o trabalho real de forma assíncrona — separado do ciclo de requisição/resposta (e pode até rodar em um processo separado).

## O que filas fornecem

```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 que isso importa

O processamento de background jobs com filas é essencial para construir back-ends robustos, responsivos e escaláveis — e entender a integração de BullMQ do NestJS é conhecimento importante de nível sênior.

O valor central é descarregar trabalho que não deve bloquear a resposta HTTP: enviar emails, processar imagens/vídeos, gerar relatórios, sincronizar dados, ou chamar serviços externos lentos.

Fazer tal trabalho inline faz os usuários esperarem, arrisca timeouts de requisição e perde o trabalho se falhar — enquanto que **enfileirar** permite responder imediatamente enquanto um **worker** em background o processa de forma confiável.

Além do descarregamento assíncrono, filas fornecem recursos críticos de produção: **retentativas automáticas com backoff** (resiliência contra falhas transitórias), **jobs atrasados e agendados**, **controle de concorrência/rate-limiting**, e **persistência** (jobs baseados em Redis sobrevivem a crashes/restarts, então o trabalho não é perdido).

Elas também **desacoplam** produtores de consumidores, permitindo escalabilidade independente.

Saber como configurar filas, adicionar jobs com opções apropriadas (retentativas, delays) e processá-los em workers é valioso para arquitetar aplicações reais que lidam com trabalho pesado ou diferido graciosamente.

Este é um padrão comum e importante em sistemas NestJS de produção e reflete compreensão madura de construir back-ends responsivos e confiáveis que vão além de simples manipulação de requisição-resposta.