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

La méthode limit_request est utilisée pour déterminer la limite actuelle. Elle nettoie d'abord les jetons expirés, puis obtient le nombre de requêtes dans le compartiment de jetons actuel si le nombre de requêtes est inférieur à la limite. l'heure actuelle est ajoutée au nombre de requêtes dans l'ensemble de séquences et renvoie l'indicateur qui autorise la requête.

Dans la fonction principale de l'exemple de code, nous créons un objet DistributedRateLimiter et une boucle pour déterminer la limite actuelle de la requête. Lorsque la limite actuelle dépasse, « Autoriser la demande » est affiché, sinon « Limite dépassée » est affiché.

Grâce à l'exemple ci-dessus, nous pouvons utiliser Redis pour implémenter une limitation de courant distribuée afin de garantir la stabilité du système lors d'un accès simultané. Bien entendu, des stratégies et paramètres spécifiques de limitation de courant doivent être ajustés et optimisés en fonction des conditions réelles.

Il convient de noter que l'exemple ci-dessus n'est qu'une simple démonstration. La limitation réelle du courant distribué peut devoir prendre en compte davantage de facteurs, tels que la synchronisation de l'horloge entre plusieurs instances, les performances et la disponibilité de Redis, etc. 🎜🎜Pour résumer, Redis, en tant que système de stockage clé-valeur hautes performances, peut nous aider à atteindre une limitation de courant distribué. Nous pouvons utiliser les structures de données et les commandes de Redis pour stocker et calculer l'état des demandes afin de limiter les accès simultanés. Grâce à des stratégies raisonnables de limitation de courant et à des configurations de paramètres, nous pouvons protéger le système back-end contre les surcharges et améliorer la disponibilité et la stabilité 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!