एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न · पाठ

Redis के साथ वितरित दर-सीमा

अनेक सेवा इंस्टेंस में काम करने वाले सुदृढ़ और विस्तार योग्य वितरित दर-सीमाकर्ता बनाने के लिए Redis का लाभ उठाना सीखें।

पाठ 2, कुल 4 में से11 चरण

Redis के साथ वितरित दर-सीमा, CoddyKit पर एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

एकल सर्वर से आगे विस्तार

पिछले पाठों में हमने बुनियादी दर सीमित करने के बारे में सीखा। लेकिन जब आपका अनुप्रयोग बढ़ता है और कई सर्वरों पर चलता है, तब क्या होता है?

मेमोरी-आधारित सीमाएँ: ये केवल एक सर्वर पर आने वाले अनुरोधों को ट्रैक करती हैं।
कई सर्वर: प्रत्येक सर्वर का अपना काउंटर होता है, जिससे सीमाएँ गलत और अप्रभावी हो जाती हैं।
समस्या: उपयोगकर्ता अलग-अलग सर्वरों पर अनुरोध भेजकर सीमाओं को पार कर सकते हैं।

हमें ऐसा तरीका चाहिए जिससे सभी सर्वर समान दर-सीमा स्थिति साझा कर सकें।

साझा स्थिति के लिए Redis का परिचय

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

Redis क्या है? यह एक ओपन-सोर्स, मेमोरी-आधारित डेटा संरचना भंडार है।
Redis क्यों? यह अत्यंत तेज़ है, विभिन्न डेटा प्रकारों का समर्थन करता है और समवर्ती ऐक्सेस के लिए बनाया गया है।
दर सीमित करने के लिए महत्वपूर्ण: इसके परमाणु संचालन कई सेवाओं में काउंटर को विश्वसनीय रूप से बढ़ाने के लिए उपयुक्त हैं।

काउंटर के लिए Redis कमांड

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

INCR key: key में संग्रहीत संख्या को परमाणु रूप से एक से बढ़ाता है। यदि कुंजी मौजूद नहीं है, तो बढ़ाने से पहले उसका मान 0 निर्धारित किया जाता है।
EXPIRE key seconds: key पर समय-सीमा निर्धारित करता है। समय-सीमा पूरी होने के बाद कुंजी अपने-आप हटा दी जाती है। हमारी दर-सीमा विंडो निर्धारित करने के लिए यह अत्यंत महत्वपूर्ण है।

कई समवर्ती अनुरोध होने पर भी ये कमांड हमारे काउंटरों को सुसंगत बनाए रखते हैं।

Redis के साथ निश्चित विंडो लागू करना

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

कुंजी परिभाषित करें: उपयोगकर्ता और वर्तमान समय विंडो के लिए एक विशिष्ट कुंजी, जैसे user:123:2023-10-27-10:00।
काउंटर बढ़ाएँ: अनुरोध आने पर इस कुंजी पर INCR का उपयोग करें।
समाप्ति निर्धारित करें: नई विंडो के पहले अनुरोध के लिए कुंजी की समय-सीमा निर्धारित करने हेतु EXPIRE का भी उपयोग करें, जैसे 60 सेकंड।
सीमा जाँचें: काउंटर बढ़ाने से पहले जाँचें कि कुंजी की वर्तमान संख्या अनुमत सीमा से कम है।

Redis की बुनियादी निश्चित विंडो कोड

यह Redis का उपयोग करने वाले निश्चित विंडो दर सीमक का एक सरल Python उदाहरण है। यह अंश पूर्ण त्रुटि प्रबंधन के बिना मुख्य तर्क दिखाता है।

import redis
import time

def is_rate_limited(user_id, limit, window_seconds):
    r = redis.Redis(host='localhost', port=6379, db=0)
    current_minute = int(time.time() // window_seconds)
    key = f"rate_limit:{user_id}:{current_minute}"

    count = r.get(key)
    if count is None:
        r.setex(key, window_seconds, 0) # Initialize and set expiry
        count = 0
    else:
        count = int(count)

    if count < limit:
        r.incr(key)
        return False # Not rate limited
    return True # Rate limited

if __name__ == "__main__":
    user = "user_alice"
    requests_limit = 5
    time_window = 60 # seconds

    print(f"Testing rate limiter for {user} ({requests_limit} reqs/{time_window}s)")
    for i in range(1, 8):
        if is_rate_limited(user, requests_limit, time_window):
            print(f"Request {i}: Rate limited!")
        else:
            print(f"Request {i}: OK")
            time.sleep(0.1) # Simulate some work

दौड़ की स्थितियों का समाधान

पिछले उदाहरण में `get`, `setex` और `incr` संचालन अलग-अलग हैं। इससे दौड़ की स्थिति उत्पन्न हो सकती है:

जब कुंजी मौजूद न हो, तब दो अनुरोध `GET` से उस कुंजी को पढ़ सकते हैं।
दोनों अनुरोध `SETEX` चला सकते हैं और एक-दूसरे की समाप्ति अवधि को बदल सकते हैं।
पहले बढ़ाए गए मान के लिए `EXPIRE` निर्धारित न हो पाए, जिससे काउंटर अनिश्चित काल तक बना रह सकता है।

हमें इन कई Redis कमांड को एकल, परमाणु संचालन के रूप में निष्पादित करना होगा।

Lua स्क्रिप्ट के साथ परमाणु संचालन

Redis आपको सर्वर-पक्षीय Lua स्क्रिप्ट चलाने की सुविधा देता है। दर सीमित करने के लिए यह अत्यंत शक्तिशाली है, क्योंकि:

परमाणुता: Lua स्क्रिप्ट एकल, अविभाज्य कमांड के रूप में चलती है। कोई अन्य Redis कमांड इसे बाधित नहीं कर सकती।
दक्षता: जटिल संचालन के लिए नेटवर्क के बार-बार होने वाले आवागमन को कम करती है।

हम एक Lua स्क्रिप्ट लिख सकते हैं, जो काउंटर की जाँच करे, उसे बढ़ाए और उसी प्रक्रिया में उसकी समाप्ति अवधि निर्धारित करे।

दर सीमक के लिए Lua स्क्रिप्ट का उदाहरण

यह परमाणु निश्चित विंडो काउंटर के लिए Lua स्क्रिप्ट है। इसमें कुंजी, सीमा और विंडो की अवधि तर्कों के रूप में ली जाती है।

local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])

