Video Reference：【尚硅谷】Docker迅速入门丨零基础学Docker

1 Docker 简介

:::color1 前提知识：

强制：熟悉 Linux 常用命令，和相关背景知识

建议：Maven / Git 相关的知识

下载链接：http://www.atguigu.com/download.shtml

:::

1.1 Docker 是什么

问题：为什么会出现 Docker 出现？

一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验。

Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案。

环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。

之前在服务器配置一个应用的运行环境，要安装各种软件，就拿尚硅谷电商项目的环境来说吧，Java/TomcatMySQLJDBC驱动包等;安装和配置这些东西有多麻烦就不说了，它还不能跨平台。假如我们是在Windows上安装的这些环境，到了Linux又得重新装。况丘就算不跨操作系统，换另一台同样操作系统的服务器，要移植应用也是非常麻烦的。

传统上认为，软件编码开发/测试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码等(java为例)。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。Docker镜像的设计，使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。

:::color1 Java 虚拟机的概念：一次编译，处处运行。

Docker 的理念：一次构建，处处运行。

:::

Docker 理念

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是“Build，Ship and Run Any App , Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP(可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

Linux容器技术的出现就解决了这样一个问题，而Docker就是在它的基础上发展过来的。将应用运行在Docker容器上面，而Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。

一句话

解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

1.2 Docker 能干嘛

1.2.1 之前的虚拟机技术

虚拟机（ Virtual Machine ）就是带环境安装的一种解决方案。

:::

1. 更便捷的升级和扩缩容

:::color1

:::

1. 更简单的系统运维

:::color1

:::

1. 更高效的计算资源

:::color1 <font style="color:rgb(119, 0, 136);">传统虚拟机技术是硬件级虚拟化，Docker是内核级虚拟化</font>，其不像传统的虚拟化技术一样需要额外的Hypervisor的支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

:::

1.2.4 企业级

Docker、Mesos等容器新技术使大规模动态调度成为可能。

• 更轻量：基于容器的虚拟化，仅包含业务运行所需的runtime环境，CentOS/Ubuntu基础镜像仅170M；宿主机可部署100～1000个容器
• 更高效：无操作系统虚拟化开销
  • 计算：轻量，无额外开销
  • 存储：系统盘aufs/dm/overlayfs;数据盘volume
  • 网络：宿主机网络，NS隔离
• 更敏捷、更灵活：
  • 分层的存储和包管理，devops理念
  • 支持多种网络配置

哪些企业在使用？

• 新浪
• 美团
• 腾讯
• 华为等企业

1.3 Docker 去哪下

1. 官网

Docker 官网：https://www.docker.com/

Docker 中文官网：https://www.docker-cn.com/ (目前已关闭该站点)

1. 仓库

DockerHub 官网：https://hub.docker.com/ ( 用于保存镜像 )

:::color1 Docker 的三大特征：容器，镜像，仓库

Java 对象的三大特征：封装，继承，多态

:::

2 Docker 安装

2.1 前提说明

CentOS Docker 安装：

Docker支持以下的CentOS版本：

• CentOS 7(64-bit)
• CentOS 6.5(64-bit)或更高的版本

前提条件：

目前，CentOS仅发行版本中的内核支持 Docker。

Docker运行在CentOS 7 上，要求系统为64位、系统内核版本为3.10以上。

Docker运行在CentOS-6.5或更高的版本的CentOS 上，要求系统为64位、系统内核版本为 2.6.32 - 431 或者更高版本。

查看自己的内核：

uname 命令用于打印当前系统相关信息（内核版本号，硬件架构，主机名称和操作系统类型等）

uname -r

查看已安装的 CentOS 版本信息

cat /etc/redhat-release

2.2 Docker 的基础组成

2.2.1 Docker 的架构图

1. 镜像（Image）

Docker镜像(Ilmage)就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。

容器与镜像的关系类似于面向对象编程中的对象与类。

1. 容器（Container）

Docker利用容器(Container）独立运行的一个或一组应用。容器是用镜像（Image）创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

1. 小总结

需要正确的理解 仓库 / 镜像 / 容器 这几个概念：

vim /etc/sysconfig/docker

将获得的自己账户下的阿里云加速地址配置添加到

other_args="--registry-mirror=https://自己的账号加速信息.mirror.aliyuncs.com"

:::

以下操作是 CentOS 7 的Docker 加速器配置

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

重新启动Docker后台服务: service docker restart

~ sudo systemctl daemon-reload
~ sudo systemctl restart docker

Linux系统下配置完加速器需要检查是否生效

~ docker info | grep -A 1 "Registry Mirrors"
 Registry Mirrors:
  https://si7y70hh.mirror.aliyuncs.com/

2.4.2 网易云镜像加速

基本同上述阿里云，推荐使用阿里云镜像加速器。

配置的Json串的地方不同了：

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["http://hub-mirror.c.163.com"]
}
EOF

2.4.3 启动 Docker 后台容器（测试运行 hello-world）

docker run hello-world
# 由于本地没有hello-world这个镜像，所以会下载一个hellow-world的镜像，并在容器中内运行

:::color1 输出这段提示以后，hello world 就会停止运行，容器自动终止

:::

• Docker run 流程

2.5 底层原理

2.5.1 Docker 是怎么工作的？

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。

2.5.2 为什么 Docker 比较 VM 快

问题：为什么 Docker 会比 VM 虚拟机快？

（1）**<font style="color:#E8323C;">Docker 有着比虚拟机更少的抽象层</font>**

由于 Docker 不需要 Hypervisor（虚拟机）实现硬件资源虚拟化，运行在 Docker 容器上的程序直接使用的都是实际物理机的硬件资源。因此CPU，内存利用率上 Docker 将会在效率上有明显优势。虚拟机需要实现硬件资源的虚拟化。

（2）**<font style="color:#E8323C;">Docker 利用的是宿主机的内核，而不需要加载操作系统OS内核</font>**

当新建一个容器时，Docker 不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻，加载操作系统内核返回等比较费时费力资源的过程，当新建一个虚拟机时，虚拟机软件需要重新加载OS，返回新建过程都是分钟级别。而Docker由于直接利用宿主机的操作系统，则省略了返回过程，因此创建一个容器只需要几秒钟。

:::color1 Docker 将传统的虚拟化技术中的 Guest OS 和 Hypervisor 虚拟化层给替换成了 Docker Engine。

:::

3 Docker 常用命令

3.1 帮助命令

:::color1 docker version

docker info

docker —help

:::

~ docker version
Client: Docker Engine - Community
 Version:           20.10.10
 API version:       1.41
 Go version:        go1.16.9
 Git commit:        b485636
 Built:             Mon Oct 25 07:44:50 2021
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true
Server: Docker Engine - Community
 Engine:
  Version:          20.10.10
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.16.9
  Git commit:       e2f740d
  Built:            Mon Oct 25 07:43:13 2021
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.6
  GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
 runc:
  Version:          1.1.2
  GitCommit:        v1.1.2-0-ga916309
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

~ docker info
Client:
 Context:    default
 Debug Mode: false
 Plugins:
  app: Docker App (Docker Inc., v0.9.1-beta3)
  buildx: Build with BuildKit (Docker Inc., v0.6.3-docker)
  scan: Docker Scan (Docker Inc., v0.17.0)
Server:
 Containers: 1
  Running: 0
  Paused: 0
  Stopped: 1
 Images: 1
 Server Version: 20.10.10
 Storage Driver: overlay2
  Backing Filesystem: xfs
  Supports d_type: true
  Native Overlay Diff: true
  userxattr: false
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Cgroup Version: 1
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: runc io.containerd.runc.v2 io.containerd.runtime.v1.linux
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: 10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
 runc version: v1.1.2-0-ga916309
 init version: de40ad0
 Security Options:
  seccomp
   Profile: default
 Kernel Version: 3.10.0-1160.el7.x86_64
 Operating System: CentOS Linux 7 (Core)
 OSType: linux
 Architecture: x86_64
 CPUs: 4
 Total Memory: 7.622GiB
 Name: docker-node
 ID: ZWS6:7BS4:CRHX:AXGV:LSQ4:3JLD:AY7M:76IZ:YKSY:LAAC:PSTY:FTUA
 Docker Root Dir: /var/lib/docker
 Debug Mode: false
 Registry: https://index.docker.io/v1/
 Labels:
 Experimental: false
 Insecure Registries:
  harbor.kubesphere.com:80
  127.0.0.0/8
 Registry Mirrors:
  https://si7y70hh.mirror.aliyuncs.com/
 Live Restore Enabled: false

~ docker --help
Usage:  docker [OPTIONS] COMMAND
A self-sufficient runtime for containers
Options:
      --config string      Location of client config files (default "/root/.docker")
  -c, --context string     Name of the context to use to connect to the daemon (overrides DOCKER_HOST env var and
                           default context set with "docker context use")
  -D, --debug              Enable debug mode
  -H, --host list          Daemon socket(s) to connect to
  -l, --log-level string   Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") (default "info")
      --tls                Use TLS; implied by --tlsverify
      --tlscacert string   Trust certs signed only by this CA (default "/root/.docker/ca.pem")
      --tlscert string     Path to TLS certificate file (default "/root/.docker/cert.pem")
      --tlskey string      Path to TLS key file (default "/root/.docker/key.pem")
      --tlsverify          Use TLS and verify the remote
  -v, --version            Print version information and quit
Management Commands:
  app*        Docker App (Docker Inc., v0.9.1-beta3)
  builder     Manage builds
  buildx*     Build with BuildKit (Docker Inc., v0.6.3-docker)
  config      Manage Docker configs
  container   Manage containers
  context     Manage contexts
  image       Manage images
  manifest    Manage Docker image manifests and manifest lists
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  scan*       Docker Scan (Docker Inc., v0.17.0)
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes
Commands:
  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes
Run 'docker COMMAND --help' for more information on a command.
To get more help with docker, check out our guides at https://docs.docker.com/go/guides/

3.2 镜像命令

3.2.1 docker images

~ docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   10 months ago   13.3kB
# 各个选项的说明：
REPOSITORY:表示镜像的仓库源
TAG                :镜像的标签
IMAGE ID    :镜像ID
CREATED        :镜像创建时间，指发布到镜像库中的时间，不是拉取时间。
SIZE            :镜像大小

同一仓库源可以有多个TAG，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。如果你不指定一个镜像的版本标签，例如你只使用 Ubuntu，Docker 将默认使用 ubuntu:latest 镜像。默认的TAG的标签是 latest 的信息。

OPTIONS 说明：

:::color1

—digests ：显示镜像的摘要信息

—no-trunc ：显示完整的镜像信息

:::

3.2.2 docker search 某个XXX 镜像名字ID

• 网站

https://hub.docker.com

• 命令

docker search [OPTIONS] 镜像名字

:::color1 —no-trunc ：显示完整的镜像描述

-s：列出收藏数不小于指定值的镜像。# 已经弃用

—automated ：只列出automated build类型的镜像；

:::

~ docker search tomcat
NAME                                           DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
tomcat                                         Apache Tomcat is an open source implementati…   3372      [OK]
tomee                                          Apache TomEE is an all-Apache Java EE certif…   97        [OK]
bitnami/tomcat                                 Bitnami Tomcat Docker Image                     46                   [OK]
......
# --limit 最大搜索结果数(默认25)
~ docker search --limit 3 tomcat
# 指定收藏数在30以上的镜像
~ docker search -f stars=30 tomcat
或者
# 没有-s的用这个 
~ docker search tomcat --filter=stars=30
# 搜索官方的镜像
~ docker search --filter is-official=true tomcat

3.2.3 docker pull 某个XXX 镜像名字ID

下载镜像

docker pull 镜像名字[:TAG]

~ docker search --limit 3 tomcat
~ docker pull tomcat # 等价于 docker pull tomcat:latest
# 拉取指定镜像的 tomcat
~ docker pull tomcat:8.5.41-alpine

3.2.4 docker rmi 某个XXX 镜像名字ID

删除镜像

删除单个

docker rmi -f <Image>:<Tag>

删除多个

# 删除指定的多个镜像名字
docker rmi -f <Image1>:<Tag> <Image2>:<Tag> ......

删除全部

docker rmi -f $(docker images -aq)

3.2.5 思考

结合我们Git的学习心得，大家猜猜是否会有 docker commit / docker push？？

3.3 容器命令

有镜像才能创建容器，这是根本的前提（下载一个CentOS镜像演示）

~ docker pull centos:centos7.9.2009
~ docker images
REPOSITORY   TAG              IMAGE ID       CREATED         SIZE
centos       centos7.9.2009   eeb6ee3f44bd   10 months ago   204MB
~ docker pull ubuntu:20.04

3.3.1 新建并启动容器

:::color1 docker run [OPTIONS] IMAGE [COMMAND] [ARG…]

Docker 里面套 Docker是好多架构的标准操作啦，比如说Jenkins Agent 用装了Docker的Docker image来实现自动化创建Docker Image

:::

OPTIONS：

:::color1 OPTIONS说明（常用）:有些是一个减号，有些是两个减号

• —name=”容器新名字”：为容器指定一个名称；
• -d：后台运行容器，并返回容器ID，也即启动守护式容器；
• -i：以交互模式运行容器，通常与 -t 同时使用；
• -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；
• -P:随机端口映射；
• -p：指定端口映射，有以下四种格式
  • ip:hostPort:containerPort
  • ip::containerPort
  • hostPort:containerPort
  • containerPort

:::

启动交互式容器：

~ docker run -itd --name c1 --hostname c1 centos:centos7.9.2009 /bin/bash
~ docker exec -it c1 /bin/bash
[root@c1 /]# ls
anaconda-post.log  bin  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@c1 /]# cat /etc/redhat-release
CentOS Linux release 7.9.2009 (Core)
[root@c1 /]# hostname
c1
# 使用镜像centos:centos7.9.2009 以交互式模式启动一个容器，在容器内执行 /bin/bash 命令
docker run -it centos:centos7.9.2009 /bin/bash

