Nginx基础

一、Nginx安装部署

docker安装

docker的nginx镜像： https://hub.docker.com/_/nginx

# docker安装nginx，本地新建nginx/conf/nginx.conf文件，文件参考下方第3小结-基础配置
$ docker run --name nginx -d -p 8070:80 -v ~/docker/nginx/html:/usr/share/nginx/html -v ~/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf nginx
# 默认编译参数
$ nginx -V
nginx version: nginx/1.21.6
built by gcc 10.2.1 20210110 (Debian 10.2.1-6)
built with OpenSSL 1.1.1k  25 Mar 2021 (running with OpenSSL 1.1.1n  15 Mar 2022)
TLS SNI support enabled
configure arguments: --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module

mac安装

$ brew install nginx
# 配置文件/opt/homebrew/etc/nginx/nginx.conf
# 静态资源/opt/homebrew/var/www
$ brew services start nginx
$ brew services stop nginx
$ nginx -v
$ nginx -s reload

linux编译安装

# rewrite模块，http模块的正则解析，需要pcre库
# gzip模块的压缩和解压缩，需要zlib库
# ssl功能需要openssl库
$ yum -y install gcc pcre pcre-devel zlib zlib-devel openssl openssl-devel

# 获取源码
$ cd usr/local/src/
$ wget http://nginx.org/download/nginx-1.16.1.tar.gz
$ tar -xvf nginx-1.16.1.tar.gz 
$ git clone https://github.com/arut/nginx-rtmp-module.git

#编译
$ ./configure --help #帮助
# 标准http模块默认编译到nginx中，除非使用--without-XXX参数。可选http模块默认不编译，除非使用--with-XXX参数。
$ ./configure --prefix=/usr/local/nginx
# 生成的nginx二进制文件在/objs目录

# 编译安装
$ make && make install

添加模块并重新编译

所属	模块名	作用	安装命令
官方	http_stub_status_module	nginx状态	–with-http_stub_status_module
官方	http_ssl_module	ssl	–with-http_ssl_module
官方	http_realip_module	真实ip	–with-http_realip_module
三方	nginx-rtmp-module	rtmp流媒体	–add-module=/usr/local/src/nginx-rtmp-module/

# 使用参数重新配置，更改安装位置，增加3个官方模块和一个三方模块
$ ./configure --prefix=/opt/nginx --with-http_stub_status_module \
--with-http_ssl_module --with-http_realip_module \
--add-module=/usr/local/src/nginx-rtmp-module/
# 重新编译安装
$ make && make install # 可以install，只会覆盖/sbin/nginx这个二进制文件，且之前的nginx会更名为nginx.old。当然也可以将/objs里的二进制copy过去

服务启停控制

$ ./nginx -h #查看命令帮助
$ ./nginx -t #测试配置文件
$ ./nginx -c /tmp/nginx.conf #指定conf文件启动
$ ./nginx -s reload|reopen|stop|quit #使用nginx -s signal 发送命令

# nginx查看
$ ps -ef|grep nginx
$ netstat -antp | grep 80 # 查看nginx端口
$ service iptables stop # 如果本地可以访问，外部无法，需要查看防火墙配置
$ nginx -V #可以查看原来编译时都带了哪些参数

平滑升级nginx版本

nginx支持的信号（不要使用kill -9）

信号	作用	是否支持worker进程
TERM(15),INT(2)	快速停止	支持
QUIT(3)	平缓停止	支持
HUP(1)	重载配置平滑重启，开新的worker进程，平滑关旧worker进程	不支持
USER1(10)	重新打日志文件	支持
USER2(12)	重新打开nginx二进制文件	不支持
WINCH(28)	平滑停止工作进程	支持

$ kill -TERM|INT|QUIT|HUP `cat /opt/nginx/logs/nginx.pid` #也可通过kill命令，kill SIGNAL PID. 
$ kill -l #kill命令支持的信号
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH

nginx平滑升级过程

# 调整参数重新编译，并替换sbin/nginx的二进制文件。最好备份下之前的nginx二进制文件。
$ ps -ef | grep nginx #初始进程
root     15975     1  0 19:36 ?        00:00:00 nginx: master process ./nginx
nobody   15976 15975  0 19:36 ?        00:00:00 nginx: worker process

$ kill -USR2 `cat /opt/nginx/logs/nginx.pid` #对旧的主进程15975发送USR2信号
$ ps -ef | grep nginx #使用新版本nginx启动了1个主进程和1个工作进程。目前新旧nginx同时处理请求
root     15975     1  0 19:36 ?        00:00:00 nginx: master process ./nginx
nobody   15976 15975  0 19:36 ?        00:00:00 nginx: worker process
root     16014 15975  0 19:41 ?        00:00:00 nginx: master process ./nginx
nobody   16015 16014  0 19:41 ?        00:00:00 nginx: worker process

$ cat nginx.pid #新的pid，该文件默认在/logs目录
16014
$ cat nginx.pid.oldbin #旧的pid
15975

$ kill -WINCH `cat /opt/nginx/logs/nginx.pid.oldbin` #对旧的主进程15975发送WINCH信号。目前2个主进程都转给新的工作进程。
$ ps -ef | grep nginx #旧的工作线程已停止
root     15975     1  0 19:36 ?        00:00:00 nginx: master process ./nginx
root     16014 15975  0 19:41 ?        00:00:00 nginx: master process ./nginx
nobody   16015 16014  0 19:41 ?        00:00:00 nginx: worker process

