本章目录

[TOC]

1.Ngnix介绍

官方描述:Nginx is an HTTP(S) server, HTTP(S) reverse proxy and IMAP/POP3 proxy server;
描述：Nginx(读音”engine x”)是一个高性能的HTTP负载均衡和反向代理服务器，在2019.3.12被F5硬件负载均衡厂家以6.7亿美金收购了，主要是用于发布网站代码，提供网页信息服务的，用户通过浏览器可以实现页面的访问，也可以是一个IMAP/POP3/SMTP代理服务器；在高连接并发的情况下Nginx是Apache服务器不错的替代品,其特点是占有内存少，并发能力强（在同类型的网页服务器中表现较好），Nginx采用C进行编写，不论是系统资源开销还是CPU使用效率都比Perlbal要好很多；


主要功能:

  • 负载均衡服务器:用户每次访问都会保证服务器集群中的每个服务器压力趋于平衡，分担了服务器压力，避免了服务器崩溃的情况（nginx会给你分配服务器压力小的去访问）;
  • HTTP代理服务器对外进行服务:通过第三方服务器访问内部服务器集群的内容，但是我们并不知道是哪一台服务器提供的内容;
  • 动态网页与静态网页资源相互分离以提高网站的整体性能;


Nginx特点:

  • 安装启用简单以及跨平台,配置文件非常简洁（还能够支持perl语法）, 并且Bugs非常少的服务器性能优秀稳定，能够在升级情况下不间断服务
  • 提供反向代理(代理转发功能)、负载均衡、WEB服务器(处理静态文件)和支持7层负载均衡和故障隔离等功能
  • Nginx 采用C进行编写内存占有少,使用更少的资源，稳定性高等优势，并且依靠并发能力强，丰富的模块库以及友好灵活的配置而闻名(具有高性能、轻量级、内存消耗少，强大的负载均衡能力等优势。)
  • 由于它的内存占用少（一个worker进程只占用10-12M内存），启动极快，高并发能力强(5w/s)-相当于Apache WEB整体性能的5-10倍，在互联网项目中广泛应用。
  • 总结一句:IO多路复用（多线程）， 轻量级 ， 功能模块少，代码模块化，并发处理能力强

什么是IO多路复用（多线程）?

WeiyiGeek.

WeiyiGeek.


架构体系:
动静分离是每个网站发展到一定规模之后必然的结果。

  • 静态网页一般是跟后端数据库不发生交互的网页，其网页内容很少更新或者几乎不更新，网页文件后缀命名通常是以.htm、.html、.xml结尾的。
  • 动态网页一般是跟后端数据库发生交互的网页，其网页内容经常更新或者随着后端数据库内容变化而更新，网页文件后缀命名通常是以.asp、.jsp、.php结尾的。

静态请求则应当最好将其拆分并启用独立的域名，既便于管理的需要也便于今后能够快速支持CDN。
如果一台Nginx性能无法满足，则可以考虑在Nginx前端添加LVS负载均衡，由多台Nginx共同分担网站请求。

新版Nginx目前已经支持直接读写Memcache，可以编译安装时候选择添加此类模块，从而节省了转交给PHP或者JPS等动态程序服务器处理时间，提高效率的同时，减小了动态服务器的负载。

使用场景:(Nginx有点入口网关的味道)

WeiyiGeek.技术架构

WeiyiGeek.技术架构


补充:
目前 Nginx 的主力竞争对手莫过于 Apache ，性能优秀稳定、配置简单以及跨平台，下面做了一个简单的对比帮助大家更好的理解 Nginx 的优势。

  • 常见的中间件服务:httpd-apache基金会的产品,IIS-微软的产品,gws-google的产品;
  • Nginx 配置简洁, Apache 配置复杂
  • Nginx 静态处理性能比 Apache 高 3倍以上，Apache 对 PHP 支持比较简单，Nginx 需要配合其他后端来使用
  • Apache 的组件比 Nginx 多
  • 核心的区别:
    • apache是同步多进程模型，一个连接对应一个进程; nginx是异步的，多个连接（万级别）可以对应一个进程 。
    • nginx的优势是处理静态请求cpu内存使用率低; apache适合处理动态请求，所以现在一般前端用nginx作为反向代理抗住压力，apache作为后端处理动态请求。

2.Nginx安装

描述:基于线上CentOS Linux云服务器，构建一套Nginx WEB服务器平台，主要部署的方式有两种：
YUM二进制方式:

  • 部署方式相对比较简单、快捷、高效，可以自动校验软件包的正确性，可以自动解决软件包之间的依赖关系，可以自动安装软件服务并且设置为系统服务，不能自定义软件服务特定的功能和模块，安装之后的文件和目录相对比较分散，不便于后期的维护和管理。

MAKE源码编译方式

  • 部署方式相对比较复杂、繁琐、低效，不能自动校验软件包的正确性，不能自动解决软件包之间的依赖关系，不能自动安装软件服务并且设置为系统服务，可以自定义软件服务特定的功能和模块，安装之后的文件和目录相对比较统一，便于后期的维护和管理。
2.0 源码安装

我们利用Ngnix源码方式进行安装
安装环境：CentOS Linux release 7.6.1810 (Core) 3.10.0-957.5.1.el7.x86_64

2.1) 安装包以及依赖包下载
Nginx下载地址：http://nginx.org/en/download.html

Q：Mainline version、Stable version、Legacy version的版本区别?
A: Nginx官网提供了三个类型的版本,

  • Mainline version：Mainline 是 Nginx 目前主力在做的版本，可以说是开发版
  • Stable version：最新稳定版，生产环境上建议使用的版本
  • Legacy versions：遗留的老版本的稳定版


Nginx依赖包下载地址:

1
2
3
4
5
6
cd /opt/nginx_packege
wget http://nginx.org/download/nginx-1.16.1.tar.gz
wget http://prdownloads.sourceforge.net/libpng/zlib-1.2.11.tar.gz
wget https://ftp.pcre.org/pub/pcre/pcre-8.43.tar.gz -O pcre.tar.gz
wget https://www.openssl.org/source/openssl-fips-2.0.16.tar.gz
wget https://www.openssl.org/source/openssl-1.0.2r.tar.gz (可选|全包)


2.2) Nginx安装
描述：因为Nginx是基于C语言开发的源代码程序，默认是不能被Linux操作系统直接使用的，需要借助C编译器将源代码文件编译生成二进制文件，所以需执行源代码软件包部署三个步骤。

  • 预编译./configure --prefix=/usr/local/nginx --user=www --group=www --with-http_stub_status_module
    主要是检测Linux系统安装该软件所需的依赖环境、库文件，检测Linux系统是否存在GCC编译环境（C编译器），指定软件服务部署的路径，自定义软件服务特定的功能和模块，最终会产生Makefile文件。
  • 编译 make -j 4
    主要是通过make编译工具，读取Makefile文件，调用Linux操作系统下GCC编译环境（C编译器），将软件包中的源代码文件编译生成二进制文件。
    Makefile文件用途，主要是告知make编译工具，在编译源代码文件时从哪个源码文件开始至哪个源码结束编译&记录依赖的信息。
  • 安装 make -j 4 install
    主要是将第二步make编译产生的二进制文件，拷贝或者安装至Linux操作系统指定的安装目录：--prefix=/usr/local/nginx/。
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
64
65
66
67
#补充
mkdir -p /usr/local/{nginx,zlib,pcre,openssl-fips}

#Step1.安装前确认linux下这些库已经安装:
$ yum -y install perl gcc gcc-c++ net-tools
Package 4:perl-5.16.3-294.el7_6.x86_64 already installed and latest version
Package gcc-4.8.5-36.el7.x86_64 already installed and latest version
Package gcc-c++-4.8.5-36.el7.x86_64 already installed and latest version
Package net-tools-2.0-0.24.20131004git.el7.x86_64 already installed and latest version

#Step2.安装openssl-fips 执行命令如下（可选-非必须）
OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用;
tar -zxf openssl-fips-2.0.16.tar.gz
./config --prefix=/usr/local/openssl-fips
make && make install

#Step3.安装zlib-1.2.11.tar.gz
Zlib是提供资料压缩之用的函式库，当Tengine想启用GZIP压缩的时候就需要使用到Zlib（http://www.zlib.net/）
./configure --prefix=/usr/local/zlib/
make && make install


#Step4.PCRE(Perl Compatible Regular Expressions)是一个Perl库，包括 perl 兼容的正则表达式库。nginx rewrite依赖于PCRE库，所以在安装Tengine前一定要先安装PCRE，最新版本的PCRE可在官网（http://www.pcre.org/）获取。
./configure --prefix=/usr/local/pcre/
make && make install


#Step5.详细nginx安装
cd /opt/package/
groupadd nginx;
useradd -M -g nginx -s /sbin/nologin nginx 

#!with-pcre指定依赖包位置(是设置源码目录，而不是编译安装后的目录)!,注意下面得不同openssl
./configure --with-pcre=../pcre-8.42 --with-zlib=../zlib-1.2.11 --with-openssl=../openssl-fips-2.0.16 --prefix=/usr/local/nginx/ --user=root


#或者采用
./configure \u
"--prefix=/usr/local/nginx" \
"--with-http_stub_status_module" \
"--with-pcre=../pcre-8.43" \
"--with-zlib=../zlib-1.2.11" \
"--with-openssl=../openssl-fips-2.0.16" \
"--user=nginx" \
"--group=nginx" \
"--with-http_ssl_module" \
"--with-cc-opt='-O2'" 

##Configuration summary
# + using PCRE library: ../pcre-8.42
# + using OpenSSL library: ../openssl-fips-2.0.16
# + using zlib library: ../zlib-1.2.11

# nginx path prefix: "/etc/nginx"
# nginx binary file: "/etc/nginx/sbin/nginx"
# nginx modules path: "/etc/nginx/modules"
# nginx configuration prefix: "/etc/nginx/conf"
# nginx configuration file: "/etc/nginx/conf/nginx.conf"
# nginx pid file: "/etc/nginx/logs/nginx.pid"
# nginx error log file: "/etc/nginx/logs/error.log"
# nginx http access log file: "/etc/nginx/logs/access.log"
# nginx http client request body temporary files: "client_body_temp"
# nginx http proxy temporary files: "proxy_temp"
# nginx http fastcgi temporary files: "fastcgi_temp"
# nginx http uwsgi temporary files: "uwsgi_temp"

make && make install
WeiyiGeek.

WeiyiGeek.


2.3) nginx验证与启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
cd /opt/nginx/web/sbin
#如下表示成功
$./nginx -t
nginx: the configuration file /opt/nginx/web/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/web/conf/nginx.conf test is successful

#启动与暂停
./nginx 启动
./nginx -s stop 停止
./nginx -s reload 修改配置后重新加载配置

#监听是否正常监听
[[email protected] sbin]# netstat -tlnp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN 11002/nginx: master


2.1 yum安装nginx

首先.安装Nginx采用yum或者apt,配置文件目录/etc/nginx/;

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
$ yum -y install perl gcc gcc-c++ net-tools

#CentOS7
cat > /etc/yum.repos.d/nginx.repo <<END
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
END
#默认情况下，用于稳定nginx的包库。如果你想使用nginx的主线包
$ sudo yum-config-manager --enable nginx-mainline
$ yum install -y nginx
$ apt-get install nginx

