转载

Nginx从原理到实战

本文收录多位大佬对于Nginx的各种操作、应用讲解的文章，希望能帮到大家！

基础原理

先了解基础的知识 一篇让你搞懂 Nginx。

基础+应用

首先介绍 Nginx 的反向代理、负载均衡、动静分离和高可用的原理，随后详解 Nginx 的配置文件，最后通过实际案例实现 Nginx 反向代理和负载均衡的具体配置。学会 Nginx ，一篇足够了。

1. 简介

Nginx 是开源的轻量级 Web 服务器、反向代理服务器，以及负载均衡器和 HTTP 缓存器。其特点是高并发，高性能和低内存。
Nginx 专为性能优化而开发，性能是其最重要的考量，实现上非常注重效率，能经受高负载的考验，最大能支持 50000 个并发连接数。 Nginx 还支持热部署，它的使用特别容易，几乎可以做到 7x24 小时不间断运行。 Nginx 的网站用户有：百度、淘宝、京东、腾讯、新浪、网易等。

2. 反向代理

2.1 正向代理

Nginx 不仅可以做反向代理，实现负载均衡，还能用做正向代理来进行上网等功能。

file

2.2 反向代理

客户端对代理服务器是无感知的，客户端不需要做任何配置，用户只请求反向代理服务器，反向代理服务器选择目标服务器，获取数据后再返回给客户端。反向代理服务器和目标服务器对外而言就是一个服务器，只是暴露的是代理服务器地址，而隐藏了真实服务器的IP地址。

file

3. 负载均衡

将原先请求集中到单个服务器上的情况改为增加服务器的数量，然后将请求分发到各个服务器上，将负载分发到不同的服务器，即负载均衡。

file

4. 动静分离

为了加快网站的解析速度，可以把静态页面和动态页面由不同的服务器来解析，加快解析速度，降低原来单个服务器的压力。

file

5. 高可用

为了提高系统的可用性和容错能力，可以增加nginx服务器的数量，当主服务器发生故障或宕机，备份服务器可以立即充当主服务器进行不间断工作。

file

6. Nginx配置文件

6.1 文件结构

Nginx 配置文件由三部分组成。

...              #全局块

events {         #events块
   ...
}

http      #http块
{
    ...   #http全局块
    server        #server块
    { 
        ...       #server全局块
        location [PATTERN]   #location块
        {
            ...
        }
        location [PATTERN] 
        {
            ...
        }
    }
    server
    {
      ...
    }
    ...     #http全局块
}

  • 第一部分 全局块
    主要设置一些影响 nginx 服务器整体运行的配置指令。
    比如： worker_processes 1; ， worker_processes 值越大，可以支持的并发处理量就越多。

  • 第二部分 events块
    events 块涉及的指令主要影响Nginx服务器与用户的网络连接。
    比如： worker_connections 1024; ，支持的最大连接数。

  • 第三部分 http块
    http 块又包括 http 全局块和 server 块，是服务器配置中最频繁的部分，包括配置代理、缓存、日志定义等绝大多数功能。

    • server块：配置虚拟主机的相关参数。
    • location块：配置请求路由，以及各种页面的处理情况。

6.2 配置文件

########### 每个指令必须有分号结束。#################
#user administrator administrators;  #配置用户或者组，默认为nobody nobody。
#worker_processes 2;  #允许生成的进程数，默认为1
#pid /nginx/pid/nginx.pid;   #指定nginx进程运行文件存放地址
error_log log/error.log debug;  #制定日志路径，级别。这个设置可以放入全局块，http块，server块，级别以此为：debug|info|notice|warn|error|crit|alert|emerg
events {
    accept_mutex on;   #设置网路连接序列化，防止惊群现象发生，默认为on
    multi_accept on;  #设置一个进程是否同时接受多个网络连接，默认为off
    #use epoll;      #事件驱动模型，select|poll|kqueue|epoll|resig|/dev/poll|eventport
    worker_connections  1024;    #最大连接数，默认为512
}
http {
    include       mime.types;   #文件扩展名与文件类型映射表
    default_type  application/octet-stream; #默认文件类型，默认为text/plain
    #access_log off; #取消服务日志    
    log_format myFormat '$remote_addr–$remote_user [$time_local] $request $status $body_bytes_sent $http_referer $http_user_agent $http_x_forwarded_for'; #自定义格式
    access_log log/access.log myFormat;  #combined为日志格式的默认值
    sendfile on;   #允许sendfile方式传输文件，默认为off，可以在http块，server块，location块。
    sendfile_max_chunk 100k;  #每个进程每次调用传输数量不能大于设定的值，默认为0，即不设上限。
    keepalive_timeout 65;  #连接超时时间，默认为75s，可以在http，server，location块。

    upstream mysvr {   
      server 127.0.0.1:7878;
      server 192.168.10.121:3333 backup;  #热备
    }
    error_page 404 https://www.baidu.com; #错误页
    server {
        keepalive_requests 120; #单连接请求上限次数。
        listen       4545;   #监听端口
        server_name  127.0.0.1;   #监听地址       
        location  ~*^.+$ {       #请求的url过滤，正则匹配，~为区分大小写，~*为不区分大小写。
           #root path;  #根目录
           #index vv.txt;  #设置默认页
           proxy_pass  http://mysvr;  #请求转向mysvr 定义的服务器列表
           deny 127.0.0.1;  #拒绝的ip
           allow 172.18.5.54; #允许的ip           
        } 
    }
}

