美文网首页Java高级架构Java架构技术栈程序员
分布式系统限流策略（二）

分布式系统限流策略（二）

作者: 若丨寒 | 来源:发表于2019-04-22 18:14 被阅读8次

前文分布式系统限流策略（一）中介绍了系统限流的原理和基础的使用场景，可以关注下我在主页观看，本篇将介绍应用接入层（Nginx）、分布式应用如何限流。

应用接入层限流（Nginx/OpenResty）

接入层通常是指流量的入口，主要的目的有：负载均衡、非法请求过滤、请求聚合、缓存、降级、限流、A/B测试、服务质量监控等。对于流量接入层所使用的中间件一般都是：Nginx（OpenResty）。下面将分别介绍一下如何进行限流操作。

Nginx

Nginx限流可以使用其自带的2个模块：连接数限流模块（ngx_http_limit_conn_module）和漏桶算法实现的请求限流模块（ngx_http_limit_req_module）。

ngx_http_limit_conn_module

limit_conn是用来对某个key对应的总的网络连接数进行限流，可以按照IP、host维度进行限流。不是每个请求都会被计数器统计，只有被Nginx处理并且已经读取了整个请求头的连接才会被计数。下面给出一个Demo（按照IP限流）：

http {
    limit_conn_zone $binary_remote_addr zone=addr:10m; # 用来配置限流key及存放key对应信息的内存区域大小。此处的key是“$binary_remote_addr”，表示IP地址。也可以使用$server_name作为key

    limit_conn_log_level error; # 被限流后的日志级别
    limit_conn_status 503; # 被限流后返回的状态码
    ...
    server {
    ...
    location /limit {
        limit_conn addr 1; # 要配置存放key和计数器的共享内存区域和指定key的最大连接数。此处表示Nginx最多同时并发处理1个连接
    }
...
}

也可以按照host进行限流，Demo如下：

http {
    limit_conn_zone $server_name zone zone=hostname:10m;

    limit_conn_log_level error; # 被限流后的日志级别
    limit_conn_status 503; # 被限流后返回的状态码
    ...
    server {
    ...
    location /limit {
        limit_conn hostname 1;
    }
...
}

流程如下所示：


ngx_http_limit_req_module

limit_req是漏桶算法，对于指定key对应的请求进行限流。配置Demo如下：

http {
    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s; # 配置限流key、存放key对应信息的共享内存区域大小、固定请求速率。此处的key是“$binary_remote_addr”(IP地址)。固定请求速率使用rate配置，支持10r/s和60r/m。

    limit_conn_log_level error;
    limit_conn_status 503;
    ...
    server {
    ...
        location /limit {
            limit_req zone=one burst=5 nodelay; # 配置限流区域、桶容量（突发容量，默认为0）、是否延迟模式（默认延迟）
        }
    ...
    }
}

limit_req的主要执行过程如下：

  1. 请求进入后首先判断上一次请求时间相对于当前时间是否需要限流，如果需要则执行步骤2，否则执行步骤3.
  2. 如果没有配置桶容量（burst=0），按照固定速率处理请求。如果请求被限流了，直接返回503；
    如果配置了桶容量（burst>0），及延迟模式（没有配置nodelay）。如果桶满了，则新进入的请求被限流。如果没有满，则会以固定速率被处理；
    如果配置了桶容量（burst>0），及非延迟模式（配置了nodelay）。则不会按照固定速率处理请求，而是允许突发处理请求。如果桶满了，直接返回503.
  3. 如果没有被限流，则正常处理请求。
  4. Nginx会在响应时间选择一些（3个节点）限流key进行过期处理，进行内存回收。

OpenResty

Openresty提供了Lua限流模块lua-resty-limit-traffic，通过它可以按照更为复杂的业务逻辑进行动态限流处理。它也提供了limit.conn和limit.req的实现，算法与Nginx的limit_conn和limit_req是一样的。其下载地址为：lua-resty-limit-traffic，下载后，将其limit文件夹中的内容覆盖掉OpenResty安装目录中的resty中的limit文件夹即可。

lua-resty-limit-traffic

OpenResty中的限速，可以分为以下三种：limit_rate（限制响应速度）、limit_conn（限制连接数）、limit_req（限制请求数）。下面将分别介绍一下它们的用法。

limit_rate（限制响应速度）

Nginx有个$limit_rate，这个变量反映的是当前请求每秒能响应的字节数。该字节数默认为配置文件中 limit_rate指令的设值。 通过 OpenResty，我们可以直接在 Lua 代码中动态设置它。

access_by_lua_block {
    -- 设定当前请求的响应上限是 每秒 300K 字节
    ngx.var.limit_rate = "300K"
}
limit_conn（限制连接数）

对于限制连接数，连接数限制并不是1S内的连接数限制，而是同一时刻的连接数限制。下面给出一个Demo：

nginx.conf

# nginx.conf
lua_code_cache on;
# 注意 limit_conn_store 的大小需要足够放置限流所需的键值。
# 每个 $binary_remote_addr 大小不会超过 16K，算上 lua_shared_dict 的节点大小，总共不到 64 字节。
# 100M 可以放 1.6M 个键值对
lua_shared_dict limit_conn_store 100M;
server {
    listen 8080;
    location /limit {
        access_by_lua_file src/access.lua;
        content_by_lua_file src/content.lua;
        log_by_lua_file src/log.lua;
    }
}

然后封装一个队req.conn的工具：limit_conn.lua

-- utils/limit_conn.lua
local limit_conn = require "resty.limit.conn"

-- new 的第四个参数用于估算每个请求会维持多长时间，以便于应用漏桶算法
local limit, limit_err = limit_conn.new("limit_conn_store", 2, 2, 0.01)
if not limit then
    error("failed to instantiate a resty.limit.conn object: ", limit_err)
end

local _M = {}

function _M.incoming()
    local key = ngx.var.binary_remote_addr
    local delay, err = limit:incoming(key, true)
    if not delay then
        if err == "rejected" then
            return ngx.exit(503)
        end
        ngx.log(ngx.ERR, "failed to limit req: ", err)
        return ngx.exit(500)
    end

    if limit:is_committed() then
        local ctx = ngx.ctx
        ctx.limit_conn_key = key
        ctx.limit_conn_delay = delay
    end

    if delay >= 0.001 then
        ngx.log(ngx.WARN, "delaying conn, excess ", delay,
                "s per binary_remote_addr by limit_conn_store")
        ngx.sleep(delay)
    end
end

function _M.leaving()
    local ctx = ngx.ctx
    local key = ctx.limit_conn_key
    if key then
        local latency = tonumber(ngx.var.request_time) - ctx.limit_conn_delay
        local conn, err = limit:leaving(key, latency)
        if not conn then
            ngx.log(ngx.ERR,
            "failed to record the connection leaving ",
            "request: ", err)
        end
    end
end

return _M

然后是接收到请求时的处理代码：access.lua

-- src/access.lua
local limit_conn = require "utils.limit_conn"

-- 对于内部重定向或子请求，不进行限制。因为这些并不是真正对外的请求。
if ngx.req.is_internal() then
    return
end
limit_conn.incoming()

对于内容生成：content.lua，这里我们就简单的处理一下：

-- src/content.lua

ngx.say('content has generated!')

ngx.sleep(0.01) # 这里模拟一个0.01S的耗时，否则看不出效果

然后是内容生成后的后置代码：log.lua

-- src/log.lua
local limit_conn = require "utils.limit_conn"

limit_conn.leaving()

笔者在MAC系统下使用webbench对接口进行测试，过程如下：

webbench -c 10 -t 10 http://localhost/limit

这里面-c表示10个并发，执行10S的压力测试。笔者从实验结果看来：

  1. 当设置limit_conn.new(“limit_conn_store”, 2, 2, 0.05)这个条件时，从第1S开始，200的响应结果为34个；后面的每一秒200的响应结果都维持在60个左右。
  2. 当设置limit_conn.new(“limit_conn_store”, 2, 2, 0.01)这个条件时，从第1S开始，200的响应结果为44个；后面的每一秒200的响应结果都维持在160个左右。
  3. 当设置limit_conn.new(“limit_conn_store”, 2, 2, 0.05)这个条件时，从第1S开始，200的响应结果为82个；后面的每一秒200的响应结果都维持在224个左右。
  4. 当设置limit_conn.new(“limit_conn_store”, 2, 2, 0.001)这个条件时，从第1S开始，200的响应结果为131个；后面的每一秒200的响应结果都维持在223个左右。
  5. 当设置limit_conn.new(“limit_conn_store”, 2, 2, 0.0001)这个条件时，从第1S开始，200的响应结果为171个；后面的每一秒200的响应结果都维持在300个左右。
    从上面的结果看来，对于每个请求的执行时间预估越接近实际值或者时间略小于实际的平均值，最后榨取机器的剩余价值会越多。
limit_req（限制请求数）

对于限制请求数，下面给出一个Demo：

lua_shared_dict my_limit_req_store 100m;

location /limit {
    access_by_lua_file src/utils/limit_req.lua;
    content_by_lua_file src/content.lua;
}

limit_req.lua的内容如下：

local limit_req = require "resty.limit.req"

-- 将请求限制在20请求/秒，突发10次/秒，
-- 也就是说，我们推迟了每秒30以下和20以上的请求，并拒绝超过30请求/秒的任何请求。
local lim, err = limit_req.new("my_limit_req_store", 20, 10)
if not lim then
    ngx.log(ngx.ERR, "failed to instantiate a resty.limit.req object: ", err)
    return ngx.exit(500)
end

local key = ngx.var.binary_remote_addr
local delay, err = lim:incoming(key, true)
if not delay then
    if err == "rejected" then
        return ngx.exit(503)
    end
    ngx.log(ngx.ERR, "failed to limit req: ", err)
    return ngx.exit(500)
end

if delay >= 0.001 then
    local excess = err

    ngx.sleep(delay)
end

笔者使用如下命令进行测试：

webbench -c 50 -t 5 http://localhost/limit

结果是每秒的200的结果为20个。

limit_traffic

limit_traffic可以聚合上面多种请求限流策略，这里不再说明。后续会在OpenResty的专题单独说明。

分布式应用限流

分布式应用限流指的是，在应用服务器上面进行限流操作，如Tomcat等。分布式限流最关键的是要将限流服务做成原子化，而解决方案可以使使用redis+lua进行实现，在Java开发语言中，Jedis可以支持原子性的Lua脚本。下面介绍一下Redis+Lua的实现。

Redis+Lua的实现

Lua脚本

local key = KEYS[1] --限流KEY（一秒一个）
local limit = tonumber(ARGV[1]) --限流大小
local current = tonumber(redis.call('get', key) or "0")
if current + 1 > limit then --如果超出限流大小
    return 0
else --请求数+1，并设置2秒过期
    redis.call("INCRBY", key,"1")
    redis.call("expire", key,"2")
    return 1
end

Java调用代码如下：

public static boolean acquire() throws Exception {
    String luaScript = Files.toString(new File("limit.lua"), Charset.defaultCharset());
    Jedis jedis = new Jedis("192.168.147.52", 6379);
    String key = "ip:" + System.currentTimeMillis()/ 1000; //此处将当前时间戳取秒数
    Stringlimit = "3"; //限流大小
    return (Long)jedis.eval(luaScript,Lists.newArrayList(key), Lists.newArrayList(limit)) == 1;
}

因为Redis的限制（Lua中有写操作不能使用带随机性质的读操作，如TIME）不能在Redis Lua中使用TIME获取时间戳，因此只好从应用获取然后传入，在某些极端情况下（机器时钟不准的情况下），限流会存在一些小问题。

读者分享

在这给大家推荐一个微信公众号，那里每天都会有技术干货、技术动向、职业生涯、行业热点、职场趣事等一切有关于程序员的内容分享。更有海量Java架构、移动互联网架构相关源码视频，面试资料，电子书籍截止于4月28日免费发放。我看了觉得资源还不错，如果你们有需要的话，扫描下方二维码关注wx公众号免费获取↓↓↓


资源大本营↓↓↓

Java架构资料
Java源码解析，到各种框架学习，再到项目实战，一应俱全，包括但不限于：Spring、Mybatis等源码、Java进阶、Java架构师、虚拟机、性能优化、并发编程、数据结构和算法。

Java架构视频资料
Java架构视频资料
java架构面试专题资料

移动互联网架构资料
Android进阶、Android架构、APP开发、NDK模块开发、小程序开发、微信开发。

Android架构资料

相关文章

  • 分布式系统限流策略（二）

    前文分布式系统限流策略（一）中介绍了系统限流的原理和基础的使用场景，可以关注下我在主页观看，本篇将介绍应用接入层（...

  • 聊聊高并发系统限流特技-2

    转载来自开涛的聊聊高并发系统限流特技-2 上一篇《聊聊高并发系统限流特技-1》讲了限流算法、应用级限流、分布式限流...

  • RateLimiter-源码分析

    一、前言 在分布式系统中，实现高可用有三大利器： 限流 降级 熔断我们先对限流来进行一个分析。 二、限流的实现 业...

  • 分布式系统限流策略（一）

    在开发高并发的系统时，有很多手段来保护系统，如缓存、降级和限流等。缓存可以提升系统的访问速度，降级可以暂时屏蔽掉非...

  • 聊聊高并发系统之限流特技-2

    摘要：上一篇《聊聊高并发系统限流特技-1》讲了限流算法、应用级限流、分布式限流；本篇将介绍接入层限流实现。 接入层...

  • 基于Redis的限流系统的设计

    本文讲述基于 Redis的限流系统的设计，主要会谈及限流系统中限流策略这个功能的设计；在实现方面，算法使用的是令牌...

  • 高并发环境下的限流策略

    本文将从以下几个方面分析限流策略： 什么是限流限流算法限流算法的应用 什么是限流 在开发高并发系统时，有很多手段来...

  • 基于Redis的限流系统的设计

    本文讲述基于Redis的限流系统的设计，主要会谈及限流系统中限流策略这个功能的设计；在实现方面，算法使用的是令牌桶...

  • 基于Redis的限流系统的设计【转】

    基于Redis的限流系统的设计，主要会谈及限流系统中限流策略这个功能的设计；在实现方面，算法使用的是令牌桶算法来，...

  • 架构成长之路：分布式系统限流策略（二）

    前文中介绍了系统限流的原理和基础的使用场景，可以关注下我在主页观看，本篇将介绍应用接入层（Nginx）、分布式应用...

网友评论

    本文标题：分布式系统限流策略（二）

    本文链接：https://www.haomeiwen.com/subject/rspugqtx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    Java高级架构

    Java架构技术栈

    程序员

    Java 杂谈

    Spring-Boot

    关于我们|服务条款|联系我们|分布式系统限流策略（二）|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！