Pembaca seperti Anda membantu mendukung MUO. Saat Anda melakukan pembelian menggunakan tautan di situs kami, kami dapat memperoleh komisi afiliasi. Baca selengkapnya.

Sebagai developer web, sangat penting agar aplikasi Anda bekerja secepat mungkin. Anda harus membuat aplikasi web yang merespons permintaan secepat mungkin.

Salah satu dari banyak teknologi yang dapat membantu Anda adalah antrian tugas.

Jadi, apa itu antrian tugas, dan bagaimana Anda menggunakannya untuk mengoptimalkan aplikasi Node.js?

Apa itu Antrian Tugas?

Antrian pesan adalah sarana komunikasi asinkron antara dua aplikasi atau layanan, biasanya disebut sebagai produsen Dan konsumen. Ini adalah konsep terkenal yang digunakan dalam arsitektur tanpa server dan layanan mikro.

Konsep dari tugas atau pekerjaanmengantri memanfaatkan antrian pesan untuk meningkatkan kinerja aplikasi. Ini abstrak kompleksitas mengelola pesan dan memungkinkan Anda untuk menentukan fungsi untuk mengelola pekerjaan atau tugas asinkron menggunakan antrian, sehingga mengurangi tingkat penggunaan memori di beberapa bagian aplikasi.

instagram viewer

Contoh paling umum dari perangkat lunak antrian pesan adalah RabbitMQ. Alat antrian tugas termasuk Celery dan Bull. Anda juga dapat mengonfigurasi RabbitMQ agar berfungsi sebagai antrian tugas. Baca terus untuk mengetahui tentang antrian tugas di Node.js menggunakan Bull.

Apa itu BullMQ?

BullMQ (Bull.js) adalah pustaka Node.js yang digunakan untuk mengimplementasikan antrean di aplikasi Node. Bull adalah sistem berbasis Redis (Anda mungkin lebih akrab dengan Redis sebagai alat untuk penyimpanan data cepat) dan merupakan opsi yang cepat dan andal untuk dipertimbangkan dalam antrian tugas di Node.js.

Anda dapat menggunakan Bull untuk banyak tugas seperti mengimplementasikan pekerjaan tertunda, pekerjaan terjadwal, pekerjaan berulang, antrean prioritas, dan banyak lagi.

Jadi, bagaimana Anda bisa menggunakan Bull dan Redis untuk menjalankan tugas Node.js secara asinkron?

Cara Mengonfigurasi Bull dan Redis untuk Task Queuing di Node.js

Untuk memulai antrian tugas di Node.js dengan Bull, Anda perlu menginstal Node.js dan Redis di mesin Anda. Anda dapat mengikuti Panduan lab Redis untuk menginstal Redis jika Anda belum menginstalnya.

Langkah pertama untuk mengimplementasikan Bull adalah menambahkannya ke dependensi proyek Anda dengan menjalankan npm instal banteng atau benang tambahkan banteng di terminal di dalam folder proyek Anda. Ada beberapa cara untuk menginisialisasi antrean di Bull seperti yang ditunjukkan di bawah ini:

const Antrian = memerlukan('banteng');
// berbagai cara untuk menginisialisasi antrean
// - menggunakan string URL redis
const emailQueue = baru Antre('Antrian Email', 'redis://127.0.0.1:6379');


// - dengan koneksi redis dan objek opsi antrean
const videoQueue = baru Antre('Antrian Video', 'redis://127.0.0.1:6379', antrianPilihan);


// - tanpa koneksi redis tetapi dengan queueOption
const docQueue = baru Antre('Antrian Dokumen', antrianPilihan);
// - tanpa koneksi redis atau opsi antrean
const QueueClient = baru Antre('Antrian Saya');

Ini semua menggunakan konfigurasi minimal untuk Bull di Node.js. Objek opsi mendukung banyak properti dan Anda dapat mempelajarinya di bagian opsi antrean dari dokumentasi Bull.

Menerapkan Antrian Tugas Email Menggunakan BullMQ

