Nginx高性能秒杀和限流

从性能上来说，内部网关Zuul限流理论上比外部网关Nginx限流的性能会差一些。和Zuul一样，外部网关Nginx也可以通过Lua脚本的形式执行缓存在Redis内部的令牌桶限流脚本来实现分布式限流。

Nginx秒杀限流有两种架构，分别说明如下：

1.Nginx限流+Zuul认证和路由+seckill-provider微服务秒杀

这种架构属于非常典型的Nginx+Spring Cloud微服务架构，限流的逻辑处于外部网关Nginx，用户的权限认证处于内部网关Zuul，而获取秒杀令牌的逻辑处于seckill-provider微服务中。

这种典型的Nginx+Spring Cloud微服务架构的秒杀流程如图10-14所示。

2.Nginx限流+Lua脚本秒杀

这种架构属于高性能的秒杀架构，不只是限流的逻辑处于外部网关Nginx，就连获取秒杀令牌逻辑也处于外部网关Nginx。和上一种秒杀架构相比，这种纯Nginx+Lua架构绝对能提高性能。为什么呢？因为除了Nginx本身的高性能之外，纯Nginx+Lua架构还能减少两次网络传输，而网络传输都是耗时较高的操作。

Nginx+Lua架构的秒杀流程如图10-15所示。

由于学会了第二种纯Nginx+Lua架构的实现，第一种架构的实现也就迎刃而解了，因此这里为大家展开介绍第二种架构的具体实现。纯Nginx+Lua架构的实现涉及以下两个Lua脚本：

（1）getToken.lua：此脚本完成秒杀令牌的设置和获取。

（2）getToken_access_limit.lua：此脚本完成分布式限流。

以上两个脚本中，getToken.lua执行在Nginx请求处理的content阶段，getToken_access_limit.lua执行在Nginx请求处理的access阶段，

两个脚本在nginx-seckill.conf文件中的具体配置如下：

 #Nginx+lua秒杀：获取秒杀token
 location = /seckill-provider/api/seckill/redis/token/v2 {
 default_type 'application/json';
 charset utf-8;
 #限流的lua脚本
 access_by_lua_file luaScript/module/seckill/getToken_access_limit.lua;
 #获取秒杀token lua脚本
 content_by_lua_file luaScript/module/seckill/getToken.lua;
 }

Lua脚本：获取秒杀令牌

获取秒杀令牌脚本getToken.lua的逻辑与seckill-provider微服务模块中的getSeckillToken方法基本类似，该脚本并没有判断和设置秒杀令牌的核心逻辑，仅仅调用缓存在Redis内部的seckill.lua脚本的setToken方法设置和获取秒杀令牌，然后对seckill.lua脚本的返回值进行判断，并根据不同的返回值做出不同的响应。

getToken.lua脚本和seckill.lua脚本都是Lua脚本，但是执行的地点不同：getToken.lua脚本被执行在Nginx中，而seckill.lua脚本被执行在Redis中，getToken.lua通过evalsha方法调用缓存在Redis中的seckill.lua脚本。getToken.lua脚本和seckill.lua脚本的关系如图10-16所示。

什么时候在Redis中加载seckill.lua脚本呢？和限流脚本一样，该脚本是在Java程序启动商品秒杀时完成其在Redis的加载和缓存的。并且，Java程序会将seckill.lua脚本加载完成之后的sha1编码通过自定义的key（具体为lua：sha1：seckill）缓存在Redis中，以方便Nginx中的getToken.lua脚本获取，并且在调用evalsha方法时使用。什么是sha1编码呢？Redis在缓存完Lua脚本后会返回该脚本的固定长度的sha1编码，作为Lua脚本的摘要提供给外部调用Lua脚本使用。

sha1摘要是通过SHA-1（Secure Hash Algorithm 1，安全散列算法1）生成的。SHA-1是第一代安全散列算法的缩写，它的本质就是一个Hash算法，主要用于生成字符串摘要（摘要经加密后成为数字签名），该算法曾被认为是MD5算法的后继者。SHA-1算法能将一个最大264比特的字符串散列成一串160位（20字节）的散列值，散列值通常的呈现形式为40个十六进制数。SHA-1算法始终能保证任何两组不同的字符串产生的摘要是不同的。

getToken.lua获取秒杀脚本的代码如下：

---此脚本的环境：nginx内部，不是运行在redis内部
---启动调试
--local mobdebug = require("luaScript.initial.mobdebug");
--mobdebug.start();
--导入自定义的基础模块
--local basic = require("luaScript.module.common.basic");
--导入自定义的RedisOperator模块
local redisExecutor = require("luaScript.redis.RedisOperator");
--导入自定义的uuid模块
local uuid = require 'luaScript.module.common.uuid'
--ngx.print("======" .. uuid.generate())
--读取post参数
ngx.req.read_body();
local data = ngx.req.get_body_data(); --获取消息体
--字符串转成json
local args = cjson.decode(data);
local goodId = args["seckillGoodId"];
local userId = args["userId"];
--生成令牌的uuid
local token = uuid.generate();
local restOut = { resp_code = 0, resp_msg = "操作成功", datas = {} };
local errorOut = { resp_code = -1, resp_msg = "操作失败", datas = {} };
local seckillSha = nil;
--创建自定义的redis操作对象
local red = redisExecutor:new();
--打开连接
red:open();
--获取lua脚本的sha1 编码
seckillSha=red:getValue("lua:sha1:seckill");
--redis没有缓存秒杀脚本
if not seckillSha or seckillSha == ngx.null then
 errorOut.resp_msg="秒杀还未启动";
 ngx.say(cjson.encode(errorOut));
 --归还连接到连接池 red:close();
 return ;
