24、Docker数据卷容器的说明与共享数据原理

### **1、数据卷容器的说明**
**（1）什么是数据卷容器**

一个容器中已经创建好的数据卷，其它容器通过这个容器实现数据共享。那么这个容器，称之为数据卷容器。（也可以说叫父容器）

**（2）数据卷容器的作用**

数据卷容器的作用就是，实现多个容器间的数据传递共享。

如果你有一些持续更新的数据需要在容器之间共享，最好创建数据卷容器。

数据卷容器，其实就是一个正常的容器，专门用来提供数据卷供其它容器挂载的。

**（3）需要使用的Docker参数**

`--volumes-from`：容器间传递共享。

**（4）补充：容器数据卷和数据卷容器的区别**

**Docker容器数据卷：**

- 文件是数据持久化的最常见的保存方式。
由于文件系统的隔离，以及本身是以沙盒形式运行等性质，使其对保存需要持久化的数据并不稳定。
对此，Docker使用了数据卷这种专门定制的形式。
- 数据卷就是一个挂载在容器内文件或目录。
在容器中，数据卷是从外界挂载到内部容器中的，所以可以脱离容器的生命周期而独立存在。
正式由于数据卷的生命周期并不等同于容器的生命周期，在容器退或者是删除之后，数据卷仍然不会受到影响，会依然存在于Docker中。

**数据卷的特点：**

数据卷中的数据并不能继承于镜像，也不在联合文件系统临时层所管理的范围内，所以镜像层面的写时复制不会作用于数据卷中的数据，而这些数据也不会被docker commit提交到新的镜像中。

1）文件的操作不是在沙盒环境中进行的，而是直接作用于宿主机内真实的硬盘I/O中；
2）外界直接挂在到容器中，脱离了容器的生命的周期；
3）生命周期不受容器控制，能够安全有效的存储文件到数据卷中；
4）数据卷独立于容器之外，可实现多个容器共享一个数据卷。
Docker数据卷容器：

将一个运行的容器作为数据卷，其他容器可以通过挂载这个容器（也叫父容器）实现数据共享。

优势：

- 1）轻松的将数据卷进行归类和汇总；
- 2）能够更好的管理容器与数据卷之间的关系；
- 3）更加合理的控制数据卷的生命周期。

### **2、数据卷容器共享数据原理**

我们以上一篇文章中创建的`wukong/centos`镜像为例，进行演示。

将会以`wukong/centos`镜像启动三个容器：`docker01-fu`、`docker02-zi`、`docker03-zi`。

**操作1：**

创建`docker01-fu`容器，并操作。

```python
# 1.查看本地docker镜像
[root@192 ~]# docker images
REPOSITORY      TAG       IMAGE ID       CREATED        SIZE
wukong/centos   1.0       98b1b6590b78   2 hours ago    209MB
centos          latest    300e315adb2f   3 months ago   209MB

# 2.运行wukong/centos镜像，创建docker01-fu容器
[root@192 ~]# docker run -it --name docker01-fu wukong/centos:1.0

# 3.查看该容器器内容
[root@d2ad442398d5 /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Mar 19 14:37 dev
drwxr-xr-x.   1 root root  66 Mar 19 14:37 etc
drwxr-xr-x.   2 root root   6 Nov  3 15:22 home
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3 15:22 lib64 -> usr/lib64
drwx------.   2 root root   6 Dec  4 17:37 lost+found
drwxr-xr-x.   2 root root   6 Nov  3 15:22 media
drwxr-xr-x.   2 root root   6 Nov  3 15:22 mnt
drwxr-xr-x.   2 root root   6 Nov  3 15:22 opt
dr-xr-xr-x. 123 root root   0 Mar 19 14:37 proc
dr-xr-x---.   2 root root 162 Dec  4 17:37 root
drwxr-xr-x.  11 root root 163 Dec  4 17:37 run
lrwxrwxrwx.   1 root root   8 Nov  3 15:22 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3 15:22 srv
dr-xr-xr-x.  13 root root   0 Mar 19 04:07 sys
drwxrwxrwt.   7 root root 145 Dec  4 17:37 tmp
drwxr-xr-x.  12 root root 144 Dec  4 17:37 usr
drwxr-xr-x.  20 root root 262 Dec  4 17:37 var
drwxr-xr-x.   2 root root   6 Mar 19 14:37 volume01  # 数据卷目录
drwxr-xr-x.   2 root root   6 Mar 19 14:37 volume02  # 数据卷目录
```

