Rust में Rate Limiting: अनुरोध आवृत्ति सीमित करने वाली लाइब्रेरीज़

Rust में Rate Limiting: प्रभावी लोड प्रबंधन

Rate limiting (अनुरोध आवृत्ति को सीमित करना) वेब-सर्विसेज़, API और नेटवर्क एप्लिकेशन की सुरक्षा और अनुकूलन के लिए एक महत्वपूर्ण तंत्र है। Rust इकोसिस्टम में कई परिपक्व लाइब्रेरीज़ हैं जो विभिन्न एल्गोरिदम लागू करती हैं: क्लासिक टोकन-बकेट से लेकर आधुनिक अनुकूली विधियों तक। इस लेख में, हम तीन मुख्य लाइब्रेरीज़: governor, leaky-bucket और ratelimit को कोड उदाहरणों और चयन संबंधी सुझावों के साथ समझेंगे।

1. governor लाइब्रेरी — स्वर्ण मानक

governor rate limiting के लिए सबसे लोकप्रिय और लचीली लाइब्रेरी है। यह Generic Cell Rate Algorithm (GCRA) एल्गोरिदम लागू करती है, जो न्यूनतम विलंबता के साथ सीमाओं का सटीक पालन सुनिश्चित करती है। यह सिंक्रोनस और एसिंक्रोनस दोनों मोड, साथ ही Actix-web, Axum और Rocket के लिए middleware का समर्थन करती है।

governor के साथ बुनियादी उदाहरण

use governor::{DefaultKeyedRateLimiter, Quota, RateLimiter};
use std::num::NonZeroU32;
use std::time::Duration;

fn main() {
    // प्रति सेकंड 5 अनुरोधों की अनुमति दें
    let quota = Quota::per_second(NonZeroU32::new(5).unwrap());
    let limiter = RateLimiter::direct(quota);

    for i in 0..10 {
        match limiter.check() {
            Ok(_) => println!("अनुरोध {} स्वीकृत", i),
            Err(_) => println!("अनुरोध {} अस्वीकृत (rate limit)", i),
        }
        std::thread::sleep(Duration::from_millis(100));
    }
}

प्रतीक्षा के साथ एसिंक्रोनस विकल्प

use governor::{Quota, RateLimiter};
use std::num::NonZeroU32;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let limiter = RateLimiter::direct(Quota::per_second(
        NonZeroU32::new(2).unwrap(),
    ));

    for i in 0..5 {
        limiter.until_ready().await;
        println!("अनुरोध {} संसाधित", i);
        sleep(Duration::from_millis(300)).await;
    }
}

governor की प्रमुख क्षमताएँ:

• KeyedRateLimiter के माध्यम से प्रति-IP, प्रति-उपयोगकर्ता सीमाओं का समर्थन
• HTTP सर्वरों के लिए tower middleware के साथ एकीकरण
• अनुकूलन योग्य रणनीतियाँ: प्रतीक्षा, अस्वीकृति, अनुकूली मंदी
• न्यूनतम मेमोरी खपत (प्रति लिमिटर एक परमाणु काउंटर)

2. leaky-bucket लाइब्रेरी — सरलता और विश्वसनीयता

leaky-bucket क्लासिक "लीकी बकेट" एल्गोरिदम लागू करती है। यह पीक लोड को स्मूथ करने के लिए आदर्श है, जब अनुरोधों का समान प्रवाह सुनिश्चित करना आवश्यक हो। यह लाइब्रेरी हल्की है और इसे किसी बाहरी निर्भरता की आवश्यकता नहीं है।

leaky-bucket के साथ उदाहरण

use leaky_bucket::RateLimiter;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let limiter = RateLimiter::builder()
        .initial(10)        // टोकन का प्रारंभिक भंडार
        .interval(Duration::from_secs(1))  // पुनःपूर्ति अंतराल
        .refill(5)          // प्रति अंतराल कितने टोकन जोड़ने हैं
        .max(20)            // टोकन की अधिकतम संख्या
        .build();

    for i in 0..15 {
        limiter.acquire_one().await;
        println!("अनुरोध {} पूर्ण", i);
    }
}

leaky-bucket की विशेषताएँ:

• एसिंक्रोनस और ब्लॉकिंग API का समर्थन
• "बर्स्ट" मोड (अल्पकालिक उछाल) को कॉन्फ़िगर करने की क्षमता
• निष्क्रियता पर टोकन का स्वचालित मुक्ति

3. ratelimit लाइब्रेरी — न्यूनतम दृष्टिकोण

ratelimit सबसे सरल लाइब्रेरी है, जो निश्चित अंतराल के साथ स्लाइडिंग विंडो लागू करती है। यह सरल परिदृश्यों के लिए उपयुक्त है जहाँ उच्च सटीकता की आवश्यकता नहीं है।

ratelimit के साथ उदाहरण

use ratelimit::Ratelimiter;
use std::time::Duration;

fn main() {
    let mut limiter = Ratelimiter::builder(10, Duration::from_secs(1))
        .build()
        .unwrap();

    for i in 0..20 {
        if limiter.try_wait() {