Docker数据持久化及实战(Nginx+Spring Boot项目+MySQL)

shasha 2021年06月07日程序员 307 0

Docker数据持久化：

Volume：

(1)创建mysql数据库的container

docker run -d --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 mysql

(2)查看volume docker volume ls

(3)具体查看该volume docker volume inspect bba71cbbe0f86c0208f62077974261fc80c6795b9a51995c4ba0d0c7d563d7a2

(4)名字不好看，name太长，修改一下，先删除原来的

docker volume rm -f bba71cbbe0f86c0208f62077974261fc80c6795b9a51995c4ba0d0c7d563d7a2

　　"-v mysql01_volume:/var/lib/mysql"表示给上述的volume起一个能识别的名字

docker run -d --name mysql01 -v mysql01_volume:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql

(5)查看volume

docker volume ls 
docker volume inspect mysql01_volume

(6)真的能够持久化保存数据吗？不妨来做个实验

# 进入容器中 docker exec -it mysql01 bash

# 登录mysql服务 mysql -uroot -p123456

# 创建测试库 create database db_test

# 查看数据库 show databases

# 退出mysql服务，退出mysql container

# 删除mysql容器 docker rm -f mysql01

# 查看volume docker volume ls 发现volume 还在。

# 新建一个mysql container，并且指定使用"mysql01_volume"

docker run -d --name test-mysql -v mysql01_volume:/var/lib/mysql -e  MYSQL_ROOT_PASSWORD=123456 mysql

# 进入容器，登录mysql服务，查看数据库

docker exec -it test-mysql bash 
mysql -uroot -p123456 
show databases;

会发现我们删除容器之前创建的数据库还在：

Bind Mounting：

(1)创建一个tomcat容器

docker run -d --name tomcat01 -p 9090:8080 -v /tmp/test:/usr/local/tomcat/webapps/test tomcat

(2)查看两个目录

centos：cd /tmp/test 
tomcat容器：cd /usr/local/tomcat/webapps/test

　　内容如下：目前都是空的

(3)在centos的/tmp/test中新建1.html，并写一些内容

<p style="color:blue; font-size:20pt;">This is p!</p>

(4)进入tomcat01的对应目录查看，发现也有一个1.html，并且也有内容

(5)在centos7上访问该路径：curl localhost:9090/test/1.html

(6)在win浏览器中通过ip访问

Docker实战：

　　MySQL高可用集群搭建：

　　这里采用docker官方提供的强一致性的数据同步的mysql集群方案 PXC(percona-xtradb-cluster)

(1) 拉取pxc镜像

docker pull percona/percona-xtradb-cluster:5.7.21

(2) 复制pxc镜像(实则重命名)

docker tag percona/percona-xtradb-cluster:5.7.21 pxc

(3)删除pxc原来的镜像

docker rmi percona/percona-xtradb-cluster:5.7.21

(4) 创建一个单独的网段，给mysql数据库集群使用

docker network create --subnet=172.18.0.0/24 pxc-net
docket network inspect pxc-net [查看详情]
docker network rm pxc-net [删除]

(5) 创建和删除volume

创建：docker volume create --name v1
删除：docker volume rm v1
查看详情：docker volume inspect v1

准备3个数据卷

docker volume create --name v1
docker volume create --name v2
docker volume create --name v3

(6) 创建单个PXC容器demo

[CLUSTER_NAME PXC集群名字]
[XTRABACKUP_PASSWORD数据库同步需要用到的密码]
[CLUSTER_JOIN将该数据库加入到某个节点上组成集群]

docker run -d -p 3301:3306 -v v1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 --privileged --name=node1 --net=pxc-net --ip 172.18.0.2 pxc 
docker run -d -p 3302:3306 -v v2:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=node1 --privileged --name=node2 --net=pxc-net --ip 172.18.0.3 pxc 
docker run -d -p 3303:3306 -v v3:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=node1 --privileged --name=node3 --net=pxc-net --ip 172.18.0.4 pxc

　　创建3个容器：

　　查看容器：

　　然后通过 navicat 去测试链接：

