OpenResty 介绍与实战讲解（nginx&lua）-六虎

一、概述

OpenResty是一个依据 Nginx 与 Lua 的高性能 Web 渠道，其内部集成了很多精良的 Lua 库、第三方模块以及大多数的依赖项。用于方便地建立能够处理超高并发、扩展性极高的动态 Web 运用、Web 服务和动态网关。

简略地说 OpenResty 的方针是让你的Web服务直接跑在 Nginx 服务内部，充分利用 Nginx 的非阻塞 I/O 模型，不仅仅对 HTTP 客户端恳求,甚至于对长途后端诸如 MySQL、PostgreSQL、Memcached 以及 Redis 等都进行一致的高性能呼应。

从上面官网的描述信息中，能够看出OpenResty主要包括两方面的技能：

Nginx：一款轻量级、高性能、高并发的Web服务器。
Lua：一种轻量、小巧、可移植、快速的脚本语言；LuaJIT即时编译器会将频频履行的Lua代码编译成本地机器码交给CPU直接履行，履行效率更高，OpenResty 会默许启用 LuaJIT。

官方网站：openresty.org/ Github组织：github.com/openresty

nginx 与 lua 介绍与装置能够参阅我以下几篇文章：

二、OpenResty 装置

yum install pcre-devel openssl-devel gcc curl
wget https://openresty.org/package/centos/openresty.repo
sudo mv openresty.repo /etc/yum.repos.d/openresty.repo
# update the yum index:
sudo yum check-update
yum -y install openresty

验证装置

/usr/local/openresty/nginx/sbin/nginx -v

发动 OpenResty

/usr/local/openresty/nginx/sbin/nginx

测试

# 创建一个 NGINX 装备文件（例如 /usr/local/openresty/nginx/conf/nginx.conf）并增加一个包括 Lua 代码的 location 块：
server {
    listen 80;
    server_name localhost;
    location /test {
        content_by_lua_block {
            ngx.say("Hello, LuaJIT!")
        }
    }
}

保存装备文件，然后重新加载 NGINX：

# 先检查语法
sudo /usr/local/openresty/nginx/sbin/nginx -t
# 重新加载装备
sudo /usr/local/openresty/nginx/sbin/nginx -s reload

拜访 http://localhost/test 应该回来 "Hello, LuaJIT!"。

三、OpenResty 的工作原理

OpenResty 是依据 Nginx 的高性能Web渠道，所以其高效运转与 Nginx 密不可分。 Nginx 处理HTTP恳求有11个履行阶段，咱们能够从ngx_http_core_module.h 的源码中看到：

typedef enum {
    NGX_HTTP_POST_READ_PHASE = 0,
    NGX_HTTP_SERVER_REWRITE_PHASE,
    NGX_HTTP_FIND_CONFIG_PHASE,
    NGX_HTTP_REWRITE_PHASE,
    NGX_HTTP_POST_REWRITE_PHASE,
    NGX_HTTP_PREACCESS_PHASE,
    NGX_HTTP_ACCESS_PHASE,
    NGX_HTTP_POST_ACCESS_PHASE,
    NGX_HTTP_PRECONTENT_PHASE,
    NGX_HTTP_CONTENT_PHASE,
    NGX_HTTP_LOG_PHASE
} ngx_http_phases;

偶然的是，OpenResty 也有 11 个 *_by_lua 指令，它们和 NGINX 的11个履行阶段有很大的关联性。指令是运用Lua编写Nginx脚本的根本构建块，用于指定用户编写的Lua代码何时运转以及运转结果怎么运用等。下图显示了不同指令的履行顺序，这张图能够协助理清咱们编写的脚本是依照怎样的逻辑运转的。

四、OpenResty 中心模块

OpenResty 是一个依据 NGINX 的全功用 Web 渠道，它集成了许多模块和库，为 NGINX 增加了额定的功用和才能。以下是 OpenResty 的一些中心模块：

1）ngx_lua 模块

ngx_lua 模块是 OpenResty 的中心模块之一，供给了对 Lua 脚本的支撑。它答应开发者在 NGINX 装备中嵌入Lua代码，完成高档的恳求处理逻辑、动态内容生成、拜访操控等功用。

ngx_lua 模块示例：

server {
    listen 80;
    server_name example.com;
    location /lua_example {
        default_type 'text/plain';
        content_by_lua_block {
            ngx.say("Hello, ngx_lua!")
        }
    }
}