GPG-Key:573B FD6B 3D8F BC64 1079 A6AB ABF5 BD82 7BD9 BF62

参考连接:http://nginx.org/en/linux_packages.html#RHEL-CentOS

yum的方式安装Nginx的目录说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
/etc/nginx  
/etc/nginx/nginx.conf  # 主配置文件
/etc/nginx/fastcgi_params  #cgi相关配置以及、fastcgi配置
/etc/nginx/uwsgi_params
/etc/nginx/scgi_params
/etc/nginx/koi-utf   #编码转换映射转化文件
/etc/nginx/mime.types  #设置HTTP协议的Content-Type与扩展名对应的关系
/var/cache/nginx #缓存
/var/log/nginx #日志
/etc/nginx/modules #模块目录
/etc/logrotate.d/nginx # 配置文件，nginx日志轮转，用于logratate服务的日志切割;
/usr/lib/systemd/system/nginx.service #用于配置出系统守护进程管理器管理方式
/usr/share/doc/nginx-xxx/  #nginx帮助手册


2.2 mac安装Nginx

(1)安装nginx

  • 1-进到homebrew官网，然后复制命令，预安装需要的东西
  • 2-brew install nginx 安装nginx
  • 3-nginx -v 显示版本号

(2)进入nginx cd /usr/local/etc/nginx 配置启动即可


3.Nginx管理与工作模式

Nginx常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
nginx -s stop #快速关闭Nginx，可能不保存相关信息，并迅速终止web服务。
nginx -s quit #平稳关闭Nginx，保存相关信息，有安排的结束web服务。
nginx -s reload #每次修改完.conf文件就需要重启nginx。
nginx -s reopen #重新打开日志文件。
nginx -c filename #为 Nginx 指定一个配置文件，来代替缺省的。
nginx -t [filename] #不运行而仅仅测试配置文件。nginx 将检查配置文件的语法的正确性，并尝试打开配置文件中所引用到的文件。
nginx -tc /etc/nginx.conf #检查配置文件
# 如果出现下面ok和successfull就代表正确了，其他的都不对
# nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
# nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful

nginx -v #显示 nginx 的版本。
nginx -V #显示 nginx 的版本编译器版本和配置参数。

#重载nginx
kill -HUP`cat /usr/local/nginx/nginx.pid`

#指定配置文件重启nginx服务
nginx -s reload -c /etc/nginx/nginx.conf

#软启动一下 Nginx
$ kill -USR1 `cat master.nginx.pid`
$ sleep 1
$ gzip access.log.0    # do something with access.log.0


Nginx的Master-Worker模式
Nginx涉及Master进程和Worker进程,在Nginx启动后涉及了Socket服务进行监听;

  • Master进程的作用：读取并验证配置文件nginx.conf；管理worker进程；
  • Worker进程的作用：每一个Worker进程都维护一个线程（避免线程切换），处理连接和请求；注意Worker进程的个数由配置文件决定，一般和CPU个数相关（有利于进程切换），配置几个就有几个Worker进程;
WeiyiGeek.

WeiyiGeek.


4.Nginx转发简单实例

4.1 项目需求 httpd 服务 8080 端口(外网不能直接访问)，通过nginx进行转发到 80进行访问;
4.2 对于以上需求进行设置修改nginx得conf/nginx.conf我将列出修改得得值

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
keepalive_timeout 65;
#设定请求缓冲，start
client_header_buffer_size 1k;
large_client_header_buffers 4 4k;
#设定请求缓冲， end

#设定提供服务的服务器，start
upstream localserver {
  #weigth 表示权重，权值越大，分配几率越大
  #max_fails 当有max_fails个请求失败，就表示后端的服务器不可用，默认为1，将其设置为0可以关闭检查
  #fail_timeout 在以后的fail_timeout时间内nginx不会再把请求发往已检查出标记为不可用的服务器
  server 127.0.0.1:8080 weight=5 max_fails=5 fail_timeout=600s;
}

server {
        listen 80;
        server_name localhost;
        charset utf-8;
        #设置指定服务器得网站访问记录
        #access_log logs/host.access.log;

        #location / {
         # root html/index.html;
           # index index.html index.htm;
        #}
        #规则1,代理内网网站
        location / {
            proxy_pass http://localserver;
        }

        #错误页设置
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
            root html;
        }

        #代理php应用程序服务器
        #proxy the PHP scripts to Apache listening on 127.0.0.1:8080
        location ~ \.php$ {
            proxy_pass http://127.0.0.1:8080;
        }
}

#重启即可
$ sbin/nginx -s reload


5.Ngin配置实例

5.1 反向代理

描述:反向代理是指以代理服务器来接受连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器,而且整个过程对于客户端而言是透明的。

WeiyiGeek.

WeiyiGeek.

简单来说就是真实的服务器不能直接被外部网络访问，所以需要一台代理服务器，而代理服务器能被外部网络访问的同时又跟真实服务器在同一个网络环境，或同一台服务器不同端口。

1
客户端 -(外围)- NGINX(代码服务器) --- 内网服务端

配置实例:

1
2
3
4
5
6
7
8
9
10
server {  
  listen   80;   #nginx 服务端 请求端口
  server_name  localhost;          
  client_max_body_size 1024M;
  location / {   #匹配指向请求URL后的路径，可以多个
    proxy_pass http://localhost:8080; 
     #URL后缀不得以在端口后加个工程目录
    proxy_set_header Host $host:$server_port;
  }
}


5.2 正向代理

描述:正向代理意思是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后由代理向原始服务器转交请求并将获得的内容返回给客户端。

简单的说类似于采用VPN来访问google:

WeiyiGeek.

WeiyiGeek.

