Video Reference：Docker最新超详细版教程通俗易懂

学前准备

• Linux 基本操作
• 计算机网络基础

Docker 的学习

• Docker 概述
• Docker 安装
• Docker 命令
  • 镜像命令
  • 容器命令
  • 仓库命令
  • 操作命令
  • ……
• Docker 镜像
• 容器的数据卷
• Dockerfile
• Docker 网络
• IDEA 整合 Docker
• Docker Compose
• Docker Swarm （ 简化版的 Docker ）
• CICD（ Jenkins ）

授人以鱼不如授人以渔（学习思想！）即使再小的帆也能远航。

1 Docker 概述

1.1 Docker 为什么会出现？

一款产品：开发 - 上线，三套环境（开发，测试，生产），应用配置

开发人员，运维人员。问题：我在我的电脑上可以运行的！版本更新，导致服务不可用，对于运维来说，考验就十分大了？开发即运维！

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

发布一个项目的 Jar （Redis，MySQL，JDK，ES）包。项目能不能带上环境安装打包！

之前在服务器配置一个应用的环境Redis MySQL jdk ES Hadoop，配置超麻烦了，不能够跨平台。Windows 最后分布到Linux！

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

Java —- Apk —- 分布（应用商店）—- 同学使用 Apk —- 安装即可用！

Java —- Jar（环境） —- 打包项目带上环境（镜像）—-（ Docker仓库：商店）—- 下载我们发布的就像 —- 直接运行即可！

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

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

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

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

传统上认为，软件编码开发/恻试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码文件等(Java为例)。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。

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

Docker镜像的设计，使得Docker得以打破过去「程序即应用」的观念。通过Docker镜像 ( images )将应用程序所需要的系统环境，由下而上打包，达到应用程序跨平台间的无缝接轨运作。

Docker 的思想就来自于集装箱！

JRE —- 多个应用（端口冲突） —- 原来都是交叉的！

隔离：Docker 核心思想！打包装箱！每个箱子都是相互隔离的。Docker 通过隔离机制，可以将服务器的性能利用到极致

本质：所有的技术都是因为出现了一些问题，我们需要去解决，才去学习！

1.2 Docker 的历史

2010年，几个搞IT的年轻人，在美国旧金山成立了一家名叫“dotCloud”的公司。

这家公司主要提供基于PaaS的云计算技术服务。具体来说，是和LXC有关的容器技术。后来，dotCloud公司将自己的容器技术进行了简化和标准化，并命名为——Docker。

Docker技术诞生之后，并没有引起行业的关注。而dotCloud公司，作为一家小型创业企业，在激烈的竞争之下，也步履维艰。正当他们快要坚持不下去的时候，脑子里蹦出了“开源”的想法。

什么是开源?开源，就是开放源代码。也就是将原来内部保密的程序源代码开放给所有人，然后让大家一起参与进来，贡献代码和意见。

有的软件是一开始就开源的。也有的软件，是混不下去，创造者又不想放弃，所以选择开源。自己养不活，就吃”百家饭”嘛。2013年3月，dotCloud公司的创始人之一，Docker之父，28岁的Solomon Hykes正式决定，将Docker项目开源。

不开则已，一开惊人。

越来越多的IT工程师发现了Docker的优点，然后蜂拥而至，加入Docker开源社区。Docker的人气迅速攀升，速度之快，令人瞠目结舌。

开源当月，Docker 0.1版本发布。此后的每一个月，Docker都会发布一个版本。到2014年6月9日，Docker 1.0版本正式发布

此时的Docker，已经成为行业里人气最火爆的开源技术，没有之一。甚至像Google、微软、Amazon、VMware这样的巨头，都对它青睐有加，表示将全力支持。I

Docker和容器技术为什么会这么火爆?说白了，就是因为它“轻”。

在容器技术之前，业界的网红是虚拟机。虚拟机技术的代表，是VMWare和Openstack。

相信很多人都用过虚拟机。虚拟机，就是在你的操作系统里面，装一个软件，然后通过这个软件，再模拟一台甚至多台”子电脑”出来。在”子电脑’里，你可以和正常电脑一样运行程序，例如开QQ。如果你愿意，你可以变出好几个”子电脑”，里面都开上QQ。”子电脑”和“子电脑”之间，是相互隔离的，互不影响。

虚拟机属于虚拟化技术。而Docker这样的容器技术，也是虚拟化技术，属于轻量级的虚拟化。

虚拟机虽然可以隔离出很多”子电脑”，但占用空间更大，启动更慢，虚拟机软件可能还要花钱（例如VMWare)。而容器技术恰好没有这些缺点。它不需要虚拟出整个操作系统，只需要虚拟一个小规模的环境(类似”沙箱”)。

它启动时间很快，几秒钟就能完成。而且，它对资源的利用率很高（一台主机可以同时运行几千个Docker容器)。此外，它占的空间很小，虚拟机一般要几GB到几十GB的空间，而容器只需要MB级甚至KB级。

正因为如此，容器技术受到了热烈的欢迎和追捧，发展迅速。

:::color1 VMware：Linux CentOS原生镜像（一台电脑！）隔离：需要开启多个虚拟机！—> nG 几分钟

Docker：隔离，镜像（最核心的环境 4M + JDK + MySQL）十分的小巧，运行镜像就可以了！小巧！—> nM/KB 秒级启动

:::

到现在，所有的开发人员和运维人员必须都要会 Docker！

Docker 三要素：容器，镜像，仓库

聊聊 Docker

Docker 是基于 Golang 语言开发的！开源项目！

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

文档地址：https://docs.docker.com/ （Docker 的文档是非常详细的！）

仓库地址：https://docs.docker.com/

1.3 Docker 能干嘛

虚拟化技术分全虚拟、半虚拟、容器技术三大类

:::color1 传统的虚拟化技术

