Nginx 站点与认证

Nginx 站点与认证

Nginx制作下载站点

首先我们先要清楚什么是下载站点?

我们先来看一个网站 http://nginx.org/download/

这个是大家去下载 Nginx 时经常访问的网站,该网站主要就是用来提供用户来下载相关资源的网站,就叫做下载网站。

image

如何制作一个下载站点:

  • Nginx 使用的是模块 ngx_http_autoindex_module 来实现的(自带),该模块处理以斜杠(『 / 』)结尾的请求,并生成目录列表。

  • Nginx 编译的时候会自动加载该模块,但是该模块默认是关闭的,我们需要使用下来指令来完成对应的配置

autoindex

autoindex 指令启用或禁用目录列表的输出

语法 默认值 位置
autoindex <on | off>; autoindex off; http、server、location

autoindex_exact_size

autoindex_exact_size 指令对应 HTLM 格式,指定是否在目录列表展示文件的详细大小。

默认为 on,显示出文件的确切大小,单位是 bytes。

改为 off 后,显示出文件的大概大小,单位是 kB 或者 MB 或者 GB。

语法 默认值 位置
autoindex_exact_size <on | off>; autoindex_exact_size on; http、server、location

autoindex_format

autoindex_format 指令设置目录列表的格式。

语法 默认值 位置
autoindex_format <html | xml | json | jsonp>; autoindex_format html; http、server、location

只有当 autoindex_format 指令设置为 html 时候,上方的 autoindex_exact_size 指令才会起作用。

该指令在 1.7.9 及以后版本中出现。

autoindex_localtime

autoindex_localtime 指令对应 HTML 格式,是否在目录列表上显示时间。

默认为 off,显示的文件时间为 GMT 时间。

改为 on 后,显示的文件时间为文件的服务器时间。

语法 默认值 位置
autoindex_localtime <on |off>; autoindex_localtime off; http、server、location

实现案例

自行准备几个文件或者压缩包,我这里准备了 4 个用过的压缩包。

  • 创建一个目录,将压缩包放入其中,我这里创建的路径是 /opt/download
1
mkdir /opt/download
  • 然后把压缩包都放到该目录下

效果如下:

1
2
3
4
5
6
7
8
[root@master download]# pwd
/opt/download
[root@master download]# ll
总用量 545504
-rw-r--r--. 1 root root 408587111 3月 12 22:02 hadoop-2.10.1.tar.gz
-rw-r--r--. 1 root root 145520298 3月 12 21:29 jdk-8u301-linux-x64.tar.gz
-rw-r--r-- 1 root root 25680 4月 27 2017 mysql57-community-release-el7-11.noarch.rpm
-rw-r--r-- 1 root root 4456335 5月 9 19:40 mysql-connector-java-5.1.48.tar.gz
  • 打开 Nginx 的配置文件
1
vim /usr/local/nginx/conf/nginx.conf
  • 添加配置如下内容:

有注释版

1
2
3
4
5
6
7
8
9
10
11
location /download {
root /opt; # 下载目录所在的路径,location 后面的 /download 拼接到 /opt 后面
# 以这些后缀的文件点击后为下载,注释掉则 txt 等文件是在网页打开并查看内容
if ($request_filename ~* ^.*?\.(txt|doc|pdf|rar|gz|zip|docx|exe|xlsx|ppt|pptx|conf)$){
add_header Content-Disposition 'attachment;';
}
autoindex on; # 启用目录列表的输出
autoindex_exact_size on; # 在目录列表展示文件的详细大小
autoindex_format html; # 设置目录列表的格式为 html
autoindex_localtime on; # 目录列表上显示系统时间
}

无注释版

1
2
3
4
5
6
7
8
9
10
11
location /download {
root /opt;

if ($request_filename ~* ^.*?\.(txt|doc|pdf|rar|gz|zip|docx|exe|xlsx|ppt|pptx|conf)$){
add_header Content-Disposition 'attachment;';
}
autoindex on;
autoindex_exact_size on;
autoindex_format html;
autoindex_localtime on;
}

注意

root 指令后面必须是下载路径,因为我的下载路径是 /opt/download,所以这里填写 /opt,而 location 的 /download 会自动拼接到后面,形成完整的下载路径。

  • 访问 192.168.91.200/download

image

  • JSON和XML格式(一般不用这两种格式)

image

image

Nginx用户认证模块

对应系统资源的访问,我们往往需要限制谁能访问,谁不能访问。这块就是我们通常所说的认证部分,认证需要做的就是根据用户输入的用户名和密码来判定用户是否为合法用户,如果是则放行访问,如果不是则拒绝访问。

Nginx 对应用户认证这块是通过 ngx_http_auth_basic_module 模块来实现的,它允许通过使用「HTTP基本身份验证」协议验证用户名和密码来限制对资源的访问。默认情况下 Nginx 是已经安装了该模块,如果不需要则使用 --without-http_auth_basic_module 删除认证模块。

该模块的指令比较简单。

auth_basic

auth_basic 指令使用「HTTP基本身份验证」协议启用用户名和密码的验证。默认关闭。

语法 默认值 位置
auth_basic <string | off>; auth_basic off; http、server、location、limit_except

开启后,服务端会返回 401,指定的字符串会返回到客户端,给用户以提示信息,但是不同的浏览器对内容的展示不一致。

auth_basic_user_file

auth_basic_user_file 指令指定用户名和密码所在文件,包括所在的路径。

语法 默认值 位置
auth_basic_user_file ; http、server、location、limit_except

指定文件路径,该文件中设置用户名和密码,密码需要进行加密。可以采用工具自动生成。

实现案例

  • 在配置文件 nginx.conf 添加如下内容:

有注释版

1
2
3
4
5
6
7
8
9
10
11
12
location /download{
# 下载站点知识
root /opt; # 下载目录所在的路径,location 后面的 /download 拼接到 /opt 后面
autoindex on; # 启用目录列表的输出
autoindex_exact_size on; # 在目录列表展示文件的详细大小
autoindex_format html; # 设置目录列表的格式为 html
autoindex_localtime on; # 目录列表上显示系统时间

# 认证模块知识
auth_basic 'please input your auth'; # 启用户名和密码的验证,并在请求头插入数据
auth_basic_user_file htpasswd; # 存用户名和密码的文件路径
}

无注释版

1
2
3
4
5
6
7
8
9
10
11
12
location /download{

root /opt;
autoindex on;
autoindex_exact_size on;
autoindex_format html;
autoindex_localtime on;


auth_basic 'please input your auth';
auth_basic_user_file htpasswd;
}
  • 我们需要使用 htpasswd 工具生成包含用户名和密码的文件