# 目前旧的主进程仍在监听，所以在这一步，如果一切正常时可以向旧的主进程发送QUIT信号，完成升级。如果不正常，支持回退。
# 选择1、完成升级
$ kill -QUIT `cat /opt/nginx/logs/nginx.pid.oldbin` #平缓停止旧的主进程
$ ps -ef | grep nginx #旧的主线程已停止
root     16014     1  0 19:41 ?        00:00:00 nginx: master process ./nginx
nobody   16015 16014  0 19:41 ?        00:00:00 nginx: worker process
$ cat nginx.pid #完成后，新的pid保持不变，nginx.pid.oldbin删除
16014

# 选择2、回退。方法1
$ kill -HUP `cat /opt/nginx/logs/nginx.pid.oldbin` #旧的主进程启动工作进程
$ kill -QUIT `cat /opt/nginx/logs/nginx.pid` #新的主进程平缓停止，回退完成

# 选择2、回退。方法2
$ kill -TERM `cat /opt/nginx/logs/nginx.pid` #新nginx立即停止，老的主进程会自动开启工作进程
$ cat nginx.pid #回退后，nginx.pid恢复，nginx.pid.oldbin删除
15975

二、Nginx架构

简介

• Nginx(engine x)是一个高性能的Web服务器和反向代理服务器，也是一个IMAP/POP3/SMTP服务器，由俄罗斯程序员Igor Sysoev于2002年开发。『Nginx官网』。
• Nginx常见的社区分支有：官方版本，Tengine（淘宝团队开发），Openresty（章宜春开发）。类似的服务器还有Caddy。
• Nginx源码是大约11万行的C代码，目录结构：Core-主干和基础设置，Event-事件驱动模型和不同的 IO 复用模块，HTTP-HTTP 服务器和模块，Mail-邮件代理服务器和模块，OS-操作系统相关的实现，Misc-杂项。
• Nginx的应用场景有，静态文件服务器、反向代理（区别于正向代理，如VPN或内网上网代理）、动静分离（静态资源和动态资源）、负载均衡（集群压力分摊）、安全防御、智能路由、流媒体服务等。

特点

Nginx特点有，高性能、高可靠性、高度模块化、高可扩展性、低内存消耗、热部署

• 高性能。它采用事件驱动，不使用传统的进程或线程服务器模型，能够非阻塞地处理10K乃至100K的海量连接。
• 高可靠性。内存池避免了常见的资源泄漏，独特的进程池机制则实现了自我监控和管理、快速恢复。
• 高度模块化。高内聚、低耦合，设计模式理论中的迪米特原则，支持分布式、支持应用拓展和升级。分为核心模块(ngx_core、ngx_conf、ngx_events、ngx_epoll、ngx_regex等)，标准http模块(ngx_http_core、ngx_http_charset)、可选http模块(ngx_http_zip、ngx_http_ssl)、邮件服务模块和第三方模块等五大类。
• 高可扩展性。支持第三方模块。

web请求处理机制，使用多进程和异步非阻塞方式。

• 1、多进程方式，服务器主进程生成子进程来交互，相对独立，但资源消耗大，导致性能下降，如早期的Apache服务器。
• 2、多线程方式，服务器主进程派生一个线程来交互，线程的开销远小于进程，减轻web服务器对系统资源的消耗。但多线程位于同一进程，可以访问同样的内存空间，相互影响，需要自己对内存进行管理，引起死锁同步等问题，可能还需定期重启服务器。
• 3、异步方式，网络通信中的同步和异步是描述通信模式的概念，发送方发送请求后需等待收到接收方响应后，才发送下一个请求。异步中所有请求形成一个队列，接收方处理完成后通知发送方。

有一个主进程和多个工作进程，所有工作进程都可用于接收和处理客户端请求。每个工作进程都使用异步非阻塞方式处理。那么，nginx工作进程调用IO后，就去进行其他工作了，当IO调用返回后，IO怎么把状态通知工作进程？有两种方式，一是工作进程主动检查，二是IO完成后主动通知。基于第二种方式，形成了事件驱动模型，放弃创建进程和线程方法，采用如下实现办法，“事件发送器”每传递过来一个请求，“目标对象”就将其放入一个待处理事件的列表，使用非阻塞I/O方式调用。select/poll/epoll等事件驱动处理库（即多路IO复用方法）就是来支持这种方案的。

select有1024链接数限制，非线程安全，事件描述符集合有3组需要分别轮询。poll去除链接数限制，非线程安全，可同时检查3组事件。epoll线程安全，是高效的。

nginx服务器架构

• 1、主进程（Master），配置文件、Socket管理、管理和监控工作进程、平滑升级重启等
• 2、工作进程（Worker），接收客户端请求、请求过滤处理、IO调用获取响应数据、与后端服务器通信、响应客户端请求，接收主进程指令。
• 3、Cache Loader和Cache Manager进程，缓存索引重建及管理。

进程交互，Master-Worker交互是单向管道，Worker-Worker相互隔离的，如需要交互，可从单向管道获取其他Worker信息。

配置文件重载原理：