虚拟机(virtual machine)就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种操作系统，比如在Windows系统里面运行Linux系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程序，操作系统和硬件三者之间的逻辑不变。

:::

虚拟机技术缺点：

1. 资源占用十分多
2. 冗余步骤多
3. 启动速度慢

:::color1 容器化技术

由于前面虚拟机存在这些缺点，Linux发展出了另一种虚拟化技术: Linux容器(Linux Containers，缩写为LXC).

Linux容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能妊终如一地运行。

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

:::

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

• ·传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程
• 而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
• 每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。

:::color1 开发/运维（DevOps）

更快速的应用交付和部署:

传统的应用开发完成后，需要提供一堆安装程序和配置说明文档，安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省部署配置和测试验证时间。

更便捷的升级和扩缩容:

随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块”积木”，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天级变成分钟级甚至秒级。

更简单的系统运维:

应用容器化运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。

更高效的计算资源利用:

Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor [管理程序]支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

:::

2 Docker 安装

2.1 Docker 的基本组成

• 镜像（Image）：

Docker 镜像就好比是一个模板，可以通过这个模板来创建容器服务，Tomcat 镜像 —> run —> tomcat01容器（提供服务）。通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器重的）。

• 容器（Container）：

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

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

目前就可以把这个容器理解为就是一个简易的Linux系统项目

• 仓库（Repository）：

仓库就是存放镜像的地方。仓库分为公有仓库和私有仓库！

公有仓库：Docker Hub（默认是国外的）。阿里云、网易云都有容器服务器（配置镜像加速！）

2.2 安装 Docker

环境准备

1. 需要会一部分Linux的基础
2. CentOS 7
3. 我们可以使用远程连接工具连接远程服务器进行操作！

环境查看

#系统内核是 3.10 以上的
$ uname -r 
3.10.0-1160.el7.x86_64

#系统版本
$ 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"

安装Docker

帮助文档：

#1.卸载旧的版本
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
#2.需要的安装
$ sudo yum install -y yum-utils
#3.设置镜像的仓库
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo #默认是国外的
$ sudo yum-config-manager \
  --add-repo \
  https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #推荐使用阿里云的，速度快
#4.更新yum软件包的索引
$ yum makecache fast
#5.安装Docker相关的 Docker-ce社区版，ee则是企业版
$ sudo yum install -y \
  docker-ce docker-ce-cli containerd.io docker-compose-plugin
#6.启动Docker
$ systemctl start docker
#7.查看Docker的信息
$ docker version
#判断Docker是否安装成功
#8.运行helloworld
$ sudo docker run hello-world

#9.查看镜像是否存在hello-world镜像
$ docker images 
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   11 months ago   13.3kB
#10.卸载Docker
#卸载依赖
yum remove -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
#删除资源
sudo rm -rf /var/lib/docker
#/var/lib/docker是Docker默认的工作路径
#最新版
sudo rm -rf /var/lib/containerd

2.3 阿里云镜像加速

1. 登录阿里云找到容器服务
2. 找到镜像加速地址

1. 配置使用

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

2.4 回顾HelloWorld流程

2.5 Docker 底层原理

2.5.1 Docker 是怎么工作的？

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

Docker Server 接受到 Docker-Client 的指令，就会执行这个命令！

Docker 为什么比 VM 快？

1. Docker 有着比虚拟机更少的抽象层
2. Docker 利用的是宿主机的内核，VM需要的是Guest OS

所以说，新建一个容器的时候，Docker 不需要像虚拟机一样重新加载一个操作系统内核，避免引导，虚拟机是加载 Guest OS，分钟级别的；而Docker 是利用宿主机的操作系统内核，省略了这个复杂的流程，秒级的。

3 Docker的常用命令

3.1 帮助命令

docker version            #显示Docker的版本信息
docker info               #显示Docker的系统信息，包括镜像和容器的数量
docker [ command ] --help #万能命令

帮助文档的地址：https://docs.docker.com/engine/reference/commandline/docker/

3.2 镜像命令

3.2.1 docker images

查看所有本地的本机上的镜像

$ docker images 
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   11 months ago   13.3kB
#解释
REPOSITORY 镜像的仓库源
TAG        镜像的表情
IMAGE ID   镜像的ID号
CREATED    镜像的创建时间
SIZE       镜像的大小

3.2.2 docker search

搜索镜像

$ docker search mysql 
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   13053     [OK]       
mariadb   MariaDB Server is a high performing open sou…   4995      [OK]     
#可选项，通过收藏进行过滤
--filte=STARS=3000 #搜索出来的镜像就是 STARS 大于3000的镜像
$ docker search --filter=STARS=3000 mysql 
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   13053     [OK]       
mariadb   MariaDB Server is a high performing open sou…   4995      [OK]

3.2.3 docker pull

下载镜像

#下载镜像 docker pull 镜像名[:tag]
$ docker pull mysql 
Using default tag: latest            #如果不写Tag，默认就是 latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete          #分层下载，docker image的核心，联合文件系统
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest         #真实的地址
$ docker pull mysql 
#等价于
$ docker pull docker.io/library/mysql:latest
#指定镜像版本下载
$ docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists 
93619dbc5b36: Already exists 
99da31dd6142: Already exists 
626033c43d70: Already exists 
37d5d7efb64e: Already exists 
ac563158d721: Already exists 
d2ba16033dad: Already exists 
0ceb82207cd7: Pull complete 
37f2405cae96: Pull complete 
e2482e017e53: Pull complete 
70deed891d42: Pull complete 
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
#查看镜像
$ docker images 
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         5.7       c20987f18b13   8 months ago    448MB
mysql         latest    3218b38490ce   8 months ago    516MB
hello-world   latest    feb5d9fea6a5   11 months ago   13.3kB

3.2.4 docker rmi

删除镜像

#删除指定的镜像
docker rmi <Image_ID>
#删除多个镜像
docker rmi <Image_ID> <Image_ID> <Image_ID> <Image_ID> 
#删除全部的镜像
docker rmi -f $(docker images -aq)

