ngx_http_lua_module - Embed the power of Lua into Nginx HTTP Servers.

This module is a core component of [https://openresty.org OpenResty]. If you are using this module,

then you are essentially using OpenResty.

''This module is not distributed with the Nginx source.'' See

[[#Installation|the installation instructions]].

Production ready.

This document describes ngx_lua

[https://github.com/openresty/lua-nginx-module/tags v0.10.16], which is not

released yet.

<geshi lang="nginx">

# set search paths for pure Lua external libraries (';;' is the default path):

lua_package_path '/foo/bar/?.lua;/blah/?.lua;;';

</geshi>

This module embeds [https://luajit.org/luajit.html LuaJIT 2.0/2.1] into Nginx.

It is a core component of [https://openresty.org OpenResty]. If you are using

this module, then you are essentially using OpenResty.

Since version <code>v0.10.16</code> of this module, the standard Lua

interpreter (also known as "PUC-Rio Lua") is not supported anymore. This

document interchangeably uses the terms "Lua" and "LuaJIT" to refer to the

LuaJIT interpreter.

By leveraging Nginx's subrequests, this module allows the integration of the

powerful Lua threads (known as Lua "coroutines") into the Nginx event model.

Unlike [https://httpd.apache.org/docs/trunk/mod/mod_lua.html Apache's mod_lua]

and [http://redmine.lighttpd.net/wiki/1/Docs:ModMagnet Lighttpd's mod_magnet],

Lua code executed using this module can be ''100% non-blocking'' on network

traffic as long as the [[#Nginx API for Lua|Nginx API for Lua]] provided by

this module is used to handle requests to upstream services such as MySQL,

PostgreSQL, Memcached, Redis, or upstream HTTP web services.

At least the following Lua libraries and Nginx modules can be used with this

module:

Almost any Nginx modules can be used with this ngx_lua module by means of

[[#ngx.location.capture|ngx.location.capture]] or

[[#ngx.location.capture_multi|ngx.location.capture_multi]] but it is

recommended to use those <code>lua-resty-*</code> libraries instead of creating

subrequests to access the Nginx upstream modules because the former is usually

much more flexible and memory-efficient.

The Lua interpreter (also known as "Lua State" or "LuaJIT VM instance") is

shared across all the requests in a single Nginx worker process to minimize

memory use. Request contexts are segregated using lightweight Lua coroutines.

Loaded Lua modules persist in the Nginx worker process level resulting in a

small memory footprint in Lua even when under heavy loads.

This module is plugged into Nginx's "http" subsystem so it can only speaks

downstream communication protocols in the HTTP family (HTTP 0.9/1.0/1.1/2.0,

WebSockets, etc...). If you want to do generic TCP communications with the

downstream clients, then you should use the

[https://github.com/openresty/stream-lua-nginx-module#readme ngx_stream_lua]

module instead, which offers a compatible Lua API.

Just to name a few:

The possibilities are unlimited as the module allows bringing together various

elements within Nginx as well as exposing the power of the Lua language to the

user. The module provides the full flexibility of scripting while offering

performance levels comparable with native C language programs both in terms of

CPU time as well as memory footprint thanks to LuaJIT 2.x.

Other scripting language implementations typically struggle to match this

performance level.

The latest version of this module is compatible with the following versions of Nginx:

Nginx cores older than 1.6.0 (exclusive) are *not* supported.

It is *highly* recommended to use [https://openresty.org OpenResty releases]

which bundle Nginx, ngx_lua (this module), LuaJIT, as well as other powerful

companion Nginx modules and Lua libraries.

It is discouraged to build this module with Nginx yourself since it is tricky

to set up exactly right.

Note that Nginx, LuaJIT, and OpenSSL official releases have various limitations

and long standing bugs that can cause some of this module's features to be

disabled, not work properly, or run slower. Official OpenResty releases are

recommended because they bundle [https://github.com/openresty/luajit2

OpenResty's optimized LuaJIT 2.1 fork] and

[https://github.com/openresty/openresty/tree/master/patches Nginx/OpenSSL

patches].

Alternatively, ngx_lua can be manually compiled into Nginx:

Build the source with this module:

<geshi lang="bash">

wget 'https://nginx.org/download/nginx-1.13.6.tar.gz'

tar -xzvf nginx-1.13.6.tar.gz

cd nginx-1.13.6/

</geshi>

Starting from NGINX 1.9.11, you can also compile this module as a dynamic module, by using the <code>--add-dynamic-module=PATH</code> option instead of <code>--add-module=PATH</code> on the

<code>./configure</code> command line above. And then you can explicitly load the module in your <code>nginx.conf</code> via the [load_module](https://nginx.org/en/docs/ngx_core_module.html#load_module)

directive, for example,

<geshi lang="nginx">

load_module /path/to/modules/ndk_http_module.so; # assuming NDK is built as a dynamic module too

load_module /path/to/modules/ngx_http_lua_module.so;

</geshi>

While building this module either via OpenResty or with the Nginx core, you can define the following C macros via the C compiler options:

To enable one or more of these macros, just pass extra C compiler options to the <code>./configure</code> script of either Nginx or OpenResty. For instance,

<geshi>

./configure --with-cc-opt="-DNGX_LUA_USE_ASSERT -DNGX_LUA_ABORT_AT_PANIC"

</geshi>

The [https://groups.google.com/group/openresty-en openresty-en] mailing list is for English speakers.

The [https://groups.google.com/group/openresty openresty] mailing list is for Chinese speakers.

The code repository of this project is hosted on GitHub at

[https://github.com/openresty/lua-nginx-module openresty/lua-nginx-module].

Please submit bug reports, wishlists, or patches by

As from the <code>v0.5.0rc32</code> release, all <code>*_by_lua_file</code> configure directives (such as [[#content_by_lua_file|content_by_lua_file]]) support loading LuaJIT 2.0/2.1 raw bytecode files directly:

<geshi lang="bash">

/path/to/luajit/bin/luajit -b /path/to/input_file.lua /path/to/output_file.ljbc

</geshi>

The <code>-bg</code> option can be used to include debug information in the LuaJIT bytecode file:

<geshi lang="bash">

/path/to/luajit/bin/luajit -bg /path/to/input_file.lua /path/to/output_file.ljbc

</geshi>

Please refer to the official LuaJIT documentation on the <code>-b</code> option for more details:

https://luajit.org/running.html#opt_b

Note that the bytecode files generated by LuaJIT 2.1 is ''not'' compatible with

LuaJIT 2.0, and vice versa. The support for LuaJIT 2.1 bytecode was first added

in ngx_lua v0.9.3.

Attempts to load standard Lua 5.1 bytecode files into ngx_lua instances linked

to LuaJIT 2.0/2.1 (or vice versa) will result in an Nginx error message such as

the one below:

<geshi lang="text">

[error] 13909#0: *1 failed to load Lua inlined code: bad byte-code header in /path/to/test_file.luac

</geshi>

Loading bytecode files via the Lua primitives like <code>require</code> and

<code>dofile</code> should always work as expected.

If you want to access the system environment variable, say, <code>foo</code>, in Lua via the standard Lua API [https://www.lua.org/manual/5.1/manual.html#pdf-os.getenv os.getenv], then you should also list this environment variable name in your <code>nginx.conf</code> file via the [https://nginx.org/en/docs/ngx_core_module.html#env env directive]. For example,

<geshi lang="nginx">

env foo;

</geshi>

The HTTP 1.0 protocol does not support chunked output and requires an explicit <code>Content-Length</code> header when the response body is not empty in order to support the HTTP 1.0 keep-alive.

So when a HTTP 1.0 request is made and the [[#lua_http10_buffering|lua_http10_buffering]] directive is turned <code>on</code>, ngx_lua will buffer the

output of [[#ngx.say|ngx.say]] and [[#ngx.print|ngx.print]] calls and also postpone sending response headers until all the response body output is received.

At that time ngx_lua can calculate the total length of the body and construct a proper <code>Content-Length</code> header to return to the HTTP 1.0 client.

If the <code>Content-Length</code> response header is set in the running Lua code, however, this buffering will be disabled even if the [[#lua_http10_buffering|lua_http10_buffering]] directive is turned <code>on</code>.

For large streaming output responses, it is important to disable the [[#lua_http10_buffering|lua_http10_buffering]] directive to minimise memory usage.

Note that common HTTP benchmark tools such as <code>ab</code> and <code>http_load</code> issue HTTP 1.0 requests by default.

To force <code>curl</code> to send HTTP 1.0 requests, use the <code>-0</code> option.

With LuaJIT 2.x, it is possible to statically link the bytecode of pure Lua

modules into the Nginx executable.

You can use the <code>luajit</code> executable to compile <code>.lua</code> Lua

module files to <code>.o</code> object files containing the exported bytecode

data, and then link the <code>.o</code> files directly in your Nginx build.

Below is a trivial example to demonstrate this. Consider that we have the following <code>.lua</code> file named <code>foo.lua</code>:

<geshi lang="lua">

-- foo.lua

local _M = {}

</geshi>

And then we compile this <code>.lua</code> file to <code>foo.o</code> file:

<geshi lang="bash">

/path/to/luajit/bin/luajit -bg foo.lua foo.o

</geshi>

What matters here is the name of the <code>.lua</code> file, which determines how you use this module later on the Lua land. The file name <code>foo.o</code> does not matter at all except the <code>.o</code> file extension (which tells <code>luajit</code> what output format is used). If you want to strip the Lua debug information from the resulting bytecode, you can just specify the <code>-b</code> option above instead of <code>-bg</code>.

Then when building Nginx or OpenResty, pass the <code>--with-ld-opt="foo.o"</code> option to the <code>./configure</code> script:

<geshi lang="bash">

./configure --with-ld-opt="/path/to/foo.o" ...

</geshi>

Finally, you can just do the following in any Lua code run by ngx_lua:

<geshi lang="lua">

local foo = require "foo"

foo.go()

</geshi>

And this piece of code no longer depends on the external <code>foo.lua</code> file any more because it has already been compiled into the <code>nginx</code> executable.

If you want to use dot in the Lua module name when calling <code>require</code>, as in

<geshi lang="lua">

local foo = require "resty.foo"

</geshi>

then you need to rename the <code>foo.lua</code> file to <code>resty_foo.lua</code> before compiling it down to a <code>.o</code> file with the <code>luajit</code> command-line utility.

It is important to use exactly the same version of LuaJIT when compiling <code>.lua</code> files to <code>.o</code> files as building nginx + ngx_lua. This is because the LuaJIT bytecode format may be incompatible between different LuaJIT versions. When the bytecode format is incompatible, you will see a Lua runtime error saying that the Lua module is not found.

When you have multiple <code>.lua</code> files to compile and link, then just specify their <code>.o</code> files at the same time in the value of the <code>--with-ld-opt</code> option. For instance,

<geshi lang="bash">

./configure --with-ld-opt="/path/to/foo.o /path/to/bar.o" ...

</geshi>

If you have too many <code>.o</code> files, then it might not be feasible to name them all in a single command. In this case, you can build a static library (or archive) for your <code>.o</code> files, as in

<geshi lang="bash">

ar rcus libmyluafiles.a *.o

</geshi>

then you can link the <code>myluafiles</code> archive as a whole to your nginx executable:

<geshi lang="bash">

./configure \

--with-ld-opt="-L/path/to/lib -Wl,--whole-archive -lmyluafiles -Wl,--no-whole-archive"

</geshi>

where <code>/path/to/lib</code> is the path of the directory containing the <code>libmyluafiles.a</code> file. It should be noted that the linker option <code>--whole-archive</code> is required here because otherwise our archive will be skipped because no symbols in our archive are mentioned in the main parts of the nginx executable.

To globally share data among all the requests handled by the same Nginx worker

process, encapsulate the shared data into a Lua module, use the Lua

<code>require</code> builtin to import the module, and then manipulate the

shared data in Lua. This works because required Lua modules are loaded only

once and all coroutines will share the same copy of the module (both its code

and data).

Note that the use of global Lua variables is *strongly discouraged*, as it may

lead to unexpected race conditions between concurrent requests.

Here is a small example on sharing data within an Nginx worker via a Lua module:

<geshi lang="lua">

-- mydata.lua

local _M = {}

</geshi>

and then accessing it from <code>nginx.conf</code>:

<geshi lang="nginx">

location /lua {

content_by_lua_block {

local mydata = require "mydata"

ngx.say(mydata.get_age("dog"))

}

}

</geshi>

The <code>mydata</code> module in this example will only be loaded and run on the first request to the location <code>/lua</code>,

and all subsequent requests to the same Nginx worker process will use the reloaded instance of the

module as well as the same copy of the data in it, until a <code>HUP</code> signal is sent to the Nginx master process to force a reload.

This data sharing technique is essential for high performance Lua applications based on this module.

Note that this data sharing is on a ''per-worker'' basis and not on a ''per-server'' basis. That is, when there are multiple Nginx worker processes under an Nginx master, data sharing cannot cross the process boundary between these workers.

It is usually recommended to share read-only data this way. You can also share changeable data among all the concurrent requests of each Nginx worker process as

long as there is ''no'' nonblocking I/O operations (including [[#ngx.sleep|ngx.sleep]])

in the middle of your calculations. As long as you do not give the

control back to the Nginx event loop and ngx_lua's light thread

scheduler (even implicitly), there can never be any race conditions in

between. For this reason, always be very careful when you want to share changeable data on the

worker level. Buggy optimizations can easily lead to hard-to-debug

race conditions under load.

If server-wide data sharing is required, then use one or more of the following approaches:

The [[#tcpsock:connect|tcpsock:connect]] method may indicate <code>success</code> despite connection failures such as with <code>Connection Refused</code> errors.

However, later attempts to manipulate the cosocket object will fail and return the actual error status message generated by the failed connect operation.

This issue is due to limitations in the Nginx event model and only appears to affect Mac OS X.

Care must be taken when importing modules, and this form should be used:

<geshi lang="lua">

local xxx = require('xxx')

</geshi>

instead of the old deprecated form:

<geshi lang="lua">

require('xxx')

</geshi>

Here is the reason: by design, the global environment has exactly the same lifetime as the Nginx request handler associated with it. Each request handler has its own set of Lua global variables and that is the idea of request isolation. The Lua module is actually loaded by the first Nginx request handler and is cached by the <code>require()</code> built-in in the <code>package.loaded</code> table for later reference, and the <code>module()</code> builtin used by some Lua modules has the side effect of setting a global variable to the loaded module table. But this global variable will be cleared at the end of the request handler, and every subsequent request handler all has its own (clean) global environment. So one will get Lua exception for accessing the <code>nil</code> value.

The use of Lua global variables is a generally inadvisable in the ngx_lua context as:

It is therefore *highly* recommended to always declare such within an appropriate local scope instead.

<geshi lang="lua">

-- Avoid

foo = 123

-- Recommended

local foo = 123

</geshi>

To find all instances of Lua global variables in your Lua code, run the [https://github.com/openresty/nginx-devel-utils/blob/master/lua-releng lua-releng tool] across all <code>.lua</code> source files:

<geshi lang="text">

$ lua-releng

Checking use of Lua global variables in file lib/foo/bar.lua ...

1 [1489] SETGLOBAL 7 -1 ; contains

55 [1506] GETGLOBAL 7 -3 ; setvar

3 [1545] GETGLOBAL 3 -4 ; varexpand

</geshi>

The output says that the line 1489 of file <code>lib/foo/bar.lua</code> writes to a global variable named <code>contains</code>, the line 1506 reads from the global variable <code>setvar</code>, and line 1545 reads the global <code>varexpand</code>.

This tool will guarantee that local variables in the Lua module functions are all declared with the <code>local</code> keyword, otherwise a runtime exception will be thrown. It prevents undesirable race conditions while accessing such variables. See [[#Data_Sharing_within_an_Nginx_Worker|Data Sharing within an Nginx Worker]] for the reasons behind this.

The [[#ngx.location.capture|ngx.location.capture]] and [[#ngx.location.capture_multi|ngx.location.capture_multi]] directives cannot capture locations that include the [[HttpAdditionModule#add_before_body|add_before_body]], [[HttpAdditionModule#add_after_body|add_after_body]], [https://nginx.org/en/docs/http/ngx_http_auth_request_module.html#auth_request auth_request], [[HttpEchoModule#echo_location|echo_location]], [[HttpEchoModule#echo_location_async|echo_location_async]], [[HttpEchoModule#echo_subrequest|echo_subrequest]], or [[HttpEchoModule#echo_subrequest_async|echo_subrequest_async]] directives.

<geshi lang="nginx">

location /foo {

content_by_lua_block {

res = ngx.location.capture("/bar")

}

}

location /bar {

echo_location /blah;

}

location /blah {

echo "Success!";

}

</geshi>

<geshi lang="nginx">

$ curl -i http://example.com/foo

</geshi>

will not work as expected.

Due to internal limitations in the Nginx core, the cosocket API is disabled in the following contexts: [[#set_by_lua|set_by_lua*]], [[#log_by_lua|log_by_lua*]], [[#header_filter_by_lua|header_filter_by_lua*]], and [[#body_filter_by_lua|body_filter_by_lua]].

The cosockets are currently also disabled in the [[#init_by_lua|init_by_lua*]] and [[#init_worker_by_lua|init_worker_by_lua*]] directive contexts but we may add support for these contexts in the future because there is no limitation in the Nginx core (or the limitation might be worked around).

There exists a workaround, however, when the original context does *not* need to wait for the cosocket results. That is, creating a zero-delay timer via the [[#ngx.timer.at|ngx.timer.at]] API and do the cosocket results in the timer handler, which runs asynchronously as to the original context creating the timer.

'''NOTE''' Following the <code>v0.9.17</code> release, this pitfall can be avoided by using the <code>*_by_lua_block {}</code> configuration directives.

PCRE sequences such as <code>\d</code>, <code>\s</code>, or <code>\w</code>, require special attention because in string literals, the backslash character, <code>\</code>, is stripped out by both the Lua language parser and by the Nginx config file parser before processing if not within a <code>*_by_lua_block {}</code> directive. So the following snippet will not work as expected:

<geshi lang="nginx">

# nginx.conf

? location /test {

? content_by_lua '

? local regex = "\d+" -- THIS IS WRONG OUTSIDE OF A *_by_lua_block DIRECTIVE

? local m = ngx.re.match("hello, 1234", regex)

? if m then ngx.say(m[0]) else ngx.say("not matched!") end

? ';

? }

# evaluates to "not matched!"

</geshi>

To avoid this, ''double'' escape the backslash:

<geshi lang="nginx">

# nginx.conf

location /test {

content_by_lua '

local regex = "\\\\d+"

local m = ngx.re.match("hello, 1234", regex)

if m then ngx.say(m[0]) else ngx.say("not matched!") end

';

}

# evaluates to "1234"

</geshi>

Here, <code>\\\\d+</code> is stripped down to <code>\\d+</code> by the Nginx config file parser and this is further stripped down to <code>\d+</code> by the Lua language parser before running.

Alternatively, the regex pattern can be presented as a long-bracketed Lua string literal by encasing it in "long brackets", <code>&#91;[...]]</code>, in which case backslashes have to only be escaped once for the Nginx config file parser.

<geshi lang="nginx">

# nginx.conf

location /test {

content_by_lua '

local regex = [[\\d+]]

local m = ngx.re.match("hello, 1234", regex)

if m then ngx.say(m[0]) else ngx.say("not matched!") end

';

}

# evaluates to "1234"

</geshi>

Here, <code>&#91;[\\d+]]</code> is stripped down to <code>&#91;[\d+]]</code> by the Nginx config file parser and this is processed correctly.