结合反向代理实现 Tomcat 部署

可以利用iptables策略实现端口重定向或DNAT，解决非标准端口的问题

iptables -t nat -A PREROUTING -p tcp --dport 80 --j REDIRECT --to-port 8080

但无法实现负载均衡

常见部署方式介绍

standalone模式，Tomcat单独运行，直接接受用户的请求，不推荐。
反向代理，单机运行，提供了一个Nginx作为反向代理，可以做到静态由nginx提供响应，动态jsp代理给Tomcat
- LNMT：Linux + Nginx + MySQL + Tomcat
- LAMT：Linux + Apache（Httpd）+ MySQL + Tomcat
前置一台Nginx，给多台Tomcat实例做反向代理和负载均衡调度，Tomcat上部署的纯动态页面更适合
- LNMT：Linux + Nginx + MySQL + Tomcat
多级代理
- LNNMT：Linux + Nginx + Nginx + MySQL + Tomcat

利用 Nginx 反向代理至同一个主机的 Tomcat

配置说明

利用nginx反向代理功能，实现的代理功能，将用户请求全部转发至指定的同一个tomcat主机

利用nginx指令proxy_pass 可以向后端服务器转发请求报文,并且在转发时会保留客户端的请求报文中的host首部

#从yum源安装nginx
#yum install nginx -y
#vim /etc/nginx/nginx.conf
#全部反向代理测试
location / {
    # proxy_pass http://127.0.0.1:8080; # 不管什么请求，都会访问后面的localhost虚拟主机
    proxy_pass http://node1.ayaka.org:8080; # 此项将用户访问全部请求转发到node1的虚拟主机上
    #proxy_pass http://node2.ayaka.org:8080; #此项将用户访问全部请求转发到node2的虚拟主机上
	#proxy_set_header Host $http_host; #转发主机头至后端服务器
	#以上两项都需要修改nginx服务器的/etc/hosts,实现node1.ayaka.org和node2.ayaka.org到IP的解析
	
}

#nginx -t
#systemctl restart nginx
#说明: proxy_pass http://FQDN/ 中的FQDN 决定转发至后端哪个虚拟主机,而与用户请求的URL无关
#如果转到后端的哪个服务器由用户请求决定,可以向后端服务转发请求的主机头实现,示例:
proxy_set_header Host $http_host;

实战案例1: 实现 HTTP

环境说明:

一台主机,实现nginx和tomcat
tomcat上有两个虚拟主机node1和node2

#在同一下主机上建立两个tomcat虚拟主机，node1.ayaka.org和node2.ayaka.org
#修改/etc/hosts文件，实现名称解析
[root@centos8 ~]#vim /etc/hosts
127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
centos8.localdomain
::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
10.0.0.100 node1.ayaka.org node2.ayaka.org

#安装nginx
[root@centos8 ~]#yum -y install nginx

#修改nginx.conf配置文件
[root@centos8 ~]#vim /etc/nginx/nginx.conf
......
#修改location / 此行，添加以下内容
location / {
            #proxy_pass http://127.0.0.1:8080;
            proxy_pass http://node1.ayaka.org:8080;
            #proxy_set_header Host $http_host; #转发主机头至后端服务器
            }
......

[root@centos8 ~]#systemctl enable --now nginx

#分别访问node1,node2和IP都可以看到一样的node1的虚拟主机页面
[root@centos8 ~]#curl http://node1.ayaka.org/
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
node1.ayaka.org
</body>
</html>

[root@centos8 ~]#curl http://node2.ayaka.org/
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
node1.ayaka.org
</body>
</html>

[root@centos8 ~]#curl http://127.0.0.1/
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
node1.ayaka.org
</body>
</html>


[root@centos8 ~]#curl http://10.0.0.100/
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
node1.ayaka.org
</body>
</html>