3.3 容器命令

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

$ docker pull centos:7.9.2009

新建容器并启动

$ docker run [可选参数] image
#参数说明
--name="Name" 容器名字 tomcat01 tomcat02，用来区分容器
-d            后台运行
-it           使用交互方式运行，进入容器查看内容
-p            指定容器的端口 -p 8080:8080
  -p ip:主机端口:容器端口
  -p 主机端口:容器端口(常用)
  -p 容器端口
  容器端口
-P            随机分配端口
#测试
$ docker run -it --name centos-node01 centos:7.9.2009 /bin/bash
#查看容器内的CentOS，基础环境，很多命令是不完善的
[root@094cce7271cd /]# ls
anaconda-post.log  bin  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
#从容器中退回主机
[root@094cce7271cd /]# exit
exit

列出所有运行的容器

#docker ps 命令
#默认是列出当前正在运行的容器
-a   #列出当前正在运行的容器+带出历史运行过的容器
-n=? #显示最近创建的容器
-q   #只显示容器的编号
$ docker ps -a
CONTAINER ID   IMAGE             COMMAND       CREATED         STATUS                    PORTS     NAMES
094cce7271cd   centos:7.9.2009   "/bin/bash"   2 minutes ago   Up 2 minutes                        centos-node01
495be2b73cf1   feb5d9fea6a5      "/hello"      24 hours ago    Exited (0) 24 hours ago             thirsty_faraday

退出容器

exit     #直接容器停止并退出
Ctrl+P+Q #容器不停止退出

删除容器

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

启动和停止容器的操作

#启动容器
docker start 容器ID
#重启容器
docker restart 容器ID
#停止当前正在运行容器
docker stop 容器ID
#强制停止当前容器
docker kill 容器ID

3.4 常用其他命令

后台启动容器

#命令 docker run -d 镜像名!
docker run -d centos:7.9.2009
#问题 docker ps ，发现 centos:7.9.2009 停止了
#常见的坑，docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
#nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了。
#测试
docker run -d -it --name centos-node02 centos:7.9.2009 /bin/bash

查看日志

$ docker logs -f -t --tail [指定条目数] 容器
#显示日志
-tf    :显示日志(-f动态显示，-t时间戳显示)
--tail :要显示日志的条目数
#启动容器时指定相应的命令
$ docker run  -itd \
            --name centos-node03 \
            --restart=always \
            centos:7.9.2009 /bin/bash -c "while true;do echo hello,world;done;sleep 1"
$ docker ps -l
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS          PORTS     NAMES
707f6716e19c   centos:7.9.2009   "/bin/bash -c 'while…"   38 seconds ago   Up 37 seconds             centos-node03
$ docker logs -f -t --tail 10 centos-node03

查看容器中进程信息

#命令 docker top 容器ID
$ docker top  centos-node03
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                15876               15855               82                  22:37               ?                   00:03:18            /bin/bash -c while true;do echo hello,world;done;sleep 1

查看容器的元数据

