Rate Limiting en Go (Golang) : bibliothèques, modèles et exemples de mise en œuvre

Rate Limiting en Go (Golang) : bibliothèques, modèles et exemples de mise en œuvre

Le rate limiting (limitation du débit des requêtes) est l'un des mécanismes clés de protection et de contrôle de charge dans les services web modernes et l'architecture de microservices. Dans l'écosystème Go (Golang), il existe plusieurs outils matures pour implémenter le rate limiting, allant du package intégré time aux bibliothèques spécialisées comme golang.org/x/time/rate. Dans cet article, nous allons détailler le fonctionnement du rate limiting en Go, quelles bibliothèques utiliser et fournir des exemples de code pratiques.

Qu'est-ce que le Rate Limiting et pourquoi est-il nécessaire ?

Le rate limiting est une technique de contrôle du nombre de requêtes qu'un client peut effectuer vers un serveur dans un intervalle de temps donné. Les principaux objectifs :

• Protection contre les attaques DDoS — empêcher la surcharge du serveur.
• Répartition équitable des ressources — limiter les clients "gourmands".
• Respect des SLA — garantir la disponibilité pour tous les utilisateurs.
• Économies de coûts — réduire la charge sur les bases de données et les API externes.

En Go, le rate limiting est implémenté à l'aide des algorithmes Token Bucket (seau de jetons) et Leaky Bucket (seau percé). Le plus populaire est Token Bucket.

Bibliothèque golang.org/x/time/rate

La bibliothèque principale et recommandée pour le rate limiting en Go est golang.org/x/time/rate. Elle implémente l'algorithme Token Bucket et fait partie de l'ensemble étendu de paquets Go (sous-dépôts).

Installation :

go get golang.org/x/time/rate

Composants principaux

• rate.Limiter — l'objet limiteur principal.
• rate.NewLimiter(r rate.Limit, b int) — crée un limiteur avec une fréquence r de requêtes par seconde et une taille de seau b.
• Allow() — vérifie si une requête peut être exécutée maintenant (non bloquant).
• Wait(ctx) — bloque l'exécution jusqu'à ce qu'un jeton soit disponible (prend en compte le contexte).
• Reserve() — retourne une Reservation, permettant de différer l'exécution.

Exemple 1 : Rate limiter de base

package main

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

func main() {    // 2 requêtes par seconde, seau de 5 jetons    limiter := rate.NewLimiter(2, 5)

    for i := 0; i < 10; i++ {        if limiter.Allow() {            fmt.Printf("Requête %d exécutée", i)        } else {            fmt.Printf("Requête %d rejetée (limite)", i)        }        time.Sleep(200 * time.Millisecond)    }}

Exemple 2 : Rate limiter avec attente (Wait)

package main

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

func main() {    limiter := rate.NewLimiter(1, 3) // 1 requête par seconde, seau de 3    ctx := context.Background()

    for i := 0; i < 6; i++ {        err := limiter.Wait(ctx)        if err != nil {            fmt.Println("Erreur d'attente :", err)            return        }        fmt.Printf("Requête %d exécutée à %s", i, time.Now().Format("15:04:05.000"))    }}

Implémentation d'un middleware HTTP avec rate limiting

En pratique, le rate limiting est le plus souvent appliqué au niveau du serveur HTTP. Examinons un exemple de middleware pour Gin ou le net/http standard.

package main

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

// RateLimiterMiddleware retourne un middleware avec rate limitfunc 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