C++ में रेट लिमिटिंग: लाइब्रेरी और उपकरण

C++ में रेट लिमिटिंग: अनुरोध सीमा के लिए पूर्ण गाइड

रेट लिमिटिंग (अनुरोध गति सीमा) सर्वर, API और वितरित सिस्टम को ओवरलोड, DDoS हमलों और ट्रैफ़िक में अचानक वृद्धि से बचाने के लिए एक महत्वपूर्ण तंत्र है। C++ में रेट लिमिटिंग को लागू करने के लिए कुशल एल्गोरिदम और सही लाइब्रेरी के चयन की आवश्यकता होती है। इस लेख में, हम मुख्य दृष्टिकोणों, लोकप्रिय लाइब्रेरीज़ का विश्लेषण करेंगे और तैयार कोड उदाहरण प्रस्तुत करेंगे।

रेट लिमिटिंग क्या है और इसकी आवश्यकता क्यों है?

रेट लिमिटिंग एक निश्चित समय अवधि में क्लाइंट या सिस्टम द्वारा किए जा सकने वाले अनुरोधों की अधिकतम संख्या निर्धारित करता है। मुख्य उद्देश्य:

दुरुपयोग और सर्वर ओवरलोड से सुरक्षा
उपयोगकर्ताओं के बीच संसाधनों का समान वितरण सुनिश्चित करना
DDoS हमलों और ब्रूट फोर्स हमलों को रोकना
API कोटा खपत पर नियंत्रण

रेट लिमिटिंग के मुख्य एल्गोरिदम

C++ में आमतौर पर तीन क्लासिक एल्गोरिदम का उपयोग किया जाता है:

1. Token Bucket (टोकन बकेट)

सबसे लोकप्रिय एल्गोरिदम। यह टोकन वाली एक "बाल्टी" है जो एक स्थिर दर से भरती है। प्रत्येक अनुरोध एक टोकन लेता है। यदि टोकन नहीं हैं, तो अनुरोध अस्वीकार कर दिया जाता है।

#include <chrono>#include <mutex>

class TokenBucket {private:    double tokens;    double maxTokens;    double refillRate; // प्रति सेकंड टोकन    std::chrono::steady_clock::time_point lastRefill;    std::mutex mtx;

public:    TokenBucket(double maxTokens, double refillRate)         : tokens(maxTokens), maxTokens(maxTokens), refillRate(refillRate) {        lastRefill = std::chrono::steady_clock::now();    }

    bool tryConsume() {        std::lock_guard<std::mutex> lock(mtx);        refill();        if (tokens >= 1.0) {            tokens -= 1.0;            return true;        }        return false;    }

private:    void refill() {        auto now = std::chrono::steady_clock::now();        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastRefill).count() / 1000.0;        tokens = std::min(maxTokens, tokens + elapsed * refillRate);        lastRefill = now;    }};

2. Leaky Bucket (लीकी बकेट)

अनुरोध एक कतार (बाल्टी) में आते हैं, जिसे एक निश्चित गति से संसाधित किया जाता है। यदि बाल्टी भर जाती है, तो अनुरोधों को हटा दिया जाता है।

#include <queue>#include <chrono>

class LeakyBucket {private:    std::queue<int> bucket;    size_t capacity;    double leakRate; // प्रति सेकंड अनुरोध    std::chrono::steady_clock::time_point lastLeak;    std::mutex mtx;

public:    LeakyBucket(size_t capacity, double leakRate)         : capacity(capacity), leakRate(leakRate) {        lastLeak = std::chrono::steady_clock::now();    }

    bool addRequest(int request) {        std::lock_guard<std::mutex> lock(mtx);        leak();        if (bucket.size() < capacity) {            bucket.push(request);            return true;        }        return false;    }

private:    void leak() {        auto now = std::chrono::steady_clock::now();        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastLeak).count() / 1000.0;        size_t toRemove = static_cast<size_t>(elapsed * leakRate);        while (toRemove > 0 && !bucket.empty()) {            bucket.pop();            toRemove--;        }        lastLeak = now;    }};

3. Sliding Window Log (स्लाइडिंग विंडो लॉग)

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