So implementieren Sie die API-Strombegrenzung mithilfe der Go-Sprache und Redis

So implementieren Sie die API-Strombegrenzung mithilfe der Go-Sprache und Redis

Übersicht:
Mit der rasanten Entwicklung des Internets nimmt auch die Nutzung von API-Schnittstellen zu, und einige API-Schnittstellen können aufgrund zu vieler Anfragen zu Systemausfällen führen . Die Belastung ist zu hoch oder es kommt sogar zu Lähmungen. Um die Stabilität und Zuverlässigkeit des Systems sicherzustellen, müssen wir den aktuellen Fluss der API-Schnittstelle begrenzen. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache und Redis die Strombegrenzungsfunktion der API implementieren, und es werden spezifische Codebeispiele bereitgestellt.

1. Prinzip der API-Strombegrenzung
   API-Strombegrenzung bezieht sich auf die Einschränkung des Zugriffs auf API-Schnittstellen, um das System vor einer Überlastung durch böswillige Anfragen oder eine große Anzahl von Anfragen zu schützen. Zu den gängigen API-Strombegrenzungsalgorithmen gehören der Zähleralgorithmus, der Leaky-Bucket-Algorithmus und der Token-Bucket-Algorithmus. In diesem Artikel wird der Token-Bucket-Algorithmus verwendet. Sein Prinzip besteht darin, den Anforderungsfluss durch Token-Buckets zu steuern.
2. Umgebungsvorbereitung
   Bevor wir beginnen, müssen wir sicherstellen, dass die Go-Sprache und Redis installiert und die entsprechenden Bibliotheken importiert sind.
3. Implementierungscode
   Das Folgende ist ein Beispielcode, der die Go-Sprache und Redis verwendet, um die API-Strombegrenzung zu implementieren:

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
}

Codebeschreibung:

• In der Funktion main stellen wir zunächst eine Verbindung her mit Redis, einen Token-Bucket initialisiert und die maximale Anzahl von Anfragen pro Sekunde auf 100 festgelegt. main函数中，我们首先建立与Redis的连接，并初始化了一个令牌桶，设置每秒最大请求数量为100。
• checkAPIRequest函数用于检查是否允许进行API请求。在每次请求时，我们通过client.Decr("bucket")操作从令牌桶中取出一个令牌，如果令牌数量小于0，则表示不能进行请求，需要向令牌桶中添加令牌，并返回false。如果令牌数量大于等于0，则表示允许进行请求，并返回true。

4. 运行代码
   保存以上代码为main.go文件，使用命令行进入文件所在目录，执行go run main.go
checkAPIRequest-Funktion wird verwendet, um zu prüfen, ob API-Anfragen zulässig sind. Bei jeder Anfrage entnehmen wir über die Operation client.Decr("bucket") ein Token aus dem Token-Bucket. Wenn die Anzahl der Token kleiner als 0 ist, bedeutet dies, dass die Anfrage nicht gestellt werden kann und Sie müssen das Token anfordern. Fügen Sie das Token zum Bucket hinzu und geben Sie false zurück. Wenn die Anzahl der Token größer oder gleich 0 ist, wird die Anfrage zugelassen und „true“ zurückgegeben.

Führen Sie den Code aus
Speichern Sie den obigen Code als main.go-Datei, geben Sie über die Befehlszeile das Verzeichnis ein, in dem sich die Datei befindet, und Führen Sie go run main.go aus, um den Code auszuführen. Das Programm simuliert 100 Anfragen mit einem Abstand von 100 Millisekunden zwischen den einzelnen Anfragen. Entsprechend der festgelegten maximalen Anzahl von Anfragen sollten die ersten 100 Anfragen zugelassen und nachfolgende Anfragen abgelehnt werden.

🎜🎜Zusammenfassung: 🎜In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache und Redis die API-Strombegrenzungsfunktion implementieren und den Anforderungsfluss über den Token-Bucket-Algorithmus steuern. Mit dieser Methode können Sie das System effektiv vor einer Überlastung durch eine große Anzahl von Anfragen schützen und die Stabilität und Verfügbarkeit des Systems verbessern. 🎜

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die API-Strombegrenzung mithilfe der Go-Sprache und Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!