Comment utiliser le langage Go et Redis pour le contrôle de flux

Comment utiliser le langage Go et Redis pour le contrôle de flux

Introduction
Dans une application réseau à haute concurrence, le contrôle de flux est un lien très important. Afin d'assurer la stabilité et la fiabilité du système, nous devons limiter et gérer le trafic. Cet article explique comment utiliser le langage Go et Redis pour implémenter le contrôle de flux et fournit des exemples de code spécifiques.

Contexte
Dans les systèmes distribués, le contrôle de flux est l'un des moyens importants pour assurer le fonctionnement normal du système. Lorsque le système est confronté à un nombre élevé de requêtes simultanées, un trafic excessif peut provoquer un blocage du système ou ralentir la réponse. Nous devons donc limiter le trafic pour éviter que le système ne soit surchargé. Redis est une base de données en mémoire hautes performances qui fournit des structures de données et des commandes riches pour faciliter le contrôle des flux.

Conception du projet
La conception de notre solution est la suivante :

1. Utilisez la structure de données du compteur de Redis pour enregistrer le nombre de requêtes pour chaque utilisateur.
2. Utilisez un ensemble trié pour stocker l'horodatage de la demande de l'utilisateur pour les calculs de fenêtre horaire ultérieurs.
3. Utilisez la fonction de transaction de Redis pour garantir l'atomicité et la cohérence des opérations.
4. Utilisez Goroutine pour le traitement simultané.

Mise en œuvre spécifique
Nous supposons qu'un utilisateur ne peut envoyer que 100 requêtes en 60 secondes. Nous pouvons utiliser la structure de données de compteur de Redis pour atteindre cette restriction. Voici un exemple de code :

package main

import (
    "fmt"
    "strconv"
    "sync"
    "time"

    "github.com/go-redis/redis"
)

var (
    wg sync.WaitGroup
    rdb *redis.Client
)

func main() {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis地址
        Password: "",               // Redis密码
        DB:       0,                // Redis数据库
    })

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go sendRequest(i)
    }

    wg.Wait()
}

func sendRequest(userID int) {
    defer wg.Done()

    // 检查用户请求数是否超过限制
    count, err := rdb.Incr(strconv.Itoa(userID)).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    if count > 100 {
        fmt.Println("Request limit exceeded for user", userID)
        return
    }

    // 获取当前时间戳
    now := time.Now().Unix()

    // 将当前时间戳添加到有序集合中
    _, err = rdb.ZAdd("timestamps", redis.Z{
        Score:  float64(now),
        Member: strconv.Itoa(userID),
    }).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    // 移除60秒前的时间戳
    _, err = rdb.ZRemRangeByScore("timestamps", "0", strconv.FormatInt(now-60, 10)).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    fmt.Println("Request sent by user", userID)
}

Explication et appel

• Tout d'abord, connectez-vous à la base de données Redis en créant un client Redis.
• Ensuite, utilisez une boucle pour créer 100 coroutines pour envoyer des requêtes. Chaque coroutine représente un utilisateur.
• Dans la fonction sendRequest qui envoie une requête, utilisez d'abord la commande INCR pour incrémenter le nombre de requêtes utilisateur et vérifier si la limite est dépassée. sendRequest中，首先使用INCR命令递增用户的请求数，并检查是否超过了限制。
• 然后，获取当前时间戳，并将其添加到有序集合中。
• 最后，使用ZRemRangeByScore
Ensuite, obtenez l'horodatage actuel et ajoutez-le à l'ensemble trié.

Enfin, utilisez la commande ZRemRangeByScore pour supprimer les horodatages expirés.

Conclusion

• Matériaux de référence :
• Documentation officielle Redis : https://redis.io/

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!