OpenResty基础

一、OpenResty基础

简介

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

OpenResty通过汇聚各种设计精良的Nginx模块，从而将Nginx有效地变成一个强大的通用Web应用平台。这样，Web开发人员和系统工程师可以使用Lua脚本语言调动Nginx支持的各种C以及Lua模块，快速构造出足以胜任10K乃至1000K以上单机并发连接的高性能Web应用系统。

OpenResty的目标是让你的Web服务直接跑在Nginx服务内部，充分利用Nginx的非阻塞I/O模型，不仅仅对HTTP客户端请求，甚至于对远程后端诸如MySQL、PostgreSQL、Memcached以及Redis等都进行一致的高性能响应。

OpenResty基于Nginx和Lua/LuaJIT，充分利用了两者的优势，能够无阻塞地处理海量并发连接，任意操纵HTTP/TCP/UDP数据流，而且功能代码不需要编译，可以就地修改脚本并运行，简化了开发流程，加快了开发和调试的速度，同时也缩短了开发周期。

应用场景

由于OpenResty具有优秀的反向代理功能，以及负载均衡、内容缓冲、安全防护等高级特性，所以最常见的用法是部署在网站架构的最前端，作为流量的总入口，提高系统的整体稳定性和可靠性。

OpenResty内嵌方便快捷的Lua脚本，完全能够取代PHP、Python、Ruby来编写应用服务，把业务逻辑跑在高性能的Nginx里，去掉不必要的中间环节直接操作Redis、MySQL等数据库，减少内部的网络消耗，节约系统资源。

OpenResty也可以充当API Gateway，以RESTful接口为基础聚合整理各种后端服务，并增加监控、缓存、权限控制等功能，改善系统的运行效率。

OpenResty使用四位数字作为版本号，形式是：a.b.c.x，其中前三位数字是内部Nginx的版本，作为大版本号，第四位数字是OpenResty自己的发布版本号，也就是小版本号。

Mac安装

1
$ brew install openresty/brew/openresty

Windows安装

去官网下载安装包。

1
2
3
4
5
6
7
$ start nginx
$ tasklist /fi "imagename eq nginx.exe"

映像名称                       PID 会话名              会话#       内存使用
========================= ======== ================ =========== ============
nginx.exe                    11468 Console                   18     10,548 K
nginx.exe                    19632 Console                   18     11,160 K

另外，如果windows环境没有安装perl，可去『strawberryperl』 下载安装。

docker安装

1
2
3
4
5
6
$ docker run -d --name openresty1 -p 8090:8090 -v ~/docker/openresty/conf/nginx.conf:/usr/local/openresty/nginx/conf/nginx.conf -v ~/docker/openresty/logs:/usr/local/openresty/nginx/logs openresty/openresty:alpine

#创建logs、conf目录
$ mkdir ~/docker/openresty
$ cd ~/docker/openresty
$ mkdir logs/ conf/

conf/nginx.conf文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
worker_processes  1; #设置worker进程数为1
error_log logs/error.log;
events {  #设置并发连接需要在events块里
    worker_connections 1024; #单个worker的最大链接数
}
http { #定义http服务
    server { #server块，定义Web服务
        listen 8080; #监听端口
        location / { #location块，匹配任意URI
            # default_type text/html;
            content_by_lua_block {
                ngx.say("HelloWorld")
            }
        }
    }
}

linux安装

1
2
3
4
5
6
7
8
#可参考nginx安装
$ tar -xzvf openresty-VERSION.tar.gz
$ ./configure --prefix=/opt/openresty \
            --with-luajit \
            --without-http_redis2_module \
            --with-http_iconv_module \
            --with-http_postgres_module
$ make && make install

openresty常用命令

1
2
3
4
5
6
7
8
9
# cd到~/docker/openresty后执行
# -c参数为运行时指定配置文件
$ /usr/local/opt/openresty/nginx/sbin/nginx -p `pwd`/ -c conf/nginx.conf
# -p是-c的增强版，设置工作目录，则运行时会使用这个目录下的conf文件来运行，日志文件存放在logs目录。
$ /usr/local/opt/openresty/nginx/sbin/nginx -p ~/docker/openresty/ -c conf/nginx.conf
# -s signal可以快速停止和重启openresty，signal可以是stop（立即停止）、quit（请求处理完后停止）、reload（重启服务，重新加载配置文件和lua代码，服务不会中断），reopen（重新打开日志文件，服务不中断，用于切分日志）
# -t，测试配置文件是否正确
# -v或-V，显示openresty版本信息
$ .\resty -e "print('hello herr')"

包管理工具

开发语言/环境都会提供配套的包管理工具，例如npm/Node.js、cpan/Perl、gem/Ruby等，OpenResty可使用opm。

opm的用法很简单，常用的命令有：

  • search ：以关键字检索相关的组件；
  • get ：安装功能组件（注意不是install）；
  • info ：显示已安装组件的详细信息；
  • list ：列出所有本地已经安装的组件；
  • upgrade：更新某个已安装组件；
  • update ：更新所有已安装组件；
  • remove ：移除某个已安装组件。

二、OpenResty核心组件

OpenResty的核心组成部分有四个，分别是：

  • Nginx：高性能的Web服务器；
  • LuaJIT：高效的Lua语言解释器/编译器；
  • ngx_lua（http_lua）：处理HTTP协议，让Lua程序嵌入在Nginx里运行；
  • stream_lua：与ngx_lua类似，但处理的是TCP/UDP协议。

还包含许多nginx组件，以C模块的方式提供，集成在Nginx内部。

  • ngx_iconv：转换不同的字符集编码；
  • ngx_encrypted：使用AES-256算法执行简单的加密运算；
  • ngx_echo：提供一系列“echo”风格的指令和变量；
  • ngx_set_misc：增强的“set_xxx”指令，用来操作变量；
  • ngx_headers_more：更方便地处理HTTP请求头和响应头的指令；
  • ngx_memc：支持各种memcached操作；
  • ngx_redis2：支持各种Redis操作；
  • ngx_dizzle：支持各种MySQL操作；
  • ngx_postgres：支持各种PostgreSQL操作。

