Node.js और Redis डिस्ट्रीब्यूटेड कैशिंग के साथ एक हाई-परफॉर्मेंस URL शॉर्टनर बनाएं

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

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

आप क्या सीखेंगे

• Node.js और Redis का उपयोग करके URL शॉर्टनर सर्विस कैसे बनाएं।

• प्रदर्शन को अनुकूलित करने के लिए डिस्ट्रीब्यूटेड कैशिंग कैसे लागू करें।

• कंसिस्टेंट हैशिंग और कैश इनवैलिडेशन रणनीतियों को समझना।

• शार्डिंग और स्केलिंग के लिए कई Redis इंस्टेंस को सिम्युलेट करने के लिए Docker का उपयोग करना।

पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्न इंस्टॉल हैं:

• Node.js (v14 या उच्चतर)

• Redis

• Docker

• JavaScript, Node.js, और Redis का बुनियादी ज्ञान।

विषय सूची

• प्रोजेक्ट अवलोकन

• चरण 1: प्रोजेक्ट सेटअप करना

• चरण 2: Redis इंस्टेंस सेटअप करना

• चरण 3: URL शॉर्टनर सर्विस लागू करना

• चरण 4: कैश इनवैलिडेशन लागू करना

• चरण 5: कैश मेट्रिक्स की निगरानी करना

• चरण 6: एप्लिकेशन का टेस्ट करना

• निष्कर्ष: आपने क्या सीखा

प्रोजेक्ट अवलोकन

हम एक URL शॉर्टनर सर्विस बनाएंगे जहां:

1. यूज़र लंबे URL को छोटा कर सकते हैं और मूल URL प्राप्त कर सकते हैं।

2. सर्विस छोटे URL और मूल URL के बीच मैपिंग को स्टोर करने के लिए Redis कैशिंग का उपयोग करती है।

3. कैश को हाई ट्रैफिक को संभालने के लिए कई Redis इंस्टेंस पर वितरित किया जाता है।

4. सिस्टम रीयल-टाइम में कैश हिट और मिस को प्रदर्शित करेगा।

सिस्टम आर्किटेक्चर

स्केलेबिलिटी और प्रदर्शन सुनिश्चित करने के लिए, हम अपनी सर्विस को निम्नलिखित घटकों में विभाजित करेंगे:

1. API सर्वर: URL को छोटा करने और प्राप्त करने के लिए रिक्वेस्ट को संभालता है।

2. Redis कैशिंग लेयर: डिस्ट्रीब्यूटेड कैशिंग के लिए कई Redis इंस्टेंस का उपयोग करता है।

3. Docker: कई Redis कंटेनरों के साथ एक डिस्ट्रीब्यूटेड वातावरण का अनुकरण करता है।

चरण 1: प्रोजेक्ट सेटअप करना

आइए एक Node.js एप्लिकेशन इनिशियलाइज़ करके अपना प्रोजेक्ट सेटअप करें:

mkdir scalable-url-shortener
cd scalable-url-shortener
npm init -y

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

npm install express redis shortid dotenv

• express: एक हल्का वेब सर्वर फ्रेमवर्क।

• redis: कैशिंग को संभालने के लिए।

• shortid: छोटे, यूनिक ID जेनरेट करने के लिए।

• dotenv: एनवायरनमेंट वेरिएबल प्रबंधित करने के लिए।

अपने प्रोजेक्ट के रूट में एक .env फ़ाइल बनाएं:

PORT=3000
REDIS_HOST_1=localhost
REDIS_PORT_1=6379
REDIS_HOST_2=localhost
REDIS_PORT_2=6380
REDIS_HOST_3=localhost
REDIS_PORT_3=6381

ये वेरिएबल उन Redis होस्ट और पोर्ट को परिभाषित करते हैं जिनका हम उपयोग करेंगे।

चरण 2: Redis इंस्टेंस सेटअप करना

हम एक डिस्ट्रीब्यूटेड वातावरण का अनुकरण करने के लिए कई Redis इंस्टेंस के साथ Docker का उपयोग करेंगे।

