Node.js ve BullMQ ile Asenkron Görevleri Yönetme

Node.js ve BullMQ ile Asenkron Görevleri Yönetme

Node.js, tek iş parçacıklı, olay odaklı ve engellemeyen (non-blocking) G/Ç mimarisi sayesinde yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmek için popüler bir platformdur. Ancak, bu tek iş parçacıklı yapı, uzun süren veya yoğun hesaplama gerektiren görevlerin doğrudan ana olay döngüsünde (event loop) çalıştırılması durumunda ciddi performans darboğazlarına yol açabilir. Bu tür görevler, olay döngüsünü bloke ederek uygulamanın yanıt verme süresini olumsuz etkiler ve kullanıcı deneyimini bozar. İşte bu noktada, asenkron görev yönetimi ve görev kuyrukları devreye girer. Bu makalede, Node.js uygulamalarınızda asenkron görevleri etkili bir şekilde yönetmek için güçlü ve modern bir çözüm olan BullMQ’yu derinlemesine inceleyeceğiz.

Node.js’te Asenkron Görevlerin Önemi

Node.js’in gücü, engellemeyen G/Ç modelinden gelir. Temelde, Node.js tek bir iş parçacığında çalışır ve gelen tüm istekleri bu olay döngüsü üzerinden işler. Bir istek geldiğinde, Node.js bunu mümkün olan en kısa sürede işler ve eğer bir G/Ç işlemi (veritabanı sorgusu, dosya okuma/yazma, ağ isteği) gerekiyorsa, bu işlemi işletim sistemine devreder ve kendi olay döngüsüne geri döner. G/Ç işlemi tamamlandığında, işletim sistemi Node.js’i bilgilendirir ve ilgili geri çağırım (callback) veya promise çözümlenir.

Olay Döngüsü ve Engelleme Sorunu

Bu model, çoğu durumda harika çalışır. Ancak, olay döngüsünü meşgul eden uzun süreli bir senkron işlemle karşılaşıldığında sorunlar başlar. Örneğin:

* Yoğun Hesaplamalar: Büyük veri kümeleri üzerinde karmaşık matematiksel işlemler, görüntü veya video işleme, şifreleme/şifre çözme.
* Uzun Süren Veritabanı Sorguları: Çok büyük tablolar üzerinde karmaşık sorgular veya indekslenmemiş alanlarda arama.
* Yüksek Gecikmeli Harici API Çağrıları: Üçüncü taraf hizmetlere yapılan ve yanıt vermesi uzun süren istekler.
* Büyük Dosya İşlemleri: Çok büyük dosyaların okunması, yazılması veya sıkıştırılması.

Bu tür görevler, olay döngüsünü saniyelerce veya daha uzun süre bloke edebilir. Bu blokaj süresince, Node.js sunucusu yeni gelen istekleri işleyemez, mevcut bağlantılara yanıt veremez ve uygulamanız donmuş gibi görünür. Bu durum, kötü bir kullanıcı deneyimi, artan hata oranları (zaman aşımı hataları) ve genel sistem performansında düşüşle sonuçlanır.

Çözüm: Görev Kuyrukları

Bu sorunları aşmanın en etkili yolu, bu tür uzun süren görevleri ana uygulamanın olay döngüsünden ayırarak ayrı bir iş parçacığı veya süreçte asenkron olarak yürütmektir. Görev kuyrukları (task queues) tam da bu amaca hizmet eder. Bir görev kuyruğu, görevleri depolayan ve daha sonra bir veya daha fazla “işçi” (worker) tarafından işlenmesini sağlayan bir mekanizmadır.

Görev kuyrukları kullanmanın başlıca faydaları şunlardır:

* Yanıt Verebilirlik: Ana uygulama, uzun süren görevi kuyruğa ekler ve hemen kullanıcının isteğine yanıt verir, bu da kullanıcı deneyimini iyileştirir.
* Ölçeklenebilirlik: Görevleri işlemek için birden fazla işçi süreci çalıştırılabilir. İş yükü arttıkça, yeni işçiler eklenerek sistemin ölçeği kolayca büyütülebilir.
* Güvenilirlik: Görevler kalıcı olarak depolandığı için, bir işçi süreci çökse bile görevler kaybolmaz ve daha sonra başka bir işçi tarafından yeniden denenebilir. Otomatik yeniden deneme (retry) mekanizmaları, geçici hatalara karşı direnç sağlar.
* Bağımsızlık: Görev üreticileri (producer) ve tüketicileri (consumer) birbirinden bağımsız hale gelir. Bu, sistem mimarisini basitleştirir ve farklı bileşenlerin farklı hızlarda çalışmasına olanak tanır.

Görev Kuyrukları ve BullMQ’ya Giriş

Görev kuyrukları, modern dağıtık sistemlerin temel bir bileşenidir. Piyasa, Redis tabanlı Bull/BullMQ, RabbitMQ, Apache Kafka gibi çeşitli görev kuyruğu çözümleri sunmaktadır. Node.js ekosisteminde, Redis’in yüksek performanslı ve kalıcı veri yapılarından yararlanan Bull ve onun daha modern, performanslı ve kapsamlı halefi olan BullMQ öne çıkmaktadır.

Neden BullMQ?

BullMQ, Node.js uygulamaları için Redis tabanlı, sağlam ve zengin özelliklere sahip bir görev kuyruğu kütüphanesidir. Eski Bull kütüphanesinin (şimdiki adıyla Bull v3) geliştirilmiş ve yeniden yazılmış versiyonudur. BullMQ’yu tercih etmek için birçok neden vardır:

* Redis Üzerine İnşa Edilmiştir: Redis, yüksek hızlı, in-memory bir veri yapısı sunucusudur. BullMQ, Redis’in atomik işlemleri, kalıcılığı ve Pub/Sub yeteneklerini kullanarak görev kuyruklarını güvenilir ve performanslı bir şekilde yönetir.
* Modern JavaScript: BullMQ, async/await ve Promise tabanlı API’ler kullanarak modern Node.js geliştirme prensiplerine tamamen uyumludur. Bu, kodun daha okunabilir ve bakımı kolay olmasını sağlar.
* Kapsamlı Özellikler:
* İş Kalıcılığı: Görevler Redis’te saklandığı için, uygulama veya işçi süreçleri yeniden başlatılsa bile görevler kaybolmaz.
* Otomatik Yeniden Deneme (Retries) ve Gecikmeli Yeniden Deneme (Backoff): Geçici hatalarda görevleri otomatik olarak yeniden deneme yeteneği, sistemin dayanıklılığını artırır. Farklı yeniden deneme stratejileri (sabit, üstel) yapılandırılabilir.
* Gecikmeli Görevler (Delayed Jobs): Görevlerin belirli bir süre sonra veya belirli bir zamanda çalıştırılmasını sağlar.
* Önceliklendirme: Yüksek öncelikli görevlerin düşük öncelikli görevlerden önce işlenmesini sağlar.
* Eşzamanlılık Kontrolü: Bir işçinin aynı anda kaç görevi işleyebileceğini kontrol etme yeteneği.
* İş Yaşam Döngüsü Olayları: Görevlerin durum değişikliklerini (başladı, tamamlandı, başarısız oldu, ilerleme kaydetti) dinlemek için zengin olay sistemi.
* Kapsamlı Hata Yönetimi: Görev işleme sırasındaki hataları yakalama ve yönetme mekanizmaları.
* Akışlar (Flows): Birden fazla görevi bir araya getirerek karmaşık iş akışları oluşturma.
* İzleme (Monitoring): BullMQ UI veya Bull Board gibi araçlarla kuyrukları ve görevleri kolayca izleme.
* Performans: BullMQ, Bull v3’e göre önemli performans iyileştirmeleri sunar, özellikle yüksek iş yüklerinde daha verimlidir.

