什么是容器数据卷

将应用和环境打包成一个镜像。
如果数据都在容器当中，那么我们容器删除，数据就会丢失。 需求：数据可以持久化。
MySQL，容器删除了，等于删库跑路。需求：MySQL数据可以存储在本地。

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地主机。
这种技术就是卷技术！目录的挂载，将我们容器内的目录，挂载到主机的指定目录上面。

image.png
总结一句话： 容器的持久化和同步操作！容器间也是可以数据共享的。
**

使用数据卷

方式一：直接使用命令挂载 -v

  1. -v, --volume list    # 绑定挂在卷
  3. docker run -it -v 主机目录:容器内目录 -p 主机端口:容器内端口
  5. # /home/ceshi: 主机home目录下的ceshi文件夹 映射：centos容器中的/home
  6. docker run -it -v /home/ceshi:/home centos /bin/bash
  7. #这时候主机的/home/ceshi文件夹就和容器的/home文件夹关联了，二者可以实现文件或者数据同步了
  9. # 通过 docker inspect 容器Id 查看
  10. docker inspect 6064c490c371

image.png=
测试文件的同步
image.png
再来测试： 1、停止容器，2、宿主机修改文件，3.启动容器，4、容器内的数据依旧是同步的。
image.png
通过使用数据卷的方式，可以使得以后修改数据或配置信息的时候，只需要在本地进行修改即可，挂载的对应的容器内的路径会自动实现同步。

方式二：通过Dockfile脚本进行挂载

具体操作请看下面的【初识Dockerfile】

实战：安装MySQL

思考：MySQL的数据持久化的问题

  1. # 获取mysql镜像
  2. docker pull mysql:5.7
  4. # 运行容器，需要做数据挂载
  5. # 安装启动mysql，需要配置密码的，这是要注意的地方
  6. # 参考DockerHub
  7. docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
  9. # 启动我们得
  10. -d 后台运行
  11. -p 端口映射
  12. -v 卷挂载
  13. -e 环境配置
  14. --name 容器名称
  15. $ docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -name mysql03 mysql:5.7
  17. # 启动成功之后，我们本地使用navicat测试一下
  18. # navicat - 连接到服务器的3310 -- 和 容器内的3306映射

image.png
当我们在本地用Navicat新建名称为test的数据库的时候，容器内的对应目录也会创建test相关的文件。
image.png
假设我们将包含mysql的容器删除时，可以发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化的过程。

具名挂载和匿名挂载

  1. # 匿名挂载
  2. -v 容器内路径
  3. $ docker run -d -P --name nginx01 -v /etc/nginx nginx
  5. # 查看所有的volume（卷）的情况
  6. $ docker volume ls
  7. DRIVER              VOLUME NAME # 容器内的卷名(匿名卷挂载)
  8. local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
  9. local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
  11. # 这里发现，这种就是匿名挂载，我们在 -v后面只写了容器内的路径，没有写主机的路径
  14. # 具名挂载 
  15. -P 表示随机映射端口
  16. -v 卷名:容器内的路径
  17. $ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
  18. 9663cfcb1e5a9a1548867481bfddab9fd7824a6dc4c778bf438a040fe891f0ee
  20. # 查看所有的volume（卷）的情况
  21. $ docker volume ls
  22. DRIVER              VOLUME NAME
  23. local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
  24. local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
  25. local               juming-nginx #多了一个名字
  27. $ docker volume inspect juming-nginx 
  28. [
  29.     {
  30.         "CreatedAt": "2020-05-23T13:55:34+08:00",
  31.         "Driver": "local",
  32.         "Labels": null,
  33.         "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data", #默认目录
  34.         "Name": "juming-nginx",
  35.         "Options": null,
  36.         "Scope": "local"
  37.     }
  38. ]

所有的docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/自定义的卷名/_data 下，如果指定了目录， docker volume ls 是查看不到的。
image.png

区分三种挂载方式

  1. # 三种挂载： 匿名挂载、具名挂载、指定路径挂载
  2. -v 容器内路径     # 匿名挂载
  3. -v 卷名:容器内路径 # 具名挂载
  4. -v /宿主机路径:容器内路径    #指定路径挂载 docker volume ls 是查不到的
  6. # 扩展 ro 和 rw
  7. # 通过 -v 容器内路径:ro/rw 改变读写权限
  8. ro # readonly 只读
  9. rw # readwrite 可读可写（默认）
  10. $ docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
  11. $ docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx
  13. # ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部无法操作。

初识Dockerfile

编写Dockerfile脚本

