Video Reference：尚硅谷2022版Docker实战教程（Docker教程天花板）

0 课程介绍

:::color1 一切在云端，万物皆容器是目前IT的主流环境。

:::

• 前提知识

- boot cloud
- Git Push Pull Redis Nginx Mysql ......
- Linux CentOS Ubuntu

• Docker 基础篇

- Docker 简介
- Docker 安装
- Docker 常用命令
- Docker 镜像(联合文件系统)
- 本地镜像发布到阿里云
- 本地镜像发布到私有库
- Docker 容器数据卷
- Docker 常规安装简介

• Docker 高级篇

- Docker 复杂安装详说
  - 安装 MySQL 主从复制
  - 安装 Redis 集群(大厂面试-分布式存储案例真题)
- Docker File 解析
- Docker 微服务实战
- Docker 网络
- Docker-compose 容器编排(一键上线，按部编排，一键发布，一键部署)
- Docker 轻量级可视化工具 Portainer
- Docker 容器监控之 CAdvisor + InfluxDB + Grafana
- 终章 & 总结

1 Docker 的简介

1.1 为什么会有 Docker 出现

• 学习新技术方法论

:::warning 1.是什么

2.能干嘛

3.去哪下(必登官网)

4.怎么玩

5.永远的Hello World跑起来一次

:::

• AB法则

:::color1 Before

• 问题：为什么会有Docker出现?
  假定你在开发一个尚硅谷的谷粒商场，你使用的是一台笔记本电脑而且你的开发环境具有特定的配置。其他开发人员身处的环境配置也各不相同。你正在开发的应用依赖于你当前的配置而且还要依赖于某些配置文件。此外，你的企业还拥有QA标准化的测试和生产环境，且具有自身的配置和一系列支持文件。你希望尽可能多在本地模拟这些环境而不产生重新创建服务器环境的开销。请问如何解决?

After

• 答案就是使用容器。Docker 之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案 —- <font style="color:#E8323C;">系统平滑移植，容器虚拟化技术</font>
• 环境配置相当麻烦，换一台机器，就要重来一次，费时费力。很多人想到，能不能从根本上解决问题，软件可以带环境安装?也就是说，安装的时候，把原始环境一模一样的复制过来。开发人员利用 Docker 可以消除协作编码时"在我的机器上可以正常工作"的问题。

:::

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

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

Docker 的出现<font style="color:#E8323C;">使得 Docker 得以打破过去 [ **程序即应用** ] 的观念。通过镜像(image)将作业系统核心除外，运作应用程序所需要的系统环境，由下而上打包，达到应用程序跨平台间无缝接轨运作。</font>

:::

1.2 Docker 理念

<font style="color:#E8323C;">Docker 是基于 GO 语言开发实现的云开源项目</font>

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

1.3 容器与虚拟机比较

1.3.1 容器发展简史

:::color1 最开始应用是存放在物理光盘上，然后发展放在卡带机上，然后存放在虚拟机，目前则是存放在Docker容器上

:::

Docker 容器可以存放静态的Web网站，用户的数据库，前端，消息中间件队列，动态数据源。

总结：Docker 是一种容器虚拟化技术，是应用层虚拟化技术

1.3.2 传统虚拟化技术

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

<font style="color:#E8323C;">Linux容器(Linux Containers)，缩写为 LXC</font>

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

Docker 容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比，<font style="color:#E8323C;">Docker 优势体现为启动速度快，占用体积小</font>。

1.3.4 对比

比较了 Docker 和传统虚拟化方式的不同之处：

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

1.4 开发 / 运维（DevOps）新一代开发工程师

:::color1 coder -> programmer -> software engineer -> DevOps engineer

:::

<font style="color:#E8323C;">开发 / 运维（DevOps）新一代开发工程师</font>

• 一次构建，随处运行

1. 更快速的应用交付和部署：

:::color1

:::

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

:::color1

:::

1. 更简单的系统运维

:::color1

:::

1. 更高效的计算资源

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

:::

• Docker 应用场景

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

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

哪些企业在使用？

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

1.5 Docker 官方站点

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

DockerHub 官网：https://hub.docker.com/

1.6 Docker 安装

Docker 并非是一个通用的容器工具，它依赖于已经存在并运行的 Linux 内核环境

Docker 实质上是已经运行 Linux 下制造了一个隔离的文件环境，因此它的执行的效率几乎等同于所部署的 Linux 主机。因此，Docker 必须部署在 Linux 内核的系统上。如果其他系统想部署 Docker 就必须安装一个虚拟的 Linux 环境。

在Windows 上部署 Docker 的方法都是先安装一个虚拟机，并在安装 Linux 系统的虚拟机中运行 Docker。（WSL可以理解为一个Windows专用的Linux虚拟机）。Windows 目前也可以使用 Docker，底层是基于WSL技术实现

前提条件

目前，CentOS 仅发行版本中的内核支持 Docker。Docker 运行在 CentOS 7( 64-bit )上，要求系统为 64 位，Linux 系统内核版本为 3.8 以上，这里选择使用 CentOS 7.x 版本。

查看系统的内核

# uname 命令用于打印当前系统相关信息(内核版本号、硬件架构、主机名称和操作系统类型等)
[root@master01 ~]#cat /etc/redhat-release
CentOS Linux release 7.9.2009 (Core)
[root@master01 ~]#uname -r
3.10.0-1160.el7.x86_64
[root@master01 ~]#uname -a
Linux master01 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

1.7 Docker 的基本组成

Docker 基本组成三大特征（Docker 三件套）：容器（Container），镜像（Image），仓库（Repository）

<font style="color:#E8323C;">镜像→模板，容器→运行起来的模板，仓库→存放模板的地方</font>

• 镜像( Image )：Docker 镜像(Image) 就是一个只读的模板。镜像可以用来创建 Docker 容器，<font style="color:#E8323C;">一个镜像可以创建多个容器</font>。它相当于是一个root 文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的root文件系统。相当于容器的”源代码”，docker 镜像文件类似于 Java 的类模板，而 docker 容器实例类似于 java 中 new 出来的实例对象。

• 容器( Container )

（1）从面向对象角度

Docker 利用容器（Container）独立运行的一个或者一组应用，应用程序或者服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是镜像创建的运行实例。就像 Java 中的类和实例对象一样。镜像是静态的定义，容器时镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的，保证安全的平台