1
yum install -y httpd-tools

该工具基本操作指令如下:

1
2
3
4
htpasswd -c /usr/local/nginx/conf/htpasswd username   # 创建一个新文件记录用户名和密码,密码后面弹出输入
htpasswd -b /usr/local/nginx/conf/htpasswd username password # 在指定文件新增一个用户名和密码
htpasswd -D /usr/local/nginx/conf/htpasswd username # 从指定文件删除一个用户信息
htpasswd -v /usr/local/nginx/conf/htpasswd username # 验证用户名和密码是否正确

根据需求指定生成路径的位置。

  • 我们创建一个 frx 的用户名,密码是 123456

image

可以查看生成的文件内容

1
2
[root@master conf]# cat /usr/local/nginx/conf/htpasswd
frx:$apr1$wDXdSh0O$yR66Agylnta9zupO7cD3k.
  • 浏览器访问 192.168.91.200/downloadimage

上述方式虽然能实现用户名和密码的验证,但是大家也看到了,所有的用户名和密码信息都记录在文件里面,如果用户量过大的话,这种方式就显得有点麻烦了,这时候我们就得通过后台业务代码来进行用户权限的校验了。


Nginx 缓存集成

Nginx 缓存集成

缓存的概念

缓存就是数据交换的缓冲区(称作:Cache),当用户要获取数据的时候,会先从缓存中去查询获取数据,如果缓存中有就会直接返回给用户,如果缓存中没有,则会发请求从服务器重新查询数据,将数据返回给用户的同时将数据放入缓存,下次用户就会直接从缓存中获取数据。

image

缓存其实在很多场景中都有用到,比如:

场景 作用
操作系统磁盘缓存 减少磁盘机械操作
数据库缓存 减少文件系统的IO操作
应用程序缓存 减少对数据库的查询
Web 服务器缓存 减少对应用服务器请求次数
浏览器缓存 减少与后台的交互次数

缓存的优点

  • 减少数据传输,节省网络流量,加快响应速度,提升用户体验
  • 减轻服务器压力
  • 提供服务端的高可用性

缓存的缺点

  • 数据的不一致
  • 增加成本

image

静态资源部署 - 缓存配置 的时候,我们学习了如何在浏览器进行缓存,而本内容学习的是 Nginx。

Nginx 作为 Web 服务器,Nginx 作为 Web 缓存服务器,它介于客户端和应用服务器之间,当用户通过浏览器访问一个 URL 时,Web 缓存服务器会去应用服务器获取要展示给用户的内容,将内容缓存到自己的服务器上,当下一次请求到来时,如果访问的是同一个 URL,Web 缓存服务器就会直接将之前缓存的内容返回给客户端,而不是向应用服务器再次发送请求。Web 缓存降低了应用服务器、数据库的负载,减少了网络延迟,提高了用户访问的响应速度,增强了用户的体验。

Web缓存服务

Nginx 是从 0.7.48 版开始提供缓存功能。Nginx 是基于 Proxy Store 来实现的,其原理是把 URL 及相关组合当做 Key,在使用 MD5 算法对 Key 进行哈希化,得到硬盘上对应的哈希目录路径,从而将缓存内容保存在该目录中。它可以支持任意 URL 连接,同时也支持 404/301/302 这样的非200 状态码。Nginx 即可以支持对指定 URL 或者状态码设置过期时间,也可以使用 purge 命令来手动清除指定 URL 的缓存。

image

缓存设置相关指令

Nginx 的 Web 缓存服务主要是使用 ngx_http_proxy_module 模块相关指令集来完成,接下来我们把常用的指令来进行介绍下。

ngx_http_proxy_module 文档地址

proxy_cache_path

该指定用于设置缓存文件的存放路径。

语法 默认值 位置
proxy_cache_path <path> [levels=number]
<keys_zone=zone_name:zone_size> [inactive=time][max_size=size];
http

path:缓存路径地址,如:

1
/usr/local/proxy_cache

levels: 指定该缓存空间 path 基础上新建的目录,最多可以设置 3 层,每层取 1 到 2 个字母作为目录名,格式为:

1
2
3
levels=num:num:num   # 三个 num 代表三层,每层目录名分别取 num 个字母
levels=num:num # 两个 num 代表两层,每层目录名分别取 num 个字母
levels=num # 一个 num 代表一层,每层目录名分别取 num 个字母

如:

1
levels=1:2   # 缓存空间有两层目录,第一层目录名取 1 个字母,第二层目录名取 2 个字母

字母名从 MD5 加密的值后面往前截取。

举例说明:

1
2
3
4
# 假设 proxy_cache_key 为 kele,通过 MD5 加密以后的值为 27ce47ea65c1381dbe5175f7c77d8a3a
levels=1:2 # 最终的存储路径为 /usr/local/proxy_cache/a/a3,每层截取个数根据 1:2
levels=2:1:2 # 最终的存储路径为 /usr/local/proxy_cache/3a/a/d8,每层截取个数根据 2:1:2
levels=2:2:2 # 最终的存储路径为 /usr/local/proxy_cache/3a/8a/7d,每层截取个数根据 2:2:2

还不理解吗?存储路径在 path 目录基础上再创建新的目录,新的目录名从加密后的值的后面往前面截取。

keys_zone:用来为这个存key的缓存区设置名称和指定大小,如:

1
keys_zone=kele:200m  # 缓存区的名称是 kele,大小为 200M,1M 大概能存储 8000 个 keys

inactive:指定的时间内未访问的缓存数据会从缓存中删除,默认情况下,inactive 设置为 10 分钟。如:

1
inactive=1d   # 缓存数据在 1 天内没有被访问就会被删除

max_size:设置最大缓存空间,如果缓存空间存满,默认会覆盖缓存时间最长的资源,默认单位为兆。如:

1
max_size=20g    # 最大缓存空间为 20G

配置实例:

1
2
3
http{
proxy_cache_path /usr/local/proxy_cache keys_zone=kele:200m levels=1:2:1 inactive=1d max_size=20g;
}

此时重启 Nginx 配置文件,发现 /usr/local 目录里多出一个目录,名字叫做 proxy_cache。

proxy_cache

该指令用来开启或关闭代理缓存,如果是开启则自定使用哪个缓存区来进行缓存。默认关闭。

语法 默认值 位置
proxy_cache <zone_name | off>; proxy_cache off; http、server、location

zone_name:指定使用缓存区的名称。

缓存区的名称必须是 proxy_cache_path 里的 keys_zone 生成的缓存名。