　　连上三台数据库，并且在node1上创建一个数据库db_test，刷新后其他两个节点也会创建，集群搭建完成：

数据库的负载均衡：

(1)拉取haproxy镜像

docker pull haproxy

(2)创建haproxy配置文件，这里使用bind mounting的方式

　　haproxy.cfg：

global 
#工作目录，这边要和创建容器指定的目录对应 
chroot /usr/local/etc/haproxy 
#日志文件 
log 127.0.0.1 local5 info 
#守护进程运行 
daemon 
defaults 
log global 
mode http 
#日志格式 
option httplog 
#日志中不记录负载均衡的心跳检测记录 
option dontlognull 
#连接超时（毫秒） 
timeout connect 5000 
#客户端超时（毫秒） 
timeout client 50000 
#服务器超时（毫秒） 
timeout server 50000 
#监控界面 
listen admin_stats 
#监控界面的访问的IP和端口 
bind 0.0.0.0:8888 
#访问协议 
mode http 
#URI相对地址 
stats uri   /dbs_monitor 
#统计报告格式 
stats realm   Global\ statistics 
#登陆帐户信息 
stats auth admin:admin 
#数据库负载均衡 
listen proxy-mysql 
#访问的IP和端口，haproxy开发的端口为3306 
#假如有人访问haproxy的3306端口，则将请求转发给下面的数据库实例 
bind 0.0.0.0:3306 
#网络协议 
mode tcp 
#负载均衡算法（轮询算法） 
#轮询算法：roundrobin 
#权重算法：static-rr 
#最少连接算法：leastconn 
#请求源IP算法：source 
balance roundrobin 
#日志格式 
option tcplog 
#在MySQL中创建一个没有权限的haproxy用户，密码为空。 
#Haproxy使用这个账户对MySQL数据库心跳检测 
option mysql-check user haproxy 
server MySQL_1 172.18.0.2:3306 check weight 1 maxconn 2000 
server MySQL_2 172.18.0.3:3306 check weight 1 maxconn 2000 
server MySQL_3 172.18.0.4:3306 check weight 1 maxconn 2000 
#使用keepalive检测死链 
option tcpka

(3)创建haproxy容器，与mysql一个网段

docker run -it -d -p 8888:8888 -p 3306:3306 -v  /tmp/haproxy:/usr/local/etc/haproxy --name haproxy01 --privileged --net=pxc-net haproxy

(4)根据haproxy.cfg文件启动haproxy，一定要启动不然连接不上

docker exec -it haproxy01 bash 
haproxy -f /usr/local/etc/haproxy/haproxy.cfg

　　登录haproxy控制台：

(5)要通过 haproxy 连接到mysql 需要在MySQL数据库上创建用户，用于心跳检测

CREATE USER 'haproxy'@'%' IDENTIFIED BY ''; 
[小技巧[如果创建失败，可以先输入一下命令]: 
  drop user 'haproxy'@'%'; 
 flush privileges; 
  CREATE USER 'haproxy'@'%' IDENTIFIED BY ''; 
]

(8)在haproxy连接上进行数据操作，然后查看数据库集群各个节点，发现数据都会保持一致

Nginx+Spring Boot项目+MySQL:

(1)网络由于上面的集群demo中占用了18.所以我们这里直接使用 pxc-net

docker network create --subnet=172.18.0.0/24 pro-net

(2)网络划分

mysql--172.18.0.6
spring boot--172.18.0.11/12/13
nginx--172.18.0.10

MySQL:

(1)创建volume

docker volume create v4

(2)创建mysql容器

docker run -d --name my-mysql -v v4:/var/lib/mysql -p 3301:3306 -e MYSQL_ROOT_PASSWORD=123456 --net=pxc-net --ip 172.18.0.6 mysql

(3)连接mysql，如果报错：Authentication plugin 'caching_sha2_password' cannot be loaded ，进入容器，mysql -uroot -ppassword 执行如下命令。

ALTER USER 'root' IDENTIFIED WITH mysql_native_password BY 'password';

　　然后执行如下脚本：