end
--执行秒杀脚本
local rawFlag = red:evalSeckillSha(seckillSha, "setToken", goodId, userId, token);
--归还连接到连接池
red:close();
if not rawFlag or rawFlag == ngx.null then
 ngx.say(cjson.encode(errorOut));
 return ;
end
local flag = tonumber(rawFlag);
if flag == 5 then
 errorOut.resp_msg = "已经排队过了";
 ngx.say(cjson.encode(errorOut));
 return ;
end
if flag == 2 then
 errorOut.resp_msg = "秒杀商品没有找到";
 ngx.say(cjson.encode(errorOut));
 return ;
end
if flag == 4 then
 errorOut.resp_msg = "库存不足，稍后再来";
 ngx.say(cjson.encode(errorOut));
 return ;
end
if flag ~= 1 then
 errorOut.resp_msg = "排队失败，未知错误";
 ngx.say(cjson.encode(errorOut));
 return ;
end
restOut.datas = token;
ngx.say(cjson.encode(restOut));

Lua脚本：执行令牌桶限流

Nginx的令牌桶限流脚本getToken_access_limit.lua执行在请求的access阶段，但是该脚本并没有实现限流的核心逻辑，仅仅调用缓存在Redis内部的rate_limiter.lua脚本进行限流。

getToken_access_limit.lua脚本和rate_limiter.lua脚本的关系如图10-17所示。

什么时候在Redis中加载rate_limiter.lua脚本呢？和秒杀脚本一样，该脚本是在Java程序启动商品秒杀时完成其在Redis的加载和缓存的。还有一点非常重要，Java程序会将脚本加载完成之后的sha1编码通过自定义的key（具体为lua：sha1：rate_limiter）缓存在Redis中，以方便Nginx的getToken_access_limit.lua脚本获取，并且在调用evalsha方法时使用。

getToken_access_limit.lua脚本的代码如下：

此脚本的环境
内部
不是运行在
内部---此脚本的环境：Nginx内部，不是运行在Redis内部
---启动调试
--local mobdebug = require("luaScript.initial.mobdebug");
--mobdebug.start();
--导入自定义的基础模块
--local basic = require("luaScript.module.common.basic");
--导入自定义的RedisOperator模块
local redisExecutor = require("luaScript.redis.RedisOperator");
--读取post参数
ngx.req.read_body();
local data = ngx.req.get_body_data(); --获取消息体
local args = cjson.decode(data);
local goodId = args["seckillGoodId"];
local userId = args["userId"];
local errorOut = { resp_code = -1, resp_msg = "限流出错", datas = {} };
local key="rate_limiter:seckill:"..goodId;
local rateLimiterSha = nil;
--创建自定义的Redis操作对象
local red = redisExecutor:new();
--打开连接
red:open();
--获取限流Lua脚本的sha1编码
rateLimiterSha=red:getValue("lua:sha1:rate_limiter");
--Redis没有缓存秒杀脚本
if not rateLimiterSha or rateLimiterSha == ngx.null then
 errorOut.resp_msg="秒杀还未启动，请先设置商品";
 ngx.say(cjson.encode(errorOut));
 --归还连接到连接池
 red:close();
 return ;
end
local connection=red:getConnection();
--执行令牌桶限流
local resp, err = connection:evalsha(rateLimiterSha, 1,key,"acquire","1");
--归还连接到连接池
red:close();
if not resp or resp == ngx.null then
 errorOut.resp_msg=err;
 ngx.say(cjson.encode(errorOut));
 return ;
end
local flag = tonumber(resp);
--ngx.say("flag="..flag);
if flag ~= 1 then
 errorOut.resp_msg = "抱歉，被限流了";
 ngx.say(cjson.encode(errorOut));
 ngx.exit(ngx.HTTP_UNAUTHORIZED);
end
return;

细心的读者可能会发现，本文的Nginx+Lua秒杀架构缺少了用户JWT认证环节，主要的原因是作为高性能学习教程的秒杀案例，用户认证已经不是重点。目前已经有非常成熟的开源插件完成Nginx上的JWT认证，如果对此感兴趣，建议自行在OpenResty上安装jwt-lua插件，尝试用户的认证过程。

本文给大家讲解的内容是高并发核心编程，Spring Cloud+Nginx秒杀实战，Nginx高性能秒杀和限流

1. 觉得文章不错的朋友可以转发此文关注小编；
2. 感谢大家的支持！