Rust में रेट लिमिटिंग और थ्रॉटलिंग: डेटा प्रवाह को नियंत्रित करना

जब Rust ओवरलोड का सामना करता है: आपकी सेवा क्यों "क्रैश" होती है?

कल्पना करें कि आपने Rust में एक आदर्श हाई-लोड सेवा लिखी है। यह बहुत तेज़ है, zero-cost एब्स्ट्रैक्शन और मेमोरी ओनरशिप के सभी लाभों का उपयोग करती है। लेकिन एक समस्या है — एक "भूखा" क्लाइंट आता है और आपके सर्वर पर प्रति सेकंड हजारों अनुरोध भेजना शुरू कर देता है। क्या होता है? डेटाबेस क्रैश हो जाता है? कतार बंद हो जाती है? या इससे भी बुरा, आपको उस बाहरी API से बैन मिल जाता है जिसका आप स्वयं उपयोग कर रहे हैं?

Rust में, किसी भी अन्य भाषा की तरह, रेट लिमिटिंग (गति सीमा) और थ्रॉटलिंग (नियंत्रण) के बिना काम नहीं चलता। यह केवल "अच्छा अभ्यास" नहीं है — यह प्रोडक्शन में आपके एप्लिकेशन के अस्तित्व का सवाल है। लेकिन Rust में एक ख़ासियत है: हम सब कुछ कुशलतापूर्वक और शुरू से करना पसंद करते हैं। हालांकि, पहिया का पुनः आविष्कार करने की आवश्यकता नहीं है — हमारे पास शक्तिशाली क्रेट (लाइब्रेरी) और सुरुचिपूर्ण पैटर्न हैं।

इस लेख में, हम समझेंगे कि क्लासिक एल्गोरिदम (Token Bucket) और आधुनिक एसिंक्रोनस दृष्टिकोणों का उपयोग करके Rust में अनुरोध सीमा को सही तरीके से कैसे लागू किया जाए। आप सीखेंगे कि अपने API को DDoS हमलों से कैसे बचाएं, बाहरी सेवाओं की सीमाओं को कैसे पार न करें, और अपना खुद का थ्रॉटलर कैसे लिखें जो Go या Python से भी तेज़ काम करेगा।

रेट लिमिटिंग बनाम थ्रॉटलिंग: क्या अंतर है?

कोड में गोता लगाने से पहले, आइए एक बार और हमेशा के लिए शब्दों को समझ लें। अक्सर इन्हें भ्रमित किया जाता है, लेकिन अंतर महत्वपूर्ण है।

\n
• रेट लिमिटिंग — यह एक सुरक्षा नीति है। आप कहते हैं: "क्लाइंट X एक मिनट में 100 से अधिक अनुरोध नहीं कर सकता।" यदि सीमा पार हो जाती है — तो आप 429 Too Many Requests लौटाते हैं। यह आपके बैकएंड की सुरक्षा है।
\n
• थ्रॉटलिंग — यह गति प्रबंधन का एक तंत्र है। आप स्वयं तय करते हैं कि CPU, I/O या डेटाबेस को ओवरलोड न करने के लिए अनुरोधों को किस गति से संसाधित करना है। क्लाइंट 1000 अनुरोध भेज सकता है, लेकिन आप उन्हें प्रति सेकंड 10 की दर से संसाधित करेंगे, बाकी को कतार में डाल देंगे।
\n

Rust में, दोनों दृष्टिकोणों को एक ही टूलकिट के साथ लागू किया जा सकता है, लेकिन अलग-अलग तर्क के साथ। हम दोनों पर विचार करेंगे।

एल्गोरिदम: Token Bucket और Leaky Bucket

रेट लिमिटिंग के लिए सबसे लोकप्रिय एल्गोरिदम Token Bucket और Leaky Bucket हैं। ये सरल हैं, लेकिन अविश्वसनीय रूप से प्रभावी हैं।

Token Bucket (टोकन की बाल्टी)

एक बाल्टी की कल्पना करें जिसमें हर सेकंड N टोकन टपकते हैं। जब कोई अनुरोध आता है, तो वह एक टोकन लेता है। यदि बाल्टी खाली है — अनुरोध अस्वीकार कर दिया जाता है। Rust परमाणु संचालन के कारण इस एल्गोरिदम को लागू करने के लिए आदर्श है।

Leaky Bucket (लीकी बाल्टी)

यहाँ बाल्टी के तल में एक छेद है जिसके माध्यम से प्रति सेकंड एक निश्चित संख्या में अनुरोध बाहर निकलते हैं। अनुरोध ऊपर से बाल्टी में आते हैं। यदि बाल्टी भर जाती है — अतिरिक्त अनुरोध हटा दिए जाते हैं। यह एल्गोरिदम पीक लोड को स्मूथ करने के लिए बेहतर है।

Rust में, हम इन एल्गोरिदम को हाथ से नहीं लिखेंगे (हालांकि यह शिक्षाप्रद है)। इसके बजाय, हम governor क्रेट का उपयोग करेंगे — Rust इकोसिस्टम में रेट लिमिटिंग का स्वर्ण मानक।

अभ्यास: Governor स्थापित करना

governor क्रेट — Token Bucket का एक तेज़, एसिंक्रोनस और थ्रेड-सेफ कार्यान्वयन है। यह सिंक्रोनस और एसिंक्रोनस दोनों मोड का समर्थन करता है, tokio और async-std के साथ काम करता है।

Cargo.toml में जोड़ें:

[dependencies]\ngovernor = "0.6"\ntokio = { version = "1", features = ["full"] }\n

अब hyper या axum पर आधारित HTTP सर्वर के लिए एक सरल रेट लिमिटर लिखते हैं। सरलता के लिए, हम axum का उपयोग करेंगे।

use axum::{\n    extract::Request,\n    http::StatusCode,\n    middleware::{self, Next},\n    response::Response,\n    routing::get,\n    Router,\n};\nuse governor::{DefaultDirectRateLimiter, Quota, RateLimiter};\n