Dockerfile就是用来构建docker镜像的构建文件。命令脚本。
通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个个的命令，每个命令都是一层的。

  1. # 创建一个dockerfile文件，名字可以随便，建议Dockerfile
  2. # 文件中的内容： 指令（大写） + 参数
  3. $ vim dockerfile
  5. FROM centos                     # 当前这个镜像是以centos为基础的
  6. VOLUME ["volume01","volume02"]  # 挂载卷的卷目录列表(多个目录)
  7. CMD echo "-----end-----"        # 输出一下用于测试
  8. CMD /bin/bash                   # 默认走bash控制台

通过Dockerfile构建镜像

  1. # 这里的每个命令，就是镜像的一层。
  2. # 构建出这个镜像
  4. -f dockerfile              # f 代表 file，指这个当前文件的地址（这里是当前目录下的dockerfile）
  5. -t test/centos              # t 代表 target, 指目标目录（注意test镜像名前不能加斜杠 '/'）
  6. .                                            # 表示生成在当前目录下
  7. $ docker build -f dockerfile -t test/centos .
  9. Sending build context to Docker daemon   2.56kB
  10. Step 1/4 : FROM centos
  11. latest: Pulling from library/centos
  12. 8a29a15cefae: Already exists 
  13. Digest: sha256:fe8d824220415eed5477b63addf40fb06c3b049404242b31982106ac204f6700
  14. Status: Downloaded newer image for centos:latest
  15.  ---> 470671670cac
  16. Step 2/4 : VOLUME ["volume01","volume02"]             # 卷名列表
  17.  ---> Running in c18eefc2c233
  18. Removing intermediate container c18eefc2c233
  19.  ---> 623ae1d40fb8
  20. Step 3/4 : CMD echo "-----end-----"                    # 输出 脚本命令
  21.  ---> Running in 70e403669f3c
  22. Removing intermediate container 70e403669f3c
  23.  ---> 0eba1989c4e6
  24. Step 4/4 : CMD /bin/bash
  25.  ---> Running in 4342feb3a05b
  26. Removing intermediate container 4342feb3a05b
  27.  ---> f4a6b0d4d948
  28. Successfully built f4a6b0d4d948
  29. Successfully tagged test/centos:latest
  31. # 查看自己构建的镜像
  32. $ docker images
  33. REPOSITORY          TAG          IMAGE ID            CREATED              SIZE
  34. test/centos               latest       f4a6b0d4d948        About a minute ago   237MB

image.png

启动自己写的容器镜像

  1. $ docker run -it f4a6b0d4d948 /bin/bash # 运行自己写的镜像
  2. $ ls -l # 查看目录

image.png
这个卷和外部一定有一个同步的目录。

  1. VOLUME ["volume01", "volume02"]

查看一下卷挂载

  1. # docker inspect 容器id
  2. $ docker inspect ca3b45913df5

image.png
测试一下刚才的文件是否同步出去了
image.png
这种方式使用的十分多，因为我们通常会构建自己的镜像。
假设构建镜像的时候没有挂载卷，那就需要手动镜像挂载 -v 卷名:容器内路径

数据卷容器

多个MySQL同步数据

命名的容器挂载数据卷
image.png

  1. # 测试 启动3个容器，通过刚才自己写的镜像启动
  2. # 创建docker01
  3. $ docker run -it --name docker01 test/centos:lastest
  5. # 查看容器docker01内容
  6. $ ls
  7. bin  home   lost+found    opt   run   sys  var
  8. dev  lib    media    proc  sbin  tmp  volume01
  9. etc  lib64  mnt        root  srv   usr  volume02
  11. # 不关闭该容器退出
  12. CTRL + Q + P
  14. # 创建docker02：并且让docker02 继承 docker01
  15. $ docker run -it --name docker02 --volumes-from docker01 test/centos:lastest
  17. # 查看容器docker02内容
  18. $ ls
  19. bin  home   lost+found    opt   run   sys  var
  20. dev  lib    media    proc  sbin  tmp  volume01
  21. etc  lib64  mnt        root  srv   usr  volume02

image.png

  1. # 再新建一个docker03同样继承docker01
  2. $ docker run -it --name docker03 --volumes-from docker01 test/centos:lastest
  3. $ cd volumn01 # 进入voluimn01 查看是否也同步docker01的数据
  4. $ ls
  5. docker01.txt
  7. # 测试：可以删除docker01，查看一下docker-2和docker03是否可以访问这个文件
  8. # 测试发现：数据依旧保留在docker02 和 docker03中没有删除

image.png

多个mysql实现数据共享

  1. $ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
  3. $ docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7
  5. # 这个时候，就实现了两个容器的数据同步。

结论
容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到本地，这个时候，本地的数据是不会删除的。