1 Nginx性能优化方法

关注哔哩哔哩海量免费架构学习视频资源
(https://space.bilibili.com/526518958)

常见的http状态码可用参考表所示

目录[-]

nginx优化

#将nginx进程设置为普通用户，为了安全考虑
user nginx;
#当前启动的worker进程，官方建议是与系统核心数一致
worker_processes 2;
#方式一，就是自动分配绑定
worker_cpu_affinity auto;
#日志配置成warn
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
#针对 nginx 句柄的文件限制
worker_rlimit_nofile 35535;
#事件模型
events {
     
#使用epoll内核模型
user epoll;
#每一个进程可以处理多少个连接，如果是多核可以将连接数调高 worker_processes * 1024
worker_connections 10240;
}
http {
     
include /etc/nginx/mime.types;
default_type application/octet-stream;
charset utf-8; #设置字符集
#设置日志输出格式，根据自己的情况设置
log_format main '$http_user_agent' '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for" '
'"$args" "$request_uri"';
access_log /var/log/nginx/access.log main;
sendfile on; #对静态资源的处理比较有效
#tcp_nopush on; #如果做静态资源服务器可以打开
#tcp_nodeny on; #当nginx做动态的服务时可以选择打开
keepalive_timeout 65;
########
#Gzip module
gzip on; #文件压缩默认可以打开
gzip_disable "MSIE [1-6]\."; #对于有些浏览器不能识别压缩，需要过滤如ie6
gzip_http_version 1.1;
include /etc/nginx/conf.d/*.conf;
}

Nginx gzip压缩模块提供了压缩文件内容的功能，用户请求的内容在发送到用户客户端之前，Nginx服务器会根据一些具体的策略实施压缩，以节约网站出口带宽，同时加快数据传输效率，来提升用户访问体验。

server_tokens off;     隐藏版本号
worker_connections 4096;    每一个进程打开的最大连接数
worker_rlimit_nofile 10240;  每个进程打开的最大的文件数，受限于操作系统：

1、Nginx运行工作进程数量

而worker 进程数默认为 1 。单进程最大连接数为1024。如下图（打开Nginx目录下的/conf/nginx.conf 文档），现在我们来对这两个数值进行调优

nginx 进程数，建议按照cpu 数目来指定，一般为它的倍数 (如,2个四核的cpu计为8)。

Nginx运行工作进程个数一般设置CPU的核心或者核心数x2。如果不了解cpu的核数，可以top命令之后按1看出来，也可以查看/proc/cpuinfo文件 grep ^processor /proc/cpuinfo | wc -l。

[root@lx~]# vi/usr/local/nginx1.10/conf/nginx.conf
worker_processes 4;

[root@lx~]# /usr/local/nginx1.10/sbin/nginx-s reload
[root@lx~]# ps -aux | grep nginx |grep -v grep
root 9834 0.0 0.0 47556 1948 ?     Ss 22:36 0:00 nginx: master processnginxwww 10135 0.0 0.0 50088 2004 ?       S   22:58 0:00 nginx: worker processwww 10136 0.0 0.0 50088 2004 ?     
  S   22:58 0:00 nginx: worker processwww 10137 0.0 0.0 50088 2004 ?     
    S   22:58 0:00 nginx: worker processwww 10138 0.0 0.0 50088 2004 ?      
     S   22:58 0:00 nginx: worker process

2、Nginx运行CPU亲和力

比如4核配置：

worker_processes 4;worker_cpu_affinity 0001 0010 0100 1000

比如8核配置：

worker_processes 8;worker_cpu_affinity 00000001 00000010 00000100 0000100000010000 00100000 01000000 10000000;

worker_processes最多开启8个，8个以上性能提升不会再提升了，而且稳定性变得更低，所以8个进程够用了。
为每个进程分配cpu，上例中将8 个进程分配到8 个cpu，当然可以写多个，或者将一个进程分配到多个cpu。

3、Nginx最大打开文件数

优化 Nginx worker 进程打开的最大文件数

# worker 进程打开的最大文件数，可设置为优化后的 ulimit -HSn 的结果
worker_rlimit_nofile 65535;

这个指令是指当一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（ulimit -n）与nginx进程数相除，但是nginx分配请求并不是那么均匀，所以最好与ulimit -n的值保持一致。

注：文件资源限制的配置可以在/etc/security/limits.conf设置，针对root/user等各个用户或者*代表所有用户来设置。

*   soft nofile   65535*   hard nofile   65535

用户重新登录生效（ulimit -n）
查看linux系统文件描述符的方法：

[root@web001 ~]# sysctl -a | grep fs.file
fs.file-max = 789972
fs.file-nr = 510 0 789972

worker_connections 65535;

每个进程允许的最多连接数， 理论上每台nginx 服务器的最大连接数为worker_processes*worker_connections。
client_header_buffer_size 4k;

客户端请求头部的缓冲区大小，这个可以根据你的系统分页大小来设置，一般一个请求头的大小不会超过1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。

分页大小可以用命令getconf PAGESIZE 取得。

[root@web001 ~]# getconf PAGESIZE

4096

但也有client_header_buffer_size超过4k的情况，但是client_header_buffer_size该值必须设置为“系统分页大小”的整倍数。
open_file_cache max=65535 inactive=60s;
这个将为打开文件指定缓存，默认是没有启用的，max 指定缓存数量，建议和打开文件数一致，inactive 是指经过多长时间文件没被请求后删除缓存。
open_file_cache_valid 80s;
这个是指多长时间检查一次缓存的有效信息。
open_file_cache_min_uses 1;
open_file_cache 指令中的inactive 参数时间内文件的最少使用次数，如果超过这个数字，文件描述符一直是在缓存中打开的，如上例，如果有一个文件在inactive 时间内一次没被使用，它将被移除。

4、Nginx事件处理模型

events {
       use epoll;  worker_connections 65535;  multi_accept on;}

nginx采用epoll事件模型，处理效率高。

work_connections是单个worker进程允许客户端最大连接数，这个数值一般根据服务器性能和内存来制定，实际最大值就是worker进程数乘以work_connections。

实际我们填入一个65535，足够了，这些都算并发值，一个网站的并发达到这么大的数量，也算一个大站了！

multi_accept 告诉nginx收到一个新连接通知后接受尽可能多的连接，默认是on，设置为on后，多个worker按串行方式来处理连接，也就是一个连接只有一个worker被唤醒，其他的处于休眠状态，设置为off后，多个worker按并行方式来处理连接，也就是一个连接会唤醒所有的worker，直到连接分配完毕，没有取得连接的继续休眠。当你的服务器连接数不多时，开启这个参数会让负载有一定的降低，但是当服务器的吞吐量很大时，为了效率，可以关闭这个参数。

5、开启高效传输模式

http {
       include mime.types;  default_type application/octet-stream;  ……  sendfile on;  tcp_nopush on;  ……}

• Include mime.types ：媒体类型,include 只是一个在当前文件中包含另一个文件内容的指令。
• default_type application/octet-stream ：默认媒体类型足够。
• sendfile on：开启高效文件传输模式，sendfile指令指定nginx是否调用sendfile函数来输出文件，对于普通应用设为 on，如果用来进行下载等应用磁盘IO重负载应用，可设置为off，以平衡磁盘与网络I/O处理速度，降低系统的负载。注意：如果图片显示不正常把这个改成off。
• tcp_nopush on：必须在sendfile开启模式才有效，防止网路阻塞，积极的减少网络报文段的数量（将响应头和正文的开始部分一起发送，而不一个接一个的发送。）

6、连接超时时间

主要目的是保护服务器资源，CPU，内存，控制连接数，因为建立连接也是需要消耗资源的。

keepalive_timeout 60;                  #keepalive 超时时间。
tcp_nodelay on;client_header_buffer_size 4k;
open_file_cache max=102400 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 1;
client_header_timeout 15;
client_body_timeout 15;
reset_timedout_connection on;
send_timeout 15;
server_tokens off;
client_max_body_size 10m;

或者

http {
     
 include mime.types;
 server_names_hash_bucket_size 512; 
 
 default_type application/octet-stream;
 sendfile on;
 tcp_nodelay on;
 
 keepalive_timeout 65;
 client_header_timeout 15;
 client_body_timeout 15;
 send_timeout 25;
 
 include vhosts/*.conf;
}

• keepalived_timeout ：客户端连接保持会话超时时间，超过这个时间，服务器断开这个链接。
• tcp_nodelay：也是防止网络阻塞，不过要包涵在keepalived参数才有效。
• client_header_buffer_size 4k：客户端请求头部的缓冲区大小，这个可以根据你的系统分页大小来设置，一般一个请求头的大小不会超过 1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。分页大小可以用命令getconf PAGESIZE取得。
• open_file_cache max=102400 inactive=20s ：这个将为打开文件指定缓存，默认是没有启用的，max指定缓存数量，建议和打开文件数一致，inactive 是指经过多长时间文件没被请求后删除缓存。
• open_file_cache_valid 30s：这个是指多长时间检查一次缓存的有效信息。
• open_file_cache_min_uses 1 ：open_file_cache指令中的inactive 参数时间内文件的最少使用次数，如果超过这个数字，文件描述符一直是在缓存中打开的，如上例，如果有一个文件在inactive 时间内一次没被使用，它将被移除。
• client_header_timeout ：设置请求头的超时时间。我们也可以把这个设置低些，如果超过这个时间没有发送任何数据，nginx将返回request time out的错误。
• client_body_timeout设置请求体的超时时间。我们也可以把这个设置低些，超过这个时间没有发送任何数据，和上面一样的错误提示。
• reset_timeout_connection ：告诉nginx关闭不响应的客户端连接。这将会释放那个客户端所占有的内存空间。
• send_timeout ：响应客户端超时时间，这个超时时间仅限于两个活动之间的时间，如果超过这个时间，客户端没有任何活动，nginx关闭连接。
• server_tokens ：并不会让nginx执行的速度更快，但它可以关闭在错误页面中的nginx版本数字，这样对于安全性是有好处的。
• client_max_body_size：上传文件大小限制。

7、fastcgi 调优

当 LNMP 组合工作时，用户通过浏览器输入域名请求 Nginx Web 服务：

如果请求的是静态资源，则由 Nginx 解析后直接返回给用户；
如果是动态请求（如 PHP），那么 Nginx 就会把它通过 FastCGI 接口发送给 PHP 引擎服务（即 php-fpm）进行解析，如果这个动态请求要读取数据库数据，那么 PHP 就会继续请求 MySQL 数据库，以读取需要的数据，并最终通过 Nginx 服务把获取的数据返回给用户。
这就是 LNMP 环境的基本请求流程。

在 Linux 中，FastCGI 接口即为 socket ，这个 socket 可以是文件 socket，也可以是 IP socket。

简化配置

fastcgi_connect_timeout 600;
fastcgi_send_timeout 600;
fastcgi_read_timeout 600;
fastcgi_buffer_size 64k;
fastcgi_buffers 4 64k;
fastcgi_busy_buffers_size 128k;
fastcgi_temp_file_write_size 128k;
fastcgi_temp_path/usr/local/nginx1.10/nginx_tmp;
fastcgi_intercept_errors on;
fastcgi_cache_path/usr/local/nginx1.10/fastcgi_cache levels=1:2 keys_zone=cache_fastcgi:128minactive=1d max_size=10g;

完整配置

http {
     
 include mime.types;
 default_type application/octet-stream;
 sendfile on;
 keepalive_timeout 65;
 fastcgi_connect_timeout 240; # Nginx服务器和后端FastCGI服务器连接的超时时间
 fastcgi_send_timeout 240; # Nginx允许FastCGI服务器返回数据的超时时间，即在规定时间内后端服务器必须传完所有的数据，否则Nginx将断开这个连接
 fastcgi_read_timeout 240; # Nginx从FastCGI服务器读取响应信息的超时时间，表示连接建立成功后，Nginx等待后端服务器的响应时间
 fastcgi_buffer_size 64k; # Nginx FastCGI 的缓冲区大小，用来读取从FastCGI服务器端收到的第一部分响应信息的缓冲区大小
 fastcgi_buffers 4 64k; # 设定用来读取从FastCGI服务器端收到的响应信息的缓冲区大小和缓冲区数量
 fastcgi_busy_buffers_size 128k; # 用于设置系统很忙时可以使用的 proxy_buffers 大小
 fastcgi_temp_file_write_size 128k; # FastCGI 临时文件的大小
# fastcti_temp_path /data/ngx_fcgi_tmp; # FastCGI 临时文件的存放路径
 fastcgi_cache_path /data/ngx_fcgi_cache levels=2:2 keys_zone=ngx_fcgi_cache:512m inactive=1d max_size=40g; # 缓存目录
 
 server {
     
 listen 80;
 server_name www.abc.com;
 location / {
     
 root html/www;
 index index.html index.htm;
 }
 location ~ .*.(php|php5)?$ {
     
 root html/www;
 fastcgi_pass 127.0.0.1:9000;
 fastcgi_index index.php;
 include fastcgi.conf;
 fastcgi_cache ngx_fcgi_cache; # 缓存FastCGI生成的内容，比如PHP生成的动态内容
 fastcgi_cache_valid 200 302 1h; # 指定http状态码的缓存时间，这里表示将200和302缓存1小时
 fastcgi_cache_valid 301 1d; # 指定http状态码的缓存时间，这里表示将301缓存1天
 fastcgi_cache_valid any 1m; # 指定http状态码的缓存时间，这里表示将其他状态码缓存1分钟
 fastcgi_cache_min_uses 1; # 设置请求几次之后响应被缓存，1表示一次即被缓存
 fastcgi_cache_use_stale error timeout invalid_header http_500; # 定义在哪些情况下使用过期缓存
 fastcgi_cache_key http://$host$request_uri; # 定义 fastcgi_cache 的 key
 }
 }
}

• fastcgi_connect_timeout 600 ：指定连接到后端FastCGI的超时时间
• fastcgi_send_timeout 600 ：向FastCGI传送请求的超时时间。
• fastcgi_read_timeout 600 ：指定接收FastCGI应答的超时时间。
• fastcgi_buffer_size 64k ：指定读取FastCGI应答第一部分需要用多大的缓冲区，默认的缓冲区大小为。fastcgi_buffers指令中的每块大小，可以将这个值设置更小。
• fastcgi_buffers 4 64k ：指定本地需要用多少和多大的缓冲区来缓冲FastCGI的应答请求，如果一个php脚本所产生的页面大小为256KB，那么会分配4个64KB的缓冲区来缓存，如果页面大小大于256KB，那么大于256KB的部分会缓存到fastcgi_temp_path指定的路径中，但是这并不是好方法，因为内存中的数据处理速度要快于磁盘。一般这个值应该为站点中php脚本所产生的页面大小的中间值，如果站点大部分脚本所产生的页面大小为256KB，那么可以把这个值设置为“8 32K”、“4 64k”等。
• fastcgi_busy_buffers_size 128k ：建议设置为fastcgi_buffers的两倍，繁忙时候的buffer。
• fastcgi_temp_file_write_size 128k ：在写入fastcgi_temp_path时将用多大的数据块，默认值是fastcgi_buffers的两倍，该数值设置小时若负载上来时可能报502BadGateway。
• fastcgi_temp_path ：缓存临时目录。
• fastcgi_intercept_errors on ：这个指令指定是否传递4xx和5xx错误信息到客户端，或者允许nginx使用error_page处理错误信息。注：静态文件不存在会返回404页面，但是php页面则返回空白页！
• fastcgi_cache_path /usr/local/nginx1.10/fastcgi_cachelevels=1:2
• keys_zone=cache_fastcgi:128minactive=1d max_size=10g ：fastcgi_cache缓存目录，可以设置目录层级，比如1:2会生成16*256个子目录，cache_fastcgi是这个缓存空间的名字，cache是用多少内存（这样热门的内容nginx直接放内存，提高访问速度），inactive表示默认失效时间，如果缓存数据在失效时间内没有被访问,将被删除，max_size表示最多用多少硬盘空间。
• fastcgi_cache cache_fastcgi ：#表示开启FastCGI缓存并为其指定一个名称。开启缓存非常有用，可以有效降低CPU的负载，并且防止502的错误放生。cache_fastcgi为proxy_cache_path指令创建的缓存区名称。
• fastcgi_cache_valid 200 302 1h ：#用来指定应答代码的缓存时间，实例中的值表示将200和302应答缓存一小时，要和fastcgi_cache配合使用。
• fastcgi_cache_valid 301 1d ：将301应答缓存一天。
• fastcgi_cache_valid any 1m ：将其他应答缓存为1分钟。
• fastcgi_cache_min_uses 1 ：该指令用于设置经过多少次请求的相同URL将被缓存。
• fastcgi_cache_key http://request_uri ：该指令用来设置web缓存的Key值,nginx根据Key值md5哈希存储.一般根据request_uri(请求的路径)等变量组合成proxy_cache_key 。
• fastcgi_pass ：指定FastCGI服务器监听端口与地址，可以是本机或者其它。
  总结：

nginx的缓存功能有：proxy_cache / fastcgi_cache

• proxy_cache的作用是缓存后端服务器的内容，可能是任何内容，包括静态的和动态。
• fastcgi_cache的作用是缓存fastcgi生成的内容，很多情况是php生成的动态的内容。
• proxy_cache缓存减少了nginx与后端通信的次数，节省了传输时间和后端宽带。
• fastcgi_cache缓存减少了nginx与php的通信的次数，更减轻了php和数据库(mysql)的压力。
  这就是 LNMP 环境的基本请求流程。

在 Linux 中，FastCGI 接口即为 socket ，这个 socket 可以是文件 socket，也可以是 IP socket。

fastcgi_cache_valid 200 302 1h;
fastcgi_cache_valid 301 1d;
fastcgi_cache_valid any 1m;

为指定的应答代码指定缓存时间，如上例中将200，302 应答缓存一小时，301 应答缓存1 天，其他为1 分钟。

fastcgi_cache_min_uses 1;

缓存在fastcgi_cache_path 指令inactive 参数值时间内的最少使用次数，如上例，如果在5 分钟内某文件1 次也没有被使用，那么这个文件将被移除。

fastcgi_cache_use_stale error timeout invalid_header http_500;

8、gzip 调优

Nginx gzip 压缩模块提供了压缩文件内容的功能，用户请求的内容在发送到客户端之前，Nginx 服务器会根据一些具体的策略实施压缩，以节约网站出口带宽，同时加快数据传输效率，来提升用户访问体验。

需要压缩的对象有 html 、js 、css 、xml 、shtml ，图片和视频尽量不要压缩，因为这些文件大多都是已经压缩过的，如果再压缩可能反而变大。

另外，压缩的对象必须大于 1KB，由于压缩算法的特殊原因，极小的文件压缩后可能反而变大。

使用gzip压缩功能，可能为我们节约带宽，加快传输速度，有更好的体验，也为我们节约成本，所以说这是一个重点。

Nginx启用压缩功能需要你来ngx_http_gzip_module模块，apache使用的是mod_deflate。

一般我们需要压缩的内容有：文本，js，html，css，对于图片，视频，flash什么的不压缩，同时也要注意，我们使用gzip的功能是需要消耗CPU的！

gzip on;
gzip_min_length 2k;
gzip_buffers   4 32k;
gzip_http_version 1.1;
gzip_comp_level 6;
gzip_typestext/plain text/css text/javascriptapplication/json application/javascript application/x-javascriptapplication/xml;
gzip_vary on;gzip_proxied any;
gzip on;   #开启压缩功能

http {
     
 gzip on; # 开启压缩功能
 gzip_min_length 1k; # 允许压缩的对象的最小字节
 gzip_buffers 4 32k; # 压缩缓冲区大小，表示申请4个单位为32k的内存作为压缩结果的缓存
 gzip_http_version 1.1; # 压缩版本，用于设置识别HTTP协议版本
 gzip_comp_level 9; # 压缩级别，1级压缩比最小但处理速度最快，9级压缩比最高但处理速度最慢
 gzip_types text/plain application/x-javascript text/css application/xml; # 允许压缩的媒体类型
 gzip_vary on; # 该选项可以让前端的缓存服务器缓存经过gzip压缩的页面，例如用代理服务器缓存经过Nginx压缩的数据
}

• gzip_min_length 1k
  ：设置允许压缩的页面最小字节数，页面字节数从header头的Content-Length中获取，默认值是0，不管页面多大都进行压缩，建议设置成大于1K，如果小与1K可能会越压越大。
• gzip_buffers 4 32k
  ：压缩缓冲区大小，表示申请4个单位为32K的内存作为压缩结果流缓存，默认值是申请与原始数据大小相同的内存空间来存储gzip压缩结果。
• gzip_http_version 1.1
  ：压缩版本，用于设置识别HTTP协议版本，默认是1.1，目前大部分浏览器已经支持GZIP解压，使用默认即可。
• gzip_comp_level 6
  ：压缩比例，用来指定GZIP压缩比，1压缩比最小，处理速度最快，9压缩比最大，传输速度快，但是处理慢，也比较消耗CPU资源。
• gzip_types text/css text/xml application/javascript
  ：用来指定压缩的类型，‘text/html’类型总是会被压缩。默认值: gzip_types text/html
  (默认不对js/css文件进行压缩)
• 压缩类型，匹配MIME型进行压缩；
• 不能用通配符 text/*；
• text/html默认已经压缩 (无论是否指定)；
• 设置哪压缩种文本文件可参考 conf/mime.types。
• gzip_vary on ：varyheader支持，改选项可以让前端的缓存服务器缓存经过GZIP压缩的页面，例如用Squid缓存经过nginx压缩的数据。

9、expires 缓存调优

Nginx expires 的功能就是给用户访问的静态内容设定一个过期时间。

当用户第一次访问这些内容时，会把这些内容存储在用户浏览器本地，这样用户第二次及以后继续访问该网站时，浏览器会检查加载已经缓存在用户浏览器本地的内容，就不会去服务器下载了，直到缓存的内容过期或被清除。

不希望被缓存的内容：广告图片、网站流量统计工具、更新很频繁的文件。

缓存期限参考：新浪缓存 15 天，京东缓存 25 年，淘宝缓存 10 年。

缓存，主要针对于图片，css，js等元素更改机会比较少的情况下使用，特别是图片，占用带宽大，我们完全可以设置图片在浏览器本地缓存365d，css，js，html可以缓存个10来天，这样用户第一次打开加载慢一点，第二次，就非常快了！缓存的时候，我们需要将需要缓存的拓展名列出来， Expires缓存配置在server字段里面。

location ~* \.(ico|jpe?g|gif|png|bmp|swf|flv)$ {
     expires 30d;#log_not_found off;access_log off;}
location ~* \.(js|css)$ {
     expires 7d;log_not_found off;access_log off;}

注：log_not_found off;是否在error_log中记录不存在的错误。默认是。

总结：

expire功能优点：

• expires可以降低网站购买的带宽，节约成本；
• 同时提升用户访问体验；
• 减轻服务的压力，节约服务器成本，是web服务非常重要的功能。

expire功能缺点：

• 被缓存的页面或数据更新了，用户看到的可能还是旧的内容，反而影响用户体验。

解决办法：第一个缩短缓存时间，例如：1天，但不彻底，除非更新频率大于1天；第二个对缓存的对象改名。

网站不希望被缓存的内容：

• 网站流量统计工具；
• 更新频繁的文件（google的logo）。
  完整配置文件

server {
     
 listen 80;
 server_name www.abc.com abc.com;
 root html/www;
 location ~ .*.(gif|jpg|jpeg|png|bmp|swf|js|css)$ # 缓存的对象
 {
     
 expires 3650d; # 缓存期限为 10 年
 }
}

10、防盗链

防盗链：简单地说，就是其它网站未经许可，通过在其自身网站程序里非法调用其他网站的资源，然后在自己的网站上显示这些调用的资源，使得被盗链的那一端消耗带宽资源 。

通过 HTTP referer 实现防盗链。

防止别人直接从你网站引用图片等链接，消耗了你的资源和网络流量，那么我们的解决办法由几种：

1、水印，品牌宣传，你的带宽，服务器足够；
2、 防火墙，直接控制，前提是你知道IP来源；
3、防盗链策略下面的方法是直接给予404的错误提示。

#第一种,匹配后缀
location ~ .*.(gif|jpg|jpeg|png|bm|swf|flv|rar|zip|gz|bz2)$ {
      # 指定需要使用防盗链的媒体资源
 access_log off; # 不记录日志
 expires 15d; # 设置缓存时间
 valid_referers none blocked *.test.com *.abc.com; # 表示仅允许这些域名访问上面的媒体资源
 if ($invalid_referer) {
      # 如果域名不是上面指定的地址就返回403
 return 403
 }
}
 
#第二种,绑定目录
location /images {
      
 root /web/www/img;
 vaild_referers none blocked *.spdir.com *.spdir.top;
 if ($invalid_referer) {
     
 return 403;
 }
}

location ~*^.+\.(jpg|gif|png|swf|flv|wma|wmv|asf|mp3|mmf|zip|rar)$ {
     valid_referers noneblocked www.benet.com benet.com;if($invalid_referer) {
       #return 302 http://www.benet.com/img/nolink.jpg;  return 404;  break;}access_log off;}

参数可以使如下形式：

• none ：意思是不存在的Referer头(表示空的，也就是直接访问，比如直接在浏览器打开一个图片)。
• blocked ：意为根据防火墙伪装Referer头，如：“Referer:XXXXXXX”。
• server_names ：为一个或多个服务器的列表，0.5.33版本以后可以在名称中使用“*”通配符。

11、内核参数优化

net.ipv4.tcp_max_tw_buckets = 6000

timewait 的数量，默认是180000。

net.ipv4.ip_local_port_range = 1024 65000

允许系统打开的端口范围。

net.ipv4.tcp_tw_recycle = 1

启用timewait 快速回收。

net.ipv4.tcp_tw_reuse = 1

开启重用。允许将TIME-WAIT sockets 重新用于新的TCP 连接。

net.ipv4.tcp_syncookies = 1

开启SYN Cookies，当出现SYN 等待队列溢出时，启用cookies 来处理。

net.core.somaxconn = 262144

web 应用中listen 函数的backlog 默认会给我们内核参数的net.core.somaxconn 限制到128，而nginx 定义的NGX_LISTEN_BACKLOG 默认为511，所以有必要调整这个值。

net.core.netdev_max_backlog = 262144

每个网络接口接收数据包的速率比内核处理这些包的速率快时，允许送到队列的数据包的最大数目。

net.ipv4.tcp_max_orphans = 262144

系统中最多有多少个TCP 套接字不被关联到任何一个用户文件句柄上。如果超过这个数字，孤儿连接将即刻被复位并打印出警告信息。这个限制仅仅是为了防止简单的DoS 攻击，不能过分依靠它或者人为地减小这个值，更应该增加这个值(如果增加了内存之后)。

net.ipv4.tcp_max_syn_backlog = 262144

记录的那些尚未收到客户端确认信息的连接请求的最大值。对于有128M 内存的系统而言，缺省值是1024，小内存的系统则是128。

net.ipv4.tcp_timestamps = 0

时间戳可以避免序列号的卷绕。一个1Gbps 的链路肯定会遇到以前用过的序列号。时间戳能够让内核接受这种“异常”的数据包。这里需要将其关掉。

net.ipv4.tcp_synack_retries = 1

为了打开对端的连接，内核需要发送一个SYN 并附带一个回应前面一个SYN 的ACK。也就是所谓三次握手中的第二次握手。这个设置决定了内核放弃连接之前发送SYN+ACK 包的数量。

net.ipv4.tcp_syn_retries = 1

在内核放弃建立连接之前发送SYN 包的数量。

net.ipv4.tcp_fin_timeout = 1

如 果套接字由本端要求关闭，这个参数决定了它保持在FIN-WAIT-2 状态的时间。对端可以出错并永远不关闭连接，甚至意外当机。缺省值是60 秒。2.2 内核的通常值是180 秒，3你可以按这个设置，但要记住的是，即使你的机器是一个轻载的WEB 服务器，也有因为大量的死套接字而内存溢出的风险，FIN- WAIT-2 的危险性比FIN-WAIT-1 要小，因为它最多只能吃掉1.5K 内存，但是它们的生存期长些。

net.ipv4.tcp_keepalive_time = 30

当keepalive 起用的时候，TCP 发送keepalive 消息的频度。缺省是2 小时。

• fs.file-max =
  999999：这个参数表示进程（比如一个worker进程）可以同时打开的最大句柄数，这个参数直线限制最大并发连接数，需根据实际情况配置。
• net.ipv4.tcp_max_tw_buckets = 6000
  ：这个参数表示操作系统允许TIME_WAIT套接字数量的最大值，如果超过这个数字，TIME_WAIT套接字将立刻被清除并打印警告信息。该参数默认为180000，过多的TIME_WAIT套接字会使Web服务器变慢。注：主动关闭连接的服务端会产生TIME_WAIT状态的连接
• net.ipv4.ip_local_port_range = 1024 65000 ：允许系统打开的端口范围。
• net.ipv4.tcp_tw_recycle = 1 ：启用timewait快速回收。
• net.ipv4.tcp_tw_reuse = 1 ：开启重用。允许将TIME-WAIT
  sockets重新用于新的TCP连接。这对于服务器来说很有意义，因为服务器上总会有大量TIME-WAIT状态的连接。
• net.ipv4.tcp_keepalive_time =
  30：这个参数表示当keepalive启用时，TCP发送keepalive消息的频度。默认是2小时，若将其设置的小一些，可以更快地清理无效的连接。
• net.ipv4.tcp_syncookies = 1 ：开启SYN
  Cookies，当出现SYN等待队列溢出时，启用cookies来处理。
• net.core.somaxconn = 40960 ：web 应用中 listen 函数的 backlog 默认会给我们内核参数的。
• net.core.somaxconn ：限制到128，而nginx定义的NGX_LISTEN_BACKLOG
  默认为511，所以有必要调整这个值。注：对于一个TCP连接，Server与Client需要通过三次握手来建立网络连接.当三次握手成功后,我们可以看到端口的状态由LISTEN转变为ESTABLISHED,接着这条链路上就可以开始传送数据了.每一个处于监听(Listen)状态的端口,都有自己的监听队列.监听队列的长度与如somaxconn参数和使用该端口的程序中listen()函数有关。somaxconn定义了系统中每一个端口最大的监听队列的长度,这是个全局的参数,默认值为128，对于一个经常处理新连接的高负载
  web服务环境来说，默认的 128 太小了。大多数环境这个值建议增加到 1024 或者更多。大的侦听队列对防止拒绝服务 DoS
  攻击也会有所帮助。
• net.core.netdev_max_backlog = 262144
  ：每个网络接口接收数据包的速率比内核处理这些包的速率快时，允许送到队列的数据包的最大数目。
• net.ipv4.tcp_max_syn_backlog = 262144
  ：这个参数标示TCP三次握手建立阶段接受SYN请求队列的最大长度，默认为1024，将其设置得大一些可以使出现Nginx繁忙来不及accept新连接的情况时，Linux不至于丢失客户端发起的连接请求。
• net.ipv4.tcp_rmem = 10240 87380 12582912
  ：这个参数定义了TCP接受缓存（用于TCP接受滑动窗口）的最小值、默认值、最大值。
• net.ipv4.tcp_wmem = 10240 87380
  12582912：这个参数定义了TCP发送缓存（用于TCP发送滑动窗口）的最小值、默认值、最大值。
• net.core.rmem_default = 6291456：这个参数表示内核套接字接受缓存区默认的大小。
• net.core.wmem_default = 6291456：这个参数表示内核套接字发送缓存区默认的大小。
• net.core.rmem_max = 12582912：这个参数表示内核套接字接受缓存区的最大大小。
• net.core.wmem_max = 12582912：这个参数表示内核套接字发送缓存区的最大大小。
• net.ipv4.tcp_syncookies = 1：该参数与性能无关，用于解决TCP的SYN攻击。

下面贴一个完整的内核优化设置：

fs.file-max = 999999
net.ipv4.ip_forward = 0
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.default.accept_source_route = 0
kernel.sysrq = 0
kernel.core_uses_pid = 1
net.ipv4.tcp_syncookies = 1
kernel.msgmnb = 65536
kernel.msgmax = 65536
kernel.shmmax = 68719476736
kernel.shmall = 4294967296
net.ipv4.tcp_max_tw_buckets = 6000
net.ipv4.tcp_sack = 1
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_rmem = 10240 87380 12582912
net.ipv4.tcp_wmem = 10240 87380 12582912
net.core.wmem_default = 8388608
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.core.netdev_max_backlog = 262144
net.core.somaxconn = 40960net.ipv4.tcp_max_orphans = 3276800
net.ipv4.tcp_max_syn_backlog = 262144
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_syn_retries = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_mem = 94500000 915000000 927000000
net.ipv4.tcp_fin_timeout = 1
net.ipv4.tcp_keepalive_time = 30
net.ipv4.ip_local_port_range = 1024 65000

执行sysctl -p使内核修改生效。

/sbin/sysctl -p

12、关于系统连接数的优化

linux 默认值 open files为1024。查看当前系统值：

# ulimit -n
1024

#ulimit Cu
1024

说明server只允许同时打开1024个文件。

使用ulimit -a 可以查看当前系统的所有限制值，使用ulimit -n 可以查看当前的最大打开文件数。

新装的linux 默认只有1024 ，当作负载较大的服务器时，很容易遇到error: too many open files。
解决方法：
使用 ulimit Cn 65535 可即时修改，但重启后就无效了。（注ulimit -SHn 65535 等效 ulimit -n 65535 ，-S 指soft ，-H 指hard)
需要将其改大。
有如下三种修改方式：

1、在/etc/rc.local 中增加一行 ulimit -SHn 65535

2、在/etc/profile 中增加一行 ulimit -SHn 65535

3、在/etc/security/limits.conf 最后增加：

*       soft    nofile         65535
*       hard    nofile         65535
*       soft    noproc         65535
*       hard    noproc         65535

具体使用哪种，在 CentOS 中使用第1 种方式无效果，使用第3 种方式有效果，而在Debian 中使用第2 种有效果

# ulimit -n
65535

# ulimit -u
65535

备注：ulimit 命令本身就有分软硬设置，加-H 就是硬，加-S 就是软默认显示的是软限制。

soft 限制指的是当前系统生效的设置值。hard 限制值可以被普通用户降低。但是不能增加。soft 限制不能设置的比 hard 限制更高。只有 root 用户才能够增加 hard 限制值。

13、配置默认主页

location / {
     
 index index.html index.htm index.php l.php;
 autoindex off;
}

14、配置反向代理

location / {
     
 proxy_pass http://localhost:8888;
 
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
}

15、调整最大连接数

控制 Nginx 单个进程允许的最大连接数的参数为 worker_connections ，这个参数要根据服务器性能和内存使用量来调整。

进程的最大连接数受 Linux 系统进程打开的最大文件数的限制，只有执行了 “ulimit -HSn 65535” 之后，worker_connections 才能生效。

连接数包括代理服务器的连接、客户端的连接等，Nginx 总并发连接数 = worker_processes * worker_connections。总数保持在 3w 左右即可。

worker_processes 2;
worker_cpu_affinity 01 10;
user nginx nginx;
events {
     
 use epoll;
 worker_connections 15000;
}

16、绑定 Nginx 进程到不同的 CPU 上

默认情况下，Nginx 的多个进程有可能跑在某一个 CPU 或 CPU 的某一核上，导致 Nginx 进程使用硬件的资源不均，因此绑定 Nginx 进程到不同的 CPU 上是为了充分利用硬件的多 CPU 多核资源。

[root@localhost ~]# grep -c processor /proc/cpuinfo # 查看CPU核数
2
worker_processes 2; # 2核CPU的配置
worker_cpu_affinity 01 10;
 
worker_processes 4; # 4核CPU的配置
worker_cpu_affinity 0001 0010 0100 1000; 
 
worker_processes 8; # 8核CPU的配置
worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 1000000;
 
[root@localhost ~]# /usr/local/nginx/sbin/nginx -t
[root@localhost ~]# /usr/local/nginx/sbin/nginx -s reload

17、限制上传文件的大小

client_max_body_size 用于设置最大的允许客户端请求主体的大小。

在请求头中有 "Content-Length" ，如果超过了此配置项，客户端会收到 413 错误，即请求的条目过大。

http {
     
 client_max_body_size 8m; # 设置客户端最大的请求主体大小为 8 M

}

18、操作系统优化

1、配置文件/etc/sysctl.conf，如下：

sysctl -w net.ipv4.tcp_syncookies=1 #防止一个套接字在有过多试图连接到达时引起过载
sysctl -w net.core.somaxconn=1024          #默认128，连接队列
sysctl -w net.ipv4.tcp_fin_timeout=10      #timewait的超时时间
sysctl -w net.ipv4.tcp_tw_reuse=1          #os直接使用timevait的连接
sysctl -w net.ipv4.tcp_tw_recycle=0        #回收禁用

2、配置文件/etc/security/limits.conf，如下：

hard nofile 204800
soft nofile 204800
soft core unlimited
soft stack 204800

或者
#针对root⽤户，soft仅提醒，hard限制，nofile打开最⼤⽂件数
# *代表所有⽤户
* soft nofile 25535
* hard nofile 25535
root soft nofile 65535
root hard nofile 65535
#针对Nginx进程
worker_rlimit_nofile 65535;

内核参数优化

[root@web01 ROOT]# vim /etc/sysctl.conf
net.ipv4.ip_local_port_range = 10240 61000 #调整系统能使⽤的端⼝数量
net.core.somaxconn = 1024 #默认128，连接队列
net.ipv4.tcp_fin_timeout = 10 #time_wait的超时时间
net.ipv4.tcp_tw_reuse = 1 #重新使⽤time_wait的连接
net.ipv4.tcp_timestamps = 1
[root@web01 ROOT]# sysctl -p

# NGINX优化

https://www.jianshu.com/p/0cac2af781b4

Nginx性能优化实践

1.性能优化概述
2.系统性能优化
3.代理服务优化
4.静态资源优化

• 4.1 静态资源缓存
• 4.2 静态资源读取
• 4.3 静态资源压缩
• 4.4 静态资源防盗链
• 4.5 静态资源防爬⾍
• 4.6 CPU亲和配置
  5.Nginx配置总结
  6.PHP服务优化
• 6.1 PHP配置⽂件
• 6.2 PHP监控模块
• 6.3 PHP⽇志管理
• 6.4 PHP最终配置

影响Nginx性能的⼀些指标
1.硬件层⾯需要了解: 磁盘损坏、磁盘速率。
1.⽹络层⾯需要了解: ⽹络带宽、⽹络是否丢包、因为这些都会影响http的请求与调⽤。
2.系统层⾯需要了解: 系统负载、系统内存，以及系统整体的稳定性。
3.服务层⾯需要了解: 连接与请求的限速，同时还需要根据业务形态做对应的服务设置。
4.程序层⾯需要了解: 接⼝性能、处理速度、程序执⾏效率。
5.数据层⾯需要了解: 数据库。

代理服务优化

通常Nginx作为代理服务，负责代理⽤户的请求，那么在代理的过程中建议开启HTTP⻓连接，⽤于减少握⼿次数，降低服务器损耗。

1.⻓连接语法示例,(应⽤层⾯优化)

Syntax: keepalive connections;
Default: —
Context: upstream
Syntax: keepalive_requests number; #keepalive_requests设置通过⼀个keepalive连
接提供的最⼤请求数。在发出最⼤请求数后，将关闭连接。
Default: keepalive_requests 100;
Context: upstream
Syntax: keepalive_timeout timeout; #keepalive_timeout超时，在此期间与代理服务器的
空闲keepalive连接将保持打开状态。
Default: keepalive_timeout 60s;
Context: upstream

2.配置Nginx代理服务使⽤⻓连接⽅式NGINX ⽀持 Keepalive ⻓连接

upstream http_backend {
     
 server 127.0.0.1:8080;
 server 127.0.0.1:8081;
 keepalive 32; #Nginx到应⽤服务器的连接池⾥⾯最⼤的空闲⻓连接数。也就是最
多有32个空闲的⻓连接
 keepalive_requests 100; #Nginx到应⽤应⽤服务器的⼀个⻓连接最多可承载处理的HTTP请求
个数，最多处理100个，到100个后⾃动关闭该连接，有需要Nginx会再⽣成新的⻓连接
 keepalive_time 60s; #keepalive_timeout超时，在60s时间内代理服务器的空闲
keepalive连接将保持打开状态
}
server {
     
 ...
 location /http/ {
     
 proxy_pass http://http_backend;
 proxy_http_version 1.1; #这⾥设置了proxy代理的协议，如果没有设置的化
默认是1.0。只有http1.1后才增加了⻓连接的⽀持。
 proxy_set_header Connection ""; #清除“connection”头字段，是清理从 Client
过来的 http header，因为即使是 Client 和 NGINX 之间是短连接，NGINX 和 upstream 之间也
是可以开启⻓连接的。这种情况下必须清理来⾃ Client 请求中的 “Connection” header。

 #proxy_params代理优化参数[此前已讲，不再复述]
 proxy_set_header Host $http_host;
 proxy_set_header X-Forwared-For $proxy_add_x_forwarded_for;
 proxy_connect_timeout 30s; # 代理连接web超时时间
 proxy_read_timeout 60s; # 代理等待web响应超时时间
 proxy_send_timeout 60s; # web回传数据⾄代理超时时间
 proxy_buffering on; # 开启代理缓冲区,web回传数据⾄缓冲区,代理边收边传返回
给客户端
 proxy_buffer_size 32k; # 代理接收web响应的头信息的缓冲区⼤⼩
 proxy_buffers 4 128k; # 缓冲代理接收单个⻓连接内包含的web响应的数量和⼤⼩

 #异常后的超时与重试机制
 proxy_next_upstream error timeout http_500 http_502 http_503 http_504; #
重试upstream中的下⼀台后端
 proxy_next_upstream_timeout 6s; #重试次数的总时间超出了6s
 proxy_next_upstream_tries 3; #重试3次(但因为之前已经请求1次了，所以还能重试2次)，
则表示重试失败
 }
}

对于fastcgi服务器，需要设置fastcgi_keep_conn以便保持⻓连接

upstream fastcgi_backend {
     
 server 127.0.0.1:9000;
 keepalive 16; #Nginx到应⽤服务器的连接池⾥⾯最⼤的空闲⻓连接数。也就是最多有16个空
闲的⻓连接
}
server {
     
 ...
 location /fastcgi/ {
     
 fastcgi_pass fastcgi_backend;
 fastcgi_keep_conn on; #开启保持⻓连接
 fastcgi_connect_timeout 600; #指定连接到后端FastCGI的超时时间
 fastcgi_send_timeout 600; #向FastCGI传送请求的超时时间
 fastcgi_read_timeout 600; #指定接收FastCGI应答的超时时间
 fastcgi_buffer_size 64k;
 fastcgi_buffers 4 64k;
 fastcgi_busy_buffers_size 128k;

 #异常后的超时与重试机制
 fastcgi_next_upstream error timeout http_500 http_502 http_503 http_504;
#重试upstream中的下⼀台后端
 fastcgi_next_upstream_timeout 6s; #重试次数的总时间超出了6s
 fastcgi_next_upstream_tries 3; #重试了3次(因为之前已经请求1次了，所以还能重试2 次)，则表示重试失败.
 }
}

CPU亲和配置

CPU亲和(affinity)减少进程之间不断频繁切换，减少性能损耗，其实现原理是将CPU核⼼和Nginx⼯作进程绑定⽅式，把每个worker进程固定对应的cpu上执⾏，减少切换cpu的cache miss，获得更好的性能。

1.查看当前CPU物理状态

[root@nginx ~]# lscpu |grep "CPU(s)"
CPU(s): 24
On-line CPU(s) list: 0-23
NUMA node0 CPU(s): 0,2,4,6,8,10,12,14,16,18,20,22
NUMA node1 CPU(s): 1,3,5,7,9,11,13,15,17,19,21,23
#本次演示服务器为两颗物理cpu，每颗物理CPU12个核⼼, 总共有24个核⼼

2.将Nginx worker进程绑⾄不同的核⼼上，官⽅建议与cpu的核⼼保持⼀致

# 第⼀种绑定组合⽅式
worker_processes 24;
worker_cpu_affinity 000000000001 000000000010 000000000100 000000001000
000000010000 000000100000 000001000000 000010000000 000100000000 001000000000
010000000000 10000000000;
# 第⼆种⽅式(使⽤较少)
worker_processes 2;
worker_cpu_affinity 101010101010 010101010101;
# 最佳⽅式绑定⽅式
worker_processes auto;
worker_cpu_affinity auto;

3.查看 nginx worker 进程绑定⾄对应 cpu

ps -eo pid,args,psr|grep [n]ginx

4.设置nginx worker进程的静态优先级，尽可能让nginx⼀直使⽤cpu

worker_priority number;
#默认值是0，可以设置为-20，减少cpu上下⽂切换的次数

Nginx配置总结

1.Nginx通⽤的主配置⽂件nginx.conf，包含静态资源优化

[root@nginx ~]# cat nginx.conf
user www;             # nginx进程启动⽤户
worker_processes auto;         #与cpu核⼼⼀致即可
worker_cpu_affinity auto;          # cpu亲和
error_log /var/log/nginx/error.log warn; #错误⽇志
pid /run/nginx.pid;
worker_rlimit_nofile 35535; #每个work能打开的⽂件描述符，调整⾄1w以上,负荷较⾼建议
2-3w
events {
     
 use epoll; # 使⽤epoll⾼效⽹络模型
 worker_connections 10240; # 限制每个worker进程能处理多少个连接，10240x[cpu核 ⼼] }
http {
     
 include mime.types;
 default_type application/octet-stream;
 charset utf-8; # 统⼀使⽤utf-8字符集
 # 定义⽇志格式
 log_format main '$remote_addr - $remote_user [$time_local] "$request" '
 '$status $body_bytes_sent "$http_referer" '
 '"$http_user_agent" "$http_x_forwarded_for"';

 access_log /var/log/nginx/access.log main; # 访问⽇志

 server_tokens off; # 禁⽌浏览器显示nginx版本号
 client_max_body_size 200m; # ⽂件上传⼤⼩限制调整

 # ⽂件⾼效传输，静态资源服务器建议打开
 sendfile on;
 tcp_nopush on;

 # ⽂件实时传输，动态资源服务建议打开,需要打开keepalived
 tcp_nodelay on;
 keepalive_timeout 65;

 # Gzip 压缩
 gzip on;
 gzip_complevel 2;
 gzip_disable "MSIE [1-6]\.";
 gzip_http_version 1.1;
 gzip_types .....;
 # 虚拟主机
 include /etc/nginx/conf.d/*.conf;
}

一个简单的nginx 配置文件：

user www www;
worker_processes 8;
worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000
01000000;
error_log /www/log/nginx_error.log crit;
pid /usr/local/nginx/nginx.pid;
worker_rlimit_nofile 204800;
events
{
     
use epoll;
worker_connections 204800;
}
http
{
     
include mime.types;
default_type application/octet-stream;
charset utf-8;
server_names_hash_bucket_size 128;
client_header_buffer_size 2k;
large_client_header_buffers 4 4k;
client_max_body_size 8m;
sendfile on;
tcp_nopush on;
keepalive_timeout 60;
fastcgi_cache_path /usr/local/nginx/fastcgi_cache levels=1:2
keys_zone=TEST:10m
inactive=5m;
fastcgi_connect_timeout 300;
fastcgi_send_timeout 300;
fastcgi_read_timeout 300;
fastcgi_buffer_size 4k;
fastcgi_buffers 8 4k;
fastcgi_busy_buffers_size 8k;
fastcgi_temp_file_write_size 8k;
fastcgi_cache TEST;
fastcgi_cache_valid 200 302 1h;
fastcgi_cache_valid 301 1d;
fastcgi_cache_valid any 1m;
fastcgi_cache_min_uses 1;
fastcgi_cache_use_stale error timeout invalid_header http_500;
open_file_cache max=204800 inactive=20s;
open_file_cache_min_uses 1;
open_file_cache_valid 30s;
tcp_nodelay on;
gzip on;
gzip_min_length 1k;
gzip_buffers 4 16k;
gzip_http_version 1.0;
gzip_comp_level 2;
gzip_types text/plain application/x-javascript text/css application/xml;
gzip_vary on;
server
{
     
listen 8080;
server_name backup.aiju.com;
index index.php index.htm;
root /www/html/;
location /status
{
     
stub_status on;
}
location ~ .*/.(php|php5)?$
{
     
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fcgi.conf;
}
location ~ .*/.(gif|jpg|jpeg|png|bmp|swf|js|css)$
{
     
expires 30d;
}
log_format access ‘$remote_addr — $remote_user [$time_local] “$request” ‘
‘$status $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” $http_x_forwarded_for’;
access_log /www/log/access.log access;
}
}