1
2
3
4
5
6
7
8
9
10
resolver 114.114.114.114 8.8.8.8;
    server {
        resolver_timeout 5s;
        listen 81;
        access_log  e:wwwrootproxy.access.log;
        error_log   e:wwwrootproxy.error.log;
        location / {
            proxy_pass http://$host$request_uri;
        }
    }

注：负载均衡通常使用正向代理加upstream的方式


5.3 负载均衡

描述：负载均衡也是Nginx常用的一个功能。简单而言就是当有2台或以上服务器时，根据规则随机的将请求分发到指定的服务器上处理，负载均衡配置一般都需要同时配置反向代理，通过反向代理跳转到负载均衡。

而Nginx目前支持自带3种负载均衡策略还有2种常用的第三方策略。

WeiyiGeek.

WeiyiGeek.

负载均衡调用中状态:

  • down : 当前server暂不参与负载均衡
  • backup : 预留的备份服务器
  • max_fails : 请求失败次数限制
  • fail_timeout : 经过max_fails后服务暂停时间
  • max_conns : 限制最大的连接数

调度算法:

  • 轮询:默认算法按时间顺序逐一分配到不同的后端服务器;
  • 加权轮询:Weight值越大，分配到访问几率越高;
  • ip_hash:为每一个请求访问的IP的hash结果分配，可以将来自一个IP的固定访问一个后端服务器;
  • url_hash:需要安装模块安装访问的URL的hash结果来分配，这样每个URL定向到同一个后端服务器
  • least_conn:按照某台机器最少连接数的进行分配访问;
  • hash关键数值: hash 自定义 KEY
1
2
3
4
5
6
upstrem weiyigeek {
    server weiyigeek.top:8080 down;
    server weiyigeek.top:8081 backup;
    server weiyigeek.top:8082 max_fails=1 fail_timeout=10s max_conns=1024;
    server unix:/tmp/backend3;
}

方式1:
RR（默认轮询）每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉能自动剔除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
upstream test {
   server localhost:8080;
   server localhost:8081;
}

server {
    listen  81;  
    server_name  localhost;                                 
    client_max_body_size 1024M;
    location / {
      proxy_pass http://test;
      proxy_set_header Host $host:$server_port;
    }
}

方式2：
权重指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。 例如

1
2
3
4
upstream test {
   server localhost:8080 weight=9;  #那么10次一般只会有1次会访问到8081，而有9次会访问到8080
   server localhost:8081 weight=1;
}

方式3:
上面的2种方式都有一个问题，那就是下一个请求来的时候请求可能分发到另外一个服务器，当我们的程序不是无状态的时候（采用了session保存数据），这时候就有一个很大的很问题了，比如把登录信息保存到了session中，那么跳转到另外一台服务器的时候就需要重新登录了，所以很多时候我们需要一个客户只访问一个服务器，那么就需要用iphash了，iphash的每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。

1
2
3
4
5
upstream test {
   ip_hash; #用户持续访问
   server localhost:8080;
   server localhost:8081;
}

方式4：
fair（第三方）按后端服务器的响应时间来分配请求，响应时间短的优先分配。

1
2
3
4
5
upstream backend { 
  fair; 
  server localhost:8080;
  server localhost:8081;
}

方式5：
url_hash（第三方）:按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。
在upstream中加入hash语句，server语句中不能写入weight等其他的参数，hash_method是使用的hash算法

1
2
3
4
5
6
upstream backend { 
  hash $request_uri; 
  hash_method crc32; 
  server localhost:8080;
  server localhost:8081;
}

以上5种负载均衡各自适用不同情况下使用，所以可以根据实际情况选择使用哪种策略模式,不过fair和url_hash需要安装第三方模块才能使用.


5.4 HTTP服务器

Nginx本身也是一个静态资源的服务器，当只有静态资源的时候，就可以使用Nginx来做服务器，同时现在也很流行动静分离，就可以通过Nginx来实现，首先看看Nginx做静态资源服务器;

1
2
3
4
5
6
7
8
9
server {
  listen 80; 
  server_name  localhost;                                       
  client_max_body_size 1024M;
  location / {
    root   e:wwwroot;
    index  index.html;
  }
}

访问http://localhost 就会默认访问到E盘wwwroot目录下面的index.html，如果一个网站只是静态页面的话，那么就可以通过这种方式来实现部署。


5.5 动静资源分离

动静分离是让动态网站里的动态网页根据一定规则把不变的资源和经常变的资源区分开来，动静资源做好了拆分以后，我们就可以根据静态资源的特点将其做缓存操作，这就是网站静态化处理的核心思路;

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
upstream test{  
  server localhost:8080;  
  server localhost:8081;  
}   

server {  
  listen       80;  
  server_name  localhost;  
  location / {  
      root   e:wwwroot;  
      index  index.html;  
  }  

  # 所有静态请求都由nginx处理，存放目录为html  
  location ~ .(gif|jpg|jpeg|png|bmp|swf|css|js)$ {  
      root    e:wwwroot;  
  }  

  # 所有动态请求都转发给tomcat处理  
  location ~ .(jsp|do)$ {  
      proxy_pass  http://test;  
  }  
  error_page   500 502 503 504  /50x.html;  
  location = /50x.html {  
      root   e:wwwroot;  
  }  
}

HTML以及图片和css以及js放到wwwroot目录下,而tomcat只负责处理jsp和请求，

例如当我们后缀为gif的时候，Nginx默认会从wwwroot获取到当前请求的动态图文件返回，当然这里的静态文件跟Nginx是同一台服务器，我们也可以在另外一台服务器，然后通过反向代理和负载均衡配置过去就好了，只要搞清楚了最基本的流程，很多配置就很简单了


5.6 请求转发案例

