Nginx

Nginx官网

Tengine翻译的Nginx中文文档

轻量级的Web服务器，主要有反向代理、负载均衡的功能。

能够支撑5万的并发量，运行时内存和CPU占用低，配置简单，运行稳定。

写在前

uWSGI与Nginx的关系

1. 安装

Windows

官网 Stable version 稳定版本 1.26.2.zip

Linux

官网 Stable version 稳定版本 nginx-1.26.2-1.el9.ngx.x86_64.rpm

rpm包比较完整，也不需要编译等操作，安装后直接使用。

# 解压
rpm -ivh nginx-*.rpm
# 关闭防火墙
firewall-cmd --zone=public --add-port=80/tcp --permanent
firewall-cmd --reload

2. 命令

3. 使用场景与配置

虚拟主机

server {
    # 1. 基于多ip的虚拟主机: 1isten监听不同网卡的ip，端口可相同
    listen 8000;
    server_name 122.12.1.1;
    listen 8000;
    server_name 122.12.1.2;
    
    # 2. 基于多端口的虚拟主机: listen监听不同端口
    # 本地内网
    listen 8001;
    server_name localhost;
    listen 8002;
    server_name localhost;
    
    # 3. 基于域名的虚拟主机: 端口可相同，server_name为不同域名
    # 公网
    listen 8003;
    server_name www.test1.com;
    listen 8003;
    server_name www.test2.com;  
}

静态站点

为了加快网站的解析速度，可以将静态资源交给Nginx解析，动态资源交给后端服务器解析。

server {
    listen 80;
    server_name localhost;
    
    location / {
        root /opt/nginx/html;
        index index.html index.htm;
    }
}

反向代理

用户客户端访问代理服务器后，被反向代理服务器（Nginx）按照一定的规则从一个或多个被代理服务器（后端服务）中获取响应资源并返回给客户端代理模式。客户端只知道代理服务器的IP，并不知道后端服务器的IP，原因是代理服务器隐藏了被代理服务器的信息。

• 应用层反向代理（七层反向代理）

  代理HTTP/HTTPS流量

  在配置文件nginx.conf的http段中

  server {
      listen 8088;
      server_name localhost;
      
      location / {
          proxy_pass https://www.baidu.com;
      }
  }
  

• 传输层反向代理（四层反向代理）

  代理TCP/UDP流量

  核心模块stream需要在编译配置时怎加 --with-stream参数进行编译（rpm包已经包含）

  stream {
      server {
          listen 3306;
          proxy_pass 122.12.0.1:3306;
      }
  }
  

**负载均衡

当出现高并发大流量业务时，单台后端服务器已经无法支撑业务正常运行，需要将请求流量按照一定规则分发到堕胎服务节点上，即使某个节点宕机，系统依然能够对外正常提供服务，以此来提高系统的稳定性。

支持协议：

支持协议

upstream模块

定义上游服务器（应用服务器）

server可选参数

负载均衡算法

• 轮询（默认）

  每个请求按时间顺序逐一分配到不同的后端服务器

  upstream backend {
      # 默认所有服务器权重都为1
      server 192.168.1.1:8000;
      server 192.168.1.2:8000;
      server 192.168.1.3:8000;
  }
  

• 权重轮询
  指定轮询概率，用于后端服务器性能不均的情况

  upstream backend {
      server 192.168.1.1：8000 weight=3;
      server 192.168.1.2：8000 weight=2;
      server 192.168.1.3：8000; # default weight=1
  }
  

• 哈希
  哈希算法是将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值叫哈希值，映射不可逆。

  根据hash $request_uri变量的哈希值来负载

  upstream backend {
      hash $request_uri;
      server 192.168.1.1：8000;
      server 192.168.1.2：8000;
      server 192.168.1.3：8000;
  }
  

• ip_hash

  每个请求按访问ip的哈希结果分配，这样每个访客固定访问一个后端服务器，是session共享问题的解决方案之一

  upstream backend {
      ip_hash;
      server 192.168.1.1：8000;
      server 192.168.1.2：8000;
      server 192.168.1.3：8000;
  }
  

• 最少连接数算法

  • 从上游服务器挑选一台当前已建立连接数最少的分配请求

  • 极端情况下会退化为轮询算法

  • least conn:

    • 多个worker子进程同时处理请求时，无法共享后端服务器的连接数状态，此时需要开辟共享内存空间，用来在多个worker子进程中共享信息
    • zone zone_name 1M，开辟共享内存

    upstream backend {
        list_conn;
        server 192.168.1.1：8000;
        server 192.168.1.2：8000;
        server 192.168.1.3：8000;
    }
    

对上游服务器返回异常的处理

• 遇到这些情况下执行失败转发

  语法：proxy_next_upstream error | timeout | invalid_header | http_500 | http_502 | http_503 | http_504 | http_403 | http_404 | http_ 429 |non_idempotent | off

  默认值

  proxy_next_upstream error timeout
  

  上下文：http, server, location

  参数	含义
  error	向后台服务器发送请求，或读取响应头出错时（服务器宕机会转发到下一台）
  timeout	向后台服务器发送请求，或读取响应头超时时(proxy_read_timeout设置的时间内没有收完响应体，则会转发到下一台服务器；但服务器宕机的话会返回502，不会转发到下一台)
  http_500/502/503/504/403/404/429	http响应状态码
  non_idempotent	非幂等请求失败时，是否需要转发到下一台后端服务器（不设置就不转发，如post请求时，如果命中404，则会返回404。对于写操作更好不要轻易设置）
  off	禁用请求失败转发功能

• 等待超时时间，超过这个时间就不再尝试失败转发

  语法：proxy_next_upstream_timeout time

  默认值

  proxy_next_upstream_timeout 0 (不等待)
  

  上下文：http, server, location

• 失败转发次数

  语法：proxy_next_upstream_tries number

  默认值

  proxy_next_upstream_tries 0 (一直转发)
  

  上下文：http, server, location

其他配置

• 请求体原封不动传给后端

  语法：proxy_pass_request_body on

• 修改http协议版本

  语法

  proxy_http_version 1.1;
  proxy_set_header test "text";
  proxy_pass_request_headers off;
  

示例

upstream test_8080 {
    zone test_8080 64k; # 配置提供共享内存区域，这允许我们在多个Nginx工作进程之间共享数据
    server localhost：8001 weight=2 max_conns=1000 fail_timeout=10s max_fails=5;
    server localhost：8002;
    server localhost：8003;
    
    keepalive 16; # 当同时有5000个请求过来，处理完毕后，会保留16个连接，其他全部关闭
    keepalive_requests 100; # 一个长连接可以处理的最多请求个数
    keepalive_timeout 30s; # 空闲情况下，一个连接的超时时长，超过后会自动销毁长连接
    
}

server {
    listen 8001;
    server_name localhost;
    
    location /test_8080 {
        return 200 "8001 upstream test"
    }
}

server {
    listen 8002;
    server_name localhost;
    
    location /test_8080 {
        return 200 "8002 upstream test"
    }
}

server {
    listen 8003;
    server_name localhost;
    
    location /test_8080 {
        return 200 "8003 upstream test"
    }
}


server {
    listen 8080;
    server_name localhost;
    
    location /test {
        proxy_pass http://test_8080/upstream_test;
        proxy_next_upstream error timeout nvalid_header http_500 http_502 http_503 http_504 http_403 http_404 http_ 429 non_idempotent off;
        proxy_next_upstream_timeout 0;
        proxy_next_upstream_tries 2;
    }
}

此时访问 http://test_8080/upstream_test后会返回8001 upstream test/8002 upstream test/8003 upstream test其中一个网页，刷新，页面会改变。

4. HTTPS加密

HTTPS 通过加密通道保护客户端与服务端之间的数据传输，已成为当前网站部署的必选配置。在部署有 Nginx 代理集群的 HTTPS 站点，通常会把 SSL 证书部署在 Nginx 的服务器上，然后把请求代理到后端的上游服务器。这种部署方式由 Nginx 服务器负责 SSL 请求的运算，相对减轻了后端上游服务器的CPU 运算量。

生成自签名HTTPS证书

• 配置https签名证书

  # 1. 创建https证书存放目录
  cd /usr/local/nginx/conf/
  mkdir ssl
  
  # 2. 创建私钥
  openssl genrsa -des3 -out https.key 1024
  
  # 3. 创建签名请求证书
  openssl req -new -key https.key -out https.csr
  
  # 4. 在加载SSL支持的Nginx并使用上述私钥时除去必须的口令
  cp https.key https.key.org
  openssl rsa -in https.key.org -out https.key
  
  # 5. 最后标记证书使用上述私钥和CSR和有效期
  openssl x509 -req -days 365 -in https.csr -signkey https.key -out https.crt
  

• server配置

  server {
      listen 433 ssl;
      server_name localhost;
      
      # 证书部分
      ssl_certificate /usr/local/nginx/conf/ssl/https.crt; # rsa证书
      ssl_certificate_key /usr/local/nginx/conf/ssl/https.key; # rsa密钥
      
      # TLS 握手优化
      ssl_session_cache shared:SSL:1m; # 会话缓存的存储大小为1M
      ssl_session_timeout 5m; # 会话缓存的超时时间
      
      keepalive_timeout 75s;
      keepalive_requests 100;
      
      location / {
          root html;
          index index.html index.htm;   
      }    
  }
  

5. 文件服务器

归档一些数据或资料，那么文件服务器必不可少。使用Nginx可以非常快捷地搭建一个简易地 文件服务。

• 配置

  server {
      listen 8004;
      server_name localhost;
      
      # 正常显示中文，windows服务器中文目录无法下钻，目前无解
      charset gbk,utf-8;
      
      # 打开autoindex功能，以/结尾地请求，如http://localhost:8004/abc/test/
      autoindex on;
      
      # 显示文件的大小
      # on：以字节显示
      # off：人性化显示，文件过大会显示为MB或GB
      autoindex_exact_size off;
      
      # 以那种格式返回：html | xml | json | jsonp
      # 默认值：html
      autoindex_format html;
      
      # 显示时间格式
      # on：12-Aug-2024 11:32(当前时区)
      # off：12-Aug-2024 03:32(0时区，GMT)
      autoindex_localtime on;
      
      location / {
          root /data/files/; # 根目录
          # 如果a.html文件存在，则会返回a.html，否则才会返回 文件目录内容
          index a.html
      }
  }
  

6. 限速

限制响应速度

location /rate {
    # 定义响应数据的传输速度，默认bytes/s
    limit_rate 20;
    # 这些是Nginx处理请求时相关变量，加大返回数据量更好地看到限速效果
    return 200 '
       	request_time $request_time
    	request_id $request_id
        server_name $server_name
        request_filename $request_filename
        document_root $document_root
        realpath_root $realpath_root
    	request_completion $request_completion
   ';
}

7. 限流

limit_conn

• 用于限制客户端并发连接数
• 使用共享内存，对所有的worker子进程生效（需要保存客户端连接数）

limit_req

• 用于限制客户端处理请求的平均速率
• 使用共享内存，对所有的worker子进程生效
• 限流算法：leaky_bucket（漏桶）
  • 暂时拦截住上方水的向下流动，等待桶中的一部分水漏走后，再放行上方水
  • 溢出的上方水直接抛弃

http {
    include mime.types;
    default_type application/json;
    
    # limit_conn_zone key zone=name:size
    	# key: 用于定义客户端的唯一标识来限速，如remote_addr, binary_remote_addr
    		# binary_remote_addr 限制远程客户端IP，使用4个字节空间，高效;
    		# remote_addr 使用7-15个字节空间
    	# name: 任意名称，空间名，这里是limit_addr
    	# size: 共享内存大小空间，m为单位
        
    limit_conn_zone $binary_remote_addr zone=limit_addr:10m;
    
    # limit_req_zone key zone=name:size rate=rate;
    # 上下文: http
    # rate:表示允许相同标识的客户端的访问频次，12r/m的，每1分钟12次，即限制每5秒访问一次，每5秒才处理一个请求。
    limit_req_zone $binary_remote_addr zone=limit_req:15m rate=12r/m;
 
    server {
        listen 80;
        server_name localhost;
        
        location / {
            root html;
            index index.html index.htm;
            
            # 触发限速后，返回状态码，默认503
            # 上下文：http，server，location
            limit_conn_status 503;
            
            # 当触发限速后，错误日志出记录一条日志，这里用于定义日志等级
            # info | notice | warn | error
            # 上下文：http,server,location
            # 默认值：error
            limit_conn_1og_level warn;
            
            # limit_conn zone number;
            # zone：用limit_conn_zone中定义的zone名称
            # number：以zone为标识的客户端被允许的同时最大连接数
            # 【比如有3台主机进行请求，随机有一台会相应失败返回503】
            limit_conn limit_addr 2;
            
            # 定义响应数据的传输速度，bytes/s
            # 本指令属于ngx_http_core_module，不属于ngx_http_limit_conn_module
            # 【测试时写小点才能测出并发效果，实际可以写大点】
            limit rate 50;
            
            # limit_req_status code(http的状态码)
            # 默认值: 503
            # 上下攻: http，server，location
            limit_req_status 504;
            
            # 触发限速后，日志记录的等级
            # info | notice | warn | error
            # 默认值:error
            # 上下文:http，:server,location
            limit_req_log level notice;
            
            # limit_req zone=name [burst=number] [nodelay | delay=number];
            	# burst: 桶大小,设置一个大小为x的缓冲区,当有大量请求(爆发)过来时，超过了访问频次限制的请求可以先放到这个缓冲区内等待，但是这个等待区里的位置只有7个，超过的请求会直接报503（这里设置的504）的错误然后返回。
            	# nodelay: 如果设置，会在瞬时（一秒钟）提供处理(burst + rate)个（这里是7+1=8个）请求的能力，请求超过(burst + rate)的时候就会直接返回503，永远不存在请求需要等待的情况。
            # 上下文: http，server，location
            # 【该配置用于限制一个ip一个时间段内访问的次数，超过次数则页面错误】
            limit_req zone=limit_req burst=7 nodelay;
        }
    }
}    

8. 黑名单

access

• 限制特定IP或网段访问

• 规则从上到下

• allow

• deny

  server {
      listen 80;
      server_name localhost;
      
      location / {
          # allow address | CIDR | UNIX | all
          # 默认值
          # 上下文：http, server, location, limit_except
          # 允许该网段
          allow 192.168.0.1/24;
          
          # deny address | CIDR | UNIX | all
          # 默认值
          # 上下文：http, server, location, limit_except
          deny all;
      }
  }
  

• 示例

  1ocation / {    
      # 拒绝
      deny 192.168.1.1;
      
      # 放行192.168.1.0网段，子网掩码24位(255.255.255.0)，但是除了192.168.1.1
      allow 192.168.1.0/24;
      
      # 放行10.1.1.0网段，子网掩码16位(255.255.0.0)
      allow 10.1.1.0/16;
      
      # 放行ipv6
      a11ow 2001:0db8::/32;
      
      # 除了上面放行的，其他全部拒绝
      deny all;
  }
  

9. 请求拦截

auth_request

• 基于子请求收到的HTTP响应码做访问控

  如：拦截所有请求，先去做鉴权请求，通过后放行

  location /private {
      # 默认值:off
      # 上下文:http，server,location;
      # 鉴权成功对会返回后面实际内容，鉴权失败会返回鉴权服务的返回内容
      auth_request /auth;
      
      proxy_pass http://localhost:8000/user/info;
      
      proxy_intercept errors on;
      ...
  }
  location /auth {
      proxy_pass http://1ocalhost:8080/auth;
      
      proxy_pass_request_body off;
      proxy_set_header Content-Length "";
      proxy_set_header X-Original-URI $request_uri;
  }
  

10. 配置变量详解

全局配置main段

如下解释为核心参数（其他参数大部分情况下用不到）

# user USERNAME [GROUP]
# 解释: 指定运行nginx的worker子进程的属主和属组，其中属组可以不指定
user nginx;

# worker_processes NUMBER | auto
# 解释: 指定nginx启动的worker子进程数量
#【*auto:自动设置为物理CPU核心数】
worker_processes auto;

# pid DIR
# 解释: 指定运行nginx的master主进程的pid文件存放路径
pid /opt/nginx/logs/nginx.pid;

# worker_rlimit_nofile NUMBER
# 解释: 指定worker子进程可以打开的最大文件句柄数
# 【系统最大打开65535，每个子进程打开数乘子进程数，实际也不会超过65535】
# 这个值需要调大
worker_rlimit_nofile 20480;

# worker_rlimit_core SIZE
# 指定worker子进程异常终止后的core文件，用于记录分析问题
worker_rlimit_core 50M;
working_directory /opt/nginx/tmp; #【必须对子进程用户赋写权限】

# 解释:将每个worker子进程与CPU物理核心绑定
#【master负责调度，worker负责处理请求】
#【假设CPU有4个核心，某一时刻worker1获取到了CPU1的工作调度时间片，时间片过后worker1从CPU1上面撤下来，CPU1去处理其他事件，下一时刻可能是CPU2、CPU3的时间片调度到了worker1上面，那么worker1就会在其他CPU上面工作，进程与CPU的调度切换是有损耗的，worker1如果绑定了CPU1，worker1将永远等待CPU1的调度，充分利用CPU缓存】
#【主要作用:将每个worker子进程与特定CPU物理核心绑定，优势在于:避免同一个worker子进程在不同的CPU核心上切换，缓存失效，降低性能;其并不能真正避免进程切换(进程切换是CPU工作特性)】
# -- worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 0010000001000000 10000000:#8核心，8个worker
# -- worker_cpu affinity 01 10 01 10; # 2核心，4个worker
worker_cpu_affinity 0001 0010 0100 1000; # 4核心，4个worker
#【指定worker子进程的nice值，以调整运行nginx的优先级，通常设定为“负值”，以优先调用nginx】

#【Linux默认进程的优先级值是120，值越小越优先；nice设定范围为-20到+19】
#【对Linux来说，优先级值则是100到139】
worker_priority -20:
# 指定worker子进程优雅退出时的超时时间，不管5秒内是否处理完，都强制退出
worker_shutdown_timeout 5s;
# worker子进程内部使用的计时器精度，调整时间间隔越大，系统调用越少，有利于性能提升:反之，系统调用越多，性能下降
# 比如某些计时的操作，worker需要去获取内核时间，频繁跟内核打交道会降低性能
timer_resolution 100ms;
# daemon onl off
# 设定nginx的运行方式，前台还是后台，前台用户调试，后台用于生产
daemon on;

#负载均衡互斥锁文件存放路径
1ock_file logs/nginx.1ock;

11. events段

events {
    # Nginx使用何种事件驱动模型,一般不指定这个参数
    # use epoll;
    # worker子进程能够处理的最大并发连接数，多核情况最大其实达不到65535
    worker_connections 65535:
    # 是否打开负载均衡互斥锁，默认off(当master接收到请求时，会给每个worker发送消息去唤醒状态为on时，则会有一个负载均衡锁，master会轮流发给每一个)
    accept_mutex on;
    # 新连接分配给worker子进程的超时时间，默认500ms，超时后会转给下一个worker处理请求
    accept_mutex_delay 100ms;
    # worker子进程可以接收的新连接个数(这个参数对性能影响不太大)
    multi_accept on;
}

12. http段

