OpenResty集群限流

已于 2024-05-21 10:48:05 修改
阅读量996 收藏 23
点赞数 31
分类专栏： Java 文章标签： openresty 负载均衡 nginx
于 2024-05-21 10:45:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43646524/article/details/139085274
版权

目录


前言： 上一遍文章介绍了 OpenResty单机限流的规则存储与限流基本流程，在生产情况下，大部分稍微大点的项目，都会进行集群部署，所以nginx也会部署多个，本文继续介绍 OpenResty集群限流。

限流规则保存和限流执行逻辑和单机限流一样（这个可以参考上一篇文章），只是限流算法使用了redis的一些数据结构来实现。

分布式限流规则原理

滑动窗口

  • 时间窗口设定：首先，定义一个时间窗口，表示限流器对请求进行计数的时间段，通常是一段固定长度的时间，比如 1 秒、1 分钟等。

  • 计数请求：在每个时间窗口内，限流器会统计进入系统的请求数量。这里使用了 Redis 的有序集合（Sorted Set）来记录请求的时间戳和唯一 ID。时间戳表示请求进入系统的时间，唯一 ID 用于区分不同的请求。

  • 限制请求数：在每个时间窗口内，限流器会统计请求的数量。如果请求的数量超过了预先设定的阈值（即 limit），则认为系统已经达到了限流状态，拒绝后续请求。

  • 清理旧数据：为了避免数据无限增长，需要定期清理旧的请求数据。这里使用了 zremrangebyscore 命令来删除时间窗口之前的数据。

  • 过期时间设置：通过设置键的过期时间，确保在一段时间后限流器自动重置。这里使用了 EXPIRE 命令来设置键的过期时间。

令牌桶

  • 获取上次生成令牌时间：通过 Redis 的哈希表数据结构，获取存储在键 中的上次生成令牌的时间和当前令牌数量。如果之前没有生成过令牌，则默认上次生成令牌时间为 0。

  • 初始化令牌桶：如果上次生成令牌时间为 0，则说明需要初始化令牌桶，此时将当前令牌数量设置为开始令牌数量，并将当前时间戳存储为上次生成令牌时间。

  • 更新令牌数量：如果上次生成令牌时间不为 0，则根据当前时间戳与上次生成令牌时间之间的时间间隔，计算出期间应该生成的令牌数量。然后将当前令牌数量更新为当前令牌数量加上期间应该生成的令牌数量，但不超过令牌桶的最大容量 。如果本次生成的令牌数量大于 0，则更新上次生成令牌的时间为当前时间戳。

  • 申请令牌：根据请求需要的令牌数量 ，判断当前令牌数量是否足够。如果不够，则表示资源不足，返回 -1；如果足够，则更新令牌数量，将当前令牌数量减去申请的令牌数量，并将其存储回 Redis。

  • 返回结果：根据申请令牌的结果，返回相应的标志。如果成功申请到了足够的令牌，则返回 1；如果资源不足，则返回 -1。

限制接口指定时间内并发连接数

请求开始：

  • 获取参数：从传入的参数中获取键名 、允许的最大并发数 和每个并发访问的过期时间 。

  • 检查当前并发数：通过 redis.call(‘get’, key) 获取当前记录的并发访问数。如果获取到的值不为 false（说明键存在），并且当前并发数已经达到或超过了允许的最大并发数，则直接返回 -1，表示无法继续访问，否则继续执行下一步。

  • 增加并发计数器：如果当前并发数未达到限制，通过 redis.call(‘incr’, key) 命令将计数器增加 1，表示有一个新的并发访问。同时，通过 redis.call(‘expire’, key, concurrentTime) 设置键的过期时间，以防止并发计数器一直增长，这样可以确保一段时间后自动重置并发计数。

  • 返回结果：如果成功增加了并发计数器，则返回 0，表示可以继续访问；否则返回 -1，表示已达到最大并发数，无法继续访问。

请求结束：

  • 减少当前请求缓存的value值

关键部分代码实现

滑动窗口

local cjson = require "cjson"
local redisUtils = require "redisUtils"
local baseUtil = require "BaseUtil"

