Nginx+Tomcat负载均衡、动静分离

nginx接收客户端请求，如果是请求静态资源，直接返回给客户端，如果是请求动态资源，把请求转发到后端，tomcat就是放淘宝、支付宝这些的地方，处理动态页面的web服务器

1、nginx 应用

Nginx是一款非常优秀的HTTP服务器软件
支持高达50 000个并发连接数的响应
拥有强大的静态资源处理能力
运行稳定
内存、CPU等系统资源消耗非常低
目前很多大型网站都应用Nginx服务器作为后端网站程序的反向代理及负载均衡器，提升整个站点的负载并发能力

2、正向代理和反向代理

① 正向代理 

正向代理 ：  代理的是客户端 去访问  服务器    加快访问速度      squid     

当客户端访问一台服务器有障碍，访问不到的时候，这时候就可以找一台可以访问到该服务器的另外一台服务器去代替他去访问，这台代替他去访问的服务器称之为代理服务器。然后客户端就可以把请求发送给代理服务器，然后通过代理服务器去访问目标服务器。由代理服务器将目标服务器的返回数据返回给客户端，客户端可以清楚目标服务器的地址，但是目标服务器并不清楚来自哪个客户端，他只知道来自哪个代理服务器。所以，正向代理可以屏蔽或者说隐藏客户端的信息。

它的工作原理就像一个跳板,简单的说,我是一个用户,我访问不了某网站,但是我能访问一个代理服务器，这个代理服务器呢,他能访问那个我不能访问的网站，于是我先连上代理服务器,告诉他我需要那个无法访问网站的内容，代理服务器去取回来,然后返回给我，从网站的角度,只在代理服务器来取内容的时候有一次记录，有时候并不知道是用户的请求,也隐藏了用户的资料,这取决于代理告不告诉网站

② 反向代理(单级)

反向代理：   代理的是服务端       负载均衡        

应用场景：把客户端 动态资源请求 转发到后端服务器

单级反向代理是指只有一个反向代理服务器位于客户端和后端服务器之间。客户端的请求首先发送到反向代理服务器，然后由反向代理服务器转发到后端服务器。

说法一：

从代理中我们得知代理服务器是给客户端做代理的，他和客户端是一伙的。而反向代理呢其实就是和正向代理反过来，他和服务器是一伙的，它屏蔽掉了服务器的信息，经常用在多台服务器的分布式部署上，像一些大的网站，由于访问人数很多，就需要多台服务器来解决人数多的问题，这时这些服务器就由一个反向代理服务器来代理，客户端发来请求，先由反向代理服务器，然后按一定的规则分发到明确的服务器，而客户端不知道是哪台服务器。常常用nginx来作反向代理。（就好像到餐厅吃饭，跟服务员点菜，服务员告诉后厨，但你不知道是那个厨师做的）

② 反向代理(多级)

多级反向代理是指在客户端和后端服务器之间存在多层反向代理服务器。请求需要经过多个反向代理服务器才能到达后端服务器。

3、 负载均衡模式

应用场景：高并发

以下是 Nginx 支持的几种常见的分流算法：

1. 轮询（Round Robin）：

   轮询算法是 Nginx 的默认分流算法。它按顺序将请求依次分配给每一台后端服务器，直到最后一台服务器，然后重新从第一台服务器开始。这种方法简单且均匀地分配了流量。

   数据流向：每个请求依次被分配到下一个服务器。假设有三台服务器（Server A、Server B、Server C），第一个请求被分配到 Server A，第二个请求分配到 Server B，第三个请求分配到 Server C，第四个请求又回到 Server A，依此类推。
   特点：请求均匀分布，无视服务器的当前负载和响应时间。

 配置示例：

 upstream backend {
       server backend1.example.com;
       server backend2.example.com;
       server backend3.example.com;
   }

 

2. 最少连接数（Least Connections）：

   最少连接数算法将请求分配给当前活动连接数最少的服务器。这种算法适用于请求处理时间不均匀的情况，可以有效平衡服务器的负载。

   数据流向：每个请求被分配到当前连接数最少的服务器。例如，Server A 有 2 个连接，Server B 有 5 个连接，新的请求会被分配到 Server A。
   特点：动态均衡负载，适用于请求处理时间不一的场景。

   配置示例：

 upstream backend {
       least_conn;
       server backend1.example.com;
       server backend2.example.com;
       server backend3.example.com;
   }