[root@centos8 ~]#systemctl restart nginx
#再次修改nginx.conf配置文件
[root@centos8 ~]#vim /etc/nginx/nginx.conf
......
#修改location / 行，添加以下内容
location / {
        #proxy_pass http://127.0.0.1:8080;
        proxy_pass http://node2.ayaka.org:8080;
        #proxy_set_header Host $http_host; #转发主机头至后端服务器
        }
......

#分别访问node1,node2和IP都可以看到一样的node2的虚拟主机页面
[root@centos8 ~]#curl http://node1.ayaka.org/
[root@centos8 ~]#curl http://node2.ayaka.org/
[root@centos8 ~]#curl http://127.0.0.1/
[root@centos8 ~]#curl http://10.0.0.100/

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
node2.ayaka.org
</body>
</html>

实战案例2：实现 HTTPS

tomcat 实现 https的参考文档

https://help.aliyun.com/document_detail/98576.html?
spm=5176.b657008.0.0.5a471b48Cyahpi

虽然在Tomcat上可以实现HTTPS，不仅配置复杂，而且会导致性能问题，因此生产中更多的是通过Nginx 实现HTTPS再反向代理至Tomcat

范例： Nginx实现反向代理实现 http 自动跳转至 https

server {
    listen 80;
    server_name blog.ayaka.org;
    return 302 https://$host$request_uri;
}
server {
    listen 443 ssl;
    server_name blog.ayaka.org;
    ssl_certificate 	/etc/nginx/ssl/www.ayaka.org.pem;
    ssl_certificate_key 	/etc/nginx/ssl/www.ayaka.org.key;
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

范例：Nginx实现反向代理实现 http 自动跳转至 https 并同时实现动静分离

server {
    listen 80;
    server_name www.ayaka.org;
    return 302 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name www.ayaka.org;
    root /var/www/html;
    ssl_certificate /etc/nginx/conf.d/www.ayaka.org.pem;
    ssl_certificate_key /etc/nginx/conf.d/www.ayaka.org.key;
    location ~ \.jsp$ {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

利用 Nginx 实现动静分离代理

配置说明

可以利用nginx实现动静分离

vim nginx.conf
root /usr/share/nginx/html;
#下面行可不加
#location / {
# 	root /data/webapps/ROOT;
# 	index index.html;
#}

# ~* 不区分大小写
location ~* \.jsp$ {
	proxy_pass http://node1.ayaka.org:8080; #注意: 8080后不要加/,需要在nginx服务器修改/etc/hosts
}

以上设置，可以将jsp的请求反向代理到tomcat，而其它文件仍由nginx处理，从而实现所谓动静分离。但由于jsp文件中实际上是由静态资源和动态组成，所以无法彻底实现动静分离。实际上Tomcat不太适合做动静分离，用它来管理程序的图片不好做动静分离部署

实战案例

#准备三个不同的资源文件
[root@centos8 ~]#echo /usr/local/tomcat/webapps/ROOT/test.html > /usr/local/tomcat/webapps/ROOT/test.html
[root@centos8 ~]#echo /usr/local/tomcat/webapps/ROOT/test.jsp > /usr/local/tomcat/webapps/ROOT/test.jsp
[root@centos8 ~]#echo /usr/share/nginx/html/test.html > /usr/share/nginx/html/test.html

[root@centos8 ~]#vim /etc/nginx/nginx.conf
......
root /usr/share/nginx/html;
#location / {
#
#}
location ~* \.jsp$ {
	proxy_pass http://127.0.0.1:8080;
		}
......

[root@centos8 ~]#systemctl restart nginx
#访问test.html，观察结果都一样访问的是nginx自身的资源
[root@centos8 ~]#curl http://node1.ayaka.org/test.html
[root@centos8 ~]#curl http://node2.ayaka.org/test.html
[root@centos8 ~]#curl http://127.0.0.1/test.html
[root@centos8 ~]#curl http://10.0.0.8/test.html
/usr/share/nginx/html/test.html

#访问test.jsp，观察结果都一样访问的是tomcat的默认主机资源
[root@centos8 ~]#curl http://node1.ayaka.org/test.jsp
[root@centos8 ~]#curl http://node2.ayaka.org/test.jsp
[root@centos8 ~]#curl http://127.0.0.1/test.jsp
[root@centos8 ~]#curl http://10.0.0.8/test.jsp
/usr/local/tomcat/webapps/ROOT/test.jsp

范例: 实现单机的tomcat的服务器的动静分离

listen 80;
server name java.ayaka.org;
location / {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $http_host;
}
    lcation ~* \.(png|jpg|jpeg|svg)${
        root /data/www/images;
        expires 1d; #缓存到客户端浏览器一天
    }
}

范例: 实现多主机的负载均衡的动静分离

#cat proxy.www.ayaka.org.conf
upstream static {
	server 10.0.0.8:80;
}
upstream tomcat {
	server 10.0.0.18:8080;
}
server {
    listen 80;
    server_name www.ayaka.org;
    location / {
        proxy_pass http://tomcat;
        proxy_set_header Host $http_host;
    }
    location ~* .*\.(png|jpg|jpeg|gif)$ {
        proxy_pass http://static;
        proxy_set_header Host $http_host;
    }
}

利用 Httpd 实现基于 AJP 协议的反向代理至后端Tomcat 服务器

图片-rXpyEjSiYyJKIGxAtQrrAJtYDkQLoKrs.png

AJP 协议说明

AJP（Apache JServ Protocol）是定向包协议，是一个二进制的TCP传输协议，相比HTTP这种纯文本的协议来说，效率和性能更高，也做了很多优化。但是浏览器并不能直接支持AJP13协议，只支持HTTP协议。所以实际情况是，通过Apache的proxy_ajp模块进行反向代理，暴露成http协议给客户端访问

启用和禁用 AJP

注意: Tomcat/8.5.51之后版本基于安全需求默认禁用AJP协议

范例: Tomcat/8.5.51之后版启用支持AJP协议

root@centos8 tomcat]#vim conf/server.xml
#取消前面的注释,并修改下面行,修改address和secretRequired
<Connector protocol="AJP/1.3" address="0.0.0.0" port="8009"
	redirectPort="8443" secretRequired="" />
	
[root@centos8 tomcat]#systemctl restart tomcat
[root@centos8 tomcat]#ss -ntl
State Recv-Q Send-Q Local Address:Port
Peer Address:Port
LISTEN 0 128 0.0.0.0:22
0.0.0.0:*
LISTEN 0 100 127.0.0.1:25
0.0.0.0:*
LISTEN 0 128 [::]:22
[::]:*
LISTEN 0 100 [::1]:25
[::]:*
LISTEN 0 1 [::ffff:127.0.0.1]:8005
*:*
LISTEN 0 100 [::ffff:127.0.0.1]:8009
*:*
LISTEN 0 100 *:8080
*:*
LISTEN 0 128 *:80
*:*

注意: secretRequired="" 必须加上,否则出现以下错误提示

[root@centos8 tomcat]#cat logs/catalina.log
Caused by: java.lang.IllegalArgumentException: The AJP Connector is configured
with secretRequired="true" but the secret attribute is either null or "". This
combination is not valid.

除httpd外，其它支持AJP代理的服务器非常少，比如Nginx就不支持AJP，所以目前一般都禁用AJP协议端口

范例：禁用AJP协议

#Tomcat/8.5.50版本之前默认支持AJP协议
[root@centos8 ~]#ss -ntl
State Recv-Q Send-Q Local Address:Port
Peer Address:Port
LISTEN 0 128 0.0.0.0:22
0.0.0.0:*
LISTEN 0 100 *:8080
*:*
LISTEN 0 128 *:80
*:*
LISTEN 0 128 [::]:22
[::]:*
LISTEN 0 1 [::ffff:127.0.0.1]:8005
*:*
LISTEN 0 100 *:8009
*:*

#配置tomcat配置文件，删除下面一行
[root@centos8 ~]#vim /usr/local/tomcat/conf/server.xml
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />


[root@centos8 ~]#systemctl restart tomcat
[root@centos8 ~]#ss -ntl
State Recv-Q Send-Q Local Address:Port
Peer Address:Port
LISTEN 0 128 0.0.0.0:22
0.0.0.0:*
LISTEN 0 100 *:8080
*:*
LISTEN 0 128 *:80
*:*
LISTEN 0 128 [::]:22
[::]:*
LISTEN 0 1 [::ffff:127.0.0.1]:8005
*:*

Httpd 实现 AJP 反向代理

配置说明

相对来讲，AJP协议基于二进制比使用HTTP协议的连接器效率高些。

proxy_ajp_module模块代理配置

<VirtualHost *:80>
    ServerName 			node1.ayaka.org
    ProxyRequests 		Off
    ProxyVia 			On
    ProxyPreserveHost 	On
    ProxyPass 		/ 		ajp://127.0.0.1:8009/
</VirtualHost>

查看Server Status可以看到确实使用的是ajp连接了。

实战案例

范例：启用httpd的AJP反向代理功能

[root@centos8 ~]#vim /etc/httpd/conf.d/tomcat.conf
[root@centos8 ~]#cat /etc/httpd/conf.d/tomcat.conf
<VirtualHost *:80>
	ServerName 			node1.ayaka.org
    ProxyRequests 		Off
    ProxyVia 			On	#此项对AJP无效
    ProxyPreserveHost 	On	#此项对AJP无效
    ProxyPass 		/ 		ajp://127.0.0.1:8009/
</VirtualHost>

[root@centos8 ~]#systemctl restart httpd

#再次用用下面不同URL访问，可以看以下结果
[root@centos8 ~]#curl http://node1.ayaka.org/test.html
/data/node1/ROOT/test.html
[root@centos8 ~]#curl http://node2.ayaka.org/test.html
/data/node2/ROOT/test.html
[root@centos8 ~]#curl http://10.0.0.8/test.html
/usr/local/tomcat/webapps/ROOT/test.html
[root@centos8 ~]#curl http://127.0.0.1/test.html
/usr/local/tomcat/webapps/ROOT/test.html


[root@centos8 ~]#vim /etc/httpd/conf.d/tomcat.conf
#只修改下面一行,关闭向后端转发请求的host首部
ProxyPreserveHost Off

#再次用用下面不同URL访问，可以看到和上面一样的结果，说明AJP协议和Http不同，自动转发所有首部信息
[root@centos8 ~]#curl http://node1.ayaka.org/test.html
/data/node1/ROOT/test.html
[root@centos8 ~]#curl http://node2.ayaka.org/test.html
/data/node2/ROOT/test.html
[root@centos8 ~]#curl http://10.0.0.8/test.html
/usr/local/tomcat/webapps/ROOT/test.html
[root@centos8 ~]#curl http://127.0.0.1/test.html
/usr/local/tomcat/webapps/ROOT/test.html

可以通过status页面看到下面AJP的信息

#用iptables禁用AJP的访问
[root@centos8 ~]#iptables -A INPUT -p tcp --dport 8009 -j REJECT
[root@centos8 ~]#curl http://node1.ayaka.org/test.html
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>503 Service Unavailable</title>
</head><body>
<h1>Service Unavailable</h1>
<p>The server is temporarily unable to service your
request due to maintenance downtime or capacity
problems. Please try again later.</p>
</body></html>

实现 Tomcat 负载均衡

动态服务器的问题，往往就是并发能力太弱，往往需要多台动态服务器一起提供服务。如何把并发的压力分摊，这就需要调度，采用一定的调度策略，将请求分发给不同的服务器，这就是Load Balance负载均衡。

当单机Tomcat，演化出多机多级部署的时候，一个问题便凸显出来，这就是Session。而这个问题的由来，都是由于HTTP协议在设计之初没有想到未来的发展。

HTTP的无状态，有连接和短连接

无状态：指的是服务器端无法知道2次请求之间的联系，即使是前后2次请求来自同一个浏览器，也没有任何数据能够判断出是同一个浏览器的请求。后来可以通过cookie、session机制来判断。
- 浏览器端第一次HTTP请求服务器端时，在服务器端使用session这种技术，就可以在服务器端产生一个随机值即SessionID发给浏览器端，浏览器端收到后会保持这个SessionID在Cookie当中，这个Cookie值一般不能持久存储，浏览器关闭就消失。浏览器在每一次提交HTTP请求的时候会把这个SessionID传给服务器端，服务器端就可以通过比对知道是谁了
- Session通常会保存在服务器端内存中，如果没有持久化，则易丢失
- Session会定时过期。过期后浏览器如果再访问，服务端发现没有此ID，将给浏览器端重新发新的SessionID
- 更换浏览器也将重新获得新的SessionID
有连接：是因为它基于TCP协议，是面向连接的，需要3次握手、4次断开。
短连接：Http 1.1之前，都是一个请求一个连接，而Tcp的连接创建销毁成本高，对服务器有很大的影响。所以，自Http 1.1开始，支持keep-alive，默认也开启，一个连接打开后，会保持一段时间（可设置），浏览器再访问该服务器就使用这个Tcp连接，减轻了服务器压力，提高了效率。

服务器端如果故障，即使Session被持久化了，但是服务没有恢复前都不能使用这些SessionID。

如果使用HAProxy或者Nginx等做负载均衡器，调度到了不同的Tomcat上，那么也会出现找不到SessionID的情况。

会话保持方式

Session sticky 会话黏性

Session绑定

nginx：source ip, cookie
HAProxy：source ip, cookie

优点：简单易配置

缺点：如果目标服务器故障后，如果没有做sessoin持久化，就会丢失session,此方式生产很少使用

Session 复制集群

Tomcat自己的提供的多播集群，通过多播将任何一台的session同步到其它节点。

缺点

Tomcat的同步节点不宜过多，互相即时通信同步session需要太多带宽
每一台都拥有全部session，内存损耗太多

Session Server

session 共享服务器，使用memcached、redis做共享的Session服务器，此为推荐方式

负载均衡规划和准备

负载均衡主机和网络地址规划

图片-bCgNNZlNZXwtXbhZxFuKboRjZWjEfVeK.png

IP	主机名	服务	软件
10.0.0.100	proxy.ayaka.org	调度器	Nginx、HTTPD
10.0.0.101	t1.ayaka.org	tomcat1	JDK8、Tomcat8
10.0.0.102	t2.ayaka.org	tomcat2	JDK8、Tomcat8

#只需在10.0.0.100的nginx主机上实现域名解析
vim /etc/hosts
#添加以下三行
10.0.0.100 proxy.ayaka.org proxy
10.0.0.101 t1.ayaka.org t1
10.0.0.102 t2.ayaka.org t2

负载均衡tomcat主机准备

修改tomcat的虚拟机主机为自定义的主机名,并设为默认的虚拟主机

t1虚拟主机配置conf/server.xml

<Engine name="Catalina" defaultHost="t1.ayaka.org">
    <Host name="t1.ayaka.org" appBase="/data/webapps" autoDeploy="true" >
    </Host>
</Engine>

t2虚拟主机配置conf/server.xml

<Engine name="Catalina" defaultHost="t1.ayaka.org">
    <Host name="t2.ayaka.org" appBase="/data/webapps" autoDeploy="true" >
    </Host>
</Engine>

准备负载均衡规划测试用的 jsp文件

在t1和 t2节点创建相同的文件/data/webapps/ROOT/index.jsp

#项目路径配置
mkdir -pv /data/webapps/ROOT

#编写测试jsp文件，内容在下面
vim /data/webapps/ROOT/index.jsp
<%@ page import="java.util.*" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>tomcat test</title>
</head>
<body>
<div>On <%=request.getServerName() %></div>
<div><%=request.getLocalAddr() + ":" + request.getLocalPort() %></div>
<div>SessionID = <span style="color:blue"><%=session.getId() %></span></div>
<%=new Date()%>
</body>
</html>

#设置权限
chown -R tomcat.tomcat /data/webapps/

Nginx 实现后端 Tomcat 的负载均衡调度

Nginx 实现后端 Tomcat 的负载均衡

nginx 配置如下

vim /etc/nginx/nginx.conf
#在http块中加以下内容
#注意名称不要用下划线

upstream tomcat-server {
    #ip_hash; # 先禁用看看轮询，之后开启开黏性,只根据客户端IP的前三位十进制数字
    #hash $remote_addr consistent; # 根据客户端IP的全部位
    #hash $cookie_JSESSIONID consistent; # 先禁用看看轮询，之后开启开黏性，JSESSIONID可以小写
    server t1.ayaka.org:8080;
    server t2.ayaka.org:8080;
}

server {
	location ~* \.(jsp|do)$ {
        proxy_pass http://tomcat-server;
        #proxy_set_header Host $http_host; #转发主机头至后端服务器
	}
}

测试 http://proxy.ayaka.org/index.jsp，可以看到轮询调度效果,每次刷新后端主机和SessionID都会变化

[root@proxy ~]#curl http://proxy.ayaka.org/index.jsp
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>tomcat test</title>
</head>
<body>
<h1> tomcat website </h1>
<div>On tomcat-server</div>
<div>10.0.0.101:8080</div>
<div>SessionID = <span
style="color:blue">2E4BFA5135497EA3628F1EBDAE62493E</span></div>
Thu Jul 09 17:58:06 CST 2020
</body>
</html>
[root@proxy ~]#curl http://proxy.ayaka.org/index.jsp
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>tomcat test</title>
</head>
<body>
<h1> tomcat website </h1>
<div>On tomcat-server</div>
<div>10.0.0.102:8080</div>
<div>SessionID = <span
style="color:blue">C5CC437BC05EE5A8620822CB07E71B7C</span></div>
Thu Jul 09 17:58:07 CST 2020
</body>
</html>

实现 Session 黏性

[root@proxy ~]#vim /etc/nginx/nginx.conf
#只添加ip_hash;这一行
upstream tomcat-server {
	ip_hash; # 先禁用看看轮询，之后开启开黏性,只根据客户端IP的前三位十进制数字
    #hash $remote_addr consistent; # 根据客户端IP的全部位
    #hash $cookie_JSESSIONID consistent; # 先禁用看看轮询，之后开启开黏性，JSESSIONID可以小写
    server t1.ayaka.org:8080;
    server t2.ayaka.org:8080;
}

配置完reload nginx服务。curl 测试一下看看效果。

#用curl访问每次都调度到10.0.0.102主机上，但因为curl每次请求不会自动携带之前获取的cookie,所有SessionID每次都在变化
[root@proxy ~]#curl http://proxy.ayaka.org/index.jsp
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>tomcat test</title>
</head>
<body>
<h1> tomcat website </h1>
<div>On tomcat-server</div>
<div>10.0.0.102:8080</div>
<div>SessionID = <span
style="color:blue">C471641C26865B08B2FDA970BE7C71A6</span></div>
Thu Jul 09 18:02:48 CST 2020
</body>
</html>
[root@proxy ~]#curl http://proxy.ayaka.org/index.jsp
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>tomcat test</title>
</head>
<body>
<h1> tomcat website </h1>
<div>On tomcat-server</div>
<div>10.0.0.102:8080</div>
<div>SessionID = <span
style="color:blue">3F61232DFD791A94D60D0D2E9561309A</span></div>
Thu Jul 09 18:02:52 CST 2020
</body>
</html>

通过图形浏览器看到主机不变，sessionID不变

实现 https 的负载均衡

范例：实现 https 的负载均衡

[root@rocky8 ~]#vim /etc/nginx/conf.d/blog.ayakakuya.com.conf
upstream blog {
    ip_hash;
    server 10.0.0.101:8080;
    server 10.0.0.102:8080;
}
server {
    listen 80;
    server_name blog.ayakakuya.com;
    return 302 https://$host$request_uri;
    #return 302 https://$server_name$request_uri; #$server_name 来自于上面的server_name,即blog.ayakakuya.com
}
server {
    listen 443 ssl;
    server_name blog.ayakakuya.com;
    ssl_certificate /etc/nginx/ssl/blog.ayakakuya.com.pem;
    ssl_certificate_key /etc/nginx/ssl/blog.ayakakuya.com.key;
    client_max_body_size 20m;
    location / {
        proxy_pass http://blog;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
}

#配置后端tomcat服务器
[root@rocky8 ~]#vim /usr/local/tomcat/conf/server.xml
...
#添加下面行
    <Host name="blog.ayakakuya.com" appBase="/data/blog"
            unpackWARs="true" autoDeploy="true">
    </Host>
#添加上面行
   </Engine>
  </Service>
</Server>
[root@rocky8 ~]#mkdir /data/blog -p
[root@rocky8 ~]#mv jpress-4.1.2.war /data/blog/ROOT.war
[root@rocky8 ~]#chown -R tomcat.tomcat /data/blog

#注意：先只在第一台tomcat服务器上配置完成初始化连接数据库和上传图片发表文章后，然后复制相关web文件至第二台主机即可，无需多次初始化
#配置后端数据库
[root@rocky8 ~]#yum -y install mysql-server
[root@rocky8 ~]#systemctl enable --now mysqld
mysql> create user blog@'10.0.0.%' identified by '123456';
mysql> create database jpress;
mysql> grant all on jpress.* to blog@'10.0.0.%';

#配置后端NFS共享存储
[root@rocky8 ~]#yum -y install nfs-utils
[root@rocky8 ~]#groupadd -g 80 www
[root@rocky8 ~]#useradd -g www -u 80 -s /sbin/nlogin www
[root@rocky8 ~]#mkdir /data/blog/ROOT/attachment -p
[root@rocky8 ~]#vim /etc/exports
[root@rocky8 ~]#cat /etc/exports
/data/blog/ROOT/attachment *(rw,all_squash,anonuid=80,anongid=80)
[root@rocky8 ~]#systemctl enable --now nfs-server.service
[root@rocky8 ~]#chown -R www.www /data/blog/ROOT/attachment
#tomcat服务器挂载 NFS共享
[root@rocky8 ~]#vim /etc/fstab
NFS服务器IP:/data/blog/ROOT/attachment /data/blog/ROOT/attachment nfs _netdev
0 0
[root@rocky8 ~]#yum -y install nfs-utils
[root@rocky8 ~]#mount -a

结合反向代理实现 Tomcat 部署

常见部署方式介绍

利用 Nginx 反向代理至同一个主机的 Tomcat

配置说明

实战案例1: 实现 HTTP

实战案例2：实现 HTTPS

利用 Nginx 实现动静分离代理

配置说明

实战案例

利用 Httpd 实现基于 AJP 协议的反向代理至后端Tomcat 服务器

AJP 协议说明

启用和禁用 AJP

Httpd 实现 AJP 反向代理

配置说明

实战案例

实现 Tomcat 负载均衡

HTTP的无状态，有连接和短连接

会话保持方式

Session sticky 会话黏性

Session 复制集群

Session Server

负载均衡规划和准备

负载均衡主机和网络地址规划

负载均衡tomcat主机准备

准备负载均衡规划测试用的 jsp文件

Nginx 实现后端 Tomcat 的负载均衡调度

Nginx 实现后端 Tomcat 的负载均衡

实现 Session 黏性

实现 https 的负载均衡

评论