Nginx转发例子1
1.案例需求
短信服务器列表三台，提供服务的地址如下:http://192.168.88.21/22/23:8091/smsserver/services/sendSms?wsdl
彩信服务器列表三台，提供服务的地址如下:http://192.168.88.21/22/23:8092/msserver/services/sendMms?wsdl
假如Nginx安装在另一台单独机器上(公网IP为public_ip)，对外提供服务地址如下：
http://public_ip:8090/[smsserver | mmsserver]/services/sendSms?wsdl 短信发送服务 / 彩信发送服务

2.对于以上需求配置 /opt/nginx/web/conf/nginx.conf 如下：

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#user nobody; 
worker_processes 1; 

#error_log logs/error.log; 
#error_log logs/error.log notice; 
#error_log logs/error.log info; 

#pid logs/nginx.pid; 

events { 
worker_connections 1024; 
} 

http { 
include mime.types; 
default_type application/octet-stream; 

#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 logs/access.log main; 

sendfile on; 
#tcp_nopush on; 

#keepalive_timeout 0; 
keepalive_timeout 65; 
#设定请求缓冲， start 
client_header_buffer_size 1k; 
large_client_header_buffers 4 4k; 
#设定请求缓冲， end 

#设定提供服务的服务器，start 
#短信发送服务器 
upstream smsserver{ 
#weigth 表示权重，权值越大，分配几率越大 
#max_fails 当有max_fails个请求失败，就表示后端的服务器不可用，默认为1，将其设置为0可以关闭检查 
#fail_timeout 在以后的fail_timeout时间内nginx不会再把请求发往已检查出标记为不可用的服务器 
server 192.168.88.21:8091 weight=5 max_fails=5 fail_timeout=600s; 
server 192.168.88.22:8091 weight=5 max_fails=5 fail_timeout=600s; 
server 192.168.88.23:8091 weight=5 max_fails=5 fail_timeout=600s; 
} 
#彩信发送服务器 
upstream mmsserver{ 
#weigth 表示权重，权值越大，分配几率越大 
#max_fails 当有max_fails个请求失败，就表示后端的服务器不可用，默认为1，将其设置为0可以关闭检查 
#fail_timeout 在以后的fail_timeout时间内nginx不会再把请求发往已检查出标记为不可用的服务器 
server 192.168.88.21:8092 weight=5 max_fails=5 fail_timeout=600s; 
server 192.168.88.22:8092 weight=5 max_fails=5 fail_timeout=600s; 
server 192.168.88.23:8092 weight=5 max_fails=5 fail_timeout=600s; 
} 
#设定提供服务的服务器，end 

#gzip on; 

server { 
listen 8090; 
server_name localhost; 
#设定请求转发规则， start 
#规则采用最长匹配，/smsserver/*优先匹配/smsserver，/mmsserver/*优先匹配/mmsserver，/aaaaaaaa/*因为没有任何匹配，最后匹配到/ 
#规则一 
location / { 
proxy_pass http://localhost:80; 
} 
#规则二 
location /smsserver { 
proxy_pass http://smsserver; 
} 
#规则三 
location /mmsserver { 
proxy_pass http://mmsserver; 
} 
#设定请求转发规则， end 
error_page 500 502 503 504 /50x.html; 
location = /50x.html { 
root html; 
} 
} 

server { 
listen 80; 
server_name localhost; 
#设定请求转发规则， start 
location / { 
#定义服务器的默认网站根目录位置 
root /home/work/statichtml/index.html; 
#定义首页索引文件的名称 
#index index.php index.html index.htm; 
#请求转向orderServer定义的服务器列表 
# proxy_pass http://server; 
#以下是一些反向代理的配置可删除. 
# proxy_redirect off; 
# proxy_set_header Host $host; 
# proxy_set_header X-Real-IP $remote_addr; 
# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
#允许客户端请求的最大单文件字节数 
# client_max_body_size 10m; 
#缓冲区代理缓冲用户端请求的最大字节数， 
# client_body_buffer_size 128k; 
#nginx跟后端服务器连接超时时间(代理连接超时) 
# proxy_connect_timeout 90; 
#后端服务器数据回传时间(代理发送超时) 
# proxy_send_timeout 90; 
#连接成功后，后端服务器响应时间(代理接收超时) 
# proxy_read_timeout 90; 
#设置代理服务器（nginx）保存用户头信息的缓冲区大小 
# proxy_buffer_size 4k; 
#proxy_buffers缓冲区，网页平均在32k以下的话，这样设置 
# proxy_buffers 4 32k; 
#高负荷下缓冲大小（proxy_buffers*2） 
# proxy_busy_buffers_size 64k; 
#设定缓存文件夹大小，大于这个值，将从upstream服务器传 
# proxy_temp_file_write_size 64k; 
} 
#设定请求转发规则， end 
error_page 500 502 503 504 /50x.html; 
location = /50x.html { root html; } 
   } 
}


Nginx转发例子2-改进例子

上面例子有个问题是直接将我整个web根目录smsserver和mmsserver暴露到公网了，其实我的目的只是想暴露两个接口地址，优化如下：
1.案例需求
API接口服务器列表两台，提供服务的地址如下:
接口一：http://192.168.88.21/22:8082/myweb/interface/getData
接口二：http://192.168.88.21/22:8082/myweb/interface/sendData
Nginx安装在另外一台单独机器上(公网IP为public_ip)，对外提供服务地址如下：
http://public_ip:8081/myweb/interface/getData 接口一
http://public_ip:8081/myweb/interface/sendData 接口二