（2）从镜像容器角度

可以把容器看做是一个简易版的Linux环境(最小最核心赖以生存的Linux内核文件，不需要的不加载)（包括root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。

• 仓库( Repository )

是集中存放镜像文件的场所

类似于：

Maven 仓库，存放各种 jar 包的地方；GitHub仓库，存放各种 Git 项目的地方；Docker 公司提供的官方 Registry 被称为Docker Hub，存放各种镜像模板的地方。

仓库分开公开仓库（Public）和私有仓库（Private）两种形式。

存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云，网易云等。

:::color1 总结Conclusion：

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

Docker 本身就是一个容器运行载体或者称为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是 image 镜像文件。只有通过这个镜像文件才能生成 Docker 容器实例（类似 Java 中 new 出来一个对象）。

image 文件可以看作是容器的模板。Docker 根据image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

*镜像文件：image 文件生成的容器实例，本身也是一个文件，称为镜像文件

*容器实例：一个容器运行一种服务，当我们需要的时候，就可以通过 Docker 客户端创建一个对应的运行实例，也就是容器

*仓库：就是放一堆镜像的地方，可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

:::

1.8 Docker 平台架构图解

:::color1

1. Docker 引擎会查看本地是否拥有Images镜像，若本地有镜像，则可以直接运行成Containers容器实例，根据镜像的不同，运行出的容器实例也各不相同
2. 若本地没有镜像，则会通过网络向公有Registry仓库或者私有仓库拉取镜像后，再来运行成容器。

:::

:::color1 整体架构及底层通信原理简述：

Docker 是一个 C/S（Client/Server） 结构的系统，后端是一个松耦合架构，众多模块各司其职。

Docker 运行的基本流程为：

1. 用户是使用 Docker Client（Docker CLI 命令行窗口） 与 Docker Daemon 建立通信，并发送请求给后者。
2. Docker Daemon 作为 Docker 架构中的主体部分，首先提供 Docker Server 的功能使其可以接受 Docker Client 的请求。
3. Docker Engine 执行 Docker 内部的一系列工作，每一项工作都是以一个Job的形式的存在。
4. Job 的运行过程中，当需要容器镜像时，则从 Docker Registry 中下载镜像，并通过镜像管理驱动 Graph Driver 将下载镜像以 Graph 的形式存储。
5. 当需要为 Docker 创建网络环境时，通过网络管理驱动 Network Driver 创建并配置 Docker 容器网络环境。
6. 当需要限制 Docker 容器运行资源或者执行用户指令等操作时，则通过 Exec Driver 来完成。
7. Libcontainer 是一项独立的容器管理包，Network Driver 以及 Exec Driver 都是通过 Libcontainer 来实现具体对容器进行操作。
8. rootfs = Linux 根文件系统，各发行版建立在 Linux内核文件系统 之上的底层系统

:::

2 Docker 安装以及配置

2.1 CentOS 7 安装 Docker

官方站点：Install Docker Engine on CentOS | Docker Documentation 要安装 Docker 引擎，您需要 CentOS 7、CentOS 8 （stream） 或 CentOS 9 （stream） 的維護版本。不支持或测试存档版本。 必须启用存储库。默认情况下，此存储库处于启用状态，但如果已禁用它，则需要重新启用它。centos-extras 建议使用存储驱动程序。overlay2

安装步骤：

• 确定你是 CentOS 7及以上版本

$ cat /etc/redhat-release

• 卸载旧版本

# https://docs.docker.com/engine/install/centos/
$  sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

• yum 安装 gcc 相关

# CentOS 7能够上外网
# gcc 是C语言的编译器
$ yum install -y gcc gcc-c++

• 安装需要的软件包

# https://docs.docker.com/engine/install/centos/
$ sudo yum install -y yum-utils
# 执行过官网，再执行一般阿里云的就好了，会覆盖掉官网地址下载的文件
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo 
# 会报错TCP连接重置,以及连接超时
# step 1: 安装必要的一些系统工具
$ sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# 注意：
# 官方软件源默认启用了最新的软件，您可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，您可以通过以下方式开启。同理可以开启各种测试版本等。
# vim /etc/yum.repos.d/docker-ce.repo
# 将[docker-ce-test]下方的enabled=0修改为enabled=1
#
# 安装指定版本的Docker-CE:
# Step 1: 查找Docker-CE的版本:
# yum list docker-ce.x86_64 --showduplicates | sort -r
#   Loading mirror speeds from cached hostfile
#   Loaded plugins: branch, fastestmirror, langpacks
#   docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable
#   docker-ce.x86_64            17.03.1.ce-1.el7.centos            @docker-ce-stable
#   docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable
#   Available Packages
# Step2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.0.ce.1-1.el7.centos)
# sudo yum -y install docker-ce-[VERSION]

• 设置 stable 镜像仓库

# Step 2: 添加软件源信息
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# Step 3: 修改镜像仓库地址
sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

• 更新 yum 软件包索引

sudo yum makecache fast

• 安装 Docker CE

# Step 4: 更新并安装Docker-CE
sudo yum install -y docker-ce docker-ce-cli containerd.io

• 启动 Docker

# Step 4: 开启Docker服务
# sudo systemctl start docker
# sudo systemctl enable docker
systemctl enable --now docker

• 测试

$ ps -ef | grep docker
root      98051      1  0 22:24 ?        00:00:00 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
root      98303  56813  0 22:26 pts/0    00:00:00 grep --color=auto docker
# 查看 Docker 版本号
$ docker version
# 查看 Docker 详细信息显示
$ docker info | docker system info
# 测试 Docker Container --> helloworld
$ docker run hello-world

• 卸载 Docker

# 停止 Docker 服务
$ systemctl stop docker
# 卸载 Docker 软件
$ sudo yum remove -y docker-ce docker-ce-cli containerd.io
# 删除 Docker 相关配置文件以及 Docker 各种库文件
$ sudo rm -rf /var/lib/docker
$ sudo rm -rf /var/lib/containerd

2.2 阿里云镜像加速器配置

:::color1 开放云原生应用：https://promotion.aliyun.com/ntms/act/kubernetes.html

使用加速器可以提升获取Docker官方镜像的速度

登录阿里云官网使用账号登录后搜索容器镜像服务

:::

这里额外添加了docker的生产环境核心配置cgroup