proxy_cache_key

该指令用来设置 Web 缓存的 key 值,Nginx 会根据 key 值利用 MD5 计算处哈希值并缓存起来,作为缓存目录名的参考。

语法 默认值 位置
proxy_cache_key <key>; proxy_cache_key $scheme$proxy_host$request_uri; http、server、location

如 kele 由 MD5 计算出来是 27ce47ea65c1381dbe5175f7c77d8a3a

在哪计算出来的? 前往 MD5 在线加密网站

proxy_cache_valid

该指令用来对不同返回状态码的 URL 设置不同的缓存时间。

语法 默认值 位置
proxy_cache_valid [code …… ] <time>; http、server、location

如:

1
2
3
proxy_cache_valid 200 302 10m; # 为 200 和 302 的响应 URL 设置 10 分钟缓存时间
proxy_cache_valid 404 1m; # 为 404 的响应 URL 设置 1 分钟缓存时间
proxy_cache_valid any 1m; # 对所有响应状态码的URL都设置 1 分钟缓存时间

proxy_cache_min_uses

该指令用来设置资源被访问多少次后才会被缓存。默认是 1 次。

语法 默认值 位置
proxy_cache_min_uses <number>; proxy_cache_min_uses 1; http、server、location

proxy_cache_methods

该指令是设置缓存哪些 HTTP 方法的请求资源。

语法 默认值 位置
proxy_cache_methods <GET | HEAD | POST>; proxy_cache_methods GET HEAD; http、server、location

默认缓存 HTTP 的 GET 和 HEAD 方法的请求资源,不缓存 POST 方法的请求资源。

缓存设置案例

需求分析

image

步骤实现

应用服务器的环境准备

  1. 192.168.200.146 服务器 A 上的 tomcat 的 webapps 下面添加一个 js 目录,并在 js 目录中添加一个 jquery.js 文件

  2. 启动 tomcat

1
2
cd /usr/local/tomcat/bin
./startup.sh
  1. 访问服务器 A 进行测试
1
http://192.168.200.146:8080/js/jquery.js

Nginx 的环境准备

  1. 准备服务器 B 完成 Nginx 的反向代理配置
1
2
3
4
5
6
7
8
9
10
11
12
http{
upstream backend{
server 192.168.200.146:8080; # 服务器 A 地址
}
server {
listen 8080;
server_name localhost;
location / {
proxy_pass http://backend/js/;
}
}
}
  1. 完成 Nginx 缓存配置

有注释版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
http{
proxy_cache_path /usr/local/proxy_cache levels=2:1 keys_zone=bing:200m inactive=1d max_size=20g;
upstream backend{
server 192.168.200.146:8080; # 服务器 A 的地址
}
server {
listen 8080; # 监听 8080 端口
server_name localhost; # 监听 localhost 的IP
location / { # 监听包含 / 的请求
proxy_cache bing; # 开启 bing 缓存区,和第 2 行的 keys_zone 对应
proxy_cache_key kele; # 缓存的 key 值,会被 MD5 解析成字符串用于生成缓存的目录
proxy_cache_min_uses 5; # 资源被访问 5 次后才会被缓存
proxy_cache_valid 200 5d; # 为 200 响应 URL 设置 5 天缓存时间
proxy_cache_valid 404 30s; # 为 404 的响应 URL 设置 30 秒缓存时间
proxy_cache_valid any 1m; # 为除了上方的任意响应 URL 设置 1 分钟缓存时间
add_header nginx-cache "$upstream_cache_status"; # 将缓存的状态放到请求头里
proxy_pass http://backend/js/; # 代理 backend,将 /js/ 追加到 backend 模块里的地址后面
}
}
}

无注释版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
http{
proxy_cache_path /usr/local/proxy_cache levels=2:1 keys_zone=bing:200m inactive=1d max_size=20g;
upstream backend{
server 192.168.200.146:8080;
}
server {
listen 8080;
server_name localhost;
location / {
proxy_cache bing;
proxy_cache_key kele;
proxy_cache_min_uses 5;
proxy_cache_valid 200 5d;
proxy_cache_valid 404 30s;
proxy_cache_valid any 1m;
add_header nginx-cache "$upstream_cache_status";
proxy_pass http://backend/js/;
}
}
}
  1. 测试是否缓存成功

利用 $upstream_cache_status 的值在控制台(F12)查看是否缓存。

第一次访问 192.168.200.113:8080/jquery.js,如图:

image

因为第一次访问时,正在缓存,所以返回的请求头 MISS 是没有缓存成功。

第二次访问 192.168.200.113:8080/jquery.js,如图:

image

HIT 代表成功缓存。

  1. 测试 404 缓存时间

测试 404 缓存时间,我们访问 192.168.200.113:8080/jquery.js111,它会返回 404 页面,并缓存 404 页面,当我们立即访问正确的 192.168.200.113:8080/jquery.js,它依然返回 404 页面,因为 /jquery.js 请求目前被缓存为 404,还没到 30 秒过期,等 30 秒后再访问,就成功了。

缓存的删除

这里介绍两种方式:

  • 删除对应的缓存目录
  • 使用第三方扩展模块

删除缓存目录

假设缓存目录是 /usr/local/proxy_cache/

1
rm -rf /usr/local/proxy_cache/......

如果想删除某个缓存目录,就在后面加上目录名。如果想删除整个缓存目录,直接删除 /usr/local/proxy_cache/ 即可。

ngx_cache_purge删除

使用第三方扩展模块 ngx_cache_purge 进行删除缓存。

  1. 下载 ngx_cache_purge 模块对应的资源包,并上传到服务器的 /root/nginx/module/ 目录下。

    这里的资源包是 ngx_cache_purge-2.3.tar.gz

  2. 对资源文件进行解压缩

1
tar -zxf ngx_cache_purge-2.3.tar.gz
  1. 修改文件夹名称为 purge,方便后期配置
1
mv ngx_cache_purge-2.3 purge
  1. 查询 Nginx 的配置参数 configure arguments,并拷贝出来
1
nginx -V
  1. 进入 Nginx 的安装包目录,使用 ./configure 进行参数配置,记得加上 nginx -V 查询出来的 configure arguments 参数
1
./configure --add-module=/root/nginx/module/purge  # 加上之前的 configure arguments 参数
  1. 使用 make 进行编译
1
make
  1. 将 Nginx 安装目录的 nginx 二级制可执行文件备份
1
mv /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.backup
  1. 将编译后的 objs 中的 nginx 拷贝到 nginx 的 sbin 目录下