在这个例子中，当拜访 http://example.com/lua_example 时，将回来 "Hello, ngx_lua!"。这儿运用了 ngx_lua 模块的 content_by_lua_block 指令，将 Lua 代码嵌入 NGINX 装备文件。

2）ngx_stream_lua 模块

ngx_stream_lua 模块与 ngx_lua 类似，但专门用于处理 TCP 和 UDP 流量。它答应开发者在 NGINX 装备中嵌入 Lua 代码以处理流量。

以下是一个简略的 ngx_stream_lua 模块的示例：

stream {
    server {
        listen 12345;
        content_by_lua_block {
            local data, err = ngx.req.socket()
            if not data then
                ngx.log(ngx.ERR, "Failed to read request: ", err)
                return
            end
            ngx.say("Received data: ", data)
        }
    }
}

在这个示例中：

运用 content_by_lua_block 指令界说了一个 Lua 代码块，用于处理 TCP 流量。
经过 ngx.req.socket() 获取衔接的套接字，然后读取恳求数据。
输出接收到的数据。

此装备监听在端口 12345 上，当有 TCP 衔接到达时，Lua 代码将读取并输出接收到的数据。

3）ngx_http_lua_module 模块

ngx_http_lua_module 模块是 ngx_lua 模块的一部分，为 NGINX 供给了强壮的 HTTP 服务和 Lua 扩展。

以下是一个简略的 ngx_http_lua_module 模块的示例：

server {
    listen 80;
    server_name example.com;
    location /lua_example {
        default_type 'text/plain';
        content_by_lua_block {
            ngx.say("Hello, ngx_http_lua!")
        }
    }
    location /lua_variable {
        default_type 'text/plain';
        set $my_variable "NGINX with Lua";
        content_by_lua_block {
            local my_variable = ngx.var.my_variable
            ngx.say("Value of my_variable: ", my_variable)
        }
    }
}

这个示例中：

/lua_example 途径下的恳求将回来 "Hello, ngx_http_lua!"。这儿运用了 content_by_lua_block 指令，将 Lua 代码嵌入 NGINX 装备文件，完成了简略的呼应内容输出。
/lua_variable 途径下的恳求将输出一个自界说变量的值。运用了 set 指令设置了一个名为 my_variable 的变量，然后在 Lua 代码块中经过 ngx.var 获取并输出了这个变量的值。

4）ngx_http_headers_more 模块

ngx_http_headers_more 模块供给了更多的操作 HTTP 头部的指令，使得在 NGINX 中更简略操作和修正 HTTP 头信息。

以下是一个简略的运用 ngx_http_headers_more 模块的示例：

server {
    listen 80;
    server_name example.com;
    location /add_custom_header {
        more_set_headers "Custom-Header: OpenResty";
        return 200 "Custom header added!";
    }
    location /remove_server_header {
        more_clear_headers Server;
        return 200 "Server header removed!";
    }
}

在这个示例中：

/add_custom_header 途径下的恳求将回来 "Custom header added!"，一起呼应头中包括了一个自界说的头部 "Custom-Header: OpenResty"。这是经过 more_set_headers 指令增加的。
/remove_server_header 途径下的恳求将回来 "Server header removed!"，一起呼应头中不再包括 "Server" 头部。这是经过 more_clear_headers 指令移除的默许的 "Server" 头部。

这些指令答应你更灵活地装备 NGINX 的呼应头信息，增加或删除特定的头部字段。请注意，运用这些指令时应慎重，保证符合安全性和隐私性的最佳实践。

5）ngx_http_echo 模块

ngx_http_echo 模块供给了更丰富的内容输出和变量替换的功用。能够经过指定呼应内容、设置 HTTP 状况码等，以及支撑类似 PHP 的变量替换。

server {
    listen 80;
    server_name example.com;
    location /echo_example {
        echo "Hello, ngx_http_echo!";
    }
}

在这个示例中：

/echo_example 途径下的恳求将回来 "Hello, ngx_http_echo!"。这是经过 ngx_http_echo 模块的 echo 指令完成的。
ngx_http_echo 模块的 echo 指令答应你更方便地输出内容，支撑类似 PHP 的变量替换等功用。你能够在 echo 指令中直接运用变量，也能够运用其他模块供给的一些特殊的变量。

6）ngx_http_lua_upstream 模块

ngx_http_lua_upstream 模块用于在 Lua 脚本中进行向上游服务器（后端服务器）的恳求，并处理来自上游的呼应。

以下是一个简略的示例，演示了怎么运用 ngx_http_lua_upstream 模块向上游服务器建议恳求，并处理来自上游服务器的呼应：

