nginx配置

Nginx (“engine x”) 是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器。Nginx是由Igor Sysoev为俄罗斯访问量第二的Rambler.ru站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。2011年6月1日，nginx 1.0.4发布。

Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，并在一个BSD-like 协议下发行。由俄罗斯的程序设计师Igor Sysoev所开发，供俄国大型的入口网站及搜索引擎Rambler（俄文：Рамблер）使用。其特点是占有内存少，并发能力强，事实上nginx的并发能力确实在同类型的网页服务器中表现较好，中国大陆使用nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等。

Nginx 是开源、高性能、高可靠的 Web 和反向代理服务器，而且支持热部署，几乎可以做到 7 * 24 小时不间断运行，即使运行几个月也不需要重新启动，还能在不间断服务的情况下对软件版本进行热更新。性能是 Nginx 最重要的考量，其占用内存少、并发能力强、能支持高达 5w 个并发连接数，最重要的是， Nginx 是免费的并可以商业化，配置使用也比较简单

优点：Nginx 可以在大多数 UnixLinux OS 上编译运行，并有 Windows 移植版。 Nginx 的1.4.0稳定版已经于2013年4月24日发布，一般情况下，对于新建站点，建议使用最新稳定版作为生产版本，已有站点的升级急迫性不高。Nginx 的源代码使用 2-clause BSD-like license。

Nginx 是一个很强大的高性能Web和反向代理服务器，它具有很多非常优越的特性：

在连接高并发的情况下，Nginx是Apache服务器不错的替代品：Nginx在美国是做虚拟主机生意的老板们经常选择的软件平台之一。能够支持高达 50,000 个并发连接数的响应，感谢Nginx为我们选择了 epoll and kqueue作为开发模型。

  • 高并发、高性能；
  • 模块化架构使得它的扩展性非常好；
  • 异步非阻塞的事件驱动模型这点和 Node.js 相似；
  • 相对于其它服务器来说它可以连续几个月甚至更长而不需要重启服务器使得它具有高可靠性；
  • 热部署、平滑升级；
  • 完全开源，生态繁荣

意义：互联网飞速发展的今天,大用户量高并发已经成为互联网的主体.怎样能让一个网站能够承载几万个或几十万个用户的持续访问呢？这是一些中小网站急需解决的问题。用单机tomcat搭建的网站，在比较理想的状态下能够承受的并发访问量在150到200左右。按照并发访问量占总用户数量的5%到10%这样计算，单点tomcat网站的用户人数在1500到4000左右。对于一个为全国范围提供服务的网站显然是不够用的，为了解决这个问题引入了负载均衡方法。负载均衡就是一个web服务器解决不了的问题可以通过多个web服务器来平均分担压力来解决，并发过来的请求被平均分配到多个后台web服务器来处理，这样压力就被分解开来。

负载均衡服务器分为两种:一种是通过硬件实现的负载均衡服务器，简称硬负载例如：f5。另一种是通过软件来实现的负载均衡，简称软负载:例如apache和nginx。硬负载和软负载相比前者作用的网络层次比较多可以作用到socket接口的数据链路层对发出的请求进行分组转发但是价格成本比较贵，而软负载作用的层次在http协议层之上可以对http请求进行分组转发并且因为是开源的所以几乎是0成本，并且阿里巴巴，京东等电商网站使用的都是Nginx服务器。

应用场景：

1.http服务器，可以做静态网页的http服务器。

2.配置虚拟机。一个域名可以被多个ip绑定。可以根据域名的不同请求转发给运行在不同端口的服务器。

3.反向代理，负载均衡。把请求转发给不同的服务器。

Nginx 的最重要的几个使用场景：

  1. 静态资源服务，通过本地文件系统提供服务；
  2. 反向代理服务，延伸出包括缓存、负载均衡等；
  3. API 服务， OpenResty ；

对于前端来说 Node.js 并不陌生， Nginx 和 Node.js 的很多理念类似， HTTP 服务器、事件驱动、异步非阻塞等，且 Nginx 的大部分功能使用 Node.js 也可以实现，但 Nginx 和Node.js 并不冲突，都有自己擅长的领域。Nginx 擅长于底层服务器端资源的处理（静态资源处理转发、反向代理，负载均衡等）， Node.js 更擅长上层具体业务逻辑的处理，两者可以完美组合

正向代理隐藏的是客户端

反向代理隐藏的是服务器端

Nginx安装

官方网站：http://nginx.org/

Nginx在windows下安装：

img

执行exe文件，在浏览器中访问localhost:80

img

Nginx在linux下安装：

1.环境要求：

nginx是C语言开发，建议在linux上运行，本教程使用Centos6.4作为安装环境。

l gcc

​ 安装nginx需要先将官网下载的源码进行编译，编译依赖gcc环境，如果没有gcc环境，需要安装gcc：

*yum install gcc-c++*

l PCRE

​ PCRE(Perl Compatible Regular Expressions)是一个Perl库，包括 perl 兼容的正则表达式库。nginx的http模块使用pcre来解析正则表达式，所以需要在linux上安装pcre库。

*yum install -y pcre pcre-devel*

注：pcre-devel是使用pcre开发的一个二次开发库。nginx也需要此库。

l zlib

​ zlib库提供了很多种压缩和解压缩的方式，nginx使用zlib对http包的内容进行gzip，所以需要在linux上安装zlib库。

*yum install -y zlib zlib-devel*

l openssl

​ OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。

​ nginx不仅支持http协议，还支持https（即在ssl协议上传输http），所以需要在linux安装openssl库。

*yum install -y openssl openssl-devel*

****2.****编译及安装

第一步：把nginx的源码包上传至linux服务器

第二步：解压源码包。 tar -zxf nginx-1.8.0.tar.gz

第三步：进入nginx-1.8.0文件夹。

第四步：使用configure命令创建makefile。参数设置如下：

./configure \

–prefix=/usr/local/nginx \

–pid-path=/var/run/nginx/nginx.pid \

–lock-path=/var/lock/nginx.lock \

–error-log-path=/var/log/nginx/error.log \

–http-log-path=/var/log/nginx/access.log \

–with-http_gzip_static_module \

–http-client-body-temp-path=/var/temp/nginx/client \

–http-proxy-temp-path=/var/temp/nginx/proxy \

–http-fastcgi-temp-path=/var/temp/nginx/fastcgi \

–http-uwsgi-temp-path=/var/temp/nginx/uwsgi \

–http-scgi-temp-path=/var/temp/nginx/scgi

*注意：上边将临时文件目录指定为*****/var/temp/nginx**，需要在**/var**下创建**temp**及**nginx*****目录*

*mkdir -p /var/temp/nginx*

第五步：make

第六步: make install

img

以上操作完成后，进入/usr/local/nginx目录,ll

img

conf它里面装入的是nginx相关的配置文件

html目录 它里面装入的html代码

sbin目录它里面有一个nginx (这个nginx其实就相当于是windows系统的exe)

想要启动nginx只需要执行bin目录下的nginx命令就可以

img

Nginx服务在启动时会启动两个服务

img此时如果想检测访问的话，去浏览器输入：192.168.19.128：80

使用 yum 安装 Nginx ：

1
yum install nginx -y

安装完成后，通过 rpm \-ql 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
25
26
# Nginx配置文件
/etc/nginx/nginx.conf # nginx 主配置文件
/etc/nginx/nginx.conf.default

# 可执行程序文件
/usr/bin/nginx-upgrade
/usr/sbin/nginx

# nginx库文件
/usr/lib/systemd/system/nginx.service # 用于配置系统守护进程
/usr/lib64/nginx/modules # Nginx模块目录

# 帮助文档
/usr/share/doc/nginx-1.16.1
/usr/share/doc/nginx-1.16.1/CHANGES
/usr/share/doc/nginx-1.16.1/README
/usr/share/doc/nginx-1.16.1/README.dynamic
/usr/share/doc/nginx-1.16.1/UPGRADE-NOTES-1.6-to-1.10

# 静态资源目录
/usr/share/nginx/html/404.html
/usr/share/nginx/html/50x.html
/usr/share/nginx/html/index.html

# 存放Nginx日志文件
/var/log/nginx

主要关注的文件夹有两个：

1. /etc/nginx/conf.d/ 是子配置项存放处， /etc/nginx/nginx.conf 主配置文件会默认把这个文件夹中所有子配置项都引入；

2. /usr/share/nginx/html/ 静态文件都放在这个文件夹，也可以根据你自己的习惯放在其他地方；

Nginx常用命令：

l 关闭nginx需要使用:（暴力）

nginx -s stop 相当于找到nginx进程kill。

l 退出命令：（温和）

nginx -s quit

等程序执行完毕后关闭，建议使用此命令。

l 重新加载配置文件:（重启）

nginx -s reload 可以不关闭nginx的情况下更新配置文件

systemctl 系统命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 开机配置
systemctl enable nginx # 开机自动启动
systemctl disable nginx # 关闭开机自动启动

# 启动Nginx
systemctl start nginx # 启动Nginx成功后，可以直接访问主机IP，此时会展示Nginx默认页面

# 停止Nginx
systemctl stop nginx

# 重启Nginx
systemctl restart nginx

# 重新加载Nginx
systemctl reload nginx

# 查看 Nginx 运行状态
systemctl status nginx

# 查看Nginx进程
ps -ef | grep nginx

# 杀死Nginx进程
kill -9 pid # 根据上面查看到的Nginx进程号，杀死Nginx进程，-9 表示强制结束进程

Nginx 应用程序命令：

1
2
3
4
5
6
nginx -s reload # 向主进程发送信号，重新加载配置文件，热重启
nginx -s reopen # 重启 Nginx
nginx -s stop # 快速关闭
nginx -s quit # 等待工作进程处理完成后关闭
nginx -T # 查看当前 Nginx 最终的配置
nginx -t # 检查配置是否有问题

Nginx配置与应用

1.Nginx虚拟机配置

主要是在描述nginx它是一个http服务器。它是apache的一个替代品。

对于nginx虚拟机配置主要可以从三个方面入手:

\1. ip配置

\2. 域名配置

\3. 端口配置

它的配置主要体现在nginx/conf/nginx.conf，这个文件中#都是注释

img

测试针对ip地址进行配置：复制一个server，将其中的server-name改为自己电脑的ip地址，可以选择性的对location中内容进行修改，实现不同的ip地址和域名访问不同的资源的效果。重启nginx

img

测试针对于域名进行配置

域名作用:可以方便记忆。

问题:为什么通过域名可以访问到网站。

答：DNS服务器—-域名解析服务器。

在windows或linux上都有一个hosts文件，它是一个本地域名解析文件。

windows上在c：\Windows\System32\drivers\etc

linux上在/etc/hosts

linux系统中nginx/conf/nginx.conf，或者windows中config下的nginx.conf文件。修改server-name为一个域名。重启nginx

img

测试针对于端口进行配置

改变listen为8001，就可以根据不同的端口访问不同的资源

img

2.Nginx作反向代理

需要在conf文件中添加反向代理的配置（当访问localhost时，默认端口为80，会跳转到server_list进而访问到tomcat的localhost：8080）如果出错了，可以查看nginx的logs文件，每次改完配置文件后，都需要重启nginx服务器。

