Som nettutvikler er det avgjørende at appene dine yter så raskt de kan. Du bør bygge nettapper som svarer på forespørsler på raskest mulig tid.
En av de mange teknologiene som kan hjelpe deg er oppgavekø.
Så, hva er oppgavekø, og hvordan kan du bruke det til å optimalisere en Node.js-applikasjon?
Hva er Task Queuing?
Meldingskø er et middel for asynkron kommunikasjon mellom to applikasjoner eller tjenester, vanligvis referert til som produsent og forbruker. Det er et velkjent konsept som brukes i serverløse og mikrotjenestearkitekturer.
Konseptet av oppgave eller jobbi kø utnytter meldingskø for å forbedre applikasjonsytelsen. Den abstraherer kompleksiteten ved å administrere meldinger og lar deg definere funksjoner for å administrere jobber eller oppgaver asynkront ved hjelp av en kø, og reduserer dermed frekvensen av minnebruk i enkelte deler av en applikasjon.
Det vanligste eksemplet på programvare for meldingskø er RabbitMQ. Verktøy for oppgavekø inkluderer Selleri og Bull. Du kan også konfigurere RabbitMQ til å fungere som en oppgavekø. Les videre for å lære om oppgavekø i Node.js ved å bruke Bull.
Hva er BullMQ?
BullMQ (Bull.js) er et Node.js-bibliotek som brukes til å implementere køer i Node-applikasjoner. Bull er et Redis-basert system (du er kanskje mer kjent med Redis som et verktøy for rask datalagring), og det er et raskt og pålitelig alternativ å vurdere for oppgavekø i Node.js.
Du kan bruke Bull til mange oppgaver som å implementere forsinkede jobber, planlagte jobber, repeterbare jobber, prioriterte køer og mange flere.
Så hvordan kan du bruke Bull og Redis til å kjøre Node.js-oppgaver asynkront?
Hvordan konfigurere Bull og Redis for oppgavekø i Node.js
For å komme i gang med oppgavekø i Node.js med Bull, trenger du Node.js og Redis installert på maskinen din. Du kan følge Redis laboratorieveiledning for å installere Redis hvis du ikke har den installert.
Det første trinnet for å implementere Bull er å legge det til prosjektets avhengigheter ved å kjøre npm installer bull eller garn legge okse i terminalen inne i prosjektets mappe. Det er flere måter å initialisere en kø i Bull som vist nedenfor:
konst Kø = krever('okse');// forskjellige måter å initialisere en kø på
// - ved å bruke redis URL-streng
konst emailQueue = ny Kø("E-postkø", 'redis://127.0.0.1:6379');// - med en redis-tilkobling og et køalternativ-objekt
konst videokø = ny Kø('Videokø', 'redis://127.0.0.1:6379', køalternativer);// - uten redis-tilkobling, men med queueOption
konst docQueue = ny Kø('Dokumentkø', køalternativer);
// - uten redis-tilkobling eller køalternativer
konst QueueClient = ny Kø('Min kø');
Disse bruker alle minimal konfigurasjon for Bull i Node.js. Alternativer-objektet støtter mange egenskaper, og du kan lære om dem i delen for køalternativer i Bulls dokumentasjon.
Implementere en e-postoppgavekø ved hjelp av BullMQ
For å implementere en kø for sending av e-post, kan du definere produsentfunksjonen din som legger til e-post i e-postkøen, og en forbrukerfunksjon for å håndtere sending av e-post.
For det første kan du initialisere køen din i en klasse ved å bruke en Redis URL og noen køalternativer som vist nedenfor.
// queueHandler.js
konst Kø = krever('okse');// bruk en ekte e-postbehandlermodul her - dette er bare et eksempel
konst emailHandler = krever('./emailHandler.js');// definerer konstanter, Redis URL og køalternativer
konst REDIS_URL = 'redis://127.0.0.1:6379';konst queueOpts = {
// rate limiter alternativer for å unngå overbelastning av køen
begrenser: {
// maksimalt antall oppgaver køen kan ta
maks: 100,// tid til å vente i millisekunder før du godtar nye jobber etter
// når grensen
varighet: 10000
},
prefiks: 'EMAIL-TASK', // et prefiks som skal legges til alle kønøkler
defaultJobOptions: { // standardvalg for oppgaver i køen
forsøk: 3, // standard antall ganger for å prøve en oppgave på nytt// for å fjerne en oppgave fra køen etter fullføring
removeOnComplete: ekte
}
};klasseE-postkø{
konstruktør() {
dette.kø = ny Kø("E-postkø", REDIS_URL, queueOpts);
}
};
eksportmisligholde EmailQueue; // eksporter klassen
Nå som du har initialisert en kø, kan du definere produsentfunksjonen din (ved å bruke Bull's Legg til() funksjon) som en metode for E-postkø klasse for å legge til e-poster i oppgavekøen. Følgende kodeblokk demonstrerer dette:
// queueHandler.jsklasseE-postkø{
konstruktør () {
// ...
}// produsentfunksjon for å legge til e-poster i køen
asynkron addEmailToQueue (emailData) {
// legg til oppgave med navnet 'email_notification' i køen
avventedette.queue.add('email_notification', e-postdata);
konsoll.Logg('e-posten er lagt til i køen...');
}
};
eksportmisligholde EmailQueue; // eksporter klassen
Produsentfunksjonen er klar, og du kan nå definere en forbrukerfunksjon (ved hjelp av Bull's prosess() funksjon) for å behandle alle e-postoppgaver i køen – dvs. ring funksjonen for å sende en e-post. Du bør definere denne forbrukerfunksjonen i konstruktøren til klassen.
// queueHandler.js
klasseE-postkø{
konstruktør () {
// ...// forbrukerfunksjon som tar inn det tildelte navnet på oppgaven og
// en tilbakeringingsfunksjon
dette.queue.process('email_notification', asynkron (e-postjobb, ferdig) => {
konsoll.Logg("behandler e-postvarslingsoppgave");
avvente emailHandler.sendEmail (emailJob); // send e-posten
ferdig(); // fullfør oppgaven
})
}
// ...
};
eksportmisligholde EmailQueue; // eksporter klassen
En jobb kan også ha alternativer for å definere atferden i køen eller hvordan forbrukerfunksjonen håndterer den. Du kan finne ut mer om dette i jobbalternativer i Bulls dokumentasjon.
De e-postjobb argument er et objekt som inneholder egenskapene til oppgaven som køen skal behandle. Den inkluderer også hoveddataene som trengs for å konstruere e-posten. For enkel forståelse Send e-post() funksjonen vil være lik dette eksemplet:
// emailHandler.js
konst sendgridMail = krever('@sendgrid/mail');konst apiKey = prosess.env. SENDGRID_API_KEY
sendgridMail.setApiKey (apiKey); // angi sikkerhetslegitimasjon for e-posttransporter
konst sendEpost = asynkron (emailJob) => {
prøve {
// trekke ut e-postdataene fra jobben
konst { name, email } = emailJob.data;konst melding = {
fra: '[email protected]',
til: '[email protected]',
Emne: 'Hei! Velkommen',
tekst: `Hei ${name}, velkommen til MUO`
};avvente sendgridMail.sendMail (melding); // Send e-post
// merk oppgaven som fullført i køen
avvente emailJob.moveToCompleted("ferdig", ekte);
konsoll.Logg("E-post sendt...");
} å fange (feil) {
// flytt oppgaven til mislykkede jobber
avvente emailJob.moveToFailed({ beskjed: 'oppgavebehandling mislyktes..' });
konsoll.feil (feil); // logg feilen
}
}
eksportmisligholde Send e-post;
Nå som du har både produsent- og forbrukerfunksjonene definert og klar til bruk, kan du nå ringe produsentfunksjonen din hvor som helst i søknaden din for å legge til en e-post i køen for behandling.
Et eksempel på en kontroller vil se slik ut:
// userController.js
konst EmailQueue = krever('../handlers/queueHandler.js')konst påmelding = asynkron (req, res) => {
konst { navn, e-post, passord } = req.body;// --
// en spørring for å legge til den nye brukeren i databasen...
// --// legg til i e-postkø
konst emailData = { navn, e-post };
avvente EmailQueue.addEmailToQueue (emailData);
res.status(200).json({
beskjed: "Registrering vellykket, vennligst sjekk e-posten din"
})
}
Din queueHandler.js filen skal nå være som følger:
// queueHandler.js
konst Kø = krever('okse');
konst emailHandler = krever('../handlers/emailHandler.js');konst REDIS_URL = 'redis://127.0.0.1:6379';
konst queueOpts = {
begrenser: {
maks: 100,
varighet: 10000
},prefiks: 'EMAIL-TASK',
defaultJobOptions: {
forsøk: 3,
removeOnComplete: ekte
}
};klasseE-postkø{
konstruktør() {
dette.kø = ny Kø("E-postkø", REDIS_URL, queueOpts);// forbruker
dette.queue.process('email_notification', asynkron (e-postjobb, ferdig) => {
konsoll.Logg("behandler e-postvarslingsoppgave");
avvente emailHandler.sendEmail (emailJob);
ferdig();
})
}// produsent
asynkron addEmailToQueue (emailData) {
// legg til oppgave med navnet 'email_notification' i køen
avventedette.queue.add('email_notification', e-postdata);
konsoll.Logg('e-posten er lagt til i køen...');
}
};
eksportmisligholde EmailQueue;
Når du implementerer dette i en Node.js REST API, vil du merke en reduksjon i responstiden til registreringsendepunktet, og raskere leveringstider for e-post sammenlignet med alternativet.
Oppgavekøer gjorde det også mulig for deg å håndtere registrerings- og e-postfeil uavhengig av hverandre.
Optimalisere applikasjoner ved hjelp av oppgavekøer
Meldings- og oppgavekøer er en fin måte å forbedre den generelle ytelsen til applikasjoner på. De er også veldig billige, og du kan bruke dem i så mange deler av et program du trenger.
Selv om denne opplæringen brukte e-poster som et eksempelscenario for å håndtere minnekrevende oppgaver med køer, er det mange andre tilfeller der du kan bruke de samme konseptene. Disse inkluderer tunge lese-/skriveoperasjoner, gjengivelse av bilder eller dokumenter av høy kvalitet og utsendelse av massevarsler.