-- 定义 Lua 脚本
local lua_script = [[
        local key = KEYS[1]
        local rangTime = tonumber(ARGV[1])
        local limit = tonumber(ARGV[2])
        -- 获取当前时间
        --local now = redis.call('TIME')[1] * 1000 + redis.call('TIME')[2] / 1000
        --local start = now - rangTime * 1000
        local now = redis.call('TIME')[1]
        local start = now - rangTime
        local count = tonumber(redis.call('zcount', key, start, now))
        --是否超出限流值
        if count >= limit then
            return -1
        end
        -- 不需要限流
        -- 窗口数据写入
        local unique_id = redis.call('INCR', 'request_id')
        -- 添加当前访问时间戳到zset
        redis.call('zadd', key, now, unique_id)
        -- 移除时间区间以外不用的数据，不然会导致zset过大
        redis.call('zremrangebyscore', key, 0, start)
        redis.call('EXPIRE', key, rangTime)
        return 1
    ]]

local function time_range_request_count(rule_detail)
    local request_uri = "timeRange_"..ngx.var.uri
    local limitTimeRange = rule_detail.limitTimeRange
    local limitNum = rule_detail.limitNum
    if not limitTimeRange or not limitNum then
        ngx.log(ngx.ERR, "limitTimeRange or limitNum is nil")
        return
    end
    -- 检查 limitTimeRange 和 limitNum 的类型
    if type(limitTimeRange) ~= "number" or type(limitNum) ~= "number" then
        ngx.log(ngx.ERR, "limitTimeRange 或 limitNum 的类型不是数字","rule_detail: "..cjson.encode(rule_detail))
        return
    end
    local redis_conn = redisUtils.get_con()
    --ngx.log(ngx.ERR, "time_range_request_count New limitTimeRange: "..limitTimeRange.." limitNum: "..limitNum)
    local keys = {request_uri}
    local argv = {limitTimeRange, limitNum}
    local keys_and_argv = {table.unpack(keys), table.unpack(argv)}
    local result, err = redis_conn:eval(lua_script, #keys, unpack(keys_and_argv))
    if not result then
        ngx.log(ngx.ERR, "Failed to run the script: ", err)
        return
    end
    if result == -1 then
        baseUtil.api_rate_limit_res(429,429,"服务器异常")
    end
end


return {
    time_range_request_count = time_range_request_count
}

令牌桶

local cjson = require "cjson"
local baseUtil = require "BaseUtil"
local redisUtils = require "redisUtils"

-- 定义 Lua 脚本
local lua_script = [[
    -- 获取上次生成令牌时间
    local last_gen_token_time = tonumber(redis.call('HGET', KEYS[1], 'time') or '0')
    -- 当前令牌数量
    local current_token_num
    -- 如果上次生成令牌时间是0，则需要初始化令牌桶，并设置令牌数量和时间
    if last_gen_token_time == 0 then
        current_token_num = tonumber(ARGV[1])
        redis.call('HMSET', KEYS[1], 'count', current_token_num, 'time', ARGV[2])
    else
        -- 当前时间戳
        local now_time = tonumber(ARGV[2])
        current_token_num = tonumber(redis.call('HGET', KEYS[1], 'count') or '0')
        -- 期间应该生成的令牌数 = 距离上一次生成令牌的秒数 * 每秒钟应该放入的令牌数
        local duration_token_num = math.floor((now_time - last_gen_token_time) / 1000) * ARGV[3]
        -- 当前令牌数量 = min(当前令牌剩余数量 + 期间应该生成的令牌数，令牌桶最大长度)
        current_token_num = math.min(current_token_num + duration_token_num, tonumber(ARGV[1]))
        -- 如果本次生成的令牌数量大于0，则更新时间
        if duration_token_num > 0 then
            redis.call('HSET', KEYS[1], 'time', ARGV[2])
        end
    end
    -- 本次申请的令牌个数
    local acquire_num = tonumber(ARGV[4])
    local rt
    if current_token_num < acquire_num then
        -- 申请资源失败
        rt = -1
    else
        -- 更新令牌数量
        current_token_num = current_token_num - acquire_num
        redis.call('HSET', KEYS[1], 'count', current_token_num)
        -- 申请资源成功
        rt = 1
    end
    return rt
  ]]

-- 令牌桶算法限流
local function token_bucket_algorithm(rule_detail)
    local request_uri = "tokenBucket_"..ngx.var.uri
    -- 限流速率 r/s
    local rate = rule_detail.rate
    -- 令牌数量
    local burst = rule_detail.burst
    -- 检查 rate 和 burst 的类型
    if type(rate) ~= "number" or type(burst) ~= "number" or rate == 0 or burst == 0  then
        ngx.log(ngx.ERR, "rate 或 burst 的类型不是数字","rule_detail: "..cjson.encode(rule_detail))
        return
    end
    local redis_conn = redisUtils.get_con()
    local now_time = os.time()*1000
    local acquire_num = 1
    ngx.log(ngx.ERR, "token_bucket_algorithm New rate: "..rate.." burst: "..burst.." now_time: "..now_time)
    local keys = {request_uri}
    local argv = {burst,now_time,rate,acquire_num}
    local keys_and_argv = {table.unpack(keys), table.unpack(argv)}
    local result, err = redis_conn:eval(lua_script, #keys, unpack(keys_and_argv))
    if not result then
        ngx.log(ngx.ERR, "Failed to run the script: ", err)
        return
    end
    ngx.log(ngx.ERR, "token_bucket_algorithm New result: ",result)
    if result == -1 then
        baseUtil.api_rate_limit_res(429,429,"服务器异常")
    end
    ngx.log(ngx.ERR, "token_bucket_algorithm New success")
end

return {
    token_bucket_algorithm = token_bucket_algorithm
}

限制接口指定时间内并发连接数

local limit_conn = require "resty.limit.conn"
local cjson = require "cjson"
local baseUtil = require "BaseUtil"
local redisUtils = require "redisUtils"

local lua_script = [[
        local key = KEYS[1]
        local concurrentNum = tonumber(ARGV[1])
        local concurrentTime = tonumber(ARGV[2])
        local num = redis.call('get', key)
        if num ~= false and tonumber(num) >= concurrentNum then
            return -1
        end
        redis.call('incr', key)
        redis.call('expire', key, concurrentTime)
        return 0
    ]]

-- 限制最大并发连接数
local function concurrent_connections(rule_detail)
    local request_uri = "concurrentCon_"..ngx.var.uri
    local concurrentNum = rule_detail.concurrentNum
    local concurrentTime = rule_detail.concurrentTime
    -- 检查 concurrentNum、concurrentExtraNum、concurrentTime 的类型
    if type(concurrentNum) ~= "number" or type(concurrentTime) ~= "number"then
        ngx.log(ngx.ERR, "concurrentNum 或 concurrentExtraNum 或 concurrentTime 的类型不是数字","rule_detail: "..cjson.encode(rule_detail))
        return
    end
    ngx.log(ngx.ERR, "concurrent_connections concurrentNum: "..concurrentNum.." concurrentTime: "..concurrentTime)
    -- 使用 eval 命令执行脚本
    local keys = {request_uri}
    local argv = {concurrentNum, concurrentTime}
    local keys_and_argv = {table.unpack(keys), table.unpack(argv)}
    local redis_conn = redisUtils.get_con()
    local result, err = redis_conn:eval(lua_script, #keys, unpack(keys_and_argv))
    -- 检查脚本执行结果
    if result == -1 then
        baseUtil.api_rate_limit_res(500,500,"服务器异常")
        return
    end
    -- 如果请求没有超过并发限制，那么将连接信息添加到ngx.ctx中
    local ctx = ngx.ctx
    ctx.limit_type = "concurrent_connections"
    ctx.limit_conn_key = request_uri
end

local function concurrent_connections_leaving()
    local ctx = ngx.ctx
    local lim = ctx.limit_conn
    if lim then
        local key = ctx.limit_conn_key
        local limit_type = ctx.limit_type
        if not limit_type then
            return
        end
        if limit_type ~= "concurrent_connections" then
            return
        end
        local redis_conn = redisUtils.get_con()
        redis_conn:decr(key)
    end
end

return {
    concurrent_connections = concurrent_connections,
    concurrent_connections_leaving = concurrent_connections_leaving
}

上面就是几种限流算法用lua实现的关键部分逻辑，代码仅供参考学习，欢迎留言讨论。后续会将完整的项目代码更新到远程仓库，欢迎关注我的公众号，后续会在公众号提供获取地址。下一篇将介绍一下使用sentinel进行限流
在这里插入图片描述

编程智囊
关注
  • 31
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenResty网关鉴权方案lua代码（Redis集群版）
02-18
通过使用lua代码的原子性操作，对OpenResty进行增强，实现网关鉴权的功能
OpenResty的文件
03-26
OpenResty
一步安装openresty
06-12
离线一步安装openresty，前提需要安装gcc
常见的限流算法
yaobo2816的专栏
12-16 333
常见的限流算法 计数器算法 计数器算法采用计数器实现限流有点简单粗暴，一般我们会限制一秒钟的能够通过的请求数，比如限流qps为100，算法的实现思路就是从第一个请求进来开始计时，在接下去的1s内，每来一个请求，就把计数加1，如果累加的数字达到了100，那么后续的请求就会被全部拒绝。等到1s结束后，把计数恢复成0，重新开始计数。具体的实现可以是这样的：对于每次服务调用，可以通过AtomicLong#incrementAndGet()方法来给计数器加1并返回最新值，通过这个最新值和阈值进行比较。这种实现方式
限流算法详解
acq的博客
03-08 321
限流是我们经常会碰到的东西，顾名思义就是限制流量。它能保证我们的系统不会被突然的流量打爆，保证系统的稳定运行。像我们生活中，地铁就会有很多护栏，弯弯绕绕的，这个就是一种限流。像我们抢茅台，肯定大部分流量也是会被限流的，你的请求可能根本没进到下单等环节就被拦截了。
【Redis】分布式限流与Redis实现限流的四种方式（Redis专栏启动）
小明的Java问道之路
12-11 5502
本文介绍分布式系统和分布式限流，我们现在的生产中的限流包括网关层的限流与Redis实现的限流策略，主要有基于Redis的 setnx 操作、List、zset实现的滑动窗口，以及Redis的Lua脚本实现分布式限流。
预案三板斧之限流大法
焦振清
10-22 340
作者：焦振清 限流策略：多维防御 + 纵深防御 限流能力 限流是针对请求的各种特征，多维防御 + 纵深防御，从而限制流量，实现对服务端资源的合理使用。这里的特征是指一个请求所包含的各种信息，包括但不限于 IP、Header、URI、Cookie 等。常见的限流策略有以下三种（以 Nginx 为例进行说明）： 限制请求数，意思是请求的次数不能太多 Nginx：http://nginx.o...
限流算法如何选择？时间敏感，QPS，集群
琦彦
02-24 680
限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣的部分。 计数器固定窗口算法 原理 计数器固定窗口算法是最基础也是最简单的一种限流算法。原理就是对一段固定时间窗口内的请求进行计数，如果请求数超过了阈值，则舍弃该请求；如果没有达到设定的阈值，则接受该请求，且计数加1。当时间窗口结束时
从构建分布式秒杀系统聊聊限流特技
不是太高的手的专栏
06-12 379
前言 俗话说的好，冰冻三尺非一日之寒，滴水穿石非一日之功，罗马也不是一天就建成的。两周前秒杀案例初步成型，分享到了中国最大的同性交友网站-码云。同时也收到了不少小伙伴的建议和投诉。我从不认为分布式、集群、秒杀这些就应该是大厂的专利，在互联网的今天无论什么时候都要时刻武装自己，只有这样，也许你的春天就在明天。 在开发秒杀系统案例的过程中，前面主要分享了队列、缓存、锁和分布式锁以及静态化等等。...
高并发场景下的限流策略
lx_Frolf的博客
01-09 1800
高并发场景下的限流策略 性能调优是针对于代码本身的不规范性和系统资源的瓶颈的，当计算机的硬件资源达到瓶颈的时间已经无法调优了。高并发场景下一方面通过缓存，异步化，服务化，集群去增加整个系统的吞吐量，另一方面通过限流，降级来保护系统。 什么是限流和降级 在开发高并发系统时，有很多手段来保护系统：缓存、降级、限流。 缓存是为了解决访问热点数据的速度问题和低速IO部件与高速IO部件之间的差异性，从而提高...
分布式电商项目——15.秒杀接口实现高并发限流方案（网关限流）
qq_28461661的博客
12-18 749
秒杀接口实现高并发限流方案 Java高并发实现限流算法 常见限流算法常用的限流算法有：令牌桶，漏桶。 令牌桶算法 在秒杀活动中，用户的请求速率是不固定的，这里我们假定为10r/s，令牌按照5个每秒的速率放入令牌桶，桶中最多存放20个令牌。仔细想想，是不是总有那么一部分请求被丢弃。 漏桶算法 漏桶算法的主要目的是控制数据注入到网络的速率，平滑网络上的突发流量。漏桶算法提供了一种机制，通过它，突发流量...
Openresty 缓存策略.pdf
08-20
Openresty 缓存策略.pdf
OpenResty教程,OpenResty使用教程
12-22
OpenResty教程,OpenResty使用教程 OpenResty是大并发服务器的不错选择,可实现数据校验前置、缓存前置、数据过滤、API请求聚合、认证管理、负载均衡、流量控制、灰度发布、降级、监控等功能
4.Nginx整合OpenResty+Lua （黑名单控制、内网访问限制、资源下载限速、日志分析、漏桶原理、令牌桶原理）
weixin_43620238的博客
08-05 884
Nginx整合OpenResty+Lua （黑名单控制、内网访问限制、资源下载限速、日志分析、漏桶原理、令牌桶原理）
CentOS7.x 基于源码构建安装openresty
qq_19783793的博客
08-02 514
openresty
Nginx企业级负载均衡：技术详解系列（16）—— Nginx的try_files指令，你知道这个指令是干什么的吗？
最新发布
趙兴晨的博客
06-02 626
在Nginx的配置文件中，try_files指令允许我们定义一个文件列表，Nginx会按照这个列表的顺序去查找文件。例如，它可能首先查找原始的URI，然后是该RUI的.html版本，接着是URI对应的目录下的index.html文件。3、访问一个不存在的URI，如 http://chensir.ink/about/xx.html，观察是否显示 default.html 的内容。4、注释掉 default.html的重定向，启用自定义状态码489的配置，再次访问不存在的URI，观察返回的状态码是否为489。
云WAF的负载均衡和流量分发功能
waitaikong_的博客
05-31 572
云WAF允许管理员根据具体业务需求和安全风险，灵活配置安全策略和规则。例如，管理员可以设置特定的规则来阻止来自某个IP地址范围的流量，或是允许特定的HTTP方法。
Kong网关的负载均衡
mrcool2012的博客
05-29 834
kong网关负载均衡
openresty lua+redis集群
09-07
OpenResty是一个基于Nginx的服务，内置了Lua脚本语言的支持。它可以使用Lua脚本与Redis集群进行交互。 Redis集群是Redis数据库的一个分布式解决方案，可以将数据分布在多个节点上，提高系统的可扩展性和可用性。在使用OpenResty与Redis集群进行交互时，可以使用Redis Lua API来执行操作。 首先，需要在OpenResty中安装Redis Lua库，可以通过下载并编译源代码来完成。然后，在OpenResty的配置文件中配置Redis集群节点的地址和端口信息。 在Lua脚本中，可以使用redis.call函数来执行Redis命令。例如，可以使用redis.call('get', 'key')来获取Redis集群中某个键的值，使用redis.call('set', 'key', 'value')来设置某个键的值。 此外，还可以使用Redis的发布与订阅功能，让OpenResty与Redis集群进行实时消息传递。可以使用redis.call('publish', 'channel', 'message')来发布消息，使用redis.call('subscribe', 'channel')来订阅消息。 总结起来，OpenResty Lua与Redis集群的集成能够帮助我们构建高性能、可扩展的Web应用。通过使用Lua脚本与Redis集群进行交互，我们可以方便地进行数据的读写操作，以及实现实时消息传递的功能。这种集成方式在大规模分布式系统中具有广泛的应用场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值