Openresrt最佳案例
第1篇：Nginx介绍
Nginx是一个高性能的Web 服务器，同时是一个高效的反向代理服务器，它还是一个IMAP/POP3/SMTP 代理服务器。
由于Nginx采用的是事件驱动的架构，能够处理并发百万级别的tcp连接，高度的模块化设计和自由的BSD许可，使得Nginx有着非常丰富的第三方模块。比如Openresty、API网关Kong。
BSD开源协议是一个给予使用者很大自由的协议。基本上使用者可以”为所欲为”,可以自由的使用，修改源代码，也可以将修改后的代码作为开源或者专有软件再发布。
Nginx的优点
- 高并发响应性能非常好，官方Nginx处理静态文件并发5w/s
- 反向代理性能非常强。（可用于负载均衡）
- 内存和cpu占用率低。（为Apache的1/5-1/10）
- 对后端服务有健康检查功能。
- 支持PHP cgi方式和fastcgi方式。
- 配置代码简洁且容易上手。
Nginx的安装
Centos系统安装，请参考这里http://www.linuxidc.com/Linux/2016-09/134907.htm。先复制粘贴下它的文章。
1.gcc 安装
安装 nginx 需要先将官网下载的源码进行编译，编译依赖 gcc 环境，如果没有 gcc 环境，则需要安装：
yum install gcc-c++
2.PCRE pcre-devel 安装
PCRE(Perl Compatible Regular Expressions) 是一个Perl库，包括 perl 兼容的正则表达式库。nginx 的 http 模块使用 pcre 来解析正则表达式，所以需要在 linux 上安装 pcre 库，pcre-devel 是使用 pcre 开发的一个二次开发库。nginx也需要此库。命令：
yum install -y pcre pcre-devel
3.zlib 安装
zlib 库提供了很多种压缩和解压缩的方式， nginx 使用 zlib 对 http 包的内容进行 gzip ，所以需要在 Centos 上安装 zlib 库。
yum install -y zlib zlib-devel
4.OpenSSL 安装
OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及 SSL 协议，并提供丰富的应用程序供测试或其它目的使用。 nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http），所以需要在 Centos 安装 OpenSSL 库。
yum install -y openssl openssl-devel
5.官网下载
1.直接下载.tar.gz安装包，地址：https://nginx.org/en/download.html
2.使用wget命令下载（推荐）。
6.解压
依然是直接命令：
tar -zxvf nginx-1.10.1.tar.gz cd nginx-1.10.1
7.配置
其实在 nginx-1.10.1 版本中你就不需要去配置相关东西，默认就可以了。当然，如果你要自己配置目录也是可以的。 使用默认配置
./configure
8.编译安装
make make install
查找安装路径：
whereis nginx
Nginx的模块组成
Nginx的模块从结构上分为核心模块、基础模块和第三方模块：
- 核心模块：HTTP模块、EVENT模块和MAIL模块
- 基础模块：HTTP Access模块、HTTP FastCGI模块、HTTP Proxy模块和HTTP Rewrite模块，
- 第三方模块：HTTP Upstream Request Hash模块、Notice模块和HTTP Access Key模块。
Nginx的高并发得益于其采用了epoll模型，与传统的服务器程序架构不同，epoll是linux内核2.6以后才出现的。Nginx采用epoll模型，异步非阻塞，而Apache采用的是select模型。
- Select特点：select 选择句柄的时候，是遍历所有句柄，也就是说句柄有事件响应时，select需要遍历所有句柄才能获取到哪些句柄有事件通知，因此效率是非常低。
- epoll的特点：epoll对于句柄事件的选择不是遍历的，是事件响应的，就是句柄上事件来就马上选择出来，不需要遍历整个句柄链表，因此效率非常高。
Nginx常用命令
nginx 环境变量配置：
export PATH=$PATH:/usr/servers/nginx/sbin
- 查看nginx进程 ps -ef|grep nginx
- 启动nginx nginx 启动结果显示nginx的主线程和工作线程，工作线程的数量跟nginx.conf中的配置参数worker_processes有关。
- 平滑启动nginx kill -HUP
cat /var/run/nginx.pid或者 nginx -s reload - 强制停止nginx pkill -9 nginx
- 检查对nginx.conf文件的修改是否正确 nginx -t
- 停止nginx的命令 nginx -s stop或者pkill nginx
- 查看nginx的版本信息 nginx -v
- 查看完整的nginx的配置信息 nginx -V
Nginx的配置
通常情况下，Nginx的配置在Ngix的安装目录下的/conf/config.default 文件里,基本配置如下：
worker_process # 表示工作进程的数量，一般设置为cpu的核数
worker_connections # 表示每个工作进程的最大连接数
server{} # 块定义了虚拟主机
listen # 监听端口
server_name # 监听域名
location {} # 是用来为匹配的 URI 进行配置，URI 即语法中的“/uri/”
location /{} # 匹配任何查询，因为所有请求都以 / 开头
root # 指定对应uri的资源查找路径，这里html为相对路径，完整路径为
# /opt/nginx-1.7.7/html/
index # 指定首页index文件的名称，可以配置多个，以空格分开。如有多
# 个，按配置顺序查找。
location 常用配置如下：
| 模式 | 含义 |
|---|---|
| location = /uri | = 表示精确匹配，只有完全匹配上才能生效 |
| location ^~ /uri | ^~ 开头对URL路径进行前缀匹配，并且在正则之前。 |
| location ~ pattern | 开头表示区分大小写的正则匹配 |
| location ~* pattern | 开头表示不区分大小写的正则匹配 |
| location /uri | 不带任何修饰符，也表示前缀匹配，但是在正则匹配之后 |
| location / | 通用匹配，任何未匹配到其它location的请求都会匹配到，相当于switch中的default |
Nginx的常用配置非常多，以下内容摘自于布尔教育课件，仅供参考：
#定义Nginx运行的用户和用户组
user www www;
#启动进程,通常设置成和cpu的数量相等
worker_processes 8;
worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000;
#为每个进程分配cpu，上例中将8个进程分配到8个cpu，当然可以写多个，或者将一个进程分配到多个cpu。
worker_rlimit_nofile 102400;
#这个指令是指当一个nginx进程打开的最多文件描述符数目，理论值应该是最多打
#开文件数（ulimit -n）与nginx进程数相除，但是nginx分配请求并不是那么均匀
#，所以最好与ulimit -n的值保持一致。
#全局错误日志及PID文件
error_log /usr/local/nginx/logs/error.log;
#错误日志定义等级，[ debug | info | notice | warn | error | crit ]
pid /usr/local/nginx/nginx.pid;
#一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（系统的值ulimit -n）与nginx进程数相除，但是nginx分配请求并不均匀.
#所以建议与ulimit -n的值保持一致。
worker_rlimit_nofile 65535;
#工作模式及连接数上限
events {
use epoll; #epoll是多路复用IO(I/O Multiplexing)中的一种方式,但是仅用于linux2.6以上内核,可以大大提高nginx的性能
worker_connections 102400; #单个后台worker process进程的最大并发链接数 （最大连接数=连接数*进程数）
multi_accept on; #尽可能多的接受请求
}
#设定http服务器，利用它的反向代理功能提供负载均衡支持
http {
#设定mime类型,类型由mime.type文件定义
include mime.types;
default_type application/octet-stream;
#设定日志格式
access_log /usr/local/nginx/log/nginx/access.log;
sendfile on;
#sendfile 指令指定 nginx 是否调用 sendfile 函数（zero copy 方式）来输出文件，对于普通应用必须设为 on
#如果用来进行下载等应用磁盘IO重负载应用，可设置为 off，以平衡磁盘与网络I/O处理速度，降低系统的uptime.
#autoindex on; #开启目录列表访问，合适下载服务器，默认关闭。
tcp_nopush on; #防止网络阻塞
keepalive_timeout 60;
#keepalive超时时间，客户端到服务器端的连接持续有效时间,当出现对服务器的后,继请求时,keepalive-timeout功能可避免建立或重新建立连接。
tcp_nodelay on; #提高数据的实时响应性
#开启gzip压缩
gzip on;
gzip_min_length 1k;
gzip_buffers 4 16k;
gzip_http_version 1.1;
gzip_comp_level 2; #压缩级别大小，最大为9，值越小，压缩后比例越小，CPU处理更快。
#值越大，消耗CPU比较高。
gzip_types text/plain application/x-javascript text/css application/xml;
gzip_vary on;
client_max_body_size 10m; #允许客户端请求的最大单文件字节数
client_body_buffer_size 128k; #缓冲区代理缓冲用户端请求的最大字节数，
proxy_connect_timeout 90; #nginx跟后端服务器连接超时时间(代理连接超时)
proxy_send_timeout 90; #后端服务器数据回传时间(代理发送超时)
proxy_read_timeout 90; #连接成功后，后端服务器响应时间(代理接收超时)
proxy_buffer_size 4k; #设置代理服务器（nginx）保存用户头信息的缓冲区大小
proxy_buffers 4 32k; #proxy_buffers缓冲区，网页平均在32k以下的话，这样设置
proxy_busy_buffers_size 64k; #高负荷下缓冲大小（proxy_buffers*2）
#设定请求缓冲
large_client_header_buffers 4 4k;
client_header_buffer_size 4k;
#客户端请求头部的缓冲区大小，这个可以根据你的系统分页大小来设置，一般一个请求的头部大小不会超过1k
#不过由于一般系统分页都要大于1k，所以这里设置为分页大小。分页大小可以用命令getconf PAGESIZE取得。
open_file_cache max=102400 inactive=20s;
#这个将为打开文件指定缓存，默认是没有启用的，max指定缓存数量，建议和打开文件数一致，inactive是指经过多长时间文件没被请求后删除缓存。
open_file_cache_valid 30s;
#这个是指多长时间检查一次缓存的有效信息。
open_file_cache_min_uses 1;
#open_file_cache指令中的inactive参数时间内文件的最少使用次数，如果超过这个数字，文件描述符一直是在缓存中打开的，如上例，如果有一个文件在inactive
#包含其它配置文件，如自定义的虚拟主机
include vhosts.conf;
}
配置详解2如下：
#这里为后端服务器wugk应用集群配置，根据后端实际情况修改即可，tdt_wugk为负载均衡名称，可以任意指定
#但必须跟vhosts.conf虚拟主机的pass段一致，否则不能转发后端的请求。weight配置权重，在fail_timeout内检查max_fails次数，失败则剔除均衡。
upstream tdt_wugk {
server 127.0.0.1:8080 weight=1 max_fails=2 fail_timeout=30s;
server 127.0.0.1:8081 weight=1 max_fails=2 fail_timeout=30s;
}
#虚拟主机配置
server {
#侦听80端口
listen 80;
#定义使用www.wuguangke.cn访问
server_name www.wuguangke.cn;
#设定本虚拟主机的访问日志
access_log logs/access.log main;
root /data/webapps/wugk; #定义服务器的默认网站根目录位置
index index.php index.html index.htm; #定义首页索引文件的名称
#默认请求
location ~ /{
root /data/www/wugk; #定义服务器的默认网站根目录位置
index index.php index.html index.htm; #定义首页索引文件的名称
#以下是一些反向代理的配置.
proxy_next_upstream http_502 http_504 error timeout invalid_header;
#如果后端的服务器返回502、504、执行超时等错误，自动将请求转发到upstream负载均衡池中的另一台服务器，实现故障转移。
proxy_redirect off;
#后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://tdt_wugk; #请求转向后端定义的均衡模块
}
# 定义错误提示页面
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
#配置Nginx动静分离，定义的静态页面直接从Nginx发布目录读取。
location ~ .*\.(html|htm|gif|jpg|jpeg|bmp|png|ico|txt|js|css)$
{
root /data/www/wugk;
#expires定义用户浏览器缓存的时间为3天，如果静态页面不常更新，可以设置更长，这样可以节省带宽和缓解服务器的压力。
expires 3d;
}
#PHP脚本请求全部转发到 FastCGI处理. 使用FastCGI默认配置.
location ~ \.php$ {
root /root;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /data/www/wugk$fastcgi_script_name;
include fastcgi_params;
}
#设定查看Nginx状态的地址
location /NginxStatus {
stub_status on;
}
}
}
Nginx 内置绑定变量
| 名称 | 说明 |
|---|---|
| $arg_name | 请求中的name参数 |
| $args | 请求中的参数 |
| $binary_remote_addr | 远程地址的二进制表示 |
| $body_bytes_sent | 已发送的消息体字节数 |
| $content_length HTTP | 请求信息里的”Content-Length” |
| $content_type | 请求信息里的”Content-Type” |
| $document_root | 针对当前请求的根路径设置值 |
| \(document_uri | 与\)uri相同; 比如 /test2/test.php | |
| $host | 请求信息中的”Host”，如果请求中没有Host行，则等于设置的服务器名 |
| $hostname | 机器名使用 gethostname系统调用的值 |
| $http_cookie | cookie 信息 |
| $http_referer | 引用地址 |
| $http_user_agent | 客户端代理信息 |
| $http_via | 最后一个访问服务器的Ip地址。 |
| $http_x_forwarded_for | 相当于网络访问路径 |
| $is_args | 如果请求行带有参数，返回“?”，否则返回空字符串 |
| $limit_rate | 对连接速率的限制 |
| $nginx_version | 当前运行的nginx版本号 |
| $pid worker | 进程的PID |
| \(query_string | 与\)args相同 | |
| $realpath_root | 按root指令或alias指令算出的当前请求的绝对路径。其中的符号链接都会解析成真是文件路径，使用 Nginx 内置绑定变量 |
| 207$remote_addr | 客户端IP地址 |
| $remote_port | 客户端端口号 |
| $remote_user | 客户端用户名，认证用 |
| $request | 用户请求 |
| $request_body | 这个变量（0.7.58+） 包含请求的主要信息。在使用proxy_pass或fastcgi_pass指令的location中比较有意义 |
| $request_body_file | 客户端请求主体信息的临时文件名 |
| $request_completion | 如果请求成功，设为”OK”；如果请求未完成或者不是一系列请求中最后一部分则设为空 |
| $request_filename | 当前请求的文件路径名，比如/opt/nginx/www/test.php |
| $request_method | 请求的方法，比如”GET”、”POST”等 |
| $request_uri | 请求的URI，带参数 |
| $scheme | 所用的协议，比如http或者是https |
| $server_addr | 服务器地址，如果没有用listen指明服务器地址，使用这个变量将发起一次系统调用以取得地址(造成资源浪费) |
| $server_name | 请求到达的服务器名 |
| $server_port | 请求到达的服务器端口号 |
| $server_protocol | 请求的协议版本，”HTTP/1.0”或”HTTP/1.1” |
| $uri | 请求的URI，可能和最初的值有不同，比如经过重定向之类的 |
第2篇：Lua入门
Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
Lua 是巴西里约热内卢天主教大学（Pontifical Catholic University of Rio de Janeiro）里的一个研究小组，由Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de Figueiredo所组成并于1993年开发。 —摘抄 http://www.runoob.com/lua/lua-tutorial.html
环境搭建
注意： 在上一篇文章中，OpenResty已经有了Lua的环境，这里安装的是单独的Lua环境，用于学习和开发Lua。大多数的电脑是Windowds版本的电脑，Windows版本下载地址http://luaforge.net/projects/luaforwindows/。
Linux和Mac电脑下载地址：http://luajit.org/download.html，安装命令如下：
wget http://luajit.org/download/LuaJIT-2.1.0-beta1.tar.gz
tar -xvf LuaJIT-2.1.0-beta1.tar.gz
cd LuaJIT-2.1.0-beta1
make
sudo make install
使用IDEA开发的同学，可以通过安装插件的形式来集成Lua的环境，插件名为EmmyLua，安装插件后，在Idea的右侧栏就会出现Lua的图标，点击图标，就会出现运行Lua代码的窗口。建议使用该插件，可以免去安装Lua环境的麻烦。
第一个Lua程序
安装好环境后，我采用EmmyLua插件的形式，对Lua的入门语法进行一个简单的讲解。 打开EmmyLua的终端，在终端上输入：
print("hi you")
按ctrl+enter，终端显示：
hi you
Lua基本数据类型
lua的基本数据类型有nil、string、boolean、number、function类型。
nil 类型
nil类似于Java中的null ，表示空值。变量第一次赋值为nil。
local num
print(num)
num=100
print(num)
终端输出：
nil
100
number (数字)
Number 类型用于表示实数，和 Java里面的 double 类型很类似。可以使用数学函数 math.floor（向下取整） 和 math.ceil（向上取整） 进行取整操作。
local order = 3.99
local score = 98.01
print(math.floor(order))
print(math.ceil(score))
输出：
3
99
string 字符串
Lua 中有三种方式表示字符串: 1、使用一对匹配的单引号。例：’hello’。 2、使用一对匹配的双引号。例：”abclua 3.字符串还可以用一种长括号（即[[ ]]） 括起来的方式定义
ocal str1 = 'hello world'
local str2 = "hello lua"
local str3 = [["add\name",'hello']]
local str4 = [=[string have a [[]].]=]
print(str1) -->output:hello world
print(str2) -->output:hello lua
print(str3) -->output:"add\name",'hello'
print(str4) --
table (表)
Table 类型实现了一种抽象的“关联数组”。“关联数组”是一种具有特殊索引方式的数组，索引通常是字符串（string） 或者 number 类型，但也可以是除 nil 以外的任意类型的值。
local corp = {
web = "www.google.com", --索引为字符串，key = "web",
-- value = "www.google.com"
telephone = "12345678", --索引为字符串
staff = {"Jack", "Scott", "Gary"}, --索引为字符串，值也是一个表
100876, --相当于 [1] = 100876，此时索引为数字
-- key = 1, value = 100876
100191, --相当于 [2] = 100191，此时索引为数字
[10] = 360, --直接把数字索引给出
["city"] = "Beijing" --索引为字符串
}
print(corp.web) -->output:www.google.com
print(corp["telephone"]) -->output:12345678
print(corp[2]) -->output:100191
print(corp["city"]) -->output:"Beijing"
print(corp.staff[1]) -->output:Jack
print(corp[10]) -->output:36
function(函数)
在 Lua 中，函数 也是一种数据类型，函数可以存储在变量中，可以通过参数传递给其他函 数，还可以作为其他函数的返回值。
local function foo()
print("in the function")
--dosomething()
local x = 10
local y = 20
return x + y
end
local a = foo --把函数赋给变量
print(a())
--output:
in the function
30
表达式
~= 不等于
| 逻辑运算符 | 说明 |
|---|---|
| and | 逻辑与 |
| or | 逻辑或 |
| not | 逻辑非 |
- a and b 如果 a 为 nil，则返回 a，否则返回 b;
- a or b 如果 a 为 nil，则返回 b，否则返回 a。
local c = nil
local d = 0
local e = 100
print(c and d) -->打印 nil
print(c and e) -->打印 nil
print(d and e) -->打印 100
print(c or d) -->打印 0
print(c or e) -->打印 100
print(not c) -->打印 true
print(not d) --> 打印 false
在 Lua 中连接两个字符串，可以使用操作符“..”（两个点）.
print("Hello " .. "World") -->打印 Hello World
print(0 .. 1) -->打印 01
控制语句
单个 if 分支 型
x = 10
if x > 0 then
print("x is a positive number")
end
两个分支 if-else 型
x = 10
if x > 0 then
print("x is a positive number")
else
print("x is a non-positive number")
end
多个分支 if-elseif-else 型:
score = 90
if score == 100 then
print("Very good!Your score is 100")
elseif score >= 60 then
print("Congratulations, you have passed it,your score greater or equal to 60")
--此处可以添加多个elseif
else
print("Sorry, you do not pass the exam! ")
end
for 控制结构
Lua 提供了一组传统的、小巧的控制结构，包括用于条件判断的 if 用于迭代的 while、repeat 和 for，本章节主要介绍 for 的使用.
for 数字型
for 语句有两种形式：数字 for（numeric for） 和范型 for（generic for） 。 数字型 for 的语法如下：
for var = begin, finish, step do
--body
end
实例1：
for i = 1, 5 do
print(i)
end
-- output:
1 2 3 4 5
实例2：
for i = 1, 10, 2 do
print(i)
end
-- output:
1 3 5 7 9
for 泛型
泛型 for 循环通过一个迭代器（iterator） 函数来遍历所有值：
-- 打印数组a的所有值
local a = {"a", "b", "c", "d"}
for i, v in ipairs(a) do
print("index:", i, " value:", v)
end
-- output:
index: 1 value: a
index: 2 value: b
index: 3 value: c
index: 4 value: d
lua的入门就到这里，因为lua语法虽少，但细节有很多，不可能花很多时间去研究这个。入个门，遇到问题再去查资料就行了。另外需要说明的是本文大部分内容为复制粘贴于OPenResty 最佳实践，感谢原作者的开源电子书，让我获益匪浅。更多内容请参考：
lua入门教程：http://www.runoob.com/lua/lua-tutorial.html
OPenResty 最佳实践： https://moonbingbing.gitbooks.io/openresty-best-practices/content/index.html
第3篇:Openresty的安装
我的服务器为一台全新的centos 7的服务器，所以从头安装openresty，并记录了安装过程中出现的问题，以及解决办法。
1.首先安装openresty
cd /usr
mkdir servers
mkdir downloads
yum install libreadline-dev libncurses5-dev libpcre3-dev libssl-dev perl
cd /usr/servers
wget https://openresty.org/download/openresty-1.11.2.4.tar.gz
tar -zxvf openresty-1.11.2.4.tar.gz
cd /usr/servers/bunble/LuaJIT-2.1-20170405
安装Lua
make clean && make && make install
安装过程中出现以下的错误：
gcc: Command not found
2.安装gcc
yum -y install gcc automake autoconf libtool make
3.重新make
make clean && make && make install
ln -sf luajit-2.1.0-alpha /usr/local/bin/luajit
4.下载ngx_cache_purge模块，该模块用于清理nginx缓存
cd /usr/servers/ngx_openresty–1.11.2.4/bundle
wget https://github.com/FRiCKLE/ngx_cache_purge/archive/2.3.tar.gz
tar -xvf 2.3.tar.gz
5.下载nginx_upstream_check_module模块，该模块用于ustream健康检查
cd /usr/servers/ngx_openresty-1.11.2.4/bundle
wget https://github.com/yaoweibin/nginx_upstream_check_module/archive/v0.3.0.tar.gz
tar -xvf v0.3.0.tar.gz
6.重新安装opresty
cd /usr/servers/ngx_openresty-1.11.2.4
./configure --prefix=/usr/servers --with-http_realip_module --with-pcre --with-luajit --add-module=./bundle/ngx_cache_purge-2.3/ --add-module=./bundle/nginx_upstream_check_module-0.3.0/ -j2
提示错误，安装pcre库
yum install -y pcre pcre-devel
<1> gcc 安装 安装 nginx 需要先将官网下载的源码进行编译，编译依赖 gcc 环境，如果没有 gcc 环境，则需要安装：
yum install gcc-c++
<2> PCRE pcre-devel 安装
PCRE(Perl Compatible Regular Expressions) 是一个Perl库，包括 perl 兼容的正则表达式库。nginx 的 http 模块使用 pcre 来解析正则表达式，所以需要在 linux 上安装 pcre 库，pcre-devel 是使用 pcre 开发的一个二次开发库。nginx也需要此库。命令：
yum install -y pcre pcre-devel
<3> zlib 安装 zlib 库提供了很多种压缩和解压缩的方式， nginx 使用 zlib 对 http 包的内容进行 gzip ，所以需要在 Centos 上安装 zlib 库。
yum install -y zlib zlib-devel
<4> OpenSSL 安装 OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及 SSL 协议，并提供丰富的应用程序供测试或其它目的使用。 nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http），所以需要在 Centos 安装 OpenSSL 库。
yum install -y openssl openssl-devel
<5>.重新安装OpenResty
cd /usr/servers/ngx_openresty-1.11.2.4
./configure --prefix=/usr/servers --with-http_realip_module --with-pcre --with-luajit --add-module=./bundle/ngx_cache_purge-2.3/ --add-module=./bundle/nginx_upstream_check_module-0.3.0/ -j2
make && make install
<6>.启动Nginx
/usr/servers/nginx/sbin/nginx
浏览器访问http://116.196.177.123：
Welcome to OpenResty!
If you see this page, the OpenResty web platform is successfully installed and working. Further configuration is required.
For online documentation and support please refer to openresty.org.
Thank you for flying OpenResty.
安装成功了。
6.配置nginx
vim /usr/servers/nginx/conf/nginx.conf
错误提示没有安装vim
yum -y install vim*
1、在http部分添加如下配置
lua模块路径，多个之间”;”分隔，其中”;;”表示默认搜索路径，默认到/usr/servers/nginx下找
lua_package_path “/usr/servers/lualib/?.lua;;”; #lua 模块
lua_package_cpath “/usr/servers/lualib/?.so;;”; #c模块
2、在nginx.conf中的http部分添加include lua.conf包含此文件片段 Java代码 收藏代码 include lua.conf;
在/usr/server/nginx/conf下
vim lua.conf
#lua.conf
server {
listen 80;
server_name _;
location /lua {
default_type 'text/html';
content_by_lua 'ngx.say("hello world")';
}
}
7.环境变量：
vim /etc/profile
JAVA_HOME=/usr/local/jdk/jdk1.8.0_144
JRE_HOME=$JAVA_HOME/jre
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
CLASSPATH=:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib/dt.jar
export JAVA_HOME JRE_HOME PATH CLASSPATH
export PATH=$PATH:/usr/servers/nginx/sbin
source /etc/profile
测试：
nginx -t
nginx: the configuration file /usr/servers/nginx/conf/nginx.conf syntax is ok nginx: configuration file /usr/servers/nginx/conf/nginx.conf test is successful
nginx -s reload
浏览器访问http://116.196.177.123/lua ，浏览器显示：
hello world
8.将Lua项目化：
mkdir /usr/example cp -r /usr/servers/lualib/ /usr/example/ mkdir /usr/example/lua
cd /usr/example vim example.conf
server {
listen 80;
server_name _;
location /lua {
default_type 'text/html';
lua_code_cache off;
content_by_lua_file /usr/example/lua/test.lua;
}
}
vim /usr/example/lua/test.lua
ngx.say("hello world");
cd /usr/servers/nginx/conf/
vim nginx.conf
http模块：
http {
include mime.types;
default_type application/octet-stream;
lua_package_path "/usr/example/lualib/?.lua;;"; #lua 模块
lua_package_cpath "/usr/example/lualib/?.so;;"; #c模块
include /usr/example/example.conf;
....
....
}
nginx -t
nginx: [alert] lua_code_cache is off; this will hurt performance in /usr/example/example.conf:7 nginx: the configuration file /usr/servers/nginx/conf/nginx.conf syntax is ok nginx: configuration file /usr/servers/nginx/conf/nginx.conf test is successful
nginx -s reload
浏览器访问http://116.196.177.123/lua ，
hello world
导出history的所有命令：
在你的账户目录下 输入命令
ls -a
找到 .bash_history
这个就是记录命令文件。
输入命令：
cat .bash_history >> history.txt
参考资料
http://www.linuxidc.com/Linux/2016-09/134907.htm
http://jinnianshilongnian.iteye.com/blog/2186270
第4篇：OpenResty常见的api
这篇文章主要讲解OpenResty常见的api。
vim /usr/example/example.conf
location /lua_var {
default_type 'text/plain';
content_by_lua_block {
ngx.say(ngx.var.arg_a)
}
}
重新加载nginx配置文件： nginx -s reload
在浏览器上访问http://116.196.177.123/lua_var?a=323,浏览器显示：
323
在上述代码中，涉及到了2个api, 一是ngx.say（直接返回请求结果）；二是ngx.var，它是获取请求的参数，比如本例子上的？a=323,获取之后，直接输出为请求结果。
获取请求类型
vim /usr/example/example.conf
location /lua_request{
default_type 'text/html';
lua_code_cache off;
content_by_lua_file /usr/example/lua/lua_request.lua;
}
vim /usr/example/lua/lua_request.lua ，添加一下代码：
local arg = ngx.req.get_uri_args()
for k,v in pairs(arg) do
ngx.say("[GET ] key:", k, " v:", v)
end
ngx.req.read_body() -- 解析 body 参数之前一定要先读取 body
local arg = ngx.req.get_post_args()
for k,v in pairs(arg) do
ngx.say("[POST] key:", k, " v:", v)
end
在上述例子中有以下的api:
- ngx.req.get_uri_args 获取在uri上的get类型参数，返回的是一个table类型的数据结构。
- ngx.req.read_body 读取body，这在解析body之前，一定要先读取body。
- ngx.req.get_post_args 获取form表单类型的参数，返回结果是一个table类型的数据。
使用curl模拟请求：
curl ‘http://116.196.177.123/lua_request?a=323&b=ss’ -d ‘c=12w&d=2se3’
返回的结果：
[GET ] key:b v:ss
[GET ] key:a v:323
[POST] key:d v:2se3
[POST] key:c v:12w
获取请求头
vim /usr/example/lua/lua_request.lua ，在原有的代码基础上，再添加一下代码:
local headers = ngx.req.get_headers()
ngx.say("headers begin", "<br/>")
ngx.say("Host : ", headers["Host"], "<br/>")
ngx.say("user-agent : ", headers["user-agent"], "<br/>")
ngx.say("user-agent : ", headers.user_agent, "<br/>")
for k,v in pairs(headers) do
if type(v) == "table" then
ngx.say(k, " : ", table.concat(v, ","), "<br/>")
else
ngx.say(k, " : ", v, "<br/>")
end
end
重新加载nginx -s reload
使用curl模拟请求：
curl ‘http://116.196.177.123/lua_request?a=323&b=ss’ -d ‘c=12w&d=2se3’
[GET ] key:b v:ss
[GET ] key:a v:323
[POST] key:d v:2se3
[POST] key:c v:12w
headers begin<br/>
Host : 116.196.77.157<br/>
user-agent : curl/7.53.0<br/>
user-agent : curl/7.53.0<br/>
host : 116.196.77.157<br/>
content-type : application/x-www-form-urlencoded<br/>
accept : */*<br/>
content-length : 12<br/>
user-agent : curl/7.53.0<br/>
获取http的其他方法
vim /usr/example/lua/lua_request.lua ，在原有的代码基础上，再添加一下代码:
ngx.say("ngx.req.http_version : ", ngx.req.http_version(), "<br/>")
--请求方法
ngx.say("ngx.req.get_method : ", ngx.req.get_method(), "<br/>")
--原始的请求头内容
ngx.say("ngx.req.raw_header : ", ngx.req.raw_header(), "<br/>")
--请求的body内容体
ngx.say("ngx.req.get_body_data() : ", ngx.req.get_body_data(), "<br/>")
ngx.say("<br/>")
重新加载nginx -s reload
使用curl模拟请求：
curl ‘http://116.196.177.123/lua_request?a=323&b=ss’ -d ‘c=12w&d=2se3’
//....
ngx.req.http_version : 1.1<br/>
ngx.req.get_method : POST<br/>
ngx.req.raw_header : POST /lua_request?a=323&b=ss HTTP/1.1
Host: 116.196.77.157
User-Agent: curl/7.53.0
Accept: */*
Content-Length: 12
输出响应
vim /usr/example/example.conf，添加一个location,代码如下：
location /lua_response{
default_type 'text/html';
lua_code_cache off;
content_by_lua_file /usr/example/lua/lua_response.lua ;
}
vim /usr/example/lua/lua_response.lua 添加一下代码：
ngx.header.a="1"
ngx.header.b={"a","b"}
ngx.say("hello","</br>")
ngx.print("sss")
return ngx.exit(200)
上述代码中有以下api:
- ngx.header 向响应头输出内容
- ngx.say 输出响应体
- ngx.print输出响应体
- ngx.exit 指定http状态码退出
使用curl模拟请求， curl ‘http://116.196.177.123/lua_response’ ，获取的响应体如下：
hello
sss
日志输出
在配置文件vim /usr/example/example.conf 加上以下代码：
location /lua_log{
default_type 'text/html';
lua_code_cache off;
content_by_lua_file /usr/example/lua/lua_log.lua;
}
vim /usr/example/lua/lua_log.lua ，加上以下代码：
local log="i'm log"
local num =10
ngx.log(ngx.ERR, "log",log)
ngx.log(ngx.INFO,"num:" ,num)
重新加载配置文件nginx -s reload
打开nginx 的logs目录下的error.log 文件：
tail -fn 1000 /usr/servers/nginx/logs/error.log
可以看到在日志文件中已经输出了日志，这种日志主要用于记录和测试。
日志级别：
- ngx.STDERR – 标准输出
- ngx.EMERG – 紧急报错
- ngx.ALERT – 报警
- ngx.CRIT – 严重，系统故障，触发运维告警系统
- ngx.ERR – 错误，业务不可恢复性错误
- ngx.WARN – 告警，业务中可忽略错误
- ngx.NOTICE – 提醒，业务比较重要信息
- ngx.INFO – 信息，业务琐碎日志信息，包含不同情况判断等
- ngx.DEBUG – 调试
内部调用
vim /usr/example/example.conf 添加以下代码：
location /lua_sum{
# 只允许内部调用
internal;
# 这里做了一个求和运算只是一个例子，可以在这里完成一些数据库、
# 缓存服务器的操作，达到基础模块和业务逻辑分离目的
content_by_lua_block {
local args = ngx.req.get_uri_args()
ngx.say(tonumber(args.a) + tonumber(args.b))
}
}
internal 关键字，表示只允许内部调用。使用curl模拟请求，请求命令如下：
由于该loction是一个内部调用的，外部不能返回，最终返回的结果为404，如下：
<html>
<head><title>404 Not Found</title></head>
<body bgcolor="white">
<center><h1>404 Not Found</h1></center>
<hr><center>openresty/1.11.2.4</center>
</body>
</html>
vim /usr/example/example.conf 添加以下代码：
location = /lua_sum_test {
content_by_lua_block {
local res = ngx.location.capture("/lua_sum", {args={a=3, b=8}})
ngx.say("status:", res.status, " response:", res.body)
}
}
上述的代码通过ngx.location.capture去调用内部的location，并获得返回结果，最终将结果输出，采用curl模拟请求：
返回结果如下：
status:200 response:11
重定向
vim /usr
location /lua_redirect{
default_type 'text/html';
content_by_lua_file /usr/example/lua/lua_redirect.lua;
}
ngx.redirect("http://www.fangzhipeng.com", 302)
http://116.196.177.123/lua_redirect
共享内存
vim /usr/servers/nginx/cong/nginx.conf
在http模块加上以下：
lua_shared_dict shared_data 1m;
location /lua_shared_dict{
default_type 'text/html';
content_by_lua_file /usr/example/lua/lua_shared_dict.lua;
}
local shared_data = ngx.shared.shared_data
local i = shared_data:get("i")
if not i then
i = 1
shared_data:set("i",i)
end
i = shared_data:incr("i",1)
ngx.say("i:",i)
多次访问 http://116.196.177.123/lua_shared_dict，浏览器打印：
i:1
i:2
i:3
i:4
i:5
OpenResty执行阶段的概念
以下内容来自于《openresty 最佳实践》
如上图所示，openresty的执行阶段分为
这样我们就可以根据我们的需要，在不同的阶段直接完成大部分典型处理了。
- set_by_lua* : 流程分支处理判断变量初始化
- rewrite_by_lua* : 转发、重定向、缓存等功能(例如特定请求代理到外网)
- access_by_lua* : IP 准入、接口权限等情况集中处理(例如配合 iptable 完成简单防火墙)
- content_by_lua* : 内容生成
- header_filter_by_lua* : 响应头部过滤处理(例如添加头部信息)
- body_filter_by_lua* : 响应体过滤处理(例如完成应答内容统一成大写)
执行阶段概念：
- log_by_lua* : 会话完成后本地异步完成日志记录(日志可以记录在本地，还可以同步到其 他机器) 实际上我们只使用其中一个阶段
- content_by_lua* ，也可以完成所有的处理。但这样做，会让 我们的代码比较臃肿，越到后期越发难以维护。把我们的逻辑放在不同阶段，分工明确，代 码独立，后期发力可以有很多有意思的玩法。
第5篇：http和C_json模块
Openresty没有提供默认的Http客户端，需要下载第三方的http客户端。
下载lua-resty-http到lualib目录下，使用以下的命令下载：
cd /usr/example/lualib/resty/
wget https://raw.githubusercontent.com/pintsized/lua-resty-http/master/lib/resty/http_headers.lua
wget https://raw.githubusercontent.com/pintsized/lua-resty-http/master/lib/resty/http.lua
lua-resty-http模块的地址为https://github.com/pintsized/lua-resty-http
安装成功后，通过require(“resty.http”)引入 lua_http模块，它有以下的api方法：
- syntax: httpc = http.new() 创建一个 http对象
- syntax: res, err = httpc:request_uri(uri, params)根据参数获取内容，包括：
- status 状态码
- headers 响应头
- body 响应体
vim /usr/example/lua/test_http.lua，写以下代码：
local http = require("resty.http")
local httpc = http.new()
local resp, err = httpc:request_uri("http://s.taobao.com", {
method = "GET",
path = "/search?q=hello",
headers = {
["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.111 Safari/537.36"
}
})
if not resp then
ngx.say("request error :", err)
return
end
ngx.status = resp.status
for k, v in pairs(resp.headers) do
if k ~= "Transfer-Encoding" and k ~= "Connection" then
ngx.header[k] = v
end
end
ngx.say(resp.body)
httpc:close()
vim /usr/example/example.conf 加上以下的配置：
location /lua_http {
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_http.lua;
}
在Nginx的配置文件nginx.conf的http部分，加上以下dns解析：
vim /usr/servers/nginx/conf/nginx.conf
resolver 8.8.8.8;
浏览器访问：http://116.196.177.123/lua_http,浏览器会显示淘宝的搜索页。
lua_cjson模块
Json是一种常见的数据交换格式，常用于http通信协议和其他数据传输领域。在openresty默认内嵌了lua_cjson模块，用来序列化数据。
lua_cjson模块的地址：https://www.kyne.com.au/~mark/software/lua-cjson-manual.html
它常用的API如下：
- local cjson = require “cjson” 获取一个cjson对象
- local str = cjson.encode(obj) obj转换成string
- local obj = cjson.decode(str) 将string转obj
vim /usr/example/lua/test_cjson.lua，添加以下内容：
local cjson = require("cjson")
local obj = {
id = 1,
name = "zhangsan",
age = nil,
is_male = false,
hobby = {"film", "music", "read"}
}
local str = cjson.encode(obj)
ngx.say(str, "<br/>")
str = '{"hobby":["film","music","read"],"is_male":false,"name":"zhangsan","id":1,"age":null}'
local obj = cjson.decode(str)
ngx.say(obj.age, "<br/>")
ngx.say(obj.age == nil, "<br/>")
ngx.say(obj.age == cjson.null, "<br/>")
ngx.say(obj.hobby[1], "<br/>")
vim /usr/example/example.conf添加以下内容：
location ~ /lua_cjson {
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_cjson.lua;
}
在浏览器上访问http://116.196.177.123/lua_cjson，浏览器显示以下内容：
{"hobby":["film","music","read"],"is_male":false,"name":"zhangsan","id":1}
null
false
true
film
第6篇：OpenResty连接Mysql
Centos系统下安装mysql，先下载mysql-community-release-el7-5.noarch.rpm，然后通过yum安装，安装过程一直确定【Y】即可。
cd /usr/downloads/
wget http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
rpm -ivh mysql-community-release-el7-5.noarch.rpm
yum install mysql-community-server
安装成功后，重启mysql，并进入mysql数据库，给root用户设置一个密码，密码为“123”。
service mysqld restart
mysql -u root -p
set password for root@localhost = password('123');
openresty连接mysql
lua-resty-mysql模块的官方文档地址： https://github.com/openresty/lua-resty-mysql
lua-resty-mysql - Lua MySQL client driver for ngx_lua based on the cosocket API
lua-resty-mysql模块是基于cosocket API 为ngx_lua提供的一个Lua MySQL客户端。它保证了100%非阻塞。
vim /usr/example/lua/test_mysql.lua，添加以下的代码：
local function close_db(db)
if not db then
return
end
db:close()
end
local mysql = require("resty.mysql")
local db, err = mysql:new()
if not db then
ngx.say("new mysql error : ", err)
return
end
db:set_timeout(1000)
local props = {
host = "127.0.0.1",
port = 3306,
database = "mysql",
user = "root",
password = "123"
}
local res, err, errno, sqlstate = db:connect(props)
if not res then
ngx.say("connect to mysql error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
local drop_table_sql = "drop table if exists test"
res, err, errno, sqlstate = db:query(drop_table_sql)
if not res then
ngx.say("drop table error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
local create_table_sql = "create table test(id int primary key auto_increment, ch varchar(100))"
res, err, errno, sqlstate = db:query(create_table_sql)
if not res then
ngx.say("create table error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
local insert_sql = "insert into test (ch) values('hello')"
res, err, errno, sqlstate = db:query(insert_sql)
if not res then
ngx.say("insert error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
res, err, errno, sqlstate = db:query(insert_sql)
ngx.say("insert rows : ", res.affected_rows, " , id : ", res.insert_id, "<br/>")
local update_sql = "update test set ch = 'hello2' where id =" .. res.insert_id
res, err, errno, sqlstate = db:query(update_sql)
if not res then
ngx.say("update error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
ngx.say("update rows : ", res.affected_rows, "<br/>")
local select_sql = "select id, ch from test"
res, err, errno, sqlstate = db:query(select_sql)
if not res then
ngx.say("select error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
for i, row in ipairs(res) do
for name, value in pairs(row) do
ngx.say("select row ", i, " : ", name, " = ", value, "<br/>")
end
end
ngx.say("<br/>")
local ch_param = ngx.req.get_uri_args()["ch"] or ''
local query_sql = "select id, ch from test where ch = " .. ngx.quote_sql_str(ch_param)
res, err, errno, sqlstate = db:query(query_sql)
if not res then
ngx.say("select error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
for i, row in ipairs(res) do
for name, value in pairs(row) do
ngx.say("select row ", i, " : ", name, " = ", value, "<br/>")
end
end
local delete_sql = "delete from test"
res, err, errno, sqlstate = db:query(delete_sql)
if not res then
ngx.say("delete error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
ngx.say("delete rows : ", res.affected_rows, "<br/>")
close_db(db)
在上面的代码中，展示了基本的创表、插入数据、修改数据、查询数据、删除数据的一些功能。
其中用到的lua-resty-mysql的一些API方法：
- syntax: db, err = mysql:new() 创建一个mysql数据库连接对象
- syntax: ok, err = db:connect(options) 尝试远程连接mysql
- host mysql的主机名
- port 端口
- database 数据库名
- user 用户名
- password 密码
- charset 编码
- syntax: db:set_timeout(time) 设置数据库连接超时时间
- syntax: ok, err = db:set_keepalive(max_idle_timeout, pool_size) 设置连接池
- syntax: ok, err = db:close() 关闭数据库
- syntax: bytes, err = db:send_query(query) 发送查询
lua-resty-mysql的一些关键的API方法，见https://github.com/openresty/lua-resty-mysql#table-of-contents
vim /usr/example/example.conf 在配置文件配置：
location /lua_mysql {
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_mysql.lua;
}
浏览器访问http://116.196.177.123/lua_mysql，浏览器显示以下的内容：
insert rows : 1 , id : 2
update rows : 1
select row 1 : ch = hello
select row 1 : id = 1
select row 2 : ch = hello2
select row 2 : id = 2
delete rows : 2
第7篇：模块开发、OpenResty连接Redis
在实际的开发过程中，不可能把所有的lua代码写在一个lua文件中，通常的做法将特定功能的放在一个lua文件中，即用lua模块开发。在lualib目录下，默认有以下的lua模块。
lualib/
├── cjson.so
├── ngx
│ ├── balancer.lua
│ ├── ocsp.lua
│ ├── re.lua
│ ├── semaphore.lua
│ ├── ssl
│ │ └── session.lua
│ └── ssl.lua
├── rds
│ └── parser.so
├── redis
│ └── parser.so
└── resty
├── aes.lua
├── core
│ ├── base64.lua
│ ├── base.lua
│ ├── ctx.lua
│ ├── exit.lua
│ ├── hash.lua
│ ├── misc.lua
│ ├── regex.lua
│ ├── request.lua
│ ├── response.lua
│ ├── shdict.lua
│ ├── time.lua
│ ├── uri.lua
│ ├── var.lua
│ └── worker.lua
├── core.lua
├── dns
│ └── resolver.lua
├── limit
│ ├── conn.lua
│ ├── req.lua
│ └── traffic.lua
├── lock.lua
├── lrucache
│ └── pureffi.lua
├── lrucache.lua
├── md5.lua
├── memcached.lua
├── mysql.lua
├── random.lua
├── redis.lua
├── sha1.lua
├── sha224.lua
├── sha256.lua
├── sha384.lua
├── sha512.lua
├── sha.lua
├── string.lua
├── upload.lua
├── upstream
│ └── healthcheck.lua
└── websocket
├── client.lua
├── protocol.lua
└── server.lua
在使用这些模块之前，需要在nginx的配置文件nginx.conf中的http模块加上以下的配置：
lua_package_path "/usr/example/lualib/?.lua;;"; #lua 模块
lua_package_cpath "/usr/example/lualib/?.so;;"; #c模块
现在来简单的开发一个lua模块：
vim /usr/example/lualib/module1.lua
在module1.lua文件加上以下的代码：
local count = 0
local function hello()
count = count + 1
ngx.say("count : ", count)
end
local _M = {
hello = hello
}
return _M
开发时将所有数据做成局部变量/局部函数；通过 _M导出要暴露的函数，实现模块化封装。
在／usr/example/lua目录下创建一个test_module_1.lua 文件，在该文件中引用上面的module1.lua文件。
vim /usr/example/lua/test_module_1.lua
加上以下代码：
local module1 = require("module1")
module1.hello()
通过require(“模块名”)来加载模块，如果是多级目录，则需要通过require(“目录1.目录2.模块名”）加载。
在/user/example/example.conf中加上以下的配置：
location /lua_module_1 {
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_module_1.lua;
}
多次在浏览器上访问：http://116.196.177.123/lua_module_1，浏览器显示：
count : 1
count : 2
count : 3
...
安装redis
linux下安装： cd /usr/servers
$ wget http://download.redis.io/releases/redis-3.2.6.tar.gz
$ tar xzf redis-3.2.6.tar.gz
$ cd redis-3.2.6
$ make
启动redis:
nohup /usr/servers/redis-3.2.6/src/redis-server /usr/servers/redis-3.2.6/redis.conf &
查看是否启动：
ps -ef |grep redis
终端显示：
root 20985 14268 0 18:49 pts/0 00:00:00 /usr/servers/redis-3.2.6/src/redis-server 127.0.0.1:6379
可见redis已经启动。
lua连接redis
lua_resty_redis模块地址：https://github.com/openresty/lua-resty-redis
lua-resty-redis - Lua redis client driver for the ngx_lua based on the cosocket API
lua_resty_redis 它是一个基于cosocket API的为ngx_lua模块提供Lua redis客户端的驱动。
创建一个test_redis_basic.lua文件
vim /usr/example/lua/test_redis_basic.lua
local function close_redis(red)
if not red then
return
end
local pool_max_idle_time = 10000 --毫秒
local pool_size = 100 --连接池大小
local ok, err = red:set_keepalive(pool_max_idle_time, pool_size)
if not ok then
ngx.say("set keepalive error : ", err)
end
end
local redis = require("resty.redis")
local red = redis:new()
red:set_timeout(1000)
local ip = "127.0.0.1"
local port = 6379
local ok, err = red:connect(ip, port)
if not ok then
ngx.say("connect to redis error : ", err)
return close_redis(red)
end
ok, err = red:set("msg", "hello world")
if not ok then
ngx.say("set msg error : ", err)
return close_redis(red)
end
local resp, err = red:get("msg")
if not resp then
ngx.say("get msg error : ", err)
return close_redis(red)
end
if resp == ngx.null then
resp = ''
end
ngx.say("msg : ", resp)
close_redis(red)
上面的代码很简单，通过连接池连接Redis，连接上redis后，通过set一对键值对（msg,helloword）到redis中，然后get(msg)，并通过ngx.say()返回给浏览器。
vim /usr/example/example.conf,添加以下的配置代码：
location /lua_redis_basic {
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_redis_basic.lua;
}
浏览器访问：http://116.196.177.123/lua_redis_basic
浏览器显示：
msg : hello world
lua_resty_redis支持所有的redis指令，本身Redis就支持lua语言操作。所以lua_resty_redis模块能够提高所有的redis操作的功能。
在很多时候，Redis是设置了口令的，连接时，如果需要验证口令，需要添加 local res, err = red:auth(“foobared”)，示例代码如下：
local redis = require "resty.redis"
local red = redis:new()
red:set_timeout(1000) -- 1 sec
local ok, err = red:connect("127.0.0.1", 6379)
if not ok then
ngx.say("failed to connect: ", err)
return
end
local res, err = red:auth("foobared")
if not res then
ngx.say("failed to authenticate: ", err)
return
end
更多请关注的官方文档https://github.com/openresty/lua-resty-redis 和开涛的博客http://jinnianshilongnian.iteye.com/blog/2187328
第8篇：RBAC介绍、sql和redis模块工具类
RBAC（Role-Based Access Control，基于角色的访问控制），用户基于角色的访问权限控制。简单地说，一个用户拥有若干角色，每一个角色拥有若干权限。这样，就构造成“用户-角色-权限”的授权模型。在这种模型中，用户与角色之间，角色与权限之间，一般都是多对多的关系。如图所示：
sql_tool
在本案例中，采用的就是这种权限设计的方式。具体的sql语句脚本如下：
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT ,
`name` varchar(255) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=latin1 COLLATE=latin1_swedish_ci
AUTO_INCREMENT=2
ROW_FORMAT=COMPACT
;
CREATE TABLE role(
`id` int(11) NOT NULL AUTO_INCREMENT ,
`name` varchar(255) CHARACTER SET latin5 NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=latin1 COLLATE=latin1_swedish_ci
AUTO_INCREMENT=2
ROW_FORMAT=COMPACT
;
CREATE TABLE permission(
`id` int(11) NOT NULL AUTO_INCREMENT ,
`permission` varchar(255) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=latin1 COLLATE=latin1_swedish_ci
AUTO_INCREMENT=3
ROW_FORMAT=COMPACT
;
CREATE TABLE user_role(
`id` int(11) NOT NULL AUTO_INCREMENT ,
`user_id` int(11) NULL DEFAULT NULL ,
`role_id` int(11) NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=latin1 COLLATE=latin1_swedish_ci
AUTO_INCREMENT=2
ROW_FORMAT=COMPACT
;
CREATE TABLE role_permission(
`id` int(11) NOT NULL AUTO_INCREMENT ,
`role_id` int(11) NULL DEFAULT NULL ,
`permission_id` int(11) NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=latin1 COLLATE=latin1_swedish_ci
AUTO_INCREMENT=3
ROW_FORMAT=COMPACT
;
初始化以下的sql脚本，即给用户id为1的用户关联角色，角色并关联权限：
INSERT INTO `permission` VALUES ('1', '/user/orgs');
INSERT INTO `role` VALUES ('1', 'user');
INSERT INTO `role_permission` VALUES ('1', '1', '1');
INSERT INTO `user` VALUES ('1', 'forezp');
INSERT INTO `user_role` VALUES ('1', '1', '1');
在本案例中，需要根据user表中的Id获取该Id对应的权限。首先根据userId获取该用户对应的角色，再根据根据该角色获取相应的权限，往往一个用户具有多个角色，而角色又有多个权限。比如查询userId为1 的用户的权限的sql语句如下：
SELECT a.id,a.permission from permission a ,role_permission b,role c,user_role d,user e WHERE a.id=b.permission_id and c.id=b.role_id and d.role_id=c.id and d.user_id=e.id and e.id=1"
在Openresty中怎么连接数据库，怎么查询sql语句，在之前的文章已将讲述过了。根据用户id获取用户的权限的功能是一个使用率极高的功能，所以考虑将这个功能模块化。
vim /usr/example/lualib/sql_tool.lua ,编辑加入以下的代码：
local mysql = require("resty.mysql")
local function close_db(db)
if not db then
return
end
db:close()
end
local function select_user_permission(user_id)
local db, err = mysql:new()
if not db then
ngx.say("new mysql error : ", err)
return
end
db:set_timeout(1000)
local props = {
host = "127.0.0.1",
port = 3306,
database = "test",
user = "root",
password = "123"
}
local res, err, errno, sqlstate = db:connect(props)
if not res then
ngx.say("connect to mysql error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
close_db(db)
end
local select_sql = "SELECT a.id,a.permission from permission a ,role_permission b,role c,user_role d,user e WHERE a.id=b.permission_id and c.id=b.role_id and d.role_id=c.id and d.user_id=e.id and e.id="..user_id
res, err, errno, sqlstate = db:query(select_sql)
if not res then
ngx.say("select error : ", err, " , errno : ", errno, " , sqlstate : ", sqlstate)
return close_db(db)
end
local permissions={}
for i, row in ipairs(res) do
for name, value in pairs(row) do
if name == "permission" then
table.insert(permissions, 1, value)
end
end
end
return permissions
end
local _M = {
select_user_permission= select_user_permission
}
return _M
在上面的代码中，有一个select_user_permission(user_id)方法，该方法根据用户名获取该用户的权限。查出来存在一个table 类型的 local permissions={}中。
vim /usr/example/example.conf 加上以下的代码：
location ~ /sql_tool{
default_type 'text/html';
content_by_lua_file /usr/example/lua/test_sql_tool.lua;
}
在浏览器上访问http://116.196.177.123/sql_tool，浏览器显示如下的内容：
/user/orgs
tokentool
在之前的文章讲述了如何使用Openresty连接redis，并操作redis。 这小节将讲述如何使用openresty连接redis，并写几个方法，用于存储用户的token等，并将这些信息模块化，主要有以下几个方法：
- close_redis(red) 通过连接池的方式释放一个连接
- connect() 连接redis
- has_token(token) redis中存在token 与否
- get_user_id(token) 根据token获取用户id
- set_permissions(user_id,permissions) 根据userid设置权限
- get_permissions(user_id)根据userid获取权限
vim /usr/example/lualib/tokentool.lua 编辑一下内容：
module("tokentool", package.seeall)
local redis = require "resty.redis"
local str = require "resty.string"
local cjson = require("cjson")
local redis_host = "127.0.0.1"
local redis_port = 6379
local function close_redis(red)
if not red then
return
end
local pool_max_idle_time = 10000 --毫秒
local pool_size = 100 --连接池大小
local ok, err = red:set_keepalive(pool_max_idle_time, pool_size)
if not ok then
ngx.say("set keepalive error : ", err)
end
end
local function connect()
local red = redis:new()
red:set_timeout(1000)
local ok, err = red:connect(redis_host, redis_port)
if not ok then
return false
end
--local res, err = red:auth("xiaoantimes")
--if not res then
-- ngx.say("failed to authenticate: ", err)
-- return false
--end
--ok, err = red:select(1)
--if not ok then
-- return false
--end
return red
end
function has_token(token)
local red = connect()
if red == false then
return false
end
local res, err = red:get(token)
if not res then
return false
end
close_redis(red)
return true
end
function set_permissions(user_id,permissions)
if (permissions==null) or( permissions==ngx.null) then
return false
end
local str = cjson.encode(permissions)
ngx.log(ngx.ERR,"set redis p:"..str)
local red=connect()
if red== false then
return false
end
local ok, err = red:set(user_id,str)
if not ok then
return false
end
return true
end
function get_permissions(user_id)
local red=connect()
if red== false then
return false
end
local res, err = red:get(user_id)
if (not res) or (res == ngx.null) then
return
end
ngx.log(ngx.ERR,"get redis p:"..res);
local permissions=cjson.decode(res)
return permissions
end
function get_user_id(token)
local red = connect()
local resp, err = red:get(token)
if not resp then
ngx.say("get msg error : ", err)
return close_redis(red)
end
close_redis(red)
return resp
end
vim /usr/example/lua/test_token_tool.lua，加上以下的内容：
local tokentool= require "tokentool"
local ret = tokentool.has_token("msg")
ngx.log(ngx.ERR,ret)
if ret == true then
ngx.say("ok")
else
ngx.say("oops,error")
end
在/usr/example/example.conf加上以下的内容：
location ~ /token_tool{
default_type 'text/html';
lua_code_cache on;
content_by_lua_file /usr/example/lua/test_token_tool.lua;
}
打开浏览器访问http://116.196.177.123/token_tool，浏览器显示：
ok
第9篇：Openresty实现的网关权限控制
采用openresty 开发出的api网关有很多，比如比较流行的kong、orange等。这些API 网关通过提供插件的形式，提供了非常多的功能。这些组件化的功能往往能够满足大部分的需求，如果要想达到特定场景的需求，可能需要二次开发，比如RBAC权限系统。本小节通过整合前面的知识点，来构建一个RBAC权限认证系统。
技术栈
本小节采用了以下的技术栈：
- Openresty(lua+nginx)
- mysql
- redis
- cjson
验证流程
- 用户请求经过nginx，nginx的openresty的模块通过拦截请求来进行权限判断
- openresty的access_by_lua_file模块，进行了一系列的判断
- 用户的请求是否为白名单uri，如果为白名单uri，则直接通过验证，进入下一个验证环节content_by_lua_file,这个环节直接打印一句话：“恭喜，请求通过。”
- 如果用户请求不为白名单url，则需要取出请求header中的token,如果请求的header不存在token,则直接返回结果401，无权限访问。
- 如果用户请求的uri的请求头包含token ，则取出token，解密token取出用户id
- 根据取出的userid去查询数据库获取该用户的权限，如果权限包含了该请求的uri，请求可以通过，否则，请求不通过。
- 请求如果通过access_by_lua_file模块，则进入到content_by_lua_file模块,该模块直接返回一个字符串给用户请求，在实际的开发中，可能为路由到具体的应用程序的服务器。
验证流程图如下所示：
vim /usr/example/example.conf ，加上以下的配置：
location / {
default_type "text/html";
access_by_lua_file /usr/example/lua/api_access.lua;
content_by_lua_file /usr/example/lua/api_content.lua;
}
以上的配置表示，要不符合已有location路径的所有请求，将走这个location为/ 的路径。符合这个location的请求将进入 access_by_lua_file和 content_by_lua_file的模块判断。
vim /usr/example/lua/access_by_lua_file ，加上以下代码：
local tokentool = require "tokentool"
local mysqltool = require "mysqltool"
function is_include(value, tab)
for k,v in ipairs(tab) do
if v == value then
return true
end
end
return false
end
local white_uri={"/user/login","/user/validate"}
--local user_id = ngx.req.get_uri_args()["userId"]
--获取header的token值
local headers = ngx.req.get_headers()
local token=headers["token"]
local url=ngx.var.uri
if ( not token) or (token==null) or (token ==ngx.null) then
if is_include(url,white_uri)then
else
return ngx.exit(401)
end
else
ngx.log(ngx.ERR,"token:"..token)
local user_id=tokentool.get_user_id(token)
if (not user_id) or( user_id ==null) or ( user_id == ngx.null) then
return ngx.exit(401)
end
ngx.log(ngx.ERR,"user_id"..user_id)
local permissions={}
permissions =tokentool.get_permissions(user_id)
if(not permissions)or(permissions==null)or( permissions ==ngx.null) then
permissions= mysqltool.select_user_permission(user_id)
if permissions and permissions ~= ngx.null then
tokentool.set_permissions(user_id,permissions)
end
end
if(not permissions)or(permissions==null)or( permissions ==ngx.null) then
return ngx.exit(401)
end
local is_contain_permission = is_include(url,permissions)
if is_contain_permission == true then
-- ngx.say("congratuation! you have pass the api gateway")
else
return ngx.exit(401)
end
end
在上述代码中：
- is_include(value, tab)，该方法判断某个字符串在不在这个table中。
- white_uri={“/user/login”,”/user/validate”} 是一个白名单的列表。
- local headers = ngx.req.get_headers()从请求的uri的请求头获取token
- is_include(url,white_uri)判断该url是否为白名单url
- local user_id=tokentool.get_user_id(token)根据token获取该token对应的用户的user_id，在常见情况下，是根据token解析出user_id，但在不同的语言加密和加密token存在盐值不一样的情况，比较麻烦，所以我偷了个懒，直接存了redis，用户登录成功后存一下。
- permissions =tokentool.get_permissions(user_id)根据user_id 从redis获取该用户的权限。
- permissions= mysqltool.select_user_permission(user_id)如果redis没有存该用户的权限，则从数据库读。
- tokentool.set_permissions(user_id,permissions)，将从数据库中读取的权限点存在reddis中。
- local is_contain_permission = is_include(url,permissions)，判断该url 在不在该用户对应的权限列表中。
如果所有的判断通过，则该用户请求的具有权限访问，则进入content_by_lua_file模块，直接在这个模块给请求返回“congratulations! you have passed the api gateway”。
vim /usr/example/lua/api_content.lua ,添加以下内容：
ngx.say("congratulations!"," you have passed ","the api gateway")
----200状态码退出
return ngx.exit(200)
验证演示
打开浏览器访问http://116.196.177.123/user/login，浏览器显示：
congratulations! you have passed the api gateway
/user/login这个url 在白名单的范围内，所以它是可以通过权限验证的。
打开浏览器访问http://116.196.177.123/user/sss，显示以下内容：
401 Authorization Required
openresty/1.11.2.4
在redis中添加一对key-value，key为token_forezp，value为1，即token_forezp对应的用户的id为1.
/usr/servers/redis-3.2.6
src/redis-cli
set token_forezp 1
初始化以下的sql脚本，即给用户id为1的用户关联角色，角色并关联权限：
INSERT INTO `permission` VALUES ('1', '/user/orgs');
INSERT INTO `role` VALUES ('1', 'user');
INSERT INTO `role_permission` VALUES ('1', '1', '1');
INSERT INTO `user` VALUES ('1', 'forezp');
INSERT INTO `user_role` VALUES ('1', '1', '1');
用postman请求，在请求头中加入token，值为token_forezp，请求结果如下：