Untuk menerapkan antrean pengiriman email, Anda dapat menentukan fungsi produsen yang menambahkan email ke antrean email, dan fungsi konsumen untuk menangani pengiriman email.

Pertama, Anda dapat menginisialisasi antrean di kelas menggunakan URL Redis dan beberapa opsi antrean seperti yang terlihat di bawah ini.

// antrianHandler.js
const Antrian = memerlukan('banteng');
// gunakan modul penangan email asli di sini - ini hanya sebuah contoh
const emailHandler = memerlukan('./emailHandler.js');


// tentukan konstanta, Redis URL, dan opsi antrean
const REDIS_URL = 'redis://127.0.0.1:6379';


const antrianPilihan = {
// opsi rate limiter untuk menghindari antrian yang berlebihan
 pembatas: {
// jumlah maksimum antrian tugas yang dapat diambil
 maks: 100,


// waktu untuk menunggu dalam milidetik sebelum menerima pekerjaan baru setelahnya
// mencapai batas
 durasi: 10000
 },
 awalan: 'TUGAS EMAIL', // awalan yang akan ditambahkan ke semua kunci antrean
 defaultJobOptions: { // opsi default untuk tugas dalam antrean
 upaya: 3, // default berapa kali untuk mencoba kembali tugas


// untuk menghapus tugas dari antrian setelah selesai
 hapusOnComplete: BENAR
 }
};


kelasEmailAntrean{
konstruktor() {
ini.antrian = baru Antre('Antrian Email', REDIS_URL, antrianOpts);
 }
};
eksporbawaan Antrean Email; // ekspor kelas

