Très bien, les amis, nous avons abordé beaucoup de choses jusqu'à présent : l'authentification JWT, les connexions à la base de données, la journalisation et la gestion des erreurs. Mais que se passe-t-il lorsque votre API commence à être critiquée par des requêtes ? Sans contrôle, un trafic élevé peut entraîner des temps de réponse lents, voire des temps d'arrêt. ?

Cette semaine, nous allons résoudre ce problème en mettant en œuvre une limitation de débit pour contrôler le flux de trafic. Nous utiliserons le package simple et efficace golang.org/x/time/rate. Plus tard, lorsque ma propre solution ThrottleX sera prête, je vous montrerai comment l'intégrer en tant qu'option plus évolutive. (Psst, consultez mon GitHub sur github.com/neelp03/throttlex pour les mises à jour ! N'hésitez pas à commenter tout problème que vous y voyez o7)

Pourquoi limiter les taux ? ?

La limitation de débit est comme un videur pour votre API : elle contrôle le nombre de requêtes que les utilisateurs peuvent effectuer dans un délai donné. Cela évite que votre API ne soit submergée, garantissant un accès fluide et équitable à tous les utilisateurs. La limitation du débit est essentielle pour :

• Prévenir les abus : empêche les mauvais acteurs ou les utilisateurs trop enthousiastes de surcharger votre API.
• Stabilité : maintient votre API réactive et fiable, même en cas de pics de trafic.
• Équité : permet aux ressources d'être partagées de manière égale entre les utilisateurs.

Étape 1 : Installation du package temps/taux

Le package golang.org/x/time/rate fait partie des bibliothèques Go étendues et fournit un limiteur de débit simple basé sur des jetons. Pour commencer, vous devrez l'installer :

go get golang.org/x/time/rate

Étape 2 : configuration du limiteur de débit

Créons un middleware limitant le débit qui contrôle le nombre de requêtes qu'un client peut effectuer. Dans cet exemple, nous limiterons les clients à 5 requêtes par 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
}

Étape 3 : Création du middleware de limitation de débit

Utilisons maintenant la fonction getClientLimiter dans un middleware qui restreindra l'accès en fonction de la limite de débit.

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

Comment ça marche :

1. Limitation basée sur IP : chaque client est identifié par son adresse IP. Nous vérifions l'adresse IP du client et lui attribuons un limiteur de débit.
2. Request Check : la méthode limiteur.Allow() vérifie si le client est dans la limite de débit. Si tel est le cas, la demande est transmise au gestionnaire suivant ; sinon, nous répondons avec 429 trop de demandes.

Étape 4 : Appliquer le middleware à l’échelle mondiale ?

Connectons maintenant notre limiteur de débit à l'API afin que chaque requête doive passer par celle-ci :

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

En appliquant r.Use(rateLimitingMiddleware), nous garantissons que chaque demande entrante est vérifiée par le limiteur de débit avant qu'elle n'atteigne un point de terminaison.

Étape 5 : tester la limitation de débit ?

Démarrez votre serveur :

go run main.go

Maintenant, passons à l'API avec quelques requêtes. Vous pouvez utiliser une boucle avec curl pour simuler plusieurs requêtes d'affilée :

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

Puisque nous avons fixé la limite à 5 requêtes par minute, vous devriez voir 429 trop de demandes réponses une fois que vous dépassez le taux autorisé.

Quelle est la prochaine étape ?

Et voilà : limitation du débit avec golang.org/x/time/rate pour maintenir votre API stable et réactive sous pression. La limitation de débit est un outil crucial pour toute API évolutive, et nous ne faisons qu'effleurer la surface ici.

Une fois que ThrottleX sera prêt pour la production, je publierai un didacticiel de suivi pour vous montrer comment l'intégrer dans votre API Go pour encore plus de flexibilité et une limitation du débit distribué. Gardez un œil sur mon dépôt ThrottleX GitHub pour les mises à jour !

La semaine prochaine, nous allons conteneuriser notre API avec Docker, afin qu'elle soit prête à fonctionner n'importe où. Restez à l'écoute et bon codage ! ??