Arka plan işleri (background jobs) ve kuyrukları nasıl yönetirsiniz?

Question

Accepted Answer

**Arka plan işleri** (HTTP yanıtını bloke etmemesi gereken işler) için NestJS, `@nestjs/bullmq` aracılığıyla **BullMQ** (Redis tarafından desteklenen bir kuyruk) ile entegre olur. İşleri bir kuyruğa ekler ve bunları ayrı çalışanlarda asenkron olarak işlersiniz — istekleri hızlı tutarak ağır veya ertelenmiş işleri güvenilir bir şekilde yönetirsiniz.

## Kuyrukların çözdüğü problem

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

## Bir kuyruk oluşturma

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

## Kuyruğa işler ekleme (üretici)

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

Üretici bir işi (yeniden denemeler, geri çekilme, gecikme gibi seçeneklerle) ekler ve hemen döner — kullanıcı e-postanın gönderilmesini beklemez.

## İşleri işleme (çalışan/tüketici)

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

Bir `@Processor` çalışanı kuyruktan işleri tüketir ve gerçek işi asenkron olarak yapar — istek/yanıt döngüsünden ayrı (ve hatta ayrı bir işlemde çalışabilir).

## Kuyrukların sağladıkları

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

## Neden önemli

Kuyruklar ile arka plan işi işleme, güçlü, duyarlı ve ölçeklenebilir arka uçlar oluşturmak için gereklidir — ve NestJS'nin BullMQ entegrasyonunu anlamak önemli senior seviyesi bilgisidir.

Temel değer, HTTP yanıtını bloke etmemesi gereken işleri offload etmektir: e-postalar gönderme, görüntü/video işleme, raporlar oluşturma, veri senkronizasyonu veya yavaş harici hizmetleri çağırma.

Böyle işleri satır içi yapmak, kullanıcıların beklemesine neden olur, istek zaman aşımı riskiyle karşı karşıya gelir ve başarısız olursa işi kaybeder — oysa **kuyruklamak**, hemen yanıt vermenizi sağlarken arka plan **çalışanı** bunu güvenilir bir şekilde işler.

Asenkron offloading ötesinde, kuyruklar kritik üretim özelliklerini sağlar: **otomatik yeniden denemeler ve geri çekilme** (geçici hatalara karşı dayanıklılık), **geciktirilmiş ve planlanan işler**, **eşzamanlılık/hız sınırlaması kontrolü** ve **kalıcılık** (Redis tarafından desteklenen işler çökmeleri/yeniden başlatmaları kurtarır, bu nedenle iş kaybolmaz).

Ayrıca **üreticileri tüketicilerden ayırarak**, bağımsız ölçeklemeye izin verirler.

Kuyrukları ayarlamayı, uygun seçeneklerle (yeniden denemeler, gecikmeler) işler eklemeyi ve bunları çalışanlarda işlemeyi bilmek, ağır veya ertelenmiş işleri zarif bir şekilde yönetmek için gerçek uygulamaları mimarlamak açısından değerlidir.

Bu, üretim NestJS sistemlerinde yaygın ve önemli bir modeldir ve basit istek-yanıt işleminin ötesine geçen, duyarlı ve güvenilir arka uçlar oluşturmanın olgun bir anlayışını yansıtır.