扩展

Nginx优化配置详解

基本参数优化

server_tokens off;
#关闭在错误页面中的nginx版本号，安全性是有好处的
sendfile on;
#传输文件时发挥作用
tcp_nopush on;
#一个数据包里发送所有头文件
tcp_nodelay on;
#不缓存数据
keepalive_timeout 10; 
#在这个超时时间过后关闭客户端链接
client_header_timeout 10; 
#设置请求头的超时时间
client_body_timeout 10;
#设置请求体的超时时间
reset_timeout_connection on;
#开启关闭不响应的客户端连接功能，释放客户端所占的内存空间
send_timeout 10;
#客户端的响应超时时间。如果在这段时间内，客户端没有读取任何数据，nginx就会关闭连接。
#limit_conn_zone 设置用于保存各种key（比如当前连接数）的共享内存的参数。5m就是5兆字节，这个值应该被设置的足够大以存储（32K5）32byte状态或者（16K5）64byte状态。
limit_conn
#为给定的key设置最大连接数。这里key是addr，我们设置的值是100，也就是说我们允许每一个IP地址最多同时打开有100个连接。
default_type
#设置文件使用的默认的MIME-type。
charset
#设置我们的头文件中的默认的字符集

Gzip压缩优化

gzip_types  
#压缩的文件类型
 text/plain text/css 
 application/json 
 application/x-javascript 
 text/xml application/xml 
 application/xml+rss 
 text/javascript
