server {
    # 1: 基于多ip的虚拟主机：listen监听不同网卡的ip，端口可相同
    listen 8000;
    server_name 172.17.1.1;
    
    listen 8000;
    server_name 172.17.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;
}

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

server {
    listen       8088;
    server_name  localhost;

    location / {
        proxy_pass   https://www.baidu.com;
    }
}

stream {
    server {
        listen 3306;
        # 访问本机的3306，就被转发到了远程的3306
        proxy_pass 172.17.0.1:3306;
    }
}

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

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

upstream backend {
    hash $request_uri;
    server 192.168.1.1:8080;
    server 192.168.1.2:8080;
    server 192.168.1.3:8080; 
}

upstream backend {
    ip_hash;
    server 192.168.1.1:8080;
    server 192.168.1.2:8080;
    server 192.168.1.3:8080; 
}

upstream backend {
    least_conn;
    server 192.168.1.1:8080;
    server 192.168.1.2:8080;
    server 192.168.1.3:8080; 
}

upstream backend {
    zone upstream_backend 64k;
    
    server 127.0.0.1:8080 weight=2 max_conns=1000 fail_timeout=10s max_fails=5;
    server test.nginx.com weight=1;
    
    keepalive 16;
    keepalive_requests 100;
    keepalive_timeout 30s;
}

server {
    location /test {
        proxy_pass http://backend/test;
        # 如果不配置proxy_next_upstream，当遇到上游返回http错误状态码时，nginx会直接返回给客户端
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504 http_403 http_404 http_429; 
    }
}

server {
    listen       443 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 握手优化
    # 会话缓存的存储大小为1MB
    ssl_session_cache    shared:SSL:1m;
    # 会话缓存的超时时间为5分钟
    ssl_session_timeout  5m;
    keepalive_timeout    75s;
    keepalive_requests   100;
    location / {
        root   html;
        index  index.html index.htm;
    }
}

server {
    listen 8004;
    server_name localhost;
    
    # 正常显示中文，windows服务器下中文目录无法下钻，目前无解
    charset gbk,utf-8;

    # 打开autoindex功能，以/结尾的请求
    autoindex on;
    
    # 显示文件的大小，
    # on：以字节显示
    # off：人性化显示，文件过大会显示为mb或gb
    autoindex_exact_size off;
    
    # 以哪种格式返回：html | xml | json | jsonp
    # 默认值：autoindex_format html
    autoindex_format html;
    
    # 显示时间格式
    # on: 12-Jul-2019 10:11（当前时区）
    # off: 12-Jul-2019 02:11(0时区，GMT)
    autoindex_localtime on;

    location / {
        root /data/files/;
        # 如果a.html文件存在，则会返回a.html内容，否则才会返回目录内容
        index a.html;
    } 
}

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
  ';
}

http {
    include       mime.types;
    default_type  application/json;
    
    # limit_conn_zone key zone=name:size
    # key：用于定义客户端的唯一标识来限速，如remote_addr
    # name：任意名称
    # size：共享内存大小空间，m为单位
    # binary_remote_addr 使用4个字节空间，高效;remote_addr 使用7-15个字节空间
    limit_conn_zone $binary_remote_addr zone=limit_addr:10m;
    
    # limit_req_zone key zone=name:size rate=rate;
    # 上下文：http
    # rate:表示允许相同标识的客户端的访问频次，12r/m的，即限制每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_log_level warn;
            
            # limit_conn zone number;
            # zone：用limit_conn_zone中定义的zone名称
            # number：以zone为标识的客户端被允许的同时最大连接数
            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的缓冲区,当有大量请求（爆发）过来时，超过了访问频次限制的请求可以先放到这个缓冲区内等待，但是这个等待区里的位置只有5个，超过的请求会直接报503的错误然后返回。
            # nodelay：如果设置，会在瞬时提供处理(burst + rate)个请求的能力，请求超过（burst + rate）的时候就会直接返回503，永远不存在请求需要等待的情况。
            # 上下文：http, server, location
            # limit_req zone=limit_req burst=7 nodelay;
            limit_req zone=limit_req;
        }
    }
}

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;  
    }
}

location / {
    # 规则从上到下
    
    # 拒绝
    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
    allow  2001:0db8::/32;
    
    # 除了上面放行的，其他全部拒绝
    deny   all;
}

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

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

# 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 00100000 01000000 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 on | off
# 设定nginx的运行方式，前台还是后台，前台用户调试，后台用于生产
daemon on;

# 负载均衡互斥锁文件存放路径
lock_file logs/nginx.lock;

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;
}

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

# 精确匹配，优先级最高，1
server_name www.test.com;

# 左通配，优先级2
server_name *.test.com;

# 右通配，优先级3
server_name www.test.*;

# 正则通配，优先级最低，4
server_name ~^w\.test\..*$;

# 多个
server_name www.test.com *.test.com www.test.* ~^w\.test\..*$;

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

location /status {
 # 监控模块
    stub_status;
}
# ------页面结果------
Active connections: 2 
server accepts handled requests
 16 16 26 
Reading: 0 Writing: 1 Waiting: 1 

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: 重写后的url发起新请求，再次进入server段，重试location中的匹配
    #     break: 直接使用重写后的url，不再匹配其他location中的语句
    #     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/$1 break;
    return 200 "return 200 in /test2";
}

location /test3 {
    # 请求：/test3/index.html,
    # 结果：直接返回"return 200 in /test3"，不会再去找index.html文件
    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";
}

#客户端地址，例如192.168.1.1
remote_addr

#客户端端口，例如58473
remote_port

#客户端地址的整型格式
binary_remote_addr

#已处理连接，是一个递增的序号
connection

#当前连接上执行的请求数，对于keepalive连接有意义
connection_request

#如果使用proxy_protocol协议，则返回原始用户的地址，否则为空
proxy_protocol_addr

#如果使用proxy_protocol协议，则返回原始用户的端口，否则为空
proxy_protocol_port

#服务器地址，例如192.168.184.240
server_addr

#服务器端口,例如80
server_port

#服务端协议，例如HTTP/1.1
server_protocol

#请求包体头部长度
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

#请求处理到现在所耗费的时间，单位为秒，例如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

#响应体中真实内容的大小 
body_bytes_sent

#全部响应体大小
body_sent

#HTTP返回状态码
status

#nginx系统版本
nginx_version

#服务器时间
time_local