C++ में Rate Limiting: API सुरक्षा के लिए लाइब्रेरी और कोड

C++ में Rate Limiting: उपकरण और कार्यान्वयन की समीक्षा

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

लोकप्रिय Rate Limiting एल्गोरिदम

लाइब्रेरी चुनने से पहले, यह समझना उपयोगी है कि कौन से एल्गोरिदम काम करते हैं:

• Token Bucket (टोकन बकेट) — टोकन एक निश्चित दर से जोड़े जाते हैं, प्रत्येक अनुरोध एक टोकन का उपभोग करता है। यदि टोकन नहीं हैं, तो अनुरोध अस्वीकार कर दिया जाता है। सरल और प्रभावी।
• Sliding Window (स्लाइडिंग विंडो) — पिछले समय अंतराल में अनुरोधों की संख्या को ध्यान में रखता है (उदाहरण: 1 सेकंड में 10 अनुरोध)।
• Fixed Window (फिक्स्ड विंडो) — एक निश्चित अवधि के लिए अनुरोधों का एक सरल काउंटर (उदाहरण: हर मिनट काउंटर रीसेट होता है)।
• Leaky Bucket (लीकी बकेट) — अनुरोधों को कतार में रखा जाता है और एक स्थिर गति से संसाधित किया जाता है, अतिरिक्त को हटा दिया जाता है।

C++ के लिए Rate Limiting लाइब्रेरी

1. Boost.Token Bucket (Boost.Timer + मैन्युअल कार्यान्वयन)

Boost में token bucket की तैयार कार्यान्वयन नहीं है, लेकिन इसे boost::timer या std::chrono के ऊपर आसानी से लिखा जा सकता है। हालांकि, production समाधानों के लिए पूर्ण लाइब्रेरी का उपयोग करना बेहतर है।

2. libcppa (C++ Actor Framework)

libcppa लाइब्रेरी (अब CAF — C++ Actor Framework का हिस्सा) एक्टर्स के लिए अंतर्निहित rate limiting तंत्र प्रदान करती है। यह प्रति इकाई समय में संदेशों की संख्या को सीमित करने की अनुमति देती है।

#include <caf/all.hpp>

using namespace caf;

behavior rate_limited_actor(event_based_actor* self, int max_requests, duration period) {
    auto limiter = self->make_rate_limiter(max_requests, period);
    return {
        [=](const std::string& msg) {
            if (limiter->try_acquire()) {
                aout(self) << "Processed: " << msg << endl;
            } else {
                aout(self) << "Rate limit exceeded for: " << msg << endl;
            }
        }
    };
}

3. userver (Yandex द्वारा)

Yandex का userver फ्रेमवर्क C++ में उच्च-लोड सेवाओं के लिए एक शक्तिशाली समाधान है। इसमें components::RateLimiter और utils::TokenBucket के माध्यम से अंतर्निहित rate limiting सपोर्ट शामिल है।

#include <userver/utils/token_bucket.hpp>

using namespace userver;

int main() {
    utils::TokenBucket limiter(10, std::chrono::seconds(1)); // 10 अनुरोध प्रति सेकंड
    for (int i = 0; i < 20; ++i) {
        if (limiter.TryObtain()) {
            std::cout << "Request " << i << " allowed\n";
        } else {
            std::cout << "Request " << i << " blocked\n";
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    return 0;
}

4. Pistache (Rate Limiting के साथ HTTP फ्रेमवर्क)

Pistache लाइब्रेरी HTTP सर्वर बनाने के लिए rate limiting के लिए अंतर्निहित middleware प्रदान करती है। उदाहरण:

#include <pistache/endpoint.h>
#include <pistache/router.h>
#include <pistache/http.h>

using namespace Pistache;

int main() {
    Http::Endpoint server(Address(Ipv4::any(), Port(9080)));
    auto router = std::make_shared<Rest::Router>();
    
    // अंतर्निहित rate limiter: 5 अनुरोध प्रति सेकंड
    router->addMiddleware(Http::Middleware::RateLimit(5, std::chrono::seconds(1)));
    
    Rest::Routes::Get(*router, "/api/resource", [](const Rest::Request& req, Http::ResponseWriter response) {
        response.send(Http::Code::Ok, "Hello, world!");
    });