http {
    upstream backend {
        server backend1;
        server backend2;
    }
    server {
        listen 80;
        server_name example.com;
        location /proxy_example {
            content_by_lua_block {
                -- 初始化 upstream 目标
                local upstream = require "ngx.upstream"
                local backend = upstream.backend
                -- 创建一个新的恳求目标
                local request = upstream.request()
                -- 设置恳求的办法、URI和头部
                request.method = ngx.HTTP_GET
                request.uri = "/path/to/resource"
                request.headers["Host"] = "backend.example.com"
                -- 发送恳求到上游服务器
                local status, headers, body = request.send(backend)
                -- 处理上游服务器的呼应
                if status == 200 then
                    ngx.say("Response from backend: ", body)
                else
                    ngx.say("Error from backend. Status: ", status)
                end
            }
        }
    }
}

在这个示例中：

界说了一个名为 backend 的上游服务器块，包括两个后端服务器 backend1 和 backend2。
在 /proxy_example 途径下的恳求中，经过 Lua 脚本运用 ngx_http_lua_upstream 模块创建了一个新的上游恳求目标。
设置了恳求的办法、URI和头部信息。
调用 request.send(backend) 发送恳求到上游服务器。
依据上游服务器的呼应状况码，输出呼应内容或显示错误信息。

请注意，实践运用时，你或许需求依据详细的事务需求和上游服务器的特性进行更杂乱的 Lua 脚本编写。此示例仅为演示根本用法。

7）ngx_http_redis 模块

ngx_http_redis 模块供给了与 Redis 数据库的交互功用，答应 NGINX 经过 Lua 脚本与 Redis 通信。

以下是一个简略的示例，演示了怎么运用 ngx_http_redis 模块与 Redis 交互：

http {
    server {
        listen 80;
        server_name example.com;
        location /redis_example {
            # 界说 Redis 服务器的地址和端口
            set $redis_host "127.0.0.1";
            set $redis_port 6379;
            # 运用 ngx_http_redis 模块向 Redis 发送 GET 恳求
            redis_pass $redis_host:$redis_port;
            redis_query GET my_key;
            # 处理 Redis 的呼应
            content_by_lua_block {
                local redis = require "ngx.redis"
                local red = redis:new()
                red:set_timeout(1000)  -- 设置超时时间
                local ok, err = red:connect(ngx.var.redis_host, ngx.var.redis_port)
                if not ok then
                    ngx.say("Failed to connect to Redis: ", err)
                    return
                end
                local res, err = red:get("my_key")
                if not res then
                    ngx.say("Failed to get value from Redis: ", err)
                    return
                end
                ngx.say("Value from Redis: ", res)
                -- 释放衔接
                local ok, err = red:set_keepalive(10000, 100)
                if not ok then
                    ngx.say("Failed to set keepalive: ", err)
                    return
                end
            }
        }
    }
}

在这个示例中：

/redis_example 途径下的恳求首要经过 redis_pass 和 redis_query 指令设置了 Redis 服务器的地址和端口，并发送了一个 GET 恳求获取键为 "my_key" 的值。
在 Lua 脚本中，运用 ngx.redis 模块创建了一个 Redis 目标，衔接到 Redis 服务器，并经过 get 办法获取了 "my_key" 的值。
最后，输出从 Redis 获取的值。

请注意，实践运用时，你需求依据你的 Redis 服务器装备和事务需求进行恰当的修正。此示例仅为演示根本用法。

8）ngx_http_proxy_connect_module 模块

ngx_http_proxy_connect_module 模块答应 NGINX 充当 CONNECT 署理，用于处理 TLS/SSL 衔接的署理恳求。

以下是一个简略的运用示例：

http {
    server {
        listen 80;
        server_name example.com;
        location /proxy_connect_example {
            proxy_pass http://backend;
        }
    }
    server {
        listen 443 ssl;
        server_name example.com;
        ssl_certificate /path/to/certificate.crt;
        ssl_certificate_key /path/to/private_key.key;
        location /proxy_connect_example {
            proxy_pass http://backend;
        }
    }
}

在这个示例中：

装备了两个 server 块，分别监听了 80 端口和 443 端口。第一个 server 块用于处理 HTTP 恳求，第二个 server 块用于处理 HTTPS 恳求。
关于 /proxy_connect_example 途径，运用了 proxy_pass 指令，将恳求署理到名为 backend 的上游服务器。
关于 HTTPS 的状况，需求供给 SSL 证书和私钥的途径。实践上，这个装备使 NGINX 具有 CONNECT 署理的才能，能够处理 TLS/SSL 握手并将恳求署理到上游服务器。

