Golang implémente la limitation du courant IP

Avec le développement rapide d'Internet et de l'Internet mobile, les serveurs sont confrontés à une pression croissante. Comment limiter les requêtes des clients au serveur et éviter les pannes du serveur est devenu un gros problème. Dans les projets réels, nous devons souvent limiter le nombre de requêtes IP pour garantir la disponibilité du site Web.

Ici, nous présenterons comment utiliser Golang pour implémenter la limitation de courant IP. En général, nous utiliserons l'algorithme du token bucket pour implémenter une limitation de courant basée sur l'adresse IP. L'algorithme de compartiment à jetons est un algorithme de contrôle de flux qui permet à un certain nombre de requêtes de passer dans un certain laps de temps et limite le flux de requêtes dans un certain laps de temps.

Détails de mise en œuvre

L'algorithme du compartiment à jetons place les jetons dans le compartiment à un rythme constant. Le compartiment à jetons a une limite de capacité, ce qui signifie que le nombre de jetons dans le compartiment ne dépassera pas la capacité. Pour chaque demande, un jeton est supprimé du compartiment. S'il n'y a aucun jeton dans le compartiment, la demande ne peut pas être traitée.

Afin de mettre en œuvre une limitation de courant basée sur l'adresse IP, nous devons créer un compartiment de jetons pour chaque adresse IP. Chaque compartiment de jetons a une capacité maximale et une vitesse constante. Lorsqu'une demande arrive, nous supprimons un jeton du compartiment de jetons et rejetons la demande s'il n'y a pas de jeton dans le compartiment.

Sur cette base, nous pouvons définir un limiteur de courant IP :

type IPRateLimiter struct {
    limiterBuckets map[string]*rate.Limiter
    mu             *sync.Mutex
    r              rate.Limit
    b              int
}

où limiteurBuckets est un mappage qui mappe les adresses IP de chaîne aux compartiments de jetons. mu est un mutex, r est la fréquence à laquelle le limiteur de débit place les jetons par seconde et b est la capacité du compartiment de jetons.

Pour créer un bucket de jetons pour chaque adresse IP, nous définissons une fonction NewIPRateLimiter :

func NewIPRateLimiter(r rate.Limit, b int) *IPRateLimiter {
    return &IPRateLimiter{
        limiterBuckets: make(map[string]*rate.Limiter),
        mu:             &sync.Mutex{},
        r:              r,
        b:              b,
    }
}

func (i *IPRateLimiter) AddIP(ip string) *rate.Limiter {
    i.mu.Lock()
    defer i.mu.Unlock()

    limiter := rate.NewLimiter(i.r, i.b)
    i.limiterBuckets[ip] = limiter

    return limiter
}

La fonction AddIP est utilisée pour créer un bucket de jetons pour une adresse IP. Si un compartiment de jetons a été créé pour cette adresse IP, le compartiment de jetons existant est renvoyé, sinon un nouveau compartiment de jetons est créé et renvoyé.

Enfin, nous pouvons implémenter un middleware HTTP pour limiter le nombre de requêtes vers une adresse IP :

func (i *IPRateLimiter) Limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter, ok := i.limiterBuckets[ip]
        if !ok {
            limiter = i.AddIP(ip)
        }

        if !limiter.Allow() {
            http.Error(w, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

Ce middleware permet aux requêtes de passer à un débit et une capacité spécifiés. Si le nombre de requêtes dépasse la capacité, le code d'erreur HTTP 429 (trop de requêtes) est renvoyé.

Le code complet est le suivant :

package main

import (
    "net/http"
    "strconv"
    "sync"

    "golang.org/x/time/rate"
)

type IPRateLimiter struct {
    limiterBuckets map[string]*rate.Limiter
    mu             *sync.Mutex
    r              rate.Limit
    b              int
}

func NewIPRateLimiter(r rate.Limit, b int) *IPRateLimiter {
    return &IPRateLimiter{
        limiterBuckets: make(map[string]*rate.Limiter),
        mu:             &sync.Mutex{},
        r:              r,
        b:              b,
    }
}

func (i *IPRateLimiter) AddIP(ip string) *rate.Limiter {
    i.mu.Lock()
    defer i.mu.Unlock()

    limiter := rate.NewLimiter(i.r, i.b)
    i.limiterBuckets[ip] = limiter

    return limiter
}

func (i *IPRateLimiter) Limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter, ok := i.limiterBuckets[ip]
        if !ok {
            limiter = i.AddIP(ip)
        }

        if !limiter.Allow() {
            http.Error(w, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

func IndexHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("welcome."))
}

func main() {
    limit := rate.Limit(10) // 速率，每秒放入令牌的数量
    capacity := 100        // 容量，桶的大小

    ipRateLimiter := NewIPRateLimiter(limit, capacity)

    http.Handle("/", ipRateLimiter.Limit(http.HandlerFunc(IndexHandler)))

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        panic(err)
    }
}

Dans cet exemple, nous autorisons 10 jetons par seconde et limitons la capacité du bucket à 100. Cela signifie que le limiteur peut gérer jusqu'à 10 requêtes par seconde, mais échouera si les requêtes adressées à la même adresse IP atteignent 100. En même temps, nous définissons un gestionnaire simple qui répondra à "Bienvenue".

Conclusion

Dans cet article, nous avons utilisé Golang pour implémenter la limitation du courant IP, en utilisant l'algorithme du bucket de jetons pour limiter le taux de requêtes de chaque adresse IP. Cette méthode peut implémenter un mécanisme de limitation de courant simple et efficace et peut être facilement implémentée dans Golang. Cela peut s'avérer une technique très utile lorsque vous écrivez des applications réseau hautement concurrentes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!