1
cp objs/nginx /usr/local/nginx/sbin
  1. 使用 make upgrade 进行升级,记得在安装包目录下执行
1
2
3
cd /opt/nginx/core/nginx-1.20.2

make upgrade
  1. 在 Nginx 配置文件中进行如下配置
1
2
3
4
5
server{
location ~/purge(/.*) {
proxy_cache_purge bing kele;
}
}

proxy_cache_purge 指令

语法 默认值 位置
proxy_cache_purge <cache> <key> - http、server、location

资源不缓存

前面咱们已经完成了 Nginx 作为 Web 缓存服务器的使用。但是我们得思考一个问题,不是所有的数据都适合进行缓存。比如说对于一些经常发生变化的数据。如果进行缓存的话,就很容易出现用户访问到的数据不是服务器真实的数据。所以对于这些资源我们在缓存的过程中就需要进行过滤,不进行缓存。

Nginx 也提供了这块的功能设置,需要使用到如下两个指令:

  • proxy_no_cache
  • proxy_cache_bypass

proxy_no_cache

该指令是用来定义不将数据进行缓存的条件,也就是不缓存指定的数据。

语法 默认值 位置
proxy_no_cache <string> …… ; http、server、location

可设置多个 string。

配置实例:

1
proxy_no_cache $cookie_nocache $arg_nocache $arg_comment;

proxy_cache_bypass

该指令是用来设置不从缓存中获取数据的条件,也就是虽然缓存了指定的资源,但请求过来也不会去获取它,而是去服务器里获取资源。

语法 默认值 位置
proxy_cache_bypass <string> …… ; http、server、location

可设置多个 string。

配置实例:

1
proxy_cache_bypass $cookie_nocache $arg_nocache $arg_comment;

上述两个指令都有一个指定的条件,这个条件可以是多个,并且多个条件中至少有一个不为空且不等于「0」,则条件满足成立。

上面给的配置实例是从官方网站获取的,里面使用到了三个变量,分别是 $cookie_nocache$arg_nocache$arg_comment

常用不缓存变量

常用不缓存的三个变量分别为:

  • $cookie_nocache
  • $arg_nocache
  • $arg_comment

这三个变量分别代表的含义是:

  • $cookie_nocache:指的是当前请求的 cookie 中 key 为 nocache 的 value 值
  • $arg_nocache$arg_comment:指的是当前请求的参数中属性名为 nocache 和 comment 对应的属性值

案例演示:

1
2
3
4
5
6
7
8
9
10
11
log_format params $cookie_nocache | $arg_nocache | $arg_comment
server {
listen 8081;
server_name localhost;
location / {
access_log logs/access_params.log params;
add_header Set-Cookie 'nocache=888';
root html;
index index.html;
}
}

访问 192.168.200.133:8081?nocache=999&comment=777,然后去日志查看结果,如图所示:

image

以后访问的某一个资源如果不想缓存,在 URL 后面加入三个变量中的任意一个或多个即可,只要它们不为空或 0。

这三个变量推荐作为不缓存资源的条件,但并不是只能作为不缓存资源的条件。

案例模板

设置不缓存资源的配置方案模板:

  • 如果访问的是 js 文件,则不会缓存该 js 文件
  • 如果 $nocache $cookie_nocache $arg_nocache $arg_comment 任意不为空或 0,则访问的资源不进行缓存
1
2
3
4
5
6
7
8
9
10
11
server {
listen 8080;
server_name localhost;
location / {
if ($request_uri ~ /.*\.js$){
set $nocache 1;
}
proxy_no_cache $nocache $cookie_nocache $arg_nocache $arg_comment;
proxy_cache_bypass $nocache $cookie_nocache $arg_nocache $arg_comment;
}
}

为什么不会缓存 js 文件呢,看第 5 - 6 行代码。如果访问的文件是 js 文件,则设置 $nocache 为 1,只要它不为 0,则触发第 8 行代码,proxy_no_cache 后面的参数只要有一个不为空或 0,则访问的资源不进行缓存。


补充

proxy_cache_path设置缓存路径,其中有一个inactive参数设置cache设置不活跃缓存的删除时间。
proxy_cache_valid设置不同响应码的缓存过期时间。

提出问题

那么这俩参数同时设置,哪个生效呢?

根据上面Stack Overflow的说法。inactive应该需要设置的比valid中时间长。

注意,inactive时间到了,数据删除。valid过期了数据不会删除。有请求,inactive就刷新计时,valid不变。没请求,inactive和valid都不变。

分析各种情况:

1、inactive设置1m,valid设置1h
首先,请求进来,cache出现,两个时间开始倒计时。
情况一:不断请求这个cache,inactive不断刷新1m倒计时,直到到达1h,valid过期。这时你去请求了一次,nginx重新去读取服务器数据,刷新valid倒计时。期间数据一直在缓存里。不请求,就再过1m删掉。
情况二:两次请求间隔超过了1min,inactive生效,删除了这个cache数据,没了。你再请求,相当于重新去服务器拿了一次数据,inactive和valid倒计时都会重新刷新,不请求,cache里就没有这份数据了

2、inactive设置1m,valid设置1m
首先,请求进来,cache出现,两个时间开始倒计时。
情况一:1m内不请求,最后inactive生效删掉。不请求就没缓存了,请求了一次,重新从服务器读取一份,两个计时刷新。
情况二:1m内请求了一次,inactive时间刷新,但是valid还在计时,所以1m到了后,缓存过期了。你再请求就重新从服务器读取一份,刷新计时。不请求,就等待1m,由inactive生效删除了缓存

3、inactive设置1h,valid设置了1m
首先,请求进来,cache出现,两个时间开始倒计时。
过了1m,缓存过期,数据在没删掉。不请求,直到1h到,inactive删掉缓存。请求了一次,重新从服务器读取,刷新两个计时。

所以,结论inactive应该需要设置的比valid中时间长。
目的是针对,一个长期不使用的缓存数据,把他删掉不占用存储,或者强制刷新。

  • inactive是针对两次请求间隔时间,到时间就删掉不占用内存。
  • valid是针对持续不断的请求,导致一直缓存,我设置时间强制刷新一下。例如,支付宝每时每刻都有人访问,一直请求,缓存就一直不刷新一直是旧的。

inactive和valid是配合使用,不是谁时间短覆盖谁的关系。


Nginx 负载均衡

Nginx 负载均衡

负载均衡

负载均衡是实际开发必须掌握的技能,Nginx 如何将少数请求跟多台服务器进行沟通,让每一台服务器的请求处理面面俱到?本内容将学习 Nginx 的负载均衡知识。

