Come gestisci background job e code?

Question

Accepted Answer

Per **background job** (lavoro che non dovrebbe bloccare la risposta HTTP), NestJS si integra con **BullMQ** (una coda supportata da Redis) tramite `@nestjs/bullmq`. Aggiungi job a una coda e li elabori asincronamente in worker separati — mantenendo le richieste veloci e gestendo il lavoro pesante o differito in modo affidabile.

## Perché è 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
```

## Configurare una coda

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

## Aggiungere job alla coda (il producer)

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

Il producer aggiunge un job (con opzioni come retry, backoff, delay) e ritorna immediatamente — l'utente non aspetta che l'email sia inviata.

## Elaborare job (il worker/consumer)

```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` consuma job dalla coda ed esegue il lavoro effettivo asincronamente — separato dal ciclo request/response (e può anche essere eseguito in un processo separato).

## Cosa forniscono le code

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

## Perché è importante

L'elaborazione di background job con code è essenziale per costruire back-end robusti, responsivi e scalabili — e comprendere l'integrazione di BullMQ in NestJS è una conoscenza importante a livello senior.

Il valore principale è scaricare il lavoro che non dovrebbe bloccare la risposta HTTP: inviare email, elaborare immagini/video, generare report, sincronizzare dati o chiamare servizi esterni lenti.

Fare tale lavoro inline fa aspettare gli utenti, rischia timeout delle richieste e perde il lavoro se fallisce — mentre **accodare** il lavoro ti permette di rispondere immediatamente mentre un **worker** background lo elabora in modo affidabile.

Oltre all'offloading asincrono, le code forniscono caratteristiche critiche di produzione: **retry automatici con backoff** (resilienza contro guasti transitori), **job ritardati e pianificati**, **controllo della concorrenza/rate-limiting** e **persistenza** (i job supportati da Redis sopravvivono a crash/restart, quindi il lavoro non viene perso).

Separano anche **produttori da consumatori**, consentendo il scaling indipendente.

Sapere come configurare code, aggiungere job con opzioni appropriate (retry, delay) ed elaborarli in worker è prezioso per architettare applicazioni reali che gestiscono il lavoro pesante o differito con eleganza.

Questo è un pattern comune e importante nei sistemi NestJS di produzione e riflette una comprensione matura della costruzione di back-end responsivi e affidabili che vanno oltre la semplice gestione request-response.