玩转Nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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;
}

1
2
3
4
5
6
7
8
9
server {
		listen 80;
		server_name localhost;
		
		location / {
				root /opt/nginx/html;
				index index.html index.htm;
		}
}

1
2
3
4
5
6
7
8
server {
		listen 8088;
		server_name localhost;
		
		location / {
				proxy_pass https://www.baidu.com;
		}
}

1
2
3
4
5
6
7
stream{
		server {
				listen 3306;
				# 访问本机的3306，就被转发到了远程的3306
				proxy_pass 172.17.0.1:3306;
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
# 配置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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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;
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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;
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
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+rage）的时候就会直接返回503，永远不存在请求需要等待的情况
						# 上下文: http, server, location
						# limit_req zone=limit_req burst=7 nodelay;
						limit_req zone=limit_req;
				}
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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;
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# 核心参数
# user USERNAME [GROUP]
# 解释：指定运行nginx的workder子进程的属主和属组，其中属组可以不指定
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_apu_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;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 精确匹配，优先级最高，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\..*$;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 测试样例
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!';
}

1
2
3
4
5
6
7
8
9
10
location /status {
		#监控模块
		stub_status;
}

# 页面结果
Active connections: 2
server accepts handled requests
	16 16 26
Reading: 0 Writing: 1 Waiting: 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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 last;
		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";
}

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

1
# 请求包体头部长度content_length# 请求包体类型content_type # URL中某个参数arg_参数名# 所有URL参数args# URL中有参数，则返回？；否则返回空is_args# 与args完全相同query_string# 请求的URL，不包含参数uri# 请求的URL，包含参数request_uri# 协议名，http或者httpsscheme# 请求的方法，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# 获取用户真实IPhttp_x_forwarded_for# 用户cookiehttp_cookie

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

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

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