9）ngx_http_js_module 模块

ngx_http_js_module 模块供给了对 JavaScript 的支撑，使得能够在 NGINX 中运用 JavaScript 来编写恳求处理逻辑。

以下是一个简略的运用 ngx_http_js_module 模块的示例：

http {
    server {
        listen 80;
        server_name example.com;
        location /js_example {
            js_content main;
        }
    }
    js_include main;
    function main(r) {
        r.return(200, "Hello, ngx_http_js_module!");
    }
}

在这个示例中：

界说了一个监听 80 端口的 server 块。
在 /js_example 途径下的恳求中，运用了 js_content 指令，将恳求处理的逻辑指定为 JavaScript 脚本。
运用 js_include 指令引入了一个名为 main 的 JavaScript 函数。
main 函数中运用了 r.return 办法回来了一个 HTTP 200 呼应，并带有相应的消息。

请注意，运用 ngx_http_js_module 模块时，需求保证现已正确装置并启用了该模块。此示例仅仅一个根本的演示，实践运用时或许需求依据详细的事务需求编写更杂乱的 JavaScript 脚本。

10）ngx_http_geoip2_module 模块

ngx_http_geoip2_module 模块用于经过 MaxMind GeoIP2 数据库来获取客户端的地理位置信息。

以下是一个简略的示例，演示了怎么运用 ngx_http_geoip2_module 模块获取客户端的地理位置信息：

http {
    geoip2 /path/to/GeoIP2-City.mmdb {
        $geoip2_city_country_iso_code country iso_code;
        $geoip2_city_country country names en;
        $geoip2_city_city city names en;
        $geoip2_city_latitude latitude;
        $geoip2_city_longitude longitude;
    }
    server {
        listen 80;
        server_name example.com;
        location /geoip_example {
            default_type 'text/plain';
            content_by_lua_block {
                local country = ngx.var.geoip2_city_country
                local city = ngx.var.geoip2_city_city
                local latitude = ngx.var.geoip2_city_latitude
                local longitude = ngx.var.geoip2_city_longitude
                ngx.say("Country: ", country)
                ngx.say("City: ", city)
                ngx.say("Latitude: ", latitude)
                ngx.say("Longitude: ", longitude)
            }
        }
    }
}

ngx_http_geoip2_module 模块用于在 NGINX 中获取客户端的地理位置信息，依据 MaxMind 的 GeoIP2 数据库。以下是一个简略的示例，演示了怎么运用 ngx_http_geoip2_module 模块获取客户端的地理位置信息：

nginx Copy code http { geoip2 /path/to/GeoIP2-City.mmdb { $geoip2_city_country_iso_code country iso_code;$ geoip2_city_country country names en; $geoip2_city_city city names en;$ geoip2_city_latitude latitude; $geoip2_city_longitude longitude; }

server {
    listen 80;
    server_name example.com;
    location /geoip_example {
        default_type 'text/plain';
        content_by_lua_block {
            local country = ngx.var.geoip2_city_country
            local city = ngx.var.geoip2_city_city
            local latitude = ngx.var.geoip2_city_latitude
            local longitude = ngx.var.geoip2_city_longitude
            ngx.say("Country: ", country)
            ngx.say("City: ", city)
            ngx.say("Latitude: ", latitude)
            ngx.say("Longitude: ", longitude)
        }
    }
}

} 在这个示例中：

运用 geoip2 指令装备了 GeoIP2 数据库的途径，并界说了一些变量用于存储地理位置信息，如国家 ISO 代码、国家称号、城市称号、纬度和经度。
在 /geoip_example 途径下的恳求中，经过 Lua 脚本获取了客户端的地理位置信息，并输出了国家、城市、纬度和经度等信息。

请注意，在实践运用中，你需求保证现已获取并装备了正确的 GeoIP2 数据库文件途径。此示例仅仅一个根本的演示，实践场景中或许需求依据事务需求进一步处理和运用这些地理位置信息。

11）ngx_brotli 模块

ngx_brotli 模块用于支撑 Brotli 紧缩算法，供给更高效的内容紧缩。

以下是一个简略的运用 ngx_brotli 模块的示例：

http {
    brotli on;
    brotli_comp_level 6;
    brotli_static on;
    server {
        listen 80;
        server_name example.com;
        location /brotli_example {
            default_type 'text/plain';
            content_by_lua_block {
                ngx.say("Hello, ngx_brotli!");
            }
        }
    }
}

