તમે બેકગ્રાઉન્ડ જોબ્સ અને કયુ કેવી રીતે હેન્ડલ કરો છો?

Question

Accepted Answer

**બેકગ્રાઉન્ડ જોબ્સ** (એવું કાર્ય જે HTTP રેસ્પોન્સને બ્લોક ન કરે) માટે, NestJS **BullMQ** (એક Redis-બેકড કયુ) સાથે `@nestjs/bullmq` દ્વારા ઇન્ટિગ્રેટ થાય છે. તમે કયુમાં જોબ્સ ઉમેરો છો અને તેમને અલગ વર્કર્સમાં અસિંક્રોનસલી પ્રોસેસ કરો છો — જે રિક્વેસ્ટ્સને ઝડપી રાખે છે અને ભારે અથવા ડિફર્ડ કાર્યને વિશ્વસનીયતાથી હેન્ડલ કરે છે.

## કયુ કયો સમસ્યા હલ કરે છે

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

## કયુ સેટ અપ કરવું

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

## કયુમાં જોબ્સ ઉમેરવી (પ્રોડ્યુસર)

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

પ્રોડ્યુસર જોબ ઉમેરે છે (રીટ્રાઈ, બેકઑફ, ડિલે જેવા વિકલ્પો સાથે) અને તરત જ રીટર્ન કરે છે — ઉપયોગકર્તાને ઈમેલ આવતાની રાહ નથી જોવી પડતી.

## જોબ્સ પ્રોસેસ કરવી (વર્કર/કંઝ્યુમર)

```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` વર્કર કયુમાંથી જોબ્સ ખપત કરે છે અને વાસ્તવિક કાર્ય અસિંક્રોનસલી કરે છે — રિક્વેસ્ટ/રેસ્પોન્સ સાયકલથી અલગ (અને તે અલગ પ્રોસેસમાં પણ ચલાવી શકાય છે).

## કયુ શું પ્રદાન કરે છે

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

## તે શા માટે મહત્વપૂર્ણ છે

બેકગ્રાઉન્ડ જોબ પ્રોસેસિંગ કયુ સાથે મજબૂત, પ્રતિક્રિયાશીલ, સ્કેલેબલ બેક-એન્ડ્સ બનાવવા માટે આવશ્યક છે — અને NestJS ની BullMQ ઇન્ટિગ્રેશન સમજવું સિનિયર-લેવલનું જ્ઞાન છે.

મૂલ્ય એ કાર્યને ઓછો કરવો છે જે HTTP રેસ્પોન્સને બ્લોક ન કરે: ઈમેલ આપવી, ઈમેજ/વીડિયો પ્રોસેસ કરવી, રિપોર્ટ જનરેટ કરવી, ડેટા સિંક કરવી, અથવા ધીમી બાહ્ય સેવાઓને કૉલ કરવી.

એવું કાર્ય ઇનલાઈન કરવું ઉપયોગકર્તાઓને રાહ જોવવા દે છે, રિક્વેસ્ટ ટાઈમાઉટનું જોખમ ઉઠાવે છે, અને અસફળ થાય તો કાર્ય ખોવાય છે — જ્યારે **કયુઇંગ** તેને તરત જ જવાબ આપવા દે છે જ્યારે બેકગ્રાઉન્ડ **વર્કર** તેને વિશ્વસનીયતાથી પ્રોસેસ કરે છે.

অસિંક પુશ કરવાથી આગળ, કયુ નિર્ણાયક પ્રોડક્શન ફીચર પ્રદાન કરે છે: **બેકઑફ સાથે આપોઆપ રીટ્રાઈ** (ક્ષણિક નિષ્ફળતાની સામે સ્થિતિસ્થાપકતા), **ડિલે અને શેડ્યુલ્ડ જોબ્સ**, **સમવર્તી/રેટ-લિમિટિંગ નિયંત્રણ**, અને **પર્સિસ્ટન્સ** (Redis-બેકડ જોબ્સ ક્રેશ/રિસ્ટાર્ટ સર્વાઈવ કરે છે, તેથી કાર્ય ખોવાતું નથી).

તેઓ **ડીકપલ** પણ કરે છે પ્રોડ્યુસરને કંઝ્યુમર્સથી, સ્વતંત્ર સ્કેલિંગ આપતા.

જાણવું કે કયુ કેવી સેટ અપ કરવી, યોગ્ય વિકલ્પ (રીટ્રાઈ, ડિલે) સાથે જોબ્સ કેવી ઉમેરવી, અને વર્કર્સમાં તેમને પ્રોસેસ કરવું વાસ્તવિક অ্যાપ્લીકેશનને આર્કિટેક્ચર કરવા માટે મૂલ્યવાન છે જે ભારે અથવા ડિફર્ડ કાર્યને ગ્રેસફુલલી હેન્ડલ કરે છે.

યે NestJS સિસ્ટમોમાં સામાન્ય, મહત્વપૂર્ણ પેટર્ન છે અને સરળ રિક્વેસ્ટ-રેસ્પોન્સ હેન્ડલિંગથી આગળ જતા પ્રતિક્રિયાશીલ, વિશ્વસનીય બેક-એન્ડ્સ બનાવવાની પરિપક્વ સમજ પ્રતિબિંબિત કરે છે.