OpenResty里的Lua组件通常以Lua源码的方式提供(*.lua)，但个别组件为追求效率会以C语言实现，是动态链接库的形式（ *.so）。

  • lua_core：OpenResty的核心功能库；
  • lua_cjson：处理JSON格式的数据，速度很快（使用C语言实现）；
  • lua_string：hex/md5/sha1/sha256等字符串功能；
  • lua_upload：流式读取HTTP的上行数据；
  • lua_healthcheck：后端集群健康检查；
  • lua_limit_traffic：定制流量控制策略；
  • lua_lock：基于共享内存的非阻塞锁；
  • lua_lrucache：高效的LRU缓存功能；
  • lua_dns：高效、非阻塞的DNS解析功能；
  • lua_websocket：高效、非阻塞的WebSocket功能；
  • lua_redis：Redis客户端，用起来比ngx_redis2更灵活；
  • lua_memcached：Memcached客户端，用起来比ngx_memc更灵活；
  • lua_mysql:MySQL客户端，用起来比ngx_dizzle更灵活。

OpenResty目前提供的辅助工具有：

  • opm ：类似rpm、npm的管理工具，用来安装各种功能组件；
  • resty-cli ：以命令行的形式直接执行OpenResty/Lua程序；
  • restydoc ：类似man的参考手册，非常详细。

三、Lua语言

Lua是OpenResty的工作语言，是一种动态脚本语言。开发工具可以是IDEA + EmmyLua插件。windows平台推荐使用luaDist。

基本语法

  • 单行注释使用–。多行注释使用–[[ … ]]–
  • 有六种基本数据类型，nil，boolean，number，string，function，table。使用函数type()测试数据类型。
  • string，字符串不可变，单引号或双引号都可以。\代表转义字符。使用[[ … ]]可避免转义。
  • 变量，区分大小写，局部变量使用local关键字声明，没有使用local的都是全局变量，且不需要声明就可以直接使用。没有常量说法。
  • 逻辑运算使用and、or和not。nil和false为假，其他都是真，包括0
  • 字符串运算有个..，用于连接多个字符串。
  • 语句块使用do…end形式声明，赋值使用=号。
  • 分支语句 if condition1 then … elseif condition2 then … else … end。
  • 循环语句有while、repeat-until和for三种。while condition do … end。repeat … until condition。for var=m,n,step do … end。
  • 支持使用break和return跳出循环，但不支持continue。
  • 模块通过require关键字来引用。自行编写Lua模块时，创建一个表，将函数作为表的元素，用return返回这个表即可。

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
local function f1(a)
    a='1' --lua的参数都是传值（表除外），修改形参不会影响外部变量
    print("var is ",a);
end
f1{1,2,3} --参数是表，调用时省略了括号。
local x= '2'
f1(x,'3') -- 多传入的参数被忽略

local function f2(a,b,c)
    print (a .. (b or '').. (c or ''))
end
f2('1','2')  --调用函数，少的参数默认为nil

local function f3(a,b)
    return a+b,a*b --返回多个结果
end
local x,y=f3(2,3) --接收多个返回值
local z =(f3(2,3)) -- 使用圆括号调用，只返回第1个值

表