# 针对Docker客户端版本大于 1.10.0 的用户
# 您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器
sudo mkdir -pv /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  //定义Docker Hub镜像仓库加速器
  "registry-mirrors": ["https://po13h3y1.mirror.aliyuncs.com"],
  //运行时执行选项
  "exec-opts": ["native.cgroupdriver=systemd"],
  //容器日志的默认驱动程序（默认为“ json-file”）
  "log-driver": "json-file",
  //容器默认日志驱动程序选项
  "log-opts": {
    "max-size": "100m"
  },
  //要使用的存储驱动程序
  "storage-driver": "overlay2"
}
EOF
# 重启 Docker 服务
sudo systemctl daemon-reload
sudo systemctl restart docker

2.3 hello-world 介绍

# 启动 Docker 后台容器(测试运行 hello-world)
$ docker run hello-world
# 由于本地没有 hello-world 镜像，所以会下载一个 hello-world 的镜像，并在容器内运行
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/
For more examples and ideas, visit:
 https://docs.docker.com/get-started/
# 输出这段提示以后， hello-world 就会停止运行，容器自动终止

• Docker run 流程

2.4 Docker 底层原理

• 为什么 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由于直接利用宿主机的操作系统，则省略了返回过程，因此创建一个容器只需要几秒钟。

💎3 Docker 容器命令

3.1 帮助启动类命令

# 启动 Docker
$ systemctl start docker
# 停止 Docker
$ systemctl stop docker
# 重启 Docker
$ systemctl restart docker
# 查看 Docker 状态
$ systemctl status docker
# 开机启动
$ systemctl enable docker
# 查看 Docker 摘要信息
$ docker info | docker system info
# 查看 Docker 总体帮助文档
$ docker --help
Usage:  docker [OPTIONS] COMMAND
# 查看 Docker 命令帮助文档
$ docker [具体命令] --help 
# 详细的帮助文档：man docker-具体命令，具体命令中空格用短划线替代

3.2 镜像命令

3.2.1 docker images

列出本地主机上的镜像

范例：OPTIONS 说明

$ docker images | docker image ls 
REPOSITORY                               TAG             IMAGE ID       CREATED        SIZE
# 各个选项说明：
- REPOSITORY:表示镜像的仓库源
- TAG:镜像的标签版本号，默认不指定版本号则使用 latest 最新版本
- IMAGE ID:镜像的ID
- CREATED:镜像创建时间
- SIZE:镜像大小

同一个仓库源可以有多个 TAG 版本，代表这个仓库源的不同版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。

如果你不指定一个镜像的版本标签，例如你只使用 ubuntu ，docker将默认使用 ubuntu:latest 镜像（最新镜像）

# docker images OPTIONS 说明：
-a :列出本地所有的镜像（含历史映像层）
-q :只显示镜像ID
--no-trunc :不截断打印

3.2.2 docker search

docker search <某个 xxx 镜像名称>

• 网站：https://hub.docker.com
• 命令：

# docker search [OPTIONS] 镜像名称
# OPTIONS 说明：
# --limit：只列出N个镜像，默认是25个
# docker search --limit 5 redis
# 过滤标志(or)格式是一对。如果有多个过滤器，则传递多个标志：-f="筛选字段=筛选值"
# -f--filterkey=value--filter is-automated=true --filter stars=3
# docker search --filter stars=3 busybox
$ docker search redis
NAME                             DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
redis                            Redis is an open source key-value store that…   10419     [OK]

3.2.3 docker pull

docker pull <某个 xxx 镜像名称>

• 下载镜像
• docker pull 镜像名称[:TAG]
• docker pull 镜像名称

~ docker pull hello-world
~ docker pull ubuntu
~ docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
ubuntu        latest    ba6acccedd29   9 months ago    72.8MB
hello-world   latest    feb5d9fea6a5   10 months ago   13.3kB
# 指定镜像:TAG标签
~ docker pull redis:6.0.8
~ docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
ubuntu        latest    ba6acccedd29   9 months ago    72.8MB
hello-world   latest    feb5d9fea6a5   10 months ago   13.3kB
redis         6.0.8     16ecd2772934   21 months ago   104MB

3.2.4 docker system df

~ docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          3         0         177MB     177MB (100%)
Containers      0         0         0B        0B
Local Volumes   0         0         0B        0B
Build Cache     0         0         0B        0B
# -v：显示空间使用的详细信息
~ docker system df -v

3.2.5 docker rmi

docker rmi <某个 xxx 镜像名称ID>

• 删除 Docker 镜像文件

# 删除单个镜像
$ docker rmi hello-world
# -f --force:强制删除镜像文件
$ docker rmi -f hello-world
$ docker rmi --force hello-world
# 删除多个镜像
$ docker rmi -f 镜像名1:TAG 镜像名2:TAG
# 删除全部
$ docker rmi -f $(docker images -aq)

3.2.6 面试题：谈谈 docker 虚悬镜像是什么？

虚悬镜像是什么？

• 仓库名，标签都是的镜像，俗称虚悬镜像 dangling image
• 被淘汰的版本，或者出错过的镜像
• 虚悬镜像不算Docker bug，就像平时压缩文件、下载文件时候也会先产生一个临时文件一样。

虚悬镜像长什么样？

$ docker images -a 
REPOSITORY                       TAG             IMAGE ID       CREATED        SIZE
<none>                          <none>          50d582768dbb   3 weeks ago    296MB
# 清除虚悬镜像
$ docker image prune -f

Dockerfile 会进行详解

:::color1 思考？

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

:::

3.3 容器命令

$ docker pull centos ; docker pull ubuntu

3.3.1 新建 & 创建容器

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

:::

3.3.1.1 OPTIONS 说明

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

• —name=“容器新名称” ：为容器指定一个名称；
• -d：后台运行容器并返回容器ID，也即启动守护模式容器（后台运行）；
• -i：以交互模式运行容器，通常与 -t 同时使用；
• -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；（也即启动交互式容器<前台有伪终端，等待交互>）
• -P：随机端口映射，大写P
• -p：指定端口映射，小写p；-p 宿主机端口[Docker Host Port]:容器端口[Container Port]

