Go में Rate Limiting: अनुरोध दर सीमित करने की पूरी गाइड

Go में Rate Limiting: अनुरोध दर सीमित करने की संपूर्ण गाइड

Rate limiting (अनुरोध दर सीमित करना) आधुनिक वेब एप्लिकेशन और माइक्रोसर्विसेज में लोड प्रबंधन और सुरक्षा का एक महत्वपूर्ण तंत्र है। Go (Golang) भाषा में rate limiting को लागू करने के लिए सरल से लेकर उन्नत तक कई दृष्टिकोण और लाइब्रेरी मौजूद हैं। इस लेख में हम मुख्य अवधारणाओं, लोकप्रिय लाइब्रेरी और कोड उदाहरणों पर चर्चा करेंगे।

Rate Limiting क्या है और इसकी आवश्यकता क्यों है?

Rate limiting एक ऐसी तकनीक है जो एक निश्चित समय अंतराल में क्लाइंट द्वारा भेजे जा सकने वाले अनुरोधों की संख्या को नियंत्रित करती है। मुख्य उद्देश्य:

• DDoS हमलों से सुरक्षा — सर्वर को ओवरलोड होने से बचाना
• संसाधनों का उचित वितरण — सभी उपयोगकर्ताओं के लिए समान पहुंच सुनिश्चित करना
• संसाधनों की बचत — इंफ्रास्ट्रक्चर लागत कम करना
• दुरुपयोग रोकना — स्क्रैपिंग और ब्रूटफोर्स से बचाव

Rate Limiting के मुख्य एल्गोरिदम

कई क्लासिक एल्गोरिदम हैं, प्रत्येक के अपने फायदे हैं:

• Token Bucket (टोकन बकेट) — सबसे लोकप्रिय एल्गोरिदम, जहां "टोकन" एक निश्चित दर से जमा होते हैं
• Leaky Bucket (लीकी बकेट) — अनुरोध एक निश्चित दर पर प्रोसेस होते हैं, अतिरिक्त अनुरोध छोड़ दिए जाते हैं
• Fixed Window (फिक्स्ड विंडो) — एक निश्चित समय अंतराल में अनुरोधों का सरल काउंटर
• Sliding Window (स्लाइडिंग विंडो) — Fixed Window से अधिक सटीक, समय सीमाओं को ध्यान में रखता है

Go में Rate Limiting के लिए लोकप्रिय लाइब्रेरी

1. स्टैंडर्ड लाइब्रेरी: golang.org/x/time/rate

यह Go टीम का आधिकारिक एक्सटेंशन है, जो Token Bucket एल्गोरिदम को लागू करता है। यह हल्का, उपयोग में आसान और अधिकांश परिदृश्यों के लिए आदर्श है।

package main

import (
    "fmt"
    "net/http"
    "time"
    "golang.org/x/time/rate"
)

func main() {
    // लिमिटर बनाएं: प्रति सेकंड 2 अनुरोध, burst 5 के साथ
    limiter := rate.NewLimiter(2, 5)

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if !limiter.Allow() {
            http.Error(w, "बहुत अधिक अनुरोध", http.StatusTooManyRequests)
            return
        }
        fmt.Fprintf(w, "OK: %s", time.Now().Format(time.RFC3339))
    })

    http.ListenAndServe(":8080", nil)
}

2. github.com/ulule/limiter

अधिक लचीली लाइब्रेरी जो विभिन्न स्टोरेज (Redis, Memcached, in-memory) और एल्गोरिदम को सपोर्ट करती है। वितरित सिस्टम के लिए उपयुक्त।

import (
    "github.com/gin-gonic/gin"
    "github.com/ulule/limiter/v3"
    "github.com/ulule/limiter/v3/drivers/store/memory"
)

func main() {
    // सेटअप: प्रति सेकंड 10 अनुरोध
    rate := limiter.Rate{
        Period: 1 * time.Second,
        Limit:  10,
    }

    store := memory.NewStore()
    instance := limiter.New(store, rate)

    r := gin.Default()
    r.Use(func(c *gin.Context) {
        key := c.ClientIP()
        context, err := instance.Get(c.Request.Context(), key)
        if err != nil {
            c.AbortWithStatusJSON(500, gin.H{"error": "आंतरिक त्रुटि"})
            return
        }
        if context.Reached {
            c.AbortWithStatusJSON(429, gin.H{"error": "बहुत अधिक अनुरोध"})
            return
        }
        c.Next()
    })

    r.Run(":8080")
}

3. github.com/juju/ratelimit

Canonical की सरल और विश्वसनीय लाइब्रेरी, जो Token Bucket एल्गोरिदम पर आधारित है। न्यूनतम API के लिए जानी जाती है।

import (
    "github.com/juju/ratelimit"
    "time"
)

func main() {
    // बकेट बनाएं: 100 टोकन, प्रति सेकंड 10 टोकन की दर से भरना
    bucket := ratelimit.NewBucketWithRate(10, 100)

    for i := 0; i < 200; i++ {
        if bucket.TakeAvailable(1