local current_count = redis.call('INCR', key)

if current_count == 1 then
    redis.call('EXPIRE', key, window)
end

if current_count > limit then
    return 1 -- Rate limited
else
    return 0 -- Not rate limited
end

Python से Lua स्क्रिप्ट चलाना

अब देखते हैं कि अपने Python अनुप्रयोग से इस Lua स्क्रिप्ट को कैसे एकीकृत और निष्पादित किया जाए। EVAL कमांड परमाणु निष्पादन के लिए स्क्रिप्ट को Redis तक भेजती है।

import redis
import time

def is_rate_limited_atomic(user_id, limit, window_seconds):
    r = redis.Redis(host='localhost', port=6379, db=0)
    current_minute = int(time.time() // window_seconds)
    key = f"rate_limit_atomic:{user_id}:{current_minute}"

    # The Lua script to execute
    lua_script = """
    local key = KEYS[1]
    local limit = tonumber(ARGV[1])
    local window = tonumber(ARGV[2])

    local current_count = redis.call('INCR', key)

    if current_count == 1 then
        redis.call('EXPIRE', key, window)
    end

    if current_count > limit then
        return 1 -- Rate limited
    else
        return 0 -- Not rate limited
    end
    """

    # Execute the Lua script atomically
    # KEYS[1] is 'key'
    # ARGV[1] is 'limit', ARGV[2] is 'window_seconds'
    result = r.eval(lua_script, 1, key, limit, window_seconds)
    return bool(result)

if __name__ == "__main__":
    user = "user_bob"
    requests_limit = 5
    time_window = 60 # seconds

    print(f"Testing atomic rate limiter for {user} ({requests_limit} reqs/{time_window}s)")
    for i in range(1, 8):
        if is_rate_limited_atomic(user, requests_limit, time_window):
            print(f"Request {i}: Rate limited!")
        else:
            print(f"Request {i}: OK")
            time.sleep(0.1) # Simulate some work

वितरित सीमा-जाँच

विशेष रूप से Lua स्क्रिप्ट का उपयोग करते समय, वितरित दर सीमित करने के लिए Redis का उपयोग करने के मुख्य लाभों में से कौन-से हैं?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: विस्तार के लिए Redis

बहुत अच्छा! आपने Redis का उपयोग करके मजबूत वितरित दर सीमक बनाना सीख लिया है।

वितरण की समस्या: कई अनुप्रयोग इंस्टेंस होने पर मेमोरी-आधारित सीमाएँ विफल हो जाती हैं।
Redis समाधान: यह दर-सीमा काउंटरों के लिए तेज़, केंद्रीकृत और साझा स्थिति उपलब्ध कराता है।
मुख्य कमांड: INCR और EXPIRE आधारभूत कमांड हैं।
Lua के साथ परमाणुता: कई Redis कमांड शामिल होने पर दौड़ की स्थितियों को रोकने और शुद्धता सुनिश्चित करने के लिए यह महत्वपूर्ण है।

स्केल किए जा सकने वाले और सुदृढ़ API बनाने के लिए यह तरीका आधारभूत है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Redis के साथ वितरित दर-सीमा” पाठ निःशुल्क है?

हाँ—“Redis के साथ वितरित दर-सीमा” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Redis के साथ वितरित दर-सीमा” में मैं क्या सीखूँगा?

अनेक सेवा इंस्टेंस में काम करने वाले सुदृढ़ और विस्तार योग्य वितरित दर-सीमाकर्ता बनाने के लिए Redis का लाभ उठाना सीखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“Redis के साथ वितरित दर-सीमा” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← एपीआई दर-सीमा निर्धारण और स्केलेबिलिटी पैटर्न पर वापस जाएँ