7.配置实例

7.1 反向代理

7.1.1 实战一

实现效果：
在浏览器输入 http://www.abc.com, 从 nginx 服务器跳转到 linux 系统 tomcat 主页面。
具体配置：

server {
        listen       80;   
        server_name  192.168.4.32;   #监听地址

        location  / {       
           root html;  #/html目录
           proxy_pass http://127.0.0.1:8080;  #请求转向
           index  index.html index.htm;      #设置默认页       
        } 
    }

7.1.2 实战二

实现效果：
根据在浏览器输入的路径不同，跳转到不同端口的服务中。
具体配置：

server {
        listen       9000;   
        server_name  192.168.4.32;   #监听地址       

        location  ~ /example1/ {  
           proxy_pass http://127.0.0.1:5000;         
        } 

        location  ~ /example2/ {  
           proxy_pass http://127.0.0.1:8080;         
        } 
    }

location 指令说明：

  • ~ : 表示uri包含正则表达式，且区分大小写。
  • ~* : 表示uri包含正则表达式，且不区分大小写。
  • = : 表示uri不含正则表达式，要求严格匹配。

7.2 负载均衡

7.2.1 实战一

实现效果：
在浏览器地址栏输入 http://192.168.4.32/example/a.html ，平均到 5000 和 8080 端口中，实现负载均衡效果。
具体配置：

upstream myserver {   
      server 192.167.4.32:5000;
      server 192.168.4.32:8080;
    }


    server {
        listen       80;   #监听端口
        server_name  192.168.4.32;   #监听地址

        location  / {       
           root html;  #html目录
           index index.html index.htm;  #设置默认页
           proxy_pass  http://myserver;  #请求转向 myserver 定义的服务器列表      
        } 
    }

nginx 分配服务器策略

  • 轮询（默认）
    按请求的时间顺序依次逐一分配，如果服务器down掉，能自动剔除。
  • 权重
    weight 越高，被分配的客户端越多，默认为 1。比如：
            upstream myserver {   
              server 192.167.4.32:5000 weight=10;
              server 192.168.4.32:8080 weight=5;
            }
  • ip
    按请求 ip 的 hash 值分配，每个访客固定访问一个后端服务器。比如：
            upstream myserver { 
              ip_hash;  
              server 192.167.4.32:5000;
              server 192.168.4.32:8080;
            }
  • fair
    按后端服务器的响应时间来分配，响应时间短的优先分配到请求。比如：
            upstream myserver { 
              fair;  
              server 192.167.4.32:5000;
              server 192.168.4.32:8080;
            }

恭喜！目前为止你已经掌握了 Nginx 的基本原理，并且能够配置反向代理和负载均衡。接下来还会更新一篇Nginx进阶：从原理到实践，彻底搞懂Nginx（高级篇），实现Nginx 配置动静分离和高可用配置实例，并对 Nginx 原理进行深入解析。

愿早日战胜疫情！码字不易，点个赞鼓励一下吧~

高级篇

Nginx高级应用

配置实例
接 从原理到实战，彻底搞懂 Nginx！，本文为 Nginx 实操高级篇。通过配置 Nginx 配置文件，实现正向代理、反向代理、负载均衡、Nginx 缓存、动静分离和高可用 Nginx 6种功能，并对 Nginx 的原理作进一步的解析。当需要使用 Nginx 配置文件时，参考本文实例即可，建议收藏。

1. 正向代理

正向代理的代理对象是客户端。正向代理就是代理服务器替客户端去访问目标服务器。
1.1 实战一
实现效果：
在浏览器输入 http://www.google.com , 浏览器跳转到http://www.google.com 。
具体配置：

 server{
     resolver 8.8.8.8;
     listen 80;

     location / {
         proxy_pass http://$http_host$request_uri;
     }
 }

在需要访问外网的客户端上执行以下一种操作即可：

 1. 方法1（推荐） 
export http_proxy=http://你的正向代理服务器地址：代理端口   

2. 方法2 
vim ~/.bashrc export http_proxy=http://你的正向代理服务器地址：代理端口