BullMQ ile Başlangıç

BullMQ kullanmaya başlamak için Node.js ve bir Redis sunucusuna ihtiyacınız var. Redis’i yerel makinenizde Docker ile veya bir bulut sağlayıcısından kolayca kurabilirsiniz.

Önkoşullar ve Kurulum

1. Node.js: Sisteminizde kurulu olmalı.
2. Redis: Çalışan bir Redis sunucunuz olmalı.
3. Bağımlılıkları Kurma: Projenizin kök dizininde aşağıdaki komutu çalıştırın:

npm install bullmq ioredis
    # veya
    yarn add bullmq ioredis

ioredis kütüphanesi, BullMQ’nun Redis ile iletişim kurmak için kullandığı güçlü ve popüler bir Redis istemcisidir.

Temel Kurulum: Kuyruk ve İşçi Oluşturma

BullMQ’da iki ana bileşen vardır:

* Kuyruk (Queue): Görevleri eklediğiniz yerdir. Bir kuyruk, belirli bir türdeki görevleri toplar.
* İşçi (Worker): Kuyruktaki görevleri işleyen fonksiyondur. İşçiler, görevleri kuyruktan alır, işler ve sonuçları döndürür veya hataları kaydeder.

Önce bir Redis bağlantısı tanımlayalım. Genellikle bu bağlantı, hem kuyruk hem de işçi tarafından paylaşılır.

// redis.js
import IORedis from 'ioredis';

const redisConfig = {
  host: 'localhost',
  port: 6379,
  maxRetriesPerRequest: null, // Redis bağlantı hatalarını yönetmek için önemli
};

export const redisConnection = new IORedis(redisConfig);

redisConnection.on('error', (error) => {
  console.error('Redis connection error:', error);
});

console.log('Redis bağlantısı kuruldu.');

Şimdi bir kuyruk oluşturalım ve ona görev ekleyelim:

// producer.js (Görev Üretici)
import { Queue } from 'bullmq';
import { redisConnection } from './redis.js';

const myQueue = new Queue('emailQueue', { connection: redisConnection });

async function addEmailJob(email, subject, body) {
  try {
    const job = await myQueue.add('sendEmail', { email, subject, body }, {
      attempts: 3, // 3 kez yeniden dene
      backoff: {
        type: 'exponential', // Üstel geri çekilme (1s, 2s, 4s...)
        delay: 1000,
      },
      removeOnComplete: true, // Başarılı olduğunda görevi kuyruktan kaldır
      removeOnFail: false, // Başarısız olsa bile hata analizi için tut
    });
    console.log(Email gönderme görevi eklendi: ${job.id});
    return job.id;
  } catch (error) {
    console.error('Görev eklenirken hata oluştu:', error);
  }
}

// Örnek kullanım
addEmailJob('test@example.com', 'Hoş Geldiniz!', 'Uygulamamıza hoş geldiniz.');
addEmailJob('user2@example.com', 'Şifre Sıfırlama', 'Şifrenizi sıfırlamak için tıklayın.');

console.log('Görevler kuyruğa eklendi.');

Ve şimdi bu görevleri işleyecek bir işçi oluşturalım:

// worker.js (Görev İşleyici)
import { Worker } from 'bullmq';
import { redisConnection } from './redis.js';

async function sendEmailService(email, subject, body) {
  // Bu kısım aslında bir e-posta gönderme API'si çağırabilir
  // veya bir e-posta gönderme kütüphanesi kullanabilir.
  // Burada sadece simüle ediyoruz.
  console.log(E-posta gönderiliyor: Kime: ${email}, Konu: ${subject});
  await new Promise(resolve => setTimeout(resolve, Math.random() * 2000 + 500)); // 0.5-2 saniye gecikme
  if (Math.random() < 0.1) { // %10 ihtimalle başarısız olsun
    throw new Error('E-posta gönderme başarısız oldu!');
  }
  console.log(E-posta başarıyla gönderildi: Kime: ${email});
  return { status: 'success', message: 'Email sent' };
}

