Comment implémenter la limitation de courant de l'API à l'aide du langage Go et Redis

Comment implémenter la limitation de courant API à l'aide du langage Go et Redis

Vue d'ensemble :
Avec le développement rapide d'Internet, l'utilisation des interfaces API augmente également et certaines interfaces API peuvent provoquer une panne du système en raison d'un trop grand nombre de requêtes . La charge est trop élevée voire paralysie. Afin d'assurer la stabilité et la fiabilité du système, nous devons limiter le flux actuel de l'interface API. Cet article explique comment utiliser le langage Go et Redis pour implémenter la fonction de limitation de courant de l'API et fournit des exemples de code spécifiques.

1. Principe de limitation du courant API
   La limitation du courant API fait référence à la restriction de l'accès aux interfaces API pour protéger le système contre la submersion de requêtes malveillantes ou d'un grand nombre de requêtes. Les algorithmes de limitation de courant API courants incluent l'algorithme de compteur, l'algorithme de compartiment à fuite et l'algorithme de compartiment à jetons. L’algorithme du token bucket est utilisé dans cet article. Son principe est de contrôler le flux des requêtes au travers des token buckets.
2. Préparation de l'environnement
   Avant de commencer, nous devons nous assurer que le langage Go et Redis sont installés et que les bibliothèques correspondantes sont importées.
3. Code d'implémentation
   Ce qui suit est un exemple de code qui utilise le langage Go et Redis pour implémenter la limitation de courant de l'API :

package main

import (
    "fmt"
    "github.com/go-redis/redis"
    "time"
)

const (
    MaxReqPerSec = 100 // 每秒最大请求数
)

func main() {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // 如果有密码，填入密码
        DB:       0,  // 默认数据库
    })

    // 初始化令牌桶
    client.Set("bucket", MaxReqPerSec, 0)

    // 模拟请求
    for i := 0; i < 1000; i++ {
        if allowed, err := checkAPIRequest(client); allowed {
            // 执行API请求
            fmt.Println("API request allowed")
            // ....
        } else {
            fmt.Println("API request denied")
            // ....
        }
        time.Sleep(time.Millisecond * 100)
    }
}

func checkAPIRequest(client *redis.Client) (bool, error) {
    val, err := client.Decr("bucket").Result()
    if err != nil {
        return false, err
    }

    if val < 0 {
        client.Incr("bucket")
        return false, nil
    }

    return true, nil
}

Description du code :

• Dans la fonction main, nous établissons d'abord une connexion avec Redis, initialisé un compartiment de jetons et défini le nombre maximum de requêtes par seconde sur 100. La fonction main函数中，我们首先建立与Redis的连接，并初始化了一个令牌桶，设置每秒最大请求数量为100。
• checkAPIRequest函数用于检查是否允许进行API请求。在每次请求时，我们通过client.Decr("bucket")操作从令牌桶中取出一个令牌，如果令牌数量小于0，则表示不能进行请求，需要向令牌桶中添加令牌，并返回false。如果令牌数量大于等于0，则表示允许进行请求，并返回true。

4. 运行代码
   保存以上代码为main.go文件，使用命令行进入文件所在目录，执行go run main.go
checkAPIRequest est utilisée pour vérifier si les requêtes API sont autorisées. A chaque requête, nous retirons un token du bucket à jetons via l'opération client.Decr("bucket") Si le nombre de tokens est inférieur à 0, cela signifie que la requête ne peut pas être effectuée. et vous devez demander le jeton, ajoutez le jeton au compartiment et renvoyez false. Si le nombre de jetons est supérieur ou égal à 0, la requête est autorisée et true est renvoyée.

Exécutez le code
Enregistrez le code ci-dessus sous le fichier main.go, utilisez la ligne de commande pour entrer dans le répertoire où se trouve le fichier, et exécutez go run main.go pour exécuter le code. Le programme simulera 100 requêtes, avec un intervalle de 100 millisecondes entre chaque requête. Selon le nombre maximum de demandes défini, les 100 premières demandes doivent être autorisées et les demandes suivantes doivent être rejetées.

🎜🎜Résumé : 🎜Cet article explique comment utiliser le langage Go et Redis pour implémenter la fonction de limitation de courant de l'API et contrôler le flux de requêtes via l'algorithme du compartiment à jetons. En utilisant cette méthode, vous pouvez protéger efficacement le système contre une surcharge par un grand nombre de requêtes et améliorer la stabilité et la disponibilité du système. 🎜

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!