1. 向 master 进程发送 HUP 信号（ reload 命令）。
2. master 进程检查配置语法是否正确。
3. master 进程打开监听端口。
4. master 进程使用新的配置文件启动新的 worker 子进程。
5. master 进程向老的 worker 子进程发送 QUIT 信号。
6. 老的 worker 进程关闭监听句柄，处理完当前连接后关闭进程。
7. 整个过程 Nginx 始终处于平稳运行中，实现了平滑升级，用户无感知。

nginx高可用

• keepalived
• LVS
• nginx集群

nginx高并发

1、linux内核

$ ulimit -n 20480 #系统打开文件描述符的最大值

# 以下参数添加到/etc/sysctl.conf文件
fs.file-max = 999999 #系统最大可打开的句柄数
net.core.netdev_max_backlog = 262144 #当每个网络接口接受数据包的速率比内核处理这些包的速率快时，允许发送队列的数据包的最大数目
net.core.somaxconn = 262144 #调节系统同时发起的TCP连接数，默认值为128
net.ipv4.tcp_max_orphans = 262144 #用于设定系统中最多允许存在多少TCP套接字不被关联到任何一个用户文件句柄上
net.ipv4.tcp_max_syn_backlog = 262144 #用于记录尚未收到客户端确认信息的连接请求的最大值，默认值为1024
net.ipv4.tcp_timestamps = 0 #用于设置时间戳，这个可以避免序列号的卷绕
net.ipv4.tcp_synack_retries = 1 #用于设置内核放弃TCP连接之前向客户端发送SYN+ACK包的数量
net.ipv4.tcp_syn_retries = 1 #设置内核放弃建立连接之前发送SYN包的数量
net.ipv4.tcp_tw_reuse = 1 #TCP连接立即回用。tcp_tw_recycle尽量不要配置

$ /sbin/sysctl -p #参数生效

2、nginx配置

worker_processes 4; #worker数，推荐等于cpu数
worker_cpu_affinity 0001 0010 0100 1000; #为每个进程分配CPU的工作内核
worker_rlimit_nofile 65535; #毎个进程的最大文件打开数
events {
    use epoll; #事件驱动类型
    worker_connections 65535; #设置一个进程理论允许的最大连接数，理论上越大越好，但不可以超过worker_rlimit_nofile
    accept_mutex off; #惊群处理
    multi_accept off;
}
http {
        sendfile on; #sendfile较传统readwrite少了多次copy
        tcp_nopush on; #数据包会累积一下再一起传输，提高传输效率
        tcp_nodelay on; #小的数据包不等待直接传输，nginx自动平衡tcp_nodelay和tcp_nopush
        keepalive_timeout 60 50;
        send_timeout 10s;
        types_hash_max_size 2048; #影响散列表的冲突率。值越大，就会消耗更多的内存，但散列key的冲突率会降低，检索速度就更快
        client_header_buffer_size 4k; #用于设置Nginx服务器允许的客户端请求头部的缓冲区大小

        gzip on; #对响应数据进行在线实时压缩,减少数据传输量
}

三、Nginx配置

基础

包含5个块：全局块、events块、http块、server块、location块

#运行worker进程的归属用户和组，其中组可以不指定
user  nobody nody;

#工作线程数，可使用ps -ef | grep nginx查看worker process，auto则与当前cpu物理核数数一致
worker_processes  auto;
#worker_rlimit_nofile 20480; # 指定worker进程可以打开的最大文件句柄数
#worker_cpu_affinity 0001 0010 0100 1000; # 4个物理核心，4个worker子进程，绑定后避免同一个worker在不同cpu核心上切换
#daemon off; # 默认是on，后台运行模式。指定 Nginx 的运行方式，前台用于调试，后台用于生产。

#配置master进程的PID文件存放路径
pid        logs/nginx.pid; #系统默认位置

#events配置，用于服务器与用户的网络连接，包括单worker连接数、对请求的事件驱动模型处理、序列化等
events {
	#每一个worker进程同时开启的最大连接数
    worker_connections  1024;
    #默认为on，是否打开负载均衡互斥锁。用于设置网络连接的序列化，对nginx进程接收到的连接进行序列化，防止多个进程对连接的争抢（惊群问题）。
    #accept_mutex off;
    #默认为off，是否允许worker进程同时接收多个新到达的网络连接
    #multi_accept on;
    #事件驱动模型的选择，method可为select、poll、epoll等，不推荐配置，nginx根据系统自动选择，一般默认为epoll
    #use method;
    #debug_connection 192.168.1.1; #对特定ip的请求开启调试
}

