Docker之Dockerfile——数据卷、数据卷容器、指令说明、实战说明_dockerfile 数据卷

什么是Dockerfile

Dockerfile就是用来构建docker镜像的构建文件！
就是一段命令和脚本

方式二：脚本生成镜像

在home目录下创建一个文件夹

mkdir docker-test-volume
1

进入文件夹中，写一段脚本，通过这个脚本可以生成镜像

vim dockerfile1
1

FROM centos

VOLUME ["volume01","volume02"]

CMD echo "----end----"
CMD /bin/bash                   
1
2
3
4
5
6

生成镜像：

docker build -f /home/docker-test-volume/dockerfile1 -t cjh/centos:1.0 .
1

• 第一步给我们一个基础镜像
• 第二步通过VOLUME进行挂载
• 第三步执行我们自己的内部命令
• 第四步进入/bin/bash

这样我们自己的镜像就生成了

这就是生成镜像的第二种方式，之前的第一种方式是通过手动的，这里的每一个命令就是镜像的一层。

运行镜像

我们发现，我们自己挂载的两个目录也生成了，这个目录是我们生成镜像的时候自动生成的，数据卷目录

查看数据卷位置

这个卷和外部一定有一个同步的目录，并且它是一个匿名挂载，因为我们没有给他指定路径

所以我们进入目录创建一个文件

然后我们进入镜像看看详细信息

我们发现对应的挂载路径在这里：

"/var/lib/docker/volumes/92e241e4a1e3c794cb1b05452b92b1a9c6ffd0ac77124197384107de0a6e4eb9/_data",
1

我们进入看一下：

我们发现我们在镜像中创建的文件也在这里面，说明挂载成功

这种方式我们未来使用的非常多，因为我们通常会构建自己的镜像，假设构建镜像的时候没有挂载卷，要手动挂载
-v 卷名：容器内路径

数据卷容器

之前我们讲过的卷技术是基于容器和服务器之间形成数据同步，现在我们想要容器和容器之间的数据同步，但是我们知道容器和容器之间是互相隔离的，因此我们要用数据卷技术，使用命令：

--volumes-from
1

这个时候，被挂载的称为父容器，而挂载的容器称为子容器

这样就可以使得两个或者多个容器之间实行数据共享！

测试

环境准备

我们现在启动三个容器
我们先启动一个容器

docker run -it --name docker01 cjh/centos:1.0 
1

我们发现里面还有我们之前创建的两个数据卷。
我们ctrl+p+q来退出当前的容器并使之后台运行。

接着启动第二个容器，并挂载数据卷容器：
使用--volumes-from 被挂载的容器

docker run -it --name docker02 --volumes-from docker01 cjh/centos:1.0
1

我们发现它也存在两个数据卷

测试

现在我们测试一下，我们在docker01里创建一个文件，看看docker02是否也会生成文件。

我们使用命令进入docker01：

docker attach 容器ID
1

同时，我们在数据卷volume01中创建一个文件docker01

接着，我们发现在docker02容器中的volume01文件夹也有了docker01这个文件

说明挂载成功！
同时我们也可以多次挂载，这个思想类似于java中的子类继承父类

我们再创建一个容器，挂载到docker01，测试是否数据也会同步

我们发现也有了两个数据卷，并且数据也同步过来了

我们在docker03中创建docker03这个文件

接着我们在docker01查看是否有生成这个文件

结果也同步过来了，因此，只要通过--volume-from，一旦我们子容器挂载了我们父容器，那么所有的容器数据都会同步。

现在我们做一个操作，我们把docker01删除，看看数据是否存在

然后查看docker02，发现数据依旧存在，因此，数据挂载可以实现我们的数据持久化

我们画个图来理解这个机制：

他们的数据都是互相拷贝的，所以你删除其中一个，数据都可以在另外一个容器中找到，这就是数据卷容器。

数据库数据共享再实现

docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --NAME mysql01 mysql:5.7
1

docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --NAME mysql02 --volume-from mysql01 mysql:5.7
1

这个时候可以实现两个容器数据同步

结论

容器之间我们可以做配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止

但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

DockerFile构建

步骤

• 编写一个dockerfile文件
• docker build 构建成为一个镜像
• docker run 运行镜像
• docker push 发布镜像（DockerHub、阿里云镜像仓库）

我们很多官方的镜像都是一些基础的镜像，很多命令功能都没有，我们通常会自己搭建一个镜像，我们希望我们自己的镜像是centos+mysql+jdk+tomcat类似。

我们自己做一个自己的镜像，我们需要学习dockerfile的指令！

规则：

1. 它的每个指令都必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建一个新的镜像层，并提交
   

