使用ngx_lua构建高并发应用

1. Memcached

在Nginx中访问Memcached需要模块的支持，这里选用HttpMemcModule，这个模块可以与后端的Memcached进行非阻塞的通信。我们知道官方提供了Memcached，这个模块只支持get操作，而Memc支持大部分Memcached的命令。

Memc模块采用入口变量作为参数进行传递，所有以$memc_为前缀的变量都是Memc的入口变量。memc_pass指向后端的Memcached Server。

配置：

[plain] view plaincopyprint?

1. #使用HttpMemcModule
2. location = /memc {
3. set $memc_cmd $arg_cmd;
4. set $memc_key $arg_key;
5. set $memc_value $arg_val;
6. set $memc_exptime $arg_exptime;
8. memc_pass '127.0.0.1:11211';
9. }

输出：

[plain] view plaincopyprint?

1. $ curl 'http://localhost/memc?cmd=set&key=foo&val=Hello'
2. $ STORED
3. $ curl 'http://localhost/memc?cmd=get&key=foo'
4. $ Hello

配置：

[plain] view plaincopyprint?

1. #在Lua中访问Memcached
2. location = /memc {
3. internal; #只能内部访问
4. set $memc_cmd get;
5. set $memc_key $arg_key;
6. memc_pass '127.0.0.1:11211';
7. }
8. location = /lua_memc {
9. content_by_lua '
10. local res = ngx.location.capture("/memc", {
11. args = { key = ngx.var.arg_key }
12. })
13. if res.status == 200 then
14. ngx.say(res.body)
15. end
16. ';
17. }

[plain] view plaincopyprint?

1. $ curl 'http://localhost/lua_memc?key=foo'
2. $ Hello

2. Redis

访问redis需要HttpRedis2Module的支持，它也可以同redis进行非阻塞通行。不过，redis2的响应是redis的原生响应，所以在lua中使用时，需要解析这个响应。可以采用LuaRedisModule，这个模块可以构建redis的原生请求，并解析redis的原生响应。

配置：

[plain] view plaincopyprint?

1. #在Lua中访问Redis
2. location = /redis {
3. internal; #只能内部访问
4. redis2_query get $arg_key;
5. redis2_pass '127.0.0.1:6379';
6. }
7. location = /lua_redis { #需要LuaRedisParser
8. content_by_lua '
9. local parser = require("redis.parser")
10. local res = ngx.location.capture("/redis", {
11. args = { key = ngx.var.arg_key }
12. })
13. if res.status == 200 then
14. reply = parser.parse_reply(res.body)
15. ngx.say(reply)
16. end
17. ';
18. }

[plain] view plaincopyprint?

1. $ curl 'http://localhost/lua_redis?key=foo'
2. $ Hello

3. Redis Pipeline

幸好redis提供pipeline机制，可以在一次连接中执行多个命令，这样可以减少多次执行命令的往返时延。客户端在通过pipeline发送多个命令后，redis顺序接收这些命令并执行，然后按照顺序把命令的结果输出出去。在lua中使用pipeline需要用到redis2模块的redis2_raw_queries进行redis的原生请求查询。

配置：

[plain] view plaincopyprint?

1. #在Lua中访问Redis
2. location = /redis {
3. internal; #只能内部访问
5. redis2_raw_queries $args $echo_request_body;
6. redis2_pass '127.0.0.1:6379';
7. }
9. location = /pipeline {
10. content_by_lua 'conf/pipeline.lua';
11. }

[plain] view plaincopyprint?

1. -- conf/pipeline.lua file
2. local parser = require(‘redis.parser’)
3. local reqs = {
4. {‘get’, ‘one’}, {‘get’, ‘two’}
5. }
6. -- 构造原生的redis查询，get one\r\nget two\r\n
7. local raw_reqs = {}
8. for i, req in ipairs(reqs) do
9. table.insert(raw_reqs, parser.build_query(req))
10. end
11. local res = ngx.location.capture(‘/redis?’..#reqs, { body = table.concat(raw_reqs, ‘’) })
13. if res.status and res.body then
14. -- 解析redis的原生响应
15. local replies = parser.parse_replies(res.body, #reqs)
16. for i, reply in ipairs(replies) do
17. ngx.say(reply[1])
18. end
19. end

[plain] view plaincopyprint?

1. $ curl 'http://localhost/pipeline'
2. $ first
3. second

4. Connection Pool

前面访问redis和memcached的例子中，在每次处理一个请求时，都会和后端的server建立连接，然后在请求处理完之后这个连接就会被释放。这个过程中，会有3次握手、timewait等一些开销，这对于高并发的应用是不可容忍的。这里引入connection pool来消除这个开销。

连接池需要HttpUpstreamKeepaliveModule模块的支持。

配置：

[plain] view plaincopyprint?

1. http {
2. # 需要HttpUpstreamKeepaliveModule
3. upstream redis_pool {
4. server 127.0.0.1:6379;
5. # 可以容纳1024个连接的连接池
6. keepalive 1024 single;
7. }
9. server {
10. location = /redis {
11. …
12. redis2_pass redis_pool;
13. }
14. }
15. }

有人曾经测过，在没有使用连接池的情况下，访问memcached（使用之前的Memc模块），rps为20000。在使用连接池之后，rps一路飙到140000。在实际情况下，这么大的提升可能达不到，但是基本上100-200%的提高还是可以的。

5. 小结

这里对memcached、redis的访问做个小结。

1. Nginx提供了强大的编程模型，location相当于函数，子请求相当于函数调用，并且location还可以向自己发送子请求，这样构成一个递归的模型，所以采用这种模型实现复杂的业务逻辑。

2. Nginx的IO操作必须是非阻塞的，如果Nginx在那阻着，则会大大降低Nginx的性能。所以在Lua中必须通过ngx.location.capture发出子请求将这些IO操作委托给Nginx的事件模型。

3. 在需要使用tcp连接时，尽量使用连接池。这样可以消除大量的建立、释放连接的开销。

以上就介绍了使用ngx_lua构建高并发应用，包括了方面的内容，希望对PHP教程有兴趣的朋友有所帮助。