Sekarang setelah Anda menginisialisasi antrean, Anda dapat menentukan fungsi produser (menggunakan Bull's menambahkan() fungsi) sebagai metode EmailAntrean kelas untuk menambahkan email ke antrean tugas. Blok kode berikut menunjukkan ini:

// antrianHandler.js
kelasEmailAntrean{
konstruktor () {
// ...
 }


// fungsi produser untuk menambahkan email ke antrean
asinkron addEmailToQueue (emailData) {
// tambahkan tugas dengan nama 'email_notification' ke antrian
menungguini.queue.add('pemberitahuan email', emailData);
menghibur.catatan('email telah ditambahkan ke antrean...');
 }
};
eksporbawaan Antrean Email; // ekspor kelas

Fungsi produser sudah siap, dan sekarang Anda dapat menentukan fungsi konsumen (menggunakan Bull's proses() function) untuk memproses semua tugas email dalam antrean—mis. memanggil fungsi untuk mengirim email. Anda harus mendefinisikan fungsi konsumen ini di konstruktor kelas.

// antrianHandler.js
kelasEmailAntrean{
konstruktor () {
// ...
// fungsi konsumen yang menggunakan nama tugas yang ditetapkan dan
// fungsi panggilan balik
ini.queue.proses('pemberitahuan email', asinkron (Pekerjaan email, selesai) => {
menghibur.catatan('memproses tugas pemberitahuan email');
menunggu emailHandler.sendEmail (emailJob); // kirim email
 Selesai(); // selesaikan tugas
 })
 }
// ...
};
eksporbawaan Antrean Email; // ekspor kelas

Pekerjaan juga dapat memiliki opsi untuk menentukan perilakunya dalam antrean atau cara fungsi konsumen menanganinya. Anda dapat mengetahui lebih lanjut tentang ini di bagian opsi pekerjaan dari dokumentasi Bull.

Itu pekerjaan email argumen adalah objek yang berisi properti tugas untuk diproses antrian. Ini juga mencakup data utama yang diperlukan untuk membuat email. Untuk memudahkan pemahaman, mengirim email() fungsinya akan mirip dengan contoh ini:

// emailHandler.js
const sendgridMail = memerlukan('@sendgrid/mail');
const apiKey = process.env. SENDGRID_API_KEY


sendgridMail.setApiKey (apiKey); // atur kredensial keamanan transporter email


const kirimEmail = asinkron (pekerjaan email) => {
mencoba {
// ekstrak data email dari pekerjaan
const { nama, email } = emailPekerjaan.data;


const pesan = {
dari: '[email protected]',
 ke: '[email protected]',
 subjek: 'Hai! Selamat datang',
 teks: `Halo ${nama}, selamat datang di MUO`
 };


menunggu sendgridMail.sendMail (pesan); // mengirim email


// tandai tugas sebagai selesai dalam antrian
menunggu emailJob.moveToCompleted('Selesai', BENAR);
menghibur.catatan('Email berhasil dikirim...');
 } menangkap (kesalahan) {
// pindahkan tugas ke pekerjaan yang gagal
menunggu emailJob.moveToFailed({ pesan: 'pemrosesan tugas gagal..' });
menghibur.error (kesalahan); // mencatat kesalahan
 }
}
eksporbawaan mengirim email;

Sekarang setelah fungsi produsen dan konsumen ditentukan dan siap digunakan, Anda sekarang dapat memanggil fungsi produsen di mana saja dalam aplikasi Anda untuk menambahkan email ke antrean untuk diproses.

Pengontrol contoh akan terlihat seperti ini:

// penggunaController.js
const EmailQueue = memerlukan('../handlers/queueHandler.js')
const mendaftar = asinkron (req, res) => {
const { nama, email, password } = req.body;


// -- 
// kueri untuk menambahkan pengguna baru ke Database...
// --


// tambahkan ke antrean Email
const emailData = { nama, email };
menunggu EmailQueue.addEmailToQueue (emailData);
 res.status(200).json({
 pesan: "Pendaftaran berhasil, silakan periksa email Anda"
 })
}

Milikmu antrianHandler.js file sekarang harus sebagai berikut:

// antrianHandler.js
const Antrian = memerlukan('banteng');
const emailHandler = memerlukan('../handlers/emailHandler.js');
const REDIS_URL = 'redis://127.0.0.1:6379';


const antrianPilihan = {
 pembatas: { 
 maks: 100, 
 durasi: 10000
 },


 awalan: 'TUGAS EMAIL',


 defaultJobOptions: {
 upaya: 3, 
 hapusOnComplete: BENAR
 }
};


kelasEmailAntrean{
konstruktor() {
ini.antrian = baru Antre('Antrian Email', REDIS_URL, antrianOpts);


// konsumen
ini.queue.proses('pemberitahuan email', asinkron (Pekerjaan email, selesai) => {
menghibur.catatan('memproses tugas pemberitahuan email');
menunggu emailHandler.sendEmail (emailJob);
 Selesai();
 })
 }


// produser
asinkron addEmailToQueue (emailData) {
// tambahkan tugas dengan nama 'email_notification' ke antrian
menungguini.queue.add('pemberitahuan email', emailData);
menghibur.catatan('email telah ditambahkan ke antrean...');
 }
};
eksporbawaan Antrean Email;

Saat Anda mengimplementasikan ini di API REST Node.js, Anda akan melihat penurunan waktu respons titik akhir pendaftaran, dan waktu pengiriman email yang lebih cepat, dibandingkan dengan alternatifnya.

Antrean tugas juga memungkinkan Anda menangani kesalahan pendaftaran dan email secara mandiri.

Mengoptimalkan Aplikasi Menggunakan Antrian Tugas

Antrean pesan dan tugas adalah cara terbaik untuk meningkatkan kinerja umum aplikasi. Mereka juga sangat murah dan Anda dapat menggunakannya di banyak bagian aplikasi yang Anda butuhkan.

Meskipun tutorial ini menggunakan email sebagai contoh skenario untuk menangani tugas yang menghabiskan memori dengan antrean, ada banyak kasus lain di mana Anda dapat menerapkan konsep yang sama. Ini termasuk operasi baca/tulis yang berat, merender gambar atau dokumen berkualitas tinggi, dan mengirimkan pemberitahuan massal.