Docker详解

一、Docker概述

1.1、Docker为什么出现

1、一款产品：开发–上线 两套环境！应用环境，应用配置！

环境配置是十分麻烦的事，每一个机器都要部署环境（集群Redis、ES、Hadoop…）费时费力

2、原来发布项目 jar、war

但是环境不会一起打包

如果可以发布项目（jar+（Redis MySql jdk es））那样就会方便很多

之前在服务器配置一个应用的环境Redis MySql jdk ES Hadoop ，配置非常麻烦，不能够跨平台

• 传统：开发jar，运维来配置环境
• 现在：开发打包部署上线，一套流程做完

Docker给以上问题提出了解决方案

java—jar（环境）—打包项目带上环境（镜像）—（Docker仓库：商店），运维要用，直接下载我们发布的镜像，直接运行即可

隔离：Docker核心思想，打包装箱，每个箱子是互相隔离的

Docker通过隔离机制，可以将服务器利用到极致

1.2、Docker的历史

2010年，几个搞IT的年轻人，在美国成立了一家公司 dotCloud ，做一些pass的云计算服务，LXC有关的容器技术

他们将自己的技术（容器化技术）命名就是Docker

Docker刚刚诞生的时候，没有引起行业的注意，于是想到开源

2013年，Docker开源

Docker越来越多的人发现了它的优点，于是火了，Docker一开始每个月都会更新一个新的版本

2014年4月9日，Docker1.0发布

• Docker为什么这么火？

轻巧！在容器技术出来之前，我们都是使用虚拟机技术

虚拟机：在windows中装一个Vmware，通过这个软件我们可以虚拟出一台或者多台电脑，很笨重！

docker：隔离，镜像，十分的小巧，运行镜像就可以了。

• Docker是基于Go语言开发，开源项目
• 官网：https://www.docker.com
• 文档！Docker的文档是超级详细的 。一定要结合文档学习
• 仓库地址：https://hub.docker.com

1.3、Docker能做什么

1. 虚拟机技术缺点：

• 资源占用十分多
• 冗余步骤多
• 启动很慢

2. 容器化技术：

• 容器化技术不是模拟的一个完整的操作系统
• 隔离

3. 比较Docker和虚拟机技术的不同：

• 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
• 容器内的应用直接运行在宿主机的内核，容器没有自己的内核，也没有虚拟我们的硬件，所以就轻便了
• 每个容器是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响

4. DevOps（开发、运维）

应用更快速的交付和部署

传统：一堆帮助文档，安装程序，配置环境

Docker：打包镜像发布测试，一键运行

更便捷的升级和扩缩容

使用了Docker之后，我们部署应用就和搭积木一样

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的

更高效的计算资源利用

Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例。服务器的性能可以发挥到极致！

二、Docker安装

2.1、Docker的基本组成

客户端—服务器—仓库

1. 镜像（image）：

docker镜像就好比是一个模板，可以通过这个模板来创建容器服务

2. 容器（container）：

Docker利用容器技术，独立运行一个或者一各组应用，通过镜像来创建的

启动，停止，删除，基本命令！

3. 仓库（repository）：

仓库就是存放镜像的地方！

仓库分为公有仓库和私有仓库！Docker Hub（默认是国外的）

阿里云…都有容器服务器（配置镜像加速）

2.2、安装Docker

1、准备：

• 一台服务器（云服务器或者虚拟机）
• CentOS7
• 环境查看

3.10.0-1160.el7.x86_64

系统内核需要是3.10以上

• 系统版本