img

完成简单的tomcat集群（这个配置有很多错误）：在server_list中继续添加tomcat服务器（这里的8081是修改端口号的tomcat文件的副本）

img

3.Nginx负载均衡

所谓的负载均衡简单说就是将一台服务原来承受的压力由多台服务器来分配，可以在nginx中实现tomcat集群，因为不同服务器的性能可能不一样，所以可以通过weight来分配权重，权重越大代表使用的越多

img

4.Nginx+tomcat集群+redis实现session共享

Session共享问题演示：

1）在tomcat中创建项目myweb，这个网页中得到sessionid值

2）分别启动两个tomcat,查看sessionid值

Tomcat_main

img

Tomcat_back

img

Session共享问题解决：

思想:将原来由每一个tomcat管理的session统一存储到redis中管理

1）下载nginx+tomcat集群+redis实现session共享工具jar包

https://github.com/jcoleman/tomcat-redis-session-manager/downloads

其它依赖包

img

最好使用这四个jar包，因为其他版本的jar包可能会存在冲突

将以上四个包copy到tomcat的lib目录下(集群中的所有Tomcat都需要有这四个jar)

2）在tomcat/conf/context.xml文件中添加配置(集群中的所有Tomcat都需要配置)

<Manager className=”com.radiadesign.catalina.session.RedisSessionManager”

​ host=”192.168.19.128”

​ port=”6379”

​ database=”0”

​ maxInactiveInterval=”60”

​

​ password=”admin”

​ />

重启tomcat，nginx，启动redis数据库

3）查看myweb工具中sessionid

img

img

Redis帮助我们存储了session

img

*配置Tomcat的session共享可以有三种解决方案:*

1.以负载均衡服务器本身提供的session共享策略，每种服务器的配置是不一样的并且nginx本身是没有的

2.利用web容器本身的session共享策略来配置共享。针对于weblogic这种方式还是靠谱的。但是针对于tomcat这种方式存在很大的缺陷，主要因为是依靠广播方式来实现的session复制，会浪费很多带宽导致整个网络反映缓慢。官网也建议这种方式最好不要超过4台tomcat,具体的内容可参考/webapps/docs/cluster-howto.html里面有详细的说明

3.*Tomcat集群+redis的Session共享配置方法*

*配置tomcat中的session共享：*

*步骤一:修改server.xml文件，最简单的集群配置只需要将节点中注释掉的下面这句取消注释即可：*

Xml代码：

使用这样方法配置的集群会将Session同步到所在网段上的所有配置了集群属性的实例上(此处讲所在网段可能不准确，是使用Membership 的address和port来区分的。tomcat集群的实例如果在Membership配置中有相同的address和port值的tomcat被分到同一个集群里边。他们的session是相互共享的，同一个session的集群被称为一个cluster。可以配置多个cluster，但是cluster和cluster之间的session是不共享的)。也就是说如果该广播地址下的所有Tomcat实例都会共享Session，那么假如有几个互不相关的集群，就可能造成Session复制浪费，所以为了避免浪费就需要对节点多做点设置了，如下：

Xml代码

​

​ <Membership className=”org.apache.catalina.tribes.membership.McastService”

​ address=”228.0.0.4”

​ port=”45564”

​ frequency=”500”

​ dropTime=”3000”/>

​

加了一个Channel，里面包了个Membership，咱们要关注的就是membership的port属性和address属性，不同的集群设置不同的port值或address值，从目前的使用来看，基本上是隔离开了。

*步骤二:修改项目的web.xml文件：*

web.xml文件的修改很简单：只需要在节点中添加这个节点就可以了。

OK，有了这二步就实现了Tomcat的集群和Session的共享了

nginx的配置

main（全局设置）、server（主机设置）、upstream（负载均衡服务器设置）和 location（URL匹配特定位置的设置）。

main块设置的指令将影响其他所有设置；
server块的指令主要用于指定主机和端口；
upstream指令主要用于负载均衡，设置一系列的后端服务器；
location块用于匹配网页位置。

这四者之间的关系式：server继承main，location继承server，upstream既不会继承其他设置也不会被继承。
在这四个部分当中，每个部分都包含若干指令，这些指令主要包含Nginx的主模块指令、事件模块指令、HTTP核心模块指令，同时每个部分还可以使用其他HTTP模块指令，例如Http SSL模块、HttpGzip Static模块和Http Addition模块等。

全局配置

1
2
3
4
5
6
7
8
user nobody nobody;  #用户及组：用户 组   windows下不指定
worker_processes 2;  
#worker_processes是个主模块指令，指定了Nginx要开启的进程数。每个Nginx进程平均耗费10M~12M内存。建议指定和CPU的数量一致即可，根据硬件调整，通常等于CPU数量或者2倍于CPU
error_log logs/error.log notice;  
#error_log是个主模块指令，用来定义全局错误日志文件存放路径。日志输出级别有debug、info、notice、warn、error、crit可供选择，其中，debug输出日志最为最详细，而crit输出日志最少
pid logs/nginx.pid;  #pid是个主模块指令，pid（进程标识符）用来指定进程pid的存储文件位置
worker_rlimit_nofile 65535;  
#worker_rlimit_nofile用于绑定worker进程和CPU， Linux内核2.4以上可用。指定进程可以打开的最大描述符：数目。这个指令是指当一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（ulimit -n）与nginx进程数相除，但是nginx分配请求并不是那么均匀，所以最好与ulimit -n 的值保持一致。现在在linux 2.6内核下开启文件打开数为65535，worker_rlimit_nofile就相应应该填写65535。这是因为nginx调度时分配请求到进程并不是那么的均衡，所以假如填写10240，总并发量达到3-4万时就有进程可能超过10240了，这时会返回502错误。

events事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#设定Nginx的工作模式及连接数上限：
events{
use epoll; 
#use是个事件模块指令，用来指定Nginx的工作模式。Nginx支持的工作模式有select、poll、kqueue、epoll、rtsig和/dev/poll。其中select和poll都是标准的工作模式，kqueue和epoll是高效的工作模式，不同的是epoll用在Linux平台上，而kqueue用在FreeBSD系统中。对于Linux系统，epoll工作模式是首选。window下不指定
worker_connections 65536;  
#worker_connections也是个事件模块指令，用于定义Nginx每个进程的最大连接数，默认是1024。最大客户端连接数由worker_processes和worker_connections决定，即Max_client=worker_processes*worker_connections。在作为反向代理时，max_clients变为：max_clients = worker_processes * worker_connections/4。进程的最大连接数受Linux系统进程的最大打开文件数限制，在执行操作系统命令“ulimit -n 65536”后worker_connections的设置才能生效
keepalive_timeout 60;  #keepalive超时时间
client_header_buffer_size 4k;
#客户端请求头部的缓冲区大小。这个可以根据你的系统分页大小来设置，一般一个请求头的大小不会超过1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。分页大小可以用命令`getconf PAGESIZE` 取得。但也有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时间内一次没被使用，它将被移除。
}

