Okay, Leute, wir haben bisher viel abgedeckt: JWT-Authentifizierung, Datenbankverbindungen, Protokollierung und Fehlerbehandlung. Aber was passiert, wenn Ihre API mit Anfragen überlastet wird? Ohne Kontrolle kann hoher Datenverkehr zu langsamen Reaktionszeiten oder sogar Ausfallzeiten führen. ?

Diese Woche werden wir dieses Problem lösen, indem wir Ratenbegrenzungen implementieren, um den Verkehrsfluss zu kontrollieren. Wir verwenden das einfache und effektive Paket golang.org/x/time/rate. Später, wenn meine eigene ThrottleX-Lösung fertig ist, zeige ich Ihnen, wie Sie diese als skalierbarere Option integrieren können. (Psst, schauen Sie sich meinen GitHub unter github.com/neelp03/throttlex an, um Updates zu erhalten! Fühlen Sie sich frei, alle Probleme zu kommentieren, die Sie dort sehen o7)

Warum Ratenbegrenzung? ?

Ratenbegrenzung ist wie ein Türsteher für Ihre API – sie steuert die Anzahl der Anfragen, die Benutzer innerhalb eines bestimmten Zeitraums stellen können. Dies verhindert, dass Ihre API überlastet wird, und gewährleistet einen reibungslosen und fairen Zugriff für alle Benutzer. Ratenbegrenzung ist wichtig für:

• Missbrauch verhindern: Verhindert, dass böswillige Akteure oder übermäßig enthusiastische Benutzer Ihre API überfordern.
• Stabilität: Sorgt dafür, dass Ihre API auch bei Verkehrsspitzen reaktionsfähig und zuverlässig bleibt.
• Fairness: Ermöglicht die gleichmäßige Aufteilung von Ressourcen zwischen Benutzern.

Schritt 1: Installation des Time/Rate-Pakets

Das Paket golang.org/x/time/rate ist Teil der erweiterten Go-Bibliotheken und bietet einen unkomplizierten tokenbasierten Ratenbegrenzer. Um zu beginnen, müssen Sie es installieren:

go get golang.org/x/time/rate

Schritt 2: Einrichten des Ratenbegrenzers

Lassen Sie uns eine ratenbegrenzende Middleware erstellen, die die Anzahl der Anfragen steuert, die ein Client stellen kann. In diesem Beispiel beschränken wir die Clients auf 5 Anfragen pro Minute.

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
}

Schritt 3: Erstellen der ratenbegrenzenden Middleware

Nun verwenden wir die Funktion getClientLimiter in einer Middleware, die den Zugriff basierend auf der Ratenbegrenzung einschränkt.

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)
    })
}

So funktioniert es:

1. IP-basierte Begrenzung: Jeder Client wird durch seine IP-Adresse identifiziert. Wir überprüfen die IP des Kunden und weisen ihm einen Ratenbegrenzer zu.
2. Request Check: Die limiter.Allow()-Methode prüft, ob der Client innerhalb des Ratenlimits liegt. Wenn dies der Fall ist, wird die Anforderung an den nächsten Handler weitergeleitet. Wenn nicht, antworten wir mit 429 Too Many Requests.

Schritt 4: Die Middleware global anwenden?

Jetzt verbinden wir unseren Ratenbegrenzer mit der API, sodass jede Anfrage diese passieren muss:

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))
}

Durch die Anwendung von r.Use(rateLimitingMiddleware) stellen wir sicher, dass jede eingehende Anfrage vom Ratenbegrenzer überprüft wird, bevor sie einen Endpunkt erreicht.

Schritt 5: Testen Sie die Geschwindigkeitsbegrenzung?

Starten Sie Ihren Server:

go run main.go

Jetzt gehen wir mit einigen Anfragen zur API. Sie können eine Schleife mit Curl verwenden, um mehrere Anfragen hintereinander zu simulieren:

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

Da wir das Limit auf 5 Anfragen pro Minute festgelegt haben, sollten Sie 429 zu viele Anfragen Antworten sehen, sobald Sie die zulässige Rate überschreiten.

Was kommt als nächstes?

Und da haben Sie es: Ratenbegrenzung mit golang.org/x/time/rate, um Ihre API unter Druck stabil und reaktionsfähig zu halten. Ratenbegrenzung ist ein entscheidendes Werkzeug für jede skalierbare API, und wir kratzen hier nur an der Oberfläche.

Sobald ThrottleX produktionsbereit ist, werde ich ein Folge-Tutorial veröffentlichen, um Ihnen zu zeigen, wie Sie es für noch mehr Flexibilität und verteilte Ratenbegrenzung in Ihre Go-API integrieren können. Behalten Sie mein ThrottleX GitHub-Repo im Auge, um Updates zu erhalten!

Nächste Woche werden wir unsere API mit Docker containerisieren, damit sie überall ausgeführt werden kann. Bleiben Sie dran und viel Spaß beim Codieren! ??