• —dns 8.8.8.8： 指定容器使用的DNS服务器，默认和宿主一致；
• —dns-search example.com： 指定容器DNS搜索域名，默认和宿主一致；
• -h “mars”： 指定容器的hostname；
• -e username=”ritchie”： 设置环境变量；
• —env-file=[]： 从指定文件读入环境变量；
• —cpuset=”0-2” or —cpuset=”0,1,2”： 绑定容器到指定CPU运行；
• -m ：设置容器使用内存最大值；
• —net=”bridge”： 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；
• —link=[]： 添加链接到另一个容器；
• —expose=[]： 开放一个端口或一组端口；
• —volume , -v： 绑定一个卷

3.3.1.2 启动交互式容器（前台命令行）

$ docker images ubuntu
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
ubuntu       latest    ba6acccedd29   2 months ago   72.8MB
$ docker run --help 
Usage:  docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
$ docker run -it ubuntu /bin/bash
root@31de50e0275a:/# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 08:50 pts/0    00:00:00 bash
root         9     1  0 08:50 pts/0    00:00:00 ps -ef
root@31de50e0275a:/# cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.3 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.3 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
# 使用镜像 centos:latest 以`交互模式`启动一个容器，在容器内执行 /bin/bash 命令
$ docker run -it centos:latest /bin/bash
# 参数说明
# -i:interactive 交互式操作
# -t:tty 伪终端
# centos:centos 镜像
# /bin/bash:放在镜像名后的是命令，这里希望有一个交互式Shell，因此用的是 /bin/bash。
# 要退出终端，直接输入 exit
$ docker run -it --name myu1 -d ubuntu /bin/bash

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

:::color1 docker ps [OPTIONS]

:::

OPTIONS 说明（常用）：

• -a：列出当前所有正在运行的容器 +历史上运行过的。（启动和未启动的容器）
• -l：显示最近创建的容器
• -n：显示最近 n 个创建的容器
• -q：静默模式，只显示容器编号

$ docker rm -f $(docker ps -aq)
$ docker ps -aq | xargs docker rm -f

3.3.9 重要

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

docker pull redis:6.0.8

:::

3.3.9.1 启动守护式容器（后台服务器）

在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以通过 -d 指定容器的后台运行模式

• docker run -d 容器名称

# 使用镜像 centos:latest 以后台模式启动一个容器
docker run -d centos
# 问题:然后docker ps -a进行查看，会发现容器已经退出
很重要的说明的一点："Docker 容器后台运行，就必须有一个前台进程"
容器运行的命令如果不是那些"一直挂起的命令"(比如运行 top，tail)，就是会自动退出的。
# 这个是Docker的机制问题，比如你的web容器，我们以nginx为例，
# 正常情况下，我们配置启动服务只需要启动相应的service即可。
# 例如service nginx start ，但是，这样做，nginx为后台进程模式运行，就导致 docker 前台没有运行的应用，
# 这样的容器后台启动后，会立即自杀因为它觉得它没事可做。
# 所以，最佳的解决方案是，将你要运行的程序以前台进程的形式运行，
# 常见的就是命令行模式，表示我还有交互操作，别中断。

• 范例：redis 前后台启动演示 case

# Redis 前台启动
$ docker run -it --name redis-node1 redis:6.0.8
# 若使用前台运行被中止，就会出现各种数据库穿透，雪崩的问题就会出现
# Redis 后台启动
$ docker run -d -it --name redis-node2 redis:6.0.8

3.3.9.2 查看容器日志

• docker logs 容器ID或者容器名称

OPTIONS 说明（常用）：

• -f：动态追踪日志

范例：查看容器日志

docker logs -f redis-node1
# 编码开发微服务
# 上线部署容器化
# 时时刻刻要监控
# DevOps

3.3.9.3 查看容器内运行的进程

• docker top 容器ID或者容器名称

3.3.9.4 查看容器内部细节

• docker inspect 容器ID或者容器名称

docker inspect redis-node1

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

:::color1 docker exec -it /bin/bash

:::

• docker exec -it 容器ID或者容器名称 /bin/bash (bashShell)

$ docker exec -it u1 /bin/bash
root@47d13d6997c8:/# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 09:13 pts/0    00:00:00 bash
root        37     0  0 12:44 pts/1    00:00:00 /bin/bash
root        46    37  0 12:44 pts/1    00:00:00 ps -ef

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

$ docker attach u1
root@47d13d6997c8:/# cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.3 LTS (Focal Fossa)"
ID=ubuntu

• 案例演示，用 centos 或者 ubuntu 都可以
• 上述两个的区别

- attach 直接进入容器启动命令的终端，不会启动新的进程，用 exit 退出，会导致容器的停止
- exec 是在容器中打开新的终端，并且可以启动新的进程，用 exit 退出，不会导致容器的停止
# Ctrl + p + q 后台运行容器，但是当你在使用 run 是重新创建一个新的容器，而 exec 是进入之前创建的容器

• 推荐大家使用 docker exec 命令，因为退出容器终端，不会导致容器的停止
• 用之前的 Redis 容器实例进入试试

# 进入 Redis 服务
$ docker exec -it 容器ID/容器名称 /bin/bash
$ docker exec -it 容器ID/容器名称 redis-cli
# 一般用 -d 后台启动的程序,再用 exec 进入对应容器实例

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

容器 —> 主机（注意：容器内的路径不能为软连接路径）

• docker cp 容器ID:容器内路径 目的主机路径

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

~ docker exec -it u1 bash
root@8c82e6b9f2d0:/# cd /tmp
root@8c82e6b9f2d0:/tmp# echo "Hello,world" > docker.txt
root@8c82e6b9f2d0:/tmp# exit
~ docker cp u1:/tmp/docker.txt /tmp
~ cat /tmp/docker.txt
Hello,world
~ echo "Hello,Docker" > host.txt
~ docker cp host.txt u1:/tmp
~ docker exec -it u1 bash
root@8c82e6b9f2d0:/# cat /tmp/host.txt
Hello,Docker

3.3.9.7 导入和导出容器

• export：导出容器的那日流作为一个 tar 归档文件 [对应 export 命令]
• import：从 tar 包中的内容创建一个新的文件系统再导入为镜像 [对应 import 命令]

:::

范例：演示 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

1. 小总结

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

:::color1 commit：将运行的容器直接提交为镜像。

export：将容器（运行或不运行）打包成tar包，再由import将tar包提交为镜像。

