Node.js और Redis के साथ मैसेज क्यू में महारत हासिल करें: वेब ऐप प्रदर्शन को बूस्ट करें

जब आप बड़े पैमाने के वेब एप्लिकेशन बना रहे होते हैं, तो गति एक प्रमुख प्राथमिकता होती है। यूज़र अब प्रतिक्रियाओं के लिए लंबा इंतजार नहीं करना चाहते, और उन्हें ऐसा करना भी नहीं चाहिए। लेकिन कुछ प्रक्रियाओं में समय लगता है, और उन्हें किसी भी तेज़ नहीं बनाया जा सकता या समाप्त नहीं किया जा सकता।

मैसेज क्यू इस समस्या को हल करने में मदद करते हैं सामान्य रिक्वेस्ट-रिस्पॉन्स यात्रा के लिए एक अतिरिक्त शाखा प्रदान करके। यह अतिरिक्त शाखा यह सुनिश्चित करने में मदद करती है कि यूज़र को तत्काल प्रतिक्रियाएं मिल सकें, और समय लेने वाली प्रक्रियाओं को साइड में किया जा सके। हर कोई खुश होकर घर जाता है।

यह लेख मैसेज क्यू क्या हैं और एक बहुत ही सरल एप्लिकेशन बनाकर उनके साथ कैसे शुरू करें, यह समझाने पर केंद्रित होगा। आपको Node.js की मूल बातों से परिचित होना चाहिए, और आपके पास Redis स्थानीय रूप से या क्लाउड इंस्टेंस पर इंस्टॉल होना चाहिए। Redis इंस्टॉल करना यहां सीखें।

क्यू क्या है?

एक क्यू एक डेटा संरचना है जो आपको संस्थाओं को एक क्रम में स्टोर करने की अनुमति देती है। क्यू फर्स्ट-इन-फर्स्ट-आउट (FIFO) सिद्धांत का उपयोग करती हैं।

कंप्यूटर साइंस में क्यू की अवधारणा रोजमर्रा की जिंदगी में क्यू की अवधारणा के समान है जहां लोग चीजें पाने के लिए लाइन लगाते हैं। आप क्यू के पीछे से जुड़ते हैं, अपनी बारी का इंतजार करते हैं, फिर सामने से क्यू छोड़ देते हैं जब आपकी देखभाल की जा चुकी होती है।

कंप्यूटर साइंस में, जब API रिक्वेस्ट जैसी प्रक्रिया चल रही होती है, और आपको वर्तमान प्रवाह से एक निश्चित कार्य (जैसे ईमेल भेजना) हटाने की आवश्यकता होती है, तो आप इसे एक क्यू में धकेलते हैं और प्रक्रिया जारी रखते हैं।

नीचे दिया गया आरेख क्यू के जीवनचक्र को दर्शाता है:

Queue Lifecycle | https://optimalbits.github.io/bull/

जॉब क्या है?

एक जॉब क्यू पर उपयोग किया जाने वाला डेटा का कोई भी टुकड़ा है, आमतौर पर एक JSON-जैसा ऑब्जेक्ट।

इस लेख की कवर इमेज में प्रदर्शित अनुसार, आप एक जॉब को हवाई अड्डे पर क्यू में प्रत्येक व्यक्ति के रूप में सोच सकते हैं। प्रत्येक व्यक्ति एक ब्रीफकेस रखता है जिसमें विशिष्ट डेटा होता है, और अन्य निर्देश (पासपोर्ट और जहां आवश्यक हो चिकित्सा कागजात) जो उनकी बारी आने पर मदद करेंगे।

इस क्यू में शामिल होने वाले नए लोग पीछे से प्रवेश करेंगे (अंतिम व्यक्ति के रूप में), और लोगों की देखभाल सामने से की जाएगी। इसी तरह जॉब भी प्रोसेस किए जाते हैं, प्रत्येक जॉब में डेटा होता है जिसका उपयोग इसकी प्रोसेसिंग के लिए किया जाएगा। नए जॉब पीछे से जोड़े जाते हैं जबकि जॉब सामने से निकाले जाते हैं।