• server段

  server {
      listen 80;
      server_name www.test.com;
      
      location /picture {
      	root /opt/nginx/html/picture;
          # 客户端请求 www.test.com/picture/1.jpg;
      	# 对应磁盘映射路径为:/opt/nginx/htm1/picture/picture/1.jpg
      }
      location /picture {
          alias /opt/nginx/html/picture/;
          # 客户端请求 www.test.com/picture/l.jpg;
          # 对应磁盘映射路径为:/opt/nginx/htm1/picture/1.jpg
          #【末尾一定要加/】
      }
  }
  

• server_name的匹配规则

  # 精确匹配，优先级最高，1
  server_name www.test.com;
  # 左通配，优先级2
  server_name *.test.com;
  # 右通配，优先级3
  server_name www.test.*:
  # 正则通配，优先级最低，4
  server_name ~^w.test..*$:
  # 多个
  server_name ww.test.com *.test.com ww.test.* ~^w.test\..*$;
  

• locaton段

  匹配规则	含义	示例	优先级（1最高）
  =	精确匹配	location = /pic/	1
  ^~	匹配到第一组字符停止搜索	location ^~ /pic/	2
  ~	正则匹配，区分大小写	location ~ .(Jpg|gif)#	3
  ~*	正则匹配，不区分大小写	location ~* .(Jpg|gif)$	4
  无符号		location /	5
  @	内部跳转	location @error_page

   #测试样例
  location ~ /test/8000/t/$ {
      return 200 'first regular expressions match!';
  }
  location ^~ /test/8000/t/ {
      return 200 'stop regular expressions match!';
  }
  location ~* /test/8000/t/(\w+)$ {
      return 200 "longest regular expressions match!';
  }
  location /test/8000/t/Test2 {
      return 200 longest prefix string match!';
  }
  location /test/8000/t {
      return 200 'prefix string match!';
  }
  location = /test/8000/t {
      return 200'exact match!';
  }
              
  location /test/auth {
      ...
      error_page 404 = @error_404;
  }
  location @error_404 {
      return 404 "404!";
  }
  

• root 与 alias的区别

  	root	alias
  语法	root path	alias path
  上下文	http, server, location, if	location
  区别	将定义路径与URI叠加	只取定义路径，末尾一定要加/

• location末尾带/的区别

  带/（location /test/）：将test作为目录，如果不存在则直接返回404

  不带/（location /test）：尝试把test作为目录，如果找不到则找test文件

13. 监控模块

location /status {
    # 监控模块
    stub_status;
}


# ------ 页面结果 ---------
Active connections: 2
server accepts handled requests 
 338 338 984
Reading: 0 Writing: 1 Waiting: 1

14. 内嵌变量

• rewrite指令&return指令
  • return
    • 停止处理请求，直接返回响应码或重定向到其他URL
    • 执行return指令后，location中后续指令将不会被执行
  • rerwrite
    • 根据指定正则表达式匹配规则，重写URL

location /{
	#上下文:server,location，if
    # return code [text];
    # text:响应体内容(如果code是200)
    # return 200"return 200 HTTP code";
    # return code URL;
    # URL: 重定向
    # return 302 /test;
    # return URL;
    # URL: 直接跟URL的话必须是http/https开头的完整路径
    # text: 响应体内容
    return http://localhost:8000/test;
}
location /test {
    index test.html;
}
    location /search {
    # rewrite regex replacement [flag
    # 上下文:server，location，if
    # flag:
    #	last: 重写后的ur1发起新请求，再次进入server段，重试1ocation中的匹配
    #	break: 直接使用重写后的ur1，不再匹配其他1ocation中的语句
    #  	redirect: 返回302临时重定向
    # 	permanent: 返回301永久重定向
    rewrite /(.*) https://www.baidu.com permanent;
}
location /test1 {
    # 继续匹配location，
    rewrite /images/(.*)/test2/$1 last;
    return 200 "return 200 in /test1";
}
location /test2 {
    #不会再匹配，直接找test3下面的文件
    rewrite /pics/(.*)/test3/$l break;
    return 200"return 200 in /test2";
}
location /test3 {
    # 请求:/test3/index.htm1，
    # 结果:直接返回"return 200jin /test3"，不会再去找index.htm]文件
    return 200"return 200 in /test3";
}
location /test4/ {
	if ( $remote_addr = “192.168.1.1") {
        return 200 "test if ok in URL /test4/";
	}
}
location /test5 {
    if( $uri ="/images/") {
        rewrite(.*)/test2/ break;
    }
	#执行了上面rewrite后，这里的return还会执行，通常不会联合一起写
    return 200 "test5 if failed\n"
}

