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

इस सप्ताह, हम यातायात के प्रवाह को नियंत्रित करने के लिए दर सीमित करने को लागू करके इसका समाधान करने जा रहे हैं। हम सरल और प्रभावी golang.org/x/time/rate पैकेज का उपयोग करेंगे। बाद में, जब मेरा अपना ThrottleX समाधान तैयार हो जाएगा, तो मैं आपको दिखाऊंगा कि इसे अधिक स्केलेबल विकल्प के रूप में कैसे एकीकृत किया जाए। (पीएसएसटी, अपडेट के लिए मेरे GitHub को github.com/neelp03/throttlex पर देखें! वहां जो भी समस्या दिखे, उस पर बेझिझक टिप्पणी करें o7)

दर सीमित क्यों? ?

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

• दुर्व्यवहार को रोकना: बुरे कलाकारों या अति उत्साही उपयोगकर्ताओं को आपके एपीआई पर हावी होने से रोकता है।
• स्थिरता: ट्रैफ़िक स्पाइक के दौरान भी आपके एपीआई को उत्तरदायी और विश्वसनीय बनाए रखता है।
• निष्पक्षता: संसाधनों को उपयोगकर्ताओं के बीच समान रूप से साझा करने की अनुमति देता है।

चरण 1: समय/दर पैकेज स्थापित करना

golang.org/x/time/rate पैकेज विस्तारित गो लाइब्रेरी का हिस्सा है और एक सीधा टोकन-आधारित दर सीमक प्रदान करता है। आरंभ करने के लिए, आपको इसे इंस्टॉल करना होगा:

go get golang.org/x/time/rate

चरण 2: दर सीमक स्थापित करना

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

package main

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

// Create a struct to hold each client's rate limiter
type Client struct {
    limiter *rate.Limiter
}

// In-memory storage for clients
var clients = make(map[string]*Client)
var mu sync.Mutex

// Get a client's rate limiter or create one if it doesn't exist
func getClientLimiter(ip string) *rate.Limiter {
    mu.Lock()
    defer mu.Unlock()

    // If the client already exists, return the existing limiter
    if client, exists := clients[ip]; exists {
        return client.limiter
    }

    // Create a new limiter with 5 requests per minute
    limiter := rate.NewLimiter(5, 1)
    clients[ip] = &Client{limiter: limiter}
    return limiter
}

चरण 3: दर सीमित मिडलवेयर बनाना

अब, एक मिडलवेयर में getClientLimiter फ़ंक्शन का उपयोग करें जो दर सीमा के आधार पर पहुंच को प्रतिबंधित करेगा।

func rateLimitingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter := getClientLimiter(ip)

        // Check if the request is allowed
        if !limiter.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

यह काम किस प्रकार करता है:

1. आईपी-आधारित सीमा: प्रत्येक ग्राहक की पहचान उनके आईपी पते से की जाती है। हम ग्राहक के आईपी की जांच करते हैं और उसके लिए दर सीमक निर्दिष्ट करते हैं।
2. अनुरोध जांच: लिमिटर.Allow() विधि जांच करती है कि ग्राहक दर सीमा के भीतर है या नहीं। यदि वे हैं, तो अनुरोध अगले हैंडलर के पास चला जाता है; यदि नहीं, तो हम 429 बहुत अधिक अनुरोधों के साथ उत्तर देते हैं।

चरण 4: मिडलवेयर को विश्व स्तर पर लागू करना?

अब अपने रेट लिमिटर को एपीआई से जोड़ते हैं ताकि हर अनुरोध को इससे गुजरना पड़े:

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    // Apply rate-limiting middleware globally
    r.Use(rateLimitingMiddleware)

    // Other middlewares
    r.Use(loggingMiddleware)
    r.Use(errorHandlingMiddleware)

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

r.Use(rateLimitingMiddleware) लागू करके, हम यह सुनिश्चित करते हैं कि प्रत्येक आने वाले अनुरोध को किसी भी अंतिम बिंदु तक पहुंचने से पहले दर सीमक द्वारा जांचा जाता है।

चरण 5: दर सीमित करने का परीक्षण?

अपना सर्वर प्रारंभ करें:

go run main.go

अब, कुछ अनुरोधों के साथ एपीआई पर आते हैं। आप एक पंक्ति में एकाधिक अनुरोधों को अनुकरण करने के लिए कर्ल के साथ एक लूप का उपयोग कर सकते हैं:

for i in {1..10}; do curl http://localhost:8000/books; done

चूंकि हमने प्रति मिनट 5 अनुरोधों की सीमा निर्धारित की है, इसलिए अनुमत दर से अधिक होने पर आपको 429 बहुत अधिक अनुरोध प्रतिक्रियाएं दिखनी चाहिए।

आगे क्या होगा?

और वहां आपके पास यह है - अपने एपीआई को दबाव में स्थिर और प्रतिक्रियाशील बनाए रखने के लिए golang.org/x/time/rate के साथ दर सीमित करना। किसी भी स्केलेबल एपीआई के लिए दर सीमित करना एक महत्वपूर्ण उपकरण है, और हम यहां केवल सतह को खंगाल रहे हैं।

एक बार थ्रॉटलएक्स उत्पादन के लिए तैयार हो जाए, मैं आपको यह दिखाने के लिए एक अनुवर्ती ट्यूटोरियल पोस्ट करूंगा कि इसे और भी अधिक लचीलेपन और वितरित दर सीमित करने के लिए इसे अपने गो एपीआई में कैसे एकीकृत किया जाए। अपडेट के लिए मेरे थ्रॉटलएक्स गिटहब रेपो पर नज़र रखें!

अगले सप्ताह, हम अपने एपीआई को डॉकर के साथ कंटेनरीकृत करने जा रहे हैं, इसलिए यह कहीं भी चलने के लिए तैयार है। बने रहें, और कोडिंग का आनंद लें! ??