负载均衡概述

早期的网站流量和业务功能都比较简单,单台服务器足以满足基本的需求,但是随着互联网的发展,业务流量越来越大并且业务逻辑也跟着越来越复杂,单台服务器的性能及单点故障问题就凸显出来了,因此需要多台服务器进行性能的水平扩展及避免单点故障出现。那么如何将不同用户的请求流量分发到不同的服务器上呢?这就需要负载均衡来处理。

image

负载均衡原理及处理流程

系统的扩展可以分为纵向扩展和横向扩展。

  • 纵向扩展是从单机的角度出发,通过增加系统的硬件处理能力来提升服务器的处理能力
  • 横向扩展是通过添加机器来满足大型网站服务的处理能力

image

如上图,负载均衡涉及到两个重要的角色分别是「应用集群」和「负载均衡器」。

  • 应用集群:将同一应用部署到多台机器上,组成处理集群,接收负载均衡设备分发的请求,进行处理并返回响应的数据
  • 负载均衡器:将用户访问的请求根据对应的负载均衡算法,分发到集群中的一台服务器进行处理

负载均衡作用

  • 解决服务器的高并发压力,提高应用程序的处理性能
  • 提供故障转移,实现高可用
  • 通过添加或减少服务器数量,增强网站的可扩展性
  • 在负载均衡器上进行过滤,可以提高系统的安全性

负载均衡常用处理方式

先说明,我们常用的是 四/七层负载均衡 方式,前面两个方式可以了解。

用户手动选择

这种方式比较原始,主要实现的方式就是在网站主页上面提供不同线路、不同服务器链接方式,让用户来选择自己访问的具体服务器,来实现负载均衡。

如下图,用户点击不同的下载方式,就会跳转到不同的下载地址。这是主动式的负载均衡,我们无法控制用户的选择。如果用户全部点击第一个下载方式,那么服务器的压力将非常大。

image

DNS轮询方式

DNS:域名系统(服务)协议(DNS)是一种分布式网络目录服务,主要用于域名与 IP 地址的相互转换。

大多域名注册商都支持对同一个主机名添加多条 A 记录,这就是 DNS 轮询,DNS 服务器将解析请求按照 A 记录的顺序,随机分配到不同的 IP 上,这样就能完成简单的负载均衡。DNS 轮询的成本非常低,在一些不重要的服务器,被经常使用。

如下图:客户端如果想访问服务器集群,首先去 DNS 服务器获取我们曾经在 DNS 服务器保存的「记录表」,这个「记录表」将会把某个服务器的地址返回给客户端,客户端再根据这个地址,访问指定的服务器。这个「记录表」在开始期间需要我们去 DNS 服务器进行添加。

image

「记录表」长什么样,如下图的主机记录 www。这是我为某一个域名添加的 IP 地址,用 2 台服务器来做负载均衡。其中两个记录值都绑定了 www.nginx521.cn 地址。(一个域名可以绑定多个IP地址)

image

验证:

1
ping www.nginx521.cn

注意:记得清空本地的 DNS 缓存,如果本地有缓存,无论你怎么 ping,都会 ping 到缓存的服务器地址,无法负载均衡

1
ipconfig/flushdns

目前需要 ping 一次然后清理一次缓存,才能实现负载均衡的轮询效果。

我们发现使用 DNS 来实现轮询,不需要投入过多的成本,虽然 DNS 轮询成本低廉,但是 DNS 负载均衡存在明显的缺点:

  1. 可靠性低

    假设一个域名 DNS 轮询多台服务器,如果其中的一台服务器发生故障,那么所有的访问该服务器的请求将不会有所回应,即使你将该服务器的 IP 从 DNS 中去掉,但是由于各大宽带接入商将众多的 DNS 存放在缓存中,以节省访问时间,导致 DNS 不会实时更新。所以 DNS 轮流上一定程度上解决了负载均衡问题,但是却存在可靠性不高的缺点。

  2. 负载均衡不均衡

    DNS 负载均衡采用的是简单的轮询负载算法,不能区分服务器的差异,不能反映服务器的当前运行状态,不能做到为性能好的服务器多分配请求,另外本地计算机也会缓存已经解析的域名到 IP 地址的映射,这也会导致使用该 DNS 服务器的用户在一定时间内访问的是同一台 Web 服务器,从而引发 Web 服务器减的负载不均衡。

    负载不均衡则会导致某几台服务器负荷很低,而另外几台服务器负荷确很高,处理请求的速度慢,配置高的服务器分配到的请求少,而配置低的服务器分配到的请求多。

四/七层负载均衡

介绍四/七层负载均衡之前,我们先了解一个概念,OSI(open system interconnection),叫开放式系统互联模型,这个是由国际标准化组织 ISO 指定的一个不基于具体机型、操作系统或公司的网络体系结构。该模型将网络通信的工作分为七层。

image

image

  • 应用层:为应用程序提供网络服务。
  • 表示层:对数据进行格式化、编码、加密、压缩等操作
  • 会话层:建立、维护、管理会话连接
  • 传输层:建立、维护、管理端到端的连接,常见的有 TCP/UDP
  • 网络层:IP 寻址和路由选择
  • 数据链路层:控制网络层与物理层之间的通信
  • 物理层:比特流传输

什么是四层负载均衡

所谓四层负载均衡指的是 OSI 七层模型中的传输层,主要是基于 IP + PORT 的负载均衡

实现四层负载均衡的方式:

  • 硬件:F5 BIG-IP、Radware 等,性能好,成本高、无法扩展
  • 软件:LVS、Nginx、Hayproxy 等,性能较好,成本低、可以扩展

什么是七层负载均衡

所谓的七层负载均衡指的是在应用层,主要是基于虚拟的 URL 或主机 IP 的负载均衡

实现七层负载均衡的方式:

  • 软件:Nginx、Hayproxy 等

四层和七层负载均衡的区别

  • 四层负载均衡数据包是在底层就进行了分发,而七层负载均衡数据包则在最顶端进行分发,所以四层负载均衡的效率比七层负载均衡的要高(四层比七层少,速度块,效率高,但是可能请求丢失等)
  • 四层负载均衡不识别域名,而七层负载均衡识别域名

处理四层和七层负载以外,其实还有二层、三层负载均衡,二层是在数据链路层基于 mac 地址来实现负载均衡,三层是在网络层一般采用虚拟 IP 地址的方式实现负载均衡。

实际环境采用的模式:四层负载(LVS) + 七层负载(Nginx)

七层负载均衡