2. 反向代理

反向代理指代理后端服务器响应客户端请求的一个中介服务器，代理的对象是服务端。
2.1 实战一
实现效果：
在浏览器输入 http://www.abc.com , 从 nginx 服务器跳转到 linux 系统 tomcat 主页面。
具体配置：

 server {
     listen       80;
     server_name  192.168.4.32;   #监听地址

     location  / {
         root html;  #/html目录  
         proxy_pass http://127.0.0.1:8080;  #请求转向
         index  index.html index.htm;      #设置默认页    
     }
}

2.2 实战二
实现效果：
根据在浏览器输入的路径不同，跳转到不同端口的服务中。
具体配置：

 server {
     listen       9000;
     server_name  192.168.4.32;   #监听地址

     location  ~ /example1/ {
         proxy_pass http://127.0.0.1:5000;
     }

     location  ~ /example2/ {
         proxy_pass http://127.0.0.1:8080;
     }
 }

location 指令说明：

  • ~ : 表示uri包含正则表达式，且区分大小写。
  • ~* : 表示uri包含正则表达式，且不区分大小写。
  • = : 表示uri不含正则表达式，要求严格匹配。

3 负载均衡

3.1 实战一
实现效果：
在浏览器地址栏输入 http://192.168.4.32/example/a.html ，平均到 5000 和 8080 端口中，实现负载均衡效果。
具体配置：

upstream myserver {   
    server 192.167.4.32:5000;
    server 192.168.4.32:8080;     
}           

server {     
    listen       80;   #监听端口   
    server_name  192.168.4.32;   #监听地址   

    location  / {             
        root html;  #html目录        
        index index.html index.htm;  #设置默认页    
        proxy_pass  http://myserver;  #请求转向 myserver 定义的服务器列表      
    }
}

nginx 分配服务器策略

  • 轮询（默认）
    按请求的时间顺序依次逐一分配，如果服务器down掉，能自动剔除。
  • 权重
    weight 越高，被分配的客户端越多，默认为 1。比如：
upstream myserver {   
    server 192.167.4.32:5000 weight=10;        
    server 192.168.4.32:8080 weight=5;  
}
  • ip
    按请求 ip 的 hash 值分配，每个访客固定访问一个后端服务器。比如：
upstream myserver {     
    ip_hash;         
    server 192.167.4.32:5000;   
    server 192.168.4.32:8080;  
}
  • fair
    按后端服务器的响应时间来分配，响应时间短的优先分配到请求。比如：
upstream myserver {   
    fair;      
    server 192.168.4.32:5000; 
    server 192.168.4.32:8080;   
}

4. Nginx 缓存

4.1 实战一
实现效果：
在3天内，通过浏览器地址栏访问 http://192.168.4.32/a.jpg ，不会从服务器抓取资源，3天后（过期）则从服务器重新下载。
具体配置：

 # http 区域下添加缓存区配置 
proxy_cache_path /tmp/nginx_proxy_cache levels=1 keys_zone=cache_one:512m inactive=60s max_size=1000m;  

# server 区域下添加缓存配置 
location ~ \.(gif|jpg|png|htm|html|css|js)(.*) {  
    proxy_pass http://192.168.4.32:5000；#如果没有缓存则转向请求 
    proxy_redirect off;   
    proxy_cache cache_one;   
    proxy_cache_valid 200 1h;            #对不同的 HTTP 状态码设置不同的缓存时间  
    proxy_cache_valid 500 1d; 
    proxy_cache_valid any 1m;  
    expires 3d; 
}

expires 是给一个资源设定一个过期时间，通过 expires 参数设置，可以使浏览器缓存过期时间之前的内容，减少与服务器之间的请求和流量。也就是说无需去服务端验证，直接通过浏览器自身确认是否过期即可，所以不会产生额外的流量。此种方法非常适合不经常变动的资源。

5. 动静分离

5.1 实战一
实现效果：
通过浏览器地址栏访问 www.abc.com/a.html ，访问静态资源服务器的静态资源内容。通过浏览器地址栏访问 www.abc.com/a.jsp ，访问动态资源服务器的动态资源内容。
具体配置：

upstream static {   
    server 192.167.4.31:80; 
}  

upstream dynamic {     
    server 192.167.4.32:8080; 
}  

server { 
    listen       80;   #监听端口  
    server_name  www.abc.com; 监听地址 

    # 拦截动态资源  
    location ~ .*\.(php|jsp)$ {  
        proxy_pass http://dynamic;
    }   

    # 拦截静态资源 
    location ~ .*\.(jpg|png|htm|html|css|js)$ {  
        root /data/;  #html目录 
        proxy_pass http://static;    
        autoindex on;;  #自动打开文件列表  
    }
}

