A hozzád hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk. Olvass tovább.

Webfejlesztőként kulcsfontosságú, hogy alkalmazásai a lehető leggyorsabban működjenek. Olyan webalkalmazásokat kell készítenie, amelyek a lehető leggyorsabban válaszolnak a kérésekre.

A sok technológia egyike, amelyek segíthetnek Önnek, a feladatsorolás.

Tehát mi az a feladatsorolás, és hogyan használhatod a Node.js alkalmazás optimalizálására?

Mi az a Task Queuing?

Az üzenetsorolás két alkalmazás vagy szolgáltatás közötti aszinkron kommunikáció eszköze, amelyet általában a termelő és fogyasztó. Ez egy jól ismert koncepció, amelyet szerver nélküli és mikroszolgáltatási architektúrákban alkalmaznak.

A koncepció feladat vagy munkasorban állás kihasználja az üzenetsort az alkalmazások teljesítményének javítása érdekében. Elvonja az üzenetek kezelésének bonyolultságait, és lehetővé teszi, hogy függvényeket határozzon meg a feladatok vagy feladatok aszinkron kezeléséhez egy sor használatával, ezáltal csökkentve az üzenetkezelés sebességét.

instagram viewer
memóriahasználat az alkalmazás egyes részeiben.

Az üzenetsor-szoftverek leggyakoribb példája a RabbitMQ. A feladatsor eszközei közé tartozik a Celery és a Bull. A RabbitMQ-t úgy is beállíthatja, hogy feladatsorként működjön. Olvasson tovább, ha többet szeretne megtudni a feladatsorról a Node.js-ben a Bull használatával.

Mi az a BullMQ?

A BullMQ (Bull.js) egy Node.js könyvtár, amelyet a Node-alkalmazások sorainak megvalósítására használnak. A Bull egy Redis-alapú rendszer (lehet, hogy jobban ismeri a Redis-t, mint eszközt a gyors adattárolás).

A Bull számos feladathoz használható, például késleltetett jobok, ütemezett jobok, megismételhető jobok, prioritásos várólisták és sok más megvalósításához.

Tehát hogyan használhatja a Bull és a Redis segítségével a Node.js feladatokat aszinkron módon?

A Bull és a Redis konfigurálása a feladatsorhoz a Node.js-ben

A Node.js-ben a Bull-lal végzett feladatsorolás megkezdéséhez telepítenie kell a Node.js-t és a Redis-t a gépen. Követheti a Redis Labs útmutató a Redis telepítéséhez ha nincs telepítve.

A Bull megvalósításának első lépése az, hogy futtatással hozzáadja a projekt függőségeihez npm install bull vagy fonal add bull a projekt mappájában található terminálban. Számos módja van a sor inicializálásának a Bullban, az alábbiak szerint:

const Sor = igényelnek('bika');
// a sor inicializálásának különböző módjai
// - redis URL karakterlánc használatával
const emailQueue = új sor("E-mail sor", "redis://127.0.0.1:6379");


// - redis kapcsolattal és sorbeállításokkal
const videoQueue = új sor("Videósor", "redis://127.0.0.1:6379", queueOptions);


// - redis kapcsolat nélkül, de queueOption-val
const docQueue = új sor("Dokumentum sor", queueOptions);
// - redis kapcsolat vagy sorbeállítások nélkül
const QueueClient = új sor("Az én sorom");

Ezek mindegyike minimális konfigurációt használ a Bull Node.js-ben. Az opciók objektum számos tulajdonságot támogat, és megtudhatja őket a sorbeállítások szakasza a Bull dokumentációjában.

E-mail feladatsor megvalósítása BullMQ használatával

Az e-mailek küldésére szolgáló sor megvalósításához meghatározhatja a termelői funkciót, amely hozzáadja az e-maileket az e-mailek sorához, és egy fogyasztói funkciót, amely kezeli az e-mailek küldését.

Először is inicializálhatja a sort egy osztályban egy Redis URL-cím és néhány soropció használatával, az alábbiak szerint.

// queueHandler.js
const Sor = igényelnek('bika');
// használj itt valódi e-mail kezelő modult - ez csak egy példa
const emailHandler = igényelnek('./emailHandler.js');


// konstansok, Redis URL és sorbeállítások meghatározása
const REDIS_URL = "redis://127.0.0.1:6379";


const queueOpts = {
// sebességkorlátozó opciók a sor túlterhelésének elkerülése érdekében
 limiter: {
// a sor által elfoglalt feladatok maximális száma
 max: 100,


// várakozási idő ezredmásodpercben, mielőtt új munkákat fogadna el
// eléri a határt
 időtartam: 10000
 },
 előtag: 'EMAIL-FELADAT', // az összes sorkulcshoz hozzáadandó előtag
 defaultJobOptions: { // a sorban lévő feladatok alapértelmezett beállításai
 próbálkozások: 3, // a feladat újrapróbálkozásainak alapértelmezett száma


// egy feladat eltávolítása a sorból a befejezés után
 RemoveOnComplete: igaz
 }
};


osztályEmailQueue{
konstruktőr() {
ez.queue = új sor("E-mail sor", REDIS_URL, queueOpts);
 }
};
exportalapértelmezett EmailQueue; // exportálja az osztályt