2.对于以上需求，配置/opt/nginx/web/conf/nginx.conf 如下：

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#user nobody; 
worker_processes 1; 
#error_log logs/error.log; 
#error_log logs/error.log notice; 
#error_log logs/error.log info; 
#pid logs/nginx.pid; 
events { 
worker_connections 1024; 
} 
http { 
include mime.types; 
default_type application/octet-stream; 

#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 logs/access.log main; 

sendfile on; 
#tcp_nopush on; 

#keepalive_timeout 0; 
keepalive_timeout 65; 
#设定请求缓冲， start 
client_header_buffer_size 1k; 
large_client_header_buffers 4 4k; 
#设定请求缓冲， end 

#设定提供服务的服务器，start 
#我的接口服务器，两台 
upstream myweb{ 
#weigth 表示权重，权值越大，分配几率越大 
#max_fails 当有max_fails个请求失败，就表示后端的服务器不可用，默认为1，将其设置为0可以关闭检查 
#fail_timeout 在以后的fail_timeout时间内nginx不会再把请求发往已检查出标记为不可用的服务器 
server 192.168.88.23:8082 weight=5 max_fails=5 fail_timeout=600s; 
server 192.168.88.24:8082 weight=5 max_fails=5 fail_timeout=600s; 
} 
#设定提供服务的服务器，end 

#gzip on; 

server { 
listen 80; 
server_name localhost; 
#设定请求转发规则， start 
#规则采用最长匹配，即长度最长优先匹配，最后不匹配的走/进行匹配 
#规则一 
location / { 
root html; 
index index.html index.htm; 
} 
#设定请求转发规则， end 
error_page 500 502 503 504 /50x.html; 
location = /50x.html { 
root html; 
} 
} 

server { 
listen 8081; 
server_name localhost; 
#设定请求转发规则， start 
#规则采用最长匹配，即长度最长优先匹配，最后不匹配的走/进行匹配 
#规则一 
location / { 
root html; 
index index.html index.htm; 
} 
#规则二，查询接口一 
location /myweb/interface/getData { 
proxy_pass http://myweb; 
#转发请求的原IP地址，程序中通过request.getHeader("Proxy-Client-IP")获得ip 
proxy_set_header Host $host; 
#如果是有涉及redirect的服务，一定要加上端口8081，否则默认tomcat在redirect时候默认找80端口 
#proxy_set_header Host $host:8081; 
proxy_set_header Proxy-Client-IP $remote_addr; 
} 
#规则三，查询接口二 
location /myweb/interface/sendData { 
proxy_pass http://myweb; 
#转发请求的原IP地址，程序中通过request.getHeader("Proxy-Client-IP")获得ip 
proxy_set_header Host $host; 
#如果是有涉及redirect的服务，一定要加上端口8081，否则默认tomcat在redirect时候默认找80端口 
#proxy_set_header Host $host:8081; 
proxy_set_header Proxy-Client-IP $remote_addr; 
} 
#设定请求转发规则， end 
error_page 500 502 503 504 /50x.html; 
location = /50x.html { 
root html; 
} 
} 
}


Nginx转发例子3-文件映射

修改/opt/nginx/nginx.conf/中第一行的运行用户改为

1
2
3
4
5
6
user root;
location /uploadfile {
    root /opt/staticdata/;
    access_log /opt/nginx/logs/upload_access.log;
    proxy_store_access user:rw group:rw all:rw;
}

访问http://ip:port/uploadfile/aa/bb/cc.jpg 相当于访问 /opt/staticdata/uploadfile/aa/bb/cc.jpg


Nginx转发例子4-反向代理


Step1.通过apt安装得Nginx修改配置文件：
cd /etc/nginx/conf.d && vim www.google.com.hk.conf


Step2.然后写入这样的配置文件：

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
proxy_cache_path /data/nginx/cache/one levels=1:2 keys_zone=one:10m max_size=10g;
proxy_cache_key "$host$request_uri";
#google 镜像站
upstream google {
 server 74.125.224.80:80 max_fails=3;
 server 74.125.224.81:80 max_fails=3;
 server 74.125.224.82:80 max_fails=3;
 server 74.125.224.83:80 max_fails=3;
 server 74.125.224.84:80 max_fails=3;  
}
server {
    listen 80;
    server_name www.example.com;
    access_log /var/log/nginx/a.access.log;
    error_log /var/log/nginx/a.error.log;
    root html;
    index index.html index.htm index.php;
    rewrite ^(.*) http://www.example.com$1 permanent;
    location / {
                    proxy_cache one;
                    proxy_cache_valid 200 302 1h;
                    proxy_cache_valid 404 1m;
                    proxy_redirect http://www.google.com.hk/ ;
                    proxy_cookie_domain google.com.hk www.example.com;
                    proxy_pass http://google;
                    proxy_set_header Host "www.google.com.hk";
                    proxy_set_header Accept-Encoding "";
                    proxy_set_header User-Agent $http_user_agent;
                    proxy_set_header Accept-Language "zh-CN";
                    proxy_set_header Cookie "NID=76=Len8rjrYIITd5At0fRh9v2eE4R4gPhQtYJ23gtZO70VZgTbmtr5HdM4AJw4j7UyG7cG9TI6w6ZpRp1zFhWjJASVc_yCDIEmvbkCrCdt8l-w0r7xGVgBc-IBaWGq5WRCT; expires=Sat, 20-Aug-2016 13:21:29 GMT;";             
                    sub_filter www.google.com.hk www.example.com;
                    sub_filter_once off;
    }
}