6. 高可用

一般情况下，通过 nginx 主服务器访问后台目标服务集群，当主服务器挂掉后，自动切换至备份服务器，此时由备份服务器充当主服务器的角色，访问后端目标服务器。
6.1 实战一
实现效果：
准备两台 nginx 服务器，通过浏览器地址栏访问虚拟 ip 地址，把主服务器的 nginx 停止，再次访问虚拟 ip 地址仍旧有效。
具体配置：
（1）在两台 nginx 服务器上安 keepalived。
keepalived 相当于一个路由，它通过一个脚本来检测当前服务器是否还活着，如果还活着则继续访问，否则就切换到另一台备份服务器。

# 安装 keepalived
 yum install keepalived -y  

# 检查版本 
rpm -q -a keepalived 
keepalived-1.3.5-16.el7.x86_64

（2）修改主备服务器 /etc/keepalived/keepalivec.conf 配置文件（可直接替换），完成高可用主从配置。
keepalived 将 nginx 服务器绑定到一个虚拟 ip ， nginx 高可用集群对外统一暴露这个虚拟 ip，客户端都是通过访问这个虚拟 ip 来访问 nginx 服务器 。

global_defs {
    notification_email {
        acassen@firewall.loc
        failover@firewall.loc
        sysadmin@firewall.loc
    }

    notification_email_from_Alexandre.Cassen@firewall.loc
    smtp_server 192.168.4.32  
    smtp_connect_timeout 30
    router_id LVS_DEVEL  # 在 /etc/hosts 文件中配置，通过它能访问到我们的主机 
}  

vrrp_script_chk_http_port {
    script "/usr/local/src/nginx_check.sh" 
    interval 2      # 检测脚本执行的时间间隔   
    weight 2        # 权重每次加2 
} 

vrrp_instance VI_1 {  
    interface ens7f0 # 网卡，需根据情况修改 
    state MASTER    # 备份服务器上将 MASTER 改为 BACKUP  
    virtual_router_id 51 # 主备机的 virtual_router_id 必须相同   
    priority 100   # 主备机取不同的优先级，主机值较大，备份机值较小  
    advert_int 1  # 每隔多长时间（默认1s）发送一次心跳，检测服务器是否还活着 

    authentication {  
    auth_type PASS     
    auth_pass 1111     
    }  

    virtual_ipaddress { 
        192.168.1.100 # VRRP H 虚拟地址，可以绑定多个  
    }
}

字段说明

  • router_id： 在 /etc/hosts 文件中配置，通过它能访问到我们的主机。
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4   
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6   
127.0.0.1   LVS_DEVEL
  • interval： 设置脚本执行的间隔时间
  • weight： 当脚本执行失败即 keepalived 或 nginx 挂掉时，权重增加的值（可为负数）。
  • interface： 输入 ifconfig 命令查看当前的网卡名是什么。
ens7f0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500           
        inet 192.168.4.32  netmask 255.255.252.0  broadcast 192.168.7.255           
        inet6 fe80::e273:9c3c:e675:7c60  prefixlen 64  scopeid 0x20<link>           
        ... ... 
 ... ...

（3）在 /usr/local/src 目录下添加检测脚本 nginx_check.sh。

#!/bin/bash 
A=`ps -C nginx -no-header |wc -l` 

