Pèn carane nganggo background jobs lan queues?

Question

Accepted Answer

Kanggo **background jobs** (karya sing ora kudu ngalangi HTTP response), NestJS integrasi karo **BullMQ** (queue sing didukung Redis) liwat `@nestjs/bullmq`. Sampeyan nambah jobs menyang queue lan proses asynchronously ing workers kapisah — nggawé request cepet lan nangani karya abot utawa deferred kanthi reliable.

## Masalah sing dipecahake queue

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

## Menyiapkan queue

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

## Nambah jobs menyang queue (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
    });
  }
}
```

Producer nambah job (karo opsi kaya retries, backoff, delay) lan return langsung — user ora nanteni email dikirim.

## Proses jobs (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 `@Processor` ngonsumsI jobs saka queue lan nindakake karya asynchronously — kapisah saka siklus request/response (lan bisa malah nglakoni ing proses kapisah).

## Apa sing diwenehake queue

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

## Sapa kaantonane

Pemrosesan background job kanthi queue esensial kanggo nggawa back-ends sing robust, responsif, lan scalable — lan ngerteni integrasi BullMQ NestJS minangka pengetahuan level senior sing penting.

Nilai intiné yaiku nglilihake karya sing ora kudu ngalangi HTTP response: ngirim email, proses gambar/video, numbas laporan, sinkronisasi data, utawa njaluk layanan eksternal sing alon.

Ngerjakake karya kaya mangkono inline ndadekake users nganti, risiko request timeout, lan ilang karyané — dene **queue** bisa nyawab langsung nalika **worker** nangani kanthi reliable.
/** Ngluwihi async offloading, queue nyedhiyakake fitur produksi sing penting: **automatic retries kanthi backoff** (resilience lawan kegagalan transient), **delayed lan scheduled jobs**, **concurrency/rate-limiting control**, lan **persistence** (jobs Redis-backed nglestarèn crash/restart, supaya karya ora ilang).

Ugé bisa **decouple** producers saka consumers, ngidini scaling independen.

Ngerti cara menyiapkan queue, nambah jobs kanthi opsi cocok (retries, delays), lan proses ing workers bermanfaat kanggo architecting aplikasi nyata sing nangani karya abot utawa deferred kanthi graceful.

Iki pola umum lan penting ing sistem NestJS produksi lan nggambarake pangerten mateng babagan nggawa responsive, reliable back-ends sing ngluwihi simple request-response handling.