我们可以看到`wukong/centos`容器创建后，会挂载好`volume01`和`volume02`两个目录。

然后我们在`volume02`目录中创建一个`docker01-fu_add.txt`文件。

```python
# 创建文件
[root@d2ad442398d5 /]# mkdir /volume02/docker01-fu_add.txt

# 查看文件中的内容
[root@d2ad442398d5 /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
```

之后`ctrl + P + Q`退出容器。

**操作2：**

创建`docker02-zi`容器，并操作。

执行如下命令：

```python
docker run -it --name docker02-zi \
--volumes-from docker01-fu \
wukong/centos:1.0

```

演示：

```python
# 1.创建docker02-zi容器
[root@192 ~]# docker run -it --name docker02-zi \
> --volumes-from docker01-fu \
> wukong/centos:1.0
[root@0ce44b3e129e /]#

# 2.查看docker02-zi容器
[root@0ce44b3e129e /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Mar 19 14:56 dev
drwxr-xr-x.   1 root root  66 Mar 19 14:56 etc
drwxr-xr-x.   2 root root   6 Nov  3 15:22 home
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3 15:22 lib64 -> usr/lib64
drwx------.   2 root root   6 Dec  4 17:37 lost+found
drwxr-xr-x.   2 root root   6 Nov  3 15:22 media
drwxr-xr-x.   2 root root   6 Nov  3 15:22 mnt
drwxr-xr-x.   2 root root   6 Nov  3 15:22 opt
dr-xr-xr-x. 127 root root   0 Mar 19 14:56 proc
dr-xr-x---.   2 root root 162 Dec  4 17:37 root
drwxr-xr-x.  11 root root 163 Dec  4 17:37 run
lrwxrwxrwx.   1 root root   8 Nov  3 15:22 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3 15:22 srv
dr-xr-xr-x.  13 root root   0 Mar 19 04:07 sys
drwxrwxrwt.   7 root root 145 Dec  4 17:37 tmp
drwxr-xr-x.  12 root root 144 Dec  4 17:37 usr
drwxr-xr-x.  20 root root 262 Dec  4 17:37 var
drwxr-xr-x.   2 root root   6 Mar 19 14:37 volume01
drwxr-xr-x.   3 root root  33 Mar 19 14:48 volume02
# 我们可以看到docker02-zi容器中，也有volume01和volume02目录
# 因为他们是同一个镜像创建的容器。

# 我们查看volume02目录中的内容
[root@0ce44b3e129e /]# ls -l /volume02/
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
[root@0ce44b3e129e /]#
```

从上面看出，我们在新创建的`docker02-zi`容器中的，`/volume02/`数据卷目录中发现，有`docker01-fu`容器中创建的`docker01-fu_add.txt`文件。

**结论：`docker01-fu`容器中创建的内容，同步到了`docker02-zi`容器上面。**

说明：

`docker01-fu`容器就可以叫做父容器，也称之为数据卷容器。

**即：通过`--volumes-from`我们就可以是容器间的数据共享了。**

在`docker02-zi`容器的`/volume02/`目录中创建`docker02-zi_add.txt`文件。

```python
# 创建文件
[root@0ce44b3e129e /]# mkdir /volume02/docker02-zi_add.txt

# 查看文件中的内容
[root@0ce44b3e129e /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
```

之后`ctrl + P + Q`退出容器。

**操作3：**

创建docker03-zi容器，并操作。

执行如下命令：

```python
docker run -it --name docker03-zi \
--volumes-from docker01-fu \
wukong/centos:1.0
```

演示：

```python
# 1.创建docker03-zi容器
[root@192 ~]# docker run -it --name docker03-zi \
> --volumes-from docker01-fu \
> wukong/centos:1.0
[root@14e91c379eb0 /]#

# 2.我们查看volume02目录中的内容
[root@14e91c379eb0 /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
```

**结论：我们可以看到新创建的`docker03-zi`容器，同步了`docker01-fu`容器和`docker02-zi`容器中创建的文件。**

我们在`docker03-zi`容器中创建`docker03-zi_add.txt`文件。

```python
# 创建文件
[root@14e91c379eb0 /]# mkdir /volume02/docker03-zi_add.txt

# 查看文件中的内容
[root@14e91c379eb0 /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt

```

