Kako upravljate background jobovima i redovima čekanja?

Question

Accepted Answer

Za **background jobove** (posao koji ne bi trebao blokirati HTTP odgovor), NestJS se integrira s **BullMQ**-om (Redis-backed red čekanja) preko `@nestjs/bullmq`. Dodajete jobove u red čekanja i procesuirate ih asinkrono u zasebnim workerima — čime održavate brze zahtjeve i pouzdano rukovarate težim ili odloženim poslom.

## Problem koji redovi čekanja rješavaju

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

## Postavljanje reda čekanja

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

## Dodavanje jobova u red čekanja (producent)

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

Producent dodaje job (s opcijama poput pokušaja, backoff-a, kašnjenja) i odmah se vraća — korisnik ne čeka da se email pošalje.

## Procesiranje jobova (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;
    }
  }
}
```

Worker s `@Processor` dekoracijom konzumira jobove iz reda čekanja i obavlja stvarni posao asinkrono — odvojen od ciklusa zahtjev/odgovor (i može se čak izvoditi u zasebnom procesu).

## Što redovi čekanja pružaju

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

## Zašto je to važno

Obrađivanje background jobova s redovima čekanja je esencijalno za izradu robusnih, responsivnih i skalabilnih back-enda — a razumijevanje NestJS-ove BullMQ integracije je važno znanje za seniorsku razinu.

Jedinska vrijednost je prebacivanje posla koji ne bi trebao blokirati HTTP odgovor: slanje emaila, obrada slika/videa, generiranje izvještaja, sinkronizacija podataka ili pozivanje sporim vanjskih usluga.

Obavljanje takvog posla u liniji čini da korisnici čekaju, rizikuje timeout zahtjeva, i gubi posao ako neće uspjeti — dok **red čekanja** omogućuje da odmah odgovorite dok background **worker** pouzdano procesira posao.

Bez obzira na asinkrono prebacivanje, redovi čekanja pružaju kritične produkcijske značajke: **automatske pokušaje s backoff-om** (otpornost na privremene greške), **odložene i zakazane jobove**, **kontrolu konkurencije/ograničenja brzine**, i **perzistenciju** (Redis-backed jobovi prežive padove/restarte, tako da se posao ne gubi).

Oni također **odvajaju** producente od konzumenata, omogućujući nezavisan skalabilnost.

Znanje kako postaviti redove čekanja, dodati jobove s odgovarajućim opcijama (pokušaji, kašnjenja), i procesuirati ih u workerima je vrijednosti za arhitekturiranje stvarnih aplikacija koje gracefully rukuju težim ili odloženim poslom.

Ovo je česta, važna uzorak u produkcijskim NestJS sustavima i odražava zrelo razumijevanje izgradnje responsivnih, pouzdanih back-enda koji idu dalje od jednostavnog rukovanja zahtjev-odgovor ciklusa.