आप background jobs और queues को कैसे handle करते हैं?

Question

Accepted Answer

**Background jobs** (ऐसा काम जो HTTP response को block नहीं करना चाहिए) के लिए, NestJS `@nestjs/bullmq` के माध्यम से **BullMQ** (एक Redis-backed queue) के साथ integrate होता है। आप एक queue में jobs add करते हैं और उन्हें अलग workers में asynchronously process करते हैं — जिससे requests fast रहती हैं और heavy या deferred काम reliably handle होता है।

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

## एक queue सेट अप करना

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

## queue में jobs add करना (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 एक job add करता है (retries, backoff, delay जैसे options के साथ) और तुरंत return हो जाता है — user को email भेजे जाने का इंतज़ार नहीं करना पड़ता।

## jobs को process करना (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;
    }
  }
}
```

एक `@Processor` worker queue से jobs consume करता है और असली काम asynchronously करता है — request/response cycle से अलग (और यह एक अलग process में भी चल सकता है)।

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

## यह क्यों महत्वपूर्ण है

queues के साथ background job processing robust, responsive, scalable back-ends बनाने के लिए आवश्यक है — और NestJS के BullMQ integration को समझना महत्वपूर्ण senior-level ज्ञान है।

मुख्य value उस काम को offload करने में है जो HTTP response को block नहीं करना चाहिए: emails भेजना, images/video process करना, reports generate करना, data sync करना, या slow external services को call करना।

ऐसा काम inline करने से users को इंतज़ार करना पड़ता है, request timeouts का जोखिम होता है, और fail होने पर काम खो जाता है — जबकि इसे **queue** करने से आप तुरंत respond कर सकते हैं जबकि एक background **worker** इसे reliably process करता है।

async offloading के अलावा, queues critical production features प्रदान करती हैं: **backoff के साथ automatic retries** (transient failures के विरुद्ध resilience), **delayed और scheduled jobs**, **concurrency/rate-limiting control**, और **persistence** (Redis-backed jobs crashes/restarts को झेल जाती हैं, इसलिए काम नहीं खोता)।

वे producers को consumers से **decouple** भी करती हैं, जिससे independent scaling संभव होती है।

queues सेट अप करना, उपयुक्त options (retries, delays) के साथ jobs add करना, और उन्हें workers में process करना जानना ऐसी real applications को architect करने के लिए मूल्यवान है जो heavy या deferred काम को gracefully handle करती हैं।

यह production NestJS systems में एक common, महत्वपूर्ण pattern है और simple request-response handling से आगे जाकर responsive, reliable back-ends बनाने की परिपक्व समझ को दर्शाता है।