save：将镜像打包成tar包，再有load将tar包提交为镜像。

:::

作业：案例 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)

3.4.1 本地镜像发布到阿里云

3.4.1.1 本地镜像发布到阿里云流程

3.4.1.2 镜像的生成方法

• 基于当前容器创建一个新的镜像，新功能增强

$ docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]

• 使用 Dockerfile 文件

3.4.1.3 将本地镜像推送到阿里云

• 本地镜像素材原型

$ docker images
REPOSITORY               TAG             IMAGE ID       CREATED        SIZE
myubuntu                v1.0            a8375a7783cc   9 hours ago    174MB

• 阿里云开发者平台

https://promotion.aliyun.com/ntms/act/kubernetes.html

• 创建仓库镜像

1. 选择控制台，进入容器镜像服务
2. 选择个人实例
3. 命名空间
4. 仓库名称
5. 进入管理界面获取脚本

• 将镜像推送到阿里云

将继续推送到阿里云 registry

• 管理界面脚本

• 脚本实例

# 1. 登录阿里云Docker Registry
$ docker login --username=dragon志伟 registry.cn-shenzhen.aliyuncs.com
用于登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。
您可以在访问凭证页面修改凭证密码
# 3. 将镜像推送到Registry
$ docker login --username=dragon志伟 registry.cn-shenzhen.aliyuncs.com
$ docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dragonzw_k8s_images/ubuntu:[镜像版本号]
$ docker push registry.cn-shenzhen.aliyuncs.com/dragonzw_k8s_images/ubuntu:[镜像版本号]
# docker tag myubuntu：v1.0 registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/myubuntu:v1.0
# docker push registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/myubuntu:v1.0
请根据实际镜像信息替换示例中的[ImageId]和[镜像版本号]参数。

3.4.1.4 将阿里云上的镜像下载到本地

# 3. 从Registry中拉取镜像
$ docker pull registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/ubuntu:[镜像版本号]
~ docker pull registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/ubuntu:1.0
~ docker history registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/ubuntu:1.0
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
e3587595bab1   44 minutes ago   /bin/bash                                       105MB     添加VIM软件
<missing>      9 months ago     /bin/sh -c #(nop)  CMD ["bash"]                 0B
<missing>      9 months ago     /bin/sh -c #(nop) ADD file:5d68d27cc15a80653…   72.8MB
~ docker run -itd --name au1 registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/ubuntu:1.0 /bin/bash
~ docker exec -it au1 /bin/bash
root@10dc9cc87e81:/# vim --version
VIM - Vi IMproved 8.1 (2018 May 18, compiled Feb 01 2022 09:16:32)
# docker pull registry.cn-shenzhen.aliyuncs.com/dragonzw_personal_images/myubuntu:1.0

3.4.2 Docker 私有镜像库

3.4.2.1 本地镜像发布到私有库流程

3.4.2.2 私有镜像库是什么

• Docker Registry

1.官方 Docker Hub地址：https://hub.docker.com/，中国大陆访问太慢了并且准备被阿里云取代的趋势，不太主流。

2.DockerHub、阿里云这样的公共镜像仓库可能不太方便，涉及机密的公司不可能提供镜像给公网，所以需要创建一个本地私人仓库供团队使用，基于公司内部项目构建镜像

Docker Registry 是官方提供的工具，可以用于构建私有镜像仓库。

3.4.2.3 将本地镜像推送到私有库

• 下载镜像 Docker Registry

$ docker pull registry
$ docker images registry
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
registry     latest    b8604a3fe854   8 months ago   26.2MB

• 运行私有库 Registry，相当于本地有个私有Docker Hub

$ mkdir -pv /app/registry
$ docker run -d -p 5000:5000 \
  -v /app/registry:/tmp/registry \
  --privileged=true \
  --name myregistry \
  --restart=always registry
$ docker ps -l
# 默认情况下，仓库被创建在容器的/var/lib/registry目录下，建议自行用容器卷映射，方便于宿主机联调

• 案例演示创建一个新镜像，ubuntu安装ifconfig命令