create schema db_gupao_springboot collate utf8mb4_0900_ai_ci; 
use db_gupao_springboot; 
create table t_user 
( 
id int not null 
primary key, 
username varchar(50) not null, 
password varchar(50) not null, 
number varchar(100) not null 
);

　　然后自己随机插入几条数据。至此mysql镜像完成。接下去看springboot项目

Spring Boot项目:

　　Spring Boot+MyBatis实现CRUD操作，名称为“springboot-mybatis”，先看一下其中有哪些文件：

@RestController 
@RequestMapping(value="/user",method = {RequestMethod.GET,RequestMethod.POST}) 
public class UserController { 
    @Autowired 
    private UserService userService; 
 
 
    @RequestMapping("/listall") 
    @ResponseBody 
    public List<User> listAll(){ 
        return userService.listUser(); 
    } 
} 
@Repository 
@Mapper 
public interface UserMapper { 
    List<User> list(); 
} 
public class User { 
    private int id; 
    private String username; 
    private String password; 
    private String number; 
    。。。。。 
} 
@Service 
public class UserService { 
 
    @Autowired 
    private UserMapper userMapper; 
 
    public List<User> listUser() { 
        return userMapper.list(); 
    } 
} 
@SpringBootApplication 
public class SpringbootMybatisApplication { 
 
    public static void main(String[] args) { 
        SpringApplication.run(SpringbootMybatisApplication.class, args); 
    } 
 
}

　　mybatis配置文件：

<?xml version = "1.0" encoding = "UTF-8"?> 
<!DOCTYPE mapper PUBLIC 
        "-//mybatis.org//DTD com.example.Mapper 3.0//EN" 
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="com.gupao.springbootmybatis.dao.UserMapper"> 
    <resultMap id="result" type="com.gupao.springbootmybatis.domain.User"> 
        <result property="username" column="username"/> 
        <result property="password" column="password"/> 
        <result property="number" column="number"/> 
    </resultMap> 
 
    <select id="list" resultMap="result"> 
        SELECT * FROM t_user 
    </select> 
 
</mapper>

　　yml:

# 数据源 
spring: 
  datasource: 
    ### 在同一个网络中，bridge  pro-net   容器之间不仅可以通过ip访问，而且可以通过名称 
    url: jdbc:mysql://172.18.0.6:3306/db_gupao_springboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC 
    username: root 
    password: jack123 
    driver-class-name: com.mysql.cj.jdbc.Driver 
 