##解释##：
<!-- 1.定义了个upstream google，放了5个谷歌的ip，而不是直接反代 www.google.com.hk ，是为了防止谷歌的验证码(谷歌为了防止恶意访问，在访问数量增加后会要求输入验证码)， proxy_pass http://google; 反向代理到upstream google，会随机把请求分配到那几个ip。那几个ip可以在自己的vps或服务器上使用nslookup www.google.com获取。。
2.设置了反向代理缓存，某些资源不用重复去请求谷歌获取，加快搜索速度。
3.proxy_redirect https://www.google.com/ /; 这行的作用是把谷歌服务器返回的302响应头里的域名替换成我们的，不然浏览器还是会直接请求www.google.com , 那样反代就失效了。
4.proxy_cookie_domain google.com www.example.com; 把cookie的作用域替换成我们的域名。
5.proxy_set_header Accept-Encoding “”; 防止谷歌返回压缩的内容，因为压缩的内容我们无法作域名替换。
6.proxy_set_header Accept-Language “zh-CN”;设置语言为中文。
7.proxy_set_header Cookie “”; 这行很关键，传固定的cookie给谷歌，是为了禁止即时搜索，因为开启即时搜索无法替换内容。还有设置为新窗口打开网站，这个符合我们打开链接的习惯。
8.sub_filter www.google.com www.example.com; 是把谷歌的域名替换成自己的，注意需要安装nginx的sub_filter模块。 -->



Step3.修改配置文件后重新启动
$ service nginx start


5.7 错误页面跳转设置

描述:：我Linux服务器上已经在tomcat上部署了一个项目，使用Nginx进行的代理，访问项目不存在的页面时，出现的是Nginx默认的404页面，现在我配置我自己写的404页面进行提示.

  • 第一种配置方式:网络地址跳转
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    http {
        include       mime.types;
        default_type  application/octet-stream;
        #关键点
      proxy_intercept_errors on;
      ... 以下省略;
        server {
            listen 80;
            server_name  www.xxxxxxx.com;
             location / {
                proxy_pass http://search-masteryee;
          proxy_set_header   REMOTE-HOST $remote_addr;
          proxy_set_header   Host $host; 
          proxy_set_header   X-Real-IP $remote_addr; 
          proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
          client_max_body_size    20m; 
            }
            #关键点
            error_page  404  http://www.baidu.com;
        }
    }
  • 第二种配置方式:跳转本地地址
    说明：我的404.html页面文件放在nginx安装目录下的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
    http {
        proxy_intercept_errors on;
        server {
            listen 8080;
            #charset utf-8;
            ....
            #绝对地址
            error_page  404 /404.html;
            location = /404.html {
                #使用绝对地址跳转服务器/usr/local/nginx/html/404.html
                root  /usr/local/nginx/html;
            }
            
            #相对地址
            error_page 404 /404.html;
            location = /404.html {
                #使用相对地址跳转nginx安装目录下的html/404.html
                root   html;
                #下面这种多了一个/ 反而不起作用
                #root   /html;
            }

            #配置多种返回码的多个错误页面，也可以同时配置多个错误码跳转一个页面，可以同时存在 
            error_page 500 502 503 504 /50x.html;
            location = /50x.html {
                root html;
            }
        }
    }
  • 第三种情况配置方式:tomcat未启动时
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    http {
        proxy_intercept_errors on;
        fastcgi_intercept_errors on;
        server {
            listen 80;
            location / {
                proxy_pass http://search-masteryee;
          proxy_set_header REMOTE-HOST $remote_addr;
          proxy_set_header Host $host; 
          proxy_set_header X-Real-IP $remote_addr; 
          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
          client_max_body_size 20m; 
            }
            error_page   500 502 503 504  /404.html;
        error_page   404  /404.html;
            location = /404.html {
                root   html;
            }
        }
    }
  • 第四种情况:proxy_intercept_errors配置地址多样
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    http {
        fastcgi_intercept_errors on;
        server {
            listen 80;
            #可以放在http、server、location下面
            proxy_intercept_errors on;
            location / {
                proxy_pass http://search-masteryee;
            }
            error_page   500 502 503 504  /404.html;
        error_page   404  /404.html;
            location = /404.html {
                root   html;
            }
        }
    }

总结:

  • proxy_intercept_errors on:配置的错误页面表示的是当服务器返回的状态码为我们配置的状态码时才进行的页面跳转;
  • fastcgi_intercept_errors on:在代理的应用服务未启动错误时候进行错误页面的跳转;


5.8 阻止特定URL访问

描述:常常采用的两种方式就是location , $request_url然后采用正则进行匹配;

比如:www.baidu.com/pan/beta/test1?fid=3
$request_uri 代表是域名后路径与参数即是/pan/beta/test1?fid=3。如果只访问www.baidu.com 这时候$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
#指定文件阻止访问
location ~ /\.ht {
    deny  all;
}

#指定参数阻止访问
location / {
    root   html;
    index  index.php;
    if ($request_uri ~* "/\?nsukey="){
        return 403 "I've recorded your ip Wait to check the water meter";
    }
}

location ~ \.php$ {
    root           html;
    fastcgi_pass   127.0.0.1:9000;
    fastcgi_index  index.php;
    fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include        fastcgi_params;
    if ($request_uri ~* "/.+\.php\?nsukey="){
        return 403 "I've recorded your ip Wait to check the water meter";
    }
}


6.附录