जॉब प्रोड्यूसर क्या है?

एक जॉब प्रोड्यूसर कोड का कोई भी टुकड़ा है जो एक जॉब को क्यू में जोड़ता है। वास्तविक जीवन में, यह हवाई अड्डे पर सुरक्षा गार्ड होगा जो लोगों को दिशा देता है, उन्हें बताता है कि विभिन्न उद्देश्यों के लिए किस क्यू में शामिल होना है।

एक जॉब प्रोड्यूसर जॉब कंज्यूमर से स्वतंत्र रूप से अस्तित्व में रह सकता है। इसका मतलब है कि माइक्रोसर्विस सेटअप में, एक विशेष सर्विस केवल क्यू में जॉब जोड़ने से संबंधित हो सकती है, लेकिन वे प्रोसेस होने के बाद कैसे प्रोसेस किए जाते हैं, इससे नहीं।

वर्कर (जॉब कंज्यूमर) क्या है?

एक वर्कर, या जॉब कंज्यूमर, एक प्रक्रिया या फ़ंक्शन है जो एक जॉब को निष्पादित कर सकता है। एक वर्कर को बैंक कैशियर के रूप में सोचें जो बैंक में क्यू में लोगों की देखभाल करता है। जब पहला व्यक्ति आता है, तो वे क्यू में एकमात्र व्यक्ति के रूप में शामिल होते हैं। कैशियर फिर उन्हें बुलाता है और क्यू खाली हो जाती है।

कैशियर उस व्यक्ति से लेनदेन को प्रोसेस करने के लिए उपयोग की जाने वाली विशिष्ट डिटेल्स का अनुरोध करता है। जब कैशियर पहले ग्राहक की देखभाल करता है, तो चार और ग्राहक लाइन लगा सकते हैं। वे क्यू पर तब तक रहेंगे जब तक कैशियर पहले ग्राहक के साथ समाप्त नहीं कर लेता तब तक अगले को बुलाने से पहले। यह क्यू वर्कर्स के साथ समान प्रक्रिया है — वे क्यू में पहला जॉब चुनते हैं, और इसे प्रोसेस करते हैं।

फेल्ड जॉब क्या हैं?

अक्सर, प्रोसेसिंग के दौरान कुछ जॉब विफल हो सकते हैं।

यहां कुछ कारण हैं कि एक जॉब क्यों विफल हो सकता है:

• अमान्य या गुम इनपुट डेटा: जब किसी जॉब को प्रोसेस करने के लिए आवश्यक डेटा गुम होता है, तो जॉब विफल हो जाएगा। उदाहरण के लिए, प्राप्तकर्ता के ईमेल पते के बिना ईमेल भेजने का जॉब विफल हो जाएगा।
• टाइमआउट: यदि यह सामान्य से अधिक समय ले रहा है तो क्यू मैकेनिज्म द्वारा एक जॉब को विफल किया जा सकता है। यह जॉब की निर्भरता पर किसी समस्या या किसी और चीज के कारण हो सकता है, लेकिन आमतौर पर आप एक ही जॉब को हमेशा के लिए चलते नहीं देखना चाहते।
• नेटवर्क या इंफ्रास्ट्रक्चर समस्याएं: ये समस्याएं लगभग आपके नियंत्रण से बाहर हैं, लेकिन वे होती हैं। उदाहरण के लिए, एक डेटाबेस कनेक्शन एरर एक जॉब को विफल कर देगी।
• निर्भरता मुद्दे: कभी-कभी एक जॉब अच्छी तरह से काम करने के लिए कुछ बाहरी संसाधनों पर निर्भर करता है। जब भी ये अन्य संसाधन अनुपलब्ध या असफल होते हैं, तो जॉब विफल हो जाएगा।