# mybatis托管mapper文件 
mybatis: 
  mapper-locations: classpath:mapper/*.xml

　　pom:

<?xml version="1.0" encoding="UTF-8"?> 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <parent> 
        <groupId>org.springframework.boot</groupId> 
        <artifactId>spring-boot-starter-parent</artifactId> 
        <version>2.1.6.RELEASE</version> 
        <relativePath/> <!-- lookup parent from repository --> 
    </parent> 
    <groupId>com.gupao</groupId> 
    <artifactId>springboot-mybatis</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <name>springboot-mybatis</name> 
    <description>Demo project for Spring Boot</description> 
 
    <properties> 
        <java.version>1.8</java.version> 
    </properties> 
 
    <dependencies> 
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId> 
        </dependency> 
 
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-test</artifactId> 
            <scope>test</scope> 
        </dependency> 
 
        <dependency> 
            <groupId>mysql</groupId> 
            <artifactId>mysql-connector-java</artifactId> 
        </dependency> 
 
        <dependency> 
            <groupId>org.mybatis.spring.boot</groupId> 
            <artifactId>mybatis-spring-boot-starter</artifactId> 
            <version>1.3.1</version> 
        </dependency> 
    </dependencies> 
 
    <build> 
        <plugins> 
            <plugin> 
                <groupId>org.springframework.boot</groupId> 
                <artifactId>spring-boot-maven-plugin</artifactId> 
            </plugin> 
        </plugins> 
 
    </build> 
</project>

(1)在本地测试该项目的功能:主要是修改application.yml文件中数据库的相关配置

(2)在项目根目录下执行mvn clean package打成一个jar包

[记得修改一下application.yml文件数据库配置] 
mvn clean package -Dmaven.test.skip=true 
在target下找到"springboot-mybatis-0.0.1-SNAPSHOT.jar.jar"

(3)在docker环境中新建一个目录"springboot-mybatis"

(4)上传"springboot-mybatis-0.0.1-SNAPSHOT.jar"到该目录下，并且在此目录创建Dockerfile

(5)编写Dockerfile内容

FROM openjdk:8-jre-alpine 
MAINTAINER itcrazy2016 
LABEL name="springboot-mybatis" version="1.0" author="itcrazy2016" 
COPY springboot-mybatis-0.0.1-SNAPSHOT.jar springboot-mybatis.jar 
CMD ["java","-jar","springboot-mybatis.jar"]

(6)基于Dockerfile构建镜像 docker build -t sbm-image . 构建完查看images：

(7)基于image创建container

docker run -d --name sb01 -p 8081:8080 --net=pxc-net --ip 172.18.0.11 sbm-image

(8)查看启动日志docker logs sb01 查看容器是否正常运行。

(9)在win浏览器访问http://192.168.8.118:8081/user/listall。能正常获取数据说明没问题。

网络问题:

　　因为sb01和my-mysql在同一个bridge的网段上，所以是可以互相ping通，比如

docker exec -it sb01 ping 172.18.0.6 
or 
docker exec -it sb01 ping my-mysql

　　so? application.yml文件不妨这样修改一下？也就是把ip地址直接换成容器的名字

url: jdbc:mysql://my-mysql/db_gupao_springboot?

　　当然是没问题的。

　　创建多个项目容器：

docker run -d --name sb01 -p 8081:8080 --net=pxc-net --ip 172.18.0.11 sbm-image 
docker run -d --name sb02 -p 8082:8080 --net=pxc-net --ip 172.18.0.12 sbm-image 
docker run -d --name sb03 -p 8083:8080 --net=pxc-net --ip 172.18.0.13 sbm-image

　　创建完依次用浏览器测试。

Nginx：

(1)在centos的/tmp/nginx下新建nginx.conf文件，并进行相应的配置

user nginx; 
worker_processes 1; 
events { 
 worker_connections 1024; 
} 
http { 
 include /etc/nginx/mime.types; 
 default_type application/octet-stream; 
 sendfile    on; 
 keepalive_timeout 65; 
 
 server { 
   listen 80; 
   location / { 
    proxy_pass http://balance; 
   } 
 } 
 
 upstream balance{ 
   server 172.18.0.11:8080; 
   server 172.18.0.12:8080; 
   server 172.18.0.13:8080; 
 } 
 include /etc/nginx/conf.d/*.conf; 
}

(2)创建nginx容器

　　注意：先在centos7上创建/tmp/nginx目录，并且创建nginx.conf文件，写上内容

docker run -d --name my-nginx -p 80:80 -v /tmp/nginx/nginx.conf:/etc/nginx/nginx.conf --network=pxc-net --ip 172.18.0.10 nginx

(3)win浏览器访问: ip[centos]/user/listall .发现没问题

　　至此集群搭建完毕。

IT序号网 Docker

微信公众号号：IT虾米（左侧二维码扫一扫）欢迎添加！

Q : 823053937

热贴推荐

Docker数据持久化及实战(Nginx+Spring Boot项目+MySQL)

Docker数据持久化：

Volume：

Bind Mounting：

Docker实战：

数据库的负载均衡：

Nginx+Spring Boot项目+MySQL:

MySQL:

Spring Boot项目:

网络问题:

Nginx：

Q : 823053937

热贴推荐

Docker数据持久化及实战(Nginx+Spring Boot项目+MySQL)

Docker数据持久化：

Volume：

Bind Mounting：

Docker实战：

数据库的负载均衡：

Nginx+Spring Boot项目+MySQL:

MySQL:

Spring Boot项目:

网络问题:

Nginx：

docker常用命令

docker容器中安装vim

Docker示例

开始docker

Docker 创建image

理解镜像，容器，存储引擎

Dcokerfile 参考

Docker 存储引擎

在容器中管理数据

容器网络配置

Docker 容器网络

Docker 网络命令