Docker入门

Docker入门

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给以上的问题，提出了一个标准化的解决方案！

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

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

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

隔离：Docker核心思想！打包装箱！每个箱子是互相隔离的。水果——生化武器

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

1.2 Docker的历史

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

这家公司主要提供基于PaaS的云计算技术服务。具体来说，是和LXC有关的容器技术。

他们将自己的技术 ( 容器化技术 ) 命名就是Docker !

Docker技术诞生之后，并没有引起行业的关注。而dotCloud公司，作为一家小型创业企业，在激烈的竞争之下，也步履维艰。

正当他们快要坚持不下去的时候，脑子里蹦出了“开源”的想法。

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

2013年3月，dotCloud公司的创始人之一，Docker之父，28岁的Solomon Hykes正式决定，将Docker项目开源。

越来越多的人发现了docker的优点！火了，Docker每个月都会更新一个版本！2014年4月9日，Docker1.0发布！

Docker和容器技术为什么这么火？说白了，就是因为它十分的轻巧！

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

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

虚拟机也是属于虚拟化技术，Docker容器技术，也是一种虚拟化技术，属于轻量级的虚拟化!

vm：linux centos 原生镜像（ 一个电脑 )   隔离，需要开启多个虚拟机！  几个G   几分钟
docker：隔离，镜像（ 最核心的环境4M + jdk + mysq1 )十分的小巧，运行镜像就可以了！ 小巧！几个M KB  秒级启动！

聊聊Docker

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

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

文档地址：https://docs.docker.com Docker的文档是超级详细的！

Docker中文网站：http://www.docker.org.cn

Docker中文文档：http://www.dockerinfo.net/document

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

1.3 Docker能干嘛

之前的虚拟机技术

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

虚拟机的缺点：
1、资源占用多
2、冗余步骤多
3 、启动慢

容器虚拟化技术

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

由于前面虚拟机存在这些缺点，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。
Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

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

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

开发 / 运维（DevOps）

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

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

更便捷的升级和扩缩容

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

项目打包为一个镜像，扩展 服务器A！ 服务器B！

更简单的系统运维

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

更高效的计算资源利用

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

2、Docker安装

2.1 Docker的基本组成

Docker的架构图：

镜像（image）：

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

容器（container）：

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

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

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

仓库（repository）：

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

仓库分为公有仓库（Public）和私有仓库（Private）！

Docker Hub ( 默认是国外的 )

阿里云 、网易云…都有容器服务器（ 配置镜像加速 )

小结：

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

• Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就似乎 image镜像文件。只有通过这个镜像文件才能生成 Docker 容器。image 文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

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

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

• 至于仓库，就是放了一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候从仓库中拉下来就可以了。

2.2 环境说明

我们使用的是 CentOS 7 (64-bit)

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

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

查看自己的内核：

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

[root@centos7 ~]# uname -r
3.10.0-1160.el7.x86_64

查看版本信息：

cat /etc/os-release

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

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

2.3 安装Docker

环境准备

1、需要会一点点的Linux的基础

2、CentOS 7

3、我们使用Xshell连接远程服务器进行操作！

安装

1、官网安装参考手册：https://docs.docker.com/engine/install/centos/

2、确定你是CentOS7及以上版本

3、yum安装gcc相关环境（需要确保 虚拟机可以连上外网 ）

yum -y install gcc
yum -y install gcc-c++

4、卸载旧版本

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

5、安装需要的软件包

yum install -y yum-utils

6、设置镜像仓库

# 错误
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
## 报错
[Errno 14] curl#35 - TCP connection reset by peer
[Errno 12] curl#35 - Timeout
# 正确推荐使用国内的
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

7、更新yum软件包索引

yum makecache fast

8、安装 Docker CE

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

9、启动 Docker

systemctl start docker

10、设置开机启动

systemctl enable docker

11、测试命令

docker version
docker run hello-world
docker images

12、卸载

systemctl stop docker #停止运行
yum -y remove docker-ce docker-ce-cli containerd.io  #卸载依赖
rm -rf /var/lib/docker  #删除资源

2.4 阿里云镜像加速

1、介绍：https://www.aliyun.com/product/acr

2、登录阿里云找到容器服务

3、找到自己的镜像加速地址

4、配置镜像加速

sudo mkdir -p /etc/docker

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

sudo systemctl daemon-reload

sudo systemctl restart docker

2.5 回顾HelloWorld流程

1、启动hello-world

docker run hello-world

2、run干了什么？

2.6 底层原理

Docker是怎么工作的

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

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

为什么Docker比较 VM 快

1、docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

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

3、Docker常用命令

3.1 帮助命令

docker version  # 显示 Docker 版本信息。
docker info    # 显示 Docker 系统信息，包括镜像和容器数。
docker --help  # 帮助

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

3.2 镜像命令

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

# 列出本地主机上的镜像
[root@centos7 /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
[root@centos7 /]# 

# 解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID  镜像的ID
CREATED 镜像创建时间
SIZE 镜像大小

# 同一个仓库源可以有多个 TAG，代表这个仓库源的不同版本，我们使用REPOSITORY：TAG 定义不同的镜像，如果你不定义镜像的标签版本，docker将默认使用 lastest 镜像！

# 可选项
[root@centos7 /]# docker images --help

Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

List images

Options:
  -a, --all             列出本地所有镜像
      --digests         显示镜像的摘要信息
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           只显示镜像id
[root@centos7 /]# 

docker search 搜索镜像

[root@centos7 /]# docker search mysql
NAME                           DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                          MySQL is a widely used, open-source relation…   12613     [OK]       
mariadb                        MariaDB Server is a high performing open sou…   4843      [OK]       
percona                        Percona Server is a fork of the MySQL relati…   577       [OK]     

# docker search 某个镜像的名称 对应DockerHub仓库中的镜像

# 可选项
[root@centos7 /]# docker search --help

Usage:  docker search [OPTIONS] TERM

Search the Docker Hub for images

Options:
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print search using a Go template
      --limit int       Max number of search results (default 25)
      --no-trunc        Don't truncate output
[root@centos7 /]# 
--filter=STARS=50   #列出收藏数不小于指定值的镜像。

docker pull 下载镜像

# 下载镜像  docker pull 镜像名[:tag]
[root@centos7 /]# docker pull mysql
Using default tag: latest  #如果不写 tag，默认就是latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete   #分层下载，docker iamge的核心   联合文件系统
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  #真实地址
[root@centos7 /]# 

#等价于它
docker pull mysql
docker pull docker.io/library/mysql:latest

指定版本下载

只能下载docker hub中存在的版本

[root@centos7 /]# docker pull mysql:8.0

镜像版本号重命名

docker tag 300e315adb2f centos:v1

docker rmi 删除镜像

docker rmi -f 镜像id # 删除单个  或者 docker rmi -f centos
docker rmi -f 镜像id 镜像id 镜像id # 删除多个
docker rmi -f $(docker images -qa) # 删除全部

3.3 容器命令

说明：有镜像才能创建容器，linux，我们这里使用 centos 的镜像来测试，就是虚拟一个 centos ！

docker pull centos

新建容器并启动

# 命令
docker run [可选参数] image 
# 参数说明
--name="Name"				# 容器名字tomcato1 tomcat02，用来区分容器
-d							# 后台方式运行
-it							# 使用交互方式运行，进入容器查看内容
-p							# 指定容器的端口-p 8080:8080，一般可以有四种写法
	-p ip:主机端口:容器端口
	-p 主机端口:容器端口（常用)
	-p 容器端口 
	容器端口
-P 							# 随机指定端口

# 测试
[root@centos7 /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
centos        latest    5d0da3dc9764   8 months ago   231MB
[root@centos7 /]# 

# 使用centos进行用交互模式启动容器，在容器内执行/bin/bash命令！
[root@centos7 /]# docker run -it centos /bin/bash
[root@605ac9903828 /]# ls  #查看容器内的centos
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@605ac9903828 /]# exit  #使用 exit 退出容器
exit
[root@centos7 /]# ls
bin   dev  home  lib64       media  opt   root  sbin  sys  usr  www
boot  etc  lib   lost+found  mnt    proc  run   srv   tmp  var
[root@centos7 /]# 

列出所有运行的容器

# docker ps 命令
docker ps [可选参数]
		# 列出当前所有正在运行的容器
-a 		# 列出当前所有正在运行的容器 + 历史运行过的容器
-l 		# 显示最近创建的容器
-n=? 	# 显示最近n个创建的容器
-q 		# 静默模式，只显示容器编号。
[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@centos7 /]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED         STATUS                     PORTS     NAMES
605ac9903828   centos        "/bin/bash"   4 minutes ago   Exited (0) 2 minutes ago             ecstatic_elbakyan
ac4017deca39   hello-world   "/hello"      2 hours ago     Exited (0) 2 hours ago               trusting_rhodes
aa5fa9c4fe0d   hello-world   "/hello"      40 hours ago    Exited (0) 40 hours ago              strange_chatterjee
[root@centos7 /]# docker ps -aq
605ac9903828
ac4017deca39
aa5fa9c4fe0d
[root@centos7 /]# 

退出容器

exit 			# 容器停止退出
ctrl + P + Q 	# 容器不停止退出

删除容器

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

启动停止容器

docker start (容器id or 容器名) 		# 启动容器
docker restart (容器id or 容器名)	# 重启容器
docker stop (容器id or 容器名) 		# 停止当前运行的容器
docker kill (容器id or 容器名) 		# 强制停止当前容器

3.4 常用其他命令

后台启动容器

# 命令
docker run -d 容器名
# 例子
docker run -d centos # 启动centos，使用后台方式启动
# 问题： 使用docker ps 查看，发现容器已经退出了！
# 解释：Docker容器后台运行，就必须有一个前台进程，容器运行的命令如果不是那些一直挂起的命令，就会自动退出。
# 比如，你运行了nginx服务，但是docker前台没有运行应用，这种情况下，容器启动后，会立即自杀，因为他觉得没有程序了，所以最好的情况是，将你的应用使用前台进程的方式运行启动。