gzip on;
#采用gzip压缩的形式发送数据
gzip_disable "msie6"
#为指定的客户端禁用gzip功能
gzip_static;
#压缩前查找是否有预先gzip处理过的资源
gzip_proxied any;
#允许或者禁止压缩基于请求和响应的响应流
gzip_min_length  1000;
#设置对数据启用压缩的最少字节数
gzip_comp_level 6;
#设置数据的压缩等级

FastCGI参数优化

fastcgi_cache_path 
/data/ngx_fcgi_cache #缓存路径
levels=2:2 #目录结构等级
keys_zone=ngx_fcgi_cache:512m 
	   #关键字区域存储时间
inactive=1d #非活动删除时间	 
fastcgi_connect_timeout 240; 
#连接到后端fastcgi的超时时间
fastcgi_send_timeout 240; 
#建立连接后多久不传送数据就断开
fastcgi_read_timeout 240; 
#接收fastcgi应答的超时时间
fastcgi_buffer_size 64k; 
#指定读取fastcgi应答缓冲区大小
fastcgi_buffers 4 64k;
#指定本地缓冲区大小（缓冲FaseCGI应答请求）
fastcgi_busy_buffers_size 128k; 
#繁忙时的buffer，可以是fastcgi_buffer的两倍
fastcgi_temp_file_write_size  128k; 
#在写入缓存文件时用多大的数据块，默认是fastcgi_buffer的两倍
fastcgi_cache mingongge;
#开启缓存时指定一个名称
fastcgi_cache_valid 200 302 1h;
#指定应答码200 302 缓存一小时
fastcgi_cache_valid 301 1d; 
#指定应答码301缓存一天
fastcgi_cache_valid any 1m;
#指定其它应答码缓存一月

