The principle and implementation method of Redis implementing distributed current limiting

With the development of the Internet, many applications need to limit the flow of various requests. This is because under high concurrency, the application will be under the pressure of a large number of requests, causing the service to crash or respond slowly. In order to solve this problem, developers usually use distributed current limiting technology to control the flow of requests and ensure the high availability and stability of the service. As a high-performance memory data storage system, Redis is one of the commonly used distributed current limiting solutions. This article will introduce the principle and implementation method of distributed current limiting in Redis.

1. What is distributed current limiting?

Distributed current limiting refers to the process of controlling request traffic through collaboration between multiple servers. A rate limiter counts the number of requests, compares the rate of incoming requests to the allowed rate, and accepts or denies requests based on the ratio. In distributed throttling, each node shares the request rate and request counter, which helps ensure that the rate is equal for all nodes and avoids overloading a node.

2. The principle of Redis implementing distributed current limiting

Redis uses its built-in data structure, especially zset (sorted set), to implement distributed current limiting. A zset is a sorted set where each element is unique and has a score. The score is used to sort elements, usually numbers or times. In distributed current limiting, we can set a zset for each user (or IP address), and then use this zset to store the user's request counter. As each request arrives, we store it in a zset and increment the counter using Redis's INCRBY command. We then pass the request score and the current timestamp together as parameters to the zrangebyscore command to calculate the rate of requests within a certain time range. If the rate exceeds our allowed rate, the request is rejected.

3. How Redis implements distributed current limiting

The specific implementation of Redis implementing distributed current limiting is as follows:

1. Create a global zset Used to store rate limiters (one rate limiter represents a user or IP address) and request counters for each rate limiter.
2. Whenever a request arrives, we store it in the zset of this rate limiter and increment the counter using the INCRBY command. By default, this command increments the counter by 1 each time, but you can increase the increment by setting the command's arguments to a higher value.
3. Use the zrangebyscore command to find all requests with a request counter within a specified time range and calculate the request rate.
4. If the request rate exceeds the allowed rate, the request will be rejected and an error message will be returned.
5. If the request rate does not exceed the allowed rate, the request is accepted and the request counter in zset is updated.

The following is a sample code showing how to use Redis to implement distributed current limiting. Among them, we used a global zset to store the request counter for each IP address, and used the zrangebyscore command to calculate the request rate per second.

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)

In the above code, we first create a class called RateLimiter, which uses Redis as the backend storage. The constructor accepts two parameters: Redis client instance and rate limit. Whenever we call the allow_request method, it will accept a parameter representing an IP address and then check whether the number of requests for that IP address exceeds the rate limit. If it is not exceeded, it collects the request and returns True; otherwise, it rejects the request and returns False.

In the main function, we created an instance named limiter, set the rate limit to 5 (ie, accepts up to 5 requests per second), and then simulated 10 consecutive requests, each request The interval is 1 second. At the beginning of the 6th request, since the rate limit has been reached, all requests will be rejected and False will be returned.

4. Summary

Redis is a high-performance memory data storage system that provides a variety of data structures, especially zset (Sorted Set), which is an ideal choice for implementing distributed current limiting. . By using functions such as Redis's zset, INCRBY and zrangebyscore commands, we can easily implement distributed current limiting to control the flow of requests and ensure the high availability and stability of the service.

The above is the detailed content of The principle and implementation method of Redis implementing distributed current limiting. For more information, please follow other related articles on the PHP Chinese website!