const emailWorker = new Worker('emailQueue', async (job) => {
  const { email, subject, body } = job.data;
  console.log(İşçi başladı: Görev ID: ${job.id}, Veri:, job.data);

  try {
    const result = await sendEmailService(email, subject, body);
    console.log(İşçi tamamlandı: Görev ID: ${job.id}, Sonuç:, result);
    return result; // Görev başarıyla tamamlandığında döndürülen değer
  } catch (error) {
    console.error(İşçi hata verdi: Görev ID: ${job.id}, Hata:, error.message);
    throw error; // Hata durumunda BullMQ'ya bildir
  }
}, { connection: redisConnection, concurrency: 5 }); // Aynı anda 5 görevi işleyebilir

emailWorker.on('completed', (job) => {
  console.log(Görev ${job.id} tamamlandı.);
});

emailWorker.on('failed', (job, err) => {
  console.error(Görev ${job.id} başarısız oldu: ${err.message});
});

emailWorker.on('error', (err) => {
  console.error('İşçi genel hata:', err);
});

console.log('E-posta işleyici çalışıyor...');

Bu örnekte:
* producer.js bir emailQueue oluşturur ve bu kuyruğa iki adet ‘sendEmail’ türünde görev ekler. Görevlere attempts ve backoff gibi seçenekler tanımlanmıştır.
* worker.js de aynı emailQueue‘yu dinleyen bir işçi oluşturur. Bu işçi, kuyruğa eklenen her ‘sendEmail’ görevini alır ve sendEmailService fonksiyonunu çağırarak e-posta gönderme işlemini simüle eder. concurrency: 5 ayarı sayesinde, bu işçi aynı anda 5 e-posta gönderme işlemini paralel olarak yürütebilir.
* İşçi, görevlerin tamamlanması veya başarısız olması durumunda completed ve failed olaylarını dinler.

Gelişmiş BullMQ Özellikleri

BullMQ, görev yönetimi için bir dizi güçlü ve esnek özellik sunar.

Görev Seçenekleri (Job Options)

queue.add() metoduna ikinci argüman olarak geçirilen seçenekler, bir görevin nasıl davranacağını belirler:

* delay: Görevin ne kadar süre sonra (milisaniye cinsinden) işlenmeye başlanacağını belirtir.
* attempts: Bir görevin başarısız olması durumunda kaç kez yeniden denenmesi gerektiğini belirtir.
* backoff: Yeniden denemeler arasındaki bekleme süresi stratejisini belirler (fixed veya exponential).
* priority: Görevin önceliğini belirler (daha düşük sayı daha yüksek öncelik anlamına gelir).
* removeOnComplete: Görev başarıyla tamamlandığında Redis’ten otomatik olarak kaldırılıp kaldırılmayacağını belirler (varsayılan: false).
* removeOnFail: Görev başarısız olduğunda Redis’ten otomatik olarak kaldırılıp kaldırılmayacağını belirler (varsayılan: false).
* jobId: Göreve özel bir ID atamanızı sağlar. Bu, idempotency (tekrar çalıştırılabilir olma) için faydalıdır.

Gecikmeli Görevler (Delayed Jobs)

Belirli bir zamanda veya belirli bir gecikmeyle çalıştırılması gereken görevler için delay seçeneğini kullanırız. Örneğin, bir kullanıcının kaydolmasından 24 saat sonra bir hoş geldin e-postası göndermek:

// producer.js
await myQueue.add('sendWelcomeEmail', { userId: 123 }, { delay: 24  60  60 * 1000 }); // 24 saat sonra

Yeniden Denemeler ve Geri Çekilme Stratejileri (Retries and Backoff)

