Nginx性能优化方法总结--详细

冷不防 2022-12-05 15:27 124阅读 0赞

**目录\[-\]**  
![在这里插入图片描述][20200420093353822.png]

# 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 文档），现在我们来对这两个数值进行调优  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTA3OTc3_size_16_color_FFFFFF_t_70]  
**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

![在这里插入图片描述][20200617153448228.png]  
**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，获得更好的性能。

![20200617111328837.png][]  
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

*  1

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

参考连接：

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

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

[https://blog.csdn.net/qq\_40907977/article/details/105627466][https_blog.csdn.net_qq_40907977_article_details_105627466]

**不错的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-2blogfirst\_rank\_v2~rank\_v25-6-104551820.nonecase&utm\_term=%E8%B0%83%E4%BC%98

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

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

[20200420093353822.png]: /images/20221123/48df02a0524749afb7b5fdf1e7df024e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTA3OTc3_size_16_color_FFFFFF_t_70]: /images/20221123/6cf755225b7046b48ef3d0cd7e847296.png
[20200617153448228.png]: /images/20221123/81ac14418f6347048dbd5f09d7f5fd74.png
[20200617111328837.png]: /images/20221123/7c4e2cbb25454c66b9ce6e948554ce21.png
[https_blog.csdn.net_qq_40907977_article_details_105627466]: https://blog.csdn.net/qq_40907977/article/details/105627466