Le principe et la méthode de mise en œuvre de Redis implémentant la limitation de courant distribué

Avec le développement d'Internet, de nombreuses applications doivent limiter le flux de requêtes diverses. En effet, en cas de concurrence élevée, l'application sera sous la pression d'un grand nombre de requêtes, ce qui entraînera un blocage ou une réponse lente du service. Afin de résoudre ce problème, les développeurs utilisent généralement une technologie de limitation de courant distribuée pour contrôler le flux de demandes et garantir la haute disponibilité et la stabilité du service. En tant que système de stockage de données en mémoire haute performance, Redis est l'une des solutions de limitation de courant distribuées couramment utilisées. Cet article présentera le principe et la méthode de mise en œuvre de la limitation de courant distribué dans Redis.

1. Qu'est-ce que la limitation de courant distribuée

La limitation de courant distribué fait référence au processus de contrôle du trafic de requêtes grâce à la collaboration entre plusieurs serveurs. Un limiteur de débit compte le nombre de demandes, compare le taux de demandes entrantes au taux autorisé et accepte ou refuse les demandes en fonction du ratio. Dans la limitation distribuée, chaque nœud partage le taux de requêtes et le compteur de requêtes, ce qui permet de garantir que le débit est égal pour tous les nœuds et d'éviter de surcharger un nœud.

2. Le principe de Redis implémentant la limitation de courant distribuée

Redis utilise sa structure de données intégrée, en particulier zset (ensemble trié) pour implémenter la limitation de courant distribuée. Un zset est un ensemble trié où chaque élément est unique et possède un score. La partition est utilisée pour trier des éléments, généralement des nombres ou des heures. Dans la limitation de courant distribué, nous pouvons définir un zset pour chaque utilisateur (ou adresse IP), puis utiliser ce zset pour stocker le compteur de requêtes de l'utilisateur. À mesure que chaque requête arrive, nous la stockons dans un zset et incrémentons le compteur à l'aide de la commande INCRBY de Redis. Nous transmettons ensuite le score de la requête et l'horodatage actuel en tant que paramètres à la commande zrangebyscore pour calculer le taux de requêtes dans une certaine plage de temps. Si le tarif dépasse notre tarif autorisé, la demande est rejetée.

3. Comment Redis implémente la limitation de courant distribuée #Créez un zset global pour stocker le limiteur de débit (un limiteur de débit représente un utilisateur ou une adresse IP) et le compteur de requêtes de chaque limiteur de débit.

Chaque fois qu'une requête arrive, nous la stockons dans le zset de ce limiteur de courant et incrémentons le compteur à l'aide de la commande INCRBY. Par défaut, cette commande incrémente le compteur de 1 à chaque fois, mais vous pouvez augmenter l'incrément en définissant les arguments de la commande sur une valeur plus élevée.

Utilisez la commande zrangebyscore pour rechercher toutes les requêtes avec un compteur de requêtes dans une plage de temps spécifiée et calculer le taux de requêtes.
1. Si le taux de demande dépasse le taux autorisé, la demande sera rejetée et un message d'erreur sera renvoyé.
2. Si le taux de demande ne dépasse pas le taux autorisé, la demande est acceptée et le compteur de demandes dans zset est mis à jour.
4. Ce qui suit est un exemple de code montrant comment utiliser Redis pour implémenter une limitation de courant distribuée. Parmi eux, nous avons utilisé un zset global pour stocker le compteur de requêtes pour chaque adresse IP et utilisé la commande zrangebyscore pour calculer le taux de requêtes par seconde.

import redis
import time

class RateLimiter(object):
    def __init__(self, redis_client, rate, key_prefix='limiter'):
        self.redis = redis_client
        self.rate = rate
        self.key_prefix = key_prefix

    def allow_request(self, ip):
        key = '%s:%s' % (self.key_prefix, ip)
        now = time.time()
        count = self.redis.zcount(key, now - 1, now)
        if count < self.rate:
            self.redis.zadd(key, now, now)
            return True
        return False

if __name__ == '__main__':
    redis_client = redis.Redis()
    limiter = RateLimiter(redis_client, 5)
    for i in range(10):
        print(limiter.allow_request('192.168.1.1'))
        time.sleep(1)

5. Dans le code ci-dessus, nous créons d'abord une classe appelée RateLimiter, qui utilise Redis comme stockage backend. Le constructeur accepte deux paramètres : l'instance client Redis et la limite de débit. Chaque fois que nous appelons la méthode allow_request, elle acceptera un paramètre représentant une adresse IP, puis vérifiera si le nombre de requêtes pour cette adresse IP dépasse la limite de débit. Sinon, il collecte la demande et renvoie True ; sinon, il rejette la demande et renvoie False.

Dans la fonction principale, nous avons créé une instance nommée limiteur, défini la limite de débit à 5 (c'est-à-dire accepter jusqu'à 5 requêtes par seconde), puis simulé 10 requêtes consécutives, chacune L'intervalle entre les requêtes est de 1 seconde. Au début de la 6ème requête, la limite de débit étant atteinte, toutes les requêtes seront rejetées et False sera renvoyé.

4. Résumé

Redis est un système de stockage de données en mémoire haute performance qui fournit une variété de structures de données, en particulier zset (Sorted Set), qui implémente une distribution limitée Idéal pour streaming. En utilisant des fonctions telles que les commandes zset, INCRBY et zrangebyscore de Redis, nous pouvons facilement implémenter une limitation de courant distribuée pour contrôler le flux de requêtes et garantir la haute disponibilité et la stabilité du service.

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!