# 从Hub上下载ubuntu镜像到本地并成功运行
$ docker pull ubuntu
$ docker run -it -d --name u1 ubuntu /bin/bash
# 原始的ubuntu镜像是不带着ifconfig命令
$ docker exec -it u1 /bin/bash
root@061f7b3bc044:/# apt update -y
root@061f7b3bc044:/# apt install -y net-tools
# 外网联通的情况下，安装ifconfig命令并测试通过
root@061f7b3bc044:/# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.3  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:03  txqueuelen 0  (Ethernet)
        RX packets 10486  bytes 21412251 (21.4 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 10507  bytes 988690 (988.6 KB)
        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@061f7b3bc044:/# exit
# 安装完成后，commit的新镜像
# 公式：docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
# 命令：在容器外执行
$ docker commit -m "Add ifconfig tools" -a "zhongzhiwei <935523993@qq.com>" u1 zzwubuntu:v1.0
# 启动我们的新镜像并和原来的对比
$ docker history zzwubuntu:v1.0
$ docker history ubuntu:latest

• curl验证私服库上有什么镜像

# 模拟发送一个Get请求
$ curl -XGET http://139.198.105.99:5000/v2/_catalog
{"repositories":[]}
# 可以看到，目前私服库没有任何镜像上传过......

• 将新镜像修改符合私服规范的Tag

# 按照公式：docker tag 镜像:tag Host:Port/Registory:Tag
使用命令docker tag将新制作的镜像修改为139.198.105.99:5000/zzwubuntu:v1.0
$ docker tag zzwubuntu:v1.0 139.198.105.99:5000/zzwubuntu:v1.0

• 修改配置文件使之支持http

# 修改配置文件使之支持http
$ vim /etc/docker/daemon.json
{
  "registry-mirrors": ["https://po13h3y1.mirror.aliyuncs.com","https://registry.docker-cn.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  #"comment" : "添加以下内容",
  "insecure-registries": ["139.198.105.99:5000"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
# registry-mirrors 配置的是国内阿里云提供的镜像加速地址，不用加速的化访问官网会很慢。
### 2个配置中间有个逗号','，这个配置是 json 格式的。
# 上述理由：由于Docker默认不允许 http 方式推送镜像，通过配置选项来取消这个限制
# ---> 修改完后如果不生效，建议重启 Docker
$ systemctl daemon-reload ; systemctl restart docker

• push推送到私服库

$ docker push 139.198.105.99:5000/zzwubuntu:v1.0

• curl验证私服库上有什么镜像

$ curl -XGET http://139.198.105.99:5000/v2/_catalog
{"repositories":["zzwubuntu"]}

范例：

~ curl -XGET http://10.0.0.101:5000/v2/_catalog
{"repositories":["kubesphere-ubuntu"]}
~ curl -XGET http://10.0.0.101:5000/v2/kubesphere-ubuntu/tags/list
{"name":"kubesphere-ubuntu","tags":["1.1"]}

• pull到本地并运行

$ docker pull 139.198.105.99:5000/zzwubuntu:v1.0

3.5 Docker 容器数据卷

坑：容器卷记得加入：

--privileged=true

为什么？

• Docker 挂载主机目录访问如果出现”cannot open directory .: Permission denid“

解决方法：

• 如果是CentOS 7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为，在SELinux里面挂载目录被禁止掉了，如果要开启，我们一般使用 <font style="color:#E8323C;">--privileged=true</font> 命令，扩大容器的权限解决挂载目录没有权限的问题，也即使用该参数，Container 内的root拥有真正的root权限，否则，Container 内的 root 只是外部的一个普通用户权限。

3.5.1 Docker 容器数据卷是什么

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

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

:::

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

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

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

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

3.5.2 Docker 容器数据卷能干嘛

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

3.5.3 数据卷案例

3.5.3.1 宿主机 VS 容器之间映射添加容器卷

范例：直接使用命令添加

# 公式：docker run -it -v /宿主机目录:/容器内目录 ubuntu /bin/bash
# docker run -it -v --name c1 \
# --privileged=true -v /tmp/myHostData:/tmp/myDockerData ubuntu /bin/bash
$ docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名

# 公式：docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
# 如果宿主机以及Docker容器中挂载路径不存在，Docker会创建挂载路径
$ mkdir -pv /tmp/host_data
$ docker run -it -d \
  --privileged=true \
  -v /tmp/host_data:/tmp/docker_data \
  --name u1 ubuntu /bin/bash
# 查看容器和宿主机Mount
$ docker inspect u1
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/tmp/host_data",
                "Destination": "/tmp/docker_data",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],
# 或者使用
$ docker inspect -f="{{json .Mounts}}" 容器ID/容器名

# 1.Docker修改，主机同步获得
# 2.主机修改，Docker同步获得
# 3.Docker容器stop，主机修改，Docker容器重启看数据是否同步(`会同步`)
# 容器操作
$ docker exec -it u1 bash
root@4521a9edcc68:/# cd /tmp/docker_data/
root@4521a9edcc68:/tmp/docker_data# touch dockerin.txt
root@4521a9edcc68:/tmp/docker_data# exit
# 宿主操作
$ cd /tmp/host_data
/tmp/host_data$ ls
dockerin.txt
/tmp/host_data$ touch hostin.txt
# 容器操作
$ docker exec -it u1 bash
root@4521a9edcc68:/# cd /tmp/docker_data/
root@4521a9edcc68:/# ls
dockerin.txt  hostin.txt
root@4521a9edcc68:/# echo "hello docker" > a.txt
root@4521a9edcc68:/# exit
# 宿主操作
$ cat /tmp/host_data/a.txt
hello docker
$ echo "hello host update" >> /tmp/host_data/a.txt
# 容器操作
$ docker exec -it u1 bash
root@4521a9edcc68:# cat /tmp/docker_data/a.txt
hello docker
hello host update
# 正常状态下是共享，并且容器内主动删除的话宿主机内数据也会被删除，
# 不过容器被删除的话，宿主机文件还能保存下来，这时候就是起备份作用了

3.5.3.2 读写规则映射添加说明（rw&ro）

- 读写(默认)
$ docker run -it --privileged=true -v /宿主机绝对路径目录:/容器绝对路径目录:rw 镜像名
# 默认同上案例，默认就是rw

- 只读
# 容器实例内部被限制，只能读取不能写
# 公式：docker run -it --privileged=true -v /宿主机绝对路径目录:/容器绝对路径目录:ro 镜像名
$ docker run -it -d \
--privileged=true \
-v /tmp/hostdata:/tmp/dockerdata:ro \
--name u2 ubuntu /bin/bash
# /容器目录:ro --> 就能完成功能，此时容器自己就只能读取不能写
# ro = readonly
# 此时如果宿主机写入内存，可以同步给容器内，容器可以读取到
$ docker exec -it u2 /bin/bash
root@9357f6d17f4e:~# touch /tmp/dockerdata/dockerin.txt
touch: cannot touch '/tmp/dockerdata/dockerin.txt': Read-only file system
root@9357f6d17f4e:~# exit
$ echo "host data" > /tmp/hostdata/hostin.txt
$ docker exec -it u2 bash
root@9357f6d17f4e:/# cat /tmp/dockerdata/hostin.txt
host data

3.5.3.3 卷的继承和共享

# 容器1完成和宿主机的映射
# 公式：docker run -it --privileged=true -v /宿主机绝对路径目录:/容器绝对路径目录 --name <容器名> 镜像名
$ docker run -it -d --name u1 \
  --privileged=true \
  -v /tmp/host_data:/tmp/docker_data \
  ubuntu /bin/bash
$ docker exec -it u1 /bin/bash
root@58b9572340e8:/# touch /tmp/docker_data/dockerin.txt
root@58b9572340e8:/# exit
$ touch /tmp/host_data/hostin.txt
$ ls /tmp/host_data
dockerin.txt  hostin.txt
# 容器2继承容器1的卷规则
# 公式：docker run -it --privileged=true --volumes-from 父类 --name <容器名> 镜像名
$ docker run -it -d \
--privileged=true \
--volumes-from u1 --name u2 ubuntu /bin/bash
$ docker exec -it u2 /bin/bash
root@5cc07927d8bd:/# ls /tmp/docker_data/
dockerin.txt  hostin.txt
root@5cc07927d8bd:/# touch /tmp/docker_data/u2data.txt
root@5cc07927d8bd:/# exit
# 总结:--volumes-from 父类(容器1卷挂载映射关系) 只是借用父类的映射关系。
# 当父类(容器1)stop后，不会影响容器2的挂载关系，可以正常的读写。
# 当父类(容器1)start后，会实时同步文件内容。

3.6 Docker 常规安装简介

总体步骤：

1. 搜索镜像
2. 拉取镜像
3. 查看镜像
4. 启动镜像 → 服务端口映射
5. 停止镜像
6. 移除镜像

3.6.1 安装 Tomcat

• Docker Hub上面查找 Tomcat 镜像

$ docker search tomcat
# https://hub.docker.com/_/tomcat

• 从 Docker Hub上拉取Tomcat镜像到本地

$ docker pull tomcat

• Docker Images 查看是否有拉取到的Tomcat

$ docker images tomcat
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
tomcat       latest    fb5657adc892   3 weeks ago   680MB

• 使用 Tomcat 镜像创建容器实例（也叫运行镜像）

# -p 小写，主机端口:docker容器端口
# -P 大写，随机分配端口  --> $ docker run -it -P --name mytomcat tomcat
# -i 交互模式  -t 终端  -d 后台运行  --name 容器名称  --restart=always Docker服务重启自启动
$ docker run -it -d --restart=always --name mytomcat --privileged=true -p 8080:8080 tomcat
# 如果是云服务器需要开启安全组
$ docker ps
CONTAINER ID   IMAGE            COMMAND                  CREATED          STATUS          PORTS                                       NAMES
cfb99a1dd16b   tomcat           "catalina.sh run"        30 seconds ago   Up 29 seconds   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   mytomcat

• 访问 Tomcat 网站

# 问题：访问Tomcat网站出现404报错
# 解决：
# 1.可能没有映射端口或者没有关闭防火墙
$ systemctl stop firewalld.service && systemctl disable firewalld.service
# 2.把webapps.dist 目录换成webapps 
# 先成功启动 Tomcat
$ docker ps
# 查看 webapps 文件夹是否为空
$ docker exec -it mytomcat /bin/bash
root@cfb99a1dd16b:/usr/local/tomcat# ls -l webapps (没有文件)
root@cfb99a1dd16b:/usr/local/tomcat# rm -rf webapps
root@cfb99a1dd16b:/usr/local/tomcat# mv webapps.dist webapps (再次访问即可)

• 免修改版说明

# 温馨提醒：tomcat8没有 ARM 架构的镜像
# $ docker pull billygoo/tomcat8-jdk8
$ docker pull tomcat:8.0.53
# $ docker run -d -p 8088:8080 --name mytomcat8 --privileged=true billygoo/tomcat8-jdk8
$ docker run -d -p 8090:8080 --name tomcat8 --privileged=true tomcat:8.0.53

3.6.2 安装 MySQL

• Docker Hub上面查找MySQL镜像

$ docker search mysql

• 从Docker Hub上（阿里云加速器）拉取MySQL镜像到本地标签为 5.7

$ docker pull mysql:5.7.36

• 使用 mysql:4.7 镜像创建容器（也叫运行镜像）

1.命令出处，哪里来的？

# https://hub.docker.com/_/mysql
$ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 1.使用 MySQL 镜像
$ ps -ef | grep mysql
# 若宿主机本身安装MySQL并启动了MySQL服务，占用了3306端口，则需要关闭MySQL服务，以便后续操作
$ docker run -it -p 3306:3306 --name my-mysql-node01 \
-e MYSQL_ROOT_PASSWORD=Admin@h3c -d mysql:5.7.36
# MYSQL_DATABASE 指定创建的初始化数据库
$ docker run -it -p 3307:3306 --name my-mysql-node02 \
-e MYSQL_ROOT_PASSWORD=Admin@h3c \
-e MYSQL_DATABASE=kubesphere -d mysql:5.7.36
$ docker ps 
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                                            NAMES
63187274cfaa   mysql:5.7.36   "docker-entrypoint.s…"   4 minutes ago   Up 4 minutes   3306/tcp, 33060/tcp, 0.0.0.0:3306->3006/tcp, :::3306->3006/tcp   my-mysql
# 2.建库建表插入数据
$ docker exec -it my-mysql-node01 /bin/bash
root@63187274cfaa:/# mysql -uroot -pAdmin@h3c
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)
mysql> create database db01;
Query OK, 1 row affected (0.00 sec)
mysql> use db01;
Database changed
mysql> create table t1(id INT,name VARCHAR(20));
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t1(id , name) values (1 , 'zhangsan');
Query OK, 1 row affected (0.01 sec)
mysql> select * from t1;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
+------+----------+
1 row in set (0.00 sec)
# 查看 my-mysql-node02 是否创建 kubesphere
docker exec -it my-mysql-node02 /bin/bash
root@1326a1390362:/# mysql -uroot -pAdmin@h3c
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| kubesphere         |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)
# 3.外部 Windows 也连接运行在Docker上的MySQL容器实例服务
# 使用 SQLyog 等数据库连接软件进行连接 远端数据库
# 远端执行 SQL 结构
mysql> SELECT * FROM t1;
mysql> INSERT INTO t1(id , NAME)
VALUES (2 , "lisi");
# 4.问题
# 4.1 插入中文数据试试
mysql> INSERT INTO t1(id , NAME)
VALUES (3 , '王五');
###
错误代码： 1366
Incorrect string value: '\xE7\x8E\x8B\xE4\xBA\x94' for column 'name' at row 1
###
# 为什么报错?
# Docker上默认字符集编码隐患
# docker 里面的 mysql 容器实例查看，内容如下：
$ docker exec -it my-mysql /bin/bash
root@63187274cfaa:/# mysql -uroot -pAdmin@h3c
mysql> show variables like 'character_%';
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | latin1                     |
| character_set_connection | latin1                     |
| character_set_database   | latin1                     |
| character_set_filesystem | binary                     |
| character_set_results    | latin1                     |
| character_set_server     | latin1                     |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.01 sec)
# 4.2 删除容器后，里面的MySQL数据如何处理?
# 容器实例一删除，你还有什么?删容器到跑路......

