C# में Rate Limiting और Throttling: अनुरोधों को नियंत्रित करें

C# में Rate Limiting और Throttling: API को ओवरलोड से बचाएं और उपयोगकर्ताओं को खुश रखें

कल्पना करें: आपने एक शानदार API लॉन्च किया। सर्वर तेज़ है, डेटाबेस तुरंत जवाब देता है। लेकिन अचानक — बूम! — एक बेईमान क्लाइंट (या इससे भी बुरा, DDoS अटैक) आपके एंडपॉइंट पर हजारों अनुरोध प्रति सेकंड भेजने लगता है। सर्वर डाउन हो जाता है, डेटाबेस हैंग हो जाता है, और असली उपयोगकर्ता 503 एरर देखते हैं। परिचित लग रहा है?

इस समस्या का समाधान है — rate limiting (दर सीमा) और throttling (थ्रॉटलिंग)। C# में हमारे पास इन तंत्रों को सुंदर और प्रभावी ढंग से लागू करने के लिए सभी उपकरण हैं। इस लेख में हम सिर्फ थ्योरी नहीं पढ़ेंगे — हम असली कोड लिखेंगे, लोकप्रिय एल्गोरिदम को समझेंगे और पता लगाएंगे कि किसी विशेष कार्य के लिए क्या चुनना चाहिए। तैयार हो जाइए, यह दिलचस्प होने वाला है!

Rate Limiting vs Throttling: क्या अंतर है?

हालांकि इन शब्दों को अक्सर एक-दूसरे के स्थान पर उपयोग किया जाता है, इनमें स्पष्ट अंतर है:

\n
• Rate Limiting — यह एक "सख्त" ब्लॉकिंग है। यदि उपयोगकर्ता सीमा पार करता है (जैसे, प्रति मिनट 100 अनुरोध), तो सर्वर HTTP 429 (Too Many Requests) लौटाता है। अनुरोध बिज़नेस लॉजिक तक नहीं पहुंचते।
\n
• Throttling — यह एक "नरम" धीमा करना है। सर्वर अनुरोध स्वीकार करता है, लेकिन इसे देरी से प्रोसेस करता है या प्राथमिकता कम कर देता है। उपयोगकर्ता को एरर नहीं मिलती, लेकिन उसकी गति कम हो जाती है।
\n

C# में हम दोनों दृष्टिकोणों को लागू कर सकते हैं, अक्सर विभिन्न परिदृश्यों के लिए इन्हें संयोजित करते हैं।

Rate Limiting एल्गोरिदम: सरल से जटिल तक

कोड लिखने से पहले, आइए गणित को समझें। चार "सुनहरे" एल्गोरिदम हैं जो 90% समाधानों का आधार हैं।

1. Fixed Window (फिक्स्ड विंडो)

सबसे सरल तरीका। हम समय को निश्चित अंतरालों (जैसे, 1 मिनट) में विभाजित करते हैं और प्रत्येक विंडो में अनुरोध गिनते हैं। जैसे ही काउंटर सीमा तक पहुंचता है — हम ब्लॉक कर देते हैं।

फायदे: लागू करना आसान। नुकसान: "एज इफेक्ट" की समस्या (विंडो के बीच संक्रमण पर अचानक उछाल)।

public class FixedWindowRateLimiter\n{\n    private readonly int _limit;\n    private readonly TimeSpan _windowSize;\n    private int _counter;\n    private DateTime _windowStart;\n\n    public FixedWindowRateLimiter(int limit, TimeSpan windowSize)\n    {\n        _limit = limit;\n        _windowSize = windowSize;\n        _windowStart = DateTime.UtcNow;\n    }\n\n    public bool AllowRequest()\n    {\n        var now = DateTime.UtcNow;\n        if (now - _windowStart >= _windowSize)\n        {\n            // विंडो रीसेट करें\n            _counter = 0;\n            _windowStart = now;\n        }\n\n        if (_counter >= _limit)\n            return false; // बहुत अधिक अनुरोध\n\n        Interlocked.Increment(ref _counter);\n        return true;\n    }\n}

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

Fixed Window का विकसित रूप। कठोर सीमाओं के बजाय, हम एक स्लाइडिंग समय अवधि में अनुरोधों को ध्यान में रखते हैं। इसे आमतौर पर टाइमस्टैम्प लॉग करके (जैसे, रिंग बफर में) लागू किया जाता है।

फायदे: उछाल को कम करता है। नुकसान: लागू करना थोड़ा जटिल, टाइमस्टैम्प स्टोर करने के लिए मेमोरी की आवश्यकता।

public class SlidingWindowRateLimiter\n{\n    private readonly int _limit;\n    private readonly TimeSpan _windowSize;\n    private readonly Queue<DateTime> _timestamps = new();\n\n    public SlidingWindowRateLimiter(int limit, TimeSpan windowSize)\n    {\n        _limit = limit;\n        _windowSize = windowSize;\n    }\n\n    public bool AllowRequest()\n    {\n        var now = DateTime.UtcNow;\n        lock (_timestamps)\n        {\n            // पुराने टाइमस्टैम्प हटाएं\n            while (_timestamps.Count > 0 && now - _timestamps.Peek() > _windowSize)\n                _timestamps.Dequeue();\n\n            if (_timestamps.Count >= _limit)\n                return false;\n\n            _timestamps.Enqueue(now);\n            return true