6.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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#!/bin/sh
# nginx - this script starts and stops the nginx daemon
# chkconfig:   - 85 15
# description:  Nginx is an HTTP(S) server, HTTP(S) reverse proxy and IMAP/POP3 proxy server
# processname: nginx
# config:      /etc/nginx/nginx.conf
# config:      /usr/local/nginx/conf/nginx.conf
# config:      /etc/sysconfig/nginx
# pidfile:     /var/run/nginx/nginx.pid
# pidfile:     /usr/local/nginx/logs/nginx.pid
# Source function library.
. /etc/rc.d/init.d/functions
# Source networking configuration.
. /etc/sysconfig/network
# Check that networking is up.
[ "$NETWORKING" = "no" ] && exit 0
#需要根据实际情况更改
nginx="/usr/local/nginx/sbin/nginx"
prog=$(basename $nginx)
#需要根据实际情况更改
NGINX_CONF_FILE="/usr/local/nginx/conf/nginx.conf"
[ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx
lockfile=/var/lock/subsys/nginx
make_dirs() {
   # make required directories
   user=`nginx -V 2>&1 | grep "configure arguments:" | sed 's/[^*]*--user=\([^ ]*\).*/\1/g' -`
   options=`$nginx -V 2>&1 | grep 'configure arguments:'`
   for opt in $options; do
       if [ `echo $opt | grep '.*-temp-path'` ]; then
           value=`echo $opt | cut -d "=" -f 2`
           if [ ! -d "$value" ]; then
               # echo "creating" $value
               mkdir -p $value && chown -R $user $value
           fi
       fi
   done
}
start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    make_dirs
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}
stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}
restart() {
    configtest || return $?
    stop
    sleep 1
    start
}
reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
    killproc $nginx -HUP
    RETVAL=$?
    echo
}
force_reload() {
    restart
}
configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}
rh_status() {
    status $prog
}
rh_status_q() {
    rh_status >/dev/null 2>&1
}
case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac
``` 
<br>

##### 6.2 学习思考
_思考1：Nginx如何做到热部署？_
描述:所谓热部署，就是配置文件nginx.conf修改后，不需要stop Nginx不需要中断请求，就能让配置文件生效
通过上文我们已经知道worker进程负责处理具体的请求，那么如果想达到热部署的效果，可以想象：
* 方案一：修改配置文件nginx.conf后，主进程master负责推送给worker进程更新配置信息，worker进程收到信息后，更新进程内部的线程信息。
* 方案二：修改配置文件nginx.conf后，重新生成新的worker进程，当然会以新的配置进行处理，而且新的请求都必须交给新的worker进程，至于老worker进程，等把那些以前的请求处理完毕kill掉即可。


_思考2：Nginx如何做到高并发下的高效处理？_
描述:上文已经提及Nginx的worker进程个数与CPU绑定、worker进程内部包含一个线程高效回环处理请求，这的确有助于效率，但这是不够的。
- 多线程Socket IO技术：BIO/NIO/AIO、异步/同步、阻塞/非阻塞...要同时处理那么多的请求，要知道有的请求需要发生IO，可能需要很长时间，如果等着它就会拖慢worker的处理速度。
Nginx采用了Linux的`epoll模型基于事件驱动机制`，它可以监控多个事件是否准备完毕，如果OK那么放入epoll队列中这个过程是异步的。worker只需要从epoll队列循环处理即可。


_思考3：Nginx挂了怎么办？_
描述:Nginx既然作为入口网关，很重要，如果出现单点问题，显然是不可接受的。答案是：Keepalived+Nginx实现高可用。(可以参考另外一篇文章)
* 第一: 请求不要直接打到Nginx上，应该先通过Keepalived（这就是所谓虚拟IP，VIP）
* 第二: Keepalived应该能监控Nginx的生命状态（提供一个用户自定义的脚本，定期检查Nginx进程状态，进行权重变化,，从而实现Nginx故障切换）

<br>

##### 6.3 错误排查
_错误1:Nginx 502 Bad Gateway_
原因:php-cgi进程数不够用、php执行时间长（mysql慢）、或者是php-cgi进程死掉，都会出现502错误与php-fpm.conf的设置有关;而Nginx 504 Gateway Time-out则是与nginx.conf的设置有关。
检查流程:
- 查看当前的PHP FastCGI进程数是否够用:netstat -anpo | grep "php-cgi" | wc -l
- 部分PHP程序的执行时间超过了Nginx的等待时间,可以适当增加nginx.conf配置文件中FastCGI的timeout时间:
```bash
http {
    fastcgi_connect_timeout 300;
    fastcgi_send_timeout 300;
    fastcgi_read_timeout 300;
}


错误2:413 Request Entity Too Large

原因:client_max_body_size:指令指定允许客户端连接的最大请求实体大小,它出现在请求头部的Content-Length字段. 如果请求大于指定的值,客户端将收到一个”Request Entity Too Large” (413)错误
解决:

1
2
3
4
#conf增大
client_max_body_size
#php.ini中增大
post_max_size 和upload_max_filesize

错误3:Nginx 403 forbidden错误
问题描述:directory index of “/xx/xx/xx/“ is forbidden,网页访问403;
解决思路:

1
2
3
4
5
6
7
#nginx.conf
autoindex on;  #进行列目录查看是否可以列目录为排错准备;

#需要排查的思路
1.selinux
2.目录下有没有index.html 文件（如果有就需要配套有 index  index.html index.php）
3.权限问题 chown -R nginx:www-data /var/www/html


错误4:Nginx 成功配置虚拟主机并且启动nginx可以看见有nginx线程存在但是无监听端口
原因:由于在设置多个虚拟主机的时候在nginx.conf主配置文件中去掉了server {…} 添加的 include domains/*,其中domains目录不是在于conf/子目录中;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
mkdir -vp /usr/local/nginx/conf/domains
cat>/usr/local/nginx/conf/domains/v1.weiyigeek.top.conf<<EOF
server {
    listen       80;
    server_name  $NGX_VHOSTS;

    location / {
        root   html/$NGX_VHOSTS;
        index  index.html index.htm;
    }
    #Nginx 监控模块启用
    location /nginxStatus {
        stub_status;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   html;
    }
}
EOF


错误4:nginx: [error] invalid PID number "" in "/usr/local/var/run/nginx.pid“
错误原因:nginx根本就没有启动过，所以pid文件的值为空没法平滑启动，先启动了才能平滑启动
解决方法:

1
2
解决方案1:sudo nginx -s reload -c  /usr/local/etc/nginx/nginx.conf
解决方案2:先启动nginx然后测试配置文件语法无误后再进行重载。