其它参数优化

open_file_cache
#指定缓存最大数目以及缓存的时间
open_file_cache_valid
#在open_file_cache中指定检测正确信息的间隔时间
open_file_cache_min_uses   
#定义了open_file_cache中指令参数不活动时间期间里最小的文件数
open_file_cache_errors     
#指定了当搜索一个文件时是否缓存错误信息
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
#指定缓存文件的类型
        {
     
        expires 3650d;    
           #指定缓存时间
        }
        location ~ .*\.(js|css)?$
        {
     
        expires 3d;                     
        }
expires有个缺点就是如果更新WEB数据后，用户没有清理缓存，会看到旧的数据，因此建议将时间设置短一点

优化后完整的配置文件

user www; 
pid /var/run/nginx.pid; 
worker_processes auto; 
worker_rlimit_nofile 100000; 
events {
      
worker_connections 2048; 
multi_accept on; 
use epoll; 
} 
http {
      
server_tokens off; 
sendfile on; 
tcp_nopush on; 
tcp_nodelay on; 
access_log off; 
error_log /var/log/nginx/error.log crit; 
keepalive_timeout 10; 
client_header_timeout 10; 
client_body_timeout 10; 
reset_timedout_connection on; 
send_timeout 10; 
limit_conn_zone $binary_remote_addr zone=addr:5m; 
limit_conn addr 100; 
include /etc/nginx/mime.types; 
default_type text/html; 
charset UTF-8; 
gzip on; 
gzip_disable "msie6"; 
gzip_proxied any; 
gzip_min_length 1000; 
gzip_comp_level 6; 
gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript; 
open_file_cache max=100000 inactive=20s; 
open_file_cache_valid 30s; 
open_file_cache_min_uses 2; 
open_file_cache_errors on; 
include /etc/nginx/conf.d/*.conf; 
include /etc/nginx/sites-enabled/*; 
}

Nginx踩坑总结

摘要: 显示乱码问题server { listen 80; server_name example.com; root /var/www/example; location / { charset utf-8; #一般是在个别的location中加入此项，具体情况具体对待 rewrite .* /index.html break; }}index显示列表（一般为企业内部使用）可在在location server 或 http段中加入autoindex on;// …

显示乱码问题

server {
     
 listen 80;
 server_name example.com;
 root /var/www/example;
 location / {
     
 charset utf-8; #一般是在个别的location中加入此项，具体情况具体对待
 rewrite .* /index.html break;
 }
}

index显示列表（一般为企业内部使用）
可在在location server 或 http段中加入

autoindex on;//自动显示目录
autoindex_exact_size off;//人性化方式显示文件大小否则以byte显示
autoindex_localtime on;//按服务器时间显示，否则以gmt时间显示

location用法

=：对URI做精确匹配；
tlocation = / {
tt...
t}
~：对URI做正则表达式模式匹配，区分字符大小写；
~*：对URI做正则表达式模式匹配，不区分字符大小写；
^~：对URI的左半部分做匹配检查，不区分字符大小写；
不带符号：匹配起始于此uri的所有的url；
location /lizi {
tt...
t}
t例如www.example.com/lizi/xxx/xxx
t只要是路径以/lizi开头的都匹配，这种一般用于最后的通用匹配。

注意：匹配优先级：=, ^~, ～/～，不带符号；*

具体匹配方式 http://seanlook.com/2015/05/17/nginx-location-rewrite/

常用优化配置

1.网络连接的优化：

只能在events模块设置，用于防止在同一一个时刻只有一个请求的情况下，出现多个睡眠进程会被唤醒但只能有一个进程可获得请求的尴尬，如果不优化，在多进程的nginx会影响以部分性能。

events {
accept_mutex on; #优化同一时刻只有一个请求而避免多个睡眠进程被唤醒的设置，on为防止被同时唤醒，默认为off，因此nginx刚安装完以后要进行适当的优化。
}

2.隐藏ngxin版本号：

当前使用的nginx可能会有未知的漏洞，如果被黑客使用将会造成无法估量的损失，但是我们可以将nginx的版本隐藏，如下：

server_tokens off; #在http 模块当中配置

3.选择事件驱动模型：

Nginx支持众多的事件驱动，比如select、poll、epoll，只能设置在events模块中设置：

events {
accept_mutex on;
multi_accept on;
use epoll; #使用epoll事件驱动，因为epoll的性能相比其他事件驱动要好很多
}

4.配置单个工作进程的最大连接数：

通过worker_connections number；进行设置，numebr为整数，number的值不能大于操作系统能打开的最大的文件句柄数，使用ulimit -n可以查看当前操作系统支持的最大文件句柄数，默认为为1024.

events {
 worker_connections 102400; #设置单个工作进程最大连接数102400
}

5.配置允许sendfile方式传输文件：

是由后端程序负责把源文件打包加密生成目标文件，然后程序读取目标文件返回给浏览器；这种做法有个致命的缺陷就是占用大量后端程序资源，如果遇到一些访客下载速度巨慢，就会造成大量资源被长期占用得不到释放（如后端程序占用的CPU/内存/进程等），很快后端程序就会因为没有资源可用而无法正常提供服务。通常表现就是 nginx报502错误，而sendfile打开后配合location可以实现有nginx检测文件使用存在，如果存在就有nginx直接提供静态文件的浏览服务，因此可以提升服务器性能.

 sendfile on; # 可以配置在http、server或者location模块，配置如下：
 sendfile_max_chunk 512k; #Nginxg工作进程每次调用sendfile()传输的数据最大不能超出这个值，默认值为0表示无限制，可以设置在http/server/location模块中。

6.会话保持时间：

用户和服务器建立连接后客户端分配keep-alive链接超时时间，服务器将在这个超时时间过后关闭链接，我们将它设置低些可以让ngnix持续工作的时间更长，1.8.1默认为65秒，一般不超过120秒。

 keepalive_timeout 65 60; #后面的60为发送给客户端应答报文头部中显示的超时时间设置为60s：如不设置客户端将不显示超时时间。
Keep-Alive:timeout=60 #浏览器收到的服务器返回的报文
如果设置为0表示关闭会话保持功能，将如下显示：
Connection:close #浏览器收到的服务器返回的报文

7.配置nginx worker进程最大打开文件数

worker_rlimit_nofile 65535;

8.配置nginx gzip压缩实现性能优化

图片、视频（流媒体）等文件尽量不要压缩，因为这些文件大多都是经过压缩的，如果再压缩很可能不会减小或减小很少，或者有可能增大，而在压缩时还会消耗大量的CPU、内存资源

gzip on; #表示开启压缩功能
gzip_min_length 1k; #表示允许压缩的页面最小字节数，页面字节数从header头的Content-Length中获取。默认值是0，表示不管页面多大都进行压缩，建议设置成大于1K。如果小于1K可能会越压越大
gzip_buffers 432k; #压缩缓存区大小
gzip_http_version 1.1; #压缩版本
gzip_comp_level 9; #压缩比率
gzip_types text/css text/xml application/javascript; #指定压缩的类型
gzip_vary on; #vary header支持

9.nginx expires功能

为用户访问网站的内容设定一个过期时间，当用户第一次访问到这些内容时，会把这些内容存储在用户浏览器本地，这样用户第二次及之后继续访问该网站，浏览器就会检查已经缓存在用户浏览器本地的内容，就不会去浏览器下载了，直到缓存的内容过期或者被清除为止。

## Add expires header according to URI(path or dir).
location ~ ^/(images|javascript|js|css|flash|media|static)/ {
 expires 360d;
}

常用正则（跟Linux上的正则没什么区别）

. ： 匹配除换行符以外的任意字符
? ： 重复0次或1次
+ ： 重复1次或更多次
* ： 重复0次或更多次
d ：匹配数字
^ ： 匹配字符串的开始
$ ： 匹配字符串的结束
{n} ： 重复n次
{n,} ： 重复n次或更多次
[c] ： 匹配单个字符c
[a-z] ： 匹配a-z小写字母的任意一个

类似分组（）：小括号()之间匹配的内容，可以在后面通过$1来引用，$2表示的是前面第二个()里的内容。正则里面容易让人困惑的是转义特殊字符。

rewrite实例

http {
 # 定义image日志格式
 log_format imagelog '[$time_local] ' $image_file ' ' $image_type ' ' $body_bytes_sent ' ' $status;
 # 开启重写日志
 rewrite_log on;
 server {
 root /home/www;
 location / {
 # 重写规则信息
 error_log logs/rewrite.log notice;
 # 注意这里要用‘’单引号引起来，避免{}
 rewrite '^/images/([a-z]{2})/([a-z0-9]{5})/(.*).(png|jpg|gif)$' /data?file=$3.$4;
 # 注意不能在上面这条规则后面加上“last”参数，否则下面的set指令不会执行
 set $image_file $3;
 set $image_type $4;
 }
 location /data {
 # 指定针对图片的日志格式，来分析图片类型和大小
 access_log logs/images.log mian;
 root /data/images;
 # 应用前面定义的变量。判断首先文件在不在，不在再判断目录在不在，如果还不在就跳转到最后一个url里
 try_files /$arg_file /image404.html;
 }
 location = /image404.html {
 # 图片不存在返回特定的信息
 return 404 "image not foundn";
 }
}

if语句块
例子是网上找的，if语句块长用在做单独的限制，如限制访问特定的资源，然后对此类请求做处理，rewire或者deny或者proxy_pass等等。

if ($http_user_agent ~ MSIE) {proxy_pass
 rewrite ^(.*)$ /msie/$1 break;
} //如果UA包含"MSIE"，rewrite请求到/msid/目录下
if ($http_cookie ~* "id=([^;]+)(?:;|$)") {
 set $id $1;
 } //如果cookie匹配正则，设置变量$id等于正则引用部分
if ($request_method = POST) {
 return 405;
} //如果提交方法为POST，则返回状态405（Method not allowed）。return不能返回301,302
if ($slow) {
 limit_rate 10k;
} //限速，$slow可以通过 set 指令设置
if (!-f $request_filename){
 break;
 proxy_pass http://127.0.0.1;
} //如果请求的文件名不存在，则反向代理到localhost 。这里的break也是停止rewrite检查
if ($args ~ post=140){
 rewrite ^ http://example.com/ permanent;
} //如果query string中包含"post=140"，永久重定向到example.com
location ~* .(gif|jpg|png|swf|flv)$ {
 valid_referers none blocked www.jefflei.com www.leizhenfang.com;
 if ($invalid_referer) {
 return 404;
 } //防盗链
}

https
定义一个新的server，配置如下，必须的配置有listen ,server_name, ssl ,ssl_certificate, ssl_certificate_key,一般配置的时候我都是直接复制，然后改主机名，证书私钥文件，日志路径，root的根目录这几项。

如果想让访问80的转到443，可用rewrite语句

listen 443;
server_name agent.t.jlhcar.com;
ssl on;
ssl_certificate, "/usr/local/certificate/agent.t.jlhcar.com.pem";证书
ssl_certificate_key "/usr/local/certificate/agent.t.jlhcar.com.key";私钥
ssl_session_cache shared:SSL:1m;
ssl_session_timeout 10m;
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
ssl_prefer_server_ciphers on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;协议
...
//日志以及root根目录的其他配置
server {
 listen 80;
 server_name agent.xxx.com;
 rewrite ^/(.*)$ https://agent.xxx.com/$1;
}

注意:曾经遇到过这么一个坑，http转https的时候会将POST转换为GET请求，此时需要这样配置

server {
 listen 80;
 server_name dev-payment.xxxx.cn;
 return 307 https://dev-payment.xxxx.cn$request_uri;
}

php后端处理(fastcgi)

location ~ .php($|/) {
 fastcgi_pass unix:/dev/shm/php-fpm.unix; //最重要的一项，根据实际情况来配置（根据php的配置文件listen的配置来配置,其值可以是一个域名、IP地址:端口、或者是一个Unix的Socket文件。
）
 fastcgi_index index.php; //当请求以/结尾的时候，会将请求传递给所设置的index.php文件处理。
 fastcgi_split_path_info ^(.+.php)(.*)$; //Nginx默认获取不到PATH_INFO的值，得通过fastcgi_split_path_info指定定义的正则表达式来给$fastcgi_path_info赋值。
 fastcgi_param PATH_INFO $fastcgi_path_info; //
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 include fastcgi.conf;
}

示例链接:https://segmentfault.com/q/1010000010786459

负载均衡和反向代理
在http配置段要配置一个upstream

upstream ucart{
 server 119.29.48.27:80;
 server 119.29.48.27:80;
}
注意：nginx中不识别_（下划线），否则会出现400错误

然后再server配置段，将所需要处理的请求反向代理至后端服务器，在可根据需要和服务器配置情况来定义权重，实现负载均衡

location /ucarapi/ {
 proxy_pass http://ucar_t/;
 proxy_connect_timeout 3; //连接超时时间
 proxy_read_timeout 30;
 proxy_set_header Host tapi.51ucar.cn; //HTTP头信息,后端服务器根据此来找到特定虚拟主机
 proxy_set_header X-Real-IP $remote_addr; //HTTP头信息，真实IP
 proxy_set_header X-Scheme $scheme;
}

10、Nginx针对非法user_agent拦截

https://www.jianshu.com/p/28d670fe698c

11、如何查看服务器状态信息（非常重要的功能）

1）编译安装时使用–with-http_stub_status_module开启状态页面模块

[root@proxy ~]# tar  -zxvf   nginx-1.12.2.tar.gz
[root@proxy ~]# cd  nginx-1.12.2
[root@proxy nginx-1.12.2]# ./configure   \
> --with-http_ssl_module                        //开启SSL加密功能
> --with-stream                                //开启TCP/UDP代理模块
> --with-http_stub_status_module                //开启status状态页面
[root@proxy nginx-1.12.2]# make && make install    //编译并安装

2）启用Nginx服务并查看监听端口状态

ss命令可以查看系统中启动的端口信息，该命令常用选项如下：

• -a显示所有端口的信息
• -n以数字格式显示端口号
• -t显示TCP连接的端口
• -u显示UDP连接的端口
• -l显示服务正在监听的端口信息，如httpd启动后，会一直监听80端口
• -p显示监听端口的服务名称是什么（也就是程序名称）
  注意：在RHEL7系统中可以使用ss命令替代netstat命令，功能一样，选项一样。

[root@proxy ~]# /usr/local/nginx/sbin/nginx
[root@proxy ~]# netstat  -anptu  |  grep nginx
tcp        0        0 0.0.0.0:80        0.0.0.0:*        LISTEN        10441/nginx
[root@proxy ~]# ss  -anptu  |  grep nginx

3）修改Nginx配置文件，定义状态页面

[root@proxy ~]# cat /usr/local/nginx/conf/nginx.conf
… …
location /status {
     
                stub_status on;
                 #allow IP地址;
                 #deny IP地址;
        }
… …
[root@proxy ~]# /usr/local/nginx/sbin/nginx -s reload

4）优化后，查看状态页面信息

[root@proxy ~]# curl  http://192.168.4.5/status
Active connections: 1 
server accepts handled requests
 10 10 3 
Reading: 0 Writing: 1 Waiting: 0

• Active connections：当前活动的连接数量。
• Accepts：已经接受客户端的连接总数量。
• Handled：已经处理客户端的连接总数量。（一般与accepts一致，除非服务器限制了连接数量）。
• Requests：客户端发送的请求数量。
• Reading：当前服务器正在读取客户端请求头的数量。
• Writing：当前服务器正在写响应信息的数量。
• Waiting：当前多少客户端在等待服务器的响应。

12、优化Nginx并发量

1）优化前使用ab高并发测试

[root@proxy ~]# ab -n 2000 -c 2000 http://192.168.4.5/
Benchmarking 192.168.4.5 (be patient)
socket: Too many open files (24)                //提示打开文件数量过多

2）修改Nginx配置文件，增加并发量

[root@proxy ~]# vim /usr/local/nginx/conf/nginx.conf
.. ..
worker_processes  2;                    //与CPU核心数量一致
events {
     
worker_connections 65535;        //每个worker最大并发连接数
}
.. ..
[root@proxy ~]# /usr/local/nginx/sbin/nginx -s reload

3）优化Linux内核参数（最大文件数量）

[root@proxy ~]# ulimit -a                        //查看所有属性值
[root@proxy ~]# ulimit -Hn 100000                //设置硬限制（临时规则）
[root@proxy ~]# ulimit -Sn 100000                //设置软限制（临时规则）
[root@proxy ~]# vim /etc/security/limits.conf
    .. ..
*               soft    nofile            100000
*               hard    nofile            100000

#该配置文件分4列，分别如下：
#用户或组    硬限制或软限制    需要限制的项目   限制的值

4）优化后测试服务器并发量（因为客户端没调内核参数，所以在proxy测试）

[root@proxy ~]# ab -n 2000 -c 2000 http://192.168.4.5/

13、优化Nginx数据包头缓存

1）优化前，使用脚本测试长头部请求是否能获得响应

[root@proxy ~]# cat lnmp_soft/buffer.sh 
#!/bin/bash
URL=http://192.168.4.5/index.html?
for i in {
     1..5000}
do
    URL=${
     URL}v$i=$i
done
curl $URL                                //经过5000次循环后，生成一个长的URL地址栏
[root@proxy ~]# ./buffer.sh
.. ..
<center><h1>414 Request-URI Too Large</h1></center>        //提示头部信息过大

2）修改Nginx配置文件，增加数据包头部缓存大小

[root@proxy ~]# vim /usr/local/nginx/conf/nginx.conf
.. ..
http {
     
client_header_buffer_size    1k;        //默认请求包头信息的缓存    
large_client_header_buffers  4 4k;        //大请求包头部信息的缓存个数与容量
.. ..
}
[root@proxy ~]# /usr/local/nginx/sbin/nginx -s reload

3）优化后，使用脚本测试长头部请求是否能获得响应

[root@proxy ~]# cat buffer.sh 
#!/bin/bash
URL=http://192.168.4.5/index.html?
for i in {
     1..5000}
do
    URL=${
     URL}v$i=$i
done
curl $URL
[root@proxy ~]# ./buffer.sh

14、浏览器本地缓存静态数据

1）使用Firefox浏览器查看缓存

以Firefox浏览器为例，在Firefox地址栏内输入about:cache将显示Firefox浏览器的缓存信息，如图所示，点击List Cache Entries可以查看详细信息。

2）清空firefox本地缓存数据，如图所示。

3）改Nginx配置文件，定义对静态页面的缓存时间

[root@proxy ~]# vim /usr/local/nginx/conf/nginx.conf
server {
     
        listen       80;
        server_name  localhost;
        location / {
     
            root   html;
            index  index.html index.htm;
        }
location ~* \.(jpg|jpeg|gif|png|css|js|ico|xml)$ {
     
expires        30d;            //定义客户端缓存时间为30天
}
}
[root@proxy ~]# cp /usr/share/backgrounds/day.jpg /usr/local/nginx/html
[root@proxy ~]# /usr/local/nginx/sbin/nginx -s reload
#请先确保nginx是启动状态，否则运行该命令会报错,报错信息如下：
#[error] open() "/usr/local/nginx/logs/nginx.pid" failed (2: No such file or directory)

4）优化后，使用Firefox浏览器访问图片，再次查看缓存信息

[root@client ~]# firefox http://192.168.4.5/day.jpg

在firefox地址栏内输入about:cache，查看本地缓存数据，查看是否有图片以及过期时间是否正确。

15、

16、

17、

18、

19、

2、

参考连接：

肝货！Nginx 高性能优化配置实战总结 : https://mp.weixin.qq.com/s/MtVmzLfGLpeJqu13zGFTZA

构建高效安全的Nginx Web服务器 ：http://www.safebase.cn/article-256876-1.html

Nginx优化配置详解 ：https://mp.weixin.qq.com/s/3UNqWHKDp7obdB8OXpGspQ

不错的Nginx配置介绍及性能调优 : http://www.safebase.cn/article-259483-1.html

Nginx在高并发下的性能优化点！有这篇就够了！ ：https://www.jianshu.com/p/bcfbb90a6776

十八般武艺之Nginx踩坑总结 ：http://www.safebase.cn/article-260363-1.html

Nginx性能调优 ： https://blog.csdn.net/qq_40907977/article/details/104551820?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522158993710319724811830427%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=158993710319724811830427&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_blogfirst_rank_v2~rank_v25-6-104551820.nonecase&utm_term=%E8%B0%83%E4%BC%98

https://mp.weixin.qq.com/s/pkB-k1LZpALkYqn-c07mOA