在这个示例中：

运用 brotli 指令敞开了 Brotli 紧缩功用。
运用 brotli_comp_level 指令设置了 Brotli 紧缩等级。
运用 brotli_static 指令敞开了静态文件的 Brotli 紧缩。
在 /brotli_example 途径下的恳求中，回来了一个简略的文本内容 "Hello, ngx_brotli!"。

请注意，在实践运用中，你需求保证现已装置了支撑 Brotli 紧缩的库，并且 NGINX 装备中启用了对应的模块。此示例仅仅一个根本的演示，实践装备中或许需求依据事务需求调整紧缩等级等参数。

这些模块共同构成了 OpenResty 的中心，使得 NGINX 变得更加强壮和灵活。运用这些模块，你能够完成更高档的恳求处理、负载均衡、反向署理、动态内容生成等功用。详细信息和用法能够参阅 OpenResty 官方文档：openresty.org/。

五、OpenResty 示例解说

OpenResty 是一个依据 NGINX 的全功用 Web 渠道，集成了很多的第三方模块和库，其中最重要的是 ngx_lua 模块，它答应在 NGINX 装备中嵌入 Lua 脚本，完成高档的恳求处理逻辑、动态内容生成、拜访操控等功用。下面是一个简略的 OpenResty 示例：

http {
    server {
        listen 80;
        server_name example.com;
        location /hello {
            default_type 'text/plain';
            content_by_lua_block {
                ngx.say("Hello, OpenResty!")
            }
        }
    }
}

在这个示例中：

装备了一个监听 80 端口的 server 块，处理 example.com 的恳求。
当拜访途径 /hello 时，经过 content_by_lua_block 指令履行 Lua 代码，输出 "Hello, OpenResty!"。

这仅仅一个最简略的演示，OpenResty 的强壮之处在于它答应在 NGINX 装备中运用 Lua 脚本，从而完成更杂乱的逻辑。以下是一个稍杂乱的示例，演示了怎么经过 OpenResty 完成简略的 API 拜访操控：

http {
    lua_shared_dict my_limit 10m;
    server {
        listen 80;
        server_name api.example.com;
        location /api {
            access_by_lua_block {
                local limit = ngx.shared.my_limit
                local key = ngx.var.remote_addr
                local reqs, err = limit:get(key)
                if reqs then
                    if reqs > 10 then
                        ngx.exit(ngx.HTTP_TOO_MANY_REQUESTS)
                    else
                        limit:incr(key, 1)
                    end
                else
                    limit:set(key, 1, 60)
                end
            }
            default_type 'application/json';
            content_by_lua_block {
                ngx.say('{"message": "API response"}')
            }
        }
    }
}

在这个示例中：

装备了一个共享内存字典 my_limit 用于存储恳求计数。
当拜访途径 /api 时，经过 access_by_lua_block 指令履行 Lua 代码，完成了一个简略的恳求频率约束，每个 IP 地址在 60 秒内最多答应 10 次恳求。
如果超过恳求约束，将回来 HTTP 429 (TOO MANY REQUESTS) 状况码；否则，持续履行后续 Lua 代码回来 JSON 呼应。

这仅仅 OpenResty 的一小部分功用展示，实践运用中能够结合更多的模块和功用，如 ngx_http_lua_upstream、ngx_http_headers_more、ngx_stream_lua 等，以完成更杂乱的 Web 运用和服务。

OpenResty 介绍与实战解说就先到这儿了，有任何疑问也可关注我大众号：大数据与云原生技能共享，进行技能交流，如本篇文章对您有所协助，费事帮忙一键三连（点赞、转发、保藏）~

OpenResty 介绍与实战讲解（nginx&lua）

一、概述

二、OpenResty 装置

三、OpenResty 的工作原理

四、OpenResty 中心模块

1）ngx_lua 模块

2）ngx_stream_lua 模块

3）ngx_http_lua_module 模块

4）ngx_http_headers_more 模块

5）ngx_http_echo 模块

6）ngx_http_lua_upstream 模块

7）ngx_http_redis 模块

8）ngx_http_proxy_connect_module 模块

9）ngx_http_js_module 模块

10）ngx_http_geoip2_module 模块

11）ngx_brotli 模块

五、OpenResty 示例解说

相关文章

Android代码静态检查（lint、Checkstyle、ktlint、Detekt）

感情、事业双丰收的2022年

Android-屏幕刷新机制

No Focused Window ANR是怎样产生的

作者信息