Build high-concurrency applications with Ngx_lua

This article focuses on how to Ngx_lua non-blocking communication with memcached and Redis on the backend.

1. Memcached

Access to the memcached in Nginx requires the support of the module, where Httpmemcmodule, which can be used with the back-end memcached for non-blocking communication. We know that the memcached is officially available, this module only supports get operations, and MEMC supports most memcached commands.

The MEMC module is passed as an entry variable as a parameter, and all variables prefixed with $MEMC_ are MEMC entry variables. Memc_pass points to the back-end of memcached Server.

Configuration:

[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. }

Output:

[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

This enables memcached access, and below is a look at how to access memcached in Lua.

Configuration:

[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 = =
14. Ngx.say (Res.body)
15. End
16. ';
17. }

Output:

[Plain] View plaincopyprint?

1. $ Curl ' Http://localhost/lua_memc?key=foo '
2. $ Hello

access to memcached through Lua is achieved primarily through the use of a similar function call in a child request. First, a MEMC location is defined for communication over the backend memcached, which is equivalent to memcached storage. Because the entire MEMC module is non-blocking, the ngx.location.capture is also non-blocking, so the entire operation is non-blocking.

2. Redis

Access to Redis requires httpredis2module support, and it can also be non-blocking with Redis. However, the response of Redis2 is the native response of Redis, so when used in Lua, this response needs to be resolved. The luaredismodule can be used to build the native request of Redis and resolve the native response of Redis.

Configuration:

[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 = =
14. Reply = parser.parse_reply (res.body)
15. Ngx.say (Reply)
16. End
17. ';
18. }

Output:

[Plain] View plaincopyprint?

1. $ Curl ' Http://localhost/lua_redis?key=foo '
2. $ Hello

similar to accessing memcached, you need to provide a Redis storage dedicated to querying Redis, and then calling Redis through child requests.

3. Redis Pipeline

when you actually access Redis, it is possible to query multiple keys at the same time. We can take ngx.location.capture_multi by sending multiple sub-requests to redis storage, and then parsing the response content. However, there is a limitation that the Nginx kernel specifies that no more than 50 child requests can be initiated at a time, so this scheme is no longer applicable when the number of keys is more than 50 o'clock.

Fortunately, Redis provides the pipeline mechanism to execute multiple commands in a single connection, which reduces the round-trip delay of executing commands multiple times. After the client sends multiple commands through pipeline, Redis sequentially receives the commands and executes them, then prints out the results of the command in order. Using pipeline in Lua requires a native request query for Redis using the redis2_raw_queries of the Redis2 module.

Configuration:

[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. }

Pipeline.lua

[Plain] View plaincopyprint?

2. --Conf/pipeline.lua file
4. Local parser = require (' Redis.parser ')
6. Local reqs = {
8. {' Get ', ' one '}, {' Get ', ' one '}
10. }
12. --Constructs native Redis query, get one\r\nget two\r\n
14. Local raw_reqs = {}
16. For I, req in Ipairs (reqs) do
18. Table.insert (Raw_reqs, Parser.build_query (req))
20. End
22. Local res = Ngx.location.capture ('/redis? '). #reqs, {BODY = Table.concat (Raw_reqs, ')})
26. If Res.status and Res.body then
28. --parsing the native response of Redis
30. Local replies = Parser.parse_replies (Res.body, #reqs)
32. For I, reply in Ipairs (replies) do
34. Ngx.say (Reply[1])
36. End
38. End

Output:

[Plain] View plaincopyprint?

1. $ Curl ' http://localhost/pipeline '
2. $ first
3. Second

4. Connection Pool

In the previous example of accessing Redis and memcached, each time a request is processed, a connection is established with the backend server and then the connection is freed after the request is processed. In this process, there will be 3 handshake, timewait and other overhead, which is not tolerated for high concurrency applications. The connection pool is introduced here to eliminate this overhead.

Connection pooling requires the support of the Httpupstreamkeepalivemodule module.

Configuration:

[Plain] View plaincopyprint?

1. HTTP {
2. # need Httpupstreamkeepalivemodule
3. Upstream Redis_pool {
4. Server 127.0.0.1:6379;
5. # can accommodate 1024 connected pools
6. KeepAlive;
7. }
9. server {
10. Location =/redis {
11. ...
12. Redis2_pass Redis_pool;
13. }
14. }
15. }

This module provides the keepalive instruction, and its context is upstream. We know that upstream use Nginx to do reverse proxy, the actual upstream refers to "upstream", this "upstream" can be Redis, memcached or MySQL and other servers. Upstream can define a virtual server cluster, and these backend servers can enjoy load balancing. KeepAlive 1024 defines the size of the connection pool, and when the number of connections exceeds this size, subsequent connections are automatically degraded to short connections. The use of connection pooling is simple, just replace the original IP and port number.

It has been measured that, in the absence of a connection pool, access to memcached (using the previous MEMC module), RPS is 20000. After using the connection pool, RPS went all the way to 140000. In fact, such a large increase may not be achieved, but basically 100-200% improvement is still possible.

5. Summary

Here's a summary of the memcached and Redis visits.

1. Nginx provides a powerful programming model, location equivalent function, sub-request equivalent function call, and location can also send themselves sub-request, so as to form a recursive model, so adopt this model to implement complex business logic.

2. Nginx IO operation must be non-blocking, if the nginx blocking, it will greatly reduce the performance of Nginx. Therefore, in Lua it is necessary to send these IO operations to the Nginx event model through Ngx.location.capture.

3. Use connection pooling whenever possible when you need to use a TCP connection. This eliminates the overhead of creating and releasing connections in large numbers.

The above describes the use of Ngx_lua to build high-concurrency applications, including aspects of the content, I hope that the PHP tutorial interested in a friend helpful.