Harici API çağrıları veya geçici veritabanı bağlantı sorunları gibi durumlar için yeniden denemeler kritik öneme sahiptir.

// producer.js
await myQueue.add('processPayment', { orderId: 'xyz' }, {
  attempts: 5, // 5 kez yeniden dene
  backoff: {
    type: 'exponential', // 1s, 2s, 4s, 8s, 16s bekle
    delay: 1000,
  },
});

exponential (üstel) stratejisi, her yeniden deneme arasında bekleme süresini artırarak sistemin toparlanması için zaman tanır. fixed (sabit) ise her seferinde aynı süreyi bekler.

Eşzamanlılık Kontrolü (Concurrency Control)

Bir işçinin aynı anda kaç görevi paralel olarak işleyebileceğini concurrency seçeneği ile kontrol edebilirsiniz:

// worker.js
const myWorker = new Worker('myQueue', async (job) => {
  // Görev işleme mantığı
}, { connection: redisConnection, concurrency: 10 }); // Aynı anda 10 görevi işleyebilir

Bu ayar, işçinizin CPU, bellek veya G/Ç kaynaklarını verimli kullanmasını sağlar. Ağır CPU kullanan görevler için daha düşük bir concurrency değeri, G/Ç yoğun görevler için daha yüksek bir değer tercih edilebilir.

İş Olayları ve Yaşam Döngüsü (Job Events and Lifecycle)

BullMQ, görevlerin yaşam döngüsü boyunca çeşitli olayları dinlemenize olanak tanır. Bu, izleme, hata raporlama veya diğer sistemlerle entegrasyon için çok faydalıdır.

// worker.js
emailWorker.on('active', (job) => {
  console.log(Görev ${job.id} aktif hale geldi.);
});

emailWorker.on('completed', (job, result) => {
  console.log(Görev ${job.id} başarıyla tamamlandı. Sonuç:, result);
  // Örneğin, kullanıcıya başarı bildirim e-postası gönder
});

emailWorker.on('failed', (job, err) => {
  console.error(Görev ${job.id} başarısız oldu. Hata: ${err.message});
  // Örneğin, yöneticiye hata bildirimi gönder
});

emailWorker.on('progress', (job, progress) => {
  console.log(Görev ${job.id} ilerleme: ${progress}%);
});

// Ayrıca kuyruk üzerinde de olayları dinleyebilirsiniz
myQueue.on('error', (err) => {
  console.error('Kuyruk hatası:', err);
});

Bir görevin içinden ilerleme durumu da güncellenebilir:

// worker.js içindeki işleme fonksiyonu
async (job) => {
  for (let i = 0; i <= 100; i += 10) {
    await job.updateProgress(i); // İlerleme durumunu % olarak güncelle
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  return 'İşlem tamamlandı!';
}

Önceliklendirme (Prioritization)

Bazı görevler diğerlerinden daha acil olabilir. priority seçeneği ile görevlere öncelik atayabilirsiniz. Düşük sayı daha yüksek öncelik anlamına gelir.

// producer.js
await myQueue.add('urgentTask', { data: 'critical' }, { priority: 1 });
await myQueue.add('normalTask', { data: 'regular' }, { priority: 5 });

İşçiler, öncelik sırasına göre görevleri kuyruktan çeker.

Akışlar (Flows)

BullMQ’nun en güçlü özelliklerinden biri de “Flows” yani iş akışlarıdır. Birkaç görevi mantıksal olarak birbirine bağlayarak bir zincir veya paralel bir grup halinde çalıştırmanıza olanak tanır. Örneğin, bir kullanıcının profil fotoğrafını yükledikten sonra önce küçük resim oluşturma, ardından yüz tanıma ve son olarak CDN’e yükleme adımlarını içeren bir akış oluşturabilirsiniz.

FlowProducer ve FlowWorker ile akışlar tanımlanır. Bu, karmaşık, çok adımlı iş süreçlerini yönetmek için idealdir.

// flowProducer.js
import { FlowProducer } from 'bullmq';
import { redisConnection } from './redis.js';

const flowProducer = new FlowProducer({ connection: redisConnection });

async function createProfilePictureFlow(userId, imageUrl) {
  const flow = await flowProducer.add({
    name: 'processProfilePicture',
    queueName: 'imageProcessingQueue',
    data: { userId, imageUrl },
    children: [
      {
        name: 'createThumbnail',
        queueName: 'imageProcessingQueue',
        data: { imageUrl, size: 'thumbnail' },
      },
      {
        name: 'detectFaces',
        queueName: 'imageProcessingQueue',
        data: { imageUrl },
        children: [
          {
            name: 'blurFaces',
            queueName: 'imageProcessingQueue',
            data: { imageUrl },
            // Bu görev 'detectFaces' tamamlandığında çalışır
          }
        ]
      },
      {
        name: 'uploadToCDN',
        queueName: 'cdnUploadQueue',
        data: { imageUrl, userId },
      },
    ],
  });
  console.log(Profil fotoğrafı işleme akışı başlatıldı: ${flow.id});
  return flow.id;
}

createProfilePictureFlow(456, 'http://example.com/raw/user456.jpg');

Bu örnekte, processProfilePicture ana görevi altında createThumbnail, detectFaces ve uploadToCDN gibi alt görevler tanımlanmıştır. detectFaces görevinin başarıyla tamamlanmasının ardından blurFaces görevi çalıştırılacaktır.

İzleme ve Yönetim

BullMQ’nun gücünü tam olarak kullanmak için, kuyruklarınızın ve görevlerinizin durumunu izlemek önemlidir.

* BullMQ UI / Bull Board: Bu web tabanlı arayüzler, kuyruklarınızı, aktif, tamamlanmış, başarısız olmuş veya bekleyen görevleri görsel olarak izlemenizi sağlar. Görev verilerini inceleyebilir, yeniden denemeleri manuel olarak başlatabilir veya görevleri silebilirsiniz. Bu, geliştirme ve üretim ortamlarında sorun giderme için paha biçilmez bir araçtır.
* Metrikler: Kuyruk boyutları, işlenme hızları, hata oranları gibi metrikleri izlemek, sisteminizin sağlığı hakkında bilgi verir ve potansiyel darboğazları tespit etmenize yardımcı olur.
* Günlükleme (Logging): İşçilerinizdeki ve kuyruklarınızdaki olayları (görev başladı, bitti, hata verdi) düzgün bir şekilde günlüğe kaydetmek, sorun giderme ve denetim için hayati öneme sahiptir.

Ölçeklenebilirlik ve Dağıtım

BullMQ, tasarımsal olarak ölçeklenebilir bir yapıya sahiptir.

* Yatay Ölçekleme:
* Üreticiler: Birden fazla Node.js uygulamasından görevleri aynı kuyruğa ekleyebilirsiniz. Web sunucularınızın yük dengeleyicinin arkasında birden fazla örneği olabilir ve hepsi aynı BullMQ kuyruğuna görev ekleyebilir.
* İşçiler: Birden fazla Node.js işçi süreci veya sunucusu çalıştırarak aynı kuyruktan görevleri paralel olarak işletebilirsiniz. İş yükü arttıkça yeni işçi örnekleri eklemek kolaydır.
* Redis Yapılandırması: Redis sunucunuzun kendisi yüksek oranda erişilebilir ve kalıcı olmalıdır.
* Kalıcılık: Redis’in RDB (snapshotting) veya AOF (append-only file) kalıcılık mekanizmalarını kullanarak görev verilerinin Redis yeniden başlatıldığında kaybolmamasını sağlayın.
* Yüksek Erişilebilirlik: Üretim ortamlarında Redis Sentinel veya Redis Cluster gibi çözümlerle Redis’in yüksek erişilebilirliğini ve hataya dayanıklılığını sağlayın.
* Docker ve Kubernetes: BullMQ tabanlı uygulamalar, Docker konteynerleri içinde kolayca paketlenebilir ve Kubernetes gibi konteyner orkestrasyon platformları üzerinde dağıtılabilir. Bu, işçi ve üretici servislerini otomatik olarak ölçeklendirmenize, yönetmenize ve izlemenize olanak tanır.

En İyi Uygulamalar

BullMQ ile asenkron görevleri yönetirken dikkate almanız gereken bazı en iyi uygulamalar:

* Görevleri İdempotent Yapın: Bir görev, birden fazla kez çalıştırıldığında aynı sonucu vermelidir. Bu, yeniden denemeler veya sistem arızaları durumunda tutarlılık sağlar.
* Küçük ve Odaklı Görevler: Karmaşık bir işlemi birden fazla küçük, bağımsız göreve bölün. Bu, hata ayıklamayı kolaylaştırır ve görevlerin daha hızlı işlenmesini sağlar.
* Anlamlı Görev Verileri: Görevlere yalnızca işlenmesi için gerekli olan verileri iletin. Büyük nesneleri doğrudan kuyruğa eklemek yerine, veritabanı ID’leri veya dosya yolları gibi referanslar kullanın.
* Sağlam Hata Yönetimi: İşçi fonksiyonlarınızda kapsamlı try-catch blokları kullanarak potansiyel hataları yakalayın ve uygun şekilde günlüğe kaydedin. BullMQ’nun yeniden deneme ve başarısız görev olaylarını kullanarak hataları izleyin.
* İzleme ve Uyarılar: Kuyruk boyutlarını, işlenme hızlarını ve hata oranlarını sürekli izleyin. Belirli eşiklerin aşılması durumunda otomatik uyarılar alacak şekilde sisteminizi yapılandırın.
* Test Etme: Görev işleme mantığınızı, özellikle yeniden denemeler ve kenar durumlar (edge cases) için kapsamlı bir şekilde test edin.
* Zarif Kapanma (Graceful Shutdown): Uygulamanız veya işçi süreçleriniz kapatılırken, devam eden görevlerin tamamlanmasını beklemeli veya güvenli bir şekilde iptal etmelidir. BullMQ, işçilerin close() metodunu çağırarak bu durumu yönetmenize yardımcı olur.

// worker.js'e ekleyin
process.on('SIGINT', async () => {
  console.log('İşçi kapanma sinyali aldı, mevcut görevlerin bitmesi bekleniyor...');
  await emailWorker.close();
  console.log('İşçi kapatıldı.');
  process.exit(0);
});

Sonuç

Node.js, tek iş parçacıklı mimarisi nedeniyle uzun süreli veya yoğun görevlerin doğrudan olay döngüsünde çalıştırılmasından kaçınmayı gerektirir. BullMQ, bu zorluğu aşmak için Redis tabanlı, güçlü ve modern bir çözüm sunar. Asenkron görevleri kuyruğa alarak, uygulamanızın yanıt verebilirliğini, ölçeklenebilirliğini ve güvenilirliğini önemli ölçüde artırabilirsiniz.

Bu makalede ele aldığımız temel kurulumdan gelişmiş özelliklere (gecikmeli görevler, yeniden denemeler, eşzamanlılık kontrolü, olaylar, akışlar) kadar, BullMQ, Node.js uygulamalarınızda karmaşık iş akışlarını yönetmek için gereken tüm araçları sağlar. Doğru yapılandırma ve en iyi uygulamalarla, BullMQ, uygulamanızın performansını ve kullanıcı deneyimini iyileştiren sağlam ve dayanıklı bir arka plan görev işleme sistemi oluşturmanıza olanak tanır. Asenkron görev yönetimini benimsemek, modern, yüksek performanslı Node.js uygulamaları geliştirmenin temel bir adımıdır ve BullMQ bu yolculukta güvenilir bir müttefiktir.