Nginx 要实现七层负载均衡需要用到 proxy_pass 代理模块配置。Nginx 默认安装支持这个模块,我们不需要再做任何处理。Nginx 的负载均衡是在 Nginx 反向代理的基础上把用户的请求根据指定的算法分发到一组「upstream 虚拟服务池」。

七层负载均衡指令

upstream指令

该指令是用来定义一组服务器,它们可以是监听不同端口的服务器,并且也可以是同时监听 TCP 和 Unix socket 的服务器。服务器可以指定不同的权重,默认为 1。

语法 默认值 位置
upstream <name> {…} http

server指令

该指令用来指定后端服务器的名称和一些参数,可以使用域名、IP、端口或者 Unix socket。

语法 默认值 位置
server <name> [paramerters] upstream

server 后的 name 就是 upstream 后的 name,两者保持一致。

七层负载均衡指令案例

准备四台服务器,一台用来做负载均衡器,三台用来接收负载均衡器的请求。

image

因为目前只有两台服务器,所以一台用来做负载均衡器,另外一台用来接收负载均衡器的请求。

服务器设置:这里以三个端口代替三个服务器,在配置文件进行如下配置:

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
# 服务器 1
server {
listen 9001;
server_name localhost;
default_type text/html;
location /{
return 200 '<h1>192.168.200.146:9001</h1>';
}
}
# 服务器 2
server {
listen 9002;
server_name localhost;
default_type text/html;
location /{
return 200 '<h1>192.168.200.146:9002</h1>';
}
}
# 服务器 3
server {
listen 9003;
server_name localhost;
default_type text/html;
location / {
return 200 '<h1>192.168.200.146:9003</h1>';
}
}

负载均衡器设置:这是一个 Nginx 代理服务器,让它去负载均衡访问三个服务器,在配置文件进行如下配置:

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9091;
server 192.168.200.146:9092;
server 192.168.200.146:9093;
}
server {
listen 8083;
server_name localhost;
location / {
proxy_pass http://backend; # backend 要对应上 upstream 后的值,根据需求修改
}
}

访问负载均衡器的地址,如 http://192.168.200.133:8083,它会找到 proxy_pass 后的地址,比如上方,它会根据 backend 找到对应的 upstream 里内地址,替换掉 backend,变成:

  • proxy_pass http://192.168.200.146:9091
  • proxy_pass http://192.168.200.146:9092
  • proxy_pass http://192.168.200.146:9093

但是它不会全部访问三个服务器地址,而是根据自己的算法(轮询)选择其中一个服务器地址。

七层负载均衡状态

代理服务器在负责均衡调度中的状态有以下几个:

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

down

down 指令将该服务器标记为永久不可用,那么负载均衡器将不参与该服务器的负载均衡。

如下,如果不希望负载均衡器以负载均衡来处理 192.168.200.146 服务器:

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001 down;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location / {
proxy_pass http://backend;
}
}

该状态一般会对需要停机维护的服务器进行设置。

backup

backup 指令将该服务器标记为备份服务器,当主服务器不可用时,才用备份服务器来传递请求。

它不同于 down 指令,down 指令将服务器永久禁止,而 backp 指令仅仅临时禁止,当主服务器不可用后,临时禁止的服务器就会站出来。

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001 down;
server 192.168.200.146:9002 backup;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

上方代码中 9001 服务器永久禁止,而 9002 服务器是备份服务器,所以 9003 服务器是主服务器。

此时需要将 9003 端口的访问禁止掉,用它来模拟当唯一对外提供访问的服务宕机以后,backup 的备份服务器就能开始对外提供服务。

为了测试验证,我们需要使用防火墙来进行拦截。

介绍一个工具 firewall-cmd,该工具是 Linux 提供的专门用来操作 firewall 防火墙的。

查询防火墙中指定的端口是否开放

1
firewall-cmd --query-port=9001/tcp

开放一个指定的端口

1
firewall-cmd --permanent --add-port=9002/tcp

批量添加开发端口

1
firewall-cmd --permanent --add-port=9001-9003/tcp

如何移除一个指定的端口

1
firewall-cmd --permanent --remove-port=9003/tcp

重新加载

1
firewall-cmd --reload

其中

  • --permanent 表示设置为持久
  • --add-port 表示添加指定端口
  • --remove-port 表示移除指定端口

经过测试,禁用掉 9003 端口后,再次访问负载均衡器,它只会请求 9002 端口的服务器(备份服务器),而恢复 9003 端口,只会请求 9003 端口的服务器。

max_conns

max_conns 指令用来限制同时连接到 upstream 负载上的单个服务器的最大连接数。默认为 0,表示不限制,使用该配置可以根据后端服务器处理请求的并发量来进行设置,防止后端服务器被压垮。

语法 默认值 位置
max_conns=<number> 0 upstream
  • number 是大于 0 的数字。
1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001 down;
server 192.168.200.146:9002 backup;
server 192.168.200.146:9003 max_conns=2;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

第 4 行配置标识 9003 端口的服务器最大能被 2 个客户端请求。

max_fails和fail_timeout

max_fails 指令设置允许请求代理服务器失败的次数,默认为 1。

fail_timeout 指令设置经过 max_fails 失败后,服务暂停的时间,默认是 10 秒。

语法 默认值 位置
max_fails=<number> 1 upstream
fail_timeout=<time> 10 秒 upstream
  • number 是大于 0 的数字
  • time 是时间,单位为秒
1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.133:9001 down;
server 192.168.200.133:9002 backup;
server 192.168.200.133:9003 max_fails=3 fail_timeout=15;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

七层负载均衡策略

介绍完 Nginx 负载均衡的相关指令后,我们已经能实现将用户的请求分发到不同的服务器上,那么除了采用默认的分配方式以外,我们还能采用什么样的负载算法?

Nginx 的 upstream 支持如下六种方式的分配算法,分别是:

算法名称 说明
轮询 默认方式
weight 权重方式
ip_hash 依据 IP 分配方式
least_conn 依据最少连接方式
url_hash 依据 URL 分配方式
fair 依据响应时间方式

轮询

这是 upstream 模块负载均衡默认的策略。每个请求会按时间顺序逐个分配到不同的后端服务器。轮询不需要额外的配置。

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

weight加权[加权轮询]

weight 指令用来设置服务器的权重,默认为 1,权重数据越大,被分配到请求的几率越大;该权重值,主要是针对实际工作环境中不同的后端服务器硬件配置进行调整的,所有此策略比较适合服务器的硬件配置差别比较大的情况。

语法 默认值 位置
weight=<number> 1 upstream
  • number 是大于 0 的数字