总结

dockerfile是面向开发的，我们以后要发布项目做镜像，就需要编写dockerfile文件，生成Docker镜像，并成为企业交付的标准！

Dockerfile：构建文件，定义一切步骤，源代码

DockerImages：通过Dockerfile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供服务器

Dockerfile指令

FROM      		 #基础镜像，一切从这里开始构建
MAINTAINER 		 #镜像是谁写的，姓名+邮箱
RUN     		 #Docker镜像构建的时候需要运行的命令
ADD     		#步骤，比如我们要加一个tomcat镜像，添加内容
WORKDIR  		 #镜像工作目录   可以自己指定
VOLUME   			#挂载的目录
EXPOSE  			 #指定暴露端口
RUN    
CMD  			 #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT  	 #指定这个容器启动的时候要运行的命令，可以**追加**命令
ONBUILD  		 #当构建一个被继承  DockerFile这个时候就会运行OBUILD的指令。
COPY   				#类似ADD，将我们的文件拷贝到镜像中
ENV 		 	#构建的时候设置环境变量
1
2
3
4
5
6
7
8
9
10
11
12
13

实战测试：构建自己的centos

我们先看官方是怎么构建的

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DockerHub中99%的镜像都是从这个基础镜像中过来的 ，然后配置我们需要的软件和配置来进行构建的。

FROM scratch
1

构建自己的centos

创建一个文件夹

这个文件夹用来存放我们以后自己写的Dockerfile

root@taobotics:/home#mkdir dockerfile
1

创建Dockerfile文件

我们自己创建的文件，名字可以自定义，我们这里叫dockerfile-centos

mkdir dockerfile-centos
1

root@taobotics:/home/dockerfile# vim mydockerfile-centos
root@taobotics:/home/dockerfile# cat mydockerfile-centos 
FROM centos    #以centos镜像作为基础镜像
MAINTAINER CJH<2221111@qq.com>  #添加我们的作者名字和邮箱

ENV MYPATH /usr/local  #设置工作环境
WORKDIR $MYPATH     #设置工作目录

RUN apt -y install vim   #下载vim这个工具
RUN apt -y install net-tools  #下载net-tools工具

EXPOSE 90     #暴露90端口

CMD echo $MYPATH   # 输出信息
CMD echo "----end----"  #输出信息
CMD /bin/bash   #工作面板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

构建Dockerfile

docker build -f dockerfile文件路径 -t 镜像名:[tag]

docker build -f mydockerfile-centos -t mycentos:0.1 .
1

测试运行

docker run -it  mycentos:0.1
1

对比

我们默认下载的官方的centos是一个压缩版的，没有很多命令，我们自己构建的centos是添加了命令的，并且我们配置了工作环境和工作目录。

CMD和ENTRYPOINT的区别

• CMD只有最后一个命令会生效，会替换之前的命令
• ENTRYPOINT命令会追加
  比如说，我们在我们的dockerfile文件中输入

CMD ["ls","-a"]
1

意思就是执行这个镜像之后，会自动把列表所有文件展示出来。
我们现在想让他展示更多的详细文件，ls -al

那么如果我们使用命令：docker run 容器id -l
显然会报错，原因就是我们的-l会替换掉ls -a这一个命令，并且我们是没有-l这一个命令的

因此，我们如果要追加命令，有两种方法：

• 第一种，我们不改变dockerfile文件内容，直接使用ls -al，在后面使用完整的新命令，这样CMD就会替换掉原本的命令。
• 第二种，我们使用ENTRYPOINT命令，其他内容不变，他就会追加命令，直接在后面加上-l，它就会自动追加，变成ls -al

构建Tomcat镜像

1. 准备镜像文件 tomcat压缩包，jdk压缩包
   使用rz命令上传本地的压缩包到我们的阿里云服务器上
2. 编写dockerfile文件

vim Dockerfile
1

注意：官方命名是Dockerfile，build会自动寻找这个文件，就不需要-f指定了

FROM centos
MAINTAINER CJH<XXXXXX@qq.com>

COPY readme.txt /usr/local/readme.txt
ADD jdk-8ull-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/

RUN apt -y install vim   #下载vim这个工具
RUN apt -y install net-tools  #下载net-tools工具

ENV MYPATH /usr/local  #设置工作环境变量
WORKDIR $MYPATH     #设置工作目录

ENV JAVA_HOME /usr/local/jdk1.8  #配置jdk环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.22
ENV CATALINA_BASH  /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE  8080

CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /url/local/apache-tomcat-9.0.22/bin/logs/catalina.out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

然后构建我们的镜像

docker build -t mytomcat .
1