3.3.2 列出当前所有正在运行的容器

:::color1 docker ps [OPTIONS]

:::

OPTIONS 说明：

:::color1

—no-trunc：不截断输出。

:::

~ docker ps
CONTAINER ID   IMAGE                   COMMAND       CREATED         STATUS         PORTS     NAMES
624bd36b61de   centos:centos7.9.2009   "/bin/bash"   3 minutes ago   Up 3 minutes             c1
## 随机生成的名字不一般，格式是[一个形容词]_[名人或伟人的名字]

3.3.3 退出容器

两种退出方式：

exit：容器停止退出

Ctrl + P + Q：容器不停止退出

~ docker exec -it c1 /bin/bash
[root@c1 /]# exit
exit
# 容器不停止退出
~ docker exec -it c1 /bin/bash
[root@c1 /]# read escape sequence
# Ctrl + P + Q

3.3.4 启动容器

docker start 容器ID或者容器名

~ docker start c1

3.3.5 重启容器

docker restart 容器ID或者容器名

~ docker restart c1

3.3.6 停止容器

docker stop 容器ID或者容器名

# stop 温柔停止容器
~ docker stop c1

3.3.7 强制停止容器

docker kill 容器ID或者容器名

# kill 强制停止容器
~ docker kill c1

3.3.8 删除已停止的容器

docker rm 容器ID或者容器名

一次性删除多个容器

docker rm -f <Container1> <Container2> <Container3> ......

删除所有的容器

# 删除所有正在运行以及不再运行的容器
docker rm -f $(docker ps -aq)
或者
docker ps -qa | xargs docker rm -f

3.3.9 重要

3.3.9.1 启动守护式容器

使用镜像centos:latest以后台模式启动一个容器docker run -d centos

问题：然后docker ps -a进行查看，会发现容器已经退出。

很重要的要说明的一点：Docker容器后台运行,就必须有一个前台进程。

容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。

这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,我们配置启动服务只需要启动响应的service即可。例如：service nginx start。

但是，这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用，这样的容器后台启动后，会立即自杀因为他觉得他没事可做了。

所以，最佳的解决方案是，将你要运行的程序以前台进程的形式运行。

# 后台运行容器
~ docker run -it -d --name c1 centos:centos7.9.2009 /bin/bash
~ docker ps
CONTAINER ID   IMAGE                   COMMAND       CREATED         STATUS         PORTS     NAMES
e8bed136415e   centos:centos7.9.2009   "/bin/bash"   2 minutes ago   Up 2 minutes             c1

3.3.9.2 查看容器日志

docker logs -f -t —tail 容器ID

:::color1 *-t：是加入时间戳

*-f：跟随最新的日志打印

*—tail 数字：显示最后多少条

:::

~ docker run -it -d --name c2 centos:centos7.9.2009 /bin/bash -c "while true;do echo hello,zzw;sleep 1;done"
~ docker ps -l
CONTAINER ID   IMAGE                   COMMAND                  CREATED          STATUS          PORTS     NAMES
34f1e2fbd9b9   centos:centos7.9.2009   "/bin/bash -c 'while…"   12 seconds ago   Up 12 seconds             c2
# *-t：是加入时间戳
# *-f：跟随最新的日志打印
# *--tail 数字：显示最后多少条
~ docker logs -t -f --tail 5 c2
2022-08-07T09:02:59.591905262Z hello,zzw
2022-08-07T09:03:00.595619177Z hello,zzw
2022-08-07T09:03:01.598037828Z hello,zzw

3.3.9.3 查看容器内运行的进程

docker top 容器ID或者容器名字

~ docker top c3
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                123503              123482              0                   17:04               pts/0               00:00:00            /bin/bash -c while true;do echo hello,zzw;sleep 1;done
root                126047              123503              0                   17:09               pts/0               00:00:00            sleep 1

3.3.9.4 查看容器内部细节

docker inspect 容器ID或者容器名字

docker inspect c3

3.3.9.5 进入正在运行的容器并以命令行交互

• docker exec -it 容器ID或者容器名字 bashShell

exec就是在container里执行后面的命令，如果执行的是开启新终端的命令就会开启新终端了。

/bin/bash 和 /bin/sh 都是开启终端的命令，相当于你在外面开启了container里面的终端，最后效果和你进container开终端是一样的。/bin/bash命令是打开新终端，打开新的终端实际上起作用的是用exec执行了/bin/bash，不是exec。

~ docker exec -it c1 /bin/bash
[root@e8bed136415e /]#
# 不进入到容器，直接在控制台显示想要的结果
~ docker exec -it c1 ls -l /tmp
total 12
-rw-r--r--. 1 root root  18 Aug  7 09:21 docker.txt
-rw-r--r--. 1 root root  16 Aug  7 09:19 host.txt

• 重新进入 docker attach 容器ID或者容器名字

~ docker attach c1
[root@e8bed136415e /]#

• 上述两个区别

:::color1

:::

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

docker cp 容器ID或者容器名称:容器内路径 目的主机路径

范例：

# 将宿主机的文件拷贝到容器中
~ echo "hello,from host" > host.txt
~ docker cp host.txt c1:/tmp
~ docker exec -it c1 /bin/bash
[root@e8bed136415e /]# cat /tmp/host.txt
hello,from host
[root@e8bed136415e /]# echo "hello,from docker" > /tmp/docker.txt
[root@e8bed136415e /]# exit
# 从容器中拷贝文件到宿主机
~ docker cp c1:/tmp/docker.txt /tmp
~ cat /tmp/docker.txt
hello,from docker

3.4 小总结

• attachAttach to a running container —- 当前Shell下attach连接指定运行容器
• buildBuild an image from a Dockerfile —- 通过Dockerfile定制镜像
• commitCreate a new image from a container’s changes —- 提交当前容器为新的镜像
• cpCopy files/folders from the containers filesystem to the host past —- 从容器中拷贝指定文件或者目录到宿主机中
• createCreate a new container —- 创建一个新的容器，同run，但是不启动容器
• diffInspect changes on a container’s filesystem —- 查看 docker 容器的变化
• eventsGet real time events from the server —- 从 docker 服务获取容器实时事件
• execRun a command in a running container —- 在已存在的容器上运行命令
• exportStream the contents of a container as a tar archive —- 导出容器的内容流作为一个 tar 归档文件[对应 import]
• historyShow the history of an image —- 展示一个镜像形成历史
• imagesList images —- 列出本地系统当前镜像
• infoDisplay system-wide information —- 显示系统相关信息
• inspect Return low-level information on Docker objects —- 查看容器详细信息
• killKill a runnning containers —- kill 指定 docker 容器
• loadLoad an image from a tar archive —- 从一个 tar 包中加载一个镜像 [ 对应 save ]
• loginLog in to a Docker registry —- 注册或者登陆一个 docker 源服务器
• logoutLog out from a Docker registry —- 从当前 Docker Registry 退出
• logsFetch the logs of a container —- 输出当前容器日志信息
• portList port mappings or a specific mapping for the container —- 查看映射端口对应的容器内部源端口
• pausePause all processes within one or more containers —- 暂停容器
• psList containers —- 列出容器列表
• pullPull an image or a repository from a registry —- 从docker镜像源服务器拉取指定镜像或者库镜像
• pushPush an image or a repository to a registry —- 推送指定镜像或者库镜像至docker镜像源服务器
• restartRestart one or more containers —- 重启运行的容器
• rmRemove one or more containers —- 移除一个或者多个容器
• rmiRemove one or more images —- 移除一个或者多个镜像[无容器使用该镜像才可输出，否则需要输出相关容器才能可以继续或者 -f 强制删除]
• runRun a command in a new container —- 创建一个新的容器并运行一个命令
• saveSave one or more images to a tar archive —- 保存一个镜像为一个 tar 包[ 对应 load ]
• searchSearch the Docker Hub for images —- 在 DockerHub 中搜索镜像
• startStart one or more stopped containers —- 启动容器
• stopStop one or more running containers —- 停止容器
• statsDisplay a live stream of container(s) resource usage statistics —- 显示容器资源使用统计的实时流
• tagTag an image into a repository —- 给源中镜像打标签
• topDisplay the running processes of a container —- 查看容器中运行的进程信息
• unpauseUnpause a pause container —- 取消暂停容器
• versionShow the Docker version information —- 查看 Docker 版本号
• waitBlock until one or more containers stop, then print their exit codes —- 截取容器停止时的退出状态值

4 Docker 镜像

docker commit 将容器提交成镜像

• docker export 将容器打包成 tar 包

docker export -o .tar

根据容器的大小，打包的效率也会随之变化

• docker import 将 tar 包提交为镜像

docker import .tar :

根据Tar包的大小，提交镜像的效率也会随之变化

• docker save 将镜像打包成 tar 包

docker save : -o .tar

根据镜像的大小，打包的效率也会随之变化

• docker load 将 tar 包提交为镜像

docker load -i .tar

根据Tar包的大小，提交镜像的效率也会随之变化

4.1 Docker 镜像是什么

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

4.1.1 UnionFS（联合文件系统）

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层一层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下（Unite several directories into a single virtual filesystem）。Union文件系统是Docker镜像的基础。<font style="color:#E8323C;">镜像可以通过分层来进行继承</font>，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但是从外面看起来，只能看到一个文件系统，<font style="color:#E8323C;">联合加载会把各种文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录</font>。

联合文件系统：分层，轻量，并且能够聚合的一种镜像基础。

4.1.2 Docker 镜像加载原理

Docker 镜像加载原理：

Docker 的镜像实际上是由一层一层的文件系统组成的，这种层级的文件系统UnionFS。

比如说有多个镜像都从相同的 base 镜像构建而来，那么 Docker Host 只需在磁盘上保存一份 base 镜像；

同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

4.2 Docker 镜像特点

<font style="color:#E8323C;">Docker 镜像层都是只读的，容器层是可写的。</font>

当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称为“容器层”，“容器层”之下的都叫镜像层。

所有对容器的改动，无论添加、删除、还是修改文件都只会发生在容器中。只有容器层时可写的，容器层下面的所有镜像层都是只读的。

4.3 Docker 镜像 commit 操作补充

:::color1 $ docker commit 提交容器副本使之成为一个新的进行

:::

范例：演示 Tomcat 模板

1. 从 Hub 上下载 tomcat 镜像到本地并成功运行
2. 故意删除上一步镜像生产 tomcat 的文档
3. 也即当前的 tomcat 运行实例是一个没有文档内容的容器，以它为模板 commit 一个没有 doc 的 tomcat 新镜像 ks/tomcat
4. 启动我们的新镜像并和原来的对比

# 使用指定端口
$ docker pull tomcat:8.0.53
# -p 主机端口:docker容器端口(端口映射)
# -P 随机分配主机端口
# -i 交互 -t 创建伪终端
# -d 后台运行容器
$ docker run -it -p 8080:8080 --name t1 tomcat:8.0.53
$ curl localhost:8080
可以展示Tomcat 的页面
# tomcat 8版本之后的路径404是因为新版本tomcat docker 目录换了一下，webapps下没有主页，
# 在webapps.dlist下，把webapps.dlist下的文件移到webaps下就好了
# 使用随机端口
$ docker run -it -P -d --name t2 tomcat:8.0.53
$ docker ps -l
CONTAINER ID   IMAGE           COMMAND             CREATED         STATUS         PORTS                                         NAMES
31d488831d03   tomcat:8.0.53   "catalina.sh run"   4 seconds ago   Up 3 seconds   0.0.0.0:49154->8080/tcp, :::49154->8080/tcp   t2
$ curl localhost:49154
可以展示Tomcat 的页面

~ docker exec -it t1 /bin/bash
root@166ff986d06b:/usr/local/tomcat# cd webapps/
root@166ff986d06b:/usr/local/tomcat/webapps# ls -l
total 8
drwxr-xr-x.  3 root root 4096 Sep 12  2018 ROOT
drwxr-xr-x. 14 root root 4096 Sep 12  2018 docs
drwxr-xr-x.  6 root root   83 Sep 12  2018 examples
drwxr-xr-x.  5 root root   87 Sep 12  2018 host-manager
drwxr-xr-x.  5 root root  103 Sep 12  2018 manager
root@166ff986d06b:/usr/local/tomcat/webapps# rm -rf docs/
root@166ff986d06b:/usr/local/tomcat/webapps# ls -l
total 4
drwxr-xr-x. 3 root root 4096 Sep 12  2018 ROOT
drwxr-xr-x. 6 root root   83 Sep 12  2018 examples
drwxr-xr-x. 5 root root   87 Sep 12  2018 host-manager
drwxr-xr-x. 5 root root  103 Sep 12  2018 manager

~ docker commit -a "zhongzhiwei <zhongzhiwei@kubesphere.io>" -m "将Tomcat的Docs删除" t1 ks/tomcat:1.0
~ docker images ks/tomcat:1.0
REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
ks/tomcat    1.0       f970d1ac7724   10 seconds ago   356MB
# 查看 ks/tomcat:1.0 的镜像的历史记录
~ docker image history ks/tomcat:1.0
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
f970d1ac7724   26 seconds ago   catalina.sh run                                 88.9kB    将Tomcat的Docs删除
...省略其他Tomcat镜像历史记录...
# 启动我们的新镜像并和原来的对比
~ docker run -it -d -P --name kst1 ks/tomcat:1.0
~ docker ps -l
CONTAINER ID   IMAGE           COMMAND             CREATED         STATUS         PORTS                                         NAMES
f134ddc6149d   ks/tomcat:1.0   "catalina.sh run"   5 seconds ago   Up 3 seconds   0.0.0.0:49155->8080/tcp, :::49155->8080/tcp   kst1

:::color1 官方的Tomcat镜像是完整的功能，自定义的Tomcat镜像是缺少 Docs 的文档功能。

:::

范例：演示 Ubuntu 安装 vim

1. 从 Hub 上下载 Ubuntu 镜像到本地并成功运行
2. 原始的默认ubuntu镜像是不带着 vim 命令的
3. 外网连通的情况下，安装 vim
4. 安装完成后，commit 成新的镜像
5. 启动新镜像生成容器实例并和原来的对比

$ docker pull ubuntu
$ docker run -it --name u1 -d ubuntu /bin/bash
# 更新容器的包管理工具
root@d674ed1c5c08:/# apt update -y
# 安装 vim 软件
root@d674ed1c5c08:/# apt install -y vim
root@d674ed1c5c08:/# vim --version
VIM - Vi IMproved 8.1 (2018 May 18, compiled Nov 08 2021 14:21:34)
root@d674ed1c5c08:/# exit
# 将容器提交为镜像
$ docker ps 
CONTAINER ID   IMAGE      COMMAND          CREATED          STATUS         PORTS    NAMES
d674ed1c5c08   ubuntu    "/bin/bash"     17 minutes ago   Up 17 minutes              u1
$ docker commit -m "添加vim软件" -a 'zhongzhiwei <935523993@qq.com>' u1 myubuntu:v1.0
$ docker images
REPOSITORY          TAG             IMAGE ID       CREATED         SIZE
myubuntu           v1.0            3a28444435e6   4 seconds ago    174MB
ubuntu             latest          ba6acccedd29   2 months ago    72.8MB
$ docker run -it --name mu1 -d myubuntu:v1.0 /bin/bash
$ docker exec -it mu1 /bin/bash
root@d674ed1c5c08:/# vim --version
VIM - Vi IMproved 8.1 (2018 May 18, compiled Nov 08 2021 14:21:34)
root@d674ed1c5c08:/# exit 
# 查看镜像历史
$ docker history ubuntu
IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
ba6acccedd29   2 months ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B
<missing>      2 months ago   /bin/sh -c #(nop) ADD file:5d68d27cc15a80653…   72.8MB
$ docker history myubuntu:v1.0
IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
3a28444435e6   8 minutes ago   /bin/bash                                       101MB     添加vim软件
ba6acccedd29   2 months ago    /bin/sh -c #(nop)  CMD ["bash"]                 0B
<missing>      2 months ago    /bin/sh -c #(nop) ADD file:5d68d27cc15a80653…   72.8MB

小总结

Docker 中的镜像分层，支持通过扩展现有镜像，创建新的镜像。类似于 Java 继承于一个 Base 基础类，自己按需扩展。新镜像是从 Base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层。

:::color1

:::

作业：案例 CentOS + Ubuntu 系统再官方镜像中添加 vim 软件并提交镜像运行成容器测试

~ docker run -itd --name c1 centos /bin/bash
~ docker exec -it c1 /bin/bash
$ rm -rf /etc/yum.repos.d/CentOS-Linux-*
$ curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
$ yum update ; yum install -y vim ; yum clean all
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
$ exit
~ docker commit -a "zhongzhiwei <935523993@qq.com>" -m "添加VIM软件" c1 kubesphere-centos:1.0
~ docker images kubesphere-centos:1.0
REPOSITORY          TAG       IMAGE ID       CREATED         SIZE
kubesphere-centos   1.0       7f36413d0ef3   4 seconds ago   271MB
# 运行添加VIM的新镜像
~ docker run -it --name kc1 kubesphere-centos:1.0 /bin/bash
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
###
~ docker run -itd --name u1 ubuntu /bin/bash
~ docker exec -it u1 /bin/bash
$ apt update ; apt install -y vim
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
$ exit
~ docker commit -a "zhongzhiwei <935523993@qq.com>" -m "添加VIM软件" c1 kubesphere-ubuntu:1.0
~ docker images kubesphere-ubuntu:1.0
REPOSITORY          TAG       IMAGE ID       CREATED         SIZE
kubesphere-ubuntu   1.0       7f36413d0ef3   4 seconds ago   178MB
# 运行添加VIM的新镜像
~ docker run -it --name ku1 kubesphere-ubuntu:1.0 /bin/bash
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)

5 Docker 容器数据卷

5.1 Docker 容器数据卷是什么

先来看看Docker的理念:

*将运用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的

为了能保存数据在 Docker 中我们使用容器数据卷。

一句话：类似于Redis的RDB文件和AOF文件

将Docker容器内的数据保存进宿主机的磁盘中

运行一个带有容器卷存储功能的容器实例

$ docker run -it --privileged=true -v /宿主机绝对路径:/容器内目录 镜像名

5.2 Docker 容器数据卷能干嘛

:::color1 数据卷就是目录或者文件，存在于一个或者多个容器中，由Docker挂载到容器，但是不属于联合文件系统，因此能够绕过 Union File System 提供一些用于持续存储或者共享数据的特性：

Docker 容器（数据） —-容器数据卷方式完成数据的持久化重要资料backup—> 映射，容器内的数据备份+持久化到本地主机目录

:::

• 将运用与运行的环境打包镜像，run 后形成容器实例运行，但是我们对数据的要求希望是持久化的
• Docker 容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了
• 为了能保存数据在Docker中我们使用数据卷
• 特点：
  • 数据据可以在容器之间共享或者重用数据
  • 卷中的更改可以直接实时生效（跟 docker cp 比较）
  • 数据卷中的更改不会包含在镜像的更新中
  • 数据卷的生命周期一直持续到没有容器使用它为止

:::color1

1. 容器的持久化
2. 容器间的继承 + 共享数据

:::

5.3 数据卷

容器内添加数据卷

• 直接命令添加数据卷

1. 命令

:::color1 docker run -it -v /宿主机绝对路径目录:/容器内的目录 镜像名

:::

范例：

# 数据卷会自动创建
~ docker run -itd \
-v /myDataVolume:/dataVolumeContainer centos:centos7.9.2009 /bin/bash
~ ls -ld /myDataVolume/
drwxr-xr-x. 2 root root 6 Aug  7 20:42 /myDataVolume/
# 查看容器的数据卷
~ docker ps -l
CONTAINER ID   IMAGE                   COMMAND       CREATED              STATUS              PORTS     NAMES
cd4098a4c4a1   centos:centos7.9.2009   "/bin/bash"   About a minute ago   Up About a minute             trusting_brattain
~ docker exec -it trusting_brattain /bin/bash
[root@cd4098a4c4a1 /]# ls -ld /dataVolumeContainer/
drwxr-xr-x. 2 root root 6 Aug  7 12:42 /dataVolumeContainer/

1. 查看数据卷是否挂载成功

~ docker inspect trusting_brattain | grep -A 9 "Mounts"
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/myDataVolume",
                "Destination": "/dataVolumeContainer",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

1. 容器和宿主机之间数据共享

~ docker exec -it trusting_brattain /bin/bash
[root@cd4098a4c4a1 /]# cat /dataVolumeContainer/host.txt
From Host data
[root@cd4098a4c4a1 /]# echo "Hello Container data" >> /dataVolumeContainer/host.txt
[root@cd4098a4c4a1 /]# exit

1. 容器退出后，主机修改后数据是否同步

~ cat /myDataVolume/host.txt
From Host data
Hello Container data
# 1.容器先停止退出
# 2.主机修改 a.log
# 3.容器重启进入
# 4.查看主机修改过的a.log
# 内容同步

1. 命令（带权限）

:::color1 docker run -it -v /宿主机绝对路径目录:/容器内的目录:ro 镜像名

:::

范例：