之后`ctrl + P + Q`退出容器。

**操作4：**

我们再到`docker01-fu`容器和`docker02-zi`容器中，看看是否能够同步到`docker03-zi`容器中创建的`docker03-zi_add.txt`文件。

![](https://cloud.cxykk.com/images/2024/2/2/1729/1706866145221.png)

演示：

```python
# 进入docker01-fu容器
[root@192 ~]# docker attach docker01-fu

# 查看/volume02目录中的内容
[root@d2ad442398d5 /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt
# ctrl + P + Q退出容器

# 进入docker01-fu容器
[root@192 ~]# docker attach docker02-zi

# 查看/volume02目录中的内容
[root@0ce44b3e129e /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt

```

**结论：我们从`docker01-fu`容器和`docker02-zi`容器中都可以看到，`docker03-zi`容器中创建的`docker03-zi_add.txt`文件。**

**说明：这三个容器可以之间可以互相同步数据。**

**操作5：**

我们现在把`docker01-fu`容器或直接删除停掉，看看`docker02-zi`容器和`docker03-zi`容器之间是否还能够同步数据。

![](https://cloud.cxykk.com/images/2024/2/2/1729/1706866150988.png)

演示：

```python
# 1.删除docker01-fu容器
[root@192 ~]# docker rm -f docker01-fu
docker01-fu

```

![](https://cloud.cxykk.com/images/2024/2/2/1729/1706866156738.png)

```python
# 2.进入docker02-zi容器
[root@192 ~]# docker attach docker02-zi

# 3.查看/volume02目录中内容，可以看到之前共享的数据还在。
[root@0ce44b3e129e /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt

# 4.在/volume02目录中内容创建docker02-zi_update.txt文件
[root@0ce44b3e129e /]# mkdir /volume02/docker02-zi_update.txt
[root@0ce44b3e129e /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:56 docker02-zi_update.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt
[root@0ce44b3e129e /]#

```

`ctrl + P + Q`退出容器。

```python
# 5.进入docker03-zi容器
[root@192 ~]# docker attach docker03-zi

# 6.查看/volume02目录中的内容
[root@14e91c379eb0 /]# ls -l /volume02
total 0
drwxr-xr-x. 2 root root 6 Mar 19 14:48 docker01-fu_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:01 docker02-zi_add.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:56 docker02-zi_update.txt
drwxr-xr-x. 2 root root 6 Mar 19 15:15 docker03-zi_add.txt
[root@14e91c379eb0 /]#
```

**结论：我们可以看到，删除了`docker01-fu`容器，原先三个容器同步的数据依然存在，并且`docker02-zi`容器和`docker03-zi`容器之间依然可以互相同步新增的数据。**

**操作6：**

我们还可以继续做如下操作，但是我们就进行叙述了，不进行代码演示了。

步骤（1）：如果在通过`wukong/centos`镜像，启动一个`docker04-zi`容器，`--volumes-from`于`docker03-zi`容器。

**结论：`docker04-zi`容器会和`docker02-zi`容器、`docker03-zi`容器，这三个容器之间互相同步数据。**

步骤（2）：如果按照操作（1）之后，把`docker03-zi`容器删除掉。

**结论：`docker04-zi`容器会和`docker02-zi`容器之间依然互相同步，且所有的数据都会存在。**

### **3、总结**

数据卷容器的生命周期为一直持续到没有容器使用它为止。

这相当于一种备份机制，可以利用数据卷容器来备份、恢复、迁移数据。

### **4、练习：MySQL实现数据共享**

目标：多个MySQL实现数据共享。

以MySQL 5.7镜像为例。

**步骤1：启动mysql-01镜像。**

```python
docker run -p 3310:3306 \
--name mysql-01 \
-v /etc/mysql/conf.d \
-v /var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:5.7
```
以匿名挂载的方式实现数据卷挂载。

**步骤2：启动mysql-02镜像。**

```python
docker run -p 3310:3306 \
--name mysql-02 --volumes-from mysql-01 \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:5.7
```

这个时候，就可以实现两个MySQL容器之间数据同步了。

**参考**：[https://www.cnblogs.com/bixiaoyu/p/9069778.html](https://www.cnblogs.com/bixiaoyu/p/9069778.html "https://www.cnblogs.com/bixiaoyu/p/9069778.html")