Als Webentwickler ist es entscheidend, dass Ihre Apps so schnell wie möglich funktionieren. Sie sollten Web-Apps erstellen, die so schnell wie möglich auf Anfragen reagieren.
Eine der vielen Technologien, die Ihnen dabei helfen können, ist die Aufgabenwarteschlange.
Was ist Task Queuing und wie können Sie damit eine Node.js-Anwendung optimieren?
Was ist Aufgabenwarteschlange?
Message Queuing ist ein Mittel zur asynchronen Kommunikation zwischen zwei Anwendungen oder Diensten, die normalerweise als das bezeichnet werden Hersteller Und Verbraucher. Es ist ein bekanntes Konzept, das in serverlosen und Microservice-Architekturen verwendet wird.
Das Konzept von Aufgabe oder Arbeitanstehen nutzt Nachrichtenwarteschlangen, um die Anwendungsleistung zu verbessern. Es abstrahiert die Komplexität der Verwaltung von Nachrichten und ermöglicht es Ihnen, Funktionen zu definieren, um Jobs oder Aufgaben asynchron über eine Warteschlange zu verwalten, wodurch die Rate von reduziert wird
Speichernutzung in einigen Teilen einer Anwendung.Das bekannteste Beispiel für Nachrichtenwarteschlangen-Software ist RabbitMQ. Zu den Aufgabenwarteschlangen-Tools gehören Celery und Bull. Sie können RabbitMQ auch so konfigurieren, dass es als Aufgabenwarteschlange fungiert. Lesen Sie weiter, um mehr über Aufgabenwarteschlangen in Node.js mit Bull zu erfahren.
Was ist BullMQ?
BullMQ (Bull.js) ist eine Node.js-Bibliothek, die zum Implementieren von Warteschlangen in Node-Anwendungen verwendet wird. Bull ist ein Redis-basiertes System (möglicherweise kennen Sie Redis eher als Tool für schnelle Datenspeicherung) und es ist eine schnelle und zuverlässige Option für das Task-Queuing in Node.js.
Sie können Bull für viele Aufgaben verwenden, z. B. das Implementieren verzögerter Jobs, geplanter Jobs, wiederholbarer Jobs, Prioritätswarteschlangen und vielem mehr.
Wie können Sie also Bull und Redis verwenden, um Node.js-Aufgaben asynchron auszuführen?
So konfigurieren Sie Bull und Redis für Task Queuing in Node.js
Um mit der Aufgabenwarteschlange in Node.js mit Bull zu beginnen, müssen Node.js und Redis auf Ihrem Computer installiert sein. Sie können dem folgen Redis Labs-Leitfaden zur Installation von Redis wenn Sie es nicht installiert haben.
Der erste Schritt zur Implementierung von Bull besteht darin, es durch Ausführen zu den Abhängigkeiten Ihres Projekts hinzuzufügen npm Bull installieren oder Garn hinzufügen Stier im Terminal im Ordner Ihres Projekts. Es gibt mehrere Möglichkeiten, eine Warteschlange in Bull zu initialisieren, wie unten gezeigt:
konst Warteschlange = erfordern('Stier');// verschiedene Möglichkeiten, eine Warteschlange zu initialisieren
// - Verwendung von redis URL-String
konst emailQueue = neu Warteschlange('E-Mail-Warteschlange', 'redis://127.0.0.1:6379');// - mit einem Redis-Verbindungs- und Warteschlangenoptionsobjekt
konst videoQueue = neu Warteschlange('Videowarteschlange', 'redis://127.0.0.1:6379', Warteschlangenoptionen);// - ohne Redis-Verbindung, aber mit queueOption
konst docQueue = neu Warteschlange('Dokumentenwarteschlange', Warteschlangenoptionen);
// - ohne Redis-Verbindung oder Warteschlangenoptionen
konst QueueClient = neu Warteschlange('Meine Warteschlange');
Diese verwenden alle eine minimale Konfiguration für Bull in Node.js. Das Optionsobjekt unterstützt viele Eigenschaften und Sie können mehr über sie in der erfahren Queue-Options-Abschnitt der Bull-Dokumentation.
Implementieren einer E-Mail-Aufgabenwarteschlange mit BullMQ
Um eine Warteschlange zum Senden von E-Mails zu implementieren, können Sie Ihre Producer-Funktion definieren, die E-Mails zur E-Mail-Warteschlange hinzufügt, und eine Consumer-Funktion, um das Senden von E-Mails zu handhaben.
Erstens können Sie Ihre Warteschlange in einer Klasse mit einer Redis-URL und einigen Warteschlangenoptionen wie unten gezeigt initialisieren.
// QueueHandler.js
konst Warteschlange = erfordern('Stier');// Verwenden Sie hier ein echtes E-Mail-Handler-Modul - dies ist nur ein Beispiel
konst emailHandler = erfordern('./emailHandler.js');// Konstanten, Redis-URL und Warteschlangenoptionen definieren
konst REDIS_URL = 'redis://127.0.0.1:6379';konst Warteschlangenoptionen = {
// Ratenbegrenzungsoptionen, um eine Überlastung der Warteschlange zu vermeiden
Begrenzer: {
// maximale Anzahl von Tasks, die die Warteschlange aufnehmen kann
maximal: 100,// Wartezeit in Millisekunden, bevor neue Jobs angenommen werden
// Grenze erreichen
Dauer: 10000
},
Präfix: 'EMAIL-AUFGABE', // ein Präfix, das allen Warteschlangenschlüsseln hinzugefügt werden soll
defaultJobOptions: { // Standardoptionen für Aufgaben in der Warteschlange
Versuche: 3, // Standard-Wiederholungshäufigkeit für eine Aufgabe// um eine Aufgabe nach Abschluss aus der Warteschlange zu entfernen
entfernenOnComplete: WAHR
}
};KlasseE-Mail-Warteschlange{
Konstrukteur() {
Das.Warteschlange = neu Warteschlange('E-Mail-Warteschlange', REDIS_URL, queueOpts);
}
};
ExportStandard E-Mail-Warteschlange; // Klasse exportieren
Nachdem Sie nun eine Warteschlange initialisiert haben, können Sie Ihre Producer-Funktion definieren (mithilfe von Bull's hinzufügen() Funktion) als Methode der E-Mail-Warteschlange Klasse, um E-Mails zur Aufgabenwarteschlange hinzuzufügen. Der folgende Codeblock demonstriert dies:
// QueueHandler.jsKlasseE-Mail-Warteschlange{
Konstrukteur () {
// ...
}// Producer-Funktion zum Hinzufügen von E-Mails zur Warteschlange
asynchron addEmailToQueue (E-Mail-Daten) {
// Aufgabe mit dem Namen 'email_notification' zur Warteschlange hinzufügen
erwartenDas.queue.add('Email Benachrichtigung', E-Mail-Daten);
Konsole.Protokoll('Die E-Mail wurde der Warteschlange hinzugefügt...');
}
};
ExportStandard E-Mail-Warteschlange; // Klasse exportieren
Die Producer-Funktion ist bereit, und Sie können jetzt eine Consumer-Funktion definieren (mithilfe von Bull's Verfahren() -Funktion), um alle E-Mail-Aufgaben in der Warteschlange zu verarbeiten – d. h. Rufen Sie die Funktion auf, um eine E-Mail zu senden. Diese Verbraucherfunktion sollten Sie im Konstruktor der Klasse definieren.
// QueueHandler.js
KlasseE-Mail-Warteschlange{
Konstrukteur () {
// ...// Verbraucherfunktion, die den zugewiesenen Namen der Aufgabe übernimmt und
// eine Callback-Funktion
Das.queue.process('Email Benachrichtigung', asynchron (emailJob, erledigt) => {
Konsole.Protokoll('E-Mail-Benachrichtigungsaufgabe wird verarbeitet');
erwarten emailHandler.sendEmail (E-Mail-Job); // E-Mail senden
Erledigt(); // die Aufgabe erledigen
})
}
// ...
};
ExportStandard E-Mail-Warteschlange; // Klasse exportieren
Ein Job kann auch Optionen haben, um sein Verhalten in der Warteschlange zu definieren oder wie die Verbraucherfunktion damit umgeht. Mehr dazu erfahren Sie im Job-Options-Abschnitt der Bull-Dokumentation.
Der emailJob Argument ist ein Objekt, das die Eigenschaften der Aufgabe enthält, die die Warteschlange verarbeiten soll. Es enthält auch die wichtigsten Daten, die zum Erstellen der E-Mail benötigt werden. Zum einfachen Verständnis, die E-Mail senden() Die Funktion wäre ähnlich wie in diesem Beispiel:
// emailHandler.js
konst sendgridMail = erfordern('@sendgrid/mail');konst apiKey = process.env. SENDGRID_API_KEY
sendgridMail.setApiKey (apiKey); // Sicherheitsanmeldeinformationen für den E-Mail-Transporter festlegen
konst E-Mail senden = asynchron (E-MailJob) => {
versuchen {
// die E-Mail-Daten aus dem Job extrahieren
konst {Name, E-Mail} = emailJob.data;konst Nachricht = {
aus: '[email protected]',
Zu: '[email protected]',
Thema: 'Hallo! Willkommen',
Text: „Hallo ${name}, willkommen bei MUO`
};erwarten sendgridMail.sendMail (Nachricht); // E-Mail senden
// Aufgabe in der Warteschlange als erledigt markieren
erwarten emailJob.moveToCompleted('Erledigt', WAHR);
Konsole.Protokoll('Email wurde erfolgreich Versendet...');
} fangen (Fehler) {
// Aufgabe zu fehlgeschlagenen Jobs verschieben
erwarten emailJob.moveToFailed({ Nachricht: 'Aufgabenverarbeitung fehlgeschlagen..' });
Konsole.error (Fehler); // Fehler protokollieren
}
}
ExportStandard E-Mail senden;
Nachdem Sie nun sowohl die Producer- als auch die Consumer-Funktion definiert und einsatzbereit haben, können Sie Ihre Producer-Funktion jetzt überall in Ihrer Anwendung aufrufen, um eine E-Mail zur Verarbeitung in die Warteschlange einzufügen.
Ein Beispiel-Controller würde so aussehen:
// userController.js
konst E-Mail-Warteschlange = erfordern('../handlers/queueHandler.js')konst anmelden = asynchron (req, res) => {
konst { Name, E-Mail, Passwort } = req.body;// --
// eine Abfrage zum Hinzufügen des neuen Benutzers zur Datenbank...
// --// zur E-Mail-Warteschlange hinzufügen
konst emailData = {Name, E-Mail};
erwarten EmailQueue.addEmailToQueue (E-Mail-Daten);
res.status(200).json({
Nachricht: "Registrierung erfolgreich, bitte überprüfen Sie Ihre E-Mail"
})
}
Dein queueHandler.js Datei sollte nun wie folgt aussehen:
// QueueHandler.js
konst Warteschlange = erfordern('Stier');
konst emailHandler = erfordern('../handlers/emailHandler.js');konst REDIS_URL = 'redis://127.0.0.1:6379';
konst Warteschlangenoptionen = {
Begrenzer: {
maximal: 100,
Dauer: 10000
},Präfix: 'EMAIL-AUFGABE',
defaultJobOptions: {
Versuche: 3,
entfernenOnComplete: WAHR
}
};KlasseE-Mail-Warteschlange{
Konstrukteur() {
Das.Warteschlange = neu Warteschlange('E-Mail-Warteschlange', REDIS_URL, queueOpts);// Verbraucher
Das.queue.process('Email Benachrichtigung', asynchron (emailJob, erledigt) => {
Konsole.Protokoll('E-Mail-Benachrichtigungsaufgabe wird verarbeitet');
erwarten emailHandler.sendEmail (E-Mail-Job);
Erledigt();
})
}// Hersteller
asynchron addEmailToQueue (E-Mail-Daten) {
// Aufgabe mit dem Namen 'email_notification' zur Warteschlange hinzufügen
erwartenDas.queue.add('Email Benachrichtigung', E-Mail-Daten);
Konsole.Protokoll('Die E-Mail wurde der Warteschlange hinzugefügt...');
}
};
ExportStandard E-Mail-Warteschlange;
Wenn Sie dies in einer Node.js-REST-API implementieren, werden Sie im Vergleich zur Alternative eine Verringerung der Antwortzeit des Anmeldeendpunkts und schnellere E-Mail-Zustellungszeiten feststellen.
Aufgabenwarteschlangen ermöglichten es Ihnen auch, Anmelde- und E-Mail-Fehler unabhängig voneinander zu behandeln.
Optimieren von Anwendungen mithilfe von Aufgabenwarteschlangen
Nachrichten- und Aufgabenwarteschlangen sind eine großartige Möglichkeit, die allgemeine Leistung von Anwendungen zu verbessern. Sie sind auch sehr billig und Sie können sie in so vielen Teilen einer Anwendung verwenden, wie Sie benötigen.
Obwohl in diesem Lernprogramm E-Mails als Beispielszenario für die Verarbeitung speicherintensiver Aufgaben mit Warteschlangen verwendet wurden, gibt es viele andere Fälle, in denen Sie dieselben Konzepte anwenden können. Dazu gehören umfangreiche Lese-/Schreibvorgänge, das Rendern hochwertiger Bilder oder Dokumente und das Versenden von Massenbenachrichtigungen.