Rate Limiting in Go (Golang): Bibliotheken, Muster und Implementierungsbeispiele

Rate Limiting in Go (Golang): Bibliotheken, Muster und Implementierungsbeispiele

Rate Limiting (Anfragenratenbegrenzung) ist einer der wichtigsten Mechanismen zum Schutz und zur Laststeuerung in modernen Webdiensten und Microservice-Architekturen. Im Go (Golang)-Ökosystem gibt es mehrere ausgereifte Werkzeuge zur Implementierung von Rate Limiting, vom integrierten Paket time bis hin zu spezialisierten Bibliotheken wie golang.org/x/time/rate. In diesem Artikel werden wir im Detail besprechen, wie Rate Limiting in Go funktioniert, welche Bibliotheken verwendet werden sollten und praktische Codebeispiele geben.

Was ist Rate Limiting und warum wird es benötigt?

Rate Limiting ist eine Technik zur Kontrolle der Anzahl von Anfragen, die ein Client innerhalb eines bestimmten Zeitraums an einen Server senden kann. Hauptziele:

• Schutz vor DDoS-Angriffen — Verhinderung von Serverüberlastung.
• Faire Ressourcenverteilung — Begrenzung "ressourcenhungriger" Clients.
• Einhaltung von SLAs — Gewährleistung der Verfügbarkeit für alle Benutzer.
• Kosteneinsparungen — Reduzierung der Last auf Datenbanken und externe APIs.

In Go wird Rate Limiting mit den Algorithmen Token Bucket (Token-Eimer) und Leaky Bucket (Undichter Eimer) implementiert. Am beliebtesten ist der Token Bucket.

Die Bibliothek golang.org/x/time/rate

Die wichtigste und empfohlene Bibliothek für Rate Limiting in Go ist golang.org/x/time/rate. Sie implementiert den Token-Bucket-Algorithmus und gehört zum erweiterten Satz von Go-Paketen (Sub-Repositories).

Installation:

go get golang.org/x/time/rate

Hauptkomponenten

• rate.Limiter — das Hauptobjekt des Begrenzers.
• rate.NewLimiter(r rate.Limit, b int) — erstellt einen Begrenzer mit der Rate r Anfragen pro Sekunde und einer Bucket-Größe von b.
• Allow() — prüft, ob eine Anfrage jetzt ausgeführt werden kann (nicht blockierend).
• Wait(ctx) — blockiert die Ausführung, bis ein Token verfügbar ist (berücksichtigt den Kontext).
• Reserve() — gibt eine Reservation zurück, die eine verzögerte Ausführung ermöglicht.

Beispiel 1: Einfacher Rate Limiter

package main

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

func main() {    // 2 Anfragen pro Sekunde, Bucket mit 5 Token    limiter := rate.NewLimiter(2, 5)

    for i := 0; i < 10; i++ {        if limiter.Allow() {            fmt.Printf("Anfrage %d ausgeführt", i)        } else {            fmt.Printf("Anfrage %d abgelehnt (Limit)", i)        }        time.Sleep(200 * time.Millisecond)    }}

Beispiel 2: Rate Limiter mit Warten (Wait)

package main

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

func main() {    limiter := rate.NewLimiter(1, 3) // 1 Anfrage pro Sekunde, Bucket mit 3    ctx := context.Background()

    for i := 0; i < 6; i++ {        err := limiter.Wait(ctx)        if err != nil {            fmt.Println("Fehler beim Warten:", err)            return        }        fmt.Printf("Anfrage %d ausgeführt um %s", i, time.Now().Format("15:04:05.000"))    }}

Implementierung von HTTP Middleware mit Rate Limiting

In der Praxis wird Rate Limiting am häufigsten auf der Ebene des HTTP-Servers eingesetzt. Betrachten wir ein Beispiel für Middleware für Gin oder das Standard-net/http.

package main

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

// RateLimiterMiddleware gibt eine Middleware mit Rate Limit zurückfunc RateLimiterMiddleware(r rate.Limit, b int) func(http.Handler) http.Handler {    limiter := rate.NewLimiter(r, b)    return func(next http.Handler) http.Handler {        return http.HandlerFunc(f