#命令
docker inspect 容器ID
#测试
$ docker inspect centos-node03
[
    {
        "Id": "707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed",
        "Created": "2022-08-23T14:37:13.462762788Z",
        "Path": "/bin/bash",
        "Args": [
            "-c",
            "while true;do echo hello,world;done;sleep 1"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 15876,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-08-23T14:37:13.81511042Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:eeb6ee3f44bd0b5103bb561b4c16bcb82328cfe5809ab675bb17ab3a16c517c9",
        "ResolvConfPath": "/var/lib/docker/containers/707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed/hostname",
        "HostsPath": "/var/lib/docker/containers/707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed/hosts",
        "LogPath": "/var/lib/docker/containers/707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed/707f6716e19ceea875cdd61dc2969b3542aed5523ffa78bb8f65c460050d08ed-json.log",
        "Name": "/centos-node03",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "always",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/72f30a5ccf50446ae62fd2722e318bea1a2dabc9eef978a37d60a7739350f8d8-init/diff:/var/lib/docker/overlay2/a37fa3541021205d4cc6fe5a51d6bda9a627c860fe9e0d6b23b317fd03e02dd8/diff",
                "MergedDir": "/var/lib/docker/overlay2/72f30a5ccf50446ae62fd2722e318bea1a2dabc9eef978a37d60a7739350f8d8/merged",
                "UpperDir": "/var/lib/docker/overlay2/72f30a5ccf50446ae62fd2722e318bea1a2dabc9eef978a37d60a7739350f8d8/diff",
                "WorkDir": "/var/lib/docker/overlay2/72f30a5ccf50446ae62fd2722e318bea1a2dabc9eef978a37d60a7739350f8d8/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "707f6716e19c",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash",
                "-c",
                "while true;do echo hello,world;done;sleep 1"
            ],
            "Image": "centos:7.9.2009",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20201113",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS",
                "org.opencontainers.image.created": "2020-11-13 00:00:00+00:00",
                "org.opencontainers.image.licenses": "GPL-2.0-only",
                "org.opencontainers.image.title": "CentOS Base Image",
                "org.opencontainers.image.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "7e286039cc7562f9fe6b6174ef9dae698a6dc049414cfc56d666ca471689a78d",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/7e286039cc75",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "4b0a08726af85c28a4a6181d335491dd61c0e0b5530248f6be9adfc8ed9f6f41",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.4",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:04",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "ab0a6a7d99f1b549817749b69872806ed8989be4f03d330498f0f6becdd2b010",
                    "EndpointID": "4b0a08726af85c28a4a6181d335491dd61c0e0b5530248f6be9adfc8ed9f6f41",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.4",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:04",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

#通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
#命令
docker attach 容器ID
docker exec -it 容器ID bashShell
#测试
$ docker exec -it centos-node03 /bin/bash
[root@707f6716e19c /]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0 85 14:37 pts/0    00:09:17 /bin/bash -c while true;do echo hello,world;done;sleep 1
root          7      0  0 14:47 pts/1    00:00:00 /bin/bash
root         21      7  0 14:48 pts/1    00:00:00 ps -ef
[root@707f6716e19c /]# exit
exit
#测试
$ docker attach centos-node03
hello,world
hello,world
hello,world
#正在执行当前的代码
#docker exec   #进入容器后开启一个新的终端，可以在里面操作(常用)
#docker attach #进入容器正在执行的终端，不会启动新的进程

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

docker cp 容器ID:容器内路径 宿主机路径
#宿主机创建一个文件
$ echo "hello,docker" > host.txt
#将宿主机的文件传到容器内
$ docker cp host.txt centos-node03:/tmp
$ docker exec -it centos-node03 cat /tmp/host.txt #容器内有该文件
hello,docker
#容器内创建文件
$ docker exec -it centos-node03 /bin/bash
[root@707f6716e19c /]# cd /tmp/
[root@707f6716e19c tmp]# echo "hello,dockerhost" > docker.txt
[root@707f6716e19c tmp]# exit
#容器内的文件传到宿主机中
$ docker cp centos-node03:/tmp/docker.txt /tmp
$ cat /tmp/docker.txt
hello,dockerhost
#拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现

3.5 总结

• 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 —- 截取容器停止时的退出状态值

docker 的命令十分多，以上是最常用的容器和镜像的命令。

3.6 作业练习

3.6.1 部署Nginx

#1.搜索nginx镜像 docker search 建议去dockerhub搜索，可以看到帮助文档
#2.下载镜像 docker pull
$ docker pull nginx:1.23.1-alpine
$ docker images nginx:1.23.1-alpine
REPOSITORY   TAG             IMAGE ID       CREATED       SIZE
nginx        1.23.1-alpine   804f9cebfdc5   13 days ago   23.5MB
#3.启动容器
#-d     后台运行
#--name 给容器命名
#-p 宿主机端口:容器内部端口
$ docker run -itd --name nginx01 -p 3344:80 --restart=always nginx:1.23.1-alpine
$ docker ps -l
CONTAINER ID   IMAGE                 COMMAND                  CREATED         STATUS         PORTS                                   NAMES
d0edd598caa1   nginx:1.23.1-alpine   "/docker-entrypoint.…"   6 minutes ago   Up 6 minutes   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
$ curl localhost:3344
$ docker port nginx01
80/tcp -> 0.0.0.0:3344
80/tcp -> :::3344

端口暴露的概念

:::color1 思考问题：我们每次改动Nginx配置，都需要进入容器内部？十分的麻烦，要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改？

解决方法：-v 数据卷

:::

3.6.2 部署 Tomcat

#官方的使用
$ docker run -it --rm tomcat:9.0
#之前的启动都是后台，停止了容器之后，容器还可以 docker ps 查到
#docker run -it --rm 一般用来测试，用完就删除容器
#下载在启动
$ docker pull tomcat:9.0
$ docker run -it -p 3355:8080 --name tomcat01 -d tomcat:9.0 
#测试访问没有问题
#进入容器
$ docker exec -it tomcat01 /bin/bash
root@2cf8573ed4e2:/usr/local/tomcat# cp -av webapps.dist/* webapps/
root@2cf8573ed4e2:/usr/local/tomcat# exit
exit
#发现问题：
#1.Linux命令少了
#2.webapps目录下没有web文件。镜像的原因，默认是最小的镜像，所有不必要的都剔除掉。
#保证最小可运行的环境
$ docker ps -l
CONTAINER ID   IMAGE        COMMAND             CREATED         STATUS         PORTS                                       NAMES
2cf8573ed4e2   tomcat:9.0   "catalina.sh run"   4 minutes ago   Up 4 minutes   0.0.0.0:3355->8080/tcp, :::3355->8080/tcp   tomcat01
$ docker port tomcat01
8080/tcp -> 0.0.0.0:3355
8080/tcp -> :::3355

:::color1 思考问题：我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？要是可以在容器外部提供一个映射路径，webapps，我们在外部放置项目，就自动同步到内部就好了！

:::

3.6.3 部署 ES+Kibana

ES暴露的端口很多

ES十分的消耗内存

ES的数据一般需要放置到安全目录！挂载

$ docker network create somenetwork
#启动 elasticsearch 容器
$ docker run -d --name elasticsearch \
      --net somenetwork \
      -p 9200:9200 \
      -p 9300:9300 \
      -e "discovery.type=single-node" elasticsearch:7.17.5
#启动了 elasticsearch容器后，docker stats 查看CPU状态
$ docker stats --no-stream elasticsearch
CONTAINER ID   NAME            CPU %     MEM USAGE / LIMIT     MEM %     NET I/O       BLOCK I/O     PIDS
90e93d93b0b0   elasticsearch   1.41%     1.226GiB / 3.682GiB   33.28%    2.38kB / 0B   0B / 1.02MB   45
#测试ES是否成功了，增加内存的设置
$ curl localhost:9200
{
  "name" : "90e93d93b0b0",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "W4bf0m9_TU2e5TxRgifsqg",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}
#设置容器的内存限制，修改配置文件-e环境配置修改
$ docker run -d --name elasticsearch \
      --net somenetwork \
      -p 9200:9200 \
      -p 9300:9300 \
      -e "discovery.type=single-node" \
      -e ES_JAVA_OPTS="-Xms256m -Xmx512m" elasticsearch:7.17.5
#再次查看 docker stats 容器资源状态
$ docker stats --no-stream elasticsearch
CONTAINER ID   NAME            CPU %     MEM USAGE / LIMIT     MEM %     NET I/O     BLOCK I/O    PIDS
c4479d160c62   elasticsearch   1.52%     364.6MiB / 3.682GiB   9.67%     656B / 0B   0B / 849kB   46
$ curl localhost:9200
{
  "name" : "c4479d160c62",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "xj_fi6P2Tc2DldYqSCz2dw",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

#安装Kibana
$ mkdir -p /mydata/elasticsearch/kibana/config/
$ cat > /mydata/elasticsearch/kibana/config/kibana.yml <<EOF
#
# ** THIS IS AN AUTO-GENERATED FILE **
#
# Default Kibana configuration for docker target
server.host: "0.0.0.0"
server.shutdownTimeout: "5s"
elasticsearch.hosts: [ "http://10.0.0.101:9200" ]
monitoring.ui.container.elasticsearch.enabled: true
EOF
$ docker run -d \
            --name kibana \
            --net somenetwork \
            -v /mydata/elasticsearch/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml \
            -p 5601:5601 kibana:7.17.5
$ docker ps -l
CONTAINER ID   IMAGE           COMMAND                  CREATED         STATUS         PORTS                                       NAMES
aa2b70cdab6f   kibana:7.17.5   "/bin/tini -- /usr/l…"   2 minutes ago   Up 2 minutes   0.0.0.0:5601->5601/tcp, :::5601->5601/tcp   kibana

3.7 可视化面板

Portainer 官方站点

#启动一个默认的Tomcat
$ docker run -it -d -p 8080:8080 --name tomcat01 tomcat
#发现这个默认的Tomcat新版本是没有webapps应用，是由于镜像的原因：官方的新镜像默认Tomcat下的webapps目录下是没有文件的
$ docker exec -it tomcat01 /bin/bash
#将webapps.dist目录下的文件拷贝到webapps中
root@82b9be0838cd:/usr/local/tomcat# cp -av webapps.dist/ webapps
root@82b9be0838cd:/usr/local/tomcat# cd webapps
root@82b9be0838cd:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
root@82b9be0838cd:/usr/local/tomcat/webapps# exit
exit
$ curl localhost:8080
#将操作过的容器通过 commit 提交为一个镜像
$ docker commit \
  -a "zhongzhiwei <zhongzhiwei@kubesphere.io>" \
  -m "拷贝webapps.dist目录下的内容到webapps" \
  tomcat01 kube-tomcat:1.0
#查看提交的镜像
$ docker images kube-tomcat:1.0
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
kube-tomcat   1.0       0cf24bc18be1   4 seconds ago   684MB
$ docker history kube-tomcat:1.0
IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
0cf24bc18be1   3 minutes ago   catalina.sh run                                 4.43MB    拷贝webapps.dist目录下的内容到webapps
fb5657adc892   8 months ago    /bin/sh -c #(nop)  CMD ["catalina.sh" "run"]    0B
<missing>      8 months ago    /bin/sh -c #(nop)  EXPOSE 8080                  0B
<missing>      8 months ago    /bin/sh -c set -eux;  nativeLines="$(catalin…   0B
<missing>      8 months ago    /bin/sh -c set -eux;   savedAptMark="$(apt-m…   20.2MB
<missing>      8 months ago    /bin/sh -c #(nop)  ENV TOMCAT_SHA512=c2d2ad5…   0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV TOMCAT_VERSION=10.0.14   0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV TOMCAT_MAJOR=10          0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV GPG_KEYS=A9C5DF4D22E9…   0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV LD_LIBRARY_PATH=/usr/…   0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV TOMCAT_NATIVE_LIBDIR=…   0B
<missing>      8 months ago    /bin/sh -c #(nop) WORKDIR /usr/local/tomcat     0B
<missing>      8 months ago    /bin/sh -c mkdir -p "$CATALINA_HOME"            0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV PATH=/usr/local/tomca…   0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV CATALINA_HOME=/usr/lo…   0B
<missing>      8 months ago    /bin/sh -c #(nop)  CMD ["jshell"]               0B
<missing>      8 months ago    /bin/sh -c set -eux;   arch="$(dpkg --print-…   343MB
<missing>      8 months ago    /bin/sh -c #(nop)  ENV JAVA_VERSION=11.0.13     0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV LANG=C.UTF-8             0B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV PATH=/usr/local/openj…   0B
<missing>      8 months ago    /bin/sh -c { echo '#/bin/sh'; echo 'echo "$J'   27B
<missing>      8 months ago    /bin/sh -c #(nop)  ENV JAVA_HOME=/usr/local/…   0B
<missing>      8 months ago    /bin/sh -c set -eux;  apt-get update;  apt-g…   11.3MB
<missing>      8 months ago    /bin/sh -c apt-get update && apt-get install…   152MB
<missing>      8 months ago    /bin/sh -c set -ex;  if ! command -v gpg > /…   18.9MB
<missing>      8 months ago    /bin/sh -c set -eux;  apt-get update;  apt-g…   10.7MB
<missing>      8 months ago    /bin/sh -c #(nop)  CMD ["bash"]                 0B
<missing>      8 months ago    /bin/sh -c #(nop) ADD file:c03517c5ddbed4053…   124MB
#使用我们修改提交的新镜像，那么就会发现在 webapps 目录下有相应的文件
$ docker run -it -p 8085:8080 --name mytomcat01 -d kube-tomcat:1.0
$ docker exec -it mytomcat01 /bin/bash
root@6b8f51a773ee:/usr/local/tomcat# ls webapps
ROOT  docs  examples  host-manager  manager
root@6b8f51a773ee:/usr/local/tomcat# exit
exit
$ curl localhost:8085

:::warning 学习方式说明：理解概念，可以比较模糊，但是一定要实践，最后实践和理论相结合。

如果想保存当前容器的状态，就可以通过 commit 方式来提交镜像，获取一个镜像。类似于虚拟机的快照功能。

:::

5 容器数据卷

5.1 什么是容器数据卷

docker 的理念回顾

将应用和运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对于数据的要求，是希望能够持久化的!就好比，你安装一个MySQL，结果你把容器删了，就相当于删库跑路了，这TM也太扯了吧!

所以我们希望容器之间有可能可以共享数据，Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据作为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了!这样是行不通的!

为了能保存数据在Docker中我们就可以使用卷!让数据挂载到我们本地!这样数据就不会因为容器删除而丢失了！

数据？如果数据都在容器中，那么容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删除了，数据则删除，删库跑路。需求：MySQL的数据存放到本地！

容器之间可以有一个数据共享的技术！Docker 容器中产生的数据，同步到本地！

这就是数据卷技术！目录的挂载，将我们容器内的目录，挂载到Linux系统指定的目录下。

作用:

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

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。

特点：

1、数据卷可在容器之间共享或重用数据

2、卷中的更改可以直接生效

3、数据卷中的更改不会包含在镜像的更新中

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

总结：容器的数据持久化和同步操作！容器间也是可以数据共享的！

5.2 使用数据卷

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

:::warning docker run -it -v 主机目录:容器内的目录

:::

范例：

$ docker run -it -d \
  -v /data/ubuntu01:/home \
  --privileged=true \
  --name ubuntu01 ubuntu:20.04 /bin/bash
#查看容器的详细信息显示
#通过docker inpsect 容器ID 查看
#值得注意的是，主机目录会直接覆盖掉容器中要挂载的目录
$ docker inspect ubuntu01 | grep -A 9 "Mounts"
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/data/ubuntu01",  #主机内的目录路径
                "Destination": "/home",      #Docker容器内的目录路径
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],
$ docker exec -it ubuntu01 /bin/bash
root@9afa7b8ee434:/# cd /home/
root@9afa7b8ee434:/home# mkdir host ; ls
host
root@9afa7b8ee434:/home# echo "Hello World!" > /home/docker.txt
root@9afa7b8ee434:/home# exit
$ ls /data/ubuntu01/
docker.txt  host
#再次测试
#删除原有的ubuntu01容器，启动ubuntu02容器进行挂载该目录
$ docker rm -f ubuntu01
$ docker run -it -d \
  --name ubuntu02 \
  --privileged=true \
  -v /data/ubuntu01:/home \
  ubuntu:20.04 /bin/bash
$ docker exec -it ubuntu02 /bin/bash
root@2ac37ab7725a:/# ls /home/
docker.txt  host
root@2ac37ab7725a:/# cat /home/docker.txt
Hello World!

:::warning 数据卷好处：我们以后修改只需要修改本地修改即可，容器内会自动同步。类似共享文件是占用一份的存储。

:::

5.3 实战：安装MySQL

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

#获取并下载MySQL镜像
$ docker pull mysql:5.7.36
#官方测试 $ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD_FILE=/run/secrets/mysql-root -d mysql:tag
#运行mysql容器，需要做数据挂载
#安装启动mysql，需要配置密码，注意事项
#-d 后台运行
#-p 端口映射
#-v 数据卷挂载
#-e 环境变量设置
#--name 容器名字
$ docker run -it -d \
  --name mysql01 \
  -p 3316:3306 \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v /data/docker/mysql01/conf:/etc/mysql/conf.d \
  -v /data/docker/mysql01/data:/var/lib/mysql \
  mysql:5.7.36
#如果在挂载时，外部是新建目录或空目录会将容器中映射目录也变成空目录
$ cat > /data/docker/mysql01/conf/my.cnf <<EOF
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
EOF
$ ls /data/docker/mysql01/conf/
my.cnf
$ ls /data/docker/mysql01/data/
auto.cnf    client-cert.pem  ib_buffer_pool  ib_logfile1  performance_schema  server-cert.pem
ca-key.pem  client-key.pem   ibdata1         ibtmp1       private_key.pem     server-key.pem
ca.pem      ib_logfile0     mysql        public_key.pem      sys
#默认 -v 是先主机挂载覆盖了，然后 MySQL 程序启动才自动创建的数据，会直接生成/var/lib/mysql/目录下的数据库数据
$ docker restart mysql01
mysql01
#启动成功之后，在本地使用Navicat等数据库连接工具进行连接即可。
#Navicat 连接到服务器 3316 --> 3316 端口是和容器的内部的 3306 映射，这个时候就可以连接上了
#在本地创建一个测试数据库dbtest，可以在挂载目录下查看到相应的目录
$ ls -l /data/docker/mysql01/data/dbtest/
total 4
-rw-r----- 1 polkitd input 67 Aug 25 17:10 db.opt

:::color1 假设我们将容器删除了。

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

:::

5.4 具名挂载和匿名挂载

#匿名挂载
-v 容器内路径
$ docker run -it -d -P --name nginx01 -v /etc/nginx nginx
#查看所有 volume 的情况
$ docker volume ls
DRIVER    VOLUME NAME
local     b5c1c38d5935b1e1adc829c3eb28af15188368169745afe75f230858969b6df9
#这里发现，这种就是匿名挂载，我们在 -v 只写了容器内的路径，没有写容器外的路径
$ docker inspect nginx01 | grep -A 9 "Mounts"
        "Mounts": [
            {
                "Type": "volume",
                "Name": "b5c1c38d5935b1e1adc829c3eb28af15188368169745afe75f230858969b6df9",
                "Source": "/var/lib/docker/volumes/b5c1c38d5935b1e1adc829c3eb28af15188368169745afe75f230858969b6df9/_data",
                "Destination": "/etc/nginx",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
$ cd /var/lib/docker/volumes/b5c1c38d5935b1e1adc829c3eb28af15188368169745afe75f230858969b6df9/_data
$ ls
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params
#具名挂载
$ docker run -it -d -P --name nginx02 -v nginx-volume:/etc/nginx nginx
62c42ad0e4ca2374ee30af5b18b48a40e197d41126225446716c241639c3dbf3
#通过 -v 卷名:容器内路径
#查看所有 volume 的情况
$ docker volume ls
DRIVER    VOLUME NAME
local     nginx-volume
#查看一下这个具名卷
$ docker volume inspect nginx-volume
[
    {
        "CreatedAt": "2022-08-25T20:41:56+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/nginx-volume/_data",
        "Name": "nginx-volume",
        "Options": null,
        "Scope": "local"
    }
]

:::color1 所有的 Docker 容器内的卷，没有指定目录的情况下都是在 “/var/lib/docker/volumes/xxx/_data“

我们通过具名挂载可以方便的让我们找到对应的数据卷名，大多数情况是使用”具名挂载”

:::

思考：如何请是具名挂载还是匿名挂载，还是指定路径挂载！

• -v 容器内路径 #匿名挂载
• -v 卷名:容器内路径 #具名挂载
• -v /宿主机路径:容器内路径 #指定路径挂载

拓展：

#通过 -v 容器内路径:ro rw 改变读写权限
ro readonly  #只读
rw readwrite #可读可写
#一旦这个设置了容器，容器对我们挂载出来的内容就有限定了！
$ docker run -it -d -P --name nginx03 -v nginx-volume:/etc/nginx:ro nginx
$ docker run -it -d -P --name nginx03 -v nginx-volume:/etc/nginx:rw nginx
#默认是rw，如果是 ro 就说明只能通过宿主机来操作，容器内部是无法操作的

5.5 初识 Dockerfile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本！先体验一下！

通过这个脚本可以生成镜像，镜像是一层一层的，对应的就是脚本一个个的。每一个命令都是一层！

$ mkdir -pv /root/docker/docker-volume ; cd /root/docker/docker-volume
#创建一个Dockerfile文件，名字可以随机 建议使用Dockerfile
#文件中的内容指令(大写) 参数
$ vim Dockerfile
FROM ubuntu:20.04
#匿名挂载
VOLUME ["/volume01", "/volume02"]
RUN echo "-----> Success ......"
CMD /bin/bash
#这里的每一个命令，就是镜像的一层
$ docker build -t kube-ubuntu:1.0 -f Dockerfile .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM ubuntu:20.04
---> ba6acccedd29
Step 2/4 : VOLUME ["/volume01", "/volume02"]
---> Running in f77e4a3d3e7f
Removing intermediate container f77e4a3d3e7f
---> 91315a9d10d0
Step 3/4 : RUN echo "-----> Success ......"
---> Running in fa440b3de704
-----> Success ......
Removing intermediate container fa440b3de704
---> ffe4ed184001
Step 4/4 : CMD /bin/bash
---> Running in f27e036a6862
Removing intermediate container f27e036a6862
---> 1f2a4e5e429d
Successfully built 1f2a4e5e429d
Successfully tagged kube-ubuntu:1.0
$ docker images kube-ubuntu:1.0
REPOSITORY    TAG       IMAGE ID       CREATED              SIZE
kube-ubuntu   1.0       1f2a4e5e429d   About a minute ago   72.8MB
$ docker run -itd --name ku1 kube-ubuntu:1.0 /bin/bash
$ docker exec -it ku1 /bin/bash
#这个目录就是我们生成镜像的时候自动挂载的，数据卷目录
root@6a6138c411dd:/# echo "Hello volume01" > /volume01/container01.txt
root@6a6138c411dd:/# echo "Hello volume02" > /volume02/container02.txt
root@6a6138c411dd:/# ls -l /volume0*
/volume01:
total 4
-rw-r--r-- 1 root root 15 Aug 25 13:08 container01.txt
/volume02:
total 4
-rw-r--r-- 1 root root 15 Aug 25 13:08 container02.txt
root@6a6138c411dd:/# exit
exit
#这个数据卷和外部一定有一个同步的目录
$ docker inspect ku1 | grep -A 21 "Mounts"
        "Mounts": [
            {
                "Type": "volume",
                "Name": "604c9c1d68d41958287107effbd1dcfbd0bbd875c9cb7dd8b35982f446e35f68",
                "Source": "/var/lib/docker/volumes/604c9c1d68d41958287107effbd1dcfbd0bbd875c9cb7dd8b35982f446e35f68/_data",
                "Destination": "/volume01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "f6262a1ec8581c5b6a6b78e3beacd4881b435a5d331f5c33d88e5c9e0b8bfb89",
                "Source": "/var/lib/docker/volumes/f6262a1ec8581c5b6a6b78e3beacd4881b435a5d331f5c33d88e5c9e0b8bfb89/_data",
                "Destination": "/volume02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
#测试一下，刚才的文件是否同步了！
#这种方式我们未来使用的十分多，因为我们通常会构建自己的镜像！
$ cat /var/lib/docker/volumes/604c9c1d68d41958287107effbd1dcfbd0bbd875c9cb7dd8b35982f446e35f68/_data/container01.txt
Hello volume01
$ cat /var/lib/docker/volumes/f6262a1ec8581c5b6a6b78e3beacd4881b435a5d331f5c33d88e5c9e0b8bfb89/_data/container02.txt
Hello volume02

假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名:容器内路径！

5.6 数据卷容器

#启动3个容器，通过我们刚才自己写的镜像启动
$ docker images kube-ubuntu:1.0
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
kube-ubuntu   1.0       317c07f88b30   30 minutes ago   72.8MB
#写/bin/bash是规定镜像启动时执行这条指令，centos镜像启动时默认会执行/bin/bash，因此可以不写
$ docker run -itd --name docker01 kube-ubuntu:1.0 /bin/bash
$ docker run -itd --name docker02 --volumes-from docker01 kube-ubuntu:1.0 /bin/bash
#--volumes-from 实际上多个容器挂载的是同一个数据卷
#--volumes-from 就可以实现容器间的数据共享了
#在docker01容器中创建测试文件，检验docker02是否也有其测试文件
#docker01创建测试文件
$ docker exec -it docker01 /bin/bash
root@51ae030c5f2a:/# echo "Hello docker02 volume01" > /volume01/test01.txt
root@51ae030c5f2a:/# echo "Hello docker02 volume02" > /volume02/test02.txt
#docker02查看测试文件
$ docker exec -it docker02 /bin/bash
root@9807aeded26e:/# cat /volume01/test01.txt
Hello docker02 volume01
root@9807aeded26e:/# cat /volume02/test02.txt
Hello docker02 volume02
#docker03继承docker02的数据卷信息，并创建测试文件
$ docker run -it --name docker03 --volumes-from docker02 kube-ubuntu:1.0 /bin/bash
root@bdc47c45e893:/# echo "Hello I am docker03" > /volume01/docker03.txt
root@bdc47c45e893:/# echo "Hello I am docker03 Here" > /volume02/docker03.txt
#docker01可以查看到docker03的测试文件
$ docker exec -it docker01 /bin/bash
root@51ae030c5f2a:/# cat /volume01/docker03.txt
Hello I am docker03
root@51ae030c5f2a:/# cat /volume02/docker03.txt
Hello I am docker03 Here

#测试：可以删除 docker01，查看一下docker02和docker03是否还可以访问这个文件
#测试依旧可以访问
$ docker rm -f docker01
#三个容器都是挂载到宿主机的同一个目录下的，如果删掉宿主机下的这个目录的文件，三个容器的数据都会消失
#可以发现三个容器的匿名数据卷挂载的路径是一样的。

已验证，多个 MySQL 实现数据共享失败。原因后续继承该MySQL 配置和数据的方式依旧是父MySQL，会导致后续的MySQL 启动失败。数据卷容器 只能使用在 无状态服务。注意两个mysql虽然共用一个数据，但是只能同时在线一个MySQL容器，否则另外一个连接不上。

:::color1 结论：

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

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

数据卷是被设计用来持久化数据的，它的生命周期独立于容器，Docker 不会在容器被删除后自动删除数据卷。如果需要在删除容器的同时移除数据卷，可以在删除容器的时候使用 docker rm -v 这个参数。

:::

6 Dockerfile

6.1 Dockerfile 介绍

Dockerfile 是用来构建 Docker 镜像的文件！命令参数脚本！

构建步骤：

1. 编写一个 Dockerfile 文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（DockerHub、阿里云镜像仓库、本地镜像仓库）

查看官方 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"
CMD ["/bin/bash"]

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

6.2 Dockerfile 构建过程

基础知识：

1. 每个保留关键字（指令）都是必须是大写字母
2. 执行从上到下顺序执行

3. 表示注释

4. 每一个指令都会创建提交一个新的镜像层，并提交！

:::color1 Dockerfile 是面向开发的，以后要发布项目，做镜像，就需要编写 Dockerfile 文件，这个文件十分简单！

:::

Docker 镜像 —> SpringBoot 。镜像逐渐成为企业交付的标准，必须掌握。

步骤：开发，部署，上线运维 …… 缺一不可！

• Dockerfile：构建文件，定义了一切的步骤，源代码。
• DockerImage：是通过 Dockerfile 构建生成的镜像，最终发布和运行的产品。
• Docker Container：容器就是镜像运行起来提供服务。

6.3 Dockerfile 的指令

:::color1 FROM #基础镜镜像，一切从这里开始构建

MAINTAINER #镜像是谁写的,姓名+邮箱

RUN #镜像构建的时候需要运行的命令

ADD #步骤: tomcat镜像,这个tomcat压缩包!添加内容

WORKDIR #镜像的工作目录

VOLUME #挂载的目录

EXPOSE #保留端口配置

CMD #指定这个容器的时候要运行的要求，只有最后一个会生效，可被替代

ENTRYPOINT #指定这个容器的时候要运行的要求，ENTRYPOINT 后的指令会作为参数进行传入

ONBUILD #当构建一个被继承 Dockerfile 这个时候就会运行 ONBUILD 的指令，才会触发指令

COPY # 类似 ADD，将文件拷贝到镜像中

ENV #构建的时候设置环境变量

:::

:::warning

6.3.2 MAINTAINER

6.3.3 RUN

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

两种格式

• 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

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

类似于 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 小总结

6.4 实战测试

Docker Hub 中 99% 镜像都是从这个基础镜像过来的 FROM scratch ，然后配置需要的软件和配置来进行的构建

6.4.1 创建自己的CentOS镜像

$ mkdir -pv /root/docker/mycentos01 && cd /root/docker/mycentos01
#1.编写Dockerfile的文件
$ vim Dockerfile
#设置基础镜像
FROM centos:centos7.9.2009
#设置镜像作者
MAINTAINER zhongzhiwei <zhongzhiwei@kubesphere.com>
#配置环境变量
ENV MYPATH="/data"
#设置工作目录
WORKDIR $MYPATH
#安装 vim net-tools 软件
RUN yum makecache fast && \
    yum install -y vim net-tools
#清空yum缓存
RUN yum clean all
#提示暴露端口
EXPOSE 80
#docker build运行的提示
RUN echo MYPATH is $MYPATH
RUN echo "---> Success ......"
#挂载卷
VOLUME /data
#设置容器启动的命令
CMD /bin/bash
#2.通过这个文件构建镜像
#命令：docker build -f Dockerfile <文件路径> -t 镜像名:[TAG]
$ docker build -t kube-centos:2.0 -f Dockerfile .
#3.测试运行
$ docker run -it --rm kube-centos:2.0 /bin/bash
[root@3fe81eda9f21 data]# pwd
/data
[root@3fe81eda9f21 data]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.11  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:0b  txqueuelen 0  (Ethernet)
        RX packets 6  bytes 516 (516.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
[root@3fe81eda9f21 data]# vim --version | head -n 1
VIM - Vi IMproved 7.4 (2013 Aug 10, compiled Dec 15 2020 16:44:08)