查看日志

# 命令
docker logs -f -t --tail 容器id
# 例子：我们启动 centos，并编写一段脚本来测试玩玩！最后查看日志
[root@centos7 /]#  docker run -d centos /bin/sh -c "while true;do echo;mstudy;sleep 1;done"

[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND 
6907a6664483   centos    "/bin/sh -c 'while t…" 
e308f3d128a1   centos    "/bin/bash"          
[root@centos7 /]# 

# 显示日志
# -t 显示时间戳
# -f 打印最新的日志
# --tail 数字 显示多少条！
[root@centos7 /]# docker logs -tf --tail 10 6907a6664483
2022-05-22T07:02:44.062538028Z 
2022-05-22T07:02:44.062906582Z /bin/sh: mstudy: command not found
2022-05-22T07:02:45.066945882Z 
2022-05-22T07:02:45.066988575Z /bin/sh: mstudy: command not found
2022-05-22T07:02:46.073760610Z 

查看容器中运行的进程信息，支持 ps 命令参数

# 命令
docker top 容器id
# 测试
[root@centos7 /]# docker top 6907a6664483
UID                 PID                 PPID                C  
root                30826               30806               0   
root                32219               30826               0  
[root@centos7 /]# 

查看容器 / 镜像的元数据

# 命令
docker inspect 容器id
# 测试
[root@centos7 /]# docker inspect 6907a6664483
[
    {
        "Id": "6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d",
        "Created": "2022-05-22T06:59:37.970498779Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo;mstudy;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 30826,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-05-22T06:59:38.709393618Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d/hostname",
        "HostsPath": "/var/lib/docker/containers/6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d/hosts",
        "LogPath": "/var/lib/docker/containers/6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d/6907a6664483dc6f6d856861ab354809ae50f09872f145fd459f698acafb250d-json.log",
        "Name": "/fervent_mayer",
        "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": "no",
                "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/749830dae9e396b171eec3fd41992395aeef385b9cd374321a7679a51468d47d-init/diff:/var/lib/docker/overlay2/bc24dd82f970ff53cc9f43a25b13561e122c6e874581629de0eb4a194c66fe7e/diff",
                "MergedDir": "/var/lib/docker/overlay2/749830dae9e396b171eec3fd41992395aeef385b9cd374321a7679a51468d47d/merged",
                "UpperDir": "/var/lib/docker/overlay2/749830dae9e396b171eec3fd41992395aeef385b9cd374321a7679a51468d47d/diff",
                "WorkDir": "/var/lib/docker/overlay2/749830dae9e396b171eec3fd41992395aeef385b9cd374321a7679a51468d47d/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "6907a6664483",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo;mstudy;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "b0cd79e059ee90855cc31d7c710157c162a6579900719a0a797ed9fdca2b5412",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/b0cd79e059ee",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "f3c1040a9080eca3e6389c89569f32e9e0f41476943dbfca798a7305220c9736",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.3",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:03",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "0ffd9da16beb01ed1725c2b49fe895b45bfb29720837b82b029a7e26a303b2ce",
                    "EndpointID": "f3c1040a9080eca3e6389c89569f32e9e0f41476943dbfca798a7305220c9736",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.3",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:03",
                    "DriverOpts": null
                }
            }
        }
    }
]
[root@centos7 /]# 

进入正在运行的容器

# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
# 命令1
docker exec -it 容器id bashShell
# 测试1
[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED             STATUS             PORTS     NAMES
6907a6664483   centos    "/bin/sh -c 'while t…"   About an hour ago   Up About an hour             fervent_mayer
e308f3d128a1   centos    "/bin/bash"              About an hour ago   Up About an hour             compassionate_cannon
[root@centos7 /]# docker exec -it 6907a6664483 /bin/bash
[root@6907a6664483 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@6907a6664483 /]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 06:59 ?        00:00:04 /bin/sh -c while true;do echo;mstudy;sleep 1;done
root       7399      0  0 08:01 pts/0    00:00:00 /bin/bash
root       7477      1  0 08:02 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr
root       7478   7399  0 08:02 pts/0    00:00:00 ps -ef
[root@6907a6664483 /]# 

# 命令2
docker attach 容器id
# 测试2
[root@centos7 /]# docker attach 6907a6664483
正在执行当前的代码...

# 区别
# docker exec   # 进入容器后开启一个新的终端，可以在里面操作 (常用)
# docker attach  # 进入容器正在执行的终端，不会启动新的进程

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

# 命令
docker cp 容器id:容器内路径 目的主机路径

# 测试
[root@centos7 /]# docker exec -it 6907a6664483 /bin/bash  #进入docker容器内部
[root@6907a6664483 /]# cd home/
[root@6907a6664483 home]# ls             
[root@6907a6664483 home]# touch test.java  # 容器内执行，创建一个文件测试
[root@6907a6664483 home]# ls
test.java
[root@6907a6664483 home]# exit
exit
[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED             STATUS             PORTS     NAMES
6907a6664483   centos    "/bin/sh -c 'while t…"   About an hour ago   Up About an hour             fervent_mayer
e308f3d128a1   centos    "/bin/bash"              About an hour ago   Up About an hour             compassionate_cannon
[root@centos7 /]# docker cp 6907a6664483:/home/test.java /home    # 将这文件拷贝出来到主机上
[root@centos7 /]# cd home/
[root@centos7 home]# ls
Linux  test.java  www
[root@centos7 home]# 

#拷贝是一个手动过程，后期我们使用 -v 卷的技术，可以实现

3.5 小结

常用命令：

attach Attach to a running container 		# 当前 shell 下attach 连接指定运行镜像
build Build an image from a Dockerfile 		# 通过 Dockerfile 定制镜像
commit Create a new image from a container changes 		# 提交当前容器为新的镜像
# 从容器中拷贝指定文件或者目录到宿主机中
cp Copy files/folders from the containers filesystem to the host path
create Create a new container   # 创建一个新的容器，同run，但不启动容器
diff Inspect changes on a container's filesystem    # 查看 docker 容器变化
events Get real time events from the server 			# 从 docker 服务获取容器实时事件
exec Run a command in an existing container 			# 在已存在的容器上运行命令
# 导出容器的内容流作为一个 tar 归档文件[对应 import]
export Stream the contents of a container as a tar archive 	
history Show the history of an image 	# 展示一个镜像形成历史
images List images 		# 列出系统当前镜像
# 从tar包中的内容创建一个新的文件系统映像[对应export]
import Create a new filesystem image from the contents of a tarball 
info Display system-wide information 	# 显示系统相关信息
inspect Return low-level information on a container 	# 查看容器详细信息
kill Kill a running container 		# kill 指定 docker 容器
load Load an image from a tar archive 	# 从一个 tar 包中加载一个镜像[对应 save]
login Register or Login to the docker registry server 	# 注册或者登陆一个docker 源服务器
logout Log out from a Docker registry server 	# 从当前 Docker registry 退出
logs Fetch the logs of a container 				# 输出当前容器日志信息
# 查看映射端口对应的容器内部源端口
port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT 
pause Pause all processes within a container 		# 暂停容器
ps List containers 		# 列出容器列表
# 从docker镜像源服务器拉取指定镜像或者库镜像
pull Pull an image or a repository from the docker registry server 
# 推送指定镜像或者库镜像至docker源服务器
push Push an image or a repository to the docker registry server 
restart Restart a running container 		# 重启运行的容器
rm Remove one or more containers 			# 移除一个或者多个容器
# 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
rmi Remove one or more images 				
run Run a command in a new container 		# 创建一个新的容器并运行一个命令
save Save an image to a tar archive			# 保存一个镜像为一个tar 包[对应 load]
search Search for an image on the Docker Hub 	# 在 docker hub 中搜索镜像
start Start a stopped containers 		# 启动容器
stop Stop a running containers 			# 停止容器
tag Tag an image into a repository 		# 给源中镜像打标签
top Lookup the running processes of a container 	# 查看容器中运行的进程信息
unpause Unpause a paused container 		# 取消暂停容器
version Show the docker version information 		# 查看 docker 版本号
wait Block until a container stops, then print its exit code 	# 截取容器停止时的退出状态值

docker的命令是十分多的，上面我们学习的那些都是最常用的容器和镜像的命令，之后我们还会学习很多命令！

3.6 作业练习

使用Docker 安装 Nginx

# 1、搜索镜像
[root@centos7 /]# docker search nginx
NAME      DESCRIPTION        		STARS     OFFICIAL   AUTOMATED
nginx     Official build of Nginx.    16818     [OK]  

# 2、拉取镜像             
[root@centos7 /]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete 
a9edb18cadd1: Pull complete 
589b7251471a: Pull complete 
186b1aaa4aa6: Pull complete 
b4df32aa5a72: Pull complete 
a0bcbecc962e: Pull complete 
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

# 3、启动容器
[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED       STATUS       PORTS     NAMES
e308f3d128a1   centos    "/bin/bash"              2 hours ago   Up 2 hours             compassionate_cannon
[root@centos7 /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
nginx         latest    605c77e624dd   4 months ago   141MB
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
centos        latest    5d0da3dc9764   8 months ago   231MB

# -d		后台运行
# --name	给容器命名
# -p		宿主机端口:容器内部端口
[root@centos7 /]# docker run -d --name mynginx -p 3344:80 nginx
9c7e41793e106ccbdc5862353015b6af987ef00c136bd1ea50c15b6bee0b92cd
[root@centos7 /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS         PORTS                                   NAMES
9c7e41793e10   nginx     "/docker-entrypoint.…"   18 seconds ago   Up 9 seconds   0.0.0.0:8081->80/tcp, :::8081->80/tcp   mynginx
6907a6664483   centos    "/bin/sh -c 'while t…"   2 hours ago      Up 2 hours                                             fervent_mayer
e308f3d128a1   centos    "/bin/bash"              2 hours ago      Up 2 hours                                             compassionate_cannon
# 4、测试访问
[root@centos7 /]# curl localhost:3344
<!DOCTYPE html>
<html>
	 ......
    <title>Welcome to nginx!</title>
    ......
</html>

# 5、进入容器
[root@centos7 /]# docker exec -it mynginx /bin/bash
root@9c7e41793e10:/# whereis nginx   # 寻找nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@9c7e41793e10:/# cd /usr/share/nginx   # nginx 的路径
root@9c7e41793e10:/usr/share/nginx# ls
html
root@9c7e41793e10:/usr/share/nginx# cd html   # 首页的位置
root@9c7e41793e10:/usr/share/nginx/html# ls
50x.html  index.html
root@9c7e41793e10:/usr/share/nginx/html# cat index.html 
<!DOCTYPE html>
<html>
	 ......
	<title>Welcome to nginx!</title>
	 ......
</html>

端口暴露概念：

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

使用Docker 安装 Tomcat

# 官方文档解释
# -it ：交互模式
# --rm ：容器启动成功并退出以后容器就自动删除了，一般在测试情况下使用！
docker run -it --rm tomcat:9.0

# 1、下载tomcat镜像
docker pull tomcat:9.0
# 2、启动运行
docker run -d -p 3355:8080 --name tomcat9 tomcat:9.0
# 3、测试访问没有问题
# 4、进入tomcat
docker exec -it tomcat9 /bin/bash

# 5、发现问题：1、1inux命令少了 2、webapps为空。
#阿里云镜像的原因，默认是最小的镜像，所有不必要的都剔除掉了
#保证最小可运行的环境!
#解决方法：
root@3bd36dea0672:/usr/local/tomcat/webapps# ls
root@3bd36dea0672:/usr/local/tomcat/webapps# cd ..
root@3bd36dea0672:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@3bd36dea0672:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@3bd36dea0672:/usr/local/tomcat# cd webapps
root@3bd36dea0672:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
root@3bd36dea0672:/usr/local/tomcat/webapps# 
#刷新页面即可

# 6、思考：我们以后要部署项目，还需要进入容器中，是不是十分麻烦，可以使用数据卷技术来进行挂载操作，将容器内和我们Linux进行映射挂载，它也是一个核心内容！

使用Docker 部署 es + kibana

# es暴露的端口很多
# es十分的耗内存
# es的数据―般需要放置到安全目录！挂载
# --net somenetwork  网络配置

# 我们启动es这种容器需要考虑几个问题
# (1) 端口暴露问题 9200、9300
# (2) 数据卷的挂载问题 data、plugins、conf
# (3) 吃内存 - "ES_JAVA_OPTS=-Xms512m -Xmx512m"

# 1、启动es测试
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 2、启动之后很卡，使用 docker stats 容器id 查看下cpu状态 ，发现占用的很大
[root@centos7 ~]# docker stats 52303d309b3d 

CONTAINER ID   NAME            CPU %     MEM USAGE / LIMIT    MEM %     NET I/O     BLOCK I/O        PIDS
52303d309b3d   elasticsearch   0.43%     1.242GiB / 3.84GiB   32.35%    656B / 0B   15.2MB / 700kB   45

# 3、测试访问
[root@centos7 ~]# curl localhost:9200
{
  "name" : "52303d309b3d",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "dt_hndlMQ06zMfqFfAKAHQ",
  "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"
}

# 4、增加内存限制启动，修改配置文件 -e环境配置修改
docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

# 5、启动之后，使用 docker stats 查看下cpu状态
[root@centos7 ~]# docker stats c82e9b1889b0

CONTAINER ID   NAME              CPU %     MEM USAGE / LIMIT   MEM %     NET I/O     BLOCK I/O        PIDS
c82e9b1889b0   elasticsearch01   0.37%     394MiB / 3.84GiB    10.02%    656B / 0B   3.84MB / 729kB   46

# 6、测试访问，效果一样，ok！
[root@centos7 ~]# curl localhost:9200

# 思考：如果我们要使用 kibana，如果配置连接上我们的es呢？网络该如何配置呢？

3.7 可视化

Portainer（先用这个）

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

Rancher（CI / CD再用这个）

#安装rancher-server
docker run --name rancher-server -p 8000:8080 -v /etc/localtime:/etc/localtime:ro -d rancher/server
#安装agent
docker run --rm --privileged -v /var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.2.11 http://39.101.191.131:8000/v1/scripts/D3DBD43F263109BB881F:1577750400000:7M0yBzCw4XSxJklD7TpysYIpI

介绍：

Portainer是Docker的图形化管理工具，提供状态显示面板、应用模板快速部署、容器镜像网络数据卷的基本操作（包括上传下载镜像，创建容器等操作）、事件日志显示、容器控制台操作、Swarm集群和服务等集中管理和操作、登录用户管理和控制等功能。功能十分全面，基本能满足中小型单位对容器管理的全部需求。

如果仅有一个docker宿主机，则可使用单机版运行，Portainer单机版运行十分简单，只需要一条语句即可启动容器，来管理该机器上的docker镜像、容器等数据。

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

访问方式：http://192.168.10.110:8088

首次登陆需要注册用户，给admin用户设置密码：

单机版这里选择local即可，选择完毕，点击Connect即可连接到本地docker：

登录成功之后可见面板！

可视化面板我们平时不会使用，大家自己测试玩玩即可！

4、Docker镜像讲解

4.1 镜像是什么

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

所有的应用，直接打包docker镜像，就可以直接跑起来!如何得到镜像：

• 从远程仓库下载
• 朋友拷贝给你
• 自己制作一个镜像DockerFile

4.2 Docker镜像加载原理

UnionFS （联合文件系统）

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

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

Docker镜像加载原理

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

bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

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

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

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

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

4.3 分层理解

分层的镜像

我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层的在下载！

思考：为什么Docker镜像要采用这种分层的结构呢？

最大的好处，我觉得莫过于是资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。

查看镜像分层的方式可以通过 docker image inspect 命令！

[root@centos7 ~]# docker image inspect redis:latest
[
    {
        "Id": "sha256:7614ae9453d1d87e740a2056257a6de7135c84037c367e1fffa92ae922784631",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-12-21T12:42:49.755107412Z",
        "Container": "13d25f53410417c5220c8dfe8bd49f06abdbcd69faa62a9b877de02464bb04a3",
        "ContainerConfig": {
            "Hostname": "13d25f534104",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD [\"redis-server\"]"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {}
        },
        "DockerVersion": "20.10.7",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "redis-server"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 112691373,
        "VirtualSize": 112691373,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/96b79cc9930256e1e353048704451e4238a81401546c095b7d646a41474c4361/diff:/var/lib/docker/overlay2/1ffba507fa3c85d231622a1182563fa935a24c311a0a9fcc7c60099997ea0fbb/diff:/var/lib/docker/overlay2/52b420e787c76275acd6fa7fd61aff62949d390d941f995eaff178b918c1985a/diff:/var/lib/docker/overlay2/865ebc36b5f8e3fe041d70a054d713d0cab45bd5796c7a9c097975fe77de1967/diff:/var/lib/docker/overlay2/7a72180be814c6da4501de2899b107c649c27572448099573b2ad9037532e821/diff",
                "MergedDir": "/var/lib/docker/overlay2/5e2d5041085e0ccc5590661f3a57398fd659817d24bdd6f64735a1adc9c175b5/merged",
                "UpperDir": "/var/lib/docker/overlay2/5e2d5041085e0ccc5590661f3a57398fd659817d24bdd6f64735a1adc9c175b5/diff",
                "WorkDir": "/var/lib/docker/overlay2/5e2d5041085e0ccc5590661f3a57398fd659817d24bdd6f64735a1adc9c175b5/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
                "sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
                "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
                "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
                "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
                "sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解：

所有的 Docker 镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子，假如基于 Ubuntu Linux 16.04 创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。

该镜像当前已经包含 3 个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含 3 个文件，而镜像包含了来自两个镜像层的 6 个文件。

上图中的镜像层跟之前图中的略有区别，主要目的是便于展示文件。

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有 6 个文件，这是因为最上层中的文件7 是文件 5 的一个更新版本。

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。

Docker 通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

Linux 上可用的存储引擎有 AUFS、Overlay2、Device Mapper、Btrfs 以及 ZFS。顾名思义，每种存储引擎都基于 Linux 中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。

Docker 在 Windows 上仅支持 windowsfilter 一种存储引擎，该引擎基于 NTFS 文件系统之上实现了分层和 CoW[1]。

下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并，对外提供统一的视图。

特点

Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！

这一层就是我们通常说的容器层，容器之下的都叫镜像层！

4.4 镜像Commit

docker commit 从容器创建一个新的镜像

docker commit 提交容器副本使之成为一个新的镜像！
# 语法
docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[标签名]

测试：

# 1、从Docker Hub 下载tomcat镜像到本地并运行 -it 交互终端 -p 端口映射
docker run -it -p 8080:8080 tomcat:9.0
# 2、发现这个默认的tomcat是没有webapps应用，镜像的原因，官方的镜像默认 webapps下面是没有文件的!
# 进入tomcat查看cd到webapps下发现全部空的，反而有个webapps.dist里有对应文件，cp -r到webapps下！

# 3、我自己拷贝进去了基本的文件
docker ps # 查看容器id
docker exec -it 容器id /bin/bash 
[root@centos7 ~]# docker exec -it 59d478bfadd2 /bin/bash
root@59d478bfadd2:/usr/local/tomcat# cp -r webapps.dist/* webapps
# 4、将我们操作过的容器通过commit提交为一个镜像!我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像
docker ps -l # 查看容器的id
# 注意：commit的时候，容器的名字不能有大写，否则报错：invalid reference format
docker commit -a="mstudy" -m="add webapps application" 59d478bfadd2 tomcat09:1.0

# 5、这个时候，我们的镜像都是可以使用的，大家可以启动原来的tomcat，和我们新的tomcat09来测试看看！
[root@centos7 ~]# docker run -it -p 8080:8080 tomcat09:1.0
# 如果你想要保存你当前容器的状态，可以通过commit，来提交镜像，方便使用，类似于 VM 中的快照！

5、容器数据卷

5.1 什么是容器数据卷

Docker的理念回顾：

将应用和环境打包成一个镜像！
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

就好比，你安装一个MySQL，结果你把容器删了，就相当于删库跑路了！需求：MySQL数据可以存储在本地！

所以我们希望容器之间可以共享数据，Docker容器产生的数据，同步到本地！

这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

作用：

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

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

特点：

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

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

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

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

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

5.2 使用数据卷

方式一：容器中直接使用命令来添加 -v

挂载

# 命令
docker run -it -v 宿主机绝对路径目录:容器内目录 镜像名
# 测试
[root@centos7 ~]# docker run -it -v /home/ceshi:/home centos /bin/bash

查看数据卷是否挂载成功 docker inspect 容器id

测试容器和宿主机之间数据共享：可以发现，在容器中，创建的会在宿主机中看到！

测试容器停止退出后，主机修改数据是否会同步！

1、停止容器

2、在宿主机上修改文件，增加些内容

3、启动刚才停止的容器

4、然后查看对应的文件，发现数据依旧同步！

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

5.3 使用 Docker 安装 mysql

思考：mysql 数据持久化的问题！

# 1、搜索镜像
[root@centos7 ~]# docker search mysql
NAME        DESCRIPTION       							  STARS     OFFICIAL   AUTOMATED
mysql       MySQL is a widely used, open-source relation…   12615     [OK] 
# 2、拉取镜像
[root@centos7 ~]# docker pull mysql:8.0
8.0: Pulling from library/mysql
72a69066d2fe: Pull complete 
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:8.0
docker.io/library/mysql:8.0
# 3、启动容器 -e 环境变量！
#官方文档
docker run --name some-mysql -v /my/custom:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
# 注意：mysql的数据应该不丢失！先体验下 -v 挂载卷！
-d		后台运行
-p		端口映射
-v		卷挂载
-e		环境配置
--name	容器名字
[root@centos7 home]# docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:8.0
# 4、使用本地的Navicat Premium 15连接测试一下 3310
# Navicat Premium 15---连接到服务器的3310 --- 3310 和容器内的 3306映射，这个时候我们就可以连接上了

# 5、查看本地的 /home/mysql 目录
[root@centos7 data]# pwd
/home/mysql/data
[root@centos7 data]# ls
.. ... . test # 可以看到我们刚刚建立的mysql数据库在本地存储着
# 6、删除mysql容器
[root@centos7 data]# docker rm -f mysql01 # 删除容器，然后发现远程连接失败！
mysql01
[root@centos7 data]# ls
.. ... . test # 可以看到我们刚刚建立的mysql数据库在本地存储着
# 我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能！

5.4 匿名和具名挂载

# 怎么判断挂载的是卷名而不是本机目录名？
# 不是 / 开始就是卷名，是 / 开始就是目录名

# 匿名挂载
# 通过 -v 容器内路径
[root@centos7 ~]# docker run -d -P --name nginx01 -v /etc/nginx nginx
# 匿名挂载的缺点，就是不好维护，通常使用命令 docker volume维护
# 查看所有的volume的情况
[root@centos7 ~]# docker volume ls
DRIVER    VOLUME NAME
local     8eb0eb2e30f1f77b47ba08f694d817f76f156c611ebbed558584508f3b01e91c
local     6750ea0c76a85db366525675aaea15d37ae465080db2f8f10b225f9102f5fb5c
#这里发现，这种就是匿名挂载，我们在-v只写了容器内的路径，没有写容器外的路径!

# 具名挂载
# 通过 -v 卷名:/容器内路径
[root@centos7 ~]# docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx nginx
# 查看所有的volume的情况
[root@centos7 ~]# docker volume ls
DRIVER    VOLUME NAME
local     8eb0eb2e30f1f77b47ba08f694d817f76f156c611ebbed558584508f3b01e91c
local     6750ea0c76a85db366525675aaea15d37ae465080db2f8f10b225f9102f5fb5c
local     nginxconfig

# 查看挂载的路径
[root@centos7 ~]# docker volume inspect nginxconfig

所有的docker容器内的卷，没有指定目录的情况下都是在/var/1ib/docker/volumes/xxxx/_data

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

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

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

拓展：

# 通过 -v 容器内路径:ro   rw 改变读写权限
# ro		readonly		#只读
# rw		readwrite		#可读可写
# 指定容器对我们挂载出来的内容的读写权限
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:rw nginx

# ro只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

5.5 初始 Docker File

DockerFile 是用来构建Docker镜像的构建文件，是由一些列命令和参数构成的命令脚本。

测试：

# 1、我们在宿主机 /home 目录下新建一个 docker-test-volume 文件夹
[root@centos7 home]# mkdir docker-test-volume

# 2、创建DockerFile文件，名字可以随机 建议	Dockerfile
# 文件中的内容	指令(大写)	参数
[root@centos7 docker-test-volume]# pwd
/home/docker-test-volume
[root@centos7 docker-test-volume]# vim dockerfile1
[root@centos7 docker-test-volume]# cat dockerfile1 
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "-------end------"
CMD /bin/bash
# 这里的每个命令，就是镜像的一层！

# 3、build后生成镜像，获得一个新镜像 mstudy/centos
[root@centos7 docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile1 -t mstudy/centos .   #注意最后有个.

# 4、启动自己写的容器
[root@centos7 docker-test-volume]# docker run -it a245a2118c77 /bin/bash   # 启动容器

这个卷和外部一定有一个同步的目录！

查看一下数据卷挂载的路径

# 问题：通过上述步骤，容器内的卷目录地址就已经知道了，但是对应的主机目录地址在哪里呢？
# 5、我们在数据卷中新建一个文件
[root@b403f003daeb /]# cd dataVolumeContainer1
[root@b403f003daeb dataVolumeContainer1]# pwd
/dataVolumeContainer1
[root@b403f003daeb dataVolumeContainer1]# touch container.txt
[root@b403f003daeb dataVolumeContainer1]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 23 03:15 container.txt

# 6、查看下这个容器的信息
[root@centos7 ~]# docker inspect b403f003daeb

# 7、这个卷在主机对应的默认位置

测试一下刚才的文件是否同步出去了！

这种方式我们未来使用的十分多，因为我们通常会构建自己的镜像！

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

注意：

如果访问出现了 cannot open directory：Permission denied

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

5.6 数据卷容器

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

例如：多个mysql同步数据！

我们使用上一步的镜像：mstudy/centos 为模板，运行容器 docker01，docker02，docker03，他们都会具有容器卷

"/dataVolumeContainer1"
"/dataVolumeContainer2"

我们来测试下，容器间传递共享

1、先启动一个父容器docker01，然后在dataVolumeContainer2新增文件

[root@centos7 ~]# docker images

[root@centos7 ~]# docker run -it --name docker01 mstudy/centos
[root@cb910f7e81ee /]# ls -l 

[root@cb910f7e81ee /]# cd dataVolumeContainer2
[root@cb910f7e81ee dataVolumeContainer2]# touch docker01.txt
[root@cb910f7e81ee dataVolumeContainer2]# ls

退出不停止：Ctrl + P + Q

2、创建docker02，docker03 让他们继承docker01 --volumes-from

[root@centos7 ~]# docker run -it --name docker02 --volumes-from docker01 mstudy/centos
[root@7f93bd6e8079 /]# cd dataVolumeContainer2 
[root@7f93bd6e8079 dataVolumeContainer2]# ls

[root@7f93bd6e8079 dataVolumeContainer2]# touch docker02.txt
[root@7f93bd6e8079 dataVolumeContainer2]# ls

[root@centos7 ~]# docker run -it --name docker03 --volumes-from docker01 mstudy/centos
[root@7f93bd6e8079 /]# cd dataVolumeContainer2 
[root@7f93bd6e8079 dataVolumeContainer2]# ls

[root@7f93bd6e8079 dataVolumeContainer2]# touch docker03.txt
[root@7f93bd6e8079 dataVolumeContainer2]# ls

3、回到docker01发现可以看到 docker02 和 docker03 添加的共享文件

[root@centos7 ~]# docker attach docker01
[root@cb910f7e81ee dataVolumeContainer2]# ls

4、删除docker01，docker02 修改后docker03还能不能访问

[root@centos7 ~]# docker rm -f docker01
[root@centos7 ~]# docker attach docker02
[root@7f93bd6e8079 dataVolumeContainer2]# touch docker02-update.txt
[root@7f93bd6e8079 dataVolumeContainer2]# ls
[root@7f93bd6e8079 dataVolumeContainer2]# Ctrl + P + Q 退出容器

[root@centos7 ~]# docker attach docker03
[root@726b036aa3ba dataVolumeContainer2]# ls
docker01.txt  docker02-update.txt  docker02.txt  docker03.txt

5、删除docker02 ，docker03还能不能访问

[root@centos7 ~]# docker rm -f docker02
[root@centos7 ~]# docker attach docker03
[root@726b036aa3ba dataVolumeContainer2]# touch docker03-update.txt
[root@726b036aa3ba dataVolumeContainer2]# ls
[root@726b036aa3ba dataVolumeContainer2]# Ctrl + P + Q 退出容器

6、新建docker04继承docker03，然后再删除docker03，看下是否可以访问！

[root@centos7 ~]# docker run -it --name docker04 --volumes-from docker03 mstudy/centos
[root@7f93bd6e8079 /]# cd dataVolumeContainer2 
[root@7f93bd6e8079 dataVolumeContainer2]# ls

[root@centos7 ~]# docker rm -f docker03   # 继续删除docker03
[root@centos7 ~]# docker attach docker04
[root@5f6a1162a53e dataVolumeContainer2]# ls

# 测试：可以删除docker01，查看一下docker02和docker03是否还可以访问这个文件
# 测试依旧可以访问

多个mysql实现数据共享

[root@centos7 home]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:8.0

[root@centos7 home]# docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:8.0

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

结论：

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

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

6、DockerFile

大家想想，Nginx，tomcat，mysql 这些镜像都是哪里来的？官方能写，我们不能写吗？

我们要研究自己如何做一个镜像，而且我们写的微服务项目以及 springboot 打包上云部署，Docker就是最方便的。

微服务打包成镜像，任何装了Docker的地方，都可以下载使用，极其的方便。

流程：开发应用 =-=> DockerFile =-=> 打包为镜像 =-=> 上传到仓库（私有仓库，公有仓库）=-=> 下载镜像 =-=> 启动运行。

还可以方便移植！

6.1 什么是DockerFile

dockerfile 是用来构建 Docker 镜像的构建文件，是由一系列命令和参数构成的脚本。

构建步骤：

1、编写一个 dockerFile 文件

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

3、docker run 运行镜像

4、docker push 发布镜像 ( DockerHub、阿里云镜像仓库！)

dockerfile 文件我们刚才已经编写过了一次，这里我们继续使用 centos 来看！

地址：https://hub.docker.com/_/centos

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

官方既然可以制作镜像，那我们也可以！

6.2 DockerFile 构建过程

基础知识：

1、每个保留字关键字 ( 指令 ) 都必须为大写字母且后面要跟随至少一个参数

2、指令按照从上到下，顺序执行

3、# 表示注释

4、每条指令都会创建一个新的镜像层，并对镜像进行提交

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

流程：

1、docker从基础镜像运行一个容器

2、执行一条指令并对容器做出修改

3、执行类似 docker commit 的操作提交一个新的镜像层

4、Docker再基于刚提交的镜像运行一个新容器

5、执行dockerfile中的下一条指令直到所有指令都执行完成！

说明：

从应用软件的角度来看，DockerFile，docker镜像与docker容器分别代表软件的三个不同阶段。

• DockerFile 是软件的原材料 （代码）
• Docker 镜像则是软件的交付品 （.apk）
• Docker 容器则是软件的运行状态 （客户下载安装执行）

DockerFile 面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可！

DockerFile：需要定义一个DockerFile，DockerFile定义了进程需要的一切东西。DockerFile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程（ 当引用进行需要和系统服务和内核进程打交道，这时需要考虑如何设计 namespace的权限控制 ）等等。

Docker镜像：在DockerFile 定义了一个文件之后，Docker build 时会产生一个Docker镜像，当运行Docker 镜像时，会真正开始提供服务；

Docker容器：容器是直接提供服务的。

6.3 DockerFile 指令

关键字：

FROM 		# 基础镜像，当前新镜像是基于哪个镜像的
MAINTAINER 	# 镜像是谁写的，姓名+邮箱地址
RUN 		# 容器构建时需要运行的命令
EXPOSE 		# 当前容器对外保留出的端口，暴露端口配置
WORKDIR 	# 指定在创建容器后，终端默认登录的进来工作目录，一个落脚点，镜像的工作目录
ENV 		# 用来在构建镜像过程中设置环境变量
ADD 		# 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY 		# 类似ADD，拷贝文件和目录到镜像中！
VOLUME 		# 容器数据卷，用于数据保存和持久化工作，挂载的目录
CMD 		# 指定一个容器启动时要运行的命令，可以有多个CMD指令，但只有最后一个生效，可被替代！
ENTRYPOINT 	# 指定一个容器启动时要运行的命令，可以追加命令，形成新的命令组合
ONBUILD 	# 当构建一个被继承的DockerFile时运行命令，父镜像在被子镜像继承后，父镜像的ONBUILD被触发

6.4 实战测试

Docker Hub 中 99% 的镜像都是通过在base镜像（Scratch）中安装和配置需要的软件构建出来的

自定义一个 centos

1、编写DockerFile

[root@centos7 ~]# cd /home/
[root@centos7 home]# ls
docker-test-volume  Linux  mysql  www
[root@centos7 home]# mkdir dockerfile-test
[root@centos7 home]# cd dockerfile-test
[root@centos7 dockerfile-test]# ls
[root@centos7 dockerfile-test]# vim mydockerfile-centos
[root@centos7 dockerfile-test]# cat mydockerfile-centos 
FROM centos:7
MAINTAINER mstudy<3070265813@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

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

2、构建

docker build -f dockerfile地址 -t 新镜像名字:TAG .

会看到 docker build 命令最后有一个 . "." 表示当前目录

[root@centos7 dockerfile-test]# docker build -f mydockerfile-centos -t mycentos:0.1 .
Sending build context to Docker daemon  2.048kB
Step 1/10 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/10 : MAINTAINER mstudy<3070265813@qq.com>
......
Removing intermediate container 4998f43f64d5
 ---> 5e4c4b5012fd
Successfully built 5e4c4b5012fd
Successfully tagged mycentos:0.1

3、运行

docker run -it 新镜像名字:TAG

[root@centos7 ~]# docker run -it mycentos:0.1
[root@c4f6a53e9fcc local]# pwd
/usr/local
[root@c4f6a53e9fcc local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.2  netmask 255.255.0.0  broadcast 172.17.255.255
......

对比：

之前的原生的centos7

我们增加之后的镜像

4、列出镜像的变更历史

docker history 镜像名

[root@centos7 ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
mycentos              0.1       5e4c4b5012fd   2 days ago      601MB
......
[root@centos7 ~]# docker history 5e4c4b5012fd
IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
5e4c4b5012fd   2 days ago     /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B        
......    
[root@centos7 ~]# 

CMD 和 ENTRYPOINT 的区别

CMD 		# 指定一个容器启动时要运行的命令，可以有多个CMD指令，但只有最后一个生效，可被替代！
ENTRYPOINT 	# 指定一个容器启动时要运行的命令，可以追加命令，形成新的命令组合

测试：

CMD命令

# 1、编写 dockerfile 文件
[root@centos7 dockerfile-test]# vim dockerfile-cmd-test
[root@centos7 dockerfile-test]# cat dockerfile-cmd-test 
FROM centos:7
CMD [ "ls", "-a" ]

# 2、build 构建镜像
[root@centos7 dockerfile-test]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/2 : CMD [ "ls", "-a" ]
 ---> Running in 37fcfe11ff16
Removing intermediate container 37fcfe11ff16
 ---> 39182fe996ce
Successfully built 39182fe996ce
Successfully tagged cmdtest:latest

# 3、执行，发现 ls -a 命令生效
[root@centos7 dockerfile-test]# docker run 39182fe996ce
.
..
.dockerenv
anaconda-post.log
bin
dev

# 4、如果我们希望用 -l 列表展示信息，我们就需要加上 -l参数
# 想追加一个命令 -l ===> ls -al
[root@centos7 dockerfile-test]# docker run cmdtest -l
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0009] error waiting for container: context canceled 

# 问题：我们可以看到可执行文件找不到的报错，executable file not found。
# 之前我们说过，跟在镜像名后面的是 command，运行时会替换 CMD 的默认值。
# 因此这里的 -l 替换了原来的 CMD，而不是添加在原来的 ls -a 后面。而 -l 根本不是命令，所以找不到。
# 那么如果我们希望加入 -l 这参数，我们就必须重新完整的输入这个命令：docker run cmdtest ls -al

ENTRYPOINT命令

# 1、编写 dockerfile 文件
[root@centos7 dockerfile-test]# vim dockerfile-entrypoint-test
[root@centos7 dockerfile-test]# cat dockerfile-entrypoint-test
FROM centos:7
ENTRYPOINT [ "ls", "-a" ]

# 2、build 构建镜像
[root@centos7 dockerfile-test]# docker build -f dockerfile-entrypoint-test -t entrypointtest .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/2 : ENTRYPOINT [ "ls", "-a" ]
 ---> Running in 2696231c6071
Removing intermediate container 2696231c6071
 ---> a7fd0c8e7c33
Successfully built a7fd0c8e7c33
Successfully tagged entrypointtest:latest

# 3、执行，发现 ls -a 命令生效
[root@centos7 dockerfile-test]# docker run a7fd0c8e7c33
.
..
.dockerenv
anaconda-post.log
bin
dev
etc

# 4、测试 -l 参数，发现可以直接使用，这里就是一种追加，我们可以明显的知道 CMD 和ENTRYPOINT 的区别了
# 我们的追加命令．是直接拼接在我们的 ENTRYPOINT 命令的后面！
[root@centos7 dockerfile-test]# docker run entrypointtest -l
total 64
drwxr-xr-x   1 root root  4096 May 29 06:11 .
drwxr-xr-x   1 root root  4096 May 29 06:11 ..
-rwxr-xr-x   1 root root     0 May 29 06:11 .dockerenv
-rw-r--r--   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x   5 root root   340 May 29 06:11 dev
......

Dockerfile 中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习方式就是对比他们然后测试效果！

6.5 自定义镜像 Tomcat

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

2、在 /opt/module目录下新建文件夹 mkdir -p build/tomcat

3、在新建目录下创建一个文件 touch readme.txt

4、将 jdk 和 tomcat 安装的压缩包拷贝进上一步目录

5、在 /opt/module/build/tomcat 目录下新建一个 Dockerfile 文件

[root@centos7 dockerfile-test]# cd /opt/module/
[root@centos7 module]# ls
apache-tomcat-9.0.63  java
[root@centos7 module]# mkdir -p build/tomcat
[root@centos7 module]# cd build/tomcat/
[root@centos7 tomcat]# touch readme.txt
[root@centos7 tomcat]# vim Dockerfile
[root@centos7 tomcat]# cat Dockerfile
FROM centos:7
MAINTAINER mstudy<3070265813@qq.com>
#把宿主机当前上下文的readme.txt拷贝到容器/usr/local/路径下
COPY readme.txt /usr/local/readme.txt
#把java与tomcat添加到容器中
ADD jdk-8u261-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.63.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_261
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.63
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.63
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.63/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.63/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.63/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.63/bin/logs/catalina.out

当前文件状态

6、构建镜像

[root@centos7 tomcat]# docker build -t diytomcat .
Sending build context to Docker daemon  154.7MB
Step 1/15 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/15 : MAINTAINER mstudy<3070265813@qq.com>
 ---> Using cache
 ---> e492f4f45bba
Step 3/15 : COPY readme.txt /usr/local/readme.txt
 ---> 43621a1bfb21
Step 4/15 : ADD jdk-8u261-linux-x64.tar.gz /usr/local/
 ---> 0947a7b43430
Step 5/15 : ADD apache-tomcat-9.0.63.tar.gz /usr/local/
......
Successfully built 952d38c9c54f
Successfully tagged diytomcat:latest

7、运行启动 run

[root@centos7 tomcat]# docker run -d -p 9090:8080 --name mydiytomcat -v /opt/module/build/tomcat/test:/usr/local/apache-tomcat-9.0.63/webapps/test -v /opt/module/build/tomcat/tomcat9logs/:/usr/local/apache-tomcat-9.0.63/logs --privileged=true diytomcat
[root@centos7 tomcat]# docker ps
CONTAINER ID   IMAGE       COMMAND                  CREATED 
02aba30fd0e0   diytomcat   "/bin/sh -c '/usr/lo…"   About a minute ago   
[root@centos7 tomcat]# docker exec -it 02aba30fd0e0 /bin/bash
[root@cafdef6e9434 local]# pwd
/usr/local
[root@cafdef6e9434 local]# ls -l
total 52
drwxr-xr-x 1 root  root  4096 May 29 07:45 apache-tomcat-9.0.63
drwxr-xr-x 2 root  root  4096 Apr 11  2018 bin
drwxr-xr-x 2 root  root  4096 Apr 11  2018 etc
drwxr-xr-x 2 root  root  4096 Apr 11  2018 games
drwxr-xr-x 2 root  root  4096 Apr 11  2018 include
drwxr-xr-x 8 10143 10143 4096 Jun 18  2020 jdk1.8.0_261
drwxr-xr-x 2 root  root  4096 Apr 11  2018 lib
drwxr-xr-x 2 root  root  4096 Apr 11  2018 lib64
drwxr-xr-x 2 root  root  4096 Apr 11  2018 libexec
-rw-r--r-- 1 root  root     0 May 29 06:25 readme.txt
drwxr-xr-x 2 root  root  4096 Apr 11  2018 sbin
drwxr-xr-x 5 root  root  4096 Nov 13  2020 share
drwxr-xr-x 2 root  root  4096 Apr 11  2018 src
[root@cafdef6e9434 local]# 

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

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

8、验证测试访问！ curl localhost:9090

[root@centos7 tomcat]# curl localhost:9090
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <title>Apache Tomcat/9.0.63</title>
......

9、发布项目 ( 由于做了卷挂载，我们直接在本地编写项目就可以发布了！)

[root@centos7 tomcat]# pwd
/opt/module/build/tomcat
[root@centos7 tomcat]# ls
apache-tomcat-9.0.63.tar.gz  Dockerfile  jdk-8u261-linux-x64.tar.gz  readme.txt  test  tomcat9logs
[root@centos7 tomcat]# cd test/
[root@centos7 test]# mkdir WEB-INF
[root@centos7 test]# cd WEB-INF/
[root@centos7 WEB-INF]# vim web.xml
[root@centos7 WEB-INF]# cd ..
[root@centos7 test]# vim index.jsp

web.xml

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xmlns="http://java.sun.com/xml/ns/javaee"
		 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
							 http://java.sun.com/xml/ns/javaee/web-app_4_0.xsd"
		 id="WebApp_ID" version="4.0">
    
	<display-name>测试项目testdisplay-name>
    
web-app>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>



	
	


	-----------welcome------------
	<%=" my docker tomcat，mstudy666 "%>
	

	

	<% System.out.println("-------my docker tomcat-------");%>

10、进行测试

curl localhost:9090/test/index.jsp

[root@centos7 test]# cd ..
[root@centos7 tomcat]# cd tomcat9logs/
[root@centos7 tomcat9logs]# ll
......
-rw-r----- 1 root root 7013 5月  29 16:57 catalina.out
......
[root@centos7 tomcat9logs]# cat catalina.out 
......

发现：项目部署成功，可以直接访问！

我们以后开发的步骤：需要掌握Dokcerfile的编写！我们之后的一切都是使用 docker 镜像来发布运行！

6.6 发布自己的镜像

DockerHub

注册dockerhub https://hub.docker.com/signup，需要有一个账号，并且可以登录

# 1、查看登录命令
[root@centos7 ~]# cd /opt/module/build/tomcat/
[root@centos7 tomcat]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

# 2、登录
[root@centos7 tomcat]# docker login -u 15009421862
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

# 3、将镜像发布出去
[root@centos7 tomcat]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
diytomcat            latest      3695ae0019aa   20 hours ago       798MB

[root@centos7 tomcat]# docker push diytomcat
Using default tag: latest
The push refers to repository [docker.io/library/diytomcat]
bf9bc31bc127: Preparing 
ca94198de3ea: Preparing 
4f19307ad483: Preparing 
1480f2e1a1c3: Preparing 
174f56854903: Preparing 
denied: requested access to the resource is denied   # 拒绝：请求的资源访问被拒绝

# 将要发布的镜像改到自己账户名下。我的账户名：15009421862
[root@centos7 tomcat]# docker tag 3695ae0019aa 15009421862/diytomcat:1.0
[root@centos7 tomcat]# docker images
REPOSITORY              TAG       IMAGE ID       CREATED         SIZE
15009421862/diytomcat      1.0       3695ae0019aa   2 minutes ago      798MB
diytomcat              latest      3695ae0019aa   2 minutes ago      798MB

# 再次 push，自己发布的镜像尽量带上版本号
[root@centos7 tomcat]# docker push 15009421862/diytomcat:1.0
The push refers to repository [docker.io/15009421862/diytomcat]
bf9bc31bc127: Pushed 
ca94198de3ea: Pushed 
4f19307ad483: Pushed 
1480f2e1a1c3: Pushed 
174f56854903: Pushed 
1.0: digest: sha256:5a78af91ae2c4a4a2052c4d32cb0113610164759aba2482166aa883f46640a74 size: 1373
# 提交的时候也是按照镜像的层级来进行提交的！

阿里云镜像服务

阿里云容器镜像的就参考官方地址！

1、登录阿里云

2、找到容器镜像服务，然后创建个人版实例

3、创建命名空间

4、创建镜像仓库

5、点击进入这个镜像仓库，可以看到所有的信息

6、测试推送发布

# 1、登录阿里云
[root@aliyun ~]# docker login --username=mc_wdg registry.cn-hangzhou.aliyuncs.com
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
# 2、设置 tag
[root@centos7 tomcat]# docker images
REPOSITORY              TAG       IMAGE ID       CREATED          SIZE
diytomcat               latest    3695ae0019aa   53 minutes ago   798MB
[root@centos7 tomcat]# docker tag 3695ae0019aa registry.cn-hangzhou.aliyuncs.com/mstudy-docker/mstudy-repository:1.0

# 3、推送命令
[root@centos7 ~]# docker push registry.cn-hangzhou.aliyuncs.com/mstudy-docker/mstudy-repository:1.0
The push refers to repository [registry.cn-hangzhou.aliyuncs.com/mstudy-docker/mstudy-repository]
bf9bc31bc127: Pushed 
ca94198de3ea: Pushed 
4f19307ad483: Pushed 
1480f2e1a1c3: Pushed 
174f56854903: Pushed 
1.0: digest: sha256:5a78af91ae2c4a4a2052c4d32cb0113610164759aba2482166aa883f46640a74 size: 1373

7、在阿里云镜像仓库查看效果！

6.7 总结

7、Docker 网络讲解

7.1 理解Docker0

准备工作：清空所有的容器，清空所有的镜像

docker rmi -f $(docker images -qa) 		# 删除全部镜像
docker rm -f $(docker ps -a -q) 		# 删除所有容器

Docker的网络也是十分重要的一个点，希望大家可以认真理解！

我们先来做个测试

查看本地ip ip addr

[root@centos7 ~]# ip addr

这里我们分析可得，有三个网络：

lo 127.0.0.1 			# 本机回环地址
ens33 192.168.10.110	# 虚拟机ip地址
docker0 172.17.0.1 		# docker网桥
# 问题：Docker 是如何处理容器网络访问的？

我们之前安装ES的时候，留过一个问题，就是安装Kibana的问题，Kibana得指定ES的地址！或者我们实际场景中，我们开发了很多微服务项目，那些微服务项目都要连接数据库，需要指定数据库的url地址，通过ip。但是我们用Docker管理的话，假设数据库出问题了，我们重新启动运行一个，这个时候数据库的地址就会发生变化，docker会给每个容器都分配一个ip，且容器和容器之间是可以互相访问的。

我们可以测试下容器之间能不能ping通过：

# 启动tomcat01
[root@centos7 ~]# docker run -d -P --name tomcat01 tomcat

# 查看容器的内部网络地址 ip addr
# 先进入容器，查看ip，如果失败就更新一下apt并安装ip组件
[root@centos7 ~]# docker exec -it ef73fe194dd7 /bin/bash
root@ef73fe194dd7:/usr/local/tomcat# ip addr
bash: ip: command not found
root@ef73fe194dd7:/usr/local/tomcat# apt update && apt install -y iproute2
Get:1 http://security.debian.org/debian-security bullseye-security InRelease [44.1 kB]
Get:2 http://deb.debian.org/debian bullseye InRelease [116 kB] 
......
debconf: falling back to frontend: Readline
Processing triggers for libc-bin (2.31-13+deb11u2) ...
root@ef73fe194dd7:/usr/local/tomcat# read escape sequence  # 按 Ctrl+P+Q 退出

# 查看tomcat01的ip地址，docker会给每个容器都分配一个ip！
[root@centos7 ~]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
6: eth0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
[root@centos7 ~]# 

# 思考，我们的linux服务器是否可以ping通容器内的tomcat ？
[root@centos7 /]# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.094 ms  # 可以ping通！

# linux 可以 ping 通 docker 容器内部

原理

1、我们每启动一个 docker 容器，docker 就会给 docker 容器分配一个 ip，每一个安装了 Docker 的 linux 主机都有一个 docker0 的虚拟网卡。这是个桥接网卡，使用了 veth-pair 技术！

# 我们再次查看主机的 ip addr
[root@centos7 /]# ip addr
......
7: vethf98d2c2@if6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 1a:2a:25:bd:c3:bc brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::182a:25ff:febd:c3bc/64 scope link 
       valid_lft forever preferred_lft forever

# 发现：本来我们有5个网络，我们在启动了一个tomcat01容器之后，多了一个 7 的网络！
# 我们启动了一个tomcat01，主机的ip地址多了一个 7: vethf98d2c2@if6
# 然后我们在tomcat01容器中查看容器的ip是 6: eth0@if7

2、每启动一个容器，linux主机就会多了一对虚拟网卡。

# 我们再启动一个tomcat02观察
[root@centos7 /]# docker run -d -P --name tomcat02 tomcat

[root@centos7 ~]# docker exec -it tomcat02 /bin/bash
root@298a47b9ce43:/usr/local/tomcat# apt update && apt install -y iproute2   
root@298a47b9ce43:/usr/local/tomcat#    # 按 Ctrl+P+Q 退出
[root@centos7 /]# docker exec -it tomcat02 ip addr

# 然后发现linux主机上又多了一个网卡 9: vethe7ae0cd@if8
# 我们看下tomcat02的容器内ip地址是  8: eth0@if9

# 观察现象：
# tomcat01 --- linux主机 7: vethf98d2c2@if6 ---- 容器内 6: eth0@if7
# tomcat02 --- linux主机 9: vethe7ae0cd@if8 ---- 容器内 8: eth0@if9
# 只要启动一个容器，就有一对网卡
# veth-pair 就是一对的虚拟设备接口，它都是成对出现的。一端连着协议栈，一端彼此相连着。
# 正因为有这个特性，它常常充当着一个桥梁，连接着各种虚拟网络设备!
# “Bridge、OVS 之间的连接”，“Docker 容器之间的连接” 等等，以此构建出非常复杂的虚拟网络结构，比如 OpenStack Neutron。

3、我们来测试下 tomcat01 和 tomcat02 容器间是否可以互相 ping 通

[root@centos7 ~]# docker exec -it tomcat02 ping 172.17.0.2
OCI runtime exec failed: exec failed: unable to start container process: exec: "ping": executable file not found in $PATH: unknown

[root@centos7 ~]# docker exec -it tomcat02 /bin/bash
root@298a47b9ce43:/usr/local/tomcat# cat >/etc/apt/sources.list <
deb http://mirrors.ustc.edu.cn/debian stable main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable main contrib non-free
deb http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
EOF

root@298a47b9ce43:/usr/local/tomcat# apt-get update
root@298a47b9ce43:/usr/local/tomcat# apt-get upgrade
root@298a47b9ce43:/usr/local/tomcat# apt-get install inetutils-ping
root@298a47b9ce43:/usr/local/tomcat#    # 按 Ctrl+P+Q 退出
[root@centos7 /]# docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2): 56 data bytes
64 bytes from 172.17.0.2: icmp_seq=0 ttl=64 time=0.105 ms  # 可以 ping 通 
# 结论：容器和容器之间是可以互相访问的。

4、我们来画一个网络模型图

结论：

• tomcat1和tomcat2共用一个路由器 docker0

• 所有的容器不指定网络的情况下，都是docker0路由

• docker会给我们的容器分配一个默认的可用IP

小结

Docker 使用的是 Linux 桥接，在宿主机虚拟一个Docker容器网桥 (docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。

Docker 容器网络就很好的利用了 Linux 虚拟网络技术，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；

Docker 中的网络接口默认都是虚拟的接口。虚拟接口的优势就是转发效率极高（因为 Linux 是在内核中进行数据的复制来实现虚拟接口之间的数据转发，无需通过外部的网络设备交换），对于本地系统和容器系统来说，虚拟接口跟一个正常的以太网卡相比并没有区别，只是他的速度快很多。

只要容器删除，对应网桥一对就没了！

[root@centos7 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
5785e7cc3403   bridge    bridge    local
d96226a28829   host      host      local
faf830b25db9   none      null      local
[root@centos7 ~]# docker network inspect 5785e7cc3403

7.2 --Link

思考一个场景，我们编写一个微服务，数据库连接地址原来是使用ip的，如果ip变化就不行了，那我们能不能使用服务名访问呢？

jdbc:mysql://mysql:3306，这样的话哪怕mysql重启，我们也不需要修改配置了！docker提供了 --link 的操作！

# 我们使用tomcat02，直接通过容器名ping tomcat01，不使用ip
[root@centos7 ~]# docker exec -it tomcat02 ping tomcat01
ping: unknown host  # 发现ping不通

# 如何可以解决呢?
# 通过 --link 即可以解决了网络连通问题
# 我们再启动一个tomcat03，但是启动的时候连接tomcat02
[root@kuangshen ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
a3a4a17a2b707766ad4f2bb967ce1d94f658cd4cccef3bb8707395cdc71fa1e7

# 这个时候，我们就可以使用tomcat03 ping通tomcat02 了
[root@centos7 ~]# docker exec -it tomcat03 /bin/bash
root@298a47b9ce43:/usr/local/tomcat# cat >/etc/apt/sources.list <
deb http://mirrors.ustc.edu.cn/debian stable main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable main contrib non-free
deb http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
EOF

root@298a47b9ce43:/usr/local/tomcat# apt-get update
root@298a47b9ce43:/usr/local/tomcat# apt-get upgrade
root@298a47b9ce43:/usr/local/tomcat# apt-get install inetutils-ping
root@298a47b9ce43:/usr/local/tomcat#    # 按 Ctrl+P+Q 退出

[root@centos7 ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.2): 56 data bytes
64 bytes from 172.17.0.2: icmp_seq=0 ttl=64 time=0.333 ms
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.192 ms

# 再来测试，tomcat03 是否可以ping tomcat01 失败
[root@centos7 ~]# docker exec -it tomcat03 ping tomcat01
ping: unknown host
# 再来测试，tomcat02 是否可以ping tomcat03 反向也ping不通
[root@centos7 ~]# docker exec -it tomcat02 ping tomcat03
ping: unknown host

探究：inspect

思考，这个原理是什么呢？我们进入tomcat03中查看下host配置文件

[root@centos7 ~]# docker exec -it tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.2	tomcat02 298a47b9ce43   # 发现tomcat2直接被写在这里
172.17.0.4	66edaee72c73

# 所以这里其实就是配置了一个 hosts 地址而已！
# 原因：--link的时候，直接把需要link的主机的域名和ip直接配置到了hosts文件中了。

本质探究：–link就是我们在hosts配置中增加了一个 172.17.0.2 tomcat02 298a47b9ce43

docker0问题：它不支持容器名连接访问！

–link早都过时了，我们不推荐使用！我们可以使用自定义网络的方式

7.3 自定义网络

基本命令查看

命令如下：

docker network --help

查看所有网络

[root@centos7 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
5785e7cc3403   bridge    bridge    local
d96226a28829   host      host      local
faf830b25db9   none      null      local

所有网路模式

网络模式	配置	说明
bridge模式	–net=bridge	桥接，默认值，在Docker网桥docker0上为容器创建新的网络
none模式	–net=none	不配置网络，用户可以稍后进入容器，自行配置
container模式	–net=container:name/id	容器和另外一个容器共享网络Network namespace。kubernetes中的pod就是多个容器共享一个网络，用得少，局限大
host模式	–net=host	容器和宿主机共享网络Network namespace
用户自定义	–net=自定义网络	用户自己使用network相关命令定义网络，创建容器的时候可以指定为自己定义的网络

查看一个具体的网络的详细信息

# 命令
[root@centos7 ~]# docker network inspect 5785e7cc3403
[
    {
        "Name": "bridge",
        "Id": "5785e7cc34036b0dc71b043a99b8f257e923f6f2839d21a24069f125b9c173c5",
        "Created": "2022-06-04T10:03:57.938173661+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                	// 默认docker0是管理这个子网范围内的。0~16，也就是 255*255，去掉0个255，我们有65534可以分配的ip
					// docker0网络默认可以支持创建6万多个容器ip不重复
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "298a47b9ce43e84623ce7b43d43bf57d5a194a7895e26a094c701abdb597b8c8": {
                "Name": "tomcat02",
                "EndpointID": "4ac44c722a2c309c76fddecc10177128d714faeda9b5b684e9e6a9a0d25c3395",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            },
            "66edaee72c7302dab8df8e2fa69e8b2a60b8ff42b8649704831bdee9f27f2f63": {
                "Name": "tomcat03",
                "EndpointID": "eb104201cd2dffa2fc2c7d06051bfb7f2fa018ad5ba2ce20121d1c20ef65e7d9",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            },
            "ef73fe194dd74fa36190271c2239567cc95b1f8722c308da2b8bc6ed9fa83102": {
                "Name": "tomcat01",
                "EndpointID": "b995b54030aea4ea8d51ed76104bfd31e852de7eeb42194b42f089077ad3765d",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

自定义网卡

1、删除原来的所有容器

[root@centos7 ~]# docker rm -f $(docker ps -aq)  # 恢复到了最开始的样子
[root@centos7 ~]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:05:2e:90 brd ff:ff:ff:ff:ff:ff
    inet 192.168.10.110/24 brd 192.168.10.255 scope global noprefixroute ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::c2b8:842c:1ae6:6d3e/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
3: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether 52:54:00:81:ea:47 brd ff:ff:ff:ff:ff:ff
    inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
       valid_lft forever preferred_lft forever
4: virbr0-nic: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast master virbr0 state DOWN group default qlen 1000
    link/ether 52:54:00:81:ea:47 brd ff:ff:ff:ff:ff:ff
5: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:69:75:8f:1a brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:69ff:fe75:8f1a/64 scope link 
       valid_lft forever preferred_lft forever

2、接下来我们来创建容器，但是我们知道默认创建的容器都是docker0网卡的

# 我们不配置网络，也就相当于使用了默认值 --net bridge 使用的docker0
# 我们直接启动的命令--net bridge，而这个就是我们的dockero
# docker0网络的特点
# 1.它是默认的
# 2.域名访问不通
# 3.--link 域名通了，但是删了又不行

[root@centos7 ~]# docker run -d -P --name tomcat01 tomcat
# 等价于
[root@centos7 ~]# docker run -d -P --name tomcat01 --net bridge tomcat

# 给 tomcat01 容器安装 ip ping 命令
[root@centos7 ~]# docker exec -it tomcat01 /bin/bash
root@298a47b9ce43:/usr/local/tomcat# cat >/etc/apt/sources.list <
deb http://mirrors.ustc.edu.cn/debian stable main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable main contrib non-free
deb http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
# deb http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
# deb-src http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
EOF

root@298a47b9ce43:/usr/local/tomcat# apt update && apt install -y iproute2   
root@298a47b9ce43:/usr/local/tomcat# apt-get update
root@298a47b9ce43:/usr/local/tomcat# apt-get upgrade
root@298a47b9ce43:/usr/local/tomcat# apt-get install inetutils-ping
root@298a47b9ce43:/usr/local/tomcat#    # 按 Ctrl+P+Q 退出

[root@centos7 ~]# docker commit -a="mstudy" -m="add ip ping" 6ac79b4fc783 tomcat01  #保存为新的镜像

3、我们可以让容器创建的时候使用自定义网络

[root@centos7 ~]# docker network create --help

# 自定义创建的默认default "bridge"
# 自定义创建一个网络网络
# --driver bridge       网络模式，默认桥接，不写也是该值
# --subnet 192.168.0.0/16  子网 
# --gateway 192.168.0.1   网关
[root@centos7 ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
59276e81a57fae8db027d6d1402f6b277e11147528c762134957f1e11e1df6fb
[root@centos7 ~]# docker network ls   # 确认下
NETWORK ID     NAME      DRIVER    SCOPE
5785e7cc3403   bridge    bridge    local
d96226a28829   host      host      local
59276e81a57f   mynet     bridge    local
faf830b25db9   none      null      local
[root@centos7 ~]# docker network inspect mynet

我们自己的网络就创建好了！

# 我们来启动两个容器测试，使用自己的 mynet！
[root@centos7 ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat01
f57906daefa422a1773921ea8a8f4ba65515ea6742fa08b82953763e1a6815d3
[root@centos7 ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat01
f6bcc67c26efeefc3d84a323fbd4fb5afc096cb1b7ae6d20103ae6df7276de87

[root@centos7 ~]# docker ps
CONTAINER ID   IMAGE    PORTS   NAMES
f6bcc67c26ef   tomcat   0.0.0.0:49157->8080/tcp  tomcat-net-02
f57906daefa4   tomcat   0.0.0.0:49156->8080/tcp  tomcat-net-01
# 再来查看下
[root@centos7 ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "59276e81a57fae8db027d6d1402f6b277e11147528c762134957f1e11e1df6fb",
        "Created": "2022-06-04T11:19:06.881581555+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "f57906daefa422a1773921ea8a8f4ba65515ea6742fa08b82953763e1a6815d3": {
                "Name": "tomcat-net-01",
                "EndpointID": "0de1a098c08b4d793d4646b354693a085aeb134bec3bb6f2f098cadfba2e68a9",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "f6bcc67c26efeefc3d84a323fbd4fb5afc096cb1b7ae6d20103ae6df7276de87": {
                "Name": "tomcat-net-02",
                "EndpointID": "94860addf6f599f060d5d25edc24ca2d00728b8d503d9f1073ee7b823eaf10ec",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 我们来测试ping容器名和ip试试，都可以 ping 通
[root@centos7 ~]# docker exec -it tomcat-net-01 ping 192.168.0.3
[root@centos7 ~]# docker exec -it tomcat-net-01 ping tomcat-net-02

# 发现，我们自定义的网络docker都已经帮我们维护好了对应的关系
# 所以我们平时都可以这样使用网络，不使用--link效果一样，所有东西实时维护好，直接域名 ping 通。

好处：

• redis 不同的集群使用不同的网络，保证集群是安全和健康的

• mysql 不同的集群使用不同的网络，保证集群是安全和健康的

7.4 网络连通

docker0和自定义网络肯定不通，我们使用自定义网络的好处就是网络隔离

那关键的问题来了，如何让 tomcat-net-01 访问 tomcat1 ？

# 启动默认的容器，在docker0网络下
[root@centos7 ~]# docker run -d -P --name tomcat-01 tomcat01
168ec290ef67e9dd0ce42248023c3f1ca0b28c133fb62cec8e2d32f5b0fe6e5d
[root@centos7 ~]# docker run -d -P --name tomcat-02 tomcat01
dfd92616401150fd63fbf693e7da3e8e2394f1ca2dac5a59e006f564e294b819

# 查看当前的容器
[root@centos7 ~]# docker ps
CONTAINER ID   IMAGE       PORTS    									 NAMES
dfd926164011   tomcat01     0.0.0.0:49154->8080/tcp, :::49154->8080/tcp   tomcat-02
168ec290ef67   tomcat01   	 0.0.0.0:49153->8080/tcp, :::49153->8080/tcp   tomcat-01
d7ee52a7752d   tomcat01     0.0.0.0:49155->8080/tcp, :::49155->8080/tcp   tomcat-net-02
af5691eb0cf0   tomcat01     0.0.0.0:49156->8080/tcp, :::49156->8080/tcp   tomcat-net-01

# 我们来查看下 network 帮助，发现一个命令 connect
[root@centos7 ~]# docker network --help
[root@centos7 ~]# docker network connect --help

# 我们来测试一下！打通 tomcat-01 mynet (mynet-docker0)
# 命令 docker network connect [OPTIONS] NETWORK CONTAINER
[root@centos7 ~]# docker network connect mynet tomcat-01
[root@centos7 ~]# docker network inspect mynet
# 发现我们的tomcat-01就进来这里了，tomcat-01拥有了双ip
# 连通之后就是将 tomcat-01 放到了 mynet 网络下
# 一个容器两个ip地址，形如 阿里云服务器：公网ip    私网ip

# tomcat-01 可以 ping 通了
[root@centos7 ~]# docker exec -it tomcat-01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.3): 56 data bytes
64 bytes from 192.168.0.3: icmp_seq=0 ttl=64 time=0.127 ms
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.082 ms
# tomcat02 依旧 ping 不通，大家应该就理解了
[root@centos7 ~]# docker exec -it tomcat-02 ping tomcat-net-01
ping: unknown host

结论： 如果要跨网络操作别人，就需要使用 docker network connect 连通！

7.5 实战：部署一个Redis集群

# 创建网卡
[root@centos7 ~]# docker network create redis --subnet 172.38.0.0/16

# 通过脚本创建六个redis配置
[root@centos7 ~]# for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 查看 node-1 的配置文件
[root@centos7 ~]# cd /mydata/redis/node-1/conf/
[root@centos7 conf]# pwd
/mydata/redis/node-1/conf
[root@centos7 conf]# cat redis.conf 

# 启动格式
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

# 启动6个容器
# 6371
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6372
docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6373
docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6374
docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6375
docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6376
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

# 进入一个redis，注意这里是 sh 命令
docker exec -it redis-1 /bin/sh

# 创建集群
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1

# 连接集群
redis-cli -c

# 查看集群信息
cluster info

# 查看节点
cluster nodes

# set a b

# 停止存值的容器

# 然后再次get a，发现依旧可以获取值

# 查看节点，发现高可用完全没问题

我们使用了docker之后，所有的技术都会慢慢的变得简单起来！

8、IDEA整合Docker

8.1 创建项目

1、使用 IDEA 构建一个 SpringBoot 项目

2、编写一个HelloController

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){
        return "hello,mstudy";
    }
}

3、启动测试下，本地访问没问题就可以！

4、打jar包

有了 jar 包，我们就可以作镜像了！ 记得测试一下jar包可以使用吗！

8.2 打包镜像

1、在项目下编写 Dockerfile 文件，将打包好的 jar 包拷贝到Dockerfile同级目录

FROM java:8
# 服务器只有dockerfile和jar在同级目录
COPY *.jar /app.jar
CMD ["--server.port=8080"]
# 指定容器内要暴露的端口
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]

2、将Dockerfile 和 项目的 jar 包上传到 linux 服务器上，构建运行

[root@centos7 ~]# cd /home/
[root@centos7 home]# ls
dockerfile-test  docker-test-volume  Linux  mysql  www
[root@centos7 home]# mkdir idea
[root@centos7 home]# cd idea/
[root@centos7 idea]# ls
[root@centos7 idea]# ll   # 上传完毕后查看
总用量 17144
-rw-r--r-- 1 root root      199 6月   4 19:35 Dockerfile
-rw-r--r-- 1 root root 17550466 6月   4 19:35 helloworld.jar

# 构建镜像
[root@centos7 idea]# docker build -t idea-test .

# 查看镜像
[root@centos7 idea]# docker images

# 运行
[root@centos7 idea]# docker run -d -P --name idea-springboot-test idea-test
d841eebf54dcab98dca391c43b1e93187fd70408ff05634d230475440a0cdab9
[root@centos7 idea]# docker ps
CONTAINER ID   IMAGE     PORTS    										NAMES
d841eebf54dc   idea-test  0.0.0.0:49153->8080/tcp, :::49153->8080/tcp   idea-springboot-test

# 测试访问
[root@kuangshen ~]# curl localhost:49153
[root@kuangshen ~]# curl localhost:49153/hello

我们使用了Dokcer之后，给别人交付的就是一个镜像即可！