În calitate de dezvoltator web, este esențial ca aplicațiile dvs. să funcționeze cât de repede pot. Ar trebui să creați aplicații web care să răspundă solicitărilor în cel mai scurt timp posibil.
Una dintre multele tehnologii care vă pot ajuta este punerea în așteptare a sarcinilor.
Deci, ce este coada de sarcini și cum o puteți folosi pentru a optimiza o aplicație Node.js?
Ce este Task Queuing?
Coada de mesaje este un mijloc de comunicare asincronă între două aplicații sau servicii, denumit de obicei producător și consumator. Este un concept binecunoscut folosit în arhitecturile serverless și microservicii.
Conceptul de sarcină sau loc de muncala coadă folosește coada de mesaje pentru a îmbunătăți performanța aplicației. Abstrage complexitatea gestionării mesajelor și vă permite să definiți funcții pentru a gestiona sarcini sau sarcini în mod asincron folosind o coadă, reducând astfel rata de
folosirea memoriei în unele părți ale unei aplicații.Cel mai comun exemplu de software pentru coadă de mesaje este RabbitMQ. Instrumentele de coadă de sarcini includ țelină și taur. De asemenea, puteți configura RabbitMQ să funcționeze ca o coadă de activități. Citiți mai departe pentru a afla despre așteptarea sarcinilor în Node.js folosind Bull.
Ce este BullMQ?
BullMQ (Bull.js) este o bibliotecă Node.js utilizată pentru implementarea cozilor în aplicațiile Node. Bull este un sistem bazat pe Redis (s-ar putea să fiți mai familiarizați cu Redis ca instrument pentru stocare rapidă a datelor) și este o opțiune rapidă și fiabilă de luat în considerare pentru așteptarea sarcinilor în Node.js.
Puteți utiliza Bull pentru multe sarcini, cum ar fi implementarea de joburi întârziate, joburi programate, joburi repetabile, cozi prioritare și multe altele.
Deci, cum puteți folosi Bull și Redis pentru a rula sarcinile Node.js asincron?
Cum să configurați Bull și Redis pentru așteptarea sarcinilor în Node.js
Pentru a începe cu așteptarea sarcinilor în Node.js cu Bull, aveți nevoie de instalarea Node.js și Redis pe computer. Puteți urmări Ghidul laboratoarelor Redis pentru a instala Redis daca nu il ai instalat.
Primul pas pentru implementarea Bull este să îl adăugați la dependențele proiectului dvs. prin rulare npm instalează bull sau fire adăuga taur în terminalul din dosarul proiectului. Există mai multe moduri de a inițializa o coadă în Bull, după cum se arată mai jos:
const coada = cere('Taur');// moduri diferite de a inițializa o coadă
// - folosind șirul URL redis
const emailQueue = nou Coadă(„Coada de e-mail”, „redis://127.0.0.1:6379”);// - cu o conexiune redis și obiect de opțiuni de coadă
const videoQueue = nou Coadă(„Coada video”, „redis://127.0.0.1:6379”, queueOptions);// - fără o conexiune redis, dar cu queueOption
const docQueue = nou Coadă(„Coada de documente”, queueOptions);
// - fără o conexiune redis sau opțiuni de coadă
const QueueClient = nou Coadă(„Coada mea”);
Toate acestea folosesc o configurație minimă pentru Bull în Node.js. Obiectul opțiuni acceptă multe proprietăți și puteți afla despre ele în secțiunea de opțiuni de coadă din documentația Bull.
Implementarea unei cozi de sarcini de e-mail folosind BullMQ
Pentru a implementa o coadă pentru trimiterea de e-mailuri, puteți defini funcția de producător care adaugă e-mailuri la coada de e-mail și o funcție de consum pentru a gestiona trimiterea de e-mailuri.
În primul rând, vă puteți inițializa coada într-o clasă folosind o adresă URL Redis și unele opțiuni de coadă, așa cum se vede mai jos.
// queueHandler.js
const coada = cere('Taur');// folosiți un modul real de gestionare a e-mailului aici - acesta este doar un exemplu
const emailHandler = cere(„./emailHandler.js”);// definește constante, URL Redis și opțiuni de coadă
const REDIS_URL = „redis://127.0.0.1:6379”;const queueOpts = {
// opțiuni de limitare a ratei pentru a evita supraîncărcarea cozii
limitator: {
// numărul maxim de sarcini pe care le poate lua coada
max: 100,// timp de așteptare în milisecunde înainte de a accepta noi locuri de muncă după
// atingerea limită
durată: 10000
},
prefix: „EMAIL-TASK”, // un prefix care trebuie adăugat la toate cheile de coadă
defaultJobOptions: { // opțiuni implicite pentru sarcinile din coadă
incercari: 3, // numărul implicit de ori pentru a reîncerca o sarcină// pentru a elimina o sarcină din coadă după finalizare
removeOnComplete: Adevărat
}
};clasăEmailQueue{
constructor() {
acest.coadă = nou Coadă(„Coada de e-mail”, REDIS_URL, queueOpts);
}
};
exportMod implicit EmailQueue; // exportă clasa
Acum că ați inițializat o coadă, vă puteți defini funcția de producător (folosind Bull's adăuga() funcţia) ca metodă a EmailQueue clasa pentru a adăuga e-mailuri la coada de activități. Următorul bloc de cod demonstrează acest lucru:
// queueHandler.jsclasăEmailQueue{
constructor () {
// ...
}// Funcție de producător pentru a adăuga e-mailuri la coadă
asincron addEmailToQueue (emailData) {
// adăugați sarcina cu numele „email_notification” la coadă
așteaptăacest.coadă.adăugare('notificare prin e-mail', emailData);
consolă.Buturuga(„e-mailul a fost adăugat la coadă...”);
}
};
exportMod implicit EmailQueue; // exportă clasa
Funcția de producător este gata și acum puteți defini o funcție de consum (folosind Bull's proces() funcția) pentru a procesa toate sarcinile de e-mail din coadă, adică apelați funcția pentru a trimite un e-mail. Ar trebui să definiți această funcție de consum în constructorul clasei.
// queueHandler.js
clasăEmailQueue{
constructor () {
// ...// funcție de consum care preia numele atribuit sarcinii și
// o funcție de apel invers
acest.proces.coadă('notificare prin e-mail', asincron (emailJob, terminat) => {
consolă.Buturuga(„procesarea sarcinii de notificare prin e-mail”);
așteaptă emailHandler.sendEmail (emailJob); // trimite e-mailul
Terminat(); // Finalizați sarcina
})
}
// ...
};
exportMod implicit EmailQueue; // exportă clasa
Un job poate avea, de asemenea, opțiuni pentru a-și defini comportamentul în coadă sau modul în care funcția de consumator îl gestionează. Puteți afla mai multe despre acest lucru în secțiunea de opțiuni de muncă din documentația Bull.
The emailJob argumentul este un obiect care conține proprietățile sarcinii pentru ca coada să fie procesată. Include, de asemenea, datele principale necesare pentru a construi e-mailul. Pentru o înțelegere ușoară, Trimite email() funcția ar fi similară cu acest exemplu:
// emailHandler.js
const sendgridMail = cere(„@sendgrid/mail”);const apiKey = process.env. SENDGRID_API_KEY
sendgridMail.setApiKey (apiKey); // setați acreditările de securitate pentru transportorul de e-mail
const trimite e-mail = asincron (emailJob) => {
încerca {
// extrage datele de e-mail din job
const { name, email } = emailJob.data;const mesaj = {
din: „[email protected]”,
la: „[email protected]”,
subiect: 'Bună! Bine ati venit',
text: `Bună ziua ${name}, bun venit la MUO`
};așteaptă sendgridMail.sendMail (mesaj); // Trimite email
// marchează sarcina ca finalizată în coadă
așteaptă emailJob.moveToCompleted('Terminat', Adevărat);
consolă.Buturuga('Email-ul a fost trimis cu succes...');
} captură (eroare) {
// mutați sarcina în joburi eșuate
așteaptă emailJob.moveToFailed({ mesaj: „Procesarea sarcinii a eșuat...” });
consolă.eroare (eroare); // înregistrează eroarea
}
}
exportMod implicit Trimite email;
Acum că aveți atât funcțiile de producător, cât și de consumator definite și gata de utilizare, puteți apela funcția de producător oriunde în aplicație pentru a adăuga un e-mail la coada de așteptare pentru procesare.
Un exemplu de controler ar arăta astfel:
// userController.js
const EmailQueue = cere(„../handlers/queueHandler.js”)const înscriere = asincron (req, res) => {
const { nume, e-mail, parolă } = req.body;// --
// o interogare pentru a adăuga noul utilizator la baza de date...
// --// adaugă la coada de e-mail
const emailData = { nume, e-mail };
așteaptă EmailQueue.addEmailToQueue (emailData);
starea res.(200).json({
mesaj: „Înscrieți-vă cu succes, vă rugăm să vă verificați e-mailul”
})
}
Ta queueHandler.js fișierul ar trebui să fie acum după cum urmează:
// queueHandler.js
const coada = cere('Taur');
const emailHandler = cere(„../handlers/emailHandler.js”);const REDIS_URL = „redis://127.0.0.1:6379”;
const queueOpts = {
limitator: {
max: 100,
durată: 10000
},prefix: „EMAIL-TASK”,
defaultJobOptions: {
incercari: 3,
removeOnComplete: Adevărat
}
};clasăEmailQueue{
constructor() {
acest.coadă = nou Coadă(„Coada de e-mail”, REDIS_URL, queueOpts);// consumator
acest.proces.coadă('notificare prin e-mail', asincron (emailJob, terminat) => {
consolă.Buturuga(„procesarea sarcinii de notificare prin e-mail”);
așteaptă emailHandler.sendEmail (emailJob);
Terminat();
})
}// producător
asincron addEmailToQueue (emailData) {
// adăugați sarcina cu numele „email_notification” la coadă
așteaptăacest.coadă.adăugare('notificare prin e-mail', emailData);
consolă.Buturuga(„e-mailul a fost adăugat la coadă...”);
}
};
exportMod implicit EmailQueue;
Când implementați acest lucru într-un API REST Node.js, veți observa o scădere a timpului de răspuns al punctului final de înscriere și timpi mai rapidi de livrare a e-mailului, în comparație cu alternativa.
Cozile de sarcini v-au permis, de asemenea, să gestionați în mod independent erorile de înscriere și de e-mail.
Optimizarea aplicațiilor utilizând cozile de sarcini
Cozile de mesaje și sarcini sunt o modalitate excelentă de a îmbunătăți performanța generală a aplicațiilor. De asemenea, sunt foarte ieftine și le puteți folosi în câte părți ale unei aplicații aveți nevoie.
Deși acest tutorial a folosit e-mailurile ca exemplu de scenariu pentru gestionarea sarcinilor consumatoare de memorie cu cozi, există multe alte cazuri în care puteți aplica aceleași concepte. Acestea includ operațiuni grele de citire/scriere, redarea de imagini sau documente de înaltă calitate și trimiterea de notificări în bloc.
