रेडिस और लुआ के साथ एक स्केलेबल वितरित दर सीमक बनाएं - चरण-दर-चरण मार्गदर्शिका

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

• <पी> Redis का उपयोग करके दर सीमित करने वाली प्रणाली कैसे बनाएं।

• <पी> परमाणु संचालन को प्राप्त करने के लिए रेडिस के साथ लुआ स्क्रिप्ट का उपयोग कैसे करें।

• <पी> कुशल अनुरोध ट्रैकिंग के लिए रेडिस डेटा संरचनाओं को समझना।

• <पी> वितरित प्रणाली में उच्च ट्रैफ़िक को संभालने की तकनीकें।

• <पी> वितरित दर सीमक को अनुकरण और स्केल करने के लिए डॉकर का उपयोग करना।

आवश्यकताएँ

• <पी> Node.js (v14 या उच्चतर)

• <पी> रेडिस

• <पी> डॉकर (वितरित वातावरण का अनुकरण करने के लिए)

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

सामग्री तालिका

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

• <पी> पूर्वावश्यकताएँ

• <पी> परियोजना अवलोकन

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

• <पी> चरण 2:रेडिस कैसे सेट करें

• <पी> चरण 3:रेडिस और लुआ के साथ रेट लिमिटर कैसे लागू करें
• <पी> चरण 4:Node.js API सर्वर कैसे बनाएं

• <पी> चरण 5:रेट लिमिटर का परीक्षण कैसे करें

• <पी> चरण 6:दर सीमित मेट्रिक्स की कल्पना कैसे करें

• <पी> चरण 7:डॉकर के साथ कैसे परिनियोजन करें

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

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

1. <पी> अनुरोध कोटा लागू करने के लिए रेडिस और लुआ का उपयोग करके एक दर सीमक बनाएं।

2. <पी> दौड़ की स्थिति से बचते हुए, परमाणु संचालन सुनिश्चित करने के लिए लुआ स्क्रिप्ट का उपयोग करें।

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

4. <पी> उच्च ट्रैफ़िक का अनुकरण करने और कार्रवाई में दर सीमित करने की कल्पना करने के लिए एक इंटरैक्टिव डेमो बनाएं।

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

1. <पी> एपीआई सर्वर :आने वाले उपयोगकर्ता अनुरोधों को संभालता है।

2. <पी> रेडिस :स्टोर डेटा का अनुरोध करते हैं और दर सीमा लागू करते हैं।

3. <पी> लुआ स्क्रिप्ट्स :दर सीमित करने के लिए रेडिस को परमाणु अपडेट सुनिश्चित करता है।

4. <पी> डॉकर :कई उदाहरणों के साथ एक वितरित वातावरण का अनुकरण करता है।

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

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

npm install express redis dotenv

• <पी> व्यक्त करना :एक हल्का वेब सर्वर ढांचा।

• <पी> रेडिस :रेडिस के साथ बातचीत के लिए।

• <पी> dotenv :पर्यावरण चर के प्रबंधन के लिए।

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

चरण 2:रेडिस कैसे सेट करें

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

चरण 3:रेडिस और लुआ के साथ रेट लिमिटर कैसे लागू करें

1. <पी> प्रत्येक उपयोगकर्ता के पास टोकन की एक "बाल्टी" होती है।

2. <पी> प्रत्येक अनुरोध के लिए एक टोकन की आवश्यकता होती है।

3. <पी> टोकन समय-समय पर एक निर्धारित दर पर पुनः भरे जाते हैं।

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

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. <पी> इनपुट :
   • <पी> कुंजियाँ[1] :रेडिस कुंजी उपयोगकर्ता की अनुरोध संख्या का प्रतिनिधित्व करती है।

   • <पी> ARGV[1] :दर सीमा (अनुमत अनुरोधों की अधिकतम संख्या)।

   • <पी> ARGV[2] :दर सीमा के लिए समय विंडो (सेकंड में)।

2. <पी> तर्क :
   • <पी> यदि उपयोगकर्ता दर सीमा तक पहुंच गया है, तो 0 लौटाएं (अनुरोध अवरुद्ध).

   • <पी> यदि उपयोगकर्ता सीमा के भीतर है, तो उनकी अनुरोध संख्या बढ़ाएँ या यदि यह पहला अनुरोध है तो समाप्ति के साथ एक नई गणना सेट करें।

   • <पी> वापसी 1 (अनुरोध स्वीकृत).

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

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);
// Middleware for rate limiting
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. <पी> रेट लिमिटर मिडलवेयर :
   • <पी> ग्राहक का आईपी पता प्राप्त करता है और लूआ स्क्रिप्ट का उपयोग करके जांच करता है कि क्या वे दर सीमा के भीतर हैं।

   • <पी> यदि उपयोगकर्ता सीमा पार कर जाता है, तो 429 प्रतिक्रिया भेज दी गई है.

2. <पी> एपीआई समापन बिंदु :
   • रूट एंडपॉइंट दर-सीमित है, इसलिए उपयोगकर्ता इसे निर्दिष्ट विंडो के भीतर सीमित संख्या में ही एक्सेस कर सकते हैं।

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

1. <पी> रेडिस प्रारंभ करें :

    docker start redis-rate-limiter
   

2. <पी> Node.js सर्वर चलाएँ :

    node server.js
   

3. <पी> अनुरोधों का अनुकरण करें :
   • <पी> curl का प्रयोग करें या दर सीमक का परीक्षण करने के लिए डाकिया:

      curl http://localhost:3000
     

   • <पी> कार्रवाई में दर सीमित करने को देखने के लिए तेजी से कई अनुरोध भेजें।

चरण 6:दर सीमित मेट्रिक्स की कल्पना कैसे करें

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:डॉकर के साथ कैसे परिनियोजन करें

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

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

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

1. <पी> वितरित सिस्टम में उपयोगकर्ता अनुरोधों को नियंत्रित करने के लिए दर सीमित लागू करें।

2. <पी> परमाणु संचालन करने के लिए रेडिस में लुआ स्क्रिप्ट का उपयोग करें।

3. <पी> अनुरोध कोटा प्रबंधित करने के लिए टोकन बकेट एल्गोरिथम लागू करें।

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

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

अगले चरण:

1. <पी> उपयोगकर्ता आईडी द्वारा दर सीमा जोड़ें :प्रति उपयोगकर्ता दर सीमा का समर्थन करने के लिए सिस्टम का विस्तार करें।

2. <पी> Nginx के साथ एकीकृत करें :Redis-समर्थित दर सीमा के साथ रिवर्स प्रॉक्सी के रूप में Nginx का उपयोग करें।

3. <पी> कुबेरनेट्स के साथ तैनाती :उच्च उपलब्धता के लिए कुबेरनेट्स का उपयोग करके अपने रेट लिमिटर को स्केल करें।