Nginx+lua+openresty精简系列

1. CentOS系统安装openresty

你可以在你的 CentOS 系统中添加 openresty 仓库，这样就可以便于未来安装或更新我们的软件包（通过 yum update 命令）。运行下面的命令就可以添加我们的仓库：

$ sudo yum install yum-utils
$ sudo yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo

然后就可以像下面这样安装软件包，比如 openresty：

$ sudo yum install openresty

如果你想安装命令行工具 resty，那么可以像下面这样安装 openresty-resty 包：

$ sudo yum install openresty-resty

命令行工具 opm 在 openresty-opm 包里，而 restydoc 工具在 openresty-doc 包里头。

列出所有 openresty 仓库里头的软件包：

$ sudo yum --disablerepo="*" --enablerepo="openresty" list available

备注：在使用一般用户切换sudo后提示：sandu is not in the sudoers file. This incident will be reported.，可以按照如下操作：

1.切换到超级用户：$ su - 
2.打开/etc/sudoers文件：$vim /etc/sudoers
3.修改文件内容：
找到“root    ALL=(ALL)       ALL”一行，在下面插入新的一行，内容是“sandu   ALL=(ALL)    ALL”，
然后在vim键入命令“:wq!”保存并退出。
注：这个文件是只读的，不加“!”保存会失败。
4.退出超级用户：$ exit，然后再切换就可以了。
默认5分钟后刚才输入的sodo密码过期，下次sudo需要重新输入密码，如果觉得在sudo的时候输入密码麻烦，把刚才的输入换成如下内容即可： sandu ALL=(ALL) NOPASSWD: ALL

openresty默认安装路径：/usr/local/openresty/

或者采用源码安装方式，比较有针对性的编译各种模块

运行相关命令：

$ sudo systemctl start openresty.service
$ sudo systemctl stop openresty.service
$ sudo systemctl restart openresty.service
$ sudo systemctl reload openresty.service

防火墙放行80端口

2. 配置虚拟主机

#user  nobody;
worker_processes  1;

error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }
        #location / {
        #    default_type text/html;
        #    content_by_lua_block {
        #        ngx.say("<p>hello, world</p>")
        #    }
        #}

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

把上述默认的配置文件改造如下：

#user  nobody;
worker_processes  1;

