Optimiser les applications linguistiques Go : définir les limites de requêtes de manière appropriée

Optimiser les applications en langage Go : définir des limites de requêtes raisonnables

Lors du développement d'applications Web, vous rencontrez généralement le besoin de limiter les requêtes externes, comme limiter la fréquence des requêtes de chaque utilisateur, empêcher les attaques malveillantes ou atténuer la pression du serveur. Dans le langage Go, nous pouvons optimiser les performances et la sécurité de l'application en fixant des limites de requêtes raisonnables. Cet article expliquera comment implémenter des restrictions de requêtes dans le langage Go et donnera des exemples de code spécifiques.

1. Implémenter la limitation des requêtes via l'algorithme du compartiment à jetons

L'algorithme du compartiment à jetons est un algorithme de limitation de courant classique qui peut contrôler efficacement le taux de requêtes. Cet algorithme maintient un compartiment de jetons à capacité fixe, et chaque requête consomme un jeton. Lorsqu'il n'y a pas suffisamment de jetons dans le compartiment de jetons, la requête sera limitée. Voici un exemple simple de limite de requêtes basé sur l'algorithme du bucket de jetons :

package main

import (
    "time"
)

type Limiter struct {
    tokens       chan struct{}
    tokenPerSec  int
}

func NewLimiter(tokenPerSec int) *Limiter {
    l := &Limiter{
        tokens:      make(chan struct{}, tokenPerSec),
        tokenPerSec: tokenPerSec,
    }
    go func() {
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()
        for range ticker.C {
            select {
            case l.tokens <- struct{}{}:
            default:
            }
        }
    }()
    return l
}

func (l *Limiter) Allow() bool {
    select {
    case <-l.tokens:
        return true
    default:
        return false
    }
}

func main() {
    limiter := NewLimiter(10) // 每秒限制10个请求
    for i := 0; i < 20; i++ {
        if limiter.Allow() {
            fmt.Println("Allow request")
        } else {
            fmt.Println("Limit request")
        }
        time.Sleep(100 * time.Millisecond)
    }
}

Dans l'exemple ci-dessus, un bucket de jetons qui limite 10 requêtes par seconde est créé via la fonction NewLimiter, et la méthode Allow détermine s'il faut autoriser la requête. De cette façon, nous pouvons limiter les demandes et assurer la stabilité du système.

2. Utilisez sync.Map pour implémenter la limitation de la fréquence des requêtes IP

En plus de la limitation des requêtes basée sur l'algorithme du compartiment à jetons, nous pouvons également utiliser sync.Map pour implémenter la limitation de la fréquence des requêtes IP. Voici un exemple simple :

package main

import (
    "fmt"
    "sync"
    "time"
)

type IPRequest struct {
    Count    int
    LastTime time.Time
}

var requests sync.Map

func LimitIP(ip string, limit int) bool {
    now := time.Now()
    value, ok := requests.Load(ip)
    if !ok {
        requests.Store(ip, &IPRequest{Count: 1, LastTime: now})
        return true
    }

    req := value.(*IPRequest)
    if req.Count >= limit && now.Sub(req.LastTime) < time.Second {
        return false
    }

    req.Count++
    req.LastTime = now
    return true
}

func main() {
    for i := 0; i < 20; i++ {
        ip := "127.0.0.1"
        if LimitIP(ip, 5) {
            fmt.Println("Allow request from ", ip)
        } else {
            fmt.Println("Limit request from ", ip)
        }
        time.Sleep(100 * time.Millisecond)
    }
}

Dans le code ci-dessus, sync.Map est utilisé pour stocker le nombre de requêtes et l'heure de la dernière requête de chaque IP, et la fonction LimitIP est utilisée pour limiter la fréquence de requête de chaque IP. Cette méthode peut implémenter des limites de fréquence de requête pour chaque IP de l'application et protéger le serveur contre les attaques malveillantes.

En fixant des limites de requêtes raisonnables, nous pouvons optimiser les performances et la sécurité des applications en langage Go, prévenir les attaques malveillantes et réduire la charge du serveur. J'espère que les exemples de code fournis dans cet article pourront vous aider à mieux implémenter la fonctionnalité de limitation des requêtes.

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!