表（table）是Lua里唯一的数据结构。类似于字典、数组等，能模拟出array、list、dict、set、map等常见数据结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
local a ={1,2,3} --声明数组形式的表
a[1]=100 --作为数组来使用时下标索引从1开始计数
print(a[1],a[2],a[3]) -- 100 2 3
print(assert(#a ==3)) --运算符#可以计算表里的数组元素数量

local d ={one =1,['two']=2} --声明字典形式的表
d['three']=3 --添加一个新元素
d.four=5; --可使用.key或者[key]来访问表里的元素
assert(#d == 0) --运算符#无法计算字典元素的数量，会返回0

local x ={}
x.mission =function(dest) --为表添加一个函数变量，相当于成员函数
    print('move to ',dest)
end
x.mission('home') --执行成员函数

for i = 1, #a do --使用for循环遍历数组
    print(a[i],', ')
end

for i,v in ipairs(a) do --ipairs只能遍历数组形式的表，遇到nil值就结束。
    print(a[i],', ')
end

for k,v in pairs(d) do --pairs可以遍历所有元素，但速度没有ipairs快。
    print(k,'=>',v)
end

local function f(v)
    v.one=v.one.. ' add'
end

f(d) --当表作为函数的参数时，不是传值，直接传递表的引用
print(d.one) -- 1 add，可以看到已经被修改

面向对象

  • 面向对象的设计原则并不完全适用Lua。字典形式的表本身就是对象，可以存储任意变量和函数。
  • 封装，但不提供private、public等关键字，所有成员都是公开的。如需要实现私有成员，则在模块文件里用local修饰变量。
  • 多态，表是动态的，成员在运行时可以随意替换，没有编译型语言静态绑定的烦恼。
  • 继承，在Lua里不提倡，替代方案是使用“原型”模块，克隆出一个新对象，然后在动态变更其属性，达到继承类似的效果。
  • 原型模式，需要使用Lua的高级特性，元表metatable和函数setmetatable()。
  • 元表需要在表里使用”__index”元方法，重载Lua里查找key的操作。
  • 函数setmetatable(t,meta)是把表t的元表设置为meta并返回t。如果meta里设置了__index方法，那么对t的操作t.key会作用在meta上，即meta.key。这样表t就克隆了表meta的所有成员，表meta就成了表t的原型。
  • self关键字代表对象自身，调用函数时可以使用”:”替代”.”，这样会隐含传入一个self参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
local proto = {} --首先声明一个原型对象 ，暂时是空表
function proto.go() --为表添加一个方法，即成员函数
    print ("go proto")
end

local mt = { __index = proto } --定义元表 注意重载了 “＿index"
local obj = setmetatable ( {} , mt) --调用 setmetatable 设置元表，返回新表
-- local obj = setmetatable ({ }, { _index = proto } ) --等同于上面2行
obj.go() --新对象是原型的克隆

function proto.new() --new 对象，也就是克隆出新对象
    return setmetatable( --调用setetatable设置元表
    {name="test"} , mt)  --克隆时为对象添加新的name属性
end

function proto:hello() -- 使用":"，隐含传入 self 参数
    print ("hello", self.name) --可以直接使用 self 参数，无须声明
end
local obj = proto:new() --使用":"的方式调用函数
obj:hello() --使用":"的方式调用函数，打印结果hello	test

标准库

  • base，最核心的函数。type()、print()、iparis()、pairs()、assert()、error()、loadstring()等函数，可直接调用。
  • package，管理Lua的模块。require()用来加载模块，package.path和package.cpath用来查找require函数查找*.lua和.so时的路径，package.loaded是个表，保存了已加载的模块。
  • string，字符串相关函数，如取子串、格式化、大小写转换等。
  • table，表相关函数，如插入删除元素、排序等。
  • math，数学计算相关函数，如三角函数、平方根等。math.floor()和math.ceil()用来对数字向下或向上取整。math.min()和math.max()获取最小值和最大值。math.randomseed()设置伪随机数种子，math.random(m,n)用来产生[0,1),[1,m],[m,n]之间的伪随机数。
  • io，文件相关函数，如打开、关闭、读写文件，注意是阻塞的。io.open(filename,mode)用来打开文件，io.popen(prog,mode)用来执行prog命令，io.tmpfile()用来创建临时文件。
  • OS，操作系统相关函数。os.execute(command)阻塞执行操作系统命令，如shell命令。os.remove(filename)和os.rename(oldname,newname)文件删除和改名。os.date(format,time)做时间戳格式化。
  • debug，调试用的函数。debug.traceback()输出Lua代码的调用栈信息，追踪代码执行情况。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
local str ='Hello'
print(string.upper(str))
print(string.lower(str))

--string.sub(s,from,to)，从s提取子串，范围是[from,to]，计数从1开始。
print(string.sub(str,1,4)) --打印结果 Hell
print(string.sub(str,2)) -- to参数默认是-1，打印结果 ello
print(string.sub(str,2,-1)) -- 等同于上一行

local str_sub =string.sub --通过local为函数起别名，可以避免lua解释器反复在表里查找函数，加快程序执行速度
print(str_sub(str,1,4)) 

local a,b=string.byte(str,1,2) --提取字符串里的字节，返回ascii的整数
print(a, ",",b) -- 72,101

print(string.char(72,101)) --char是byte的反函数，打印值He

print(string.format("%04d,%f,%s",255,3.14,'lua')) --0255,3.140000,lua

local x={3,2,1}
x[#x + 1] =4; --添加元素，也可以使用table.insert
table.remove(x,2) --删除第2个元素

print(table.concat(x,'+')) --将数组里的元素用分隔符连接，3+1+4
table.sort(x) --排序
print(table.concat(x,'+')) --排序完成后，1+3+4

高级特性

  • 闭包，参考js的闭包，Lua函数天然就是闭包，在声明的同时就捕获了之前的所有变量。
  • 保护调用，可以使用base库的pcall或xpcall函数，来保护程序执行不会出错，并返回调用结果。
  • 可变参数，在参数列表里用”…”表示接受不确定数量的参数。
1
2
3
4
5
6
7
8
9
local ok, v = pcall(math.sqrt, 2)
print(ok and v)
local ok, v = pcall(math.sqrt, -1)
print(ok and v)

local ok, err= pcall(require,"test")
if not ok then
    print("not have test module")
end

LuaJIT

  • 『LuaJIT传送门』
  • 为了追求极致的性能， OpenResty里使用的却不是官方Lua解释器，而是一个非官方的开源实现LuaJIT。
  • LuaJIT是Lua语言的另一个实现，包括一个汇编语言编写的解释器和一个JIT编译器。由于使用的是汇编语言，可以把Lua语言用Just-In-Time技术直接编译为目标机器码，使运行速度达到或接近C代码的程度。
  • LuaJIT基于Lua 5.1，适当引入5.2和5.3的语言特性，还提供了特别的优化和库。
  • LuaJIT执行Lua程序时会将源程序转换成字节码，再倒入LuaVM里解释运行。再运行时做热点分析，热点代码触发JIT编译器，尝试将字节码再变异成本地的机器码。

新特性包括：

  • goto语句，用于不支持continue情况下的变通实现。
  • jit库，包含一些环境信息
  • table库，添加了一些新函数，table.new创建表，table.clear置为空表，table.clone浅拷贝表。
  • bit库，增强整数类型的位运算能力。包括进制转换，按位操作等。
  • ffi库，简化Lua代码调用c接口，还可以加载so形式的动态库并调用函数，灵活拓展Lua功能。

四、OpenResty和Lua开发

  • 由于Nginx的模块化架构具有良好的扩展性，OpenResty实现了ngx_lua和stream_lua等模块，把Lua/LuaJIT完美地整合进了Nginx，从而让我们能够在Nginx内部的多个关键节点里嵌入Lua脚本，用Lua这种便捷的语言来实现复杂的HTTP/TCP/UDP业务逻辑，同时依然保持着高度的并发服务能力。
  • OpenResty的开发服务本质上是编写conf配置文件。

运行机制

nginx的一个web服务的生命周期可以分成三个阶段。

  • initing，服务启动，工作通常是读取配置文件，初始化内部数据结构。
  • running，服务运行，接受客户端的请求，返回响应结果。
  • exiting，服务停止，做一些必要的清理工作，如关闭监听端口。

initing阶段在OpenResty里分为三个子阶段。

  • configuration，读取配置文件，解析配置指令，设置运行参数。
  • master-initing，配置文件解析完毕，master进程初始化公用的数据。
  • worker-initing，worker 进程自己的初始化，进程专用的数据。

running阶段，收到客户端请求后，OpenResty对每个请求都会使用一个专门的“流水线”顺序进行处理，就是 OpenResty 定义的处理阶段，包括：

  • ssl，SSL/TLS安全通信和验证。
  • preread，在正式处理之前预数据，接收HTTP请求头。
  • rewrite，检查、改写URI，实现跳转重定向。
  • access，访问权限控制。
  • content，产生响应内容。
  • filter，对content阶段产生的内容进行过滤加工处理。
  • log，请求处理完毕，记录日志，或者其他的收尾工作。

对应以上的处理阶段，OpenResty提供了一些”xxx by lua”指令，开发Web应用时使用它们就可以在这些阶段里插入Lua代码，执行业务逻辑，常用的有：

  • init_by_lua，master-initing 阶段，初始化全局配置或模块。可启动定时器，定时从redis获取数据等
  • init_worker_by_lua，worker-initing阶段，初始化进程专用功能。
  • ssl_certificate_by_luassl 阶段，在“握手”时设置安全证书。
  • set_by_lua，rewrite阶段，改写Nginx变量。
  • rewrite_by_lua，rewrite阶段，改写URI，实现跳转/重定向。
  • access_by_lua，access阶段，访问控制或限速。
  • content_by_lua，content阶段，产生响应内容。可运行主要的业务逻辑。
  • balancer_by_lua，content阶段，反向代理时选择后端服务器。
  • header_filter_by_lua，filter阶段，加工处理响应头。
  • body_filter_by_lua，filter阶段，加工处理响应体。可进行数据编码，加密等。
  • log_by_lua，log阶段，记录日志或其他的收尾工作。可发送处理完毕的回调等。

以上指令通常都有3种形式：

  • xxx_by_lua，执行字符串形式的Lua代码。由于涉及到单引号和双引号冲突，不推荐使用。
  • xxx_by_lua_block，功能相同，但指令后是{ … }的Lua代码块。由于代码混在了配置文件里，不建议过多使用。
  • xxx_by_lua_file，功能相同，但执行磁盘上的源码文件。推荐使用，彻底分离了配置文件和业务代码，可以独立部署和以模块的方式管理Lua程序。

功能接口

OpenResty为用户提供了上百个功能接口，可分为如下几类。

  • 基础功能，系统信息、日志、时间日期、数据编码、正则表达式等功能。如ngx.print，ngx.say，ngx.get_phase()等。
  • 高级功能，共享内存、定时器、轻量级线程、信号量等功能。
  • 请求处理，处理TCP/UDP/HTTP协议，响应或拒绝请求。
  • 访问后端，无阻塞地与各种后端服务通信（如Redis、MySQL)。
  • 反向代理，管理上游服务器集群，健康检查。
  • 负载均衡，自定义负载均衡策略，选择上游服务器。
  • 安全通信，SSL、OSCP、WAF等密码、证书、安全相关功能。

这些接口大部分位于全局表ngx里，无须require即可访问。与Lua 自带的标准库函数不同，它们基于nginx的事件机制和Lua的协程特性，都是”100 nonblocking”的，能够轻松编写出同步非阻塞的高效代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
-- 1、系统信息
ngx.say(ngx.config.debug) --通常不是 Debug 版本
ngx.say(ngx.config.prefix())  --工作目录，注意是函数调用
ngx.say(ngx.config.nginx_version) --内部 Nginx 的版本号
ngx.say(ngx.config.nginx_configure())  --编译时的配置参数，注意是函数调用
ngx.say(ngx.config.subsystem) --当前所在的子系统
ngx.say(ngx.config.ngx_lua_version) --当前所在子系统的版本号

--2、运行日志
nginx.log(ngx.STDEER,"STDEER"） --日志直接打印到标准输出，最高级别的日志
nginx.log(ngx.EMERG,"EMERG"）--发生了紧急情况，需要立即处理
nginx.log(ngx.CRIT,"CRIT"） --发生严重错误，可能需要报警给运维系统
nginx.log(ngx.WARN,"WARN"） --警告信息，业务正常，但可能要检查警告的来源
nginx.log(ngx.NOTICE,"NOTICE"）--提醒信息 仅仅是告知，通常可以忽略
print("NOTICE") --等同于上一行
nginx.log(ngx.INFO,"INFO"） --一般的信息
nginx.log(ngx.DEBUG,"DEBUG"）--调试用的信息，只有debug版本才会启用

--3、时间日期
ngx.say(ngx.today()) --本地时间，输出 2017-03-29
ngx.say(ngx.localtime()) --本地时间，输出 2017-03-29 16:47:32
ngx.say(ngx.utctime())  --UTC时间，输出 2017-03-29 08:47:32

ngx.say(ngx.time()) --epoch时间戳，整数，精确到秒
ngx.say(ngx.now())  --浮点数，精确到毫秒

ngx.say(ngx.http_time(ngx.time()))  --转换为http时间格式
ngx.say(ngx.cookie_time(ngx.time())) --转换为cookie时间格式
ngx.say(ngx.parse_http_time(ngx.localtime()))  --转换为时间戳

ngx.sleep(0.001) --同步非阻塞睡眠，单位是s。会基于协程机制去执行其他请求，等睡眠到了再执行后续代码。该语句在执行阶段上有限制。
ngx.update_time() --更新内部缓存时间

--4、数据编码
local str="1234"
local enc=ngx.encode_base64(str) --Base64加密，
local dec=ngx.decode_base64(enc) --Base64解密
ngx.say(enc) --MTIzNA==
ngx.say(dec) --1234
ngx.encode_base64(str,true) -- MTIzNA，无等号，padding特性

local b64 =require "ngx.base64"
local enc_url=b64.encode_base64url(str) --由于+和/符号会被url转码，用-和_符号替代
ngx.say(enc_url)

local cjson =require "cjson.safe" --Json操作
local jsonstr=cjson.encode({name='iherr',age='18'}) --将Lua表编码为JSON字符串
ngx.say(jsonstr)
local obj =cjson.decode(jsonstr) --接续字符串为Lua表
ngx.say(assert(obj.name =='iherr')) --检查表的name属性是否正确

正则表达式

提供6个正则表达式相关函数，底层实现是PCRE库。函数有个名为options的参数，-j代表PCRE-JIT编译，-o代表仅编译1次并缓存，正则替换时尽量不要使用o选项。

  • match，单词正则匹配
  • gmatch，多次正则匹配
  • find，同match，返回的是查到的位置索引
  • sub，正则替换
  • gsub，多次正则替换
  • split，正则切分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
local str ='abcd-123'
local m = ngx.re.match(str,[[\d{3}]],"jo") --返回一个匹配结果表
ngx.say(assert(m and m[0]=='123')) --匹配成功，匹配结果存储在表里

local m = ngx.re.match(str,"(.*)-123$","jo") --使用了子表达式，匹配123结尾的字符串
ngx.say(assert(m and m[1]=='abcd')) --匹配成功，匹配结果存储在表里

local m = ngx.re.match(str,"[A-Z]+","jo")
assert(not m)

local from , to = ngx.re.find(str,[[\d+]],"jo") --正则查找查找数字
assert(string.sub(str, from)== "123")

local ngx_re = require("ngx.re")  -- 显式加载ngx.re模块

local res, err  = ngx_re.split("a,b,c,d",",") 
assert(res and #res== 4) --切分成功，有4个结果

cache高速缓存

Cache的容量通常都是有限的，需要使用某种算法更新淘汰数据，较常见的有FIFO、LFU、LRU等，OpenResty基于LRU算法提供了一个方便易用的Cache库lua-resty-lru-cache，并且支持过期时间功能（expire）。该库内部有两个模块：resty.lrucache适用于
高命中率低更新率的场景。resty.lru-cache.pureffi适用于低命中率
高更新率的场景，必须使用require加载后才能使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
local lrucache = require "resty.lrucache" -- 加载lrucache
local urls, err = lrucache.new(lOO) -- 最多存放100个元素的缓存
if not urls then -- 检查是否创建成功
    ngx.say(err);return -- 失败则输出错误信息
end
package.loaded.urls = urls  -- 直接存入package.loaded表备用

urls:set('github','www.github.com')  --添加一个字符串
urls:set('apple','www.apple.com', 0.1) --添加一个字符串， 0.1秒后过期
urls:set('nginx',{https=true}) --添加一个元素，类型是表

local v = urls:get('github') -- 获取元素

ngx.sleep (0.15)  --非阻塞睡眠 0.15
local v, stale = urls:get ('apple') --获取己过期的元素
assert(not v and stale) --第二个返回值得到“陈旧”的数据
 
urls:delete('nginx') --删除一个元素
assert(not urls:get（'nginx'）） --获取的结果是 nil
urls:flush_all() --快速清空缓存

HTTP服务

开发HTTP服务主要用到的执行阶段有：set_by_lua，rewrite_by_lua，access_by_lua，content_by_lua，header_filter_by_lua，body_filter_by_lua，log_by_lua。

请求和响应常用函数：

  • 函数ngx.req.get_method和set_method用于读写当前请求方法。
  • 函数ngx.req.set_uri(uri,jump)，用来改写请求行的地址。
  • 函数ngx.req.get_uri_args和set_uri_args用来读写URI里的参数。
  • 函数ngx.req.get_post_args用来获取POST的参数。
  • 函数ngx.req.get_headers和set_header用来解析或改写请求头字段。
  • 函数ngx.req.discard_body可以丢失请求体。
  • 函数ngx.req.read_body会开始读取请求体数据。则可以用ngx.req.get_body_data来获取请求体，可以用ngx.req.set_body_data或ngx.req.set_body_file来改写请求体。
  • 使用ngx.status读写响应状态码。
  • ngx.header可以读取或修改响应头字段，ngx.resp.add_header添加响应头字段。ngx.send_headers可以显式的发送响应头。
  • ngx.print和ngx.say用来发送响应体数据。内部使用缓冲机制，可以用函数ngx.flush来强制刷新缓冲区发送。
  • ngx.req.socket函数用来获取连接客户端的cosocket对象，直接和客户端通信。

流程控制：

  • ngx.redirect(uri,status)，标准的301/302重定向
  • ngx.exec(uri,args)，跳转到内部的其他location
  • ngx.exit(status)，结束请求的处理
  • ngx.eof()，发送EOF标志，不会再响应数据

案例：

  • 只支持 GET POST 方法：
  • 只支持 HTTP 1.1 /2 协议
  • 只允许某些ip的用户访问服务
  • GET方法获取当前时间，以http时间格式输出
  • POST方法在请求体里传入时间戳，服务器转换为http时间格式输出
  • 可以使用URI参数need_encode=1,则输出会做Base64编码

划分为4个模块，对应的nginx总体配置文件如下，对应的lua文件需要放置到openresty目录下。

1
2
3
4
5
6
location /http {
    rewrite_by_lua_file lua/http_rewrite.lua;
    access_by_lua_file lua/http_access.lua;
    content_by_lua_file lua/http_content.lua;
    body_filter_by_lua_file lua/http_filter.lua;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
--lua/http_rewrite.lua文件
local method = ngx.req.get_method() --获取请求方法，请求方法常量有HTTP_GET,HTTP_HEAD,HTTP_POST,HTTP_PUT,HTTP_DELETE,HTTP_PATCH等。
if method ~= "GET" and method ~='POST' then --必须是 GET PUT
    ngx.header ["Allow"]= 'GET, POST' --方法错误返回 Allow 头字段
    ngx.exit(405) --返回状态码 405 ，结束请求
end

local ver = ngx.req.http_version() --获取HTTP协议的版本号
if ver < 1.1 then --不能低于 1.1
    ngx.exit(400) --返回状态码 400 ，结束请求
end

ngx.ctx.encode = --ngx.ctx可以暂存数据，用于不同处理阶段中数据的共享使用
ngx.var.arg_need_encode --ngx.var用来操作nginx变量，可读可写。ngx.var.arg_need_encode为读取need_encode变量，ngx.var.uri为读取请求URI。

ngx.header.content_length =nil
1
2
3
4
5
6
7
8
--lua/http_access.lua文件
local white_list={['127.0.0.1']=1}
local ip =ngx.var.remote_addr --获取请求ip地址

if not white_list[ip] then --检查是否在自名单
    ngx.log(ngx.ERR, ip," is blocked")
    ngx.exit(403)
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
--lua/http_content.lua文件
local function action_get() --处理GET请求的函数
    ngx.req.discard_body() --显式丢弃请求体
    local t =ngx.time() --获取当前时间戳
    ngx.say(ngx.http_time(t)) --输出
end

local function action_post() --处理POST请求的函数
    ngx.req.read_body() --非阻塞的读取请求体
    local data = ngx.req.get_body_data() --获取请求体数据
    local num =tonumber(data)
    if not num then --判断请求参数是否正确
        ngx.log(ngx.ERR,"not a num") -- 记录错误日志
        ngx.exit(400) --返回状态码400，结束请求
    end
    ngx.say(ngx.http_time(num)) --输出
end

local actions ={
    GET = action_get,
    POST = action_post
}

local method =ngx.req.get_method() --获取请求方法
actions[method]() --执行对应的处理函数
1
2
3
4
5
6
7
8
9
--lua/http_filter.lua文件
if ngx.status ~= ngx.HTTP_OK then --判断是否200正常响应，状态码常量有200正常,302重定向,400请求错误,401未认证,403禁止访问,404未找到,500服务器内部错误,502网关错误,503不可用,504网关超时等
    return
end

if ngx.ctx.encode then --检查是否要进行编码
    ngx.log(ngx.WARN,"need to encode")
    ngx.arg[1] =ngx.encode_base64(ngx.arg[1]) --改写响应体数据,对数据做 Base64 编码
end

四、访问后端

OpenResty可以通过后台通信，与Redis、Mysql、消息队列、tomcat等业务服务，ZooKeeper等配置服务等，构建复杂的业务逻辑，变身为动态网关。

子请求（location capture）

  • 是较传统的方式，基于Nginx平台内部的子请求机制，需要配合Nginx反向代理模块（如ngx_proxy,ngx_redis2,ngx_fastcgi等），间接地访问后端服务，接口参数较多，调用成本也略高。
  • 基本原理是在本请求内向另外的location再发起一个HTTP请求一这被称为子请求，原请求则称为父请求，并完整地“捕获”处理后的所有数据，就像是调用了location。
  • ngx.location.capture只能在rewrite_by_lua、access_by_lua和content_by_lua三个执行阶段。
  • 缺点是配置不够灵活，需要访问新的后端必须要改写文件，配置新的location。如果后端服务没有对应的nginx模块就需要用C语言开发，难度较大。
1
2
3
4
5
6
7
8
9
10
11
location = /hello {
    proxy set header Host $host; # 使用ngx_proxy模块访问http服务
    proxy_pass http://127.0.0.1/hello;  #反向代理到一个http服务器
}

location = /ngx_redis2 {  #使用ngx_redis2模块访问redis服务
    set unescape_uri $key $arg_key; #设置查询的key
    redis2_query get $key ; #使用get命令获取数据
    redis2_pass 127.0.0.1:6379; #反向代理到一个Redis服务器
}

1
2
3
4
5
6
7
8
local capture = ngx.location.capture --别名简化调用
local res = capture('/hello') --调用'/hello'，访问HTTP服务
ngx.print(res.body)

local res = capture('/ngx_redis2',--调用'/ngx_redis2'，访问Redis服务
                    {args={key='metroid'}}) --使用表传递URI参数key 
ngx.print(res.body)

协程套接字（corountine based socket，cosocket）

  • 是OpenResty独有的特性，结合了Nginx的事件机制和Lua的协程特性，以同步非阻塞的方式实现了socket编程，高效的与任意的后端服务通信。
  • 利用bit/ffi库解析二进制数据，能够支持任意的通信协议。
  • 内建了连接池机制，实现了长连接。支持TCP、UDP和UNIX Domain Socket。
  • 能在rewrite_by_lua、access_by_lua、content_by_lua、ssl_certificate_by_lua和ngx.timer里运行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
local sock = ngx.socket.tcp() --创建cosocket对象
sock:settimeout(1000) --设置超时时间为1000毫秒
local ok , err = sock:connect("127.0.0.1",900) --同步非阻塞连接后端服务器,指定指IP和端口号

--发送数据使用lua-resty-msgpack库
local mp = require "resty.msgpack" --加载msgpack库
local msg = {str = ”hello“，num = 3} --一个简单的消息
local body = mp.pack(msg) --编码消息，作为body
local header = mp.pack(#body) --编码长度，作为header
local _ , err = sock:send(header..body)  --同步非阻塞发送数据

--接收数据
local data, err = sock:receive("*a") --同步非阻 读取所有数据
local iter = mp.unpacker(data) --使用 MessagePack 迭代器解码数据
local _, len=iter() --解码头字段，数据的长度
local _, msg=iter() --解码字符串

ngx.say ("len:", len,"data:", msg) --输出服务器返回的结果
sock:setkeepalive() --最后放入连接池 ，复用连接

其他功能

  • DNS客户端，使用lua-resty-dns库来实现域名解析功能
  • HTTP客户端，使用lua-resty-http库来实现HTTP协议的接口调用
  • WebSocket客户端，使用lua-resty-websocket库来实现WebSocket协议的接口调用
  • Redis客户端，使用lua-resty-redis库来实现Redis命令和管道操作
  • Mysql客户端，使用lua-resty-mysql库来实现Mysql数据库操作

以下为redis的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
local redis = require "resty.redis" --加载resty.redis模块
local rds = redis:new() --新建一个redis连接对象
rds:set_timeout(1000) --设置超时时间

ok,err =rds:connect("127.0.0.1",6379) --连接Redis服务器
if not ok then
    ngx.say("connect redis err")
    rds:close() --连接失败需要关闭释放连接
    return
end
ok,err=rds:set("name","iherr") --向Redis写入数据
res,err =rds:get("name") --从Redis读取数据
ngx.say(res)

ok , err = rds:hset ('x1','x2', 2017) --设置散列数据
res, err = rds:hget ('x1','x2') --读取散列数据
ngx.say(res)

ok , err = rds:del('list') --删除一个键
ok , err = rds:lpush('list', 1 , 2 , 3 , 4 ) --向列表添加多个元素
res, err = rds:lpop('list')  --从列表弹出一个元素
ngx.say(res)

以下为mysql的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
local mysql = require("resty.mysql") --加载msyql库
db,err =mysql:new() --创建数据库对象

if not db then
    ngx.say("mysql error") --检查数据库对象是否创建成功
    return
end
db:set_timeout(1000) --设置超时时间为1000ms
local opts={ --指定连接mysql的参数
    host ="127.0.0.1",
    port =3306,
    database= 'test',
    user='root',
    password='123'
}
local ok,err =db:connect(opts) --连接数据库
if not ok then --检查是否连接成功
    ngx.say("connect mysql err")
    db:close() --连接失败需要关闭释放连接
    return
end
local res,err =db:query("select * from user",1) --简单查询
for i, rows in ipairs(res) do --遍历结果集数组
    for k, v in pairs(rows) do --逐个输出字段和值
        ngx.say(k," = ", v,";")
    end
end

五、高级特性

反向代理

上游集群配置如下，

1
2
3
4
5
6
7
8
upstream backend1{  #第1个上游集群
    server x1.iherr.cn weight=2; 
    server x2.iherr.cn max_fails=5; 
}
upstream backend2{ #第2个上游集群
    server 127.0.0.1:83;  #主服务器
    server 127.0.0.1:84 backup;  #备份服务器
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
local upstream = require "ngx.upstream" --显式加载ngx.upstream库
-- 静态服务器信息
names = upstream.get_upstreams() --获取 upstream 块的名字
servers, err = upstream.get_servers(upstream_name) --获取块内的server信息

--动态服务器信息
peers,err = upstream.get_primary_peers(upstream_name) --主服务器信息
peers,err = upstream.get_backup_peers(upstream_name) --备份服务器信息

--上线或下线服务器
upstream.set_peer_down( --主动下线1个服务器
    "backend2", false , 0 , true) --backend2里的第0号主服务器
upstream.set_peer_down ( --上线一个服务器，参数是 false
    "backend2", false , 0 , false)  --backend2里的第0号主服务器

--当前上游服务器
local name = upstream.current_upstream_name() --当前正在使用的upstream块
local addr = ngx.var.upstream_addr --反向代理的上游IP地址

共享内存

  • 共享内存是进程间通信（IPC）的一种常用手段，它在系统内存里开辟了一个特别的区域，多个进程可以共享所有权读写数据，比起信号、管道、消息队列、套接字等其他方式来说速度
    更快，也更加灵活实用。
  • OpenResty内置了强大的共享内存功能，不仅支持简单的数据存取，还支持原子计数和队列操作，用起来就像是一个微型的Redis数据库，极大地便利了worker进程间的通信和协作。
  • OpenResty 共享内存里存储的数据只能是布尔、数字、字符串这三种类型。
  • 使用时需要在nginx配置文件的http块里进行定义。lua_shared_dict dict size; #定义1个名为dict的共享内存，大小为size
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
--共享内存提供对象读写删除操作
local dict =ngx.shared.dict --获取共享内存对象，dict为在配置文件配置的共享内存名称
local ok,err,f --ok代表写入是否成功，err是错误原因，f为forcible 淘汰动作执行标志，用于当内存满了的时候，根据LRU算法淘汰数据后尝试写入

ok,err,f=dict:set("num",1,0.5) --写入1个值，0.5秒后过期。如果内存已满，会淘汰数据。如使用safe_set函数，则不会淘汰数据，而是写入失败。
assert(ok and not f) --写入成功，未淘汰数据
ok,err,f=dict:add("num",1) --新增数据，键值相同，只有key不存在才会写入。如使用safe_add函数，则不会淘汰数据，而是写入失败。
assert(not ok) --新增失败，已有该键值
ok,err,f=dict:replace("num",2) --改写数据，只有key存在才会写入
assert(ok) --改写成功
ok,err,f=dict:replace("ver",2) --改写数据，只有key存在才会写入
assert(not ok) --改写失败
ok,err,f=dict:safe_add("ver",1,0,1) --写入1个值，永不过期，flags为1。如果内存已满，则不会淘汰数据，而是写入失败。
assert(ok and not f) --写入成功，未淘汰数据

local v,flags =dict:get("ver") --获取之前add的数据
ngx.sleep(1) --非阻塞睡眠1秒
local v,err,stale= dict:get_stale("num") --获取可能过期的数据

dict:delete("ver") --删除共享内存里的数据

--incr操作是多进程安全的原子计数操作，类似于redis
local v=dict:incr("count",1,0) --count初始为0，加1，返回值是1
local v=dict:incr("count",5) --count加5，返回值是6

--共享内存也提供redis队列的操作
local len=dict:lpush('list','a') --左端添加字符a
local len=dict:rpush('list','z') --右端添加字符z
local len=dict:llen('list') --获取队列长度
local v = dict:lpop('list') --左端弹出字符a
local v = dict:rpop('list') --右端弹出字符z

--其他操作
local ok,err =dict:set("data",100,0.02) --过期时间0.02s
local ttl =dict:ttl("data") --获取过期时间

ngx.sleep(0.1)
v,_,stale=dict:get_stale("data") --数据已过期，stale为true
ok,err =dict:expire("data",0.1) --重新设置过期时间
--函数flush_all会将共享内存的所有key均设置为过期，flush_expired会彻底清空释放内存

定时器

  • 定时器可以在任意处理阶段发起任意多个定时器，执行任意的功能。
  • 使用lua_max_pending_timers num来限制排队的任务数量。使用lua_max_running_timers num来限制最多可同时运行的定时任务数量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
-- ok,err=ngx.timer.at(delay,handler,...) --启动单次任务定时器，delay秒后开始

local function once_task (premuture,uri) --定时器的回调函数
    if premuture then --检查进程是否处于退出阶段
        ngx.log(ngx.WARN, uri,": task abort")
        return --即结束任务
    end
    local http = require "resty.http" --lua_resty_http库
    local httpc = http:new() --创建http连接对象
    local res, err = httpc:request_uri("xxx") --访问后端服务
    ngx.log(ngx.ERR, uri,": task success") --记录日志
end
local ok ,err = ngx.timer.at (0.1,once_task,ngx.var.uri) --启动定时器，传递了一个参数
if not ok then --检查定时器是否创建成功
    ngx.say("timer failed :", err)
end

--周期任务定时器
local function cycle_task (premuture,name) --定时器的回调函数
    if premuture then --检查进程是否处于退出阶段
        return --结束任务
    end
    ngx.shared[name]:incr("count",1,0) --共享内存原子计数
end

local ok,err =ngx.timer.every(60,cycle_task,"dict") --启动定时器，每1分钟运行一次

进程管理

  • OpenResty的进程模型基于nginx，以master/worker多进程方式提供服务。新增了一个拥有root权限的特权进程。
  • 进程管理位于ngx.process库，它是lua-resty-core库的一部分。
  • OpenResty进程有六种类型：single单一进程，master监控进程，signaller信号进程，worker工作进程，helper辅助进程，privileged agent特权进程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
--进程类型
local process =require "ngx.process" --显式加载ngx.process库
local str =process.type() --获取当前的进程类型
ngx.say("type is ",str) --通常是"worker"

--工作进程
ngx.say("count = ",ngx.worker.count()) --worker进程数量
ngx.say("pid = ",ngx.worker.pid()) --系统进程号
ngx.say("id = ",ngx.worker.id()) --进程的内部唯一顺序号
ngx.say("status = ",ngx.worker.exiting()) --是否处于exiting阶段
process.signal_gracefull_exit() --主动“自杀”

--启用特权进程，只能在init_by_lua阶段启用
local ok,err =process.enable_privileged_agent() --启用特权进程，可以实现服务的自我管理

轻量级线程

  • OpenResty本质是多进程单线程的，每个worker里只有一个主线程，通过I/O多路复用机制（epoll/kqueue）实现服务。
  • 基于Lua的协程提出了轻量级线程概念，类似于操作系统的线程，可并发运行，但不是通过系统内核来调度。
  • 轻量级线程只能在rewrite_by_lua、access_by_lua、content_by_lua、ssl_certificate_by_lua和ngx.timer里使用。
  • OpenResty使用ngx.semaphore提供信号量操作，能实现高级的线程同步功能。信号量是线程同步的经典手段，但只能在本进程的线程之间同步，不能跨进程生效。不同进程的线程同步必须使用共享内存。
  • 信号量有4个操作方法，new新建一个信号量，wait等待信号量，post增加信号量，count获取当前信号量的数量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
--启动线程
local spawn =ngx.thread.spawn --别名方便调用
local function task(v)
    ngx.sleep(v)
    ngx.say("query redis in ",v)
    return v
end

local t1=spawn(task,1) --第1个线程，运行1s
local t2=spawn(task,2) --第2个线程，运行2s
local threads={t1,t2} --使用数组保存启动的多个线程

-- 等待线程
local wait =ngx.thread.wait --别名方便调用
local ok, v=wait(unpack(threads)) --等待任意一个线程结束
ngx.say("wait =",ok," v = ",v) --输出"wait = true v = 1"

--杀死进程
local kill =ngx.thread.kill --别名方便调用
local ok, v=wait(unpack(threads)) --等待任意一个线程结束
for i,t in ipaires(threads) do --检查线程数组里的所有线程
    ngx.say("kill ",i," is ",kill(t)) --杀死尚在运行的线程
end

--挂起线程
local function f() --在线程里执行的函数
    local co = coroutine.running() --获得当前所在的协程对象
    ngx.say(1)
    coroutine.yield(co) --暂时挂起协程，让出执行权
    ngx.say(2)
end

local function g()
    local co = coroutine.running()
    ngx.say('a')
    coroutine.yield(co)
    ngx.say('b')
end

spawn(f)
spawn(g) --交替输出数字和字母，即yield操作让两个线程依次让出执行权

--信号量
local semaphore =require "ngx.semaphore" --加载信号量库
local sema =semaphore.new(0)

local function producer(n)  --生产者线程
    for i = 1, n do --生产n个资源
        dict.rpush('logs','xxx') --使用共享内存队列
        sema:post() --post通知消费者线程
        ngx.sleep(0.1) --睡眠0.1秒后再生产数据
    end
end

local function consumer(n)  --消费者线程
    for i = 1, n do --消费n个资源
        local ok,err =sema:wait(0.2) --等待信号量通知，最多0.2秒
        if not ok then --检查信号量操作是否成功
            ngx.say("failed: ",err)
            return
        end
    end
end

local threads ={ --分别启动两个线程
    spawn(producer,3), --生产者线程
    spawn(consumer,3), --消费者线程
}

HTTPS服务

  • OpenResty为HTTPS服务增加了关键指令，”ssl_certificate_by_lua”，能在SSL/TLS握手阶段执行Lua代码，实现各种优化。
  • 常用的手段有利用ngx.ssl动态加载整数，利用ngx.ocsp动态查验证书，以及Session ID和Session Ticket会话复用。
  • 会话复用的原理是，由于https有安全成本，当第一次握手时认证身份，获取了通信的密钥，可以把这个密钥保存起来供下次通信时直接使用。
  • 搭建HTTPS服务的常见配置如下。
1
2
3
4
5
6
7
8
9
server {
    listen 443 ssl; #监听443端口，启用SSL
    server_name *.*;

    ssl_certificate ssl/a.crt; #目录conf/ssl下的证书文件
    ssl_certificate_key ssl/a.key; #目录conf/ssl下的私钥文件
    ssl_session_timeout 10m; # 会话超时时间为10分
    ssl_prefer_server_ciphers on; #优先使用服务器的加密算法
}

HTTP2服务

HTTP2协议脱胎于SPDY协议，是HTTP 1.0/1.1的升级和优化，主要解决网络性能问题。HTTP2的改进包括：

  • 二进制格式，非明文协议，将数据分为数据帧，更利于组织和传输
  • 多路复用，允许使用单个连接同时发起多个请求，不受数 的限制
  • 请求优先级，高优先级的请求可以更快地获得响应
  • 流量控制，类似TCP的流量控制机制，使用窗口避免拥塞
  • 头部压缩，使用专用的HPACK算法压缩冗余的头部信息
  • 服务端推送，服务器可以主动向客户端发送可能需要的资源
  • 安全性增强，禁用了数百种不再安全的算法，减少了被攻破的可能
  • 不强制加密，允许用户在安全与性能间做出自己的选择

如需要支持HTTP2，需要编译时configure使用选项”–with-http_v2_module”开启。

1
2
3
4
5
6
7
8
9
server{
    listen 443 ssl http2; --启用SLL和HTTP2
}

location / {
    content_by_lua_block{
        ngx.say("hello ",ngx.var.http2) # 输出HTTP2协议特有的变量
    }
}

可以让curl发送HTTP2请求

1
curl --http2 -k 'https://127.0.0.1:443/' #请求HTTP2服务，-k为不验证证书

websocket服务

  • WebSocket是为了解决现有HTTP协议的缺陷，即实现双方向的实时通信，避免通过HTTP协议轮询。
  • WebSocket使用HTTP协议通过握手动作建立连接，之前基于TCP的全双工通信协议。在建立连接的初始阶段完全兼容HTTP协议，因此服务的配置文件中和传统http配置相同。
  • OpenResty内置lua-resty-websocket库来支持WebSocket功能，调用resty.websocket.server提供的接口来实现服务端功能。

TCP/UDP服务

  • Nginx 1.9.0引入steam子系统后，可以处理TCP/UDP协议。OpenResty也实现了运行在stream块里的stream_lua模块。
  • OpenResty也会对每个TCP/UDP请求使用流水线顺序进行处理，处理阶段和http有差异，如access阶段发生在ssl之前，没有rewrite阶段等。
  • OpenResty主要聚焦在HTTP开发，目前还无法做到ngx_lua的完善程序。

安全防护

安全防护主要应用场景：

  • 基本算法
  • 防止SQL注入
  • 访问权限控制
  • 策略限速限连
  • WAF

使用lua-resty-limit-traffic，实现服务限制，10 req/s。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
lua_shared_dict lim_req_store lOm; #定义多进程间使用的共享内存

server {  #限速的服务器
    listen 87; 
    location / { 
        access_by_lua_block {  #在access阶段限速
            local limit_req = require "resty.limit.req"  #加载功能库
            local lim, err =  #创建限速规
            limit_req.new ("limit_req_store", 10 , 5)  #需要使用共享内存
            local key=ngx.var.binary_remote_addr #限速使用的键值
            local delay,err = lim:incoming(key,true) #计算是否应当限速
            if not delay then
                if err =="reject" then #reject则拒绝访问
                    return ngx.exit(503)
                end
                return ngx.exit(500) #其他意外错误
            end

            if delay > 0 then  #应当延后的时间
                ngx.sleep(delay) #延后再响应请求
            end
        }
        
        content by lua block { ... }  #正常的内容处理逻辑
    }
}

六、Tengine

『Tengine』是淘宝团队在nginx基础上，针对大访问量网站的需求，添加了很多高级功能和特性。

特性包括：

  • 继承Nginx-1.18.0的所有特性，兼容Nginx的配置；
  • 支持HTTP的CONNECT方法，可用于正向代理场景；
  • 增强相关运维、监控能力,比如异步打印日志及回滚,本地DNS缓存,内存监控等；
  • Stream模块支持server_name指令；
  • 更加强大的负载均衡能力，包括一致性hash模块、会话保持模块，还可以对后端的服务器进行主动健康检查，根据服务器状态自动上线下线，以及动态解析upstream中出现的域名；
  • 输入过滤器机制支持。通过使用这种机制Web应用防火墙的编写更为方便；
  • 支持设置proxy、memcached、fastcgi、scgi、uwsgi在后端失败时的重试次数；
  • 动态脚本语言Lua支持。扩展功能非常高效简单；
  • 支持按指定关键字(域名，url等)收集Tengine运行状态；
  • 组合多个CSS、JavaScript文件的访问请求变成一个请求；
  • 自动去除空白字符和注释从而减小页面的体积

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true