~ docker run -it -d --name centos-demo \
-v /myHostVolume:/dataVolumeContainer:ro centos:centos7.9.2009 /bin/bash
~ echo "From Host Data" > /myHostVolume/host.txt
# 查看容器的数据卷信息
~ docker exec -it centos-demo /bin/bash
[root@5dfd7423052b /]# cat /dataVolumeContainer/host.txt
From Host Data
[root@5dfd7423052b /]# echo "From Docker data" >> /dataVolumeContainer/host.txt
bash: /dataVolumeContainer/host.txt: Read-only file system
[root@5dfd7423052b /]# touch /dataVolumeContainer/docker.txt
touch: cannot touch '/dataVolumeContainer/docker.txt': Read-only file system
# 发现在容器中的数据卷只能是只读功能，没有写入操作。
~ docker inspect centos-demo | grep -A 3 HostConfig
        "HostConfig": {
            "Binds": [
                "/myHostVolume:/dataVolumeContainer:ro"
            ],

• Dockerfile 添加数据卷

:::warning

说明:

出于可移植和分享的考虑，用 -v 主机目录:容器目录 这种方法不能够直接在Dockerfile中实现。

由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

:::

1. File 构建
2. build 后生成镜像 -> 获得一个新镜像 ks/centos:1.0
3. run 容器
4. 通过上述步骤，容器内的卷目录地址已经知道对应的主机目录地址了吗？
5. 主机对应默认地址

$ mkdir -pv /mydocker ; cd /mydocker
$ cat > Dockerfile <<EOF
# 设置基础镜像
FROM centos:centos7.9.2009
# 设置容器的数据卷挂载，Docker会在宿主机开辟一块空间用于数据卷的持久化
VOLUME ["/dataVolumeContainer1", "/dataVolumeContainer2"]
# 打印文本信息
CMD echo "Finished, ------> Success"
# 容器的启动运行程序
CMD /bin/bash
EOF
# build 后生成镜像 -> 获得一个新镜像 ks/centos:1.0
$ docker build -f /mydocker/Dockerfile -t ks/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos:centos7.9.2009
 ---> eeb6ee3f44bd
Step 2/4 : VOLUME ["/dataVolumeContainer1", "/dataVolumeContainer2"]
 ---> Running in 8669a671d710
Removing intermediate container 8669a671d710
 ---> 4217584674d3
Step 3/4 : CMD echo "Finished, ------> Success"
 ---> Running in e70c9faf7633
Removing intermediate container e70c9faf7633
 ---> a5b7fa2c931a
Step 4/4 : CMD /bin/bash
 ---> Running in 717a1acf0aed
Removing intermediate container 717a1acf0aed
 ---> da4deaafa2b2
Successfully built da4deaafa2b2
Successfully tagged ks/centos:1.0
# 查看镜像
$ docker images ks/centos:1.0
REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
ks/centos    1.0       da4deaafa2b2   57 minutes ago   204MB
# 运行容器
$ docker run -it --name ks1 ks/centos:1.0 /bin/bash
[root@9bc6e66cb278 /]# ls -l /dataVolumeContainer*
/dataVolumeContainer1:
total 0
/dataVolumeContainer2:
total 0
[root@9bc6e66cb278 /]# echo "Hello dataVolumeContainer1 Data" > /dataVolumeContainer1/container1.txt
[root@9bc6e66cb278 /]# echo "Hello dataVolumeContainer2 Data" > /dataVolumeContainer2/container2.txt
# 容器的数据卷要与宿主机进行数据的交互沟通
# 查看容器的数据卷的挂载路径
$ docker inspect ks1 | grep -A 21 "Mounts"
        "Mounts": [
            {
                "Type": "volume",
                "Name": "b21f926635e0cd0b8586b01eec96b46cff36eaa12b9461ce24b5aae39917948b",
                "Source": "/var/lib/docker/volumes/b21f926635e0cd0b8586b01eec96b46cff36eaa12b9461ce24b5aae39917948b/_data",
                "Destination": "/dataVolumeContainer1",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "54327544d13290a1630b6bb138c47383f0515e55932aaff6b814fc813ceafd27",
                "Source": "/var/lib/docker/volumes/54327544d13290a1630b6bb138c47383f0515e55932aaff6b814fc813ceafd27/_data",
                "Destination": "/dataVolumeContainer2",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
$ ls -l /var/lib/docker/volumes/b21f926635e0cd0b8586b01eec96b46cff36eaa12b9461ce24b5aae39917948b/_data
total 4
-rw-r--r--. 1 root root 32 Aug  7 22:46 container1.txt
$ ls -l /var/lib/docker/volumes/54327544d13290a1630b6bb138c47383f0515e55932aaff6b814fc813ceafd27/_data
total 4
-rw-r--r--. 1 root root 32 Aug  7 22:47 container2.txt
$ cat /var/lib/docker/volumes/b21f926635e0cd0b8586b01eec96b46cff36eaa12b9461ce24b5aae39917948b/_data/container1.txt
Hello dataVolumeContainer1 Data
$ cat /var/lib/docker/volumes/54327544d13290a1630b6bb138c47383f0515e55932aaff6b814fc813ceafd27/_data/container2.txt
Hello dataVolumeContainer2 Data

• 备注

Docker 挂载主机目录Docker访问出现 cannot open directory .: Permission denied。

解决办法：在挂载目录后多加一个 —privileged=true 参数即可

5.4 数据卷容器

5.4.1 数据卷容器是什么

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器。

活动硬盘上面挂载活动硬盘，实现数据的传递依赖。

5.4.2 数据卷容器总体介绍

以上一步新建的镜像zzyy/centos为模板并运行容器 dc01 / dco2 / dc03

它们已经具有容器卷

• /dataVolumeContainer1
• /dataVolumeContainer2

5.4.3 容器间传递共享（—volumes-from）

先启动一个父容器 dc01

~ docker images ks/centos:1.0
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
ks/centos    1.0       da4deaafa2b2   3 hours ago   204MB
~ docker run -it --name dc01 ks/centos:1.0
[root@04629a777bbc /]# touch /dataVolumeContainer2/dc01_add.txt
[root@04629a777bbc /]# ls -l /dataVolumeContainer*
/dataVolumeContainer1:
total 0
/dataVolumeContainer2:
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt

dc02 / dc03 继承自 dc01

• —volumes-from
• 命令
  • dc02/ dc03 分别在 /dataVolumeContainer2 各自新增内容

~ docker run -it --name dc02 --volumes-from dc01 ks/centos:1.0
[root@0e1fb0e5dda8 /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
[root@0e1fb0e5dda8 /]# touch /dataVolumeContainer2/dc02_add.txt
~ docker run -it --name dc03 --volumes-from dc01 ks/centos:1.0
[root@628252b6bbee /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
[root@628252b6bbee /]# touch /dataVolumeContainer2/dc03_add.txt

回到dc01可以看到 dc02 / dc03各自添加的都能共享了

~ docker exec -it dc01 /bin/bash
[root@04629a777bbc /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt

删除dc01，dc02修改后dc03可否访问

~ docker rm -f dc01
~ docker exec -it dc02 /bin/bash
[root@0e1fb0e5dda8 /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt
[root@0e1fb0e5dda8 /]# touch /dataVolumeContainer2/dc02_update.txt
~ docker attach dc03
[root@628252b6bbee /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:52 dc02_update.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt
# --volumes-from 虽然指定容器数据卷，但是其实是宿主机的一片存储区域

删除dc02 后 dc03 可否访问

~ docker rm -f dc02
~ docker exec -it dc03 /bin/bash
[root@628252b6bbee /]# touch /dataVolumeContainer2/dc03_update.txt
[root@628252b6bbee /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:52 dc02_update.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:56 dc03_update.txt

新建 dc04 继承 dc03 后再删除dc03

~ docker run -it --name dc04 --volumes-from dc03 ks/centos:1.0
[root@58ac5443836b /]# ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:52 dc02_update.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:56 dc03_update.txt
~ docker rm -f dc03
~ docker exec -it dc04 touch /dataVolumeContainer2/dc04_add.txt
~ docker exec -it dc04 ls -l /dataVolumeContainer2/
total 0
-rw-r--r--. 1 root root 0 Aug  7 16:43 dc01_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc02_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:52 dc02_update.txt
-rw-r--r--. 1 root root 0 Aug  7 16:47 dc03_add.txt
-rw-r--r--. 1 root root 0 Aug  7 16:56 dc03_update.txt
-rw-r--r--. 1 root root 0 Aug  7 16:59 dc04_add.txt

6 Dockerfile 解析

:::warning 在上一个步骤中：

1. 手动编写一个 Dockerfile 文件，当然，必须要符合 file 的规范
2. 有这个文件后，直接 docker build 执行，获取一个自定义的镜像
3. docker run 运行成一个容器

:::

6.1 Dockerfile 是什么

:::warning

:::

概述

官网

https://docs.docker.com/engine/reference/builder/

构建三步骤

• 编写Dockerfile文件
• docker build 命令构建镜像
• docker run 依镜像运行容器实例

案例：以 CentOS 为例

CentOS Dockerfile

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"
# Default command
CMD ["/bin/bash"]

6.2 Dockerfile 构建过程解析

6.2.1 Dockerfile 内容基础知识

:::warning

1. 每条保留字指令都**<font style="color:#E8323C;">必须为大写字母</font>**并且后面要跟随至少一个参数
2. 指令按照从上到下，顺序执行
3. # 表示注释
4. 每条指令都会创建一个新的镜像层并对镜像进行提交

:::

6.2.2 Docker 执行 Dockerfile 大致流程

:::warning

1. docker 从基础镜像运行一个容器
2. 执行一条指令并对容器作出修改
3. 执行类似 docker commit 的操作提交一个新的镜像层
4. docker 再基于刚提交的镜像运行一个新容器
5. 执行 dockerfile 中的下一条指令直到所有指令都执行完成
6. 最后将所有指令汇集的容器执行 docker commit 操作提交镜像
7. 并将最后所有指令汇集的容器删除

:::

6.2.3 小总结

:::warning 从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段

• Dockerfile 是软件的原材料
• Docker 镜像是软件的交付品
• Docker 容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例

Dockerfile 面向开发，Docker 镜像成为交付标准，Docker 容器则涉及部署与运维，三者缺一不可，合力充当Docker 体系的基石。

:::

1. Dockerfile，需要定义一个 Dockerfile文件，Dockerfile 定义了进程需要的一切东西。Dockerfile 涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程（当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计 namespace 的权限控制）等等。
2. Docker 镜像，在用Dockerfile 定义一个文件之后，docker build 时产生一个Docker 镜像，当运行 Docker 镜像时会真正开始提供服务。
3. Docker 容器，容器直接提供服务的。

6.3 Dockerfile 保留字体系结构

FROM debian:bullseye-slim
# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added
RUN groupadd -r -g 999 redis && useradd -r -g redis -u 999 redis
# grab gosu for easy step-down from root
# https://github.com/tianon/gosu/releases
ENV GOSU_VERSION 1.14
RUN set -eux; \
    savedAptMark="$(apt-mark showmanual)"; \
    apt-get update; \
    apt-get install -y --no-install-recommends ca-certificates dirmngr gnupg wget; \
    rm -rf /var/lib/apt/lists/*; \
    dpkgArch="$(dpkg --print-architecture | awk -F- '{ print $NF }')"; \
    wget -O /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/$GOSU_VERSION/gosu-$dpkgArch"; \
    wget -O /usr/local/bin/gosu.asc "https://github.com/tianon/gosu/releases/download/$GOSU_VERSION/gosu-$dpkgArch.asc"; \
    export GNUPGHOME="$(mktemp -d)"; \
    gpg --batch --keyserver hkps://keys.openpgp.org --recv-keys B42F6819007F00F88E364FD4036A9C25BF357DD4; \
    gpg --batch --verify /usr/local/bin/gosu.asc /usr/local/bin/gosu; \
    gpgconf --kill all; \
    rm -rf "$GNUPGHOME" /usr/local/bin/gosu.asc; \
    apt-mark auto '.*' > /dev/null; \
    [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark > /dev/null; \
    apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
    chmod +x /usr/local/bin/gosu; \
    gosu --version; \
    gosu nobody true
ENV REDIS_VERSION 7.0.4
ENV REDIS_DOWNLOAD_URL http://download.redis.io/releases/redis-7.0.4.tar.gz
ENV REDIS_DOWNLOAD_SHA f0e65fda74c44a3dd4fa9d512d4d4d833dd0939c934e946a5c622a630d057f2f
RUN set -eux; \
    \
    savedAptMark="$(apt-mark showmanual)"; \
    apt-get update; \
    apt-get install -y --no-install-recommends \
        ca-certificates \
        wget \
        \
        dpkg-dev \
        gcc \
        libc6-dev \
        libssl-dev \
        make \
    ; \
    rm -rf /var/lib/apt/lists/*; \
    \
    wget -O redis.tar.gz "$REDIS_DOWNLOAD_URL"; \
    echo "$REDIS_DOWNLOAD_SHA *redis.tar.gz" | sha256sum -c -; \
    mkdir -p /usr/src/redis; \
    tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1; \
    rm redis.tar.gz; \
    \
# disable Redis protected mode [1] as it is unnecessary in context of Docker
# (ports are not automatically exposed when running inside Docker, but rather explicitly by specifying -p / -P)
# [1]: https://github.com/redis/redis/commit/edd4d555df57dc84265fdfb4ef59a4678832f6da
    grep -E '^ *createBoolConfig[(]"protected-mode",.*, *1 *,.*[)],$' /usr/src/redis/src/config.c; \
    sed -ri 's!^( *createBoolConfig[(]"protected-mode",.*, *)1( *,.*[)],)$!\10\2!' /usr/src/redis/src/config.c; \
    grep -E '^ *createBoolConfig[(]"protected-mode",.*, *0 *,.*[)],$' /usr/src/redis/src/config.c; \
# for future reference, we modify this directly in the source instead of just supplying a default configuration flag because apparently "if you specify any argument to redis-server, [it assumes] you are going to specify everything"
# see also https://github.com/docker-library/redis/issues/4#issuecomment-50780840
# (more exactly, this makes sure the default behavior of "save on SIGTERM" stays functional by default)
    \
# https://github.com/jemalloc/jemalloc/issues/467 -- we need to patch the "./configure" for the bundled jemalloc to match how Debian compiles, for compatibility
# (also, we do cross-builds, so we need to embed the appropriate "--build=xxx" values to that "./configure" invocation)
    gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; \
    extraJemallocConfigureFlags="--build=$gnuArch"; \
# https://salsa.debian.org/debian/jemalloc/-/blob/c0a88c37a551be7d12e4863435365c9a6a51525f/debian/rules#L8-23
    dpkgArch="$(dpkg --print-architecture)"; \
    case "${dpkgArch##*-}" in \
        amd64 | i386 | x32) extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-page=12" ;; \
        *) extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-page=16" ;; \
    esac; \
    extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-hugepage=21"; \
    grep -F 'cd jemalloc && ./configure ' /usr/src/redis/deps/Makefile; \
    sed -ri 's!cd jemalloc && ./configure !&'"$extraJemallocConfigureFlags"' !' /usr/src/redis/deps/Makefile; \
    grep -F "cd jemalloc && ./configure $extraJemallocConfigureFlags " /usr/src/redis/deps/Makefile; \
    \
    export BUILD_TLS=yes; \
    make -C /usr/src/redis -j "$(nproc)" all; \
    make -C /usr/src/redis install; \
    \
# TODO https://github.com/redis/redis/pull/3494 (deduplicate "redis-server" copies)
    serverMd5="$(md5sum /usr/local/bin/redis-server | cut -d' ' -f1)"; export serverMd5; \
    find /usr/local/bin/redis* -maxdepth 0 \
        -type f -not -name redis-server \
        -exec sh -eux -c ' \
            md5="$(md5sum "$1" | cut -d" " -f1)"; \
            test "$md5" = "$serverMd5"; \
        ' -- '{}' ';' \
        -exec ln -svfT 'redis-server' '{}' ';' \
    ; \
    \
    rm -r /usr/src/redis; \
    \
    apt-mark auto '.*' > /dev/null; \
    [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark > /dev/null; \
    find /usr/local -type f -executable -exec ldd '{}' ';' \
        | awk '/=>/ { print $(NF-1) }' \
        | sort -u \
        | xargs -r dpkg-query --search \
        | cut -d: -f1 \
        | sort -u \
        | xargs -r apt-mark manual \
    ; \
    apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
    \
    redis-cli --version; \
    redis-server --version
RUN mkdir /data && chown redis:redis /data
VOLUME /data
WORKDIR /data
COPY docker-entrypoint.sh /usr/local/bin/
ENTRYPOINT ["docker-entrypoint.sh"]
EXPOSE 6379
CMD ["redis-server"]

6.3.1 FROM

6.3.2 MAINTAINER

6.3.3 RUN

容器构建时需要运行的命令(容器启动前做的一下预操作)，在 docker build 命令构建镜像的时候，就会执行RUN的部分。一个 RUN 的操作就会添加一层镜像层，Dockerfile 最多 127 层镜像层。

两种格式

• Shell 格式

RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 指令
# 例如: 
RUN yum install -y vim

• exec 格式

RUN ["可执行文件", "参数1", "参数2"]
# 例如:
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline

RUN 是在 docker build 时运行

6.3.4 EXPOSE

EXPOSE [/…]

6.3.5 WORKDIR

WORKDIR /path/to/workdir

6.3.6 USER

6.3.7 ENV

用来在构建镜像过程中设置环境变量

ENV MY_PATH /usr/mytest

这个环境变量可以在后续的任何 RUN 指令中使用，这就如同在命令前面指定了环境变量前缀一样；

也可以在其他指令中直接使用这些环境变量

比如：WORKDIR $MY_PATH

6.3.8 ADD

ADD [—chown=:] … ADD [—chown=:] [““,… ““]

ADD 命令支持将远程URL的资源，但是 Docker 官方不建议直接用远程url，所以还是先下载到主机

6.3.9 COPY

:::warning COPY src dest

COPY [“src”, “dest”]

：源文件或者源目录

：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建

:::

6.3.10 VOLUME

VOLUME [“/data”]

VOLUMEVOLUME [“/var/log/“]VOLUME /var/logVOLUME /var/log /var/db

6.3.11 CMD

**<font style="color:#E8323C;">指定容器启动（docker run）后的要干的事情</font>**

CMD 容器启动命令

CMD 指令的格式和 RUN 相似，也是两种格式：

• shell 格式：CMD <命令>
• exec 格式：CMD [“可执行文件”, “参数1”, “参数2”, ……]
• 参数列表格式：CMD[“参数1”, “参数2” ……]。在指定了 ENTRYPOINT 指定后，用 CMD 指定具体的参数

注意

Dockerfile 中可以有很多个 CMD 指令，<font style="color:#E8323C;">但是只有最后一个生效，CMD会被docker run 之后的参数替换</font>

参考官网Tomcat 的 dockerfile 演示介绍

# 官网Dockerfile文件内容
......
EXPOSE 8080
CMD ["catalina.sh", "run"]

$ docker run -it -p 8080:8080 -d billygoo/tomcat8-jdk8:latest /bin/bash
# 浏览器将无法访问8080 Tomcat 默认网页

它和前面 RUN 命令的区别

**<font style="color:#E8323C;">CMD 是在 docker run 时运行</font>**

**<font style="color:#E8323C;">RUN 是在 docker build 时运行</font>**

6.3.12 ENTRYPOINT

也是用来指定一个容器启动（docker run）时要运行的命令

类似于 CMD 指令，但是 <font style="color:#E8323C;">ENTRYPOINT 不会被 docker run 后面的命令覆盖，而且这些命令行参数会被当做参数送给 ENTRYPOINT 指令指定的程序</font>

命令格式和案例说明

命令格式：
ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT 可以和 CMD 一起使用，一般是"变参"才会使用 CMD，这里的 CMD 等于是在给 ENTRYPOINT 传参
当指定了 ENTRYPOINT 后，CMD 的含义就发生了变化，
不再是直接运行其命令而是将 CMD 的内容作为参数传递给 ENTRYPOINT 指令，它两个组合会变成 <ENTRYPOINT> "<CMD>"
案例如下：假设已通过Dockerfile 构建了 "nginx:test 镜像"
FROM nginx
EXPOSE 80
ENTRYPOINT ["nginx", "-c"]         # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参

优点：在执行 docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。

注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

CMD 和 ENTRYPOINT 区别

:::warning CMD # 指定这个容器启动的时候要运行的命令，不可以追加命令

ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令

:::

6.3.13 ONBUILD

当构建一个被继承的 Dockerfile 时运行命令，父镜像在被子镜像的 ONBUILD 被触发。

ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

范例：

# 设置基础镜像
FROM centos:centos7.9.2009
# 添加 curl 软件包信息
RUN yum install -y curl
# 查看当前IP地址的归属地信息
# ENTRYPOINT [ "curl", "-s", "https://ip.cn" ]
ENTRYPOINT [ "curl", "-L", "http://ip.tool.lu" ]
ONBUILD RUN echo "Father image onbuild -----> Bye Bye Bye"

~ docker build -t myip-father:1.0 .
~ docker images myip-father:1.0
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
myip-father   1.0       8a88395f970d   19 seconds ago   381MB

# 设置基础镜像
FROM myip-father:1.0
# 添加 curl 软件包信息
RUN yum install -y curl
# 查看当前IP地址的归属地信息
# ENTRYPOINT [ "curl", "-s", "https://ip.cn" ]
ENTRYPOINT [ "curl", "-L", "http://ip.tool.lu" ]

~ docker build -t myip-san:1.0 .
Sending build context to Docker daemon   12.8kB
Step 1/3 : FROM myip-father:1.0
# Executing 1 build trigger
 ---> Running in a43745fd0d1d
Father image onbuild -----> Bye Bye Bye
Removing intermediate container a43745fd0d1d
 ---> b8250e846205
Step 2/3 : RUN yum install -y curl
 ---> Running in a8c963470adc
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
 * base: mirrors.ustc.edu.cn
 * extras: mirrors.ustc.edu.cn
 * updates: mirrors.cn99.com
Package curl-7.29.0-59.el7_9.1.x86_64 already installed and latest version
Nothing to do
Removing intermediate container a8c963470adc
 ---> dc891edbbcad
Step 3/3 : ENTRYPOINT [ "curl", "-L", "http://ip.tool.lu" ]
 ---> Running in 70e9ebe88871
Removing intermediate container 70e9ebe88871
 ---> 836a84139e73
Successfully built 836a84139e73
Successfully tagged myip-san:1.0