HTTP服务器配置

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
http{
include conf/mime.types;  
#include是个主模块指令，实现对配置文件所包含的文件的设定，可以减少主配置文件的复杂度。类似于Apache中的include方法。设定mime类型,类型由mime.type文件定义
default_type application/octet-stream;  
#default_type属于HTTP核心模块指令，这里设定默认类型为二进制流，也就是当文件类型未定义时使用这种方式，例如在没有配置PHP环境时，Nginx是不予解析的，此时，用浏览器访问PHP文件就会出现下载窗口
log_format main '$remote_addr - $remote_user [$time_local] '  用以记录客户端的ip地址  用来记录客户端用户名称  用来记录访问时间与时区
'"$request" $status $bytes_sent '     用来记录请求的url与http协议  用来记录请求状态；成功是200  记录发送给客户端文件主体内容大小
'"$http_referer" "$http_user_agent" '  用来记录从那个页面链接访问过来的  记录客户浏览器的相关信息
'"$gzip_ratio"';
log_format download '$remote_addr - $remote_user [$time_local] '
'"$request" $status $bytes_sent '
'"$http_referer" "$http_user_agent" '
'"$http_range" "$sent_http_content_range"';
    ##通常web服务器放在反向代理的后面，这样就不能获取到客户的IP地址了，通过$remote_add拿到的IP地址是反向代理服务器的iP地址。反向代理服务器在转发请求的http头信息中，可以增加x_forwarded_for信息，用以记录原有客户端的IP地址和原来客户端的请求的服务器地址
#log_format是Nginx的HttpLog模块指令，用于指定Nginx日志的输出格式。main为此日志输出格式的名称，用了log_format指令设置了日志格式之后，需要用access_log指令指定日志文件的存放路径。
access_log  logs/host.access.log  main;
access_log  logs/host.access.404.log  log404;

server_names_hash_bucket_size 128;
#保存服务器名字的hash表是由指令server_names_hash_max_size 和server_names_hash_bucket_size所控制的。参数hash bucket size总是等于hash表的大小，并且是一路处理器缓存大小的倍数。在减少了在内存中的存取次数后，使在处理器中加速查找hash表键值成为可能。如果hash bucket size等于一路处理器缓存的大小，那么在查找键的时候，最坏的情况下在内存中查找的次数为2。第一次是确定存储单元的地址，第二次是在存储单元中查找键值。因此，如果Nginx给出需要增大hash max size 或 hash bucket size的提示，那么首要的是增大前一个参数的大小

client_max_body_size 20m;  #client_max_body_size用来设置允许客户端请求的最大的单个文件字节数；设定通过nginx上传文件的大小
client_header_buffer_size 32K;  #client_header_buffer_size用于指定来自客户端请求头的headerbuffer大小。对于大多数请求，1K的缓冲区大小已经足够，如果自定义了消息头或有更大的Cookie，可以增加缓冲区大小。这里设置为32K
large_client_header_buffers 4 32k;  #large_client_header_buffers用来指定客户端请求中较大的消息头的缓存最大数量和大小， “4”为个数，“128K”为大小，最大缓存量为4个128K
Sendfile on;  #sendfile参数用于开启高效文件传输模式。将tcp_nopush和tcp_nodelay两个指令设置为on用于防止网络阻塞
tcp_nopush on;  #此选项允许或禁止使用socke的TCP_CORK的选项，此选项仅在使用sendfile的时候使用
tcp_nodelay on;  
    
keepalive_timeout 60;  #keepalive_timeout设置客户端连接保持活动的超时时间。在超过这个时间之后，服务器会关闭该连接
client_header_timeout 10;  #client_header_timeout设置客户端请求头读取超时时间。如果超过这个时间，客户端还没有发送任何数据，Nginx将返回“Request time out（408）”错误
client_body_timeout 10;  #client_body_timeout设置客户端请求主体读取超时时间。如果超过这个时间，客户端还没有发送任何数据，Nginx将返回“Request time out（408）”错误，默认值是60
send_timeout 10;  #send_timeout指定响应客户端的超时时间。这个超时仅限于两个连接活动之间的时间，如果超过这个时间，客户端没有任何活动，Nginx将会关闭连接

HttpGzip模块

这个模块支持在线实时压缩输出数据流。通过/opt/nginx/sbin/nginx -V命令可以查看安装Nginx时的编译选项

1
2
3
4
5
6
7
8
9
10
11
12
13
[root@vps ~]# /opt/nginx/sbin/nginx  -V
nginx version: nginx/1.0.14
built by gcc 4.4.6 20110731 (Red Hat 4.4.6-3) (GCC)
configure arguments: --with-http_stub_status_module --with-http_gzip_static_module --prefix=/opt/nginx
                   
gzip on;   #gzip用于设置开启或者关闭gzip模块，“gzip on”表示开启GZIP压缩，实时压缩输出数据流
gzip_min_length 1k;  #gzip_min_length设置允许压缩的页面最小字节数，页面字节数从header头的Content-Length中获取。默认值是0，不管页面多大都进行压缩。建议设置成大于1K的字节数，小于1K可能会越压越大
gzip_buffers 4 16k;  #gzip_buffers表示申请4个单位为16K的内存作为压缩结果流缓存，默认值是申请与原始数据大小相同的内存空间来存储gzip压缩结果
gzip_http_version 1.1;  #gzip_http_version用于设置识别HTTP协议版本，默认是1.1，目前大部分浏览器已经支持GZIP解压，使用默认即可
gzip_comp_level 2;  #gzip_comp_level用来指定GZIP压缩比，1 压缩比最小，处理速度最快；9 压缩比最大，传输速度快，但处理最慢，也比较消耗cpu资源
gzip_types text/plain application/x-javascript text/css application/xml;  
#gzip_types用来指定压缩的类型，无论是否指定，“text/html”类型总是会被压缩的
gzip_vary on;  #gzip_vary选项可以让前端的缓存服务器缓存经过GZIP压缩的页面，例如用Squid缓存经过Nginx压缩的数据

负载均衡设置

Nginx的负载均衡模块目前支持4种调度算法:

1.轮询(默认):每个请求按时间顺序逐一分配到不同的后端服务器。指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  #设定负载均衡服务器列表
  upstream roundrobin {
       #后端服务器访问规则
      server 192.168.1.115:8080  weight=1;       #server1
      server 192.168.1.131:8081  weight=1;       #server1
      server 192.168.1.94:8090   weight=1;       #server3
  }
   
  server {
          listen 80;
          server_name 192.168.1.131;
          location / {
                  proxy_pass http://roundrobin;
          }
  }
当访问 http://192.168.131 的时候，会把这个请求负载到 192.168.1.115 的 8080 端口、192.168.1.115 的 8080 端口、192.168.1.115 的 8080 端口。负载的权重由 weight 来决定，默认为 1 ，weight 越大，权重就越大

2.ip_hash:每个请求按访问IP的hash结果分配，同一个IP客户端固定访问一个后端服务器。可以保证来自同一ip的请求被打到固定的机器上，可以解决session问题

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
#设定负载均衡服务器列表
upstream roundrobin {
     #后端服务器访问规则
    	ip_hash;
        server 192.168.1.134 weight=1 max_fails=2 fail_timeout=2;
        server 192.168.1.131 weight=1 max_fails=2 fail_timeout=2;
}
 
server {
        listen 80;
        server_name 192.168.1.131;
        location / {
                proxy_pass http://roundrobin;
        }
}
设置后端负载均衡服务器的状态:
down，表示当前的server暂时不参与负载均衡。
backup，预留的备份机器。当其他所有的非backup机器出现故障或者忙的时候，才会请求backup机器，因此这台机器的压力最轻。
max_fails：允许请求失败的次数，默认为1。当超过最大次数时，返回proxy_next_upstream 模块定义的错误。
fail_timeout：在经历了max_fails次失败后，暂停服务的时间。max_fails可以和fail_timeout一起使用。
注意：backup不能和ip_hash同时配置。因为ip_hash只能访问同一台服务器，而backup是在只有所有参与负载均衡的服务器出现故障时，才会请求备份机。当所有负载均衡的服务器出现故障了，ip_hash的将无法请求了
#设定负载均衡服务器列表
upstream roundrobin {
    #后端服务器访问规则
    server 192.168.1.115:8080  weight=1;       #server1
    server 192.168.1.131:8080  down;           #server2 不参与负载
    server 192.168.1.94:8090   backup;         #server3 备份机   
}
 
server {
        listen 80;
        server_name 192.168.1.131;
        location / {
                proxy_pass http://roundrobin;
        }
}

3.url_hash（第三方）:访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，可以进一步提高后端缓存服务器的效率。Nginx本身是不支持url_hash的，如果需要使用这种调度算法，必须安装Nginx 的hash软件包

1
2
3
4
5
6
upstream backend {
server squid1:3128;
server squid2:3128;
hash $request_uri;
hash_method crc32;
}

4.fair（第三方）:这是比上面两个更加智能的负载均衡算法。此种算法可以依据页面大小和加载时间长短智能地进行负载均衡，也就是根据后端服务器的响应时间来分配请求，响应时间短的优先分配。Nginx本身是不支持 fair的，如果需要使用这种调度算法，必须下载Nginx的 upstream_fair模块

upstream是Nginx的HTTP Upstream模块，这个模块通过一个简单的调度算法来实现客户端IP到后端服务器的负载均衡。

1
2
3
4
5
upstream backend {
server server1;
server server2;
fair;
}

location对URL进行匹配.可以进行重定向或者进行新的代理 负载均衡

server虚拟主机配置

建议将对虚拟主机进行配置的内容写进另外一个文件，然后通过include指令包含进来，这样更便于维护和管理

1
2
3
4
5
6
7
8
9
10
11
12
13
server{    #server标志定义虚拟主机开始
listen 80;   #listen用于指定虚拟主机的服务端口
server_name 192.168.8.18 cszhi.com;  #server_name用来指定访问的IP地址或者域名，多个域名之间用空格分开
index index.html index.htm index.php;  #index用于设定访问的默认首页地址
root /wwwroot/www.cszhi.com  #root指令用于指定虚拟主机的网页根目录，这个目录可以是相对路径，也可以是绝对路径
charset gb2312;  #charset用于 设置网页的默认编码格式
access_log logs/www.ixdba.net.access.log main;  #access_log用来指定此虚拟主机的访问日志存放路径，最后的main用于指定访问日志的输出格式
proxy_pass http://img_relay$request_uri;  #设置被代理服务器的端口或套接字，以及URL
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;  
#以上三行，目的是将代理服务器收到的用户的信息传到真实服务器上

location URL匹配配置

URL地址匹配是进行Nginx配置中最灵活的部分。 location支持正则表达式匹配，也支持条件判断匹配，用户可以通过location指令实现Nginx对动、静态网页进行过滤处理。使用location URL匹配配置还可以实现反向代理，用于实现PHP动态解析或者负载负载均衡

1
2
3
4
5
6
7
8
9
10
11
#这段设置是通过location指令来对网页URL进行分析处理，所有扩展名以.gif、.jpg、.jpeg、.png、.bmp、.swf结尾的静态文件都交给nginx进行负载均衡
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$ {
root /wwwroot/www.cszhi.com;
expires 30d;   #expires用来指定静态文件的过期时间，这里是30天
}

#这段设置中，location是对此虚拟主机下动态网页的过滤处理，也就是将所有以.jsp为后缀的文件都交给本机的8080端口处理
location ~ .*.php$ {
index index.php;
proxy_pass http://localhost:8080;
}

root和alias的区别：

StubStatus模块配置

StubStatus模块能够获取Nginx自上次启动以来的工作状态，此模块非核心模块，需要在Nginx编译安装时手工指定才能使用此功能。

1
2
3
4
5
6
7
#以下指令是指定启用获取Nginx工作状态的功能
location /NginxStatus {
stub_status on;  #stub_status设置为“on”表示启用StubStatus的工作状态统计功能
access_log logs/NginxStatus.log;  #access_log 用来指定StubStatus模块的访问日志文件
auth_basic "NginxStatus";  #auth_basic是Nginx的一种认证机制
auth_basic_user_file ../htpasswd;
}

auth_basic_user_file用来指定认证的密码文件，由于Nginx的auth_basic认证采用的是与Apache兼容的密码文件，因此需要用Apache的htpasswd命令来生成密码文件，例如要添加一个test用户，可以使用下面方式生成密码文件
/usr/local/apache/bin/htpasswd -c /opt/nginx/conf/htpasswd test
然后输入两次密码后确认之后添加用户成功。

要查看Nginx的运行状态，可以输入http://ip/NginxStatus，输入创建的用户名和密码就可以看到Nginx的运行状态

1
2
3
4
Active connections: 1  #Active connections表示当前活跃的连接数
server accepts handled requests
34561 35731 354399  #表示Nginx当前总共处理了34561个连接， 成功创建次握手， 总共处理了354399个请求
Reading: 0 Writing: 3 Waiting: 0  #Reading表示Nginx读取到客户端Header信息数， Writing表示Nginx返回给客户端的Header信息数，“Waiting”表示Nginx已经处理完，正在等候下一次请求指令时的驻留连接数

错误信息

这段设置中，设置了虚拟主机的错误信息返回页面，通过error_page指令可以定制各种错误信息的返回页面。在默认情况下，Nginx会在主目录的html目录中查找指定的返回页面，特别需要注意的是，这些错误信息的返回页面大小一定要超过512K，否者会被ie浏览器替换为ie默认的错误页面

1
2
3
4
5
error_page 404 /404.html;
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}

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
# main段配置信息
user  nginx; # 运行用户，默认即是nginx，可以不进行设置
worker_processes  auto; # Nginx 进程数，一般设置为和 CPU 核数一样
error_log  /var/log/nginx/error.log warn; # Nginx 的错误日志存放目录
pid        /var/run/nginx.pid; # Nginx 服务启动时的 pid 存放位置

# events段配置信息
events {
    use epoll; # 使用epoll的I/O模型(如果你不知道Nginx该使用哪种轮询方法，会自动选择一个最适合你操作系统的)
    worker_connections 1024; # 每个进程允许最大并发数
}

# http段配置信息
# 配置使用最频繁的部分，代理、缓存、日志定义等绝大多数功能和第三方模块的配置都在这里设置
http { 
    # 设置日志模式
    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; # Nginx访问日志存放位置

    sendfile            on; # 开启高效传输模式
    tcp_nopush          on; # 减少网络报文段的数量
    tcp_nodelay         on;
    keepalive_timeout   65; # 保持连接的时间，也叫超时时间，单位秒
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types; # 文件扩展名与类型映射表
    default_type        application/octet-stream; # 默认文件类型

    include /etc/nginx/conf.d/*.conf; # 加载子配置项
    
    # server段配置信息
    server {
     listen       80; # 配置监听的端口
     server_name  localhost; # 配置的域名
      
     # location段配置信息
     location / {
      root   /usr/share/nginx/html; # 网站根目录
      index  index.html index.htm; # 默认首页文件
      deny 172.168.22.11; # 禁止访问的ip地址，可以为all
      allow 172.168.33.44；# 允许访问的ip地址，可以为all
     }
     
     error_page 500 502 503 504 /50x.html; # 默认50x对应的访问页面
     error_page 400 404 error.html; # 同上
    }
}
  • 全局配置，对全局生效；
  • events 配置影响 Nginx 服务器与用户的网络连接；
  • http 配置代理，缓存，日志定义等绝大多数功能和第三方模块的配置；
  • server 配置虚拟主机的相关参数，一个 http 块中可以有多个 server 块；
  • location 用于配置匹配的 uri ；
  • upstream 配置后端服务器具体地址，负载均衡配置不可或缺的部分；

用一张图清晰的展示它的层级结构：

图片

配置文件 main 段核心参数

user

指定运行 Nginx 的 woker 子进程的属主和属组，其中组可以不指定。

1
2
3
user USERNAME [GROUP]

user nginx lion; # 用户是nginx;组是lion

pid

指定运行 Nginx master 主进程的 pid 文件存放路径。

1
pid /opt/nginx/logs/nginx.pid # master主进程的的pid存放在nginx.pid的文件

worker_rlimit_nofile_number

指定 worker 子进程可以打开的最大文件句柄数。

1
worker_rlimit_nofile 20480; # 可以理解成每个worker子进程的最大连接数量。

worker_rlimit_core

指定 worker 子进程异常终止后的 core 文件，用于记录分析问题。

1
2
worker_rlimit_core 50M; # 存放大小限制
working_directory /opt/nginx/tmp; # 存放目录

worker_processes_number

指定 Nginx 启动的 worker 子进程数量。

1
2
worker_processes 4; # 指定具体子进程数量
worker_processes auto; # 与当前cpu物理核心数一致

worker_cpu_affinity

将每个 worker 子进程与我们的 cpu 物理核心绑定。

1
worker_cpu_affinity 0001 0010 0100 1000; # 4个物理核心，4个worker子进程

图片

将每个 worker 子进程与特定 CPU 物理核心绑定，优势在于，避免同一个 worker 子进程在不同的 CPU 核心上切换，缓存失效，降低性能。但其并不能真正的避免进程切换。

worker_priority

指定 worker 子进程的 nice 值，以调整运行 Nginx 的优先级，通常设定为负值，以优先调用Nginx 。

1
worker_priority -10; # 120-10=110，110就是最终的优先级

Linux 默认进程的优先级值是120，值越小越优先；nice 定范围为 -20 到 +19 。

[备注] 应用的默认优先级值是120加上 nice 值等于它最终的值，这个值越小，优先级越高。

worker_shutdown_timeout

指定 worker 子进程优雅退出时的超时时间。

1
worker_shutdown_timeout 5s;

timer_resolution

worker 子进程内部使用的计时器精度，调整时间间隔越大，系统调用越少，有利于性能提升；反之，系统调用越多，性能下降。

1
timer_resolution 100ms;

在 Linux 系统中，用户需要获取计时器时需要向操作系统内核发送请求，有请求就必然会有开销，因此这个间隔越大开销就越小。

daemon

指定 Nginx 的运行方式，前台还是后台，前台用于调试，后台用于生产。

1
daemon off; # 默认是on，后台运行模式

配置文件 events 段核心参数

use

Nginx 使用何种事件驱动模型。

1
2
3
use method; # 不推荐配置它，让nginx自己选择

method 可选值为：select、poll、kqueue、epoll、/dev/poll、eventport

worker_connections

worker 子进程能够处理的最大并发连接数。

1
worker_connections 1024 # 每个子进程的最大连接数为1024

accept_mutex

是否打开负载均衡互斥锁。

1
accept_mutex on # 默认是off关闭的，这里推荐打开

server_name 指令

指定虚拟主机域名。

1
2
3
4
server_name name1 name2 name3

# 示例：
server_name www.nginx.com;

域名匹配的四种写法：

  • 精确匹配：server_name www.nginx.com ;
  • 左侧通配：server_name *.nginx.com ;
  • 右侧统配：server_name www.nginx.* ;
  • 正则匹配：server_name ~^www\.nginx\.*$ ;

匹配优先级：精确匹配 > 左侧通配符匹配 > 右侧通配符匹配 > 正则表达式匹配

server_name 配置实例：

1、配置本地 DNS 解析 vim /etc/hosts （ macOS 系统）

1
2
3
4
5
6
7
# 添加如下内容，其中 121.42.11.34 是阿里云服务器IP地址
121.42.11.34 www.nginx-test.com
121.42.11.34 mail.nginx-test.com
121.42.11.34 www.nginx-test.org
121.42.11.34 doc.nginx-test.com
121.42.11.34 www.nginx-test.cn
121.42.11.34 fe.nginx-test.club

[注意] 这里使用的是虚拟域名进行测试，因此需要配置本地 DNS 解析，如果使用阿里云上购买的域名，则需要在阿里云上设置好域名解析。

2、配置阿里云 Nginx ，vim /etc/nginx/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
# 这里只列举了http端中的sever端配置

# 左匹配
server {
 listen 80;
 server_name *.nginx-test.com;
 root /usr/share/nginx/html/nginx-test/left-match/;
 location / {
  index index.html;
 }
}

# 正则匹配
server {
 listen 80;
 server_name ~^.*\.nginx-test\..*$;
 root /usr/share/nginx/html/nginx-test/reg-match/;
 location / {
  index index.html;
 }
}

# 右匹配
server {
 listen 80;
 server_name www.nginx-test.*;
 root /usr/share/nginx/html/nginx-test/right-match/;
 location / {
  index index.html;
 }
}

# 完全匹配
server {
 listen 80;
 server_name www.nginx-test.com;
 root /usr/share/nginx/html/nginx-test/all-match/;
 location / {
  index index.html;
 }
}

3、访问分析

  • 当访问 www.nginx-test.com 时，都可以被匹配上，因此选择优先级最高的“完全匹配”；
  • 当访问 mail.nginx-test.com 时，会进行“左匹配”；
  • 当访问 www.nginx-test.org 时，会进行“右匹配”；
  • 当访问 doc.nginx-test.com 时，会进行“左匹配”；
  • 当访问 www.nginx-test.cn 时，会进行“右匹配”；
  • 当访问 fe.nginx-test.club 时，会进行“正则匹配”；

root

指定静态资源目录位置，它可以写在 http 、 server 、 location 等配置中。

1
2
3
4
5
6
7
8
root path

例如：
location /image {
 root /opt/nginx/static;
}

当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png

[注意] root 会将定义路径与 URI 叠加， alias 则只取定义路径。

alias

它也是指定静态资源目录位置，它只能写在 location 中。

1
2
3
4
5
location /image {
 alias /opt/nginx/static/image/;
}

当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png

[注意] 使用 alias 末尾一定要添加 / ，并且它只能位于 location 中。

location

配置路径。

1
2
3
location [ = | ~ | ~* | ^~ ] uri {
 ...
}

匹配规则：

  • = 精确匹配；
  • ~ 正则匹配，区分大小写；
  • ~* 正则匹配，不区分大小写；
  • ^~ 匹配到即停止搜索；

匹配优先级：= > ^~ > ~ > ~* > 不带任何字符。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
server {
  listen 80;
  server_name www.nginx-test.com;
  
  # 只有当访问 www.nginx-test.com/match_all/ 时才会匹配到/usr/share/nginx/html/match_all/index.html
  location = /match_all/ {
      root /usr/share/nginx/html
      index index.html
  }
  
  # 当访问 www.nginx-test.com/1.jpg 等路径时会去 /usr/share/nginx/images/1.jpg 找对应的资源
  location ~ \.(jpeg|jpg|png|svg)$ {
   root /usr/share/nginx/images;
  }
  
  # 当访问 www.nginx-test.com/bbs/ 时会匹配上 /usr/share/nginx/html/bbs/index.html
  location ^~ /bbs/ {
   root /usr/share/nginx/html;
    index index.html index.htm;
  }
}

location 中的反斜线

1
2
3
4
5
6
7
location /test {
 ...
}

location /test/ {
 ...
}
  • 不带 / 当访问 www.nginx-test.com/test 时， Nginx 先找是否有 test 目录，如果有则找 test 目录下的 index.html ；如果没有 test 目录， nginx 则会找是否有 test 文件。
  • 带 / 当访问 www.nginx-test.com/test 时， Nginx 先找是否有 test 目录，如果有则找test 目录下的 index.html ，如果没有它也不会去找是否存在 test 文件。

return

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
return code [text];
return code URL;
return URL;

例如：
location / {
 return 404; # 直接返回状态码
}

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

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

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

rewrite

根据指定正则表达式匹配规则，重写 URL 。

1
2
3
4
5
语法：rewrite 正则表达式 要替换的内容 [flag];

上下文：server、location、if

示例：rewirte /images/(.*\.jpg)$ /pic/$1; # $1是前面括号(.*\.jpg)的反向引用

flag 可选值的含义：

  • last 重写后的 URL 发起新请求，再次进入 server 段，重试 location 的中的匹配；
  • break 直接使用重写后的 URL ，不再匹配其它 location 中语句；
  • redirect 返回302临时重定向；
  • permanent 返回301永久重定向；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
server{
  listen 80;
  server_name fe.lion.club; # 要在本地hosts文件进行配置
  root html;
  location /search {
   rewrite ^/(.*) https://www.baidu.com redirect;
  }
  
  location /images {
   rewrite /images/(.*) /pics/$1;
  }
  
  location /pics {
   rewrite /pics/(.*) /photos/$1;
  }
  
  location /photos {
  
  }
}

按照这个配置我们来分析：

  • 当访问 fe.lion.club/search 时，会自动帮我们重定向到 https://www.baidu.com。
  • 当访问 fe.lion.club/images/1.jpg 时，第一步重写 URL 为 fe.lion.club/pics/1.jpg，找到 pics 的 location ，继续重写 URL 为 fe.lion.club/photos/1.jpg ，找到/photos 的 location 后，去 html/photos 目录下寻找 1.jpg 静态资源。

if 指令

1
2
3
4
5
6
7
8
语法：if (condition) {...}

上下文：server、location

示例：
if($http_user_agent ~ Chrome){
  rewrite /(.*)/browser/$1 break;
}

condition 判断条件：

  • $variable 仅为变量时，值为空或以0开头字符串都会被当做 false 处理；
  • = 或 != 相等或不等；
  • ~ 正则匹配；
  • ! ~ 非正则匹配；
  • ~* 正则匹配，不区分大小写；
  • -f 或 ! -f 检测文件存在或不存在；
  • -d 或 ! -d 检测目录存在或不存在；
  • -e 或 ! -e 检测文件、目录、符号链接等存在或不存在；
  • -x 或 ! -x 检测文件可以执行或不可执行；

实例：

1
2
3
4
5
6
7
8
9
10
11
server {
  listen 8080;
  server_name localhost;
  root html;
  
  location / {
   if ( $uri = "/images/" ){
     rewrite (.*) /pics/ break;
    }
  }
}

当访问 localhost:8080/images/ 时，会进入 if 判断里面执行 rewrite 命令。

autoindex

用户请求以 / 结尾时，列出目录结构，可以用于快速搭建静态资源下载网站。

autoindex.conf 配置信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
server {
  listen 80;
  server_name fe.lion-test.club;
  
  location /download/ {
    root /opt/source;
    
    autoindex on; # 打开 autoindex，，可选参数有 on | off
    autoindex_exact_size on; # 修改为off，以KB、MB、GB显示文件大小，默认为on，以bytes显示出⽂件的确切⼤⼩
    autoindex_format html; # 以html的方式进行格式化，可选参数有 html | json | xml
    autoindex_localtime off; # 显示的⽂件时间为⽂件的服务器时间。默认为off，显示的⽂件时间为GMT时间
  }
}

当访问 fe.lion.com/download/ 时，会把服务器 /opt/source/download/ 路径下的文件展示出来，如下图所示：

图片

变量

Nginx 提供给使用者的变量非常多，但是终究是一个完整的请求过程所产生数据， Nginx 将这些数据以变量的形式提供给使用者。

下面列举些项目中常用的变量：

图片

实例演示 var.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
server{
 listen 8081;
 server_name var.lion-test.club;
 root /usr/share/nginx/html;
 location / {
  return 200 "
remote_addr: $remote_addr
remote_port: $remote_port
server_addr: $server_addr
server_port: $server_port
server_protocol: $server_protocol
binary_remote_addr: $binary_remote_addr
connection: $connection
uri: $uri
request_uri: $request_uri
scheme: $scheme
request_method: $request_method
request_length: $request_length
args: $args
arg_pid: $arg_pid
is_args: $is_args
query_string: $query_string
host: $host
http_user_agent: $http_user_agent
http_referer: $http_referer
http_via: $http_via
request_time: $request_time
https: $https
request_filename: $request_filename
document_root: $document_root
";
 }
}

当我们访问 http://var.lion-test.club:8081/test?pid=121414&cid=sadasd 时，由于Nginx 中写了 return 方法，因此 chrome 浏览器会默认为我们下载一个文件，下面展示的就是下载的文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
remote_addr: 27.16.220.84
remote_port: 56838
server_addr: 172.17.0.2
server_port: 8081
server_protocol: HTTP/1.1
binary_remote_addr: 茉
connection: 126
uri: /test/
request_uri: /test/?pid=121414&cid=sadasd
scheme: http
request_method: GET
request_length: 518
args: pid=121414&cid=sadasd
arg_pid: 121414
is_args: ?
query_string: pid=121414&cid=sadasd
host: var.lion-test.club
http_user_agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36
http_referer: 
http_via: 
request_time: 0.000
https: 
request_filename: /usr/share/nginx/html/test/
document_root: /usr/share/nginx/html

Nginx 的配置还有非常多，以上只是罗列了一些常用的配置，在实际项目中还是要学会查阅文档。

Nginx 应用核心概念

代理是在服务器和客户端之间假设的一层服务器，代理将接收客户端的请求并将它转发给服务器，然后将服务端的响应转发给客户端。

不管是正向代理还是反向代理，实现的都是上面的功能。

图片

正向代理

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

正向代理是为我们服务的，即为客户端服务的，客户端可以根据正向代理访问到它本身无法访问到的服务器资源。

正向代理对我们是透明的，对服务端是非透明的，即服务端并不知道自己收到的是来自代理的访问还是来自真实客户端的访问。

反向代理

  • 反向代理*（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。

反向代理是为服务端服务的，反向代理可以帮助服务器接收来自客户端的请求，帮助服务器做请求转发，负载均衡等。

反向代理对服务端是透明的，对我们是非透明的，即我们并不知道自己访问的是代理服务器，而服务器知道反向代理在为他服务。

反向代理的优势：

  • 隐藏真实服务器；
  • 负载均衡便于横向扩充后端动态服务；
  • 动静分离，提升系统健壮性；

那么“动静分离”是什么？负载均衡又是什么？

动静分离

动静分离是指在 web 服务器架构中，将静态页面与动态页面或者静态内容接口和动态内容接口分开不同系统访问的架构设计方法，进而提示整个服务的访问性和可维护性。

图片

一般来说，都需要将动态资源和静态资源分开，由于 Nginx 的高并发和静态资源缓存等特性，经常将静态资源部署在 Nginx 上。如果请求的是静态资源，直接到静态资源目录获取资源，如果是动态资源的请求，则利用反向代理的原理，把请求转发给对应后台应用去处理，从而实现动静分离。

使用前后端分离后，可以很大程度提升静态资源的访问速度，即使动态服务不可用，静态资源的访问也不会受到影响。

负载均衡

一般情况下，客户端发送多个请求到服务器，服务器处理请求，其中一部分可能要操作一些资源比如数据库、静态资源等，服务器处理完毕后，再将结果返回给客户端。

这种模式对于早期的系统来说，功能要求不复杂，且并发请求相对较少的情况下还能胜任，成本也低。随着信息数量不断增长，访问量和数据量飞速增长，以及系统业务复杂度持续增加，这种做法已无法满足要求，并发量特别大时，服务器容易崩。

很明显这是由于服务器性能的瓶颈造成的问题，除了堆机器之外，最重要的做法就是负载均衡。

请求爆发式增长的情况下，单个机器性能再强劲也无法满足要求了，这个时候集群的概念产生了，单个服务器解决不了的问题，可以使用多个服务器，然后将请求分发到各个服务器上，将负载分发到不同的服务器，这就是负载均衡，核心是「分摊压力」。Nginx 实现负载均衡，一般来说指的是将请求转发给服务器集群。

举个具体的例子，晚高峰乘坐地铁的时候，入站口经常会有地铁工作人员大喇叭“请走 B 口，B 口人少车空….”，这个工作人员的作用就是负载均衡。

图片

Nginx 实现负载均衡的策略：

  • 轮询策略：默认情况下采用的策略，将所有客户端请求轮询分配给服务端。这种策略是可以正常工作的，但是如果其中某一台服务器压力太大，出现延迟，会影响所有分配在这台服务器下的用户。
  • 最小连接数策略：将请求优先分配给压力较小的服务器，它可以平衡每个队列的长度，并避免向压力大的服务器添加更多的请求。
  • 最快响应时间策略：优先分配给响应时间最短的服务器。
  • 客户端 ip 绑定策略：来自同一个 ip 的请求永远只分配一台服务器，有效解决了动态网页存在的 session 共享问题。

Nginx 实战配置

在配置反向代理和负载均衡等等功能之前，有两个核心模块是我们必须要掌握的，这两个模块应该说是 Nginx 应用配置中的核心，它们分别是：upstream 、proxy_pass 。

upstream

用于定义上游服务器（指的就是后台提供的应用服务器）的相关信息。

图片

1
2
3
4
5
6
7
8
9
10
语法：upstream name {
 ...
}

上下文：http

示例：
upstream back_end_server{
  server 192.168.100.33:8081
}

在 upstream 内可使用的指令：

  • server 定义上游服务器地址；
  • zone 定义共享内存，用于跨 worker 子进程；
  • keepalive 对上游服务启用长连接；
  • keepalive_requests 一个长连接最多请求 HTTP 的个数；
  • keepalive_timeout 空闲情形下，一个长连接的超时时长；
  • hash 哈希负载均衡算法；
  • ip_hash 依据 IP 进行哈希计算的负载均衡算法；
  • least_conn 最少连接数负载均衡算法；
  • least_time 最短响应时间负载均衡算法；
  • random 随机负载均衡算法；

server

定义上游服务器地址。

1
2
3
语法：server address [parameters]

上下文：upstream

parameters 可选值：

  • weight=number 权重值，默认为1；
  • max_conns=number 上游服务器的最大并发连接数；
  • fail_timeout=time 服务器不可用的判定时间；
  • max_fails=numer 服务器不可用的检查次数；
  • backup 备份服务器，仅当其他服务器都不可用时才会启用；
  • down 标记服务器长期不可用，离线维护；

keepalive

限制每个 worker 子进程与上游服务器空闲长连接的最大数量。

1
2
3
4
5
keepalive connections;

上下文：upstream

示例：keepalive 16;

keepalive_requests

单个长连接可以处理的最多 HTTP 请求个数。

1
2
3
4
5
语法：keepalive_requests number;

默认值：keepalive_requests 100;

上下文：upstream

keepalive_timeout

空闲长连接的最长保持时间。

1
2
3
4
5
语法：keepalive_timeout time;

默认值：keepalive_timeout 60s;

上下文：upstream

配置实例

1
2
3
4
5
6
upstream back_end{
 server 127.0.0.1:8081 weight=3 max_conns=1000 fail_timeout=10s max_fails=2;
  keepalive 32;
  keepalive_requests 50;
  keepalive_timeout 30s;
}

proxy_pass

用于配置代理服务器。

1
2
3
4
5
6
7
语法：proxy_pass URL;

上下文：location、if、limit_except

示例：
proxy_pass http://127.0.0.1:8081
proxy_pass http://127.0.0.1:8081/proxy

URL 参数原则

1. URL 必须以 http 或 https 开头；

2. URL 中可以携带变量；

3. URL 中是否带 URI ，会直接影响发往上游请求的 URL ；

接下来让我们来看看两种常见的 URL 用法：

  1. proxy_pass http://192.168.100.33:8081
  2. proxy_pass http://192.168.100.33:8081/

这两种用法的区别就是带 / 和不带 / ，在配置代理时它们的区别可大了：

  • 不带 / 意味着 Nginx 不会修改用户 URL ，而是直接透传给上游的应用服务器；
  • 带 / 意味着 Nginx 会修改用户 URL ，修改方法是将 location 后的 URL 从用户 URL 中删除；

不带 / 的用法：

1
2
3
location /bbs/{
  proxy_pass http://127.0.0.1:8080;
}

分析：

\1. 用户请求 URL ：/bbs/abc/test.html

\2. 请求到达 Nginx 的 URL ：/bbs/abc/test.html

3 .请求到达上游应用服务器的 URL ：/bbs/abc/test.html

带 / 的用法：

1
2
3
location /bbs/{
  proxy_pass http://127.0.0.1:8080/;
}

分析：

\1. 用户请求 URL ：/bbs/abc/test.html

\2. 请求到达 Nginx 的 URL ：/bbs/abc/test.html

\3. 请求到达上游应用服务器的 URL ：/abc/test.html

并没有拼接上 /bbs ，这点和 root 与 alias 之间的区别是保持一致的。

配置反向代理

这里为了演示更加接近实际，作者准备了两台云服务器，它们的公网 IP 分别是：121.42.11.34与 121.5.180.193 。

我们把 121.42.11.34 服务器作为上游服务器，做如下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
# /etc/nginx/conf.d/proxy.conf
server{
  listen 8080;
  server_name localhost;
  
  location /proxy/ {
    root /usr/share/nginx/html/proxy;
    index index.html;
  }
}

# /usr/share/nginx/html/proxy/index.html
<h1> 121.42.11.34 proxy html </h1>

配置完成后重启 Nginx 服务器 nginx \-s reload 。

把 121.5.180.193 服务器作为代理服务器，做如下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# /etc/nginx/conf.d/proxy.conf
upstream back_end {
  server 121.42.11.34:8080 weight=2 max_conns=1000 fail_timeout=10s max_fails=3;
  keepalive 32;
  keepalive_requests 80;
  keepalive_timeout 20s;
}

server {
  listen 80;
  server_name proxy.lion.club;
  location /proxy {
   proxy_pass http://back_end/proxy;
  }
}

本地机器要访问 proxy.lion.club 域名，因此需要配置本地 hosts ，通过命令：vim /etc/hosts 进入配置文件，添加如下内容：

1
121.5.180.193 proxy.lion.club

图片

分析：

当访问 proxy.lion.club/proxy 时通过 upstream 的配置找到 121.42.11.34:8080 ；

因此访问地址变为 http://121.42.11.34:8080/proxy ；

连接到 121.42.11.34 服务器，找到 8080 端口提供的 server ；

通过 server 找到 /usr/share/nginx/html/proxy/index.html 资源，最终展示出来。

配置负载均衡

配置负载均衡主要是要使用 upstream 指令。

我们把 121.42.11.34 服务器作为上游服务器，做如下配置（/etc/nginx/conf.d/balance.conf ）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
server{
  listen 8020;
  location / {
   return 200 'return 8020 \n';
  }
}

server{
  listen 8030;
  location / {
   return 200 'return 8030 \n';
  }
}

server{
  listen 8040;
  location / {
   return 200 'return 8040 \n';
  }
}

配置完成后：

1. nginx -t 检测配置是否正确；

2. nginx -s reload 重启 Nginx 服务器；

\3. 执行 ss -nlt 命令查看端口是否被占用，从而判断 Nginx 服务是否正确启动。

把 121.5.180.193 服务器作为代理服务器，做如下配置（ /etc/nginx/conf.d/balance.conf）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
upstream demo_server {
  server 121.42.11.34:8020;
  server 121.42.11.34:8030;
  server 121.42.11.34:8040;
}

server {
  listen 80;
  server_name balance.lion.club;
  
  location /balance/ {
   proxy_pass http://demo_server;
  }
}

配置完成后重启 Nginx 服务器。并且在需要访问的客户端配置好 ip 和域名的映射关系。

1
2
3
# /etc/hosts

121.5.180.193 balance.lion.club

在客户端机器执行 curl http://balance.lion.club/balance/ 命令：

图片

不难看出，负载均衡的配置已经生效了，每次给我们分发的上游服务器都不一样。就是通过简单的轮询策略进行上游服务器分发。

接下来，我们再来了解下 Nginx 的其它分发策略。

hash 算法

通过制定关键字作为 hash key ，基于 hash 算法映射到特定的上游服务器中。关键字可以包含有变量、字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
upstream demo_server {
  hash $request_uri;
  server 121.42.11.34:8020;
  server 121.42.11.34:8030;
  server 121.42.11.34:8040;
}

server {
  listen 80;
  server_name balance.lion.club;
  
  location /balance/ {
   proxy_pass http://demo_server;
  }
}

hash $request_uri 表示使用 request_uri 变量作为 hash 的 key 值，只要访问的 URI 保持不变，就会一直分发给同一台服务器。

ip_hash

根据客户端的请求 ip 进行判断，只要 ip 地址不变就永远分配到同一台主机。它可以有效解决后台服务器 session 保持的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
upstream demo_server {
  ip_hash;
  server 121.42.11.34:8020;
  server 121.42.11.34:8030;
  server 121.42.11.34:8040;
}

server {
  listen 80;
  server_name balance.lion.club;
  
  location /balance/ {
   proxy_pass http://demo_server;
  }
}

最少连接数算法

各个 worker 子进程通过读取共享内存的数据，来获取后端服务器的信息。来挑选一台当前已建立连接数最少的服务器进行分配请求。

1
2
3
语法：least_conn;

上下文：upstream;

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
upstream demo_server {
  zone test 10M; # zone可以设置共享内存空间的名字和大小
  least_conn;
  server 121.42.11.34:8020;
  server 121.42.11.34:8030;
  server 121.42.11.34:8040;
}

server {
  listen 80;
  server_name balance.lion.club;
  
  location /balance/ {
   proxy_pass http://demo_server;
  }
}

最后你会发现，负载均衡的配置其实一点都不复杂。

配置缓存

缓存可以非常有效的提升性能，因此不论是客户端（浏览器），还是代理服务器（ Nginx ），乃至上游服务器都多少会涉及到缓存。可见缓存在每个环节都是非常重要的。下面让我们来学习Nginx 中如何设置缓存策略。

proxy_cache

存储一些之前被访问过、而且可能将要被再次访问的资源，使用户可以直接从代理服务器获得，从而减少上游服务器的压力，加快整个访问速度。

1
2
3
4
5
语法：proxy_cache zone | off ; # zone 是共享内存的名称

默认值：proxy_cache off;

上下文：http、server、location

proxy_cache_path

设置缓存文件的存放路径。

1
2
3
4
5
语法：proxy_cache_path path [level=levels] ...可选参数省略，下面会详细列举

默认值：proxy_cache_path off

上下文：http

参数含义：

  • path 缓存文件的存放路径；
  • level path 的目录层级；
  • keys_zone 设置共享内存；
  • inactive 在指定时间内没有被访问，缓存会被清理，默认10分钟；

proxy_cache_key

设置缓存文件的 key 。

1
2
3
4
5
语法：proxy_cache_key

默认值：proxy_cache_key $scheme$proxy_host$request_uri;

上下文：http、server、location

proxy_cache_valid

配置什么状态码可以被缓存，以及缓存时长。

1
2
3
4
5
语法：proxy_cache_valid [code...] time;

上下文：http、server、location

配置示例：proxy_cache_valid 200 304 2m;; # 说明对于状态为200和304的缓存文件的缓存时间是2分钟

proxy_no_cache

定义相应保存到缓存的条件，如果字符串参数的至少一个值不为空且不等于“ 0”，则将不保存该响应到缓存。

1
2
3
4
5
语法：proxy_no_cache string;

上下文：http、server、location

示例：proxy_no_cache $http_pragma    $http_authorization;

proxy_cache_bypass

定义条件，在该条件下将不会从缓存中获取响应。

1
2
3
4
5
语法：proxy_cache_bypass string;

上下文：http、server、location

示例：proxy_cache_bypass $http_pragma    $http_authorization;

upstream_cache_status 变量

它存储了缓存是否命中的信息，会设置在响应头信息中，在调试中非常有用。

1
2
3
4
5
6
7
MISS: 未命中缓存
HIT：命中缓存
EXPIRED: 缓存过期
STALE: 命中了陈旧缓存
REVALIDDATED: Nginx验证陈旧缓存依然有效
UPDATING: 内容陈旧，但正在更新
BYPASS: X响应从原始服务器获取

配置实例

我们把 121.42.11.34 服务器作为上游服务器，做如下配置（ /etc/nginx/conf.d/cache.conf）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server {
  listen 1010;
  root /usr/share/nginx/html/1010;
  location / {
   index index.html;
  }
}

server {
  listen 1020;
  root /usr/share/nginx/html/1020;
  location / {
   index index.html;
  }
}

把 121.5.180.193 服务器作为代理服务器，做如下配置（ /etc/nginx/conf.d/cache.conf）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
proxy_cache_path /etc/nginx/cache_temp levels=2:2 keys_zone=cache_zone:30m max_size=2g inactive=60m use_temp_path=off;

upstream cache_server{
  server 121.42.11.34:1010;
  server 121.42.11.34:1020;
}

server {
  listen 80;
  server_name cache.lion.club;
  location / {
    proxy_cache cache_zone; # 设置缓存内存，上面配置中已经定义好的
    proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
    proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
    add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
    proxy_pass http://cache_server; # 代理转发
  }
}

缓存就是这样配置，我们可以在 /etc/nginx/cache_temp 路径下找到相应的缓存文件。

对于一些实时性要求非常高的页面或数据来说，就不应该去设置缓存，下面来看看如何配置不缓存的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
...

server {
  listen 80;
  server_name cache.lion.club;
  # URI 中后缀为 .txt 或 .text 的设置变量值为 "no cache"
  if ($request_uri ~ \.(txt|text)$) {
   set $cache_name "no cache"
  }
  
  location / {
    proxy_no_cache $cache_name; # 判断该变量是否有值，如果有值则不进行缓存，如果没有值则进行缓存
    proxy_cache cache_zone; # 设置缓存内存
    proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
    proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
    add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
    proxy_pass http://cache_server; # 代理转发
  }
}

HTTPS**
**

在学习如何配置 HTTPS 之前，我们先来简单回顾下 HTTPS 的工作流程是怎么样的？它是如何进行加密保证安全的？

HTTPS 工作流程

\1. 客户端（浏览器）访问 https://www.baidu.com 百度网站；

\2. 百度服务器返回 HTTPS 使用的 CA 证书；

\3. 浏览器验证 CA 证书是否为合法证书；

\4. 验证通过，证书合法，生成一串随机数并使用公钥（证书中提供的）进行加密；

\5. 发送公钥加密后的随机数给百度服务器；

\6. 百度服务器拿到密文，通过私钥进行解密，获取到随机数（公钥加密，私钥解密，反之也可以）；

\7. 百度服务器把要发送给浏览器的内容，使用随机数进行加密后传输给浏览器；

\8. 此时浏览器可以使用随机数进行解密，获取到服务器的真实传输内容；

这就是 HTTPS 的基本运作原理，使用对称加密和非对称机密配合使用，保证传输内容的安全性。

关于HTTPS更多知识，可以查看作者的另外一篇文章《学习 HTTP 协议》。

配置证书

下载证书的压缩文件，里面有个 Nginx 文件夹，把 xxx.crt 和 xxx.key 文件拷贝到服务器目录，再进行如下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
server {
  listen 443 ssl http2 default_server; # SSL 访问端口号为 443
  server_name lion.club; # 填写绑定证书的域名(我这里是随便写的)
  ssl_certificate /etc/nginx/https/lion.club_bundle.crt; # 证书地址
  ssl_certificate_key /etc/nginx/https/lion.club.key; # 私钥地址
  ssl_session_timeout 10m;
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # 支持ssl协议版本，默认为后三个，主流版本是[TLSv1.2]
 
  location / {
    root         /usr/share/nginx/html;
    index        index.html index.htm;
  }
}

如此配置后就能正常访问 HTTPS 版的网站了。

配置跨域 CORS

先简单回顾下跨域究竟是怎么回事。

跨域的定义

同源策略限制了从同一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的重要安全机制。通常不允许不同源间的读操作。

同源的定义

如果两个页面的协议，端口（如果有指定）和域名都相同，则两个页面具有相同的源。

下面给出了与 URL http://store.company.com/dir/page.html 的源进行对比的示例:

1
2
3
4
http://store.company.com/dir2/other.html 同源
https://store.company.com/secure.html 不同源，协议不同
http://store.company.com:81/dir/etc.html 不同源，端口不同
http://news.company.com/dir/other.html 不同源，主机不同

不同源会有如下限制：

  • Web 数据层面，同源策略限制了不同源的站点读取当前站点的 Cookie 、 IndexDB 、LocalStorage 等数据。
  • DOM 层面，同源策略限制了来自不同源的 JavaScript 脚本对当前 DOM 对象读和写的操作。
  • 网络层面，同源策略限制了通过 XMLHttpRequest 等方式将站点的数据发送给不同源的站点。

Nginx 解决跨域的原理

例如：

  • 前端 server 的域名为：fe.server.com
  • 后端服务的域名为：dev.server.com

现在我在 fe.server.com 对 dev.server.com 发起请求一定会出现跨域。

现在我们只需要启动一个 Nginx 服务器，将 server_name 设置为 fe.server.com 然后设置相应的 location 以拦截前端需要跨域的请求，最后将请求代理回 dev.server.com 。如下面的配置：

1
2
3
4
5
6
7
server {
 listen      80;
 server_name  fe.server.com;
 location / {
  proxy_pass dev.server.com;
 }
}

这样可以完美绕过浏览器的同源策略：fe.server.com 访问 Nginx 的 fe.server.com 属于同源访问，而 Nginx 对服务端转发的请求不会触发浏览器的同源策略。

配置开启 gzip 压缩

GZIP 是规定的三种标准 HTTP 压缩格式之一。目前绝大多数的网站都在使用 GZIP 传输 HTML、CSS 、 JavaScript 等资源文件。

对于文本文件， GZiP 的效果非常明显，开启后传输所需流量大约会降至 1/4~1/3 。

并不是每个浏览器都支持 gzip 的，如何知道客户端是否支持 gzip 呢，请求头中的 Accept-Encoding 来标识对压缩的支持。

图片

启用 gzip 同时需要客户端和服务端的支持，如果客户端支持 gzip 的解析，那么只要服务端能够返回 gzip 的文件就可以启用 gzip 了,我们可以通过 Nginx 的配置来让服务端支持 gzip 。下面的 respone 中 content-encoding:gzip ，指服务端开启了 gzip 的压缩方式。

图片

在 /etc/nginx/conf.d/ 文件夹中新建配置文件 gzip.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
# # 默认off，是否开启gzip
gzip on; 
# 要采用 gzip 压缩的 MIME 文件类型，其中 text/html 被系统强制启用；
gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

# ---- 以上两个参数开启就可以支持Gzip压缩了 ---- #

# 默认 off，该模块启用后，Nginx 首先检查是否存在请求静态文件的 gz 结尾的文件，如果有则直接返回该 .gz 文件内容；
gzip_static on;

# 默认 off，nginx做为反向代理时启用，用于设置启用或禁用从代理服务器上收到相应内容 gzip 压缩；
gzip_proxied any;

# 用于在响应消息头中添加 Vary：Accept-Encoding，使代理服务器根据请求头中的 Accept-Encoding 识别是否启用 gzip 压缩；
gzip_vary on;

# gzip 压缩比，压缩级别是 1-9，1 压缩级别最低，9 最高，级别越高压缩率越大，压缩时间越长，建议 4-6；
gzip_comp_level 6;

# 获取多少内存用于缓存压缩结果，16 8k 表示以 8k*16 为单位获得；
gzip_buffers 16 8k;

# 允许压缩的页面最小字节数，页面字节数从header头中的 Content-Length 中进行获取。默认值是 0，不管页面多大都压缩。建议设置成大于 1k 的字节数，小于 1k 可能会越压越大；
# gzip_min_length 1k;

# 默认 1.1，启用 gzip 所需的 HTTP 最低版本；
gzip_http_version 1.1;

其实也可以通过前端构建工具例如 webpack 、rollup 等在打生产包时就做好 Gzip 压缩，然后放到 Nginx 服务器中，这样可以减少服务器的开销，加快访问速度。

关于 Nginx 的实际应用就学习到这里，相信通过掌握了 Nginx 核心配置以及实战配置，之后再遇到什么需求，我们也能轻松应对。接下来，让我们再深入一点学习下 Nginx 的架构。

Nginx 架构

进程结构

多进程结构 Nginx 的进程模型图：

图片

多进程中的 Nginx 进程架构如下图所示，会有一个父进程（ Master Process ），它会有很多子进程（ Child Processes ）。

  • Master Process 用来管理子进程的，其本身并不真正处理用户请求。

    • 某个子进程 down 掉的话，它会向 Master 进程发送一条消息，表明自己不可用了，此时Master 进程会去新起一个子进程。
    • 某个配置文件被修改了 Master 进程会去通知 work 进程获取新的配置信息，这也就是我们所说的热部署。

  • 子进程间是通过共享内存的方式进行通信的。

配置文件重载原理

reload 重载配置文件的流程：

\1. 向 master 进程发送 HUP 信号（ reload 命令）；

2. master 进程检查配置语法是否正确；

3. master 进程打开监听端口；

4. master 进程使用新的配置文件启动新的 worker 子进程；

5. master 进程向老的 worker 子进程发送 QUIT 信号；

\6. 老的 worker 进程关闭监听句柄，处理完当前连接后关闭进程；

\7. 整个过程 Nginx 始终处于平稳运行中，实现了平滑升级，用户无感知；

Nginx 模块化管理机制

Nginx 的内部结构是由核心部分和一系列的功能模块所组成。这样划分是为了使得每个模块的功能相对简单，便于开发，同时也便于对系统进行功能扩展。Nginx 的模块是互相独立的,低耦合高内聚。

图片

nginx带参数转发链接

https://blog.csdn.net/ixr_wang/article/details/7359825

配置示例

image-20210330153357593

修改root文件下的ngnix,新加一个server()

/default.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
server {
    listen       80;     #ipv4的端口
    listen  [::]:80;     #ipv6的端口
    server_name  localhost;

    #charset koi8-r;   在Unicode未流行之前，KOI8-R 是最为广泛使用的俄语编码，使用率甚至比ISO 8859-5还高
    #access_log  /var/log/nginx/host.access.log  main;

  location ~ .*\.(gif|jpg|jpeg|png)$ {  
    expires 24h;  
      root /yxtl/data/;#鎸囧畾鍥剧墖瀛樻斁璺緞  
      access_log /usr/local/websrv/nginx-1.9.4/logs/images.log;#鏃ュ織瀛樻斁璺緞  
      proxy_store on;  
      proxy_store_access user:rw group:rw all:rw;  
      proxy_temp_path     /home/images/;#鍥剧墖璁块棶璺緞  
      proxy_redirect     off;  
      proxy_set_header    Host 127.0.0.1;  
      client_max_body_size  10m;  
      client_body_buffer_size 1280k;  
      proxy_connect_timeout  900;  
      proxy_send_timeout   900;  
      proxy_read_timeout   900;  
      proxy_buffer_size    40k;  
      proxy_buffers      40 320k;  
      proxy_busy_buffers_size 640k;  
      proxy_temp_file_write_size 640k;  
      if ( !-e $request_filename)  
      {  
         proxy_pass http://elinktech.cn;#榛樿80绔彛  
      }  
  }   
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
     location /api {
          proxy_pass http://elinktech.cn:9005;
	  proxy_http_version 1.1;
	  proxy_set_header Upgrade $http_upgrade;
	  proxy_set_header Connection "upgrade";	
       }
    location /daohang.html {
          proxy_pass http://elinktech.cn/#/;
          proxy_redirect default;
       }
     location /shop.html {
          proxy_pass http://elinktech.cn/#/shophome;
          proxy_redirect default;
       }

    #error_page  404              /404.html;
    # redirect server error pages to the static page /50x.html
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
    
    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}
    
    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}
    
    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}

/nginx/default/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
server {
    listen       80;
    listen  [::]:80;
    server_name elinktech.cn  localhost;

    #charset koi8-r;
    #access_log  /var/log/nginx/host.access.log  main;

  #location ~ .*\.(gif|jpg|jpeg|png)$ {  
  #  expires 24h;  
  #    root /yxtl/data/; 
  #    access_log /usr/local/websrv/nginx-1.9.4/logs/images.log; 
  #    proxy_store on;  
  #    proxy_store_access user:rw group:rw all:rw;  
  #    proxy_temp_path     /home/images/ 
  #    proxy_redirect     off;  
  #    proxy_set_header    Host 127.0.0.1;  
  #    client_max_body_size  10m;  
  #    client_body_buffer_size 1280k;  
  #    proxy_connect_timeout  900;  
  #    proxy_send_timeout   900;  
  #    proxy_read_timeout   900;  
  #    proxy_buffer_size    40k;  
  #    proxy_buffers      40 320k;  
  #    proxy_busy_buffers_size 640k;  
  #    proxy_temp_file_write_size 640k;  
  #    if ( !-e $request_filename)  
  #    {  
  #       proxy_pass http://elinktech.cn; 
  #    }  
  #}   
    location / {
        root   /yxtl/data/shop;
        index  index.html index.htm;
    }
    
    location /api/yxtl/data/ {
        alias   /yxtl/data/;
        index  index.html index.htm;
    }
    
       location /api {
        proxy_pass http://elinktech.cn:9005;
    	  proxy_http_version 1.1;
    	  proxy_set_header Upgrade $http_upgrade;
    	  proxy_set_header Connection "upgrade";	
     }
    
    location /daohang.html {
          proxy_pass http://elinktech.cn/#/;
          proxy_redirect default;
       }
     location /shop.html {
          proxy_pass http://elinktech.cn/#/shophome;
          proxy_redirect default;
       }
    
    location /about.html {
          proxy_pass http://elinktech.cn/#/auth/index;
          proxy_redirect default;
       }
    
    #error_page  404              /404.html;
    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
    
    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}
    
    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}
    
    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}

/nginx/guanwang.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server {
    listen       80;
    listen  [::]:80;
    server_name  www.elinktek.com.cn elinktek.com.cn;

    location / {
        root /yxtl/data/myindex/index;
        index index.html index.htm;
    }
    location /mystatics/ {
   		alias  /yxtl/data/myindex/mystatics/;
    }
    
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

/root/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
user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/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  /var/log/nginx/access.log  main;
    
    sendfile        on;
    #tcp_nopush     on;
    
    keepalive_timeout  65;
    
    #gzip  on;
    
    include /etc/nginx/conf.d/*.conf;
}

/root/nginx/conf/default.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
server {
    listen       80;
    listen  [::]:80;
    server_name  localhost;

    #charset koi8-r;
    #access_log  /var/log/nginx/host.access.log  main;
    
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
     location /api {
          proxy_pass http://elinktech.cn:9005;
          proxy_redirect default;
       }
    location /daohang.html {
          proxy_pass http://39.101.193.57/#/;
          proxy_redirect default;
       }
     location /shop/index {
          proxy_pass http://39.101.193.57/#/shophome;
          proxy_redirect default;
       }
    
    #error_page  404              /404.html;
    
    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
    
    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}
    
    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}
    
    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}

/etc/nginx/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
# For more information on configuration, see:
#   * Official English Documentation: http://nginx.org/en/docs/
#   * Official Russian Documentation: http://nginx.org/ru/docs/

user root;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/doc/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
   	use epoll;
}

http {
    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;
    
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;
    
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
    
    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include
    # for more information.
    include /etc/nginx/conf.d/*.conf;
    proxy_next_upstream error;

    upstream tornado{
        server 127.0.0.1:8081;
    }
    upstream admin{
        server 127.0.0.1:8080;
    }
    
    server {
        listen       80 default_server;
        # listen       [::]:80 default_server;
        server_name  www.elinktech.cn;
        root         /usr/share/nginx/html;
    
  # Load configuration files for the default server block.
  include /etc/nginx/default.d/*.conf;
    location /admin {
        proxy_pass  http://admin ;
        }
        location /static/admin {
        alias /root/project_helmet/tornado_admin/mystatics;
                if ($query_string) {
                    expires max;
                }
        }
    
        location /static {
        alias /root/project_helmet/weixin_0.1/mystatics;
                if ($query_string) {
                    expires max;
                }
        }
    
        location / {
        proxy_pass  http://tornado ;
        }
    
        error_page 404 /404.html;
        location = /404.html {
        }
    
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
        }
    }

# Settings for a TLS enabled server.
#
#    server {
#        listen       443 ssl http2 default_server;
#        listen       [::]:443 ssl http2 default_server;
#        server_name  _;
#        root         /usr/share/nginx/html;
#
#        ssl_certificate "/etc/pki/nginx/server.crt";
#        ssl_certificate_key "/etc/pki/nginx/private/server.key";
#        ssl_session_cache shared:SSL:1m;
#        ssl_session_timeout  10m;
#        ssl_ciphers HIGH:!aNULL:!MD5;
#        ssl_prefer_server_ciphers on;
#
#        # Load configuration files for the default server block.
#        include /etc/nginx/default.d/*.conf;
#
#        location / {
#        }
#
#        error_page 404 /404.html;
#        location = /404.html {
#        }
#
#        error_page 500 502 503 504 /50x.html;
#        location = /50x.html {
#        }
#    }

}

/etc/nginx/nginx.conf.default

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
#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;
    
    #gzip  on;
    
    server {
        listen       80;
        server_name  localhost;
    
        #charset koi8-r;
    
        #access_log  logs/host.access.log  main;
    
        location / {
            root   html;
            index  index.html index.htm;
        }
    
        #error_page  404              /404.html;
    
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    
        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}
    
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}
    
        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;
    
    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;
    
    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;
    
    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;
    
    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;
    
    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

nginx部署静态网站

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
server {
    listen       80;
    listen  [::]:80;
    server_name  www.elinktek.com.cn;

    #charset koi8-r;
    #access_log  /var/log/nginx/host.access.log  main;
    
    location / {
        root   /usr/share/nginx/mystatics;
        index  index.html; 
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;

}

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
server {
listen 80 default_server;#只能配一个默认监听
servername aa.com;

server_name_in_redirect off;
    proxy_set_header Host $host:$server_port;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header REMOTE-HOST $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

access_log  /home/wwwlogs/access_default.log;

location / {            
    proxy_pass http://localhost:8080;
    }
}

server {
listen 80;
server_name bb.com;

server_name_in_redirect off;
    proxy_set_header Host $host:$server_port;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header REMOTE-HOST $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

location / {            
    proxy_pass http://localhost:8008;
    }
}

另：

Nginx 是一个高性能的 HTTP 和反向代理服务器，特点是占用内存少，并发能力强，事实上 Nginx 的并发能力确实在同类型的网页服务器中表现较好。Nginx 专为性能优化而开发，性能是其最重要的要求，十分注重效率，有报告 Nginx 能支持高达 50000 个并发连接数。

01

Nginx 知识网结构图

Nginx 的知识网结构图如下：

图片

02

反向代理

正向代理：局域网中的电脑用户想要直接访问网络是不可行的，只能通过代理服务器来访问，这种代理服务就被称为正向代理。

图片

反向代理：客户端无法感知代理，因为客户端访问网络不需要配置，只要把请求发送到反向代理服务器，由反向代理服务器去选择目标服务器获取数据，然后再返回到客户端。

此时反向代理服务器和目标服务器对外就是一个服务器，暴露的是代理服务器地址，隐藏了真实服务器 IP 地址。

图片

03

负载均衡

客户端发送多个请求到服务器，服务器处理请求，有一些可能要与数据库进行交互，服务器处理完毕之后，再将结果返回给客户端。

普通请求和响应过程如下图：

图片

但是随着信息数量增长，访问量和数据量飞速增长，普通架构无法满足现在的需求。

我们首先想到的是升级服务器配置，可以由于摩尔定律的日益失效，单纯从硬件提升性能已经逐渐不可取了，怎么解决这种需求呢？

我们可以增加服务器的数量，构建集群，将请求分发到各个服务器上，将原来请求集中到单个服务器的情况改为请求分发到多个服务器，也就是我们说的负载均衡。

图解负载均衡：

图片

假设有 15 个请求发送到代理服务器，那么由代理服务器根据服务器数量，平均分配，每个服务器处理 5 个请求，这个过程就叫做负载均衡。

**04
**

动静分离

为了加快网站的解析速度，可以把动态页面和静态页面交给不同的服务器来解析，加快解析的速度，降低由单个服务器的压力。

动静分离之前的状态：

图片

动静分离之后：

图片

**06
**

Nginx安装

Nginx 如何在 Linux 安装

参考链接：

1
https://blog.csdn.net/yujing1314/article/details/97267369

Nginx 常用命令

查看版本：

1
./nginx -v

启动：

1
./nginx

关闭（有两种方式，推荐使用 ./nginx -s quit）：

1
2
./nginx -s stop
./nginx -s quit

重新加载 Nginx 配置：

1
./nginx -s reload

Nginx 的配置文件

配置文件分三部分组成：

①全局块

从配置文件开始到 events 块之间，主要是设置一些影响 Nginx 服务器整体运行的配置指令。

并发处理服务的配置，值越大，可以支持的并发处理量越多，但是会受到硬件、软件等设备的制约。

图片

②events 块

影响 Nginx 服务器与用户的网络连接，常用的设置包括是否开启对多 workprocess 下的网络连接进行序列化，是否允许同时接收多个网络连接等等。

支持的最大连接数：

图片

③HTTP 块

诸如反向代理和负载均衡都在此配置。

1
2
3
location[ = | ~ | ~* | ^~] url{

}

location 指令说明，该语法用来匹配 url，语法如上：

  • =：用于不含正则表达式的 url 前，要求字符串与 url 严格匹配，匹配成功就停止向下搜索并处理请求。
  • ~：用于表示 url 包含正则表达式，并且区分大小写。
  • ~*：用于表示 url 包含正则表达式，并且不区分大小写。
  • ^~：用于不含正则表达式的 url 前，要求 Nginx 服务器找到表示 url 和字符串匹配度最高的 location 后，立即使用此 location 处理请求，而不再匹配。
  • 如果有 url 包含正则表达式，不需要有 ~ 开头标识。

07

反向代理实战

①配置反向代理

目的：在浏览器地址栏输入地址 www.123.com 跳转 Linux 系统 Tomcat 主页面。

②具体实现

先配置 Tomcat，因为比较简单，此处不再赘叙，并在 Windows 访问：

图片

具体流程如下图：

图片

修改之前：

图片

配置如下：

图片

再次访问：

图片

③反向代理 2

目标：

准备：配置两个 Tomcat，端口分别为 8080 和 8081，都可以访问，端口修改配置文件即可。

图片

图片

新建文件内容分别添加 8080！！！和 8081！！！

图片

图片

响应如下图：

图片

图片

具体配置如下：

图片

重新加载 Nginx：

1
./nginx -s reload

访问：

图片

图片

实现了同一个端口代理，通过 edu 和 vod 路径的切换显示不同的页面。

**
**

反向代理小结

第一个例子：浏览器访问 www.123.com，由 host 文件解析出服务器 ip 地址
192.168.25.132 www.123.com。

然后默认访问 80 端口，而通过 Nginx 监听 80 端口代理到本地的 8080 端口上，从而实现了访问 www.123.com，最终转发到 tomcat 8080 上去。

第二个例子：

实际上就是通过 Nginx 监听 9001 端口，然后通过正则表达式选择转发到 8080 还是 8081 的 Tomcat 上去。

**08
**

负载均衡实战

①修改 nginx.conf，如下图：

图片

图片

②重启 Nginx：

1
./nginx -s reload

③在 8081 的 Tomcat 的 webapps 文件夹下新建 edu 文件夹和 a.html 文件，填写内容为 8081！！！！

④在地址栏回车，就会分发到不同的 Tomcat 服务器上：

图片

图片

负载均衡方式如下：

  • 轮询（默认）。
  • weight，代表权，权越高优先级越高。
  • fair，按后端服务器的响应时间来分配请求，相应时间短的优先分配。
  • ip_hash，每个请求按照访问 ip 的 hash 结果分配，这样每一个访客固定的访问一个后端服务器，可以解决 Session 的问题。

图片

图片

图片

09

动静分离实战

什么是动静分离？把动态请求和静态请求分开，不是讲动态页面和静态页面物理分离，可以理解为 Nginx 处理静态页面，Tomcat 处理动态页面。

动静分离大致分为两种：

  • 纯粹将静态文件独立成单独域名放在独立的服务器上，也是目前主流方案。
  • 将动态跟静态文件混合在一起发布，通过 Nginx 分开。

动静分离图析：

图片

实战准备，准备静态文件：

图片

图片

配置 Nginx，如下图：

图片

Nginx 高可用

如果 Nginx 出现问题：

图片

解决办法：

图片

前期准备：

  • 两台 Nginx 服务器
  • 安装 Keepalived
  • 虚拟 ip

安装 Keepalived：

1
2
3
[root@192 usr]# yum install keepalived -y
[root@192 usr]# rpm -q -a keepalived
keepalived-1.3.5-16.el7.x86_64

修改配置文件：

1
2
[root@192 keepalived]# cd /etc/keepalived
[root@192 keepalived]# vi keepalived.conf

分别将如下配置文件复制粘贴，覆盖掉 keepalived.conf，虚拟 ip 为 192.168.25.50。

对应主机 ip 需要修改的是：

  • smtp_server 192.168.25.147（主）smtp_server 192.168.25.147（备）
  • state MASTER（主） state BACKUP（备）
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
global_defs {
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   notification_email_from Alexandre.Cassen@firewall.loc
   smtp_server 192.168.25.147
   smtp_connect_timeout 30
   router_id LVS_DEVEL # 访问的主机地址
}

vrrp_script chk_nginx {
  script "/usr/local/src/nginx_check.sh"  # 检测文件的地址
  interval 2   # 检测脚本执行的间隔
  weight 2   # 权重
}

vrrp_instance VI_1 {
    state BACKUP    # 主机MASTER、备机BACKUP    
    interface ens33   # 网卡
    virtual_router_id 51 # 同一组需一致
    priority 90  # 访问优先级，主机值较大，备机较小
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.25.50  # 虚拟ip
    }
}

启动代码如下：

1
[root@192 sbin]# systemctl start keepalived.service

图片

访问虚拟 ip 成功：

图片

关闭主机 147 的 Nginx 和 Keepalived，发现仍然可以访问。

原理解析

图片

如下图，就是启动了一个 master，一个 worker，master 是管理员，worker是具体工作的进程。

图片

worker 如何工作？如下图：

图片

worker 数应该和 CPU 数相等；一个 master 多个 worker 可以使用热部署，同时 worker 是独立的，一个挂了不会影响其他的。

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一起加油吧！