开源软件名称（OpenSource Name）：openresty/lua-nginx-module开源软件地址(OpenSource Url)：https://github.com/openresty/lua-nginx-module开源编程语言(OpenSource Language)：C 94.9%开源软件介绍(OpenSource Introduction)：Namengx_http_lua_module - Embed the power of Lua into Nginx HTTP Servers. This module is a core component of OpenResty. If you are using this module, then you are essentially using OpenResty. This module is not distributed with the Nginx source. See the installation instructions. This is a core component of OpenResty. If you are using this module, then you are essentially using OpenResty :) Table of Contents
StatusProduction ready. VersionThis document describes ngx_lua v0.10.19, which was released on 3 Nov, 2020. Videos
You are welcome to subscribe to our official YouTube channel, OpenResty. Synopsis # set search paths for pure Lua external libraries (';;' is the default path):
lua_package_path '/foo/bar/?.lua;/blah/?.lua;;';
# set search paths for Lua external libraries written in C (can also use ';;'):
lua_package_cpath '/bar/baz/?.so;/blah/blah/?.so;;';
server {
location /lua_content {
# MIME type determined by default_type:
default_type 'text/plain';
content_by_lua_block {
ngx.say('Hello,world!')
}
}
location /nginx_var {
# MIME type determined by default_type:
default_type 'text/plain';
# try access /nginx_var?a=hello,world
content_by_lua_block {
ngx.say(ngx.var.arg_a)
}
}
location = /request_body {
client_max_body_size 50k;
client_body_buffer_size 50k;
content_by_lua_block {
ngx.req.read_body() -- explicitly read the req body
local data = ngx.req.get_body_data()
if data then
ngx.say("body data:")
ngx.print(data)
return
end
-- body may get buffered in a temp file:
local file = ngx.req.get_body_file()
if file then
ngx.say("body is in file ", file)
else
ngx.say("no body found")
end
}
}
# transparent non-blocking I/O in Lua via subrequests
# (well, a better way is to use cosockets)
location = /lua {
# MIME type determined by default_type:
default_type 'text/plain';
content_by_lua_block {
local res = ngx.location.capture("/some_other_location")
if res then
ngx.say("status: ", res.status)
ngx.say("body:")
ngx.print(res.body)
end
}
}
location = /foo {
rewrite_by_lua_block {
res = ngx.location.capture("/memc",
{ args = { cmd = "incr", key = ngx.var.uri } }
)
}
proxy_pass http://blah.blah.com;
}
location = /mixed {
rewrite_by_lua_file /path/to/rewrite.lua;
access_by_lua_file /path/to/access.lua;
content_by_lua_file /path/to/content.lua;
}
# use nginx var in code path
# CAUTION: contents in nginx var must be carefully filtered,
# otherwise there'll be great security risk!
location ~ ^/app/([-_a-zA-Z0-9/]+) {
set $path $1;
content_by_lua_file /path/to/lua/app/root/$path.lua;
}
location / {
client_max_body_size 100k;
client_body_buffer_size 100k;
access_by_lua_block {
-- check the client IP address is in our black list
if ngx.var.remote_addr == "132.5.72.3" then
ngx.exit(ngx.HTTP_FORBIDDEN)
end
-- check if the URI contains bad words
if ngx.var.uri and
string.match(ngx.var.request_body, "evil")
then
return ngx.redirect("/terms_of_use.html")
end
-- tests passed
}
# proxy_pass/fastcgi_pass/etc settings
}
}DescriptionThis module embeds LuaJIT 2.0/2.1 into Nginx. It is a core component of OpenResty. If you are using this module, then you are essentially using OpenResty. Since version 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 Apache's mod_lua and 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 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 or
ngx.location.capture_multi but it is
recommended to use those 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 ngx_stream_lua module instead, which offers a compatible Lua API. Typical UsesJust 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. Nginx CompatibilityThe latest version of this module is compatible with the following versions of Nginx:
Nginx cores older than 1.6.0 (exclusive) are not supported. InstallationIt is highly recommended to use 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 OpenResty's optimized LuaJIT 2.1 fork and Nginx/OpenSSL patches. Alternatively, ngx_lua can be manually compiled into Nginx:
Build the source with this module: wget 'https://openresty.org/download/nginx-1.19.3.tar.gz'
tar -xzvf nginx-1.19.3.tar.gz
cd nginx-1.19.3/
# tell nginx's build system where to find LuaJIT 2.0:
export LUAJIT_LIB=/path/to/luajit/lib
export LUAJIT_INC=/path/to/luajit/include/luajit-2.0
# tell nginx's build system where to find LuaJIT 2.1:
export LUAJIT_LIB=/path/to/luajit/lib
export LUAJIT_INC=/path/to/luajit/include/luajit-2.1
# Here we assume Nginx is to be installed under /opt/nginx/.
./configure --prefix=/opt/nginx \
--with-ld-opt="-Wl,-rpath,/path/to/luajit/lib" \
--add-module=/path/to/ngx_devel_kit \
--add-module=/path/to/lua-nginx-module
# Note that you may also want to add `./configure` options which are used in your
# current nginx build.
# You can get usually those options using command nginx -V
# you can change the parallelism number 2 below to fit the number of spare CPU cores in your
# machine.
make -j2
make install
# Note that this version of lug-nginx-module not allow to set `lua_load_resty_core off;` any more.
# So, you have to install `lua-resty-core` and `lua-resty-lrucache` manually as below.
cd lua-resty-core
make install PREFIX=/opt/nginx
cd lua-resty-lrucache
make install PREFIX=/opt/nginx
# add necessary `lua_package_path` directive to `nginx.conf`, in the http context
lua_package_path "/opt/nginx/lib/lua/?.lua;;";Building as a dynamic moduleStarting from NGINX 1.9.11, you can also compile this module as a dynamic module, by using the 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;C Macro ConfigurationsWhile 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 CommunityEnglish Mailing ListThe openresty-en mailing list is for English speakers. Chinese Mailing ListThe openresty mailing list is for Chinese speakers. Code RepositoryThe code repository of this project is hosted on GitHub at openresty/lua-nginx-module. Bugs and PatchesPlease submit bug reports, wishlists, or patches by
LuaJIT bytecode supportWatch YouTube video "Measure Execution Time of Lua Code Correctly in OpenResty" As from the /path/to/luajit/bin/luajit -b /path/to/input_file.lua /path/to/output_file.ljbcThe /path/to/luajit/bin/luajit -bg /path/to/input_file.lua /path/to/output_file.ljbcPlease refer to the official LuaJIT documentation on the 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: Loading bytecode files via the Lua primitives like System Environment Variable SupportIf you want to access the system environment variable, say, env foo;HTTP 1.0 supportThe HTTP 1.0 protocol does not support chunked output and requires an explicit For large streaming output responses, it is important to disable the lua_http10_buffering directive to minimise memory usage. Note that common HTTP benchmark tools such as Statically Linking Pure Lua ModulesWith LuaJIT 2.x, it is possible to statically link the bytecode of pure Lua modules into the Nginx executable. You can use the Below is a trivial example to demonstrate this. Consider that we have the following -- foo.lua
local _M = {}
function _M.go()
print("Hello from foo")
end
return _MAnd then we compile this /path/to/luajit/bin/luajit -bg foo.lua foo.oWhat matters here is the name of the Then when building Nginx or OpenResty, pass the ./configure --with-ld-opt="/path/to/foo.o" ...Finally, you can just do the following in any Lua code run by ngx_lua: local foo = require "foo"
foo.go()And this piece of code no longer depends on the external If you want to use dot in the Lua module name when calling local foo = require "resty.foo"then you need to rename the It is important to use exactly the same version of LuaJIT when compiling When you have multiple ./configure --with-ld-opt="/path/to/foo.o /path/to/bar.o" ...If you have too many ar rcus libmyluafiles.a *.othen you can link the ./configure \
--with-ld-opt="-L/path/to/lib -Wl,--whole-archive -lmyluafiles -Wl,--no-whole-archive"where Data Sharing within an Nginx WorkerTo 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
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: -- mydata.lua
local _M = {}
local data = {
dog = 3,
cat = 4,
pig = 5,
}
function _M.get_age(name)
return data[name]
end
return _Mand then accessing it from location /lua {
content_by_lua_block {
local mydata = require "mydata"
ngx.say(mydata.get_age("dog"))
}
}The 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) 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:
Known IssuesTCP socket connect operation issuesThe tcpsock:connect method may indicate 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. |