3. IP 哈希（IP Hash）：

   IP 哈希算法通过计算客户端 IP 地址的哈希值，将同一IP请求始终分配给同一台服务器。适用于需要将特定客户端的请求固定在同一台服务器上的场景。（有助于会话保持，比如购物车里的商品信息，保留在同一服务器内，不会丢失）（用得少，可能导致服务器崩溃）

   数据流向：每个客户端的 IP 地址被哈希计算，然后根据哈希值将请求固定分配到某一台服务器。假设客户端 X 的哈希值指向 Server A，客户端 Y 的哈希值指向 Server B，则无论多少次请求，X 的请求总是流向 Server A，Y 的请求总是流向 Server B。
   特点：同一个客户端总是被分配到同一台服务器，有助于会话保持。

   配置示例：
   upstream backend {
       ip_hash;
       server backend1.example.com;
       server backend2.example.com;
       server backend3.example.com;
   }

4. 加权轮询（Weighted Round Robin）：

   加权轮询算法允许为每台服务器设置权重，权重越大的服务器，获得更多的请求。适用于服务器性能不均衡的情况。（可以设置 8核16G设置权重 > 4核8G的权重）

   数据流向：根据服务器设置的权重值分配请求。假设 Server A 权重为 3，Server B 权重为 1，则 4 个请求中，3 个会被分配到 Server A，1 个会被分配到 Server B。
   特点：高权重服务器接收更多的请求，适用于服务器性能差异较大的场景。

   配置示例：

   upstream backend {
       server backend1.example.com weight=3;
       server backend2.example.com weight=1;
       server backend3.example.com weight=2;
   }

5. 最少时间算法（Least Time）：

  最少时间算法基于请求的响应时间，将请求分配给响应时间最短的服务器（每次的请求时间会改变）。这种算法在 Nginx 1.15.3 及以后版本中可用，适用于需要最大化响应速度的场景。

   数据流向：每个请求分配到响应时间最短或平均连接时间最短的服务器。假设 Server A 的响应时间较快，Server B 较慢，则新的请求更可能流向 Server A。
   特点：进一步优化了最少连接算法，适用于高负载环境下的动态负载均衡。

   配置示例：

   upstream backend {
       least_time header;
       server backend1.example.com;
       server backend2.example.com;
       server backend3.example.com;
   }

6. 一致性哈希（Consistent Hashing）：

   一致性哈希算法可以保证当集群中某台服务器故障时，只有部分请求会重新分配到其他服务器，而不是全部重新分配。这在缓存等场景中非常有用。（ServerA崩溃的话，ServerA使用中的请求转发到 Server B，不在使用的留在缓存中 ）

   数据流向：根据请求的某个特定参数（如 URL、Cookie 或其他 Header），进行哈希计算，将请求分配到哈希值对应的服务器。假设 Server A 和 Server B，参数 "foo" 的哈希值指向 Server A，参数 "bar" 的哈希值指向 Server B，则 "foo" 请求总是流向 Server A，"bar" 请求总是流向 Server B。
   特点：适应服务器节点变动，减少请求的重新分配，适合缓存敏感的场景。

   配置示例（需要第三方模块如 `ngx_http_upstream_hash_module`）：
   upstream backend {
       hash $request_uri consistent;
       server backend1.example.com;
       server backend2.example.com;
       server backend3.example.com;
   }

4、规划部署负载均衡和反向代理

Nginx 服务器：192.168.190.10:80
Tomcat服务器1：192.168.190.50:8080
Tomcat服务器2：192.168.190.60:8080                                                                                      Tomcat服务器3：192.168.190.70:8080
 

1.部署Nginx 负载均衡器

systemctl stop firewalld
setenforce 0

yum -y install pcre-devel zlib-devel openssl-devel gcc gcc-c++ make

useradd -M -s /sbin/nologin nginx
tail /etc/passwd

cd /opt
tar zxvf nginx-1.20.2.tar.gz -C /opt/

cd nginx-1.20.2/
./configure \
--prefix=/usr/local/nginx \
--user=nginx \
--group=nginx \
--with-file-aio \                                    #启用文件修改支持
--with-http_stub_status_module \                    #启用状态统计
--with-http_gzip_static_module \                    #启用 gzip静态压缩
--with-http_flv_module \                            #启用 flv模块，提供对 flv 视频的伪流支持
--with-http_ssl_module                                #启用 SSL模块，提供SSL加密功能
--with-stream                                        #启用 stream模块，提供4层调度

----------------------------------------------------------------------------------------------------------
./configure --prefix=/usr/local/nginx --user=nginx --group=nginx --with-file-aio --with-http_stub_status_module --with-http_gzip_static_module --with-http_flv_module  --with-http_ssl_module --with-stream 

make && make install

ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/

