Question

我正在使用模块pyTelegramBotAPI开发一个bot，它通过webhooks与已安装的Flask + Gunicorn一起作为webhooks的服务器。 Gunicorn正在与5名工人合作以提高速度，我项目的结构看起来像这样：

app.py
bot.py

在bot.py中，我有一个处理更新的功能：

def process_the_update(update):
    logger.info(update)
    update = types.Update.de_json(update)
    bot.process_new_updates([update])

在app.py我导入了这个函数，所以，每当更新到来时，app.py都会调用这个函数，而bot会处理更新。在我的bot中，用户可以调用一个命令，该命令将使用外部api来获取一些信息。问题是，这个外部api限制了每秒3个请求。我需要配置具有此速率限制的机器人。首先我想用Queue做这个代码：

lock_queue = Queue(1)
requests_queue = Queue(3)
def api_request(argument):
    if lock_queue.empty():
        try:
            requests_queue.put_nowait(time.time())
        except queue.Full:
            lock_queue.put(1)
            first_request_time = requests_queue.get()
            logger.info('First request time: ' + str(first_request_time))
            current_time = time.time()
            passed_time = current_time - first_request_time
            if passed_time >= 1:
                requests_queue.put_nowait(time.time())
                lock_queue.get()
            else:
                logger.info(passed_time)
                time.sleep(1 - passed_time)
                requests_queue.put_nowait(time.time())
                lock_queue.get()
    else:
        lock_queue.put(1)
        first_request_time = vk_requests_queue.get()
        logger.info('First request time: ' + str(first_request_time))
        current_time = time.time()
        passed_time = current_time - first_request_time
        if passed_time >= 1:
            requests_queue.put_nowait(time.time())
            lock_queue.get()
        else:
            logger.info(passed_time)
            time.sleep(1 - passed_time)
            requests_queue.put_nowait(time.time())
            lock_queue.get()
    result = make_api_request(argument) # requests are made too by external module.
    return result

逻辑是，正如我所想的那样，因为模块pyTelegramBotAPI使用线程来更快地处理更新，所有线程都会检查requests_queue，它将有3个最后一次api_requests的时间，因此3个请求中的第一个请求的时间将是与当前时间相比（检查，如果第二次通过）。并且，因为我需要确定，只有一个线程会同时进行这种比较，我做了lock_queue。但是，问题在于，首先，gunicorn使用5个工作者，因此总是有可能来自用户的所有消息将在不同的进程中处理，并且这些进程将具有自己的队列。其次，即使我将工人数量设置为默认值（1名工人），我仍然会得到429错误，所以我认为，我的代码根本无法工作。

我想用redis进行速率限制，所以每次在每个线程和进程机器人都会检查最后3个请求的时间，但我仍然不确定，这是正确的方式，我不确定，怎么写这个。

很高兴，如果有人提出任何想法甚至代码示例（外部api不提供任何x-rate-limit标头）

Answer 1

写了这个函数，使用redis来计算请求（基于这个https://www.binpress.com/tutorial/introduction-to-rate-limiting-with-redis/155教程）

import redis

r_db = redis.Redis(port=port, db=db)

def limit_request(request_to_make, limit=3, per=1, request_name='test', **kwargs):
    over_limit_lua_ = '''
    local key_name = KEYS[1]
    local limit = tonumber(ARGV[1])
    local duration = ARGV[2]

    local key = key_name .. '_num_of_requests'
    local count = redis.call('INCR', key)
    if tonumber(count) > limit then
        local time_left = redis.call('PTTL', key)
        return time_left
    end
    redis.call('EXPIRE', key, duration)
    return -2
    '''

    if not hasattr(r_db, 'over_limit_lua'):
        r_db.over_limit_lua = r_db.register_script(over_limit_lua_)

    request_possibility = int(r_db.over_limit_lua(keys=request_name, args=[limit, per]))
    if request_possibility > 0:
        time.sleep(request_possibility / 1000.0)
        return limit_request(request_to_make, limit, per, request_name, **kwargs)
    else:
        request_result = request_to_make(**kwargs)
        return request_result

电报机器人的API费率限制

1 个答案: