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

अनुरोधों की दर को नियंत्रित करने के लिए कई एल्गोरिदम हैं, लेकिन यहां हम टोकन बकेट एल्गोरिदम पर ध्यान केंद्रित करेंगे, क्योंकि इसे समझना और लागू करना अपेक्षाकृत आसान है। यह एल्गोरिदम बताता है कि: एक बाल्टी अधिकतम T टोकन रख सकती है, और जब कोई एप्लिकेशन तीसरे पक्ष एपीआई के लिए अनुरोध करना चाहता है, तो उसे 1 लेना होगा बाल्टी से टोकन. यदि बाल्टी खाली है, तो उसे बाल्टी में कम से कम 1 टोकन होने तक इंतजार करना होगा। साथ ही, बाल्टी को 1 टोकन से R टोकन/मिलीसेकंड की एक निश्चित दर पर फिर से भर दिया जाता है।

टोकन बकेट एल्गोरिदम समझने में बहुत सरल है, लेकिन कोई इसे वितरित वातावरण में तीसरे पक्ष एपीआई के आउटगोइंग अनुरोध को नियंत्रित करने के लिए कैसे उपयोग कर सकता है?

यदि कोई वितरित वातावरण में आउटगोइंग दर सीमा को नियंत्रित करना चाहता है, तो वर्तमान दर सीमा के लिए सत्य का एक केंद्रीकृत स्रोत आवश्यक है। सत्य के स्रोत को लागू करने के कई तरीके हैं और मैंने संभावित कार्यान्वयन के साथ निम्नलिखित आरेख को आदर्श बनाया है:

उपरोक्त चित्र में, हमारे पास कई पॉड्स में एक वितरित एप्लिकेशन है, और प्रत्येक पॉड तीसरे पक्ष एपीआई के लिए अनुरोध कर सकता है। एप्लिकेशन इंफ्रास्ट्रक्चर में, एक टीसीपी सर्वर है जो टोकन बकेट एल्गोरिदम का उपयोग करके दर सीमा को नियंत्रित करता है। तीसरे पक्ष एपीआई के लिए अनुरोध करने से पहले, पॉड टीसीपी सर्वर से एक नए टोकन के लिए पूछता है, और पॉड टीसीपी सर्वर से प्रतिक्रिया की प्रतीक्षा करता है जब तक कि कम से कम एक टोकन उपलब्ध न हो। टोकन उपलब्ध होने के बाद, पॉड तीसरे पक्ष एपीआई को अनुरोध करता है।

टीसीपी सर्वर कार्यान्वयन इस रिपॉजिटरी https://github.com/rafaquelhodev/rlimit/ में पाया जा सकता है और अगले भाग में मैं गोलांग में टोकन बकेट कार्यान्वयन पर संक्षेप में चर्चा करूंगा।

टोकन बकेट कार्यान्वयन

नीचे, मैं टोकन बकेट कार्यान्वयन के पीछे मुख्य विचार दिखा रहा हूं। कृपया, विस्तृत कार्यान्वयन को समझने के लिए https://github.com/rafaquelhodev/rlimit/ रिपॉजिटरी पर एक नज़र डालें।

दर सीमा नियंत्रण टोकनबकेट संरचना में केंद्रीकृत है:

type TokenBucket struct {
    id           string
    mu           sync.Mutex
    tokens       int64
    maxTokens    int64
    refillPeriod int64
    cron         chan bool
    subs         []chan bool
}

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

बकेट शुरू करते समय, हमें अधिकतम संख्या में टोकन प्रदान करने की आवश्यकता होती है जो बाल्टी समर्थन कर सकती है (मैक्सटोकन) और टोकन को बाल्टी में जोड़े जाने की मात्रा (रीफिलपीरियोड):

func newTokenBucket(id string, maxTokens int64, refillPeriod int64) *TokenBucket {
    bucket := &TokenBucket{
        id:           id,
        tokens:       0,
        maxTokens:    maxTokens,
        refillPeriod: refillPeriod,
        cron:         make(chan bool),
        subs:         make([]chan bool, 0),
    }
    fmt.Printf("refill period  = %d\n", refillPeriod)
    bucket.startCron()
    return bucket
}

अब, आप आश्चर्यचकित हो सकते हैं, "टोकन को बाल्टी में कैसे जोड़ा जाता है?"। उसके लिए, जब एक बकेट बनाया जाता है, तो एक क्रॉन जॉब शुरू किया जाता है, और प्रत्येक रिफिलपीरियड मिलीसेकेंड पर, बकेट में एक नया टोकन जोड़ा जाता है:

func (tb *TokenBucket) startCron() {
    ticker := time.NewTicker(time.Duration(tb.refillPeriod) * time.Millisecond)

    go func() {
        for {
            select {
            case  0 {
                        sub := tb.subs[0]
                        tb.subs = tb.subs[1:]
                        sub 



अंत में, जब कोई ग्राहक बकेट से टोकन चाहता है, तो waitAvailable फ़ंक्शन को कॉल किया जाना चाहिए:


func (tb *TokenBucket) waitAvailable() bool {
    tb.mu.Lock()

    if tb.tokens > 0 {
        fmt.Printf("[CONSUMING TOKEN] - id = %s\n", tb.id)
        tb.tokens -= 1
        tb.mu.Unlock()
        return true
    }

    fmt.Printf("[WAITING TOKEN] - id %s\n", tb.id)

    ch := tb.tokenSubscribe()

    tb.mu.Unlock()

    




https://github.com/Mohamed-hattab/Token-bucket-rate-limiter से प्रेरित