vim /lib/systemd/system/nginx.service
[Unit]
Description=nginx
After=network.target
[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStart=/usr/local/nginx/sbin/nginx
ExecrReload=/bin/kill -s HUP $MAINPID
ExecrStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
[Install]
WantedBy=multi-user.target

systemctl daemon-reload              #加载才能用

chmod 754 /lib/systemd/system/nginx.service

systemctl start nginx.service
systemctl enable nginx.service

lsof -i:80

浏览器访问Nginx ：192.168.190.10

=========================================================================

部署3台tomcat服务器之前要 在Nginx Service （192.168.190.10），不然用不了

echo $PATH

2.部署3台Tomcat 应用服务器    （192.168.190.50；192.168.190.60；192.168.190.70）

后端的服务器可以随意横向扩展，只要在负载均衡里加上ip+端口号就行，只能重新加载，不能重启服务，不然就挂了

192.168.190.50

systemctl stop firewalld
setenforce 0

tar zxvf jdk-8u91-linux-x64.tar.gz -C /usr/local/
java -version           #现在是openjdk，配完etc/profile应该是jdk

vim /etc/profile                     #G到行尾，添加
export JAVA_HOME=/usr/local/jdk1.8.0_91
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

source /etc/profile    或    . /etc/profile
java -version      #现在应该是java

cd /opt
tar zxvf apache-tomcat-8.5.16.tar.gz

mv /opt/apache-tomcat-8.5.16/ /usr/local/tomcat

另外两台tomcat2、tomcat3安装JDK、Apache-tomcat
scp -r /usr/local/jdk1.8.0_91 /usr/local/tomcat/ 192.168.190.60:/usr/local
scp -r /usr/local/jdk1.8.0_91 /usr/local/tomcat/ 192.168.190.70:/usr/local
# scp 不压缩，传输数据到别的虚拟机
另外两台主机改主机名tomcat1、tomcat2

  vim /etc/profile     source /etc/profile     java -version       #跟上面tomcat1步骤一样

/usr/local/tomcat/bin/shutdown.sh 
/usr/local/tomcat/bin/startup.sh

netstat -ntap | grep 8080         #以上三步先不做，做下面的

  tomcat1 （192.168.190.50）

tomcat2 (192.168.190.60)

tomcat3 (192.168.190.70)

3.动静分离配置
（1）Tomcat1 server（192.168.190.50） 配置

mkdir /usr/local/tomcat/webapps/test

vim /usr/local/tomcat/webapps/test/index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>JSP test1 page</title>   #指定为 test1 页面
</head>
<body>
<% out.println("动态页面 1,http://www.test1.com");%>
</body>
</html>

cd /usr/local/tomcat/conf
cp server.xml{,_bak}

vim /usr/local/tomcat/conf/server.xml
#由于主机名 name 配置都为 localhost，需要删除前面的 HOST 配置
<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="/usr/local/tomcat/webapps/test" path="" reloadable="true">
    </Context>
</Host>

/usr/local/tomcat/bin/shutdown.sh 
/usr/local/tomcat/bin/startup.sh 

lsof -i:8080

网页访问 192.168.190.50:8080

scp /usr/local/tomcat/conf/server.xml 192.168.190.60:/usr/local/tomcat/conf
scp /usr/local/tomcat/conf/server.xml 192.168.190.70:/usr/local/tomcat/conf

访问网页192.168.190.50:8080

tomcat2 (192.168.190.60)：
cd /usr/local/tomcat/webapps
mkdir test              
 vim /test/index.jsp     把页面内容放进去     

/usr/local/tomcat/bin/startup.sh 
lsof -i:8080        netstat -antulp| grep java    

192.168.190.70
cd /usr/local/tomcat/webapps
mkdir test              
 vim /test/index.jsp     把页面内容放进去    

/usr/local/tomcat/bin/startup.sh 
lsof -i:8080        netstat -antulp| grep java     

或者也可以按照下面教案一个一个配 tomcat2 、tomcat3

tomcat2（192.168.190.60）

tomcat3 （192.168.190.70）

（2）Tomcat2 server（192.168.190.60） 配置 

mkdir /usr/local/tomcat/webapps/test 

vim /usr/local/tomcat/webapps/test/index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>JSP test2 page</title>   #指定为 test2 页面
</head>
<body>
<% out.println("动态页面 2,http://www.test2.com");%>
</body>
</html>

vim /usr/local/tomcat/conf/server.xml
#删除前面的 HOST 配置
<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="/usr/local/tomcat/webapps/test" path="" reloadable="true" />
</Host>

/usr/local/tomcat/bin/shutdown.sh 
/usr/local/tomcat/bin/startup.sh 

Tomcat3 server（192.168.190.70） 配置 

vim /usr/local/tomcat/webapps/test/index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>JSP test3 page</title>   #指定为 test3 页面
</head>
<body>
<% out.println("动态页面 3,http://www.test3.com");%>
</body>
</html>

vim /usr/local/tomcat/conf/server.xml
#删除前面的 HOST 配置
<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="/usr/local/tomcat/webapps/test" path="" reloadable="true" />
</Host>

/usr/local/tomcat/bin/shutdown.sh 
/usr/local/tomcat/bin/startup.sh 

（3）Nginx server （192.168.190.10）配置

#准备静态页面和静态图片
echo '<html><body><h1>这是静态页面</h1></body></html>' > /usr/local/nginx/html/index.html

mkdir /usr/local/nginx/html/img
cp /root/dog.jpg /usr/local/nginx/html/img           #把图片放进去
 

cp /usr/local/nginx/conf/nginx.conf{,_bak}
vim /usr/local/nginx/conf/nginx.conf
......
http {
......
    #gzip on;
#配置负载均衡的服务器列表，weight参数表示权重，权重越高，被分配到的概率越大
    upstream tomcat_server {           #upstream做负载均衡；tomcat_server负载均衡名称(随便起)
        server 192.168.190.50:8080 weight=1;
        server 192.168.190.60:8080 weight=1;
        server 192.168.190.70:8080 weight=1;
    }
 

server {
        listen 80;
        server_name www.kgc.com;    #www.kgc.com随便，localhost也行
    
        charset utf-8;
    
        #access_log logs/host.access.log main;
        
        #配置Nginx处理动态页面请求，将 .jsp文件请求转发到Tomcat 服务器处理
        location ~ .*\.jsp$ {           #~取分大小写  .* 匹配任意字符0~多次     \.jsp$匹配以jsp结尾
            proxy_pass http://tomcat_server;         #proxy_pass做反向代理
#设置后端的Web服务器可以获取远程客户端的真实IP
##设定后端的Web服务器接收到的请求访问的主机名（域名或IP、端口），默认HOST的值为proxy_pass指令设置的主机名。如果反向代理服务器不重写该请求头的话，那么后端真实服务器在处理时会认为所有的请求都来在反向代理服务器，如果后端有防攻击策略的话，那么机器就被封掉了。
            proxy_set_header HOST $host;   
##把$remote_addr赋值给X-Real-IP，来获取源IP
            proxy_set_header X-Real-IP $remote_addr;
##在nginx 作为代理服务器时，设置的IP列表，会把经过的机器ip，代理机器ip都记录下来
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
 

#配置Nginx处理静态图片请求
        location ~ .*\.(gif|jpg|jpeg|png|bmp|swf|css)$ {    
            root /usr/local/nginx/html/img;
            expires 10d;            #缓存保留10天
        }
        
        location / {
            root html;
            index index.html index.htm;
        }
......
    }
......
}
 

nginx -t      #检查语法
nginx -s reload      #重新加载
 

4.测试效果

测试静态页面效果
浏览器访问 http://192.168.190.10/
浏览器访问 http://192.168.190.10/dog.jpg

测试负载均衡效果，不断刷新浏览器测试
浏览器访问 http://192.168.10.19/index.jsp
刷新之后，会轮询显示

不断刷新浏览器测试

分流策略
Nginx 负载均衡模式：
●rr 负载均衡模式：
每个请求按时间顺序逐一分配到不同的后端服务器，如果超过了最大失败次数后（max_fails，默认1），在失效时间内(fail_timeout，默认10秒)，该节点失效权重变为0，超过失效时间后，则恢复正常，或者全部节点都为down后，那么将所有节点都恢复为有效继续探测，一般来说rr可以根据权重来进行均匀分配。

权重

●least_conn 最少连接：
优先将客户端请求调度到当前连接最少的服务器。

●ip_hash 负载均衡模式：
每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题，但是ip_hash会造成负载不均，有的服务请求接受多，有的服务请求接受少，所以不建议采用ip_hash模式，session 共享问题可用后端服务的 session 共享代替 nginx 的 ip_hash。

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

●url_hash（第三方）负载均衡模式：
基于用户请求的uri做hash。和ip_hash算法类似，是对每个请求按url的hash结果分配，使每个URL定向到同一个后端服务器，但是也会造成分配不均的问题，这种模式后端服务器为缓存时比较好。

扩展

面试题：nginx有几层代理   *********

四层     调用stream代理        速度快

七层     调用upstream代理

Nginx 四层代理配置：
./configure --with-stream

和http同等级：所以一般只在http上面一段设置，
stream {
    
    upstream appserver {
        server 192.168.80.100:8080 weight=1;
        server 192.168.80.101:8080 weight=1;
        server 192.168.80.101:8081 weight=1;
    }
    server {
        listen 8080;
        proxy_pass appserver;
    }
}

http {
......