तीन Redis कंटेनर शुरू करने के लिए निम्न कमांड चलाएं:

docker run -p 6379:6379 --name redis1 -d redis
docker run -p 6380:6379 --name redis2 -d redis
docker run -p 6381:6379 --name redis3 -d redis

यह अलग-अलग पोर्ट पर चलने वाले तीन Redis इंस्टेंस सेटअप करेगा। हम इन इंस्टेंस का उपयोग कंसिस्टेंट हैशिंग और शार्डिंग को लागू करने के लिए करेंगे।

चरण 3: URL शॉर्टनर सर्विस लागू करना

आइए अपनी मुख्य एप्लिकेशन फ़ाइल, index.js बनाएं:

require('dotenv').config();
const express = require('express');
const redis = require('redis');
const shortid = require('shortid');
const app = express();
app.use(express.json());
const redisClients = [
    redis.createClient({ host: process.env.REDIS_HOST_1, port: process.env.REDIS_PORT_1 }),
    redis.createClient({ host: process.env.REDIS_HOST_2, port: process.env.REDIS_PORT_2 }),
    redis.createClient({ host: process.env.REDIS_HOST_3, port: process.env.REDIS_PORT_3 })
];
// Redis क्लाइंट के बीच कुंजियों को वितरित करने के लिए हैश फंक्शन
function getRedisClient(key) {
    const hash = key.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
    return redisClients[hash % redisClients.length];
}
// URL को छोटा करने के लिए एंडपॉइंट
app.post('/shorten', async (req, res) => {
    const { url } = req.body;
    if (!url) return res.status(400).send('URL is required');
    const shortId = shortid.generate();
    const redisClient = getRedisClient(shortId);
    await redisClient.set(shortId, url);
    res.json({ shortUrl: `https://localhost:${process.env.PORT}/${shortId}` });
});
// मूल URL प्राप्त करने के लिए एंडपॉइंट
app.get('/:shortId', async (req, res) => {
    const { shortId } = req.params;
    const redisClient = getRedisClient(shortId);
    redisClient.get(shortId, (err, url) => {
        if (err || !url) {
            return res.status(404).send('URL not found');
        }
        res.redirect(url);
    });
});
app.listen(process.env.PORT, () => {
    console.log(`Server running on port ${process.env.PORT}`);
});

जैसा कि आप इस कोड में देख सकते हैं, हमारे पास है:

1. कंसिस्टेंट हैशिंग:

   • हम एक साधारण हैश फंक्शन का उपयोग करके कुंजियों (छोटे URL) को कई Redis क्लाइंट के बीच वितरित करते हैं।

   • हैश फंक्शन यह सुनिश्चित करता है कि URL Redis इंस्टेंस पर समान रूप से वितरित हों।

2. URL छोटा करना:

   • /shorten एंडपॉइंट एक लंबा URL स्वीकार करता है और shortid लाइब्रेरी का उपयोग करके एक छोटा ID जेनरेट करता है।

   • छोटा URL हमारे हैश फंक्शन का उपयोग करके Redis इंस्टेंस में से एक में स्टोर किया जाता है।

3. URL रीडायरेक्शन:

   • /:shortId एंडपॉइंट कैश से मूल URL प्राप्त करता है और यूज़र को रीडायरेक्ट करता है।

   • यदि URL कैश में नहीं मिलता है, तो एक 404 प्रतिक्रिया लौटाई जाती है।

चरण 4: कैश इनवैलिडेशन लागू करना

एक वास्तविक दुनिया के एप्लिकेशन में, URL समय के साथ समाप्त या बदल सकते हैं। इसे संभालने के लिए, हमें कैश इनवैलिडेशन लागू करने की आवश्यकता है।

कैश्ड URL में एक्सपायरी जोड़ना

आइए अपनी index.js फ़ाइल को प्रत्येक कैश्ड एंट्री के लिए एक्सपायरेशन समय सेट करने के लिए संशोधित करें:

// एक्सपायरी के साथ URL को छोटा करने के लिए एंडपॉइंट
app.post('/shorten', async (req, res) => {
    const { url, ttl } = req.body; // ttl (time-to-live) वैकल्पिक है
    if (!url) return res.status(400).send('URL is required');
    const shortId = shortid.generate();
    const redisClient = getRedisClient(shortId);
    await redisClient.set(shortId, url, 'EX', ttl || 3600); // डिफ़ॉल्ट TTL 1 घंटे का
    res.json({ shortUrl: `https://localhost:${process.env.PORT}/${shortId}` });
});

• TTL (Time-To-Live): हम प्रत्येक छोटे URL के लिए 1 घंटे का डिफ़ॉल्ट एक्सपायरेशन समय सेट करते हैं। यदि आवश्यक हो तो आप प्रत्येक URL के लिए TTL को कस्टमाइज़ कर सकते हैं।

• कैश इनवैलिडेशन: जब TTL समाप्त हो जाता है, तो एंट्री कैश से स्वचालित रूप से हटा दी जाती है।

चरण 5: कैश मेट्रिक्स की निगरानी करना

कैश हिट और मिस की निगरानी करने के लिए, हम अपने एंडपॉइंट में index.js में कुछ लॉगिंग जोड़ेंगे:

app.get('/:shortId', async (req, res) => {
    const { shortId } = req.params;
    const redisClient = getRedisClient(shortId);
    redisClient.get(shortId, (err, url) => {
        if (err || !url) {
            console.log(`Cache miss for key: ${shortId}`);
            return res.status(404).send('URL not found');
        }
        console.log(`Cache hit for key: ${shortId}`);
        res.redirect(url);
    });
});

यहां इस कोड में क्या हो रहा है:

• कैश हिट: यदि URL कैश में मिलता है, तो यह एक कैश हिट है।

• कैश मिस: यदि URL नहीं मिलता है, तो यह एक कैश मिस है।

• यह लॉगिंग आपके डिस्ट्रीब्यूटेड कैश के प्रदर्शन की निगरानी करने में मदद करेगी।

चरण 6: एप्लिकेशन का टेस्ट करना

1. अपने Redis इंस्टेंस शुरू करें:

docker start redis1 redis2 redis3

2. Node.js सर्वर चलाएं:

node index.js

3. एंडपॉइंट का टेस्ट करें curl या Postman का उपयोग करके:

   • एक URL छोटा करें:

     POST https://localhost:3000/shorten
     Body: { "url": "https://example.com" }

   • छोटे URL को एक्सेस करें:

     GET https://localhost:3000/{shortId}

निष्कर्ष: आपने क्या सीखा

बधाई हो! आपने Node.js और Redis का उपयोग करके डिस्ट्रीब्यूटेड कैशिंग के साथ एक स्केलेबल URL शॉर्टनर सर्विस को सफलतापूर्वक बनाया है। इस ट्यूटोरियल के दौरान, आपने सीखा कि कैसे:

1. कई Redis इंस्टेंस पर कैश एंट्री वितरित करने के लिए कंसिस्टेंट हैशिंग लागू करें।

2. डेटा को अद्यतन रखने के लिए कैश इनवैलिडेशन रणनीतियों के साथ अपने एप्लिकेशन को अनुकूलित करें।

3. कई Redis नोड्स के साथ एक डिस्ट्रीब्यूटेड वातावरण का अनुकरण करने के लिए Docker का उपयोग करें।

4. प्रदर्शन को अनुकूलित करने के लिए कैश हिट और मिस की निगरानी करें।

अगले कदम:

• डेटाबेस जोड़ें: कैश से परे पर्सिस्टेंस के लिए URL को डेटाबेस में स्टोर करें।

• एनालिटिक्स लागू करें: छोटे URL के लिए क्लिक काउंट और एनालिटिक्स ट्रैक करें।

• क्लाउड पर डिप्लॉय करें: ऑटो-स्केलिंग और रेजिलिएंस के लिए Kubernetes का उपयोग करके अपने एप्लिकेशन को डिप्लॉय करें।

हैप्पी कोडिंग!