[root@localhost ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

2、安装

• 先卸载

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce
                  
                  

• 需要的安装包

yum install -y yum-utils

• 设置镜像仓库

yum-config-manager \

    --add-repo \

    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

• 更新软件包索引

yum makecache fast

• 安装docker

yum install docker-ce docker-ce-cli containerd.io

• 启动docker

systemctl start docker

• 检查是否安装成功

docker version

• 使用docker

docker run hello-world

出现 Hello from Docker 就说明使用成功

当没有镜像时就会去下载，例如helloworld，没有就会去下载

查看镜像

可以看到刚才下载的hello-world在里面了

• 配置阿里云镜像加速

登录阿里云官方，然后找到容器镜像服务，镜像加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://kynuterj.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

• 卸载docker

# 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io


#删除资源
rm -rf /var/lib/docker    # docker的默认工作路径

3、docker RUN机制

开始run一个镜像—> Docker会在本机寻找镜像 —> 判断本机是否有镜像，有就直接运行，没有就去docker仓库下载，下载完后再运行这个仓库

三、底层原理

1. Docker是怎么工作的？

Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问！

DockerServer接收到Docker-Client的指令，就会执行这个命令

docker容器就好比是一个小的linux虚拟机，并且相互隔离

2、Docker为什么比VM快？

• Docker有着比虚拟机更少的抽象层
• docker利用的是宿主机的内核，vm需要的是Guest OS 。所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统的内核，避免引导。虚拟机是加载GuestOS，分钟级别的。而Docker是利用宿主机的操作系统，省略了这个复杂的过程。秒级

四、Docker的常用命令

4.1、帮助命令

docker version   # 显示docker的版本信息
docker info    # 显示docker系统信息，详细，包括镜像和容量的数量
docker --help  #  列出来docker的命令

4.2、镜像命令

docker images  # 查看所有本地的主机上的镜像

REPOSITORY —镜像的复制源

（xshell复制是ctrl+ins ，粘贴是shift+ins）

可选项：

-a：列出所有的镜像

-q：只显示镜像的id

docker search   #搜索镜像

docker search --help  # 可以得到这个命令的帮助

docker search mysql --filter=STARTS=3000   # 搜索出来的结果是star大于3000的

docker pull  #下载镜像
docker pull xxx [:tag]  #指定版本，如果不写tag就默认下载最新版   
docker pull mysql:5.7

• 分层下载

docker rmi  #删除镜像
docker rmi -f xxx #-f是全部删除，可以通过id删，也可以通过镜像名称删
# 删除多个容器 空格

docker rmi -f $(docker images -aq)  # 删除全部的容器

4.3、容器命令

说明：我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习

docker pull centos   # 下载最新版的centos

使用镜像

docker run (image)
# 参数说明
--name="Name"   容器名字，tomcat01，tomcat02，用来区分容器
-d              后台方式运行
-it            使用交互方式运行，进入容器查看内容
-p              指定容器的端口
     -P 主机端口：容器端口（常用
     
     
docker run -it centos /bin/bash   #创建并进入容器
exit  #  退出容器

docker ps   #列出正在运行的容器
docker ps -a  # 列出所有的运行过的容器

进入容器后，ctrl+q+p 可以不退出然后切换到主机下

删除容器

docker rm  容器id     #删除指定id的容器  不能删除正在运行的容器，如果要强制删除， rm -f
docker rm -f $(docker ps -aq)   # 删除所有的容器

启动和停止容器

docker start 容器id   # 启动指定id容器
docker restart 容器id  #重启
docker stop 容器id  # 暂停容器
docker kill  容器id  # 强制停止当前容器

后台启动容器

docker run -d centos

# 当 docker ps  的时候，发现并没有刚才后台启动的容器----这是docker的常见的坑：
当docker 后台启动一个容器的时候，必须此时要有一个前台进程（也就是-it进去容器的这种），如果此时docker发现没有任何前台进程，那么就会把后台运行的进程也停止

例如，nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

docker logs  

docker logs -f -t --tail nums xxx    

查看容器中进程信息

docker top xxx

查看镜像的元数据

docker inspect xxx

进入当前正在运行的容器

# 我们通常容器都是使用后台方式运行的，当需要进入容器，修改一下配置时
docker exec -it 容器id /bin/bash

可以进入我们想要进的容器，然后使用容器，修改一些配置之类的

docker attach 容器id   # 可以直接进入正在运行的容器的命令行，而不是新开一个窗口

• docker exec ：进入容器后开启一个新的终端，可以在里面操作（常用）
• docker attach ：进入容器正在执行的终端，不会启动新的进程

从容器内拷贝文件到主机上

docker cp 容器id：容器内路径  目的主机路径

五、部署应用

5.1、部署nginx

1. 搜索nginx ： docker search nginx
2. 下载 docker pull nginx
3. 运行 docker run -d --name nginx01 -p 3344:80 nginx （意思是将虚拟机的3344端口和nginx的80端口绑定，即待会通过宿主机公网ip：3344就可以访问nginx）
4. 本机自测

通过ip访问

5. 进入容器

（做完部署的理解：linux系统，安装那些个环境，例如redis啊jdk啊之类的，都会比在windows下安装后启动要快，这也是为什么推荐将这些环境部署到linux系统下，启动更快，而且更轻便。在linux系统中安装docker，用docker，在docker中安装环境，又会更小更方便，docker就像是一个系统，然后docker里面的镜像，可以开启成一个一个的容器，每个容器相互隔离，所以可以部署多套环境，并且这些镜像都比较小，相对于直接在linux系统下安装这些环境，还要更加方便。在docker中部署nginx，nginx默认端口是80，要和自己服务器开放的端口绑定，这样通过自己服务器的公网ip加上绑定的端口号就可以访问部署的应用了 ）

5.2、部署tomcat

1、官方的使用

docker run -it --rm tomcat:9.0 # 这种方法，一般用于测试，用完就会把这个容器删除

2、创建容器并绑定端口号

[root@localhost /]# docker run -d --name tomcat01 -p 3355:8080 tomcat:9.0
091cbae35d3e54b1c0bb93748ed8541f72c22764920c7ed5660495ef21e23796

3、此时通过 192.168.180.100:3355 并不能进入到tomcat首页，原因是因为docker默认下载的tomcat是最简化版的，也就是阉割版的，我们需要做一些复制操作

[root@localhost /]# docker exec -it 091cbae35d3e /bin/bash
root@091cbae35d3e:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@091cbae35d3e:/usr/local/tomcat# cd webapps
root@091cbae35d3e:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

将webapps.dist/* 中的内容复制到webapps中

再次公网测试，成功进到tomcat

5.3、可视化工具

• portainer
• rancher

1. 什么是portainer？

Docker图形化界面管理工具，提供一个后台面板供我们操作！

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试： http://ip:8088

得到这样一个面板

在里面可以方便直观的看到自己的容器数量还有镜像还有网络等

六、Docker镜像讲解

6.1、镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件

所有的应用，直接打包docker镜像，就可以直接跑起来

如何得到镜像？

• 从远程仓库下载
• 他人拷贝
• 自己制作一个镜像 DockerFile

6.2、Docker镜像加载原理

• UnionFS （联合文件系统）

Union文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像，可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

• Docker镜像加载原理

Docker的镜像实际上由一层一层的文件系统组成

bootfs（boot file system） 主要包含bootloader和kernel ， bootloader 主要是引导加载kernel，linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs

rootfs（root file system） 在bootfs之上，包含的就是典型linux系统中的 /dev , /proc , /bin , /etc等标准目录和文件。rootfs就是各种不同的操作系统发行版。比如 Ubuntu ，Centos

• 平时我们安装进虚拟机的Centos都是好几个G，为什么Docker这里才200M？

对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs。由此可见，对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs

虚拟机是分钟级别的，容器是秒级的

6.3、commit镜像

docker commit  # 提交容器成为一个新的副本

# 命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id  目标镜像名;[TAG]

实战：

官方下载tomcat中，webapps里面是没有任何文件的，没有应用程序，所以打开tomcat容器也仍然访问不到tomcat，所以我们在前面就对tomcat容器内的webapps文件进行了复制操作。现在我们可以将这个修改了内容的tomcat容器反向打包成tomcat镜像，也就是我们修改后的镜像，基于此镜像再创建容器就可以直接访问了

容器—修改—镜像—容器

[root@localhost /]# docker ps
CONTAINER ID   IMAGE        COMMAND             CREATED       STATUS         PORTS                                       NAMES
091cbae35d3e   tomcat:9.0   "catalina.sh run"   2 hours ago   Up 3 minutes   0.0.0.0:3355->8080/tcp, :::3355->8080/tcp   tomcat01
[root@localhost /]# docker commit -a="xqh" -m="add webapps" 091cbae35d3e tomcat1.0
sha256:5ec5ad45d4e8c56d67965a46f03cb5ef1f86922acc124c661ab172948b751349
[root@localhost /]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
tomcat1.0             latest    5ec5ad45d4e8   6 seconds ago   685MB
nginx                 latest    605c77e624dd   14 months ago   141MB
tomcat                9.0       b8e65a4d736d   15 months ago   680MB
centos                latest    5d0da3dc9764   18 months ago   231MB
portainer/portainer   latest    580c0e4e98b0   2 years ago     79.1MB
[root@localhost /]# 

commit后的镜像，会到自己的镜像目录里

七、容器数据卷

• 如果数据都在容器里，那么我们容器删除，数据就会丢失！ 需求：数据要持久化
• 比如用docker安装MySQL，mysql容器删了，如果里面的数据也一并删除，删库跑路！ 需求：MySQL数据可以存储在本地

解决这两个需求----也就是容器之间可以有一个数据共享的技术

Docker容器中产生的数据，同步到本地！

卷技术–目录的挂载，将我们容器内的目录，挂载到Linux上面

容器的持久化和同步操作！

7.1、使用数据卷

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

docker run -it -v /home/ceshi:/home centos /bin/bash

意思是将centos容器内的home目录映射到本地/home/ceshi，在centos容器home下的东西都会自动同步到本地/home/ceshi里

docker inspect 容器id 查看容器具体信息

Mounts就是挂载信息。Source是本地文件目录，destination是挂载的文件目录 — 将本地/home/ceshi 和 容器内/home 绑定

绑定后 在容器内部的操作会同步到容器外

绑定后，即便关掉容器，在容器外的操作依旧会同步到容器内

好处：我们以后修改只需要在本地修改即可，容器内会自动同步！

7.2、实战：安装MySQL

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

1. 安装MySql

#获取镜像
[root@localhost /]# docker pull mysql:5.7
#需要配置密码
-e MYSQL_ROOT_PASSWORD 

#挂载  将配置文件和数据文件挂载到报本地
[root@localhost /]# docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MY_SQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
076faa33a5d8218cdf490d2609b7cb8ff1398a0597137b0dfd74884a11c125cd
[root@localhost /]# 

发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能！

7.3、具名和匿名挂载

# 匿名挂载  ，-v后面只写需要挂载出去的容器内的路径，会自动在容器外部生成一个路径
-v 容器内路径！
docker run -d -p --name nginx01 -v /etc/nginx nginx

# 查看所有卷（volume）的情况
docker volume ls  
[root@localhost /]# docker run -d -P --name nginx02 -v /etc/nginx nginx
aa9ba0712bae0dd5fa360c2fd229b4fb25dba4867070437b40ed77e71007ef8f
[root@localhost /]# docker volume ls
DRIVER    VOLUME NAME
local     0e11e51f5727b8865a2ce9eece159bfc767128e3dda526a9f79b3d8b1fe6aeff
local     40cf9d0ad90a9d417bb809bf34f504024f6e8c2beda3c38c392dc5a2e76e4342
local     246ada27de9db06d476ef0271d4096a85213e53ca419439a1a8ce8c5e64377b8
local     2573fe846b221ff92f1cb50a2ee20e0fb9355124c0ec388bd21200b37851fb1b
local     66083af0e0bdfc926b8097a54629e1527a2720239112a8fe3773269872cb3165
[root@localhost /]# 
# 这种就是匿名挂载，我们在-v只写了容器内的路径，没有写容器外的路径！没有写目录名称


# 具名挂载
[root@localhost /]# docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx nginx
141c5b2a15f34fe2c9f2d46801b0753033f0e3fdf60169fef40e1dde2b990d6b
[root@localhost /]# docker volume ls
DRIVER    VOLUME NAME
local     0e11e51f5727b8865a2ce9eece159bfc767128e3dda526a9f79b3d8b1fe6aeff
local     40cf9d0ad90a9d417bb809bf34f504024f6e8c2beda3c38c392dc5a2e76e4342
local     246ada27de9db06d476ef0271d4096a85213e53ca419439a1a8ce8c5e64377b8
local     2573fe846b221ff92f1cb50a2ee20e0fb9355124c0ec388bd21200b37851fb1b
local     66083af0e0bdfc926b8097a54629e1527a2720239112a8fe3773269872cb3165
local     juming-nginx
[root@localhost /]# 
# 这种指定了目录名称的，就是具名挂载

所有的docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx/_data，匿名挂载是在这个路径下生成随机代码目录名，而具名挂载是在这个路径下生成指定名称的目录名

我们通过具名挂载可以方便的找到我们的一个卷，大多数情况使用的是具名挂载

如何确是具名挂载还是匿名挂载，还是指定路径挂载？

-v  /容器内路径     #  匿名挂载
-v 卷名：/容器内路径 #  具名挂载
-v /容器外路径 : /容器内路径   # 指定路径挂载

# 拓展
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx
#通过 -v 容器内路径：ro  rw  改变读写权限
ro : 只读
rw : 可读可写
一旦设定了容器权限，容器对我们挂载出来的内容就有限定了

7.4、初始Dockerfile

方式二：Dockerfile就是用来构建docker镜像的构建文件。命令脚本

通过这个脚本可以生成镜像，镜像是一层一层的！

FORM centos

VOLUME ["volume01","volume02"]

CMD echo "----end----"
CMD /bin/bash

自己构建的镜像，就会在镜像列表里了

创建一个dockerfile文件----文件中的内容，指令大写 ----构建镜像（根据命令一层一层构建镜像）

打开自己构建的镜像，会发现两个挂载的卷。----这就是通过dockerfile来挂载卷

这个卷和外部一定有一个同步的目录！ --前面我们写的命令行，只写了内部路径，是匿名挂载

7.5、数据卷容器

#根据刚才我们创建的镜像，开启容器1
[root@localhost /]# docker run -it --name docker01  afa669b6bce7
[root@735d7736d323 /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Apr 20 07:17 dev
drwxr-xr-x.   1 root root  66 Apr 20 07:17 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 132 root root   0 Apr 20 07:17 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Mar 25 13:20 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var
drwxr-xr-x.   2 root root   6 Apr 20 07:17 volume01
drwxr-xr-x.   2 root root   6 Apr 20 07:17 volume02

#开启第二个容器，并继承容器1docker01，可以看到docker02也会有01挂载的那些卷
[root@localhost /]# docker run -it --name docker02 --volumes-from docker01 afa669b6bce7
[root@8a9b8253c75a /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Apr 20 07:19 dev
drwxr-xr-x.   1 root root  66 Apr 20 07:19 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 124 root root   0 Apr 20 07:19 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Mar 25 13:20 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var
drwxr-xr-x.   2 root root   6 Apr 20 07:17 volume01
drwxr-xr-x.   2 root root   6 Apr 20 07:17 volume02

# 在docker01挂载的卷中添加文件，在docker02中对应的卷中也会有这个添加的文件。。
[root@localhost /]# docker attach 8a9b8253c75a
[root@8a9b8253c75a /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Apr 20 07:19 dev
drwxr-xr-x.   1 root root  66 Apr 20 07:19 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 122 root root   0 Apr 20 07:19 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Mar 25 13:20 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var
drwxr-xr-x.   2 root root  30 Apr 20 07:21 volume01
drwxr-xr-x.   2 root root   6 Apr 20 07:17 volume02
[root@8a9b8253c75a /]# cd volume01
[root@8a9b8253c75a volume01]# ls
01  docker

# --volumes-from  就相当于继承一样  son extend father

这样就实现了容器之间的数据共享。并且，在删除了docker01后，docker02和dcoker03依旧可以访问共享的文件。即，只要还有一个容器还在使用共享的数据，就不会被删除

结论：

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

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

八、DockerFile

dockerfile是用来构建docker镜像的文件，命令参数脚本

构建步骤：

1、编写一个dockerfile文件

2、docker build 构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜像（DockerHub、阿里云镜像仓库）

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像

8.1、DockerFile构建过程

1、基础知识：

• 每个保留关键字（指令）都必须是大写字母
• 执行从上到下顺序执行
• “ #” 表示注释
• 每一个指令都会创建提交一个新的镜像层----命令一行一行执行，镜像一层一层构建

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockefile文件。

DockerFile： 构建文件，定义了一切的步骤，源代码

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

8.2、DockerFile的指令

FROM   #from一个基础镜像，一切从这里构建。指定基础镜像
MAINTAINER  # 镜像是谁写的，姓名+邮箱
RUN   #镜像构建的时候需要运行的命令
ADD   # 添加本地的文件，构建的时候会自动解压。例如，要做tomcat镜像，这里add一个tomcat压缩包！添加内容
WOKEDIR  # 镜像的工作目录
VOLUME  #挂载卷
EXPOSE # 指定对外端口
CMD  # 指定容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT   # 指定这个容器启动的时候要运行的命令，区别是可以追加命令
ONBULID   # 当构建一个被继承DockerFile，这个时候就会运行ONBUILD的指令。触发指令
COPY   #类似ADD，将我们的文件拷贝到镜像中
ENV  # 构建的时候设置环境变量

8.3、实战：构建自己的centos

1创建一个自己的centos

#1、编写dockerfile文件
[root@localhost dockerfile]# vi mydockerfile-centos
[root@localhost dockerfile]# cat mydockerfile-centos
FROM centos：7

MAINTAINER xqh<791172229@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "----end----"
CMD /bin/bash
[root@localhost dockerfile]# 

#2、构建镜像
[root@localhost dockerfile]# docker build -f mydockerfile-centos -t centos:0.1 .

可以看到构建好的镜像已经在镜像列表里了

测试运行镜像

原来的镜像是不能vim也不能ifconfig的。现在可以，这就是我们自己构建镜像时加的功能。运行后，目录也是我们在文件中指定的工作目录

查看镜像的构建历史(本地的变更历史)

区别

CMD # 指定容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，区别是可以追加命令

• 用CMD，当运行容器的时候，追加参数，会直接取代配置文件里的。即只有最后一个命令的参数才会生效
• 而ENTRYPOINT 则是可以追加命令。当运行参数的时候，追加参数，会先执行配置文件里的，再执行追加的命令。

8.4、实战：构建tomcat镜像

1、准备镜像文件tomcat压缩包，jdk压缩包

2、编写dockerfile文件，官方命名Dockerfile ,build的时候会自动去寻找dockerfile文件，不用加-f

[root@localhost tomcat]# vi Dockerfile
[root@localhost tomcat]# cat Dockerfile
FROM centos:7

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u341-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.35.tar.gz /usr/local

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_341
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /url/local/apache-tomcat-9.0.35/bin/logs/catalina.out



[root@localhost tomcat]# 

3、构建镜像。用了官方名字后，不用再指定文件夹了，可以直接build

docker build -t diytomcat .

[root@localhost tomcat]# docker build -t diytomcat .
[+] Building 279.9s (11/11) FINISHED                                                                         
 => [internal] load build definition from Dockerfile                                                    0.0s
 => => transferring dockerfile: 695B                                                                    0.0s
 => [internal] load .dockerignore                                                                       0.0s
 => => transferring context: 2B                                                                         0.0s
 => [internal] load metadata for docker.io/library/centos:7                                            15.5s
 => CACHED [1/6] FROM docker.io/library/centos:7@sha256:9d4bcbbb213dfd745b58be38b13b996ebb5ac315fe7571  0.0s
 => [internal] load build context                                                                       3.5s
 => => transferring context: 159.39MB                                                                   3.5s
 => [2/6] COPY readme.txt /usr/local/readme.txt                                                         0.2s
 => [3/6] ADD jdk-8u341-linux-x64.tar.gz /usr/local                                                     6.6s
 => [4/6] ADD apache-tomcat-9.0.35.tar.gz /usr/local                                                    0.4s
 => [5/6] RUN yum -y install vim                                                                      250.2s
 => [6/6] WORKDIR /usr/local                                                                            0.0s 
 => exporting to image                                                                                  3.5s 
 => => exporting layers                                                                                 3.5s 
 => => writing image sha256:0f8e45ff3cd8f0add0e10fc2bddfedfd44536a080951647ae1ca9c38e5c40bd7            0.0s 
 => => naming to docker.io/library/diytomcat                                                            0.0s 
[root@localhost tomcat]#                    

4、启动镜像

5、访问测试

6、发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了）

编写web.xml，index.jsp在挂载目录test下添加

访问项目 192.168.180.100:9090/test

可以看到自己写的页面。项目部署成功，可以直接访问

8.5、发布自己的镜像

1、发布到Dockerhub

• 地址：https://hub.docker.com 注册自己的账号
• 在服务器上提交自己的镜像

# 命令行登录,然后在push
docker login -u xxx -p xxx
docker push 

push前，先用docker tag命令将要push的镜像改个名称，改为加上作者和版本号

如

docker tag diytomcat pluto80/diytomcat:1.0

push的时候要指定版本号

2、发布到阿里云镜像服务上

• 登录阿里云
• 找到容器镜像服务
• 创建命名空间

• 创建镜像仓库

• 登录，push