Bagaimana Anda menangani background jobs dan queues?

Question

Accepted Answer

Untuk **background jobs** (pekerjaan yang tidak boleh memblokir respons HTTP), NestJS terintegrasi dengan **BullMQ** (queue berbasis Redis) melalui `@nestjs/bullmq`. Anda menambahkan jobs ke antrian dan memrosesnya secara asinkron di worker terpisah — menjaga request tetap cepat dan menangani pekerjaan berat atau tertunda dengan andal.

## Masalah yang diselesaikan queues

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

## Menambahkan jobs ke 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 menambahkan job (dengan opsi seperti retries, backoff, delay) dan langsung kembali — user tidak perlu menunggu email terkirim.

## Memproses 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` mengonsumsi jobs dari antrian dan melakukan pekerjaan sesungguhnya secara asinkron — terpisah dari siklus request/response (dan bahkan dapat berjalan di proses terpisah).

## Apa yang disediakan queues

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

## Mengapa ini penting

Background job processing dengan queues sangat penting untuk membangun back-end yang robust, responsif, dan scalable — dan memahami integrasi BullMQ NestJS adalah pengetahuan penting tingkat senior.

Nilai inti adalah mengalihkan pekerjaan yang seharusnya tidak memblokir respons HTTP: mengirim email, memproses gambar/video, menghasilkan laporan, menyinkronkan data, atau memanggil layanan eksternal yang lambat.

Melakukan pekerjaan seperti itu secara inline membuat user menunggu, berisiko request timeout, dan kehilangan pekerjaan jika gagal — sedangkan **queuing** memungkinkan Anda merespons langsung sementara **worker** background memrosesnya dengan andal.

Selain offloading asinkron, queues menyediakan fitur production penting: **automatic retries with backoff** (ketahanan terhadap kegagalan transient), **delayed dan scheduled jobs**, **kontrol concurrency/rate-limiting**, dan **persistence** (jobs berbasis Redis bertahan dari crash/restart, jadi pekerjaan tidak hilang).

Mereka juga **decoupling** producer dari consumer, memungkinkan scaling independen.

Mengetahui cara menyiapkan queues, menambahkan jobs dengan opsi yang sesuai (retries, delays), dan memrosesnya di workers sangat berharga untuk merancang aplikasi real yang menangani pekerjaan berat atau tertunda dengan baik.

Ini adalah pola umum dan penting di sistem NestJS production dan mencerminkan pemahaman matang dalam membangun back-end yang responsif dan reliable yang melampaui penanganan request-response sederhana.