Utiliser Redis pour implémenter une limitation de courant distribuée

Utiliser Redis pour implémenter une limitation de courant distribuée

Texte :

Avec le développement rapide d'Internet, le nombre de visites simultanées sur des sites Web et des services continue d'augmenter afin de protéger la stabilité du back-. Fin du système, limiter le nombre de visites simultanées est devenu une tâche importante. Dans un système distribué, afin de garantir un statut partagé entre plusieurs instances de service, nous pouvons utiliser Redis comme outil de limitation de courant distribué.

Redis est un système de stockage clé-valeur hautes performances avec des vitesses de lecture et d'écriture rapides et une prise en charge riche de la structure de données, et est largement utilisé dans les systèmes distribués. Ci-dessous, nous présenterons comment utiliser Redis pour implémenter une limitation de courant distribuée et fournirons des exemples de code spécifiques.

Tout d’abord, nous devons déterminer la stratégie de limitation actuelle. Les algorithmes courants de limitation de courant incluent l'algorithme de compartiment à fuite et l'algorithme de compartiment à jetons. Dans cet article, nous utilisons l’algorithme du token bucket comme exemple.

Le principe de l'algorithme du token bucket est de distribuer des tokens à chaque requête, et lorsque le nombre de tokens dans le token bucket est insuffisant, les nouvelles requêtes sont rejetées. Nous pouvons utiliser des compteurs Redis et des ensembles triés pour implémenter l'algorithme du compartiment à jetons.

Ce qui suit est un exemple de code (écrit en langage Python) qui utilise Redis pour implémenter la limitation de débit distribuée :

import redis
import time


class DistributedRateLimiter:
    def __init__(self, host, port, password, limit, interval):
        self.r = redis.Redis(host=host, port=port, password=password)
        self.limit = limit
        self.interval = interval

    def limit_request(self, key):
        current_time = int(time.time() * 1000)
        self.r.zremrangebyscore(key, 0, current_time - self.interval)
        requests_count = self.r.zcard(key)
        if requests_count < self.limit:
            self.r.zadd(key, {current_time: current_time})
            return True
        return False


if __name__ == '__main__':
    limiter = DistributedRateLimiter('localhost', 6379, 'password', 100, 1000)
    for _ in range(10):
        if limiter.limit_request('api:rate_limit'):
            print('Allow request')
        else:
            print('Limit exceeded')

Dans le code ci-dessus, nous avons créé une classe nommée DistributedRateLimiter, qui contient la logique pertinente. de l'algorithme de limitation de courant est expliqué. La méthode de construction accepte les paramètres de connexion Redis, le seuil de limitation de courant et l'intervalle de limitation de courant. DistributedRateLimiter的类，其中包含了限流算法的相关逻辑。构造方法接受Redis的连接参数、限流的阈值和限流的时间间隔。

limit_request方法用于进行限流判断，它首先清理过期的令牌，然后获取当前令牌桶中的请求数量，如果请求数量小于限制，则将当前时间添加到有序集合中，并返回允许请求的标志位。

在示例代码的主函数中，我们创建了一个DistributedRateLimiter

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!