1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001 weight=10;
server 192.168.200.146:9002 weight=5;
server 192.168.200.146:9003 weight=3;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

ip_hash

当对后端的多台动态应用服务器做负载均衡时,ip_hash 指令能够将某个客户端 IP 的请求通过哈希算法定位到同一台后端服务器上。

这样,当来自某一个 IP 的用户在后端 Web 服务器 A 上登录后,在访问该站点的其他 URL,能保证其访问的还是后端 Web 服务器 A

总结:哪个服务器曾经处理过请求,无论在哪里,相同的请求依然让该服务器处理

语法 默认值 位置
ip_hash; upstream
1
2
3
4
5
6
7
8
9
10
11
12
13
upstream backend{
ip_hash;
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

需要额外多说一点的是使用 ip_hash 指令无法保证后端服务器的负载均衡,可能导致有些后端服务器接收到的请求多,有些后端服务器接收的请求少,而且设置后端服务器权重等方法将不起作用。

image

least_conn

最少连接数,把请求转发给连接数较少的后端服务器。

轮询算法是把请求平均的转发给各个后端,使它们的负载大致相同;但是,有些请求占用的时间很长,会导致其所在的后端负载较高。这种情况下,least_conn 这种方式就可以达到更好的负载均衡效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
upstream backend{
least_conn;
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

此负载均衡策略适合请求处理时间长短不一造成服务器过载的情况。

image

url_hash

按访问 URL 的 hash 结果来分配请求,使每个 URL 定向到同一个后端服务器,要配合缓存命中来使用。

当出现同一个资源多次请求,可能会到达不同的服务器上,导致不必要的多次下载,缓存命中率不高,以及一些资源时间的浪费时,使用 url_hash,可以使得同一个 URL(也就是同一个资源请求)会到达同一台服务器,一旦缓存住了资源,再此收到请求,就可以从缓存中读取。

总结:发送相同的请求时,希望只有一个服务器处理该请求,使用 uri_hash。因为 URL 相同,则哈希值(hash)相同,那么哈希值对应的服务器也相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
upstream backend{
hash &request_uri;
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

如图:文件系统有一个文件,目前只有 web 服务 1 和服务 3 获取了该文件,那么我们想要下载这个文件时,只能找服务 1 或服务 3,这时候就固定一个 URL,该 URL 不允许服务 2 进行处理,那么如何规定哪个服务处理呢?就用到 url_hash

它会根据 URL 计算处哈希值,由哈希值对应服务,所以固定下载文件的 URL,就固定了一个服务处理。

image

fair

fair 指令采用的不是内建负载均衡使用的轮换的均衡算法,而是可以根据页面大小、加载时间长短智能的进行负载均衡。

那么如何使用第三方模块的 fair 负载均衡策略?

1
2
3
4
5
6
7
8
9
10
11
12
13
nupstream backend{
fair;
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

但是这样直接使用会报错,因为 fair 属于第三方模块实现的负载均衡。需要添加 nginx-upstream-fair 模块,如何添加对应的模块:

  1. 下载 nginx-upstream-fair 模块,下载地址如下:
1
https://github.com/gnosek/nginx-upstream-fair
  1. 将下载的文件上传到服务器并进行解压缩
1
2
3
4
5
# 进入安装包目录
cd /opt

# 解压
unzip nginx-upstream-fair-master.zip
  1. 我的解压目录在 /opt,所以第 6 步记得指定好模块的路径。
1
mv nginx-upstream-fair-master fair
  1. 将原有 /usr/local/nginx/sbin/nginx 进行备份
1
mv /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.backup
  1. 查看 configure arguments 的配置信息,拷贝出来
1
2
3
nginx -V

# 拷贝 configure arguments 后面的数据
  1. 进入 Nginx 的安装目录,执行 make clean 清空之前编译的内容
1
2
3
cd /root/nginx/core/nginx-1.21.6

make clean
  1. 使用 configure 来配置参数,添加模块,记得加上第(4)步拷贝的配置信息
1
./configure --add-module=/opt/fair  # 记得添加 configure arguments 后的数据
  1. 通过 make 模板进行编译
1
make

编译可能会出现如下错误,ngx_http_upstream_srv_conf_t 结构中缺少 default_port

image

解决方案:

在 Nginx 的源码目录(安装包目录)中 src/http/ngx_http_upstream.h,找到 ngx_http_upstream_srv_conf_s,在模块中添加添加 default_port 属性

1
vim /opt/nginx/core/nginx-1.21.6/src/http/ngx_http_upstream.h

添加内容:

1
in_port_t	   default_port

image

然后再进行 make。

  1. 将安装目录下的 objs 中的 nginx 拷贝到 sbin 目录
1
2
cd /opt/nginx/core/nginx-1.21.6/objs
cp nginx /usr/local/nginx/sbin

10 .更新nginx

1
2
cd /opt/nginx/core/nginx-1.21.6
make upgrade

上面介绍了 Nginx 常用的负载均衡的策略,有人说是 5 种,是把轮询和加权轮询归为一种,也有人说是 6 种。那么在咱们以后的开发中到底使用哪种,这个需要根据实际项目的应用场景来决定的。

七层负载均衡案例

案例一:对所有请求实现一般轮询规则的负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 8083;
server_name localhost;
location / {
proxy_pass http://backend;
}
}

案例二:对所有请求实现加权轮询规则的负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
upstream backend{
server 192.168.200.146:9001 weight=7;
server 192.168.200.146:9002 weight=3;
server 192.168.200.146:9003 weight=5;
}
server {
listen 8083;
server_name localhost;
location /{
proxy_pass http://backend;
}
}

处理请求概率:9001 端口 > 9003 端口 > 9002 端口

案例三:对特定资源实现负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
upstream videobackend{
server 192.168.200.146:9001;
server 192.168.200.146:9002;
}
upstream filebackend{
server 192.168.200.146:9003;
server 192.168.200.146:9004;
}
server {
listen 8084;
server_name localhost;
location /video/ {
proxy_pass http://videobackend;
}
location /file/ {
proxy_pass http://filebackend;
}
}

发送 /video/ 请求会被 9001 和 9002 端口的服务器处理。

发送 /file/ 请求会被 9003 和 9004 端口的服务器处理。

案例四:对不同域名实现负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
upstream frxbackend{
server 192.168.200.146:9001;
server 192.168.200.146:9002;
}
upstream bingbackend{
server 192.168.200.146:9003;
server 192.168.200.146:9004;
}
server {
listen 8085;
server_name www.frx.com;
location / {
proxy_pass http://frxbackend;
}
}
server {
listen 8086;
server_name www.bing.com;
location / {
proxy_pass http://bingbackend;
}
}

www.frx.com 地址的请求由 9001 端口和 9002 端口处理。

www.bing.com 地址的请求由 9003 端口和 9004 端口处理。

案例五:实现带有URL重写的负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
upstream backend{
server 192.168.200.146:9001;
server 192.168.200.146:9002;
server 192.168.200.146:9003;
}
server {
listen 80;
server_name localhost;
location /file/ {
rewrite ^(/file/.*) /server/$1 last;
}
location /server {
proxy_pass http://backend;
}
}

/file/xxx 请求重写为 /server/xxx,然后触发 location /server,实现负载均衡。

此时被负载均衡的服务器地址也会带有 /server 以及后面的参数,如 192.168.200.146:9001/server/xxx

四层负载均衡

Nginx 在 1.9 之后,增加了一个 stream 模块,用来实现四层协议的转发、代理、负载均衡等。stream 模块的用法跟 http 的用法类似,允许我们配置一组 TCP 或者 UDP 等协议的监听,然后通过 proxy_pass 来转发我们的请求,通过 upstream 添加多个后端服务,实现负载均衡。

四层协议负载均衡的实现,一般都会用到 LVS、HAProxy、F5 等,要么很贵要么配置很麻烦,而 Nginx 的配置相对来说更简单,更能快速完成工作。

添加stream模块的支持

Nginx 默认是没有编译这个模块的,需要使用到 stream 模块,那么需要在编译的时候加上 --with-stream

完成添加 --with-stream 的实现步骤:

  • 将原有 /usr/local/nginx/sbin/nginx 进行备份
  • 拷贝 Nginx -V 的 configure arguments 配置信息
  • 在 Nginx 的安装源码进行配置指定对应模块:./configure --with-stream 加上一步拷贝的configure arguments 配置
  • 通过 make 模板进行编译
  • 将 objs 下面的 nginx 移动到 /usr/local/nginx/sbin
  • 在源码目录下执行 make upgrade 进行升级,这个可以实现不停机添加新模块的功能

添加模块的详细步骤我已经在 七层负载均衡策略-fair 指令静态资源部署-Nginx 模块添加反向代理-添加ssl支持 描述过,而你只需要替换模块名字罢了。

四层负载均衡指令

如果不想在 http 模块使用负载均衡,可以在 steam 模块使用。

stream指令

该指令提供在其中指定流服务器指令的配置文件上下文。和 http 模块同级。

语法 默认值 位置
stream { … } main

如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
http {
server {
listen 80;
# ......
}
}
stream {
upstream backend{
server 192.168.200.146:6379;
server 192.168.200.146:6378;
}
server {
listen 81;
proxy_pass backend;
}
}

upstream指令

该指令和七层负载均衡的 upstream 指令是类似的。

四层负载均衡的案例

准备两台服务器,这里称为 A 和 B。服务器 A 的 IP 为 192.168.200.146,服务器 B 的IP 为 192.168.200.133,服务器 A 存放 Redis 和 Tomcat,服务器 B 作为负载均衡器,对服务器 A 的端口进行负载均衡处理。

需求分析

image

Redis 配置

准备 Redis 服务器,在服务器 A 上准备两个 Redis,端口分别是 6379、6378。

  1. 上传 redis 的安装包 redis-4.0.14.tar.gz,这里上传目录是 /opt
  2. 将安装包进行解压缩
1
tar -zxf redis-4.0.14.tar.gz
  1. 进入redis的安装包
1
cd redis-4.0.14
  1. 使用 make 和 install 进行编译和安装,这里的安装路径是 /usr/local/redis/redis01
1
make PREFIX=/usr/local/redis/redis01 install
  1. 拷贝 redis 配置文件 redis.conf/usr/local/redis/redis01/bin 目录中,因为安装后,目录并没有 redis.conf
1
cp /opt/redis-4.0.14/redis.conf	/usr/local/redis/redis01/bin
  1. 修改 redis.conf 配置文件,注意:不是添加内容,是修改内容,要自己搜索 bind、port 和 daemonize 进行修改
1
2
3
bind 0.0.0.0   # 允许任意地址访问
port 6379 # redis 的端口
daemonize yes # 后台启动 redis
  1. 将 redis01 复制一份为 redis02
1
2
cd /usr/local/redis
cp -r redis01 redis02
  1. 将 redis02 文件夹中的 redis.conf 进行修改,注意:不是添加内容,是修改内容,要自己搜索 bind、port 和 daemonize 进行修改
1
2
3
bind 0.0.0.0   # 允许任意地址访问
port 6378 # redis 的端口
daemonize yes # 后台启动 redis
  1. 分别启动,即可获取两个 Redis 并查看
1
ps -ef | grep redis

使用 Nginx 将请求分发到不同的 Redis 服务器上。

安装 Redis 并验证能启动成功后,在另一台服务器 B 192.168.200.133 的 Nginx 配置文件添加如下内容:(确保安装了 steam 模块)

1
2
3
4
5
6
7
8
9
10
stream {
upstream redisbackend{
server 192.168.200.146:6379; # 服务器 B 的 6379 端口
server 192.168.200.146:6378; # 服务器 B 的 6378 端口
}
server {
listen 81;
proxy_pass redisbackend;
}
}

此时利用 redis-cli 连接测试

image

服务器 B 通过负载均衡连接到了服务器 A 的 Redis,只是不知道连接的是 6378 还是 6379 端口,可以在 Redis 添加不一样的数据来测试,这里不演示了。

Tomcat 配置

准备 Tomcat 服务器 到服务器 A

  1. 上传 tomcat 的安装包,apache-tomcat-8.5.56.tar.gz
  2. 将安装包进行解压缩
1
tar -zxf apache-tomcat-8.5.56.tar.gz
  1. 进入 tomcat 的 bin 目录,启动 tomcat
1
2
cd apache-tomcat-8.5.56/bin
./startup

服务器 B 的配置文件 nginx.conf 配置如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
stream {
upstream redisbackend {
server 192.168.200.146:6379; # 服务器 B 的 6379 端口
server 192.168.200.146:6378; # 服务器 B 的 6378 端口
}
upstream tomcatbackend {
server 192.168.200.146:8080; # 服务器 B 的 8080 端口
}
server {
listen 81;
proxy_pass redisbackend; # redis 的负载均衡
}
server {
listen 82;
proxy_pass tomcatbackend; # tomcat 的负载均衡
}
}

访问服务器 B 的地址进行测试:192.168.200.133:82