Nginx技术研究系列5-动态路由升级版

前几篇文章咱们介绍了Nginx的配置、OpenResty安装配置、基于Redis的动态路由以及Nginx的监控。

Nginx-OpenResty安装配置

Nginx配置详解

Nginx技术研究系列1-经过应用场景看Nginx的反向代理

Nginx技术研究系列2-基于Redis实现动态路由

[原创]Nginx监控-Nginx+Telegraf+Influxb+Grafana

在分布式环境下，咱们要考虑高可用性和性能：

1. 不能由于Redis宕机影响请求的反向代理

2. 每次请求若是都访问Redis，性能有必定的损耗，同时Redis集群的压力随着流量的激增不断增长。

所以，咱们要升级一下动态路由的设计方案。 咱们仍是先从应用场景出发：

1.提高性能，下降Redis的访问频率

2.Redis宕机不影响Nginx反向代理

实现上述两个应用场景，咱们采用本地缓存+Redis缓存的双缓存配合机制。

• 第一次请求时，从Redis中获取路由地址，而后放到本地缓存中，同时设置本地缓存项的有效时间
• 后续请求时，从本地缓存直接获取路由地址，若是本地缓存已经失效，则再次从Redis获取路由地址，再放到本地缓存中。

肯定了上述实现方案后，咱们回顾一下咱们已有的Redis动态路由实现：

        upstream redis_cluster {
            server 192.0.1.*:6379;
            server 192.0.1.*:6379;
            server 192.0.1.*:6379;
        }

        location = /redis {
            internal;
            set_unescape_uri $key $arg_key;
            redis2_query get $key;
            redis2_pass redis_cluster;
        }

        location / {
            set $target '';
            access_by_lua '
                local query_string = ngx.req.get_uri_args()
                local sid = query_string["RequestID"]
                if sid == nil then
                    ngx.exit(ngx.HTTP_FORBIDDEN)
                end

                local key = sid
                local res = ngx.location.capture(
                    "/redis", { args = { key = key } }
                )

                if res.status ~= 200 then
                    ngx.log(ngx.ERR, "redis server returned bad status: ",
                        res.status)
                    ngx.exit(res.status)
                end

                if not res.body then
                    ngx.log(ngx.ERR, "redis returned empty body")
                    ngx.exit(500)
                end

                local parser = require "redis.parser"
                local server, typ = parser.parse_reply(res.body)
                if typ ~= parser.BULK_REPLY or not server then
                    ngx.log(ngx.ERR, "bad redis response: ", res.body)
                    ngx.exit(500)
                end

                if server == "" then
                    server = "default"
                end

                server = server .. ngx.var.request_uri
                ngx.var.target = server
            ';
                resolver 255.255.255.0;
                proxy_pass http://$target;
         }

咱们要在上述代码中增长一层本地缓存实现，所以，咱们须要找一个本地缓存的实现Lib。

咱们在OpenResty的官网上找了一遍已提供的组件，发现了：lua-resty-lrucache - Lua-land LRU Cache based on LuaJIT FFI

Git Hub的地址：https://github.com/openresty/lua-resty-lrucache

尝试写了一下，发现这个cache实现是worker进程级别的，咱们Nginx是Auto的进程数配置，通常有4~8个，这个缓存每一个进程都New一个，貌似不符合咱们的要求，同时，这个cache是预分配好缓存的大小和数量，启动的时候若是数量太多，分配内存很慢。

测试了一下，果然是这样，所以，咱们继续查找新的Cache实现。

ngx.shared.DICT，https://github.com/openresty/lua-nginx-module#ngxshareddict

这个 cache 是 nginx 全部 worker 之间共享的，内部使用的 LRU 算法（最近常常使用）来判断缓存是否在内存占满时被清除。同时提供了以下方法：

而后，咱们基于这个组件实现了咱们升级版的Redis动态路由，直接上代码Show：

        upstream redis_cluster {
            server 192.0.1.*:6379;
            server 192.0.1.*:6379;
            server 192.0.1.*:6379;
        }

 lua_shared_dict localcache 10m;——

        location = /redis {
            internal;
            set_unescape_uri $key $arg_key;
            redis2_query get $key;
            redis2_pass redis_cluster;
        }

        location / {
            set $target '';
            access_by_lua '
                local query_string = ngx.req.get_uri_args()
                local sid = query_string["RequestID"]
                if sid == nil then
                   ngx.exit(ngx.HTTP_FORBIDDEN)
                end

                local key = sid local cache = ngx.shared.localcache local server = cache:get(key) if server == nil then
                  local res = ngx.location.capture(
                    "/redis", { args = { key = key } }
                  )

                  if res.status ~= 200 then
                    ngx.log(ngx.ERR, "redis server returned bad status: ",
                        res.status)
                    ngx.exit(res.status)
                  end

                  if not res.body then
                    ngx.log(ngx.ERR, "redis returned empty body")
                    ngx.exit(500)
                  end

                  local parser = require "redis.parser"
                  local serveradr, typ = parser.parse_reply(res.body)

                  if typ ~= parser.BULK_REPLY or not serveradr then
                    ngx.log(ngx.ERR, "bad redis response: ", res.body)
                    ngx.exit(500)
                  end

                  server = serveradr cache:set(key, server,3600)                 end

                if server == "" then
                    server = "default"
                end

                server = server .. ngx.var.request_uri
                ngx.var.target = server
            ';

                resolver 255.255.255.0;
                proxy_pass http://$target;
         }
     }

 重点说一下上面的代码：

 首先，定义了一个本地缓存：

lua_shared_dict localcache 10m;

 而后，从本地缓存中获取路由地址

local cache = ngx.shared.localcache
local server = cache:get(key)

若是本地缓存中没有，从Redis中获取，从Redis中获取到以后，加入到本地缓存中，缓存有效时间3600s：

server = serveradr
cache:set(key, server, 3600)

升级后的Redis+本地缓存的动态路由方案，压测性能提高1.4倍，同时解决了Redis宕机的问题。
以上这个方案和实现都分享给你们。

 

周国庆

2017/11/13