Nginx变量分类

• TCP连接相关

  # 客户端地址，例如192.168.1.1
  remote_addr
  
  # 客户端端口，例如58473
  remote_port
  
  # 客户端地址的整型格式
  binary_remote_addr
  
  # 已处理连接，是一个递增的序号
  connection
  
  # 当前连接上执行的请求数，对于keepalive连接有意义
  connection_request
  
  # 如果使用proxy_protoco1协议，则返回原始用户的地址，否则为空
  proxy_protocol_addr
  
  # 如果使用proxy_protoco1协议，则返回原始用户的端口，否则为空
  proxy_protocol_port
  
  # 服务器地址，例如192.168.184.240
  server_addr
  
  # 服务器端口,例如80
  server_port
  
  # 服务端协议，例如HTTP/1.1
  server_protocol
  

  示例

  location /test/tcp {
      return 200 "
          remote_addr: $remote_addr
          remote_port: $remote_port
          binary_remote_addr: $binary_remote_addr
          connection: $connection
          connection_request: $connection_request
          proxy_protocol_addr: $proxy_protocol_addr
          proxy_protocol_port: $proxy_protocol_port
          server_addr: $server_addr
          server_port: $server_port
          server_protocol: $server_protocol
          time_local: $ time_local
          ";
  }
  

• HTTP请求相关变量

  # 请求包体头部长度
  conten_length
  
  # 请求包体类型
  content_type
  
  # URL中某个参数
  arg_参数名
  
  # 所有URL参数
  args
  
  # URL中有参数，返回?,否则返回空
  is_args
  
  # 与args完全相同
  query_string
  
  # 请求的URL，不包含参数
  uri
  
  # 请求的URL，包含参数
  request_uri
  
  # 协议名，http或者https
  scheme
  
  # 请求的方法，GET、HEAD、POST等
  request_method
  
  # 所有请求内容的大小，包含请求行，头部，请求体
  request_length
  
  # 由HTTP Basic Authentication协议传入的用户名
  remote_user
  
  # 客户端请求主体信息的临时文件名
  request_body_file
  
  # 包含请求的主要信息,在使用proxy_pass或fastcgi_pass指令的location中比较有意义
  request body
  
  # 先看请求行，再看请求头，最后找server_name
  host
  
  # 用户浏览器标识
  http_user_agent
  
  # 从哪些链接过来的请求
  http_referer
  # 经过一层代表服务器，添加对应代理服务器的信息
  http_via
  
  # 获取用户真实IP
  http_x_forwarded_for
  
  # 用户cookie
  http_cookie
  

• Nginx处理请求时相关变量

  # 请求处理到现在所耗费的时间，单位为秒，例如0.03代表30毫秒
  request_time
  
  # 请求处理完成，则返回OK，否则为空
  request_completion
  
  # 16进制显示的请求id，随机生成的
  request_id
  
  # 匹配上请求的server_name值
  server_name
  
  # 若开启https，则值为on,否则为空
  https
  
  # 待访问文件的完整路径
  request_filename
  
  # 由URI和root/alias规则生成的文件夹路径
  document_root
  
  # 将document_root中的软链接换成真实路径
  realpath_root
  
  # 返回响应时的速度上限值
  limit_rate
  

• Nginx返回响应时相关变量

  # 响应体中真实内容的大小
  body_bytes_sent
  
  # 全部响应体大小
  body_sent
  
  # HTTP返回状态码
  status
  

• 系统变量

  # nginx系统版本
  nginx_version
  
  # 服务时间
  time_local
  

HTTP状态码