Redis और Lua के साथ एक स्केलेबल डिस्ट्रीब्यूटेड रेट लिमिटर बनाएं - चरण-दर-चरण गाइड

इस व्यापक गाइड में, आप Redis और Lua स्क्रिप्टिंग का उपयोग करके एक डिस्ट्रीब्यूटेड रेट लिमिटर बनाएंगे ताकि हाई-ट्रैफिक वातावरण में यूज़र रिक्वेस्ट को नियंत्रित किया जा सके।

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

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

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

• Redis का उपयोग करके रेट लिमिटिंग सिस्टम कैसे बनाएं।

• Redis के साथ Lua स्क्रिप्ट का उपयोग करके एटॉमिक ऑपरेशन कैसे प्राप्त करें।

• कुशल रिक्वेस्ट ट्रैकिंग के लिए Redis डेटा संरचनाओं को समझना।

• डिस्ट्रीब्यूटेड सिस्टम में हाई ट्रैफिक को संभालने की तकनीक।

• डिस्ट्रीब्यूटेड रेट लिमिटर का अनुकरण और स्केल करने के लिए Docker का उपयोग करना।

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

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

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

• Redis

• Docker (डिस्ट्रीब्यूटेड वातावरण का अनुकरण करने के लिए)

• Node.js, Redis, और Lua स्क्रिप्टिंग की बुनियादी समझ।

विषय सूची

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

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

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

• चरण 1: प्रोजेक्ट सेटअप कैसे करें

• चरण 2: Redis सेटअप कैसे करें

• चरण 3: Redis और Lua के साथ रेट लिमिटर कैसे लागू करें

• चरण 4: Node.js API सर्वर कैसे बनाएं

• चरण 5: रेट लिमिटर का टेस्ट कैसे करें

• चरण 6: रेट लिमिटिंग मेट्रिक्स को कैसे विज़ुअलाइज़ करें

• चरण 7: Docker के साथ डिप्लॉय कैसे करें

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

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

इस ट्यूटोरियल में, आप:

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

2. रेस कंडीशन से बचने के लिए एटॉमिक ऑपरेशन सुनिश्चित करने के लिए Lua स्क्रिप्ट का उपयोग करेंगे।

3. रेट लिमिटिंग के लिए टोकन बकेट एल्गोरिदम लागू करेंगे।

4. हाई ट्रैफिक का अनुकरण करने और रेट लिमिटिंग को एक्शन में देखने के लिए एक इंटरैक्टिव डेमो बनाएंगे।

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

आप निम्नलिखित घटकों के साथ सिस्टम बनाएंगे:

1. API सर्वर: इनकमिंग यूज़र रिक्वेस्ट को संभालता है।

2. Redis: रिक्वेस्ट डेटा स्टोर करता है और रेट लिमिट लागू करता है।

3. Lua स्क्रिप्ट्स: रेट लिमिटिंग के लिए Redis पर एटॉमिक अपडेट सुनिश्चित करता है।

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

चरण 1: प्रोजेक्ट सेटअप कैसे करें

आइए अपने Node.js प्रोजेक्ट को सेटअप करके शुरू करें:

mkdir distributed-rate-limiter
cd distributed-rate-limiter
npm init -y

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

npm install express redis dotenv

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

• redis: Redis के साथ इंटरैक्ट करने के लिए।

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

निम्न सामग्री के साथ एक .env फ़ाइल बनाएं:

REDIS_HOST=localhost
REDIS_PORT=6379
PORT=3000
RATE_LIMIT=5
TIME_WINDOW=60

ये वेरिएबल Redis होस्ट, पोर्ट, रेट लिमिट (अनुमत रिक्वेस्ट की संख्या), और टाइम विंडो (सेकंड में) को परिभाषित करते हैं।

चरण 2: Redis सेटअप कैसे करें

कोड में गोता लगाने से पहले, सुनिश्चित करें कि Redis आपके सिस्टम पर इंस्टॉल और चल रहा है। यदि आपके पास Redis इंस्टॉल नहीं है, तो आप इसे जल्दी से सेटअप करने के लिए Docker का उपयोग कर सकते हैं:

docker run -p 6379:6379 --name redis-rate-limiter -d redis

चरण 3: Redis और Lua के साथ रेट लिमिटर कैसे लागू करें

रेट लिमिटिंग को कुशलतापूर्वक संभालने के लिए, हम टोकन बकेट एल्गोरिदम का उपयोग करेंगे। इस एल्गोरिदम में:

1. प्रत्येक यूज़र के पास टोकन का एक "बकेट" होता है।

2. प्रत्येक रिक्वेस्ट एक टोकन का उपभोग करती है।

3. टोकन एक सेट दर पर समय-समय पर रीफिल होते हैं।

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

रेट लिमिटिंग के लिए Lua स्क्रिप्ट कैसे बनाएं

rate_limiter.lua नामक एक फ़ाइल बनाएं:

local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local current = redis.call("get", key)
if current and tonumber(current) >= limit then
    return 0
else
    if current then
        redis.call("incr", key)
    else
        redis.call("set", key, 1, "EX", window)
    end
    return 1
end

1. इनपुट:

   • KEYS[1]: यूज़र के रिक्वेस्ट काउंट को दर्शाने वाली Redis कुंजी।

   • ARGV[1]: रेट लिमिट (अनुमत अधिकतम रिक्वेस्ट की संख्या)।

   • ARGV[2]: रेट लिमिट के लिए टाइम विंडो (सेकंड में)।

2. लॉजिक:

   • यदि यूज़र रेट लिमिट पर पहुंच गया है, तो 0 लौटाएं (रिक्वेस्ट ब्लॉक)।

   • यदि यूज़र लिमिट के भीतर है, तो उनके रिक्वेस्ट काउंट को बढ़ाएं या पहली रिक्वेस्ट होने पर एक्सपायरेशन के साथ एक नया काउंट सेट करें।

   • 1 लौटाएं (रिक्वेस्ट अनुमत)।

चरण 4: Node.js API सर्वर कैसे बनाएं

server.js नामक एक फ़ाइल बनाएं:

require('dotenv').config();
const express = require('express');
const redis = require('redis');
const fs = require('fs');
const path = require('path');
const app = express();
const client = redis.createClient({ host: process.env.REDIS_HOST, port: process.env.REDIS_PORT });
const rateLimitScript = fs.readFileSync(path.join(__dirname, 'rate_limiter.lua'), 'utf8');
const RATE_LIMIT = parseInt(process.env.RATE_LIMIT);
const TIME_WINDOW = parseInt(process.env.TIME_WINDOW);
// रेट लिमिटिंग के लिए मिडलवेयर
async function rateLimiter(req, res, next) {
    const ip = req.ip;
    try {
        const allowed = await client.eval(rateLimitScript, 1, ip, RATE_LIMIT, TIME_WINDOW);
        if (allowed === 1) {
            next();
        } else {
            res.status(429).json({ message: 'Too many requests. Please try again later.' });
        }
    } catch (err) {
        console.error('Error in rate limiter:', err);
        res.status(500).json({ message: 'Internal server error' });
    }
}
app.use(rateLimiter);
app.get('/', (req, res) => {
    res.send('Welcome to the Rate Limited API!');
});
const PORT = process.env.PORT;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

1. रेट लिमिटर मिडलवेयर:

   • क्लाइंट का IP एड्रेस प्राप्त करता है और Lua स्क्रिप्ट का उपयोग करके जांचता है कि वे रेट लिमिट के भीतर हैं या नहीं।

   • यदि यूज़र लिमिट से अधिक हो जाता है, तो 429 प्रतिक्रिया भेजी जाती है।

2. API एंडपॉइंट:

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

चरण 5: रेट लिमिटर का टेस्ट कैसे करें

1. Redis शुरू करें:

   docker start redis-rate-limiter

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

   node server.js

3. रिक्वेस्ट का अनुकरण करें:

   • curl या Postman का उपयोग करके रेट लिमिटर का टेस्ट करें:

     curl https://localhost:3000

   • रेट लिमिटिंग को एक्शन में देखने के लिए तेजी से कई रिक्वेस्ट भेजें।

चरण 6: रेट लिमिटिंग मेट्रिक्स को कैसे विज़ुअलाइज़ करें

कैश हिट और ब्लॉक की गई रिक्वेस्ट जैसे रेट लिमिटिंग मेट्रिक्स की निगरानी करने के लिए, हम server.js में मिडलवेयर में लॉगिंग जोड़ेंगे:

async function rateLimiter(req, res, next) {
    const ip = req.ip;
    try {
        const allowed = await client.eval(rateLimitScript, 1, ip, RATE_LIMIT, TIME_WINDOW);
        if (allowed === 1) {
            console.log(`Allowed request from ${ip}`);
            next();
        } else {
            console.log(`Blocked request from ${ip}`);
            res.status(429).json({ message: 'Too many requests. Please try again later.' });
        }
    } catch (err) {
        console.error('Error in rate limiter:', err);
        res.status(500).json({ message: 'Internal server error' });
    }
}

चरण 7: Docker के साथ डिप्लॉय कैसे करें

आइए एप्लिकेशन को कंटेनराइज़ करें ताकि इसे डिस्ट्रीब्यूटेड वातावरण में चलाया जा सके।

एक Dockerfile बनाएं:

FROM node:14
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["node", "server.js"]

Docker कंटेनर को बिल्ड और चलाएं:

docker build -t rate-limiter .
docker run -p 3000:3000 rate-limiter

अब आप रेट लिमिटर को कई इंस्टेंस चलाकर स्केल कर सकते हैं।

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

बधाई हो! आपने Redis और Lua स्क्रिप्ट का उपयोग करके एक डिस्ट्रीब्यूटेड रेट लिमिटर को सफलतापूर्वक बनाया है। इस ट्यूटोरियल के दौरान, आपने सीखा कि कैसे:

1. डिस्ट्रीब्यूटेड सिस्टम में यूज़र रिक्वेस्ट को नियंत्रित करने के लिए रेट लिमिटिंग लागू करें।

2. Redis में एटॉमिक ऑपरेशन करने के लिए Lua स्क्रिप्ट का उपयोग करें।

3. रिक्वेस्ट कोटा प्रबंधित करने के लिए टोकन बकेट एल्गोरिदम लागू करें।

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

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

अगले कदम:

1. यूज़र ID द्वारा रेट लिमिटिंग जोड़ें: सिस्टम को प्रति यूज़र रेट लिमिट का समर्थन करने के लिए विस्तारित करें।

2. Nginx के साथ इंटीग्रेट करें: Redis-बैक्ड रेट लिमिटिंग के साथ Nginx को रिवर्स प्रॉक्सी के रूप में उपयोग करें।

3. Kubernetes के साथ डिप्लॉय करें: उच्च उपलब्धता के लिए Kubernetes का उपयोग करके अपने रेट लिमिटर को स्केल करें।

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