# 1.新建Mysql容器实例
$ mkdir -pv /app/mysql/{log,data,conf}
$ docker run -d -p 3306:3306 \
  --privileged=true \
  -v /app/mysql/log:/var/log/mysql \
  -v /app/mysql/data:/var/lib/mysql \
  -v /app/mysql/conf:/etc/mysql/conf.d \
  -e MYSQL_ROOT_PASSWORD=Admin@h3c \
  -e MYSQL_DATABASE=kubesphere \
  --name my-mysql mysql:5.7.36
# 2.新建my.cnf --> 通过容器卷同步给mysql容器实例
$ cat > /app/mysql/conf/my.cnf <<EOF
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]
init_connect='SET NAMES utf8mb4'
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
EOF
# 3.重新启动mysql容器实例再重新进入并查看字符编码
$ docker restart my-mysql
# 4.再新建库新建表再插入中文测试
$ docker exec -it my-mysql /bin/bash
root@049e957f38aa:/# mysql -uroot -pAdmin@h3c
mysql> SHOW variables like 'character_%';
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | utf8mb4                    |
| character_set_connection | utf8mb4                    |
| character_set_database   | utf8mb4                    |
| character_set_filesystem | binary                     |
| character_set_results    | utf8mb4                    |
| character_set_server     | utf8mb4                    |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)
mysql> CREATE DATABASE db01;
Query OK, 1 row affected (0.00 sec)
mysql> USE db01;
mysql> CREATE TABLE t1(id INT,NAME VARCHAR(20));
mysql> INSERT INTO t1(id , NAME) VALUES (1 , 'zhangsan');
mysql> INSERT INTO t1(id , NAME) VALUES (2 , 'lisi');
### 需要注意的是：容器里面是不能输入中文的。
mysql> INSERT INTO t1(id , NAME) VALUES (3 , '王五');
mysql> SELECT * FROM t1;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
|    2 | lisi     |
|    3 | 王五     |
+------+----------+
3 rows in set (0.00 sec)
# 5.结论
之前的DB无效，修改字符集操作+重启mysql容器实例
之后的DB有效，需要新建
结论："Docker安装完MySQL并run出容器后，建议请先修改完字符集编码后再新建mysql库-表-插入数据"
# 6.假如将当前容器实例删除，再重新来一次，之前建的db01实例
$ docker rm -f my-mysql
$ docker run -d -p 3306:3306 \
  --privileged=true \
  -v /app/mysql/log:/var/log/mysql \
  -v /app/mysql/data:/var/lib/mysql \
  -v /app/mysql/conf:/etc/mysql/conf.d \
  -e MYSQL_ROOT_PASSWORD=Admin@h3c \
  -e MYSQL_DATABASE=kubesphere\
  --name my-mysql-backup mysql:5.7.36
