文章目录

前言

部署

数据库部署
tomcat部署
Maven进行工程的打包
运行java容器部署后台项目

nginx

单个nginx
多nginx
使用keepalived来实现nginx的双机热备

后记

结语

前言

前面完成了对MySql与Redis集群的搭建，现在就需要完成将后端项目部署到自己搭建的这些集群上面，在面对数据库出现问题或是高并发时候，高负载环境下仍能正常的运行，满足我们实际需求。Redis也搭建了一个集群，也可以实现更多的缓存来实现。下面来具体学习以下：

部署

数据库部署

MySql测试链接：
在前面完成了从Docker内部映射到外部地址，并且实现了端口的映射，映射到3306端口，我们在Navicat 就可以进行测试链接。
后端项目的部署：
这里使用到人人网的开源项目进行学习：项目下载地址：renren-fast下载地址关于配置问题导入到自己的idea工具即可。
数据库集群的连接：
对于前面两章搭建好的数据库集群这里进行配置：首先是MySql数据库集群的配置：打开如下图片目录，进入到数据库源的配置：

在如下代码中写上自己之前配置出来的端口信息。

druid:
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://192.168.99.150:3306/renrenfast?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
            username: root
            password: 123456
            initial-size: 10
            max-active: 100
            min-idle: 10
            max-wait: 60000

然后打开同级目录下的application.yml文件填写上自己之前设置完成的redis数据库集群。

redis:
    open: false  # 是否开启redis缓存  true开启   false关闭
    database: 0
    port: 6379
    timeout: 6000ms  # 连接超时时长（毫秒）
    cluster:
          nodes:
            - 172.19.0.2:6379
            - 172.19.0.2:6379
            - 172.19.0.2:6379
            - 172.19.0.2:6379
            - 172.19.0.2:6379
            - 172.19.0.2:6379
    jedis:
      pool:
        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接

tomcat部署

与redis的配置文件同一个配置文件里面进行如下的配置：

server:
  tomcat:
    uri-encoding: UTF-8
    max-threads: 1000
    min-spare-threads: 30
  port: 6001
  connection-timeout: 5000ms
  servlet:
    context-path: /renren-fast

注意： 通过前面的配置我们知道，对于Mysql和Redi都进行了网段的划分，在自己的网段里面搭建起来了集群，此时若是我们的项目部署在另外一个网段，想要对数据库的调用访问时候就会出现问题，因为docker虚拟机是静止跨网段进行访问的。
这个时候，就需要把我部署我们java程序所在的网络部署到宿主机的网络上，就是说不为我们的java容器划分网段，直接使用到宿主机的网络，这个时候就可以访问所有的网段。但是我们的宿主机不可能只搭载一个程序，未来会搭载多个程序，我们就需要未每一个程序分配一个端口，未来使用起来也会更加的方便。

Maven进行工程的打包

在进行打包之前需要先进入到对应的目录下面就是renren项目对应的目录的下面：可以使用命令进行打包这里先学习命令打包的方法：

mvn clean install -Dmaven.test.skip=true;
// clean 表示清除之前打包的Jar文件。
// install: 表示打包到本地。
// -Dmaven.test.skip=true 最后一部分表示跳过测试代码。

这是使用到命令的方式，当然对于idea来说直接可以通过如下操作进行打包处理。

点击maven：
点击 LiftCycle 看到clean和下面的install。
点击clean 然后 install（注意使用这种方式，需要将代码中的test 代码注释掉。因为这样没有办法进行跳过test）如下表示成功。进行拷贝。

运行java容器部署后台项目

既然是要运行java项目，我们还是先要拉去java镜像：

docker pull java

如下查看你已经下载了哪些镜像
在这里插入图片描述
2. 我们知道需要使用到一个数据卷来容纳和运行我们的java程序

docker volume create j1
ls /var/lib/docker/volumes/j1/_data
// 可以使用到sftp将java文件上传到应数据卷目录下面
renren-fast.jar