जब जॉब विफल होते हैं, तो आप अपने क्यू मैकेनिज्म को उन्हें रीट्राई करने के लिए कॉन्फिगर कर सकते हैं। आप या तो जॉब को तुरंत रीट्राई कर सकते हैं, या गणना किए गए समय के बाद। आप अधिकतम प्रयासों की संख्या सेट कर सकते हैं, जिसकी सिफारिश की जाती है। यदि नहीं, तो आप एक ऐसे जॉब को अनिश्चित काल तक चलाते रहेंगे जो हमेशा विफल होगा।

क्यू माइक्रोसर्विसेज के बीच मजबूत संचार चैनल बनाने के लिए उपयोगी हैं। कई सर्विस एक ही क्यू का उपयोग कर सकती हैं। अलग-अलग सर्विस को अलग-अलग समस्याओं का कार्य सौंपा जा सकता है। जब एक सर्विस अपना कार्य पूरा करती है, तो यह दूसरी सर्विस को एक जॉब धकेल सकती है जिसमें उस जॉब के लिए वर्कर प्रतीक्षा कर रहे हैं। वह सर्विस इसे उठाएगी और डेटा के साथ जो भी आवश्यक है वह करेगी।

क्यू एक प्रक्रिया से भारी कार्यों को ऑफलोड करने के लिए भी उपयोगी हैं। जैसा कि आप इस लेख में देखेंगे, ईमेल भेजने जैसे समय लेने वाले कार्य को रिक्वेस्ट रिस्पॉन्स समय को धीमा करने से बचने के लिए क्यू पर रखा जा सकता है।

क्यू विफलता के एकल बिंदुओं से बचने में मदद करते हैं। एक प्रक्रिया जिसमें विफल होने की क्षमता है और जिसे रीट्राई किया जा सकता है, उसे क्यू का उपयोग करके प्रोसेस करना सबसे अच्छा है जहां इसे थोड़ी देर बाद रीट्राई किया जा सकता है।

क्यू का उपयोग करने वाला एक साधारण एप्लिकेशन कैसे बनाएं

इस लेख में, हम Node.js और Redis का उपयोग करके एक साधारण प्रोजेक्ट बनाएंगे। हम Bull लाइब्रेरी का उपयोग करेंगे क्योंकि यह क्यू सिस्टम बनाने में शामिल कई जटिलताओं को सरल बनाता है। प्रोजेक्ट में ईमेल भेजने के लिए एक सिंगल एंडपॉइंट होगा।

एक नया Node.js प्रोजेक्ट बनाएं

mkdir nodejs-queue-project
cd nodejs-queue-project
npm init -y

उपरोक्त कमांड nodejs-queue-project नामक एक नया फोल्डर और उसमें एक package.json फ़ाइल बनाएंगे। package.json फ़ाइल इस तरह दिखनी चाहिए:

{
    "name": "nodejs-queue-project",
    "version": "1.0.0",
    "description": "",
    "main": "index.js",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    "keywords": [],
    "author": "",
    "license": "ISC"
}

आवश्यक डिपेंडेंसी इंस्टॉल करें

npm i express @types/express @types/node body-parser ts-node ts-lint typescript nodemon nodemailer @types/nodemailer

उपरोक्त कमांड प्रोजेक्ट के लिए आवश्यक विभिन्न पैकेज और डिपेंडेंसी इंस्टॉल करेंगे।

इंस्टॉलेशन के बाद, आप अपने package.json के scripts सेक्शन को एक dev कमांड रखने के लिए अपडेट कर सकते हैं। आपका पूरा package.json फ़ाइल अब इस तरह दिखनी चाहिए:

{
    "name": "nodejs-queue-project",
    "version": "1.0.0",
    "description": "",
    "main": "index.js",
    "scripts": {
        "dev": "nodemon src/app.ts"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "dependencies": {
        "@types/express": "^4.17.17",
        "@types/node": "^20.3.3",
        "@types/nodemailer": "^6.4.8",
        "body-parser": "^1.20.2",
        "express": "^4.18.2",
        "nodemailer": "^6.9.3",
        "nodemon": "^2.0.22",
        "ts-lint": "^4.5.1",
        "ts-node": "^10.9.1",
        "typescript": "^5.1.6"
    }
}

ऊपर की फ़ाइल आपकी सभी इंस्टॉल्ड डिपेंडेंसी दिखाती है। npm run dev कमांड dev स्क्रिप्ट का उपयोग करके चलेगा।

एंडपॉइंट कैसे बनाएं

पहली बात यह है कि src नामक एक नया फोल्डर बनाएं। यह फोल्डर आपकी सभी कोड फ़ाइलों को समाहित करेगा। इसमें पहली फ़ाइल एप्लिकेशन की रूट फ़ाइल होगी — package.json फ़ाइल में परिभाषित app.ts फ़ाइल।

हम app.ts फ़ाइल का उपयोग आवश्यक पैकेज इम्पोर्ट करने और नीचे दिखाए अनुसार ईमेल भेजने के लिए एक सिंगल एंडपॉइंट के साथ एक साधारण सर्वर बनाने के लिए करेंगे:

import express from "express";
import bodyParser from "body-parser";
import nodemailer from "nodemailer";
const app = express();
app.use(bodyParser.json());
app.post("/send-email", async (req, res) => {
    const { from, to, subject, text } = req.body;
    // ट्यूटोरियल के रूप में एक टेस्ट अकाउंट का उपयोग करें
    const testAccount = await nodemailer.createTestAccount();
    const transporter = nodemailer.createTransport({
        host: "smtp.ethereal.email",
        port: 587,
        secure: false,
        auth: {
            user: testAccount.user,
            pass: testAccount.pass,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    console.log("Sending mail to %s", to);
    let info = await transporter.sendMail({
        from, to, subject, text,
        html: `${text}`,
    });
    console.log("Message sent: %s", info.messageId);
    console.log("Preview URL: %s", nodemailer.getTestMessageUrl(info));
    res.json({ message: "Email Sent", });
});
app.listen(4300, () => {
    console.log("Server started at https://localhost:4300");
});

अब, आप अपने टर्मिनल में npm run dev चलाकर अपना सर्वर शुरू कर सकते हैं। आपको अपने टर्मिनल में Server started at [https://localhost:4300](https://localhost:4300) कहने वाला एक संदेश देखना चाहिए।

npm run dev संदेश

आप Postman जैसे टूल का उपयोग करके एंडपॉइंट का टेस्ट कर सकते हैं:

Postman पर एंडपॉइंट टेस्टिंग

रिक्वेस्ट में लगभग 4 सेकंड लगे जैसा कि स्क्रीनशॉट में दिखाया गया है। यह एक एंडपॉइंट के लिए बहुत धीमा है। यदि आप अपने टर्मिनल पर एक नज़र डालते हैं, तो आपको एक URL भी देखना चाहिए जहां आप भेजे गए ईमेल का पूर्वावलोकन कर सकते हैं।

लिंक खोलने से आप देख सकते हैं कि ईमेल कैसा दिखता है।

ईमेल कंटेंट

क्यू कैसे बनाएं

प्रक्रिया को और भी तेज़ बनाने के लिए, ईमेल को बाद में भेजने के लिए कतारबद्ध किया जा सकता है और यूज़र को तुरंत प्रतिक्रिया भेजी जा सकती है।

ऐसा करने के लिए, bull लाइब्रेरी और इसके @types लाइब्रेरी को इंस्टॉल करें क्योंकि हम इसका उपयोग क्यू बनाने के लिए करेंगे। वह है:

npm i bull @types/bull

bull का उपयोग करके एक नई क्यू बनाना Bull ऑब्जेक्ट को क्यू के नाम के साथ इंस्टेंटिएट करने जितना आसान है:

// यह आपकी फ़ाइल के शीर्ष पर जाता है
import Bull from 'bull';
const emailQueue = new Bull("email");

जब क्यू को केवल क्यू नाम के साथ बनाया जाता है, तो यह डिफ़ॉल्ट Redis कनेक्शन URL का उपयोग करने का प्रयास करता है: localhost:6379। यदि आप एक अलग URL का उपयोग करना पसंद करते हैं, तो बस Bull क्लास में एक दूसरा ऑब्जेक्ट विकल्प ऑब्जेक्ट के रूप में पास करें:

const emailQueue = new Bull("email", { redis: "localhost:6379", });

इस बिंदु पर, आप एक साधारण फ़ंक्शन बना सकते हैं जो जॉब प्रोड्यूसर के रूप में कार्य करता है और हर बार रिक्वेस्ट आने पर क्यू में एक जॉब जोड़ता है।

type EmailType = { from: string; to: string; subject: string; text: string; };
const sendNewEmail = async (email: EmailType) => {
    emailQueue.add({ ...email });
};

नव निर्मित यह फ़ंक्शन, sendNewEmail, EmailType प्रकार का एक ऑब्जेक्ट स्वीकार करता है जिसमें भेजे जाने वाले नए ईमेल का विवरण होता है। प्रेषक ईमेल पता (from), प्राप्तकर्ता ईमेल पता (to), ईमेल का subject, और ईमेल की सामग्री (text)। फिर यह क्यू में एक नया जॉब धकेलता है।

आप रिक्वेस्ट के दौरान ईमेल भेजने के बजाय इस फ़ंक्शन का उपयोग कर सकते हैं। एंडपॉइंट को ऐसा करने के लिए संशोधित करें:

app.post("/send-email", async (req, res) => {
    const { from, to, subject, text } = req.body;
    await sendNewEmail({ from, to, subject, text });
    console.log("Added to queue");
    res.json({ message: "Email Sent", });
});

इस बिंदु पर, कोड सरल है और प्रक्रिया तेज़ है। रिक्वेस्ट केवल लगभग 40ms लेता है - पहले की तुलना में लगभग 100x तेज़।

Postman के साथ एंडपॉइंट टेस्टिंग

इस बिंदु पर, ईमेल एक क्यू में जोड़ा जाता है। यह तब तक क्यू पर रहेगा जब तक प्रोसेस नहीं किया जाता। जॉब को उसी एप्लिकेशन या किसी अन्य सर्विस द्वारा प्रोसेस किया जा सकता है (यदि माइक्रोसर्विस सेटअप में)।

जॉब को कैसे प्रोसेस करें

चक्र अधूरा और बेकार है अगर मेल कभी क्यू नहीं छोड़ते। हम जॉब को प्रोसेस करने और क्यू को साफ़ करने के लिए एक जॉब कंज्यूमर बनाएंगे।

हम एक फ़ंक्शन के लिए लॉजिक बना सकते हैं जो एक Job ऑब्जेक्ट स्वीकार करता है और ईमेल भेजता है:

const processEmailQueue = async (job: Job) => {
    // ट्यूटोरियल के रूप में एक टेस्ट अकाउंट का उपयोग करें
    const testAccount = await nodemailer.createTestAccount();
    const transporter = nodemailer.createTransport({
        host: "smtp.ethereal.email",
        port: 587,
        secure: false,
        auth: {
            user: testAccount.user,
            pass: testAccount.pass,
        },
        tls: { rejectUnauthorized: false, },
    });
    const { from, to, subject, text } = job.data;
    console.log("Sending mail to %s", to);
    let info = await transporter.sendMail({
        from, to, subject, text,
        html: `${text}`,
    });
    console.log("Message sent: %s", info.messageId);
    console.log("Preview URL: %s", nodemailer.getTestMessageUrl(info));
    return nodemailer.getTestMessageUrl(info);
};

ऊपर का फ़ंक्शन एक Job ऑब्जेक्ट स्वीकार करता है। ऑब्जेक्ट में उपयोगी गुण होते हैं जो जॉब की स्थिति और डेटा दिखाते हैं। यहां, हम data प्रॉपर्टी का उपयोग करते हैं।

इस बिंदु पर, हमारे पास बस एक फ़ंक्शन है। यह स्वचालित रूप से जॉब नहीं चुनता क्योंकि यह नहीं जानता कि किस क्यू के साथ काम करना है।

इसे क्यू से जोड़ने से पहले, आप कुछ रिक्वेस्ट भेजकर क्यू में कुछ जॉब जोड़ सकते हैं। आप अपने redis-cli में यह कमांड चलाकर वर्तमान में कतारबद्ध ईमेल जॉब की जांच कर सकते हैं:

LRANGE bull:email:wait 0 -1

यह ईमेल वेटलिस्ट की जांच करता है, और प्रतीक्षा कर रहे जॉब के ids लौटाता है।

Redis CLI

मैंने सिर्फ यह दिखाने के लिए कुछ जॉब बनाए हैं कि वर्कर वास्तव में कैसे काम करते हैं।

अब, इस कोड लाइन को जोड़कर वर्कर को क्यू से जोड़ें:

emailQueue.process(processEmailQueue);

आपका app.ts फ़ाइल अब इसके बाद ऐसी दिखनी चाहिए:

import express from "express";
import bodyParser from "body-parser";
import nodemailer from "nodemailer";
import Bull, { Job } from "bull";
const app = express();
app.use(bodyParser.json());
const emailQueue = new Bull("email", { redis: "localhost:6379", });
type EmailType = { from: string; to: string; subject: string; text: string; };
const sendNewEmail = async (email: EmailType) => { emailQueue.add({ ...email }); };
const processEmailQueue = async (job: Job) => {
    // ट्यूटोरियल के रूप में एक टेस्ट अकाउंट का उपयोग करें
    const testAccount = await nodemailer.createTestAccount();
    const transporter = nodemailer.createTransport({
        host: "smtp.ethereal.email",
        port: 587,
        secure: false,
        auth: { user: testAccount.user, pass: testAccount.pass, },
        tls: { rejectUnauthorized: false, },
    });
    const { from, to, subject, text } = job.data;
    console.log("Sending mail to %s", to);
    let info = await transporter.sendMail({ from, to, subject, text, html: `${text}`, });
    console.log("Message sent: %s", info.messageId);
    console.log("Preview URL: %s", nodemailer.getTestMessageUrl(info));
};
emailQueue.process(processEmailQueue);
app.post("/send-email", async (req, res) => {
    const { from, to, subject, text } = req.body;
    await sendNewEmail({ from, to, subject, text });
    console.log("Added to queue");
    res.json({ message: "Email Sent", });
});
app.listen(4300, () => { console.log("Server started at https://localhost:4300"); });

एक बार जब आप सेव करते हैं, तो आप देखेंगे कि सर्वर रीस्टार्ट होता है और तुरंत मेल भेजना शुरू कर देता है। ऐसा इसलिए है क्योंकि वर्कर क्यू को देखता है और तुरंत प्रोसेस करना शुरू कर देता है।

कतारबद्ध ईमेल भेज रहा सर्वर

अब, प्रोड्यूसर और वर्कर दोनों सक्रिय हैं। हर नया API रिक्वेस्ट क्यू में धकेला जाएगा, और वर्कर इसे तुरंत प्रोसेस करेगा जब तक कि पहले से ही कुछ लंबित जॉब न हों।

सारांश

मुझे उम्मीद है कि इस लेख ने आपको यह समझने में मदद की कि मैसेज क्यू क्या है, जॉब कैसे जोड़ें और उन्हें चलाने के लिए प्रक्रियाएं कैसे बनाएं, और आप बेहतर वेब एप्लिकेशन बनाने के लिए उनका उपयोग कैसे कर सकते हैं। आप इस लेख में उपयोग की गई कोड फ़ाइलों को GitHub पर पा सकते हैं।

यदि आपके कोई प्रश्न या प्रासंगिक सलाह है, तो कृपया उनसे साझा करने के लिए मुझसे संपर्क करें।

मेरे और लेख पढ़ने या मेरे काम का पालन करने के लिए, आप LinkedIn, Twitter, और Github पर मुझसे जुड़ सकते हैं। यह तेज़ है, यह आसान है, और यह मुफ़्त है!