error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    #default_type  application/octet-stream;
    default_type  text/html;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    gzip  on;
	
	 # server块注释
    #server {
        #listen       80;
        #server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        #location / {
        #    root   html;
        #    index  index.html index.htm;
        #}
        #location / {
        #    default_type text/html;
        #    content_by_lua_block {
        #        ngx.say("<p>hello, world</p>")
        #    }
        #}

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        #error_page   500 502 503 504  /50x.html;
        #location = /50x.html {
        #    root   html;
        #}

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    #}


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}
	 
	 # 新增这一行，在nginx.conf配置文件同目录下新建目录vhosts
    include vhosts/*.conf;

}

1.基于域名绑定虚拟主机

# vhosts/test.conf文件

server {
    listen       80;
    server_name  server1.test.com;

    #charset koi8-r;

    location / {
#       root   html;
#       index  index.html index.htm;
        echo 'server1.test.com';
    }
}

server {
    listen       80;
    server_name  server2.test.com;

    #charset koi8-r;

    location / {
        echo 'server2.test.com';
    }
}

server {
    listen       80;
    server_name  server3.test.com;

    #charset koi8-r;

    location / {
        echo 'server3.test.com';
    }
}

本机/etc/hosts文件增加如下内容：

127.0.0.1   server1.test.com
127.0.0.1   server2.test.com
127.0.0.1   server3.test.com

使用curl命令分别对server1.test.com，server2.test.com，server3.test.com进行访问，出现相应的访问结果。

2.基于端口绑定虚拟主机

# 基于端口绑定的虚拟主机,注意：没有server_name，默认是localhost
server {
    listen       81;

    location / {
        echo 'server1.test.com';
    }
}

server {
    listen       82;

    location / {
        echo 'server2.test.com';
    }
}

server {
    listen       83;

    location / {
        echo 'server3.test.com';
    }
}

[sandu@bogon vhosts]$ curl http://localhost:81
server1.test.com
[sandu@bogon vhosts]$ curl http://localhost:82
server2.test.com
[sandu@bogon vhosts]$ curl http://localhost:83
server3.test.com

3.基于IP绑定虚拟主机

server {
    listen       192.168.0.2:80;

    location / {
        echo 'server1.test.com';
    }
}

server {
    listen       192.168.0.3:80

    location / {
        echo 'server2.test.com';
    }
}

server {
    listen       192.168.0.3:80

    location / {
        echo 'server3.test.com';
    }
}

4.总结

基于域名的配置一般都是针对外网，也就是面对用户的，而后两者配置一般都是基于内网，企业内部的各个系统的跳转多用端口号区别，因为也没有用户去使用ip地址和端口号去访问一个网站，都是通过域名访问的。

3. 配置反向代理

反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。

nginx的负载均衡配置就依赖于反向代理。

反向代理的作用：

网关服务器
负载均衡
请求转发、请求统计
黑白名单拦截

http{
......

    upstream to_local{
        server localhost:81;
        server localhost:82;
    }

    server {
        listen       80;

        location / {
            proxy_pass http://to_local;
        }
    }

    server {
        listen       81;

        location / {
            echo '81,remote_addr=$remote_addr';
        }
    }

    server {
        listen       82;

        location / {
            echo '82,remote_addr=$remote_addr';
        }
    }

}

代码块说明：

upstream块，紧跟着后面有一个to_local别名，因为可以配置多个upstream块，所以为了区别需要别名，且在server块使用的时候需要指定该别名。块内是两个server，也就是选择哪台内部服务器展示网站内容的域名，也可以写成 ip：port 形式。也可以只写一个server，相当于请求转发；配置多个就是负载均衡。
location内的proxy_pass配置。使用 http:// + upstream别名的形式，也就是当访问某一个域名的时候，location匹配到根路径，然后使用反向代理功能，将该请求‘跳转’到upstream块中，由该块决定请求策略。upstream块发现有两个server可以使用，于是使用轮训策略(默认情况下)，依次访问localhost:81和localhost:82

访问效果：

[sandu@bogon conf]$ curl http://localhost
82,remote_addr=127.0.0.1
[sandu@bogon conf]$ curl http://localhost
81,remote_addr=127.0.0.1
[sandu@bogon conf]$ curl http://localhost
82,remote_addr=127.0.0.1
[sandu@bogon conf]$ curl http://localhost
81,remote_addr=127.0.0.1

使用代理的情况，得到的结果却是127.0.0.1，看上去像是Linux系统本机IP，实际上是我运行程序的机器的IP地址

$remote_addr只存储上次请求的ip地址，而不是最原始的客户机ip地址。

解决方案：

使用proxy模块的proxy_set_header配置，将原始客户机ip地址放到请求头里。

server {
    listen       80;

    location / {
        proxy_pass http://to_local;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

一次代理，设置请求头之后可以根据X-Real-IP获取真实客户机ip地址；二次代理则不是真实ip，X-Forwarded-For头里不论几次代理都可以获取到真实ip。

nginx的命令执行并不是按代码的实际书写顺序，而是根据模块来划分。模块的代码执行有先后顺序，若A模块先于B模块执行，那么即便在同一个location中，所属B模块的代码在所属A模块代码之前，依然不会先执行。这就是配置指令执行顺序的问题。同一个模块不同的指令也有不同的执行顺序，有的是在阶段末尾有的则是在阶段开始。

proxy模块还有其他更多的指令配置，一般常见就是设置头和设置反向代理一起使用。

4. 配置负载均衡

负载均衡是为了将海量的请求分发给一台台服务器，让每台服务器处理的请求达到均衡。它是由多台服务以等价地位的方式组成一个服务器集合，也就是集群。每台服务器可以单独对外服务，具备完整的对外服务功能。负载均衡是通过某种技术，让请求均匀的分配给集群中的各个机器，而收到请求的机器可以独立回应客户请求。

负载均衡作用:

缓解单台服务器压力，有效分流降压
高可用，若干台服务器中宕机数个不影响整体使用
提高服务的响应速度
支持在线扩展升级，可临时增加机器以便应对短暂洪流

负载均衡解决方案:

用户手动选择不同的下载线路
DNS轮询
F5等物理设备
nginx等软件：通过OSI的第七层即应用层来实现负载均衡

nginx目前支持6种调度算法：

轮询策略：默认依次轮询
ip_hash策略：根据客户机的ip地址进行hash后再取模，nginx可以保证同一个客户机的请求始终分配到同一台服务器上。若被分配到的机器宕机，则会重新分配到其他机器上。

upstream to_local{
    ip_hash;
    server localhost:81;
    server localhost:82;
}

最少连接数策略：使请求分配到最少连接数的机器上

upstream to_local{
    least_conn;
    server localhost:81;
    server localhost:82;
}

upstream 块中 server配置后所支持的参数：

weight：权重，常用于机器性能不均衡时，权重越大被访问的几率越大

upstream to_local{
    server localhost:81 weight=1;
    server localhost:82 weight=2;
}

down：设置当前server不参与负载均衡，即访问不到

upstream to_local{
    server localhost:81 weight=1;
    server localhost:82 weight=2 down;
}

backup：用于其他server全部无法访问或者忙时备用server

upstream to_local{
    server localhost:81;
    server localhost:82 backup;
}

max_fails：server允许请求失败的次数，
fail_timeout：请求失败次数达到max_fails时，指定server暂停多久，以便检测故障原因

upstream to_local{
    server localhost:81 max_fails=1 fail_timeout=30s;
    server localhost:82 max_fails=1 fail_timeout=30s;
}

反向代理是可以直接书写代理地址的

proxy_pass http://localhost:80

5. nginx缓存

缓存原则：

越近越好
能用自家缓存就不要用别人家的缓存

web缓存：web缓存位于内容源web服务器和客户端之间，当访问一个url时，web服务器会去后端服务器取回要输出的内容，然后当下一个请求到来时，如果访问的是同一个url，web服务器则会直接输出内容给客户端，而不是向后端服务器再次发送请求。

常用的缓存软件比如redis、memcache，是不是web缓存呢？答案是不是的，因为这两者是需要通过应用程序去操作，需要通过建立连接，通过自己的程序也就是代码去控制存储拉取，要在服务器内部进行处理。而web缓存对于同一个url来说，第一次请求会访问服务器，但是第二次请求不到服务器就直接返回了。

nginx的缓存指令在proxy模块中可以查到：

proxy_cache_path：nginx缓存是将缓存的内容存储到磁盘和内存两种途径，此指令声明了缓存在硬盘中的存储路径，最大存储量，失效时间等。
proxy_cache：nginx缓存是共享的，也就是proxy_cache_path声明的一个nginx缓存可以被其他localtion所共用，所以就有个zone的概念，proxy_cache_path声明zone即缓存的别名，proxy_cache指定该别名表示使用这块缓存。
proxy_cache_valid：控制不同响应状态码的HTTP响应的缓存失效时间。比如响应码是200的缓存10s ，404状态则缓存1s。

nginx配置：

http {
    
	......
	
    proxy_cache_path /tmp/cache levels=1:2 keys_zone=myCache:10m max_size=1g inactive=30s use_temp_path=off;
	
    server {
        listen       80;
        add_header X-Cache $upstream_cache_status;
        location / {
            proxy_pass http://127.0.0.1:8088;
            proxy_cache_valid 10s; # 缓存在内存中的存储时间，还可以制定响应码的缓存时间
            proxy_cache myCache; # 设置该location的所有请求都将缓存，并指定缓存zone
        }
    }
}

proxy_cache_path 指令分析：

cache/test：缓存数据存储在根目录下的cache/test目录中
levels：表示缓存文件在目录中的存储方式，不用关心，最好是1:2就行。
keys_zone=myCache:10m：定义一块共享的内存区域，名称叫myCache，大小为10m，用来存储key值和缓存数据的信息，10m大约可以存8000个key。这个10m和缓存在硬盘中的容量不是一个概念。
max_size：缓存在硬盘中存储的最大容量，超容则删除最不常用的缓存腾出空间，删除规则也可以手动配置。
inactive：表示已缓存数据在硬盘中的最大存储时间，超时就删除，默认10分钟。
use_temp_path：是否使用临时存储路径，意思是先有临时存储路径，然后再把临时的存储文件转到真正的存储路径也就是proxy_cache_path中的路径，如果开启则需要配置临时缓存路径，一般不开启。

add_header指令分析：

是headers模块中的指令，意思很明确，就是在HTTP响应的时候添加响应头，key值为 X-Cache，value为$upstream_cache_status，$upstream_cache_status是upstream模块中的一个内置变量，它表示HTTP响应的缓存状态。
表示响应是否命中缓存，hit表示命中，miss表示未命中。设置此请求头的原因是缓存是否使用，用肉眼辨别不出来，我们在响应头中加一个是否缓存的标记，通过查看响应头就能看出是否使用了缓存。

实际配置：

http{
	
	......
	
    upstream to_local{
        server localhost:81 weight=1;
        server localhost:82 weight=2 down;
    }

    proxy_cache_path /tmp/cache levels=1:2 keys_zone=myCache:10m max_size=1g inactive=30s use_temp_path=off; # 需要提前建好/tmp/cache目录

    server {
        listen       80;

        add_header X-Cache $upstream_cache_status;

        location / {
            proxy_pass http://to_local;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_cache_valid 10s;
            proxy_cache myCache;
        }
    }

    server {
        listen       81;

        location / {
            root   html;
            index  index.html index.htm; # index.html文件中包含图片
        }
    }
}

效果展示：

直接访问http://ip:81,没有X-Cache响应头
访问http://ip,第一次访问时有 X-Cache响应头且状态是miss状态。同时发现/tmp/cache文件夹下多了很多文件夹，二级文件夹，正是levels所配置的1:2，最下级是一个文件，即缓存数据，30s过后消失，文件夹依然存在，说明inactive生效。为了避免浏览器缓存，可以使用ctrl+F5刷新页面，发现缓存文件又出现了。第二次访问，再次查看状态，发现X-Cache的状态已经变为hit ，表示缓存命中。

6. Lua入门

openresty的开发主要是基于lua，Lua 在葡萄牙语里代表美丽的月亮。

Lua 从一开始就是作为一门方便嵌入(其它应用程序)并可扩展的轻量级脚本语言来设计的，因此她一直遵从着简单、小巧、可移植、快速的原则，官方实现完全采用 ANSI C 编写，能以 C程序库的形式嵌入到宿主程序中。

Lua特点：

变量无类型，任何值都可以一个关键字表示
仅提供一种数据结构，table，类似于Map，使用key，value的形式存储数据。
具有远程连接的功能，可以连接数据库，可以连接redis
语法简单

因为已经安装有openrestyle ，所以自带的有lua开发环境，在命令中执行：lua即可。

[sandu@bogon ~]$ lua
Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
>

6.1 Lua变量、值类型

lua虽然变量是没有类型的，但是值是有类型的

[sandu@bogon tmp]$ cat hello.lua 
local a = 1
local b = true
local c = "字符串"
local d 

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(print))
[sandu@bogon tmp]$ lua hello.lua 
number
boolean
string
nil
function

首先定义了四个变量，都是用local变量接收，然后输出这些变量的值得类型，type类似于JavaScript中的typeof,能够返回变量或值的类型。

前三个都很好理解了，数值类型，布尔类型，字符串类型，开发者已经不能再熟悉了。nil表示无效值，假如一个变量没有被赋值，则默认为nil，function则表示该值是一个function类型，方法也是这个类型。

lua的变量确实是无类型的，可以任意接收不同的类型的值

number数字类型，一般情况下，lua中的数字类型都是双精度的，而luajit会根据上下文将整数存储为整型，用双精度浮点数来存储浮点数。
string字符串，单引号或者双引号都可以。但是如果想在字符串里加引号，或者使用其他转义字符，那么就得用 [ ] 大括号了。
table数据类型，类似于json数据格式，很实用，会有table表的遍历

[sandu@bogon tmp]$ cat 1.lua 
local corp = {
    web = "www.google.com", 
    telephone = "12345678", 
    staff = {"Jack", "Scott", "Gary"}, 
    100876, 
    100191, 
    [10] = 360, 
    ["city"] = "Beijing" 
}

print(corp.web) 
print(corp["telephone"]) 
print(corp[2]) 
print(corp["city"])
print(corp.staff[1]) 
print(corp[10])
[sandu@bogon tmp]$ lua 1.lua 
www.google.com
12345678
100191
Beijing
Jack
360
[sandu@bogon tmp]$

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:360

lua的function是可以赋值给变量的，所以它也是一种数据类型。

# 语法1
function  name()  # 匿名
    代码块
 end

# 语法2
name = function()  # 有名
    代码块
 end

[sandu@bogon tmp]$ cat 2.lua 
function hello()
    return 'hello lua'
end

local a = hello

print(a()) 
[sandu@bogon tmp]$ lua 2.lua 
hello lua
[sandu@bogon tmp]$

定义了一个hello方法，然后将hello赋值给a变量，并输出a变量，发现输出了hello lua。

那么为什么要在输出a的时候加个括号呢？因为a是一个变量，且指向的是一个方法即hello，直接输出的话输出的是该方法的地址：function: 0000000000dfd370，加个括号意思就是调用该方法，方法中的代码就会执行并返回一个字符串。

function分为匿名函数和有名函数，刚刚声明的就是一个匿名函数，实际上可以转变为一个有名函数。所以可以直接使用hello这个变量

hello = function ()
    return "hello lua"
end

6.2 Lua语法

注释使用--两个中横线

--
-- Created by IntelliJ IDEA.
-- Date: 2019/1/25
-- Time: 14:52
-- To change this template use File | Settings | File Templates.
--

表达式，加减乘除，是非与或，小于大于等于，但是对于lua来说,and和or有点特殊

a and b  如果 a 为 nil，则返回 a，否则返回 b;
a or b  如果 a 为 nil，则返回 b，否则返回 a。

在if判断中，false和Nil都视为假，其他如字符串或者数字都视为真。

字符串连接使用..两个点

print("Hello " .. "World") -->打印 Hello World
print(0 .. 1) -->打印 01

if语句

a = 90
if a == 100 then
    print("a=100")
elseif a >= 60 then  -- elseif 是连在一起的
    print("a>=60")
    --此处可以添加多个elseif
else
    print("a<60")
end

for循环

local arr = {"a", "b", "c", "d"}
for index, value in ipairs(arr) do
    print("index:", index, " value:", value)
end

# 输出
index:    1    value: a
index:    2    value: b
index:    3    value: c
index:    4    value: d

while循环

-- 计算1+2+3+4+5的值
x = 1
sum = 0
while x <= 5 do
    sum = sum + x
    x = x + 1
end

print(sum) -->output 15

6.3 Lua库

string库

print(string.upper("Hello Lua")) -->output HELLO LUA
print(string.lower("Hello Lua")) -->output hello lua
print(string.len("hello lua")) -->output 9

table库
日期库

6.4 模块

通过require函数,跨文件使用其他lua代码,模块就是一个lua代码块

定义一个hello.lua文件

--一个模块通常视为一个table表
--其他代码调用该模块就相当于调用table表
--于是返回table，就相当于把代码暴露出去了

local hello={}

local setName = function()
    return "myname"
end

hello.getName = function() --给hello添加一个key值：getName，value就是function
    print(setName())
end

return hello

再定义一个user.lua文件

local helloTable = require("hello")

helloTable.getName()

[sandu@bogon tmp]$ cat hello.lua 
--一个模块通常视为一个table表
----其他代码调用该模块就相当于调用table表
----于是返回table，就相当于把代码暴露出去了


local hello={}

local setName = function()
    return "myname"
end

hello.getName = function() --给hello添加一个key值：getName，value就是function
    print(setName())
end

return hello
[sandu@bogon tmp]$ cat user.lua 
local helloTable = require("hello")

helloTable.getName()
[sandu@bogon tmp]$ lua user.lua  
myname
[sandu@bogon tmp]$

7. openresty企业级应用1

openresty是基于nginx和lua，所以nginx能干的它基本都能干，通常openresty/nginx都会作为请求入口，即所谓的网关，那么是不是就可以在入口处做很多动作，比如ip拦截、黑白名单校验、限流、url拦截等。

网关

数据校验前置，数据过滤前置，缓存前置。请求聚合，AB测试，监控等

web应用

可以完全借助openresty写出一个web应用，不依靠其他语言，lua可连接数据库，可连接缓存，再对数据进行处理之后返回。所以具备业务逻辑处理的能力

防火墙

即各种拦截，url、ip、黑白名单。

缓存

由于lua有共享缓存，且nginx有缓存功能，所以openresty也能做缓存服务器。

7.1 常用API介绍

API地址

上面所说的是写在lua脚本中的API，即在脚本中使用的代码，那么肯定有个要写脚本的地方对吧，要从nginx走到lua脚本肯定需要一个桥梁，也就是如何运行lua脚本咯。这个桥梁就是nginx指令了，和proxy_pass、echo、listen指令一样，openresty也有一系列的指令，不仅仅包含进入lua代码片段的指令，还有一些控制指令等。

在directive指令集中，content_by_lua,content_by_lua_block和conten_by_lua_file就是写lua脚本的地方。

7.2 API实战演练

helloworld案例

server{
	listen 80;
	location / {
		content_by_lua_block{
			ngx.say("hello wolrd!")
		}   
	}
}

唯一变化的就是多了一条指令：content_by_lua_block。该指令的意思，就是lua代码块内容，ngx.say就是输出打印，同ngx.print

启动openresty 访问localhost，得到“helloworld”结果。

获取请求参数

server{
      listen 81;
      charset "utf-8";
      location / {
          content_by_lua_block{
              local requstMethod = ngx.req.get_method()
              ngx.say('请求方法类型：'..requstMethod)
              local requsetData
              if requstMethod == nil then
                  ngx.say("获取请求方法失败！")
              elseif requstMethod == 'POST' then
                  ngx.req.read_body()
                  requsetData = ngx.req.get_post_args()
              elseif requstMethod == 'GET' then
                  requsetData = ngx.req.get_uri_args()
              end

              for k, v in pairs(requsetData) do
                    ngx.say("key = "..k..' value = '..v)
              end
          }
      }
 }

由于要输出中文，避免中文乱码，加了一个charset指令
ngx.req.get_method()获取请求类型
两个点是字符串连接等于+
nil相当于null
获取post参数前需要先读一下请求体，否则读取失败的哦
uri_args就是get请求URI上的参数 post_args很简单明了了
最后使用for循环输出参数值很简单

使用postman进行验证

get请求

GET ip?a=1&b=2

post请求

POST ip (在Body里添加数据)

获取请求体

locaiton / {
	content_by_lua_block{
	   local headers = ngx.req.get_headers()
	   for k, v in pairs(headers) do
			ngx.say("headerK = "..k..' value = '..v)
	   end
	}
}

日志打印

locaiton / {
	content_by_lua_block{
		local headers = ngx.req.get_headers()
		for k, v in pairs(headers) do
			  ngx.log(ngx.INFO,"headerK = "..k..' value = '..v)
		end
	}
}

日志记录保存在openresty安装目录下的nginx/logs目录下，跟nginx日志保存一样

ngx.log为日志API，日志级别设置在第一个参数中表明。

可设置的值有：

ngx.STDERR,ngx.EMERG,ngx.ALERT,ngx.CRIT,ngx.ERR,ngx.WARN,ngx.NOTICE,ngx.INFO,ngx.DEBUG

需要注意的是日志级别不能低于err_log中设置的日志级别，否则无效。

error_log  logs/error.log  error;

重定向与内部重定向

重定向：ngx.redirect('uri')

server{
    listen 80;
	server_name 172.21.168.120;
    charset "utf-8";
    location /{
        content_by_lua_block{
            ngx.redirect("/request?a=1&b=2")
        }
    }
    location /request {
        content_by_lua_block{
            local requstMethod = ngx.req.get_method()
            ngx.say('请求方法类型：'..requstMethod)
            local requsetData
            if requstMethod == nil then
                ngx.say("获取请求方法失败！")
            elseif requstMethod == 'POST' then
                ngx.req.read_body()
                requsetData = ngx.req.get_post_args()
            elseif requstMethod == 'GET' then
                requsetData = ngx.req.get_uri_args()
            end
            for k, v in pairs(requsetData) do
                  ngx.say("key = "..k..' value = '..v)
            end
        }
    }
}

重定向时也可以指定重定向状态码，默认为302.在浏览器端访问localhost 可以看到url的变化,从localhost重定向到 localhost/request?a=1&b=2,浏览器URL被改写了，也就是重定向的功能。返回结果同B。

访问ip，也就是访问首页，状态302，然后跳转到http://172.21.168.120/request?a=1&b=2,状态200，然后又对http://172.21.168.120/request?a=1&b=2发起一次get请求。

内部重定向：ngx.exec('uri')

浏览器uri不会发生变化，但会有一样的输出结果。

二者区别:

内部重定向不会发出额外的HTTP请求，不涉及新的外部HTTP流量，纯粹是内部的重定向。

调用两者都会终止当前请求的处理，推荐使用return +重定向的方式，强化请求处理在此终止的事实。

子请求

单个子请求：res = ngx.location.capture('uri')

多个子请求：res,res2 = ngx.location.capture_multi('uri1','uri2',...)

所谓子请求，和重定向不同，它是当前请求分发出去的子请求，就像Java中当前主线程中创建一个带有返回值的线程。它不会终止当前请求，相当于去调用一个方法，然后返回结果。并且子请求只是模仿HTTP接口，没有额外的HTTP/tcp流量，一切都在内部执行，非常高效。

res中包括 4个值

status 子请求响应状态码
header 子请求响应头内容
body 子请求响应体内容
truncated 布尔值，判断body中是否包含截断的数据

server{
    listen 80;
    server_name 172.21.168.120;
    charset "utf-8";
    location /{
        content_by_lua_block{
            local cjson = require('cjson')
            local res = ngx.location.capture("/request?a=1&b=2")
            ngx.say(res.status)
            ngx.say(cjson.encode(res.header))
            ngx.say(cjson.encode(res.body))
            ngx.say(res.truncated)
        }
    }
    location /request {
        content_by_lua_block{
            local requstMethod = ngx.req.get_method()
            ngx.say('请求方法类型：'..requstMethod)
            local requsetData
            if requstMethod == nil then
                ngx.say("获取请求方法失败！")
            elseif requstMethod == 'POST' then
                ngx.req.read_body()
                requsetData = ngx.req.get_post_args()
            elseif requstMethod == 'GET' then
                requsetData = ngx.req.get_uri_args()
            end
            for k, v in pairs(requsetData) do
                  ngx.say("key = "..k..' value = '..v)
            end
        }
    }
}

请求返回结果：

200
{"Content-Type":"text\/html"}
"请求方法类型：GET\nkey = a value = 1\nkey = b value = 2\n"
false

cjson是lua的一个库，就相当于java中的核心API，作用就是处理json数据。

很显然，我们看到 request中的输出都放进了body体内，很像方法调用。

多个子请求的用法也比较简单，有几个子请求就要几个返回结果，然后对返回结果进行解析即可。

子请求的作用非常之大，在流量拷贝、API聚合、AB测试中占有巨大地位。

8. openresty企业级应用2

8.1 API请求聚合

比如我们在查看淘宝订单详情的时候，要展示订单派件情况的信息、收货人信息、收货人地址信息、商品信息、付款信息、积分信息还有其他的活动信息等等。在这样一个页面中，你会怎么设计接口信息呢？

http {

    ......
	
    upstream user {
        server localhost:81;
    }
    upstream hair {
        server localhost:82;
    }
    server{
        listen 80;
		server_name 172.21.168.120;
        charset 'UTF-8';
        location / {

        }
        location /user/hair {
            content_by_lua_block{
                local cjson = require('cjson')
                ngx.say("请求植发和个人信息")
                local res,res2 = ngx.location.capture_multi{
                    {'/user/tomcat/userInfo'},
                    {'/hair/jetty/hairInfo'}
                }
                local data ={}
                if(res.status == 200) then
                    data['userinfo'] = res.body
                end
                if(res2.status == 200) then
                    data['hairInfo'] = res2.body
                end
                ngx.say(cjson.encode(data))
            }
        }
        location /user {
            rewrite ^/user(.*)$ $1 break;
            proxy_pass http://user;
        }
        location /hair {
            rewrite ^/hair(.*)$ $1 break;
            proxy_pass http://hair;
        }
		
		location /user/tomcat/userInfo {
			echo "/user/tomcat/userInfo!";
        }
		
		location /hair/jetty/hairInfo {
			echo "/hair/jetty/hairInfo";
        }
		
    }
}

针对 /user/hair 这个URI进行处理，当前端请求该URI时，将会被openresty拦截，进入lua代码块处理
使用子请求调用两个URI，然后将结果进行聚合。
另外又定义了两个location 请求路径，/user和/hair，当子请求发起时，根据URI匹配规则，会调用反向代理
需要注意的是，子请求中的URI /user/,/hair/ 前缀只是起到一个过滤和定位的作用，因为要匹配到location。而真正的请求路径是/tomcat/userInfo 和/jetty/hairInfo，所以就需要将原请求改写成真正的请求路径，要不然请求经过反向代理之后是访问不到资源的，故而使用了rewrite指令。
rewrite 将A规则改写为B规则，^/hair(.)$ 是所有匹配 /hair的路径，$1是指(.*)括号中的内容，也是要被改写的路径。所以 /hair/jetty/hairInfo 经过改写后就变成了 /jetty/hairInfo

请求结果：

请求植发和个人信息
{"hairInfo":"\/hair\/jetty\/hairInfo\n","userinfo":"\/user\/tomcat\/userInfo\n"}

8.2 线上数据库升级方案

使用openresty，则可以很方便的进行线上观察，一方面不妨碍老方案的进行，数据仍可以保存到单库单表中；另一方面，通过流量的拷贝，新方案也能获得线上环境的请求，达到100%线上模拟的效果。然后通过一段时间的观察，假若新方案有问题，对老方案也没有任何影响。而且针对流量拷贝的策略也可以做些定制化，按百分比切换、按黑白名单切换、按订单id范围切换或者按userID取模切换等等，可以说是非常的灵活了.

再将策略方案数据放入redis中或其他缓存中存储，不用重启openresty也可做到方案的快速切换，通过更新缓存数据即可。

具体使用原理主要就是子请求的使用:ngx.location.capture_multi{}，一个请求老方案，一个请求新方案。

其他的就是数据的解析处理了，根据不同的条件进行不同的方案处理，思路就是这个样子啦!代码量不多，两三百行就可以搞定。

附录：lua API帮助文档

Name

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

This module is a core component of OpenResty. If you are using this module, then you are essentially using OpenResty 😃

This module is not distributed with the Nginx source. See the installation instructions.

Status

Production ready.

Version

This document describes ngx_lua v0.10.16, which is not released yet.

Synopsis

 # set search paths for pure Lua external libraries (';;' is the default path):
 lua_package_path '/foo/bar/?.lua;/blah/?.lua;;';

 # set search paths for Lua external libraries written in C (can also use ';;'):
 lua_package_cpath '/bar/baz/?.so;/blah/blah/?.so;;';

 server {
     location /lua_content {
         # MIME type determined by default_type:
         default_type 'text/plain';

         content_by_lua_block {
             ngx.say('Hello,world!')
         }
     }

     location /nginx_var {
         # MIME type determined by default_type:
         default_type 'text/plain';

         # try access /nginx_var?a=hello,world
         content_by_lua_block {
             ngx.say(ngx.var.arg_a)
         }
     }

     location = /request_body {
         client_max_body_size 50k;
         client_body_buffer_size 50k;

         content_by_lua_block {
             ngx.req.read_body()  -- explicitly read the req body
             local data = ngx.req.get_body_data()
             if data then
                 ngx.say("body data:")
                 ngx.print(data)
                 return
             end

             -- body may get buffered in a temp file:
             local file = ngx.req.get_body_file()
             if file then
                 ngx.say("body is in file ", file)
             else
                 ngx.say("no body found")
             end
         }
     }

     # transparent non-blocking I/O in Lua via subrequests
     # (well, a better way is to use cosockets)
     location = /lua {
         # MIME type determined by default_type:
         default_type 'text/plain';

         content_by_lua_block {
             local res = ngx.location.capture("/some_other_location")
             if res then
                 ngx.say("status: ", res.status)
                 ngx.say("body:")
                 ngx.print(res.body)
             end
         }
     }

     location = /foo {
         rewrite_by_lua_block {
             res = ngx.location.capture("/memc",
                 { args = { cmd = "incr", key = ngx.var.uri } }
             )
         }

         proxy_pass http://blah.blah.com;
     }

     location = /mixed {
         rewrite_by_lua_file /path/to/rewrite.lua;
         access_by_lua_file /path/to/access.lua;
         content_by_lua_file /path/to/content.lua;
     }

     # use nginx var in code path
     # CAUTION: contents in nginx var must be carefully filtered,
     # otherwise there'll be great security risk!
     location ~ ^/app/([-_a-zA-Z0-9/]+) {
         set $path $1;
         content_by_lua_file /path/to/lua/app/root/$path.lua;
     }

     location / {
        client_max_body_size 100k;
        client_body_buffer_size 100k;

        access_by_lua_block {
            -- check the client IP address is in our black list
            if ngx.var.remote_addr == "132.5.72.3" then
                ngx.exit(ngx.HTTP_FORBIDDEN)
            end

            -- check if the URI contains bad words
            if ngx.var.uri and
                   string.match(ngx.var.request_body, "evil")
            then
                return ngx.redirect("/terms_of_use.html")
            end

            -- tests passed
        }

        # proxy_pass/fastcgi_pass/etc settings
     }
 }

哈喽

Nginx+lua+openresty精简系列

1. CentOS系统安装openresty

2. 配置虚拟主机

1.基于域名绑定虚拟主机

2.基于端口绑定虚拟主机

3.基于IP绑定虚拟主机

4.总结

3. 配置反向代理

4. 配置负载均衡

5. nginx缓存

6. Lua入门

6.1 Lua变量、值类型

6.2 Lua语法

6.3 Lua库

6.4 模块

7. openresty企业级应用1

7.1 常用API介绍

7.2 API实战演练

8. openresty企业级应用2

8.1 API请求聚合

8.2 线上数据库升级方案

附录：lua API帮助文档

Name

Table of Contents

Status

Version

Synopsis

Description

Typical Uses

Nginx Compatibility

Installation

Building as a dynamic module

C Macro Configurations

Community

English Mailing List

Chinese Mailing List

Code Repository

Bugs and Patches

Lua/LuaJIT bytecode support

System Environment Variable Support

HTTP 1.0 support

Statically Linking Pure Lua Modules

Data Sharing within an Nginx Worker

Known Issues

TCP socket connect operation issues

Lua Coroutine Yielding/Resuming

Lua Variable Scope

Locations Configured by Subrequest Directives of Other Modules

Cosockets Not Available Everywhere

Special Escaping Sequences

Mixing with SSI Not Supported

SPDY Mode Not Fully Supported

Missing data on short circuited requests

TODO

Changes

Test Suite

Copyright and License

See Also

Directives

lua_load_resty_core

lua_capture_error_log

lua_use_default_type

lua_malloc_trim

lua_code_cache

lua_regex_cache_max_entries

lua_regex_match_limit

lua_package_path

lua_package_cpath

init_by_lua

init_by_lua_block

init_by_lua_file

init_worker_by_lua

init_worker_by_lua_block

init_worker_by_lua_file

set_by_lua

set_by_lua_block

set_by_lua_file

content_by_lua

content_by_lua_block