if [ $A -eq 0 ];then 
    /usr/local/nginx/sbin/nginx  
    sleep 2 

    if [ ps -C nginx -no-header |wc -l` -eq 0 ];then  
        killall keepalived 
    fi 
fi

（4）启动两台服务器的 nginx 和 keepalived。

# 启动 nginx 
./nginx  

# 启动 keepalived 
systemctl start keepalived.service

（5）查看虚拟 ip 地址 ip a 。把主服务器 192.168.4.32 nginx 和 keepalived停止，再访问虚拟 ip 查看高可用效果。
\6. 原理解析

file

Nginx 启动之后，在 Linux 系统中有两个进程，一个为 master，一个为 worker。master 作为管理员不参与任何工作，只负责给多个 worker 分配不同的任务（worker 一般有多个）。

ps -ef |grep nginx 
root     20473     1  0  2019 ?        00:00:00 nginx: master process /usr/sbin/nginx 
nginx     4628 20473  0 Jan06 ?        00:00:00 nginx: worker process 
nginx     4629 20473  0 Jan06 ?        00:00:00 nginx: worker process

worker 是如何工作的？

客户端发送一个请求首先要经过 master，管理员收到请求后会将请求通知给 worker，多个 worker 以争抢的机制来抢夺任务，得到任务的 worker 会将请求经由 tomcat 等做请求转发、反向代理、访问数据库等（nginx 本身是不直接支持 java 的）。

file

一个 master 和多个 worker 的好处？

  • 可以使用 nginx -s reload 进行热部署。
  • 每个 worker 是独立的进程，如果其中一个 worker 出现问题，其它 worker 是独立运行的，会继续争抢任务，实现客户端的请求过程，而不会造成服务中断。

设置多少个 worker 合适？
Nginx 和 redis 类似，都采用了 io 多路复用机制，每个 worker 都是一个独立的进程，每个进程里只有一个主线程，通过异步非阻塞的方式来处理请求，每个 worker 的线程可以把一个 cpu 的性能发挥到极致，因此，worker 数和服务器的 cpu 数相等是最为适宜的。

思考：

（1）发送一个请求，会占用 worker 几个连接数？
（2）有一个 master 和 4个 worker，每个 worker 支持的最大连接数为 1024，该系统支持的最大并发数是多少？

恭喜！目前为止你已经掌握了 Nginx 6种功能的配置方式，并和我一起进一步探讨了 Nginx 的原理。最后两个面试中可能会问到的思考题，欢迎大家评论区积极讨论。如果本文对你有所帮助，点赞互相鼓励一下吧~

文章来源：小晶

易踩坑点

Nginx通过匹配路径配置跳转时有带 \ 和不带 \ 的稍微的区别，主要在 proxy_pass 和 location 的使用时，请注意！

 server {
        listen       8080;
        server_name  192.168.1.10;

        location / {
            proxy_pass   http://localhost:8081;
        }
        location /abc {
            proxy_pass   http://localhost:8082;
        }
    }
区别 带 \ 不带 \ 对比区别
location 需要前缀以分隔符为准完全匹配，可滤掉前缀相同的长字符如：/abcdef 可匹配到以abc开头的任意字符，效果如/abc * ,如：/abcdefgh 精确区分最好带斜线 ,/abc/def 、/abddef 的区别
proxy_pass proxy_pass http: //localhost:8082/ proxy_pass http: //localhost:8082 请求匹配到对应的location后：带斜线为截取后面内容拼接到proxy_pass中； 不带斜线将和前缀匹配项一起拼接到proxy_pass中

Nginx+Lua篇

NGINX + LUA实现复杂的控制

第一个lua脚本

ngx.say 是打印的打印输出的意思。。。

location /echo {
default_type text/plain;
echo hello lua;
}
location /lua {
default_type text/plain;
content_by_lua 'ngx.say("hello world")';
}

用lua脚本做nginx的访问的限制...

location @client{
proxy_pass  http://www.ruifengyun.com;
}
location ~  /test {
default_type  text/html;
content_by_lua 'ngx.say("this is  ruifengyun.com!")';
access_by_lua '
if ngx.var.remote_addr == "10.2.20.110" then
ngx.exit(ngx.HTTP_FORBIDDEN)
end
if ngx.var.remote_addr == "10.2.20.112" then
ngx.exec("@client")
end
';
}

控制经过判断之后，才能访问

location / {
access_by_lua '
local res = ngx.location.capture("/auth")
if res.status == ngx.HTTP_OK then
return
end
if res.status == ngx.HTTP_FORBIDDEN then
ngx.exit(res.status)
end
ngx.exit(ngx.HTTP_INTERNAL_SERVER_ERROR)
';
# proxy_pass/fastcgi_pass/postgres_pass/...
}

使用lua做nginx的rewrite跳转

这个是先判断 check-pam接口的return的内容是不是spam，是的话，转跳到其他的页面

location / {
rewrite_by_lua '
local res = ngx.location.capture("/check-spam")
if res.body == "spam" then
ngx.redirect("/terms-of-use.html")
end
'; fastcgi_pass ...;
}

根据ip做不同的响应

location / {
content_by_lua '
           myIP = ngx.req.get_headers()["X-Real-IP"]
           if myIP == nil then
               myIP = ngx.req.get_headers()["x_forwarded_for"]
           end
           if myIP == nil then
               myIP = ngx.var.remote_addr
           end
           if myIP == "" then
               ngx.exec("@client")
           else
               ngx.exec("@client_test")
           end
       ';
}

redirect的使用

return ngx.redirect("/foo")
return ngx.redirect("http://localhost:1984/foo", ngx.HTTP_MOVED_TEMPORARILY)
return ngx.redirect("/foo", 301)

返回302临时重定向 地址栏会显示跳转后的地址

rewrite ^ /foo? redirect;  # nginx config
return ngx.redirect('/foo');  -- lua code

lua过滤post过来的参数

location = /test {
content_by_lua '
ngx.req.read_body()
local args = ngx.req.get_post_args()
for key, val in pairs(args) do
if type(val) == "table" then
ngx.say(key, ": ", table.concat(val, ", "))
else
ngx.say(key, ": ", val)
end
end
';
}

一个Lua的例子：

#!/usr/bin/env lua
ngx.say('aaaaaa </br>')
local url = ngx.var.uri
ngx.say('<br>',url,'<br/>')
ngx.print('这次访问的header头是   ',ngx.req.raw_header())
ngx.print('<meta http-equiv="content-type" content="text/html;charset=utf-8">')
ngx.print('<h1> 这个是 h1 </h1>')
ngx.print('这次访问的是 get 还是 post 呀   ',ngx.req.get_Method())
local args = ngx.req.get_uri_args()
ngx.print(args)
local res = ngx.location.capture("/")
ngx.print('<br>http code <br>‘,res.status)

lua 调用mysql的例子

worker_processes  2;
error_log logs/error.log warn;
events {
worker_connections 1024;
}
http {
  upstream backend {
  drizzle_server 127.0.0.1:3306 protocol=mysql
  dbname=ngx_test user=ngx_test password=ngx_test;
  drizzle_keepalive max=10 overflow=ignore mode=single;
}
server {
  listen 8080;
  location @cats-by-name {
    set_unescape_uri $name $arg_name;
    set_quote_sql_str $name;
    drizzle_query 'select * from cats where name=$name';
    drizzle_pass backend;
    rds_json on;
 }
 location @cats-by-id {
  set_quote_sql_str $id $arg_id;
  drizzle_query 'select * from cats where id=$id';
  drizzle_pass backend;
  rds_json on;
 }
 location = /cats {
   access_by_lua '
   if ngx.var.arg_name then
   return ngx.exec("@cats-by-name")
   end
   if ngx.var.arg_id then
    return ngx.exec("@cats-by-id")
   end
';
  rds_json_ret 400 "expecting \"name\" or \"id\" query arguments";
 }
}
}

改改密码就能用啦~

lua获取url中的参数

location = /adder {
    set_by_lua $res "
            local a = tonumber(ngx.arg[1])
                local b = tonumber(ngx.arg[2])
                return a + b" $arg_a $arg_b;

        echo $res;
}

ngx.req.set_uri

nginx里面的配置是：

location /test {
       rewrite ^/test/(.*) /$1 break;
       proxy_pass http://my_backend;
   }

lua里面的配置是：

location /test {
       rewrite_by_lua '
           local uri = ngx.re.sub(ngx.var.uri, "^/test/(.*)", "$1", "o")
           ngx.req.set_uri(uri)
       ';
       proxy_pass http://my_backend;
   }

我想大家看这个对照，已经知道是啥意思了.

通过lua获取nginx的内置变量，通过这些变量做些逻辑的处理~

Nginx提供了很多内置的变量,如:

  • $arg_PARAMETER 这个变量包含在查询字符串时GET请求PARAMETER的值。
  • $args 这个变量等于请求行中的参数。
  • $binary_remote_addr 二进制码形式的客户端地址。
  • $body_bytes_sent 传送页面的字节数
  • $content_length 请求头中的Content-length字段。
  • $content_type 请求头中的Content-Type字段。
  • $cookie_COOKIE cookie COOKIE的值。
  • $document_root 当前请求在root指令中指定的值。
  • $document_uri 与$uri相同。
  • $host 请求中的主机头字段，如果请求中的主机头不可用，则为服务器处理请求的服务器名称。
  • $is_args 如果$args设置，值为"?"，否则为""。
  • $limit_rate 这个变量可以限制连接速率。
  • $nginx_version 当前运行的nginx版本号。
  • $query_string 与$args相同。
  • $remote_addr 客户端的IP地址。
  • $remote_port 客户端的端口。
  • $remote_user 已经经过Auth Basic Module验证的用户名。
  • $request_filename 当前连接请求的文件路径，由root或alias指令与URI请求生成。
  • $request_body 这个变量（0.7.58+）包含请求的主要信息。在使用proxy_pass或fastcgi_pass指令的location中比较有意义。
  • $request_body_file 客户端请求主体信息的临时文件名。
  • $request_completion 未知。
  • $request_method 这个变量是客户端请求的动作，通常为GET或POST。包括0.8.20及之前的版本中，这个变量总为main request中的动作，如果当前请求是一个子请求，并不使用这个当前请求的动作。
  • $request_uri 这个变量等于包含一些客户端请求参数的原始URI，它无法修改，请查看$uri更改或重写URI。
  • $scheme 所用的协议，比如http或者是https，比如rewrite ^(.+)$ $scheme://example.com$1 redirect;
  • $server_addr 服务器地址，在完成一次系统调用后可以确定这个值，如果要绕开系统调用，则必须在listen中指定地址并且使用bind参数。
  • $server_name 服务器名称。
  • $server_port 请求到达服务器的端口号。
  • $server_protocol 请求使用的协议，通常是HTTP/1.0或HTTP/1.1。
  • $uri 请求中的当前URI(不带请求参数，参数位于$args)，可以不同于浏览器传递的$request_uri的值，它可以通过内部重定向，或者使用index指令进行修改。

另外： HTTP_X_FORWARDED_FOR是透过代理服务器取得客户端的真实IP地址，有些用此方法读取到的仍然是代理服务器的IP。还有一点需要注意的是：如果客户端没有通过代理服务器来访问，那么用 HTTP_X_FORWARDED_FOR 取到的值将是空的。

函数版的访问

location /lua1 {
default_type 'text/plain';
content_by_lua 'ngx.say("hello, lua")';
}
# 请求另外的url
location /lua2 {
content_by_lua '     
　　local res = ngx.location.capture("/hello1")     
　　ngx.say("data: " .. res.body)  
';
}

文章来源：huangyimo

nginx+lua实践场景

前言

nginx，lua，nginx+lua，这三个名词不知道大家熟悉多少。为了后面内容的展示，我简单的介绍一下它们，想深入了解的网上资料很多，在这就不啰嗦了。nginx是一个高性能的反向代理服务器，一般会处在网站的最前端（有可能前面还会加一层slb，在这暂时忽略），用来做后端web服务的代理；lua是一个小巧的脚本语言，其设计的目的就是嵌入应用程序中，为其提供一些扩展和增强，比如redis，nginx等等；nginx+lua顾名思义就是nginx和lua的结合体，这两者之间沟通的桥梁是nginx_lua_module，它是nginx的一个模块，有了它nginx和lua才能互通，笔者在最近几年的工作中恰好有这方面的开发经验，所以想把这些真实的使用场景分享出来供大家做参考，具体的api doc还请大家参考官方资料。

案例1-入口层流量的灰度识别

何谓入口层流量的灰度识别呢，简单来说就是A用户的请求打到线上环境，B用户的请求打到灰度环境，目的就是做新功能的验证，实现逻辑很简单，大体流程如下：

1.测试同学在灰度控制台配置灰度规则，规则里会约束哪些url下哪些商户的请求进入灰度环境；

2.灰度控制台推送规则给入口层nginx，nginx会将规则存储到本地内存中，借助ngx.shared.DICT；

3.请求进入的时候（通过rewrite_by_lua_file触发）获取本地内存中的规则进行比对，如何命中规则就将请求转发到灰度环境，对nginx来说就是切换不同的upstream，比如线上是prod_serverA，灰度是gray_serverA；

代码片段如下：

upstream gray_serverA {``  ``server 192.68.1.``1:8080``;``}` `upstream prod_serverA {``  ``server 192.68.1.``2:8080``;``}` `server {``  ``listen 80;``  ``server_name graytest.demo.com;``  ``charset utf-8;``  ` `  ``location ~ \.do$ {``    ``set $backend ``'prod_serverA'``;  #默认的upstream为线上服务``    ``rewrite_by_lua_file ``"conf/lua-gray/rewriter.lua"``; # <a href=``"https://github.com/openresty/lua-nginx-module/#rewrite_by_lua_file"` `target=``"_blank"``>rewrite_by_lua_file</a> 可以简单的理解为一个过滤器，nginx在rewrite阶段会执行你指定的脚本文件，``          ``　　　　　　　　　　 #在这个文件中我们会判断请求是否为灰度请求如果是灰度请求就将backend改为gray_serverA``    ``proxy_pass http://$backend;``  ``} ``}

　　

案例2-入口层记录错误日志

之前有同学反馈说springmvc偶尔会报415错误，这个错误的一个常见原因是传递的Content-Type头不对，比如后端需要application/json，但是前端传递了application/x-www-form-urlencoded，那就会报这个错。但是跟前端确认了传递的头是没有问题的，有人猜测可能是头信息有特殊字符，导致后端web 容器（tomcat、resin）解析头出现了问题，既然这样把所有请求头打出来一看究竟，于是lua再一次出场，这次主要用来输出请求头到日志文件中，主要用到了log_by_lua_block这个指令，代码片段如下：

location  ~ \.do$ {
        proxy_pass http://$backend;
        log_by_lua_block {　　　　　　//判断下如果http 响应状态码为415就输出请求头到文件中
          if tonumber(ngx.var.status) == 415 then
                ngx.log(ngx.ERR,"upstream reponse status is 415,please notice it,here are request headers:")
                local h, err = ngx.req.get_headers(100,true)

               if err == "truncated" then
                    ngx.log(ngx.ERR,"request headers beyond 100,will not return")
                else
                   local cjson = require("cjson")
                   ngx.log(ngx.ERR,cjson.encode(h))
              end
          end
       }
   }

想详细了解这个案例的，请移步到我的另一篇博客（https://www.cnblogs.com/chopper-poet/p/11625144.html）。

案例3-将nginx信息注册到监控平台

需求很简单，当nginx启动的时候将自身信息上报到redis中，上报内容包扣自身的ip，代理的域名信息等，有个监控平台会定期从redis读取这些信息做展示，方便运维干活，流程很简单就是定时读取自身ip和代理的域名信息写到redis中，为什么要定时呢，这里还起到一种心跳的效果，当长时间没有上报时可能是nginx出问题了，主要用到的指令如下：

1.init_worker_by_lua_file "conf/ua-grayngxReloadListener.lua"，当nginx启动或者reload的时候会执行指定的文件；

2.ngx.worker.id() 这个方法会返回nginx worker进程的编号，从0开始，如果nginx有4个worker，那取值范围为0-3，这个主要是为了防止并发上报，因为第一步里面提到的init_worker_by_lua_file，如果有几个worker就会触发几次，所以为了只上报一次，会判断下返回值是否为0，也就是只让第一个worker执行；

3.ngx.timer.every 用来执行定时任务；

代码片段如下：

local worker``Id` `= ngx.worker.id()` `if``(worker``Id` `== 0) then``  ``ngx.log(ngx.``INFO``,``'workerId is 0 will startup task'``)``    ` `  ` `  ``local ok, err = ngx.timer.every(4,function()``    ``#1. get local ip ``and` `domins``      ``#2. write to redis``  ``end``)` `else``  ``ngx.log(ngx.``INFO``,``'workerId is not 0 ,just ignore it'``)``end

案例4-将入口层流量同时转发到多个后端服务

类似于消息队列的发布订阅一样，在nginx这一层可以将一个请求同时发到多个地址，代码片段如下：

location  ~ /capture_test$ {
            content_by_lua_block {
            ngx.req.read_body()

            res1, res3 = ngx.location.capture_multi{
                        { "/capture_test1",{ method = ngx.HTTP_POST, always_forward_body=true}},
                       { "/capture_test2",{ method = ngx.HTTP_POST, always_forward_body=true}},
                  }

           ngx.say(res3.body)
           ngx.exit(res3.status)
    }

总结

上面列举了nginx+lua在我司使用的四个案例，真实场景要复杂很多，为了方便大家理解，特意将案例做了简化。如果觉得有用，请点个推荐。

参考资料

https://github.com/openresty/lua-nginx-module

文章来源：踩刀诗人

插件篇

nginx的headers_more模块

nginx的headers_more模块用于 添加、修改或清除 请求/响应头，该模块不是nginx自带的，默认不包含该模块，需要另外安装。幸运的是openresty默认包含了该模块，可以直接使用。

该模块主要有4个指令

  • more_set_headers 用于 添加、修改、清除 响应头
  • more_clear_headers 用于 清除 响应头
  • more_set_input_headers 用于 添加、修改、清除 请求头
  • more_clear_input_headers 用于 清除 请求头

1. 删除响应头

去掉X-Powered-By 和 Server响应头：

more_clear_headers X-Powered-By Server;

删除前：

file

删除后：

file

2.自定义响应头

去掉X-Powered-By响应头，增加一个X-Author响应头，修改Server响应头为Apache，伪装一下。

more_clear_headers X-Powered-By;
more_set_headers "X-Author: Lcy" "Server: Apache 2.4";

效果：

file

3. 修改请求头

把query_string 中的cid参数改写成Cookie。

if ($arg_cid) {
  more_set_input_headers "Cookie: PHPSESSID=$arg_cid";
}

效果如下：

file

4.参考

该模块的详细文档可参考 headers-more-nginx-module 。

文章来源：chunyuan314

正文到此结束
所属分类：工具
  • 本文标签： Nginx 高效 工具
  • 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
阿里云首购8折
热门推荐
相关文章
说给你听

本文目录
    标签云
    Linux Java Spring Spring Boot 其他 建站 Mysql 安全 广告 基础 Git&Svn Docker 网络 OS UML 数据结构&算法 JVM 分布式 MQ 监控 感悟 K8s Spring Cloud 秒杀 线程 性能 设计模式 IDEA redis 速查 vertx hash SQL 锁 面试 数据库 VUE 前端 工具 高效 Nginx Lua shell 架构 windows Protobuf 优化 总结 dubbo 故障 Gradle 爬虫 valid 日期 Job
    1. 暂无相关文章
    网站信息
    • 文章总数：93 篇
    • 标签总数：55 个
    • 分类总数：17 个
    • 留言数量：0 条
    • 在线人数：1人
    • 运行天数：518天
    • 最后更新：2020年05月31日00点