Hvordan håndterer du bakgrunnsjobber og køer?

Question

Accepted Answer

For **bakgrunnsjobber** (arbeid som ikke skal blokkere HTTP-responsen), integrerer NestJS med **BullMQ** (en Redis-basert kø) via `@nestjs/bullmq`. Du legger jobber til en kø og behandler dem asynkront i separate arbeidere — som holder forespørsler raske og håndterer tung eller utsatt arbeid pålitelig.

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

## Oppsett av en kø

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

## Legge jobber til køen (produsenten)

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

Produsenten legger til en jobb (med alternativer som forsøk, backoff, forsinkelse) og returnerer umiddelbart — brukeren venter ikke på at e-posten sendes.

## Behandle jobber (arbeideren/konsumenten)

```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`-arbeider konsumerer jobber fra køen og utfører det faktiske arbeidet asynkront — atskilt fra forespørsel-/responsesyklusen (og kan til og med kjøre i en separat prosess).

## Hva køer gir

```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 spiller en rolle

Bakgrunnsjobbbehandling med køer er essensielt for å bygge robuste, responsive, skalerbare back-ender — og å forstå NestJS sin BullMQ-integrasjon er viktig kunnskap på seniorbygnivå.

Kjernverdien er å overføre arbeid som ikke skal blokkere HTTP-responsen: sending av e-poster, behandling av bilder/video, generering av rapporter, synkronisering av data, eller kalling av trege eksterne tjenester.

Å gjøre slikt arbeid inline får brukere til å vente, risikerer forespørselsovergang, og mister arbeidet hvis det mislykkes — mens **køing** det lar deg svare umiddelbart mens en bakgrunns**arbeider** behandler det pålitelig.

Utover asynkron overføring gir køer kritiske produksjonsfunksjoner: **automatiske forsøk med backoff** (motstand mot forbigående feil), **forsinkede og planlagte jobber**, **kontroll av samtidighet/hastighetsbegrensning**, og **persistens** (Redis-baserte jobber overlever kræsj/omstarter, så arbeid går ikke tapt).

De **frikoblet** også produsenter fra konsumenter, som tillater uavhengig skalering.

Å vite hvordan man setter opp køer, legger til jobber med passende alternativer (forsøk, forsinkelser), og behandler dem i arbeidere er verdifullt for å arkitekturere virkelige applikasjoner som håndterer tung eller utsatt arbeid elegant.

Dette er et vanlig, viktig mønster i produksjon NestJS-systemer og gjenspeiler moden forståelse av å bygge responsive, pålitelige back-ender som går utover enkel forespørsel-responsehåndtering.