Hvordan håndterer du baggrundsjob og køer?

Question

Accepted Answer

For **baggrundsjob** (arbejde, der ikke skal blokere HTTP-svaret), integrerer NestJS med **BullMQ** (en Redis-understøttet kø) via `@nestjs/bullmq`. Du tilføjer job til en kø og behandler dem asynkront i separate workers — hvilket holder anmodninger hurtige og håndterer tungt eller udskudt arbejde pålideligt.

## Problemet, som køer løser

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

## Opsætning af en kø

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

## Tilføjelse af job til køen (producenten)

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

Producenten tilføjer et job (med muligheder som retries, backoff, delay) og vender straks tilbage — brugeren venter ikke på, at emailen bliver sendt.

## Behandling af job (workeren/forbrugeren)

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

En `@Processor` worker forbruger job fra køen og udfører det faktiske arbejde asynkront — adskilt fra anmodnings-/svarcyklussen (og kan endda køre i en separat proces).

## Hvad køer tilbyder

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

## Hvorfor det betyder noget

Baggrundsjobbehandling med køer er vigtig for at opbygge robuste, responsive, skalerbare backends — og forståelse af NestJS's BullMQ-integration er vigtig knowledge på seniorplan.

Kerneplaceringen er at aflaste arbejde, der ikke skal blokere HTTP-svaret: afsendelse af emails, behandling af billeder/video, generering af rapporter, synkronisering af data eller opkald til langsomme eksterne tjenester.

At udføre sådan arbejde inline får brugere til at vente, risikerer anmodningestimeout og mister arbejdet, hvis det fejler — hvorimod **køerne** giver dig mulighed for at svare straks, mens en baggrunds-**worker** behandler det pålideligt.

Ud over asynkron aflastning tilbyder køer kritiske produktionsfunktioner: **automatiske forsøg med backoff** (modstandskraft mod forbigående fejl), **forsinket og planlagte job**, **kontrol af concurrency/rate-limiting** og **persistens** (Redis-understøttede job overlever nedgange/genstarter, så arbejde går ikke tabt).

De **afkobler** også producenter fra forbrugere, hvilket tillader uafhængig skalering.

At vide, hvordan man opretter køer, tilføjer job med passende muligheder (retries, delays) og behandler dem i workers, er værdifuldt for at arkitekturere virkelige applikationer, der håndterer tungt eller udskudt arbejde elegant.

Dette er et almindeligt, vigtigt mønster i produktions-NestJS-systemer og afspejler modent kendskab til at opbygge responsive, pålidelige backends, der går ud over simpel anmodnings-svarhåndtering.