Most, hogy inicializált egy sort, meghatározhatja a termelői függvényt (a Bull's segítségével add() függvény) módszereként a EmailQueue osztályt, hogy e-maileket adjon a feladatsorhoz. A következő kódblokk ezt szemlélteti:

// queueHandler.js
osztályEmailQueue{
konstruktőr () {
// ...
 }


// produceri függvény e-mailek hozzáadásához a sorhoz
async addEmailToQueue (emailData) {
// 'email_notification' nevű feladat hozzáadása a sorhoz
várjaez.queue.add('Email értesítés', emailData);
konzol.log('az e-mail felkerült a sorba...');
 }
};
exportalapértelmezett EmailQueue; // exportálja az osztályt

A termelő függvény készen áll, és most már definiálhat egy fogyasztói függvényt (a Bull's folyamat() függvény) a sorban lévő összes e-mail feladat feldolgozásához – pl. e-mail küldéséhez hívja meg a funkciót. Ezt a fogyasztói függvényt az osztály konstruktorában kell meghatározni.

// queueHandler.js
osztályEmailQueue{
konstruktőr () {
// ...
// fogyasztói függvény, amely átveszi a feladat hozzárendelt nevét és
// visszahívási függvény
ez.queue.process('Email értesítés', async (emailJob, kész) => {
konzol.log("e-mail értesítési feladat feldolgozása");
várja emailHandler.sendEmail (emailJob); // küldje el az e-mailt
 Kész(); // fejezze be a feladatot
 })
 }
// ...
};
exportalapértelmezett EmailQueue; // exportálja az osztályt

Egy jobnak lehetõségei is lehetnek arra, hogy meghatározzák viselkedését a sorban, vagy azt, hogy a fogyasztói függvény hogyan kezelje azt. Erről többet megtudhat a a Bull dokumentációjának munkalehetőségek szakasza.

A emailJob Az argumentum egy olyan objektum, amely a feladat tulajdonságait tartalmazza a várólista feldolgozásához. Tartalmazza az e-mail összeállításához szükséges főbb adatokat is. A könnyebb érthetőség érdekében a küldjön e-mailt() függvény hasonló lenne ehhez a példához:

// emailHandler.js
const sendgridMail = igényelnek("@sendgrid/mail");
const apiKey = process.env. SENDGRID_API_KEY


sendgridMail.setApiKey (apiKey); // az e-mail transzporter biztonsági hitelesítő adatainak beállítása


const sendEmail = async (emailJob) => {
próbáld ki {
// kivonja az e-mail adatokat a munkából
const { name, email } = emailJob.data;


const üzenet = {
tól től: "[email protected]",
 nak nek: "[email protected]",
 tantárgy: 'Szia! Üdvözöljük',
 szöveg: `Szia ${name}, üdvözöljük a MUO-ban
 };


várja sendgridMail.sendMail (üzenet); // küldjön e-mailt


// feladat megjelölése befejezettként a sorban
várja emailJob.moveToCompleted('Kész', igaz);
konzol.log('Az e-mail sikeresen elküldve...');
 } fogás (hiba) {
// a feladat áthelyezése sikertelen feladatokra
várja emailJob.moveToFailed({ üzenet: "A feladat feldolgozása nem sikerült.." });
konzol.error (hiba); // naplózza a hibát
 }
}
exportalapértelmezett küldjön e-mailt;

Most, hogy mind a termelői, mind a fogyasztói funkciók definiáltak és használatra készen állnak, az alkalmazásban bárhol hívhatja a termelői funkciót, és hozzáadhat egy e-mailt a feldolgozási sorhoz.

Egy példa vezérlő így nézne ki:

// userController.js
const EmailQueue = igényelnek("../handlers/queueHandler.js")
const regisztráció = async (req, res) => {
const { név, e-mail, jelszó } = req.body;


// -- 
// lekérdezés az új felhasználó hozzáadásához az adatbázishoz...
// --


// hozzáadása az e-mail sorhoz
const emailData = { név, email };
várja EmailQueue.addEmailToQueue (emailData);
 res.status(200).json({
 üzenet: "Sikeres regisztráció, kérjük ellenőrizze e-mailjeit"
 })
}

A te queueHandler.js a fájlnak most a következőnek kell lennie:

// queueHandler.js
const Sor = igényelnek('bika');
const emailHandler = igényelnek("../handlers/emailHandler.js");
const REDIS_URL = "redis://127.0.0.1:6379";


const queueOpts = {
 limiter: { 
 max: 100, 
 időtartam: 10000
 },


 előtag: 'EMAIL-FELADAT',


 defaultJobOptions: {
 próbálkozások: 3, 
 RemoveOnComplete: igaz
 }
};


osztályEmailQueue{
konstruktőr() {
ez.queue = új sor("E-mail sor", REDIS_URL, queueOpts);


// fogyasztó
ez.queue.process('Email értesítés', async (emailJob, kész) => {
konzol.log("e-mail értesítési feladat feldolgozása");
várja emailHandler.sendEmail (emailJob);
 Kész();
 })
 }


// termelő
async addEmailToQueue (emailData) {
// 'email_notification' nevű feladat hozzáadása a sorhoz
várjaez.queue.add('Email értesítés', emailData);
konzol.log('az e-mail felkerült a sorba...');
 }
};
exportalapértelmezett EmailQueue;

Ha ezt egy Node.js REST API-ban implementálja, a regisztrációs végpont válaszidejének csökkenése és az e-mailek kézbesítési ideje az alternatívához képest csökken.

A feladatsorok lehetővé tették a regisztrációs és e-mail-hibák önálló kezelését is.

Alkalmazások optimalizálása feladatsorok használatával

Az üzenet- és feladatsorok nagyszerű módot jelentenek az alkalmazások általános teljesítményének javítására. Ezenkívül nagyon olcsók, és az alkalmazás annyi részében használhatja őket, amennyire szüksége van.

Bár ez az oktatóanyag az e-maileket példaként használta a memóriaigényes, sorokkal járó feladatok kezeléséhez, sok más eset is alkalmazható, amikor ugyanezeket a koncepciókat alkalmazhatja. Ide tartoznak a nehéz olvasási/írási műveletek, a kiváló minőségű képek vagy dokumentumok renderelése, valamint a tömeges értesítések küldése.