$ docker exec -it my-mysql-backup /bin/bash
root@146c8022535b:/# mysql -uroot -pAdmin@h3c
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| db01               |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)
mysql> use db01;
mysql> select * from t1;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
|    2 | lisi     |
|    3 | 王五     |
+------+----------+
3 rows in set (0.00 sec)
$ docker inspect my-mysql-backup

3.6.3 安装 Redis

• 从 DockerHub上（阿里云加速器）拉取Redis镜像到本地

$ docker pull redis:latest

• 入门命令
• 命令提醒：容器卷记得加入 --privileged=true
• 在CentOS宿主机下新建目录/app/redis —> mkdir -pv /app/redis

$ mkdir -pv /app/redis
$ docker run -it -d --name redis-node01 -p 16379:6379 redis:latest
$ docker exec -it redis-node01 bash
root@54c8d49e3400:/data# redis-cli
127.0.0.1:6379> SET k1 v1
OK
127.0.0.1:6379> GET k1
"v1"
127.0.0.1:6379>
root@54c8d49e3400:/data#
exit

• 将一个 redis.conf 文件模板拷贝进 /app/redis 目录下

# /app/redis目录下修改 redis.conf 文件
# 1.开启 Redis 验证（可选）
# --> requirepass <password>
# 2.允许 Redis 外地连接 必须
# --> # bind 127.0.0.1 (注释掉）
# 3.将daemonize yes注释起来或者设置daemonize no，因为该配置和 docker run 中-d参数冲突，会导致容器一直启动失败
# --> daemonize no
# 4.开启Redis数据持久化，appendonly yes（可选）
# --> appendonly yes

• /app/redis 目录下修改 redis.conf 文件 —> 默认出厂的原始 redis.conf

$ cat > /app/redis/redis.conf <<EOF
appendonly yes
# 设置密码
requirepass Admin@h3c
daemonize no
EOF

• 使用 redis 6.0.8 镜像创建容器（也叫运行镜像）

$ docker run -d -p 6379:6379 \
  --name test-redis --privileged=true \
  -v /app/redis/redis.conf:/etc/redis/redis.conf \
  -v /app/redis/data:/data \
  redis:6.0.8 redis-server /etc/redis/redis.conf
$ docker ps -l
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                       NAMES
48c120a094ff   redis     "docker-entrypoint.s…"   25 seconds ago   Up 24 seconds   0.0.0.0:6380->6379/tcp, :::6380->6379/tcp   test-redis

• 测试 redis-cli 连接上来

$ docker exec -it test-redis /bin/bash
root@48c120a094ff:/data# redis-cli
127.0.0.1:6379> auth Admin@h3c
OK
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379> ping
PONG

• 请证明 docker 启动使用了指定的配置文件

# 修改前，redis.conf配置文件默认为16个
# 修改后，将redis.conf的配置文件数据库设置为20个
# 宿主机的修改会同步给Docker容器里面的配置
$ echo "databases 20" >> /app/redis/redis.conf
$ cat /app/redis/redis.conf
appendonly yes
# 设置密码
requirepass Admin@h3c
daemonize no
databases 20
$ docker exec -it test-redis /bin/bash
root@48c120a094ff:/data# cat /etc/redis/redis.conf
appendonly yes
# 设置密码
requirepass Admin@h3c
daemonize no
databases 20

• 测试 redis-cli 连接上来第2次

$ docker restart test-redis
$ docker exec -it test-redis /bin/bash
root@48c120a094ff:/data# redis-cli
127.0.0.1:6379> auth Admin@h3c
OK
127.0.0.1:6379> SELECT 19
OK

3.6.4 安装 Nginx

$ mkdir -pv /app/nginx/html
$ echo "<h1>Hello,world</h1>" > /app/nginx/html/index.html
$ docker run -it -d \
-p 80:80 \
--name nginx-node01 \
-v /app/nginx/html:/usr/share/nginx/html:ro nginx
$ curl localhost
<h1>Hello,world</h1>