#http配置
http {
	#引用types结构的映射表，包含浏览器能够识别的MIME类型和扩展名。
    include       /etc/nginx/mime.types;
    #默认文件类型
    default_type  application/octet-stream; 
    #charset utf-8; #默认编码

	#自定义日志服务，以下$开头的为常用变量，$http_xxx为请求header头的x_forwarded_for的值。
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
	
	#日志存放路径，main为log_format名称
    access_log  logs/access.log  main;
    #错误日志存放路径，参数可使用debug、warn、error等，需要用户有写权限。可以放在http、server和location块
    #error_log  logs/error.log  debug; #调试模式，需要nginx编译时添加参数--with-debug

    #sendfile        on;#默认为off，用于配置允许sendfile方式来高效传输文件，数据包会累积一下后再一起传输
    #tcp_nopush     on; #减少网络报文段的数量
    #tcp_nodelay     on; #禁用nagle算法，小数据包不需要等待直接传输，可以提高响应速度

    #client_max_body_size 8m; #客户端请求允许的最大值，超过了会返回413Request Entity Too Large
    #types_hash_max_size    2048; #影响散列表的冲突率，影响检索速度
    #types_hash_bucket_size 64;

	#配置连接超时时间，与用户建立会话后，nginx服务器可保持连接打开一段时间
    keepalive_timeout  65;
    #keepalive_timeout 120s 100s; #服务端超时120s，发送给客户端应答报文header为100s
    #单连接请求数上限，建立会话后，通过此连接发送请求的数量，默认为100
    #keepalive_requests 100;
	
	#是否使用gzip压缩
    gzip on; #开启gzip压缩输出
    gzip_min_length 1k; #允许压缩的页面的最小字节数,页面字节数从header的content-length中获取.默认是0,不管页面多大都进行压缩.建议设置成大于1k的字节数,小于1k可能会越压越大
    gzip_buffers 4 16k; #表示申请4个单位为16k的内存作为压缩结果流缓存,默认值是申请与原始数据大小相同的内存空间来存储gzip压缩结果
    gzip_comp_level 4; #压缩等级.1压缩比最小,处理速度快.9压缩比最大,比较消耗cpu资源
    gzip_types text/plain application/javascript text/css; #压缩类型,默认就已经包含text/html，不建议对图片和文件进行gzip
    gzip_vary on; #在响应消息头中添加 Vary：Accept-Encoding，使代理服务器识别是否启用gzip压缩
    gzip_proxied any;默认 off，nginx做为反向代理时启用，用于设置启用或禁用从代理服务器上收到相应内容gzip压缩
	 
	#子配置文件的引入，一般里面都是server块，一个http块中可以有多个server块
    include /opt/nginx/conf.d/*.conf;
}

/opt/nginx/conf.d/xxx.conf文件如下（只需要server块）：

#server块，虚拟主机相关参数
server {
	#可监听ip地址、端口和UNIX Domain Socket等，此处为端口
    listen       80;

    #指定虚拟主机域名
    #基于ip的虚拟主机配置，ifconfig命令可添加网卡的ip别名
    #server_name 172.17.0.2;
    server_name  www.iherr.cn; #精确匹配
    #server_name  *.iherr.cn; #左侧或右侧通配
    #正则表达式匹配
    #server_name ~^www\d+\.iherr\.cn$;
	
	#location用于配置匹配的uri，语法为location [= | ~ | ~* | ^~] uri { ... }，=为严格匹配，~为正则区分大小写，~*为正则不区分大小写。^~代表在这个字符串匹配后停止进行正则表达式的匹配。
    location / {
    	#用于配置请求静态资源的根目录，root可以在http、server、location块
        root   /opt/nginx/html;
        #设置网站默认首页
        index  index.html index.htm;
        deny 192.168.x.x; #禁止访问的ip地址
        allow all;#允许访问的ip地址
    }
    
    #指定静态资源目录位置，访问/image/1.png时，实际路径是/opt/nginx/html/image/1.png
    #root会将定义路径与URI叠加，alias则只取定义路径
    location /image {
        alias   /opt/nginx/html/image/; #末尾一定要加/，否则404报错。且只能位于location
        #root /opt/nginx/html; # root末尾加不加/是一样的，实际路径同样是/opt/nginx/static/image/1.png
    }

    location /redirect { 
        return 301 https://iherr.cn$request_uri; #301/303重定向
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    # HTTP的错误代码，5XX代表服务端错误，对应的访问页面
    error_page   500 502 503 504  /50x.html;
    # 重新配置50x.html的根目录
    location = /50x.html {
        root   html;
    }
    
    # .+为支持字符串捕获功能，可在alias里按顺序使用$1,$2等
    # location ~ ^/data/(.+\.(htm|html))$
    # {
    # 可更改location的URL
    #	alias /location/other/$1;
    # }
    
    #基于ip配置Nginx的访问权限，支持ip、CIDR和all。除ip外，还提供基于密码配置访问权限
    #location /herr {
    #	deny 192.168.1.1;
    #	allow 192.168.1.0/24;
    #	deny all;
    #}
}

内置变量

常用的nginx内置变量以$符号起始

变量名	含义
$remote_addr和$http_x_forwarded_for	远程客户端的IP地址，请求者IP
$remote_port	客户端端口
$server_protocol、$server_addr、$server_port	服务器协议、ip地址、端口
$server_name	虚拟主机名称
$uri	请求url，不包含参数
$request_uri	请求url，包含参数
$request	请求的URI和HTTP协议，这是整个PV日志记录中最有用的信息，记录服务器收到一个什么样的请求
$request_length	请求的长度，包含请求行、请求头和请求体
$request_time	整个请求的总时间
$request_method	请求方法
$request_length	请求的长度
$request_filename	磁盘文件系统待访问文件的完整路径
$args	全部参数字符串
$arg_xxx	特定参数值
$is_args	是否有参数，有返回?，否则返回空
$host	请求信息中的host
$status	记录请求返回的http状态码，比如成功是200
$uptream_status	upstream状态，比如成功是200
$upstream_addr	upstream的地址，即真正提供服务的主机地址
$upstream_response_time	请求过程中，upstream的响应时间
$body_bytes_sent	发送给客户端的文件主体内容的大小
$bytes_sent	发送给客户端的总大小，可以将日志每条记录中的这个值累加起来以粗略估计服务器吞吐量。
$http_user_agent	用户ua
$http_referer	http的referer字段
$http_via	经过一层代理服务器添加的信息
$http_cookie	用户cookie
$document_root	由URI和root、alias规则生成的文件夹路径

$request_time和$upstream_response_time等时间，经常用于日志打印，定义如下图

location相关

针对location的匹配，有以下几类：

• 精确匹配： location = /img
• 普通匹配（前缀匹配）： location /img/ 或 location ^~ /img/，两者的区别在于匹配优先级。另需要注意尽量后面加上/，如果只有/img，那么/img1也能匹配到
• 大小写敏感正则匹配：location ~ .(gif|jpg|png|jpeg)$
• 大小写不敏感正则匹配： location ~* .(gif|jpg|png|jpeg)$
• 任意匹配： /

匹配优先级： (=) > (^) > () >(~*) > (/path) >(/)

1. 匹配到全等匹配时，终止后续所有匹配，直接返回；
2. 步骤一未匹配上时，然后遍历所有的普通匹配，按照最长匹配原则找到最满足的匹配项，
   如果匹配项前面有^~符号，则终止后续正则匹配，采用该匹配项；反之则继续后续的正则匹配。
3. 步骤一二都未匹配上时，此时进行正则匹配，找到第一个满足的正则匹配项，直接返回，若都不满足，则返回步骤二中的最长匹配项。

#location普通匹配
location /img/ { #必须是/img/xx才能匹配到
    root  html;
}

location /img { #/img1也能匹配到
    root  html;
}

#return指令
#停止处理请求，直接返回响应码或重定向到其他 URL ；执行 return 指令后， location 中后续指令将不会被执行。
location / {
    return 404; # 直接返回状态码
}

location / {
    return 404 "pages not found"; # 返回状态码 + 一段文本
}

location / {
    return 302 /xxx ; # 返回状态码 + 重定向地址
}

location / {
    return https://www.baidu.com ; # 返回重定向地址
}

#rewrite指令，根据指定正则表达式匹配规则，重写URL。语法：rewrite 正则表达式 要替换的内容 [flag];
#flag 可选值的含义：
#1、last 重写后的URL发起新请求，再次进入server段，重试location的中的匹配
#2、break 直接使用重写后的URL，不再匹配其它location中语句
#3、redirect 返回302临时重定向
#4、permanent 返回301永久重定向
location /search {
    rewrite ^/(.*) https://www.baidu.com redirect; #302跳转到百度
}

location /images {
    rewrite /images/(.*) /img/$1; #当访问/images/1.png时，$1为1.png，重写url为/img/1.png，去html/img目录找到资源
}

#autoindex指令
location /list {
    root html;
    autoindex on; # 打开 autoindex，，可选参数有 on | off
    autoindex_exact_size on; # 修改为off，以KB、MB、GB显示文件大小，默认为on，以bytes显示出⽂件的确切⼤⼩
    autoindex_format html; # 以html的方式进行格式化，可选参数有 html | json | xml
    autoindex_localtime off; # 显示的⽂件时间为⽂件的服务器时间。默认为off，显示的⽂件时间为GMT时间
}

#if指令
# $variable 仅为变量时，值为空或以0开头字符串都会被当做 false 处理；
# = 或 != 相等或不等；
# ~ 正则匹配；
# !~ 非正则匹配；
# ~* 正则匹配，不区分大小写；
# -f 或 !-f 检测文件存在或不存在；
# -d 或 !-d 检测目录存在或不存在；
# -e 或 !-e 检测文件、目录、符号链接等存在或不存在；
# -x 或 !-x 检测文件可以执行或不可执行；
location / {
    if ( $uri = "/images/" ){
        rewrite (.*) /img/ break;
    }
    if (!-f $request_filename){
        return 400;
    }
}

反向代理

#upstream在http块里配置。用于定义上游服务器的相关信息
upstream proxy { 
    server 127.0.0.1:8000 weight=1;         #代理后端的ip，weight用于加权轮询的权重设置，默认为1
    #server 127.0.0.1:8001 weight=1 down;   #暂时不参与负载
    #server 127.0.0.1:8002 weight=1 backup; #备用服务器，其他非backup忙时才会请求
    #server 127.0.0.1:8003 max_fails=3 fail_timeout=30s max_conns=1000; #max_fails默认为1，超过最大次数剔除。fail_timeout默认值10s，定义剔除的时间。max_conns为上游服务器的最大并发连接数

    #健康检查，需使用nginx_upstream_check_module模块
    #http类型检查：interval调用间隔时间，成功rise次后存活，失败fall次后不存活
    check interval=3000 rise=1 fall=3 timeout=2000 type=http;
    #和上游服务器长连接数
    check_keepalive_requests 100;
    #检查调用接口
    check_http_send "HEAD /index.html HTTP/1.0\r\nConnection: keep-alive\r\n\r\n";
    #调用接口响应状态码为正常
    check_http_expect_alive http_2xx http_3xx;

    keepalive 8;                   #每个worker子进程与上游服务器空闲长连接的最大数量，官方推荐是大于server数的2倍。避免server大量TIME_WAIT
    #keepalive_requests 100;                #默认是100，单个长连接可以处理的最多HTTP请求个数，超过时连接会被关闭
    #keepalive_timeout 75s;                 #空闲长连接的最长保持时间

    zone cache_zone 10M;                         #zone可以设置共享内存空间的名字和大小
    #负载均衡策略，默认是轮询
    #hash $request_uri;                     #哈希负载均衡算法，例如指定request_uri变量为hash的key。同一个uri会一直分发到同一台服务器
    #ip_hash;                               #根据ip进行哈希的算法。当负载两台以上用ip来hash解决session的问题
    #least_conn;                            #最少连接数负载均衡算法，通过读取zone共享内存空间的数据，优先分配给压力较小的服务器
    #least_time;                            #最短响应时间负载均衡算法
    #random;                                #随机负载均衡算法
    #fair;                                  #必须安装三方插件upstream_fair模块，响应时间短的优先分配
    #url_hash;                              #必须安装nginx的hash软件包，按访问url的hash结果分配，同一个url定向到同一台服务器
}

server {
    listen 8000;
    server_name localhost;
    location /{
        root html8000;
        index index.html;
    }
}

server {
    listen 80;
    server_name  localhost;
    location / {
        proxy_http_version                 1.1;
        proxy_pass                         http://proxy; #proxy_pass用于配置代理服务器。这里proxy是上面的负载的名称，映射到代理服务器。必须以http或https开头，可以携带变量。
        proxy_redirect                     default; #当返回码是3xx重定向时，可以修改返回header的location或refresh字段

        # Proxy headers
        proxy_set_header Upgrade           $http_upgrade;
        proxy_set_header Connection        $connection_upgrade;
        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_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host  $host;
        proxy_set_header X-Forwarded-Port  $server_port;

        # Proxy timeouts
        proxy_connect_timeout              60s; #与上游服务器连接的超时时间，发起握手等候响应超时时间
        proxy_send_timeout                 60s; #发送给上游服务器的超时时间
        proxy_read_timeout                 61s; #接收上游服务器的超时时间
    }

    #反向代理的缓存配置
    location /cache {
        # URI中后缀为.txt的设置变量值为"no cache"
        if ($request_uri ~ \.(txt)$) {
            set $cache_name "no cache";
        }
        proxy_cache_bypass                 $http_upgrade;
        proxy_no_cache $cache_name; # 定义保存到缓存的条件。判断该变量有值则不进行缓存，如果没有值则进行缓存
        proxy_cache cache_zone; # 设置缓存的共享内存空间，在上方定义好cache_zone
        proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
        proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
        add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端。如MISS未命中，HIT命中等
    
        proxy_pass                         http://proxy/;
    }

    #proxy_pass的URL中是否带URI（比如/），会直接影响发往上游请求的URL。不带/不会修改用户url，直接透传给上游。带/会修改用户url，直接删除location后的uri。
    #情况1，proxy_pass末尾加/，不包含路径，访问http://localhost/test/a.html，会被代理到http://localhost:8000/a.html
    location /test {
        proxy_pass                         http://proxy/; 
    }

    #情况2，proxy_pass末尾加/，包含路径，访问http://localhost/test/a.html，会被代理到http://localhost:8000/a/a.html
    location /test {
        proxy_pass                         http://proxy/a/; 
    }


    #情况3，proxy_pass末尾不加/，不包含路径，访问http://localhost/test/a.html，会被代理到http://localhost:8000/test/a.html
    location /test {
        proxy_pass                         http://proxy; 
    }

    #情况4，proxy_pass末尾不加/，包含路径，访问http://localhost/test/a.html，会被代理到http://localhost:8000/aa.html
    location /test {
        proxy_pass                         http://proxy/a; 
    }

}

SSL配置

{
listen 80;
    server_name www.iherr.cn;
    return 301 https://$host$request_uri; #301强制跳转https
    #也可以用下方设置强制跳转https
    #location / {
    #    rewrite ^(.*)$ https://$host$1 permanent;
    #}
}

#https证书可以使用阿里云的免费证书，或者Let's Encrypt免费生成
server {
    listen 443 ssl;
    server_name www.iherr.cn; #绑定证书的域名
    ssl_certificate cert/www.iherr.cn.pem; #证书文件
    ssl_certificate_key cert/www.iherr.cn.key; #私钥文件，和证书的公钥配对使用
    ssl_session_timeout 10m; #会话超时时间
    #ssl_session_cache shared:SSL:10m; #配置session重用
    #ssl_session_tickets off;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4; #SSL/TLS 的算法
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;  #SSL/TLS的协议版本，主流版本是[TLSv1.2]
    ssl_prefer_server_ciphers on;
    location / {
        root html;
        index index.html index.htm;
    }
}

限流

• 漏桶流算法，Nginx的限流都是基于漏桶流算法。我们把水比作是请求，漏桶比作是系统处理能力极限，水先进入到漏桶里，漏桶里的水按一定速率流出，当流出的速率小于流入的速率时，由于漏桶容量有限，后续进入的水直接溢出（拒绝请求），以此实现限流。
• 令牌桶算法，可以理解成医院的挂号看病，只有拿到号以后才可以进行诊病。系统会维护一个令牌桶，以一个恒定的速度往桶里放入令牌，这时如果有请求进来想要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则该请求将被拒绝服务。令牌桶算法通过控制桶的容量、发放令牌的速率，来达到对请求的限制。

# 限流返回状态码设置
limit_req_status 429;
# 根据remote_addr限制，生成10M的名字为mylimit的内存区域，访问频次为每秒20次
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=20r/s;

location / {
    #执行限流，使用mylimit配置。burst代表缓冲区为10，排队超出部分会失败。nodelay代表超过访问频次且缓冲区满了会直接返回429
    limit_req zone=mylimit burst=10 nodelay;
    ...
}

静态资源配置

# vue配置
location ^~ /dist/{
    root /html;
    index index.html;
    #html不缓存，避免出现更新后白屏等情况
    if ($request_filename ~* .*\.(?:htm|html)$)
    {
        add_header Cache-Control "private, no-store, no-cache";
    }
    #css和js缓存7天
    if ($request_filename ~* .*\.(?:js|css)$)
    {
        add_header Cache-Control max-age=604800;
    }
    try_files $uri $uri/ /index.html; #修复vue的history模式刷新404问题
}

#index.html不缓存
location ~ /index.html$
{
    add_header Cache-Control "no-store, no-cache";
}

# favicon.ico
location = /favicon.ico {
    log_not_found off; #默认on，是否在error_log中记录not_found的错误
    access_log    off; #关闭日志
}

# 静态资源
location ~* \.(?:css|js|jpe?g|png|gif|ico|webp|tiff?|mp3|mp4|webm)$ { #(?:)表示非捕获分组
    expires    7d;   #缓存7天
    #expires    off; #缓存关闭
    access_log off;
}

TCP/UDP

#配置TCP/UDP相关功能，平行于http块
stream { 
    server {
        listen 53; #监听TCP 53端口
        ...
    }
    server {
        listen 520 udp; #监听UDP 520端口
        ...
    }
}

常用

#除了常用请求类型，限制其他类型，如OPTIONS等
if ($request_method !~ ^(GET|POST|PUT|HEAD|DELETE)$) {
    return '405'; #405代表对于请求所标识的资源，不允许使用请求行中所指定的方法
}

# 跨域option处理
if ($request_method = 'OPTIONS') {
    add_header Access-Control-Allow-Origin 'https://xxx.iherr.cn';
    add_header Access-Control-Allow-Methods 'GET, POST, OPTIONS';
    add_header Access-Control-Allow-Headers 'Content-Type';
    add_header Access-Control-Allow-Credentials true;
    return 204;
}

# php配置
location / {
    try_files $uri $uri/ /index.php?$query_string;
}

# php请求转到FastCGI server127.0.0.1:9000
location ~ \.php$ {
    fastcgi_split_path_info ^(.+\.php)(/.+)$;
    fastcgi_pass 127.0.0.1:9000; #php-cgi监听9000端口
    #fastcgi_pass unix:/var/run/php/php-fpm.sock; #也可使用sock调用php-fpm
    fastcgi_index index.php;
    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}

fastcgi_connect_timeout 600;
fastcgi_send_timeout 600;
fastcgi_read_timeout 300;

# 不允许IE浏览器访问，返回500
if ($http_user_agent ~ Trident) {
  return 500;
}

相关工具

『在线Nginx配置生成』，nginxconfig.io是github开源项目

四、Nginx的三方模块

RTMP流媒体

https://github.com/arut/nginx-rtmp-module

verynginx

https://github.com/alexazhou/VeryNginx/

ngx_http_geoip2

https://github.com/leev/ngx_http_geoip2_module.git，通过ip获取地理信息

echo-nginx-module，memc-nginx-module、rds-json-nginx-module，lua-nginx-module

agentzh的开源

ngx_http_accesskey_module

nginx防盗链

五、Nginx进阶

变量

Nginx 变量的值只有一种类型，那就是字符串。使用$来命名变量，使用标准ngx_rewrite模块的set配置指令来赋值，可使用$name或${name}来进行变量插值。

location /test1{
    #set为标准ngx_rewrite模块指令
    set $name herr;
    #echo指令，需要使用ngx_echo三方模块
    echo "name : ${name}1";
}

location /test2{
    echo "name : $name";
}

Nginx 变量的创建和赋值操作发生在全然不同的时间阶段。创建只能发生在 Nginx 配置加载的时候，而赋值操作则只会发生在请求实际处理的时候。这意味着不创建而直接使用变量会导致启动失败，同时也意味着我们无法在请求处理时动态地创建新的 Nginx 变量。

Nginx 变量一旦创建，其变量名的可见范围就是整个 Nginx 配置，甚至可以跨越不同虚拟主机的 server 配置块。Nginx 变量名的可见范围虽然是整个配置，但每个请求都有所有变量的独立副本。

按照上方的配置，请求结果如下：

$ curl 'http://localhost:8080/test2'
name : 

$ curl 'http://localhost:8080/test1'
name : herr1

$ curl 'http://localhost:8080/test2'
name : 

变量容器的生命期，也不是与 location 配置块绑定的，而是与当前正在处理的请求绑定的。一个请求在其处理过程中，即使经历多个不同的 location 配置块，它使用的还是同一套 Nginx 变量的副本。比如下面的“内部跳转”，访问/test3，还是会输出”a = [hello]”。

location /test3 {
    set $a hello;
    rewrite ^ /test4;
    #echo_exec /bar; #同上一句，使用第三方模块 ngx_echo 提供的 echo_exec 配置指令发起内部跳转
}

location /test4 {
    echo "a = [$a]";
}

nginx提供了大量的内建变量，用于获取关于请求或响应的各种信息。例如由 ngx_http_core 模块提供的内建变量 $uri和$request_uri。其中有个特别的$arg_XXX变量群。其中很多变量如$uri和$request_uri都是只读的，但是$args是可写的，意味着可以改变请求的参数值。

location /test5 {
    echo "uri = $uri"; # 请求的URI，可能和最初的值有不同，比如经过重定向之类的
    echo "request_uri = $request_uri"; # 请求的URI，带参数
    echo "remote_addr = $remote_addr"; # 客户端IP地址
    echo "remote_port = $remote_port"; # 客户端端口号
    echo "request_method = $request_method"; # 请求的方法，比如"GET"、"POST"等
    echo "http_cookie = $http_cookie"; # cookie 信息
    echo "args = $args"; # 请求中的参数
    echo "host = $host"; # 请求域名
    echo "arg_a = $arg_a"; # 请求的参数a
}

$ curl 'http://localhost:8090/test5?a=1
uri = /test5
request_uri = /test5?a=1
remote_addr = 127.0.0.1
remote_port = 17971
request_method = GET
http_cookie = 
args = a=1
host = localhost
arg_a = 1

可以修改内建变量的值。

location /test6 {
        set $orig_args $args;
        set $args "a=3";

        echo "original args: $orig_args";
        echo "args: $args";
    }

$ curl 'http://localhost:8080/test6'
original args: 
args: a=3

$ curl 'http://localhost:8080/test?a=0&b=1'
original args: a=0&b=1
args: a=3

使用了“取处理程序”，变量都会缓存结果。

# 标准 ngx_map 模块的 map 配置指令，映射规则：当 $args 的值等于 debug 的时候，$foo 变量的值就是 1，否则 $foo 的值就为 0.
map $args $foo {
    default     0;
    debug       1;
}

server {
    listen       80;
    location /test7 {
        set $orig_foo $foo;
        set $args debug;

        echo "original foo: $orig_foo";
        echo "foo: $foo";
    }
}

类似 ngx_map 模块，标准的 ngx_geo 等模块也一样使用了变量值的缓存机制。因为缓存的存在，变量 $foo 在第一次被读取时就被缓存了，只在请求生命期中的第一次读取中才被执行

$ curl 'http://localhost/test7'
original foo: 0
foo: 0

$ curl 'http://localhost/test7?debug'
original foo: 1
foo: 1

配置指令的执行顺序

Nginx 处理每一个用户请求时，都是按照若干个不同阶段（phase）依次处理的。Nginx 的请求处理阶段共有 11 个，按照执行顺序依次是 post-read、server-rewrite、find-config、rewrite、post-rewrite、preaccess、access、post-access、try-files、content 以及 log。

typedef enum {
    NGX_HTTP_POST_READ_PHASE = 0,   //读取请求头
 
    NGX_HTTP_SERVER_REWRITE_PHASE,   //执行rewrite
 
    NGX_HTTP_FIND_CONFIG_PHASE,  //根据uri替换location
    NGX_HTTP_REWRITE_PHASE,      //根据替换结果继续执行rewrite
    NGX_HTTP_POST_REWRITE_PHASE, //执行rewrite后处理
 
    NGX_HTTP_PREACCESS_PHASE,    //认证预处理，请求限制，连接限制
 
    NGX_HTTP_ACCESS_PHASE,       //认证处理
    NGX_HTTP_POST_ACCESS_PHASE,  //认证后处理，认证不通过，丢包
 
    NGX_HTTP_TRY_FILES_PHASE,    //尝试try标签
    NGX_HTTP_CONTENT_PHASE,      //内容处理
 
    NGX_HTTP_LOG_PHASE           //日志处理
} ngx_http_phases;

location /test6 {
    set $a 1;
    echo $a;

    set $a 2;
    echo $a;
}

## 运行结果
2
2

按照上例，会先在 rewrite 阶段执行完这里的两条 set 赋值语句，然后再在后面的 content 阶段依次执行那两条 echo 语句。分属两个不同处理阶段的配置指令之间是不能穿插着运行的。

主要关注以下几个阶段：

• rewrite阶段：Nginx 已经在 find-config 阶段完成了当前请求与 location 的配对，所以从 rewrite 阶段开始，location 配置块中的指令便可以产生作用。ngx_rewrite 模块中的几乎全部指令，如set。set_by_lua也属于该阶段。rewrite_by_lua运行在阶段末尾。
• access阶段：标准模块 ngx_access、第三方模块 ngx_auth_request 以及第三方模块 ngx_lua 的 access_by_lua 指令就运行在这个阶段。
• content阶段：是所有请求处理阶段中最为重要的一个，因为运行在这个阶段的配置指令一般都肩负着生成“内容”（content）并输出 HTTP 响应的使命。echo、echo_exec、proxy_pass、echo_location等指令，以及 content_by_lua都是在该阶段运行。