创建一个容器名为j1.

docker run -it -d  --name j1 -v j1:/home/soft --net=host java

进入到容器的内部启动jar文件

docker exec -it j1 bash
// 启动java项目 注意 此时是后台运行 需要在前面加上 nohup。
nohup java -jar /home/soft/renren-fast.jar

测试访问，完成以上以后，我们就可以进行访问测试：出现没有办法访问的情况，可以开启防火墙设置。

完成以上的配置之后，虽然后端的健壮性和高，可以在Mysql数据库节点或是redis节点挂掉的时候仍然能够提供正常的服务，但是此时若是前端的Tomcat节点出现了故障，就完全不能够再访问，所以我们再任何可能会出现问题的地方都需要进行冗余节点的配置。
我们如法炮制上面的操作，对于数据库连接和redis连接都不变化，但是由于创建多个连接，所以修改tomcat的端口，设置6002 6003，然后打包，创建数据卷，容器，拷贝到容器内部执行等。

#创建数据卷，上传JAR文件
docker volume create j2
#启动容器
docker run -it -d --name j2 -v j2:/home/soft --net=host java
#进入j1容器
docker exec -it j2 bash
#启动Java项目
nohup java -jar /home/soft/renren-fast.jar

#创建数据卷，上传JAR文件
docker volume create j3
#启动容器
docker run -it -d --name j3 -v j3:/home/soft --net=host java
#进入j1容器
docker exec -it j3 bash
#启动Java项目
nohup java -jar /home/soft/renren-fast.jar

这个时候我们的三个端口都可以访问到我们的网页。可以自行测试，记得开放防火墙。

nginx

单个nginx

现在我们的三个后台程序都可以成功运行，但是是在三个端口进行运行，我们有也不可能将所有的请求都打在同一个端口（也不可能去记忆这些端口）所以就需要用到负载均衡，和之前数据库的原理是类似的。
前端接口的请求，由nginx进行负载均衡
在这里插入图片描述

首先还是下载安装nginx的镜像
配置文件编写:

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;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	upstream tomcat {
	# 自定义名称 下面就是ip地址和端口号
		server 192.168.99.101:6001;
		server 192.168.99.101:6002;
		server 192.168.99.101:6003;
	}
	server {
	# 服务端端口 配置转发
        listen       6101;
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://tomcat;
            index  index.html index.htm;
        }
    }
}

启动nginx 需要注意的一点是，这里启动时候没有使用数据卷，因为数据卷只能实现目录和目录的映射处理，这里我们是nginx的修改的配置文件，所以需要先在本地创建对应的文件夹将nginx配置文件放到其中。在home目录下面创建叫做n1的文件夹，然后再里面创建叫做nginx.conf 的配置文件。

docker run -it -d --name n1 -v /home/n1/nginx.conf:/etc/nginx/nginx.conf --net=host --privileged nginx

这个时候对于nginx就相当于已经启动了，我们可能访问6101 端口不会觉得有什么变化，其实对于nginx来说已经实现了负载均衡，我们可以进行测试，使用到挂掉j1容器，还有j2 与 j3 但是此时访问到6101 端口还是没有问题

docker pause j1

多nginx

经过我们前面的学习发现，此时对于一个nginx来说能够保证后端节点出现问题还能访问，但是若是这个nginx发生故障呢，岂不就是也不能够继续访问，所以我们需要实现nginx冗余节点。我们对下面的部分进行修改：

upstream tomcat {
	# 自定义名称 下面就是ip地址和端口号
		server 192.168.99.101:6001;
		server 192.168.99.101:6002;
		server 192.168.99.101:6003;
	}
	server {
	# 服务端端口 配置转发
        listen       6102;
        # 端口变成了6102 
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://tomcat;
            index  index.html index.htm;
        }
    }

前面的nginx第一个节点的操作就是先本机创建目录，同上面一样在相同的home下面创建叫做n2的文件夹里面使用touch创建nginx.conf ，然后将配置文件上传上去，再度创建一个nginx节点，测试访问也是没有问题的，这个时候，我们就可以开始对于nginx的双击热备的部署与学习了。

使用keepalived来实现nginx的双机热备

和之前一样，在docker内安装keepalived，然后设置虚拟的ip，让这两个keepalived去争抢虚拟ip。
在这里插入图片描述
之前我们不是已经创建完成了n1容器，现在进入到这个容器，来进行安装keepalived。

docker exec -it n1 bash  // 进入容器
apt-get update             // 执行更新
apt-get install keepalived  // 安装keepalived
apt-get install vim // 安装编译器，不然在容器内部无法使用 vim对配置文件的信息进行改动。

在以上完成之后就可以开始对keepalived配置文件进行具体的配置

vi  /etc/keepalived/keepalived.conf
# 完成以后使用 esc + wq 退出

配置文件的内容如下：

vrrp_instance VI_1 {
    state MASTER
    # 
    interface ens33 # 网卡 使用宿主机网络 网卡 宿主机网卡
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.151
        # 虚拟ip
    }
}
virtual_server 192.168.99.151 6201 {
# 表示这个ip和端口接受请求 然后转发到我们下面的ip和端口
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.101 6101 {
    # 真实宿主机ip地址 和之前我们接受的ip地址。
        weight 1
    }
}

然后启动keepalived。

service keepalived start

然后就可以使用192.168.99.151:6201+ 对应的原来的地址进行访问即可。
这个时候我们就是相当于在nginx第一个结点里面使用了一个keepalived实现由最开始的192.168.99.101:6101 转换成为192.168.99.151:6201。这个时候我们再度重复以上的操作实现第二个nginx结点里装配keepalived。

#进入n2节点 和n1结点的操作相同
docker exec -it n2 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件(如下)
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

配置信息：

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.151
    }
}
virtual_server 192.168.99.151 6201 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.104 6102 {
    # 真实机器的6201 端口。
        weight 1
    }
}

后记

以上我们就完成了对于后端项目的搭载和负均衡。下面我们来重新回顾一下具体的流程。

因为我们后端的Mysql数据库和Redis数据库都配置了集群的功能，所以修改配置文件改成我们数据库的集群。
完成以后，因为不可能只搭建一个java后端项目，我们想着出问题了那之前的数据库集群也都白费了，所以搭建了三个java后端项目，端口非别是 6001 ,6002,6003 。但是我们访问不可能还记录端口，并且请求都落在同一个端口上面岂不是压力就会很大，所以想到了使用nginx负载均衡。
这个时候我们就搭建一个nginx1负载均衡，端口映射到6101 端口，就可以使用主机ip地址+6101 端口进行访问，这个时候我们做了尝试发现就算是停掉一个java容器还是可以继续运行。
但是我们又想到了要是对于这个nginx节点也出现了问题呢，不还是会所有的端口都不能能够正常访问，所以我们又创建了一个nginx节点，端口是6201，这个时候，两个端口都可以进行访问。
当然我们创建多个端口的意义就是能够实现双机，就使用到了keepalived，我们在之前配置好的两个nginx容器都安装keepalived并修改配置文件，实现ip地址的映射。这样就可以使用到虚拟的ip地址+6201端口进行访问。
所以前端访问 192.168.99.151 6201端口，转发到192.168.99.101:6101,192.168.99.101:6201上(两个nginx)。然后每一个nginx结点下面都有 192.168.99.6001,6002,6003三个java服务器，保证在一个nginx出现故障并且java容器也出现故障的时候还能够提供正常的服务。

结语

以上就是在Mysql和Redis数据库集群上搭建后端项目，并实现nginx的负载均衡了，有什么不得体或是没有看懂的地方大家可以指出来，我也一定及时进行更改！！！谢谢。

基于Mysql与Redis集群上的后端项目搭载与负载均衡