Docker 学习笔记 -- kuangshen Docker 视频学习笔记

Docker ！

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 的思想就来自于集装箱!

JRE–多个应用（端口冲突)—原来都是交叉的!

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

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

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

2. Docker的历史

2010年，几个搞 IT 的年轻人，就在美国成立了一家公司 dotcloud

做一些 pass 的云计算服务! LXC 有关的容器技术!

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

Docker 刚刚诞生的时候，没有引起行业的注意! dotCloud,就活不下去!

开源

开发源代码!

2013年，Docker 开源!

Docker越来越多的人发现了docker 的优点!火了，Docker 每个月都会更新一个版本!

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

Docker 为什么这么火?十分的轻巧!

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

虚拟机:在 window 中装一个 VMware，通过这个软件我们可以虚拟出来一台或者多台电脑！笨重！虚拟机也是属于虚拟化技术，Docker容器技术，也是一种虚拟化技术!

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

到现在，所有开发人员都必须要会 Docker !

聊聊Docker

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

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

官方文档：https://docs.docker.com/

3. Docker的用处

之前的虚拟机

虚拟机技术的缺点：

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

容器化技术

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

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

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

DevOps（开发、运维）

应用更快速的交付和部署

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

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

更便捷的升级和扩缩容

使用了 Docker 之后，我们部署应用就和搭积木一样!项目打包为一个镜像，扩展服务器A、服务器B

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的。更高效的计算资源利用∶
Docker 是内核级别的虚拟化，可以再一个物理机上可以运行很多的容器实例!服务器的性能可以被压榨到极致。

4. Docker的安装

4.1 Docker的基本组成

镜像（Image）：

镜像就好比一个模板，可以通过模板创建容器服务，通过这个镜像创建很多个容器（最终服务或项目运行就是在容器中）

容器（Container）：

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

停止，删除、基本命令!

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

仓库（repository）：

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

仓库分为公有仓库和私有仓库!

Docker Hub(默认是国外的)

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

4.2 Docker的安装

环境准备

1. Linux命令基础
2. CentOS
3. Xshell远程连接

环境查看

# 系统内核查看
[root@iZbp160rjf7ztq5oshw6m0Z ~]# uname -r
4.18.0-193.14.2.el8_2.x86_64

# 系统版本查看
[root@iZbp160rjf7ztq5oshw6m0Z ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="8 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="8"
PLATFORM_ID="platform:el8"
PRETTY_NAME="CentOS Linux 8 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:8"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

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

安装

跟着官方的帮助文档

1. 卸载旧版本

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

2. 安装依赖

yum install -y yum-utils

3. 设置镜像仓库

yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
    # 默认是从国外镜像，安装很慢，不推荐使用
    
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
	# 使用阿里云镜像仓库，国内推荐设置阿里云镜像仓库

4. 安装

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

5. 启动 Docker

systemctl start docker

6. 查看 Docker 是否启动成功

docker version

7. 测试 Hello world

docker run hello-world
# Docker 会先查找本机是否有这个镜像，有则直接运行，没有则尝试拉取这个镜像
# 这里就是先拉取为本地镜像，然后启动

8. 查看下载的hello world 镜像
   docker images

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   6 weeks ago   13.3kB

了解：卸载docker

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

# 2. 删除镜像
rm -rf /var/lib/docker

# /var/lib/docker docker的默认工作路径

4.3 配置阿里云镜像加速

1. 找到阿里云镜像加速

​ 弹性计算 -> 容器镜像服务 ->镜像工具 -> 镜像加速器

2. 配置使用
   注意：每个人的阿里云账号的加速地址都是不一样的，请使用自己的加速地址

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

4.4 HelloWorld流程

4.5 底层原理

4.5.1 docker 是怎么工作的

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

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

4.5.2 docker 为什么比 VM 快

1. Docker比虚拟机更少的抽象层

2. docker 利用宿主机的内核，VM 需要的是 Guest OS( GuestOS：VM（虚拟机）里的的系统（OS）)

Docker 新建一个容器的时候，不需要像虚拟机一样重新加载一个操作系统内核，直接利用宿主机的操作系统，而虚拟机是需要加载 Guest OS。

5. Docker的常用命令

5.1 帮助命令

docker version 			# docker 版本信息
docker info			    # docker 系统信息
docker 命令 --help	    # docker 帮助命令

文档查询：https://docs.docker.com/engine/reference/commandline/docker/

5.2 镜像命令

5.2.1 查看本机的所有镜像

docker images

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   6 weeks ago   13.3kB

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

# 可选参数
-a / --all 		列出所有镜像
-q / --quite 	只显示镜像id

5.2.2 搜索镜像

docker search

docker search 镜像名

# 可选项 
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
      

# 搜索STAR数大于3000的镜像
docker search mysql --filter=STARS=3000

5.2.3 下载镜像

docker pull

docker pull 镜像名 [:tag]

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker pull mysql

Using default tag: latest				# 不指定tag，默认下载最新版
latest: Pulling from library/mysql
b380bbd43752: Pull complete 			# 分层下载，docker image的核心-联合文件系统
f23cbf2ecc5d: Pull complete 
30cfc6c29c0a: Pull complete 
b38609286cbe: Pull complete 
8211d9e66cd6: Pull complete 
2313f9eeca4a: Pull complete 
7eb487d00da0: Pull complete 
4d7421c8152e: Pull complete 
77f3d8811a28: Pull complete 
cce755338cba: Pull complete 
69b753046b9f: Pull complete 
b2e64b0ab53c: Pull complete 
Digest: sha256:6d7d4524463fe6e2b893ffc2b89543c81dec7ef82fb2020a1b27606666464d87 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #下载的真实地址

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

指定版本下载（版本号必须存在）

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker pull mysql:5.7 
5.7: Pulling from library/mysql
b380bbd43752: Already exists 
f23cbf2ecc5d: Already exists 
30cfc6c29c0a: Already exists 
b38609286cbe: Already exists 
8211d9e66cd6: Already exists 
2313f9eeca4a: Already exists 
7eb487d00da0: Already exists # 能看出分层的优势，相同的文件公用，只下载不同的文件
a71aacf913e7: Pull complete 
393153c555df: Pull complete 
06628e2290d7: Pull complete 
ff2ab8dac9ac: Pull complete 
Digest: sha256:2db8bfd2656b51ded5d938abcded8d32ec6181a9eae8dfc7ddf87a656ef97e97
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

5.2.4 删除镜像

docker rmi

#1.删除指定的镜像id
docker rmi -f  镜像id
#2.删除多个镜像id
docker rmi -f  镜像id 镜像id 镜像id
#3.删除全部的镜像id
docker rmi -f  $(docker images -aq)

5.3 容器命令

我们有了镜像才能创建容器，这里下载一个 centos 镜像测试学习

5.3.1 拉取镜像

拉取一个CentOS镜像

docker pull centos

5.3.2 启动容器

docker run

docker run [可选参数] 镜像名

# 参数说明
    --name="名字"			   指定容器的名字
    -d						后台运行
    -it						使用交互方式运行，并进入容器
    -p						指定容器的端口（四种方式
    	-p ip:主机端口:容器端口
    	-p 主机端口:容器端口
    	-p 容器端口
    	容器端口
    -P						随机指定容器端口
    
# 测试
docker run -it centos /bin/bash	# 启动并进入容器，使用bash交互
# centos 基础的版本，很多命令不完善

5.3.3 退出容器

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

5.3.4 查看运行的容器

docker ps [options]

docker ps [可选参数]

# 空		列出当前运行的容器
# -a	 	列出所有容器
# -n=？		列出最近创建的n个容器
# -q	 	只列出容器id
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
826f7cbb95ee   centos    "/bin/bash"   6 minutes ago   Up 6 minutes             zen_margulis

5.3.5 删除容器

docker rm [options]

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

5.3.6 启动和停止容器

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

5.4 其他常用命令

5.4.1 日志

docker logs

docker logs [可选项] 容器id

# 可选项
-f : 跟踪日志输出

--since :显示某个开始时间的所有日志

-t : 显示时间戳

--tail :仅列出最新N条容器日志

5.4.2 后台启动的坑

# 命令docker run -d 镜像名!

[root@kuangshen/]# docker run -d centos

# 问题docker ps，发现centos停止了

# 常见的坑: docker容器使用后台运行，就必须要有要一个前台进程，docker发现没有应用，就会自动停止

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

5.4.3 查看容器中的进程

docker top 容器id

5.4.4 查看容器的元数据

docker inspect [可选项] 容器id | 容器名字

# 可选项
-f :指定返回值的模板文件。

-s :显示总的文件大小。

--type :为指定类型返回JSON。

5.4.5 进入后台运行的容器

我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置

# docker exec 在运行中的容器执行命令
# 此方法连接后退出不会停止容器的运行

docker exec -it 容器id CAMMAND（分配终端还是执行脚本）

# docker attach 连接到正在运行中的容器
# 连接后退出会停止容器的运行

docker attach 容器id

5.4.6 容器与主机之间拷贝数据

docker cp CONTAINER:SRC_PATH DEST_PATH|-

docker cp SRC_PATH|- CONTAINER:DEST_PATH

# 将主机/www/runoob目录拷贝到容器96f7f14e99ab的/www目录下。
docker cp /www/runoob 96f7f14e99ab:/www/

# 将主机/www/runoob目录拷贝到容器96f7f14e99ab中，目录重命名为www。
docker cp /www/runoob 96f7f14e99ab:/www

# 将容器96f7f14e99ab的/www目录拷贝到主机的/tmp目录中。
docker cp  96f7f14e99ab:/www /tmp/

5.5 小结

对于更多的 docker 命令，可以去菜鸟教材查询：
菜鸟命令大全

6. Docker 小练习

6.1 部署Nginx

# 1. 拉取镜像（指定版本需要先去dockerHub搜索查看版本）
docker pull nginx

# 2. 查看镜像是否下载成功
docker images

# 3. 启动容器
# 后台运行，使用2233端口映射nginx的80端口，名为nginx——test
docker run -it -p 2233:80 --name nginx_test nginx

# 4. 本地测试访问
curl localhost:2233 

# 5. 外网测试
http://服务器公网ip:2233

端口暴露的理解：

6.2 部署Tomcat

#官方的使用
docker run -it -rm tomcat:9.0

# 我们之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it --rm，一般用来测试，用完就删除

# 1. 下载在启动
docker pu1l tomcat
# 启动运行
docker run -d -p 2234:8080 --name tomcat_test tomcat

# 测试访间没有间题

# 进入容器
[root@kuangshen home]# docker exec -it tomcat01 /bin/bash
# 发现问题:
# 1. 1inux命令少了;
# 2. webapps没有东西。阿里云镜像的原因。默认是最小的镜像，所有不必要的都剔除掉。
# 目的是保证最小可运行的环境!

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

6.3 部署 ES + Kibana

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

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

# 启动了1inux就卡住了
# docker stats查看cpu的状态

# 测试一下es是够成功了
[root@kuangshen home]# cur1 localhost: 9200
{
    "name" : "7e2469973535"，
    "cluster_name” : "docker-cluster"",
    "cluster_uuid"" : ""eJ1FbVtzs91ERQ71EQjoug",
    "version" :{
        "number":"7.6.2 "",
        "build_flavor” : "defau1t"",
        "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-betal""
    	}，
    "tagline" : "You Know.for Search"
}

# es是十分耗内存的 解决：
# 添加 ’-e ES_JAVA_OPTS="-Xms128m -Xmx512m" ‘ 配置ElasticSearch的虚拟机占用的内存大小。

思考：

7. Docker 的可视化工具

作为了解，一般都不会使用可视化工具

• portainer
• Rancher（CI/CD 再用）

7.1 portainer

# 下载 启动
docker run -d -p 8000:8000 -p 9443:9443 --name portainer_test \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:latest
    
# 连接 注册登录 
http://服务器ip:9443
user: admin
password: asdfghjkl

# 测试 使用

可视化面板平时不会使用，自己测试玩玩！

8. Docker 镜像详解

8.1 镜像是什么

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

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

如何得到镜像︰

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

8.2 镜像加载原理

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 里的才几百M？

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

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

分层理解

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

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

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

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

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

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

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

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

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

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

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

特点

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

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

8.3 commit 镜像

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

# 命令和 git 原理类似
docker commit -m="提交的信息" -a="作者" 容器ID 目标镜像名字[:tag]

实战练习

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED       SIZE
nginx                    latest    04661cdce581   4 days ago    141MB
portainer/portainer-ce   latest    a1c22f3d250f   2 weeks ago   252MB
tomcat                   latest    b0e0b0a92cf9   3 weeks ago   680MB
mysql                    5.7       938b57d64674   3 weeks ago   448MB
hello-world              latest    feb5d9fea6a5   7 weeks ago   13.3kB

# 1. 启动一个 tomcat 我就启动之前的一个 tomcat 容器
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker ps -a
CONTAINER ID   IMAGE                           COMMAND                  CREATED        STATUS                    PORTS     NAMES
0e118541147c   tomcat                          "catalina.sh run"        2 days ago     Exited (143) 2 days ago             tomcat_test
# 2. 新启动的 tomcat 用外网访问的没有内容的，因为 webapps 里没有东西
# 这个容器是我之前测试的时候已经复制东西过来了，所以就直接用这个了
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker start 0e118541147c

# 3. 提交一个新镜像
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker commit -a="timmi" -m="add webapps files" 0e118541147c tomcat_commit:1.0
sha256:846c6917d72209b1b196137ac547847bcf133d6edcd21af0ad2531a39458935e

# 4. 查看新提交的镜像
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
tomcat_commit            1.0       846c6917d722   7 seconds ago   684MB
tomcat                   latest    b0e0b0a92cf9   3 weeks ago     680MB

# 5. 启动这个镜像测试
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker run -d -p 8080:8080 tomcat_commit:1.0
# 这里启动需要带上 Tag, 否则会去 Docker Hub 上搜索 latest（最新版）

9. Docker 的容器数据卷

9.1 什么是容器数据卷

docker的理念回顾
将应用和环境打包成一个镜像!

数据：如果数据都在容器中，那么我们容器删除，数据就会丢失!

需求∶数据可以持久化

MySQL，容器删了，删库跑路!需求:MySQL 数据可以存储在本地!

容器之间可以有一个数据共享的技术!

Docker容器中产生的数据，同步到本地!这就是卷技术! 目录的挂载，将我们容器内的目录，挂载到Linux上面！

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

9.2 数据卷的使用

9.2.1 直接使用命令挂载

docker run -v 主机目录:容器目录 [][]……

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

# 解释：
# 启动成功后使用 docker inspect 容器 id 命令查看是否挂载成功
# 查看 Mounts 对应的 Value
"Mounts": [
        {
            "Type": "bind",
            "Source": "/home/ceshi",
            "Destination": "/home",
            "mode": "",
            "Rw": "",
            "Propagation": "rprivate"
        }
]

挂载成功后，便可以在主机挂载目录上修改，容器目录就会自动同步修改

9.2.2 MySQL的挂载实战

使用 Docker 拉取 MySQL 5.7版本，后续启动

# 1. 启动mysql，注意 mysql 需要配置密码，使用-e 配置
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker run -d -p 3306:3306 \
-v /home/mysql/conf:/etc/mysqlconf.d -v /home/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 --name=mysql_test mysql:5.7

# 解释
-d 后台启动
-p 指定端口
-v 卷挂载，可以挂载多个目录
-e 配置环境
--name 设置容器名字

# 2. 启动成功后，使用第三方数据库连接软件连接测试
# 这里使用 navicat 连接

这时，我们将 MySQL 容器删除，挂载到本地的数据依旧不会丢失

注意，在主机挂载目录里手动删除的数据，在容器里也会被删除

9.3 具名和匿名挂载

匿名挂载：不指定主机的挂载目录，-v 后面直接就是容器的挂载目录-v /etc/xxxx

具名挂载：不指定主机的挂载目录，但是-v 后面与容器的挂载目录之间给容器挂载目录取一个名字 -v name:/etc/xxxx

查看挂载的卷

docker volume [command]

Commands:
  create      创建一个数据卷
  inspect     查看指定数据卷的详细信息
  ls          查看所有数据卷
  prune       删除所有未使用的数据卷
  rm          删除数据卷
  

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker volume ls
DRIVER    VOLUME NAME
local     portainer_data

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker volume inspect portainer_data
[
    {
        "CreatedAt": "2021-11-12T16:44:46+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/portainer_data/_data",
        "Name": "portainer_data",
        "Options": null,
        "Scope": "local"
    }
]

所有的 docker 容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes /xxxxx/_data
我们通过具名挂载可以方便的找到我们的一个卷，大多数情况在使用的匿名挂载

拓展:

# 通过 -v 容器内路径:ro、rw ，能够改变读写权限
ro：readonly		# 只读
rw：readwrite		# 可读可写

#一旦这个了设置了容器权限，容器对我们挂载出来的内容就被限定了!
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro nginxdocker \
run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

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

10. Docker File

10.1 初识 Docker File

Docker File 就是用来构建 Docker 镜像的构建文件！是一个命令脚本

通过这个命令脚本可以生成镜像，镜像是一层一层的，脚本里一个命令就相当于一层！

# 1. 创建 Docker file 文件，名字可以随意，但是建议取 Dockerfile
# 因为 docker 在构建镜像时会默认寻找这个文件
# 脚本的指令：指令全部大写 参数

FROM centos

VOLUME ["volume01","volume02"]

CMD echo "-----end line-----"

CMD /bin/bash

使用 docker build 命令生成镜像：

docker build -f dockerfile_test -t timmi/centos:1.0 .

# 解释
-f 	dockerfile文件的路径
-t 	指定镜像名字和版本号
. 	表示生成在当前目录

查看镜像：

[root@iZbp160rjf7ztq5oshw6m0Z home]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED          SIZE
timmi/centos             1.0       6cf7aff6e83a   14 minutes ago   231MB
centos                   latest    5d0da3dc9764   8 weeks ago      231MB

启动自己生成的镜像：

docker run -it --rm 6cf7aff6e83a /bin/bash

这两个挂载目录是匿名挂载，通过 docker inspect 命令查看主机挂载的目录

Docker File 文件可以很方便的在进行创建多个容器的时候就进行自动挂载，这种方法十分常用

10.2 数据卷容器

即多个容器共享一个数据卷，具体就是先创建一个容器（可以称为父容器），挂载好数据卷，后面创建的容器直接共享父容器的挂载，这个父容器就叫做数据卷容器

# 1. 创建父容器，利用上面生成自己的镜像
docker run -it --name centos01 timmi/centos:1.0

# 2. 创建子容器
docker run -it --name centos02 --volumes -from centos01 timmi/centos:1.0

# 这样 centos01 和 centos02 就共享同一个数据卷，即时父容器被删除了，只要还有容器仍在使用这个数据卷，这个数据卷就不会失效

所有，可以实现多个 MySQL 实现数据共享

# 
docker run -d -p 3306:3306 -v /etc/mysql/conf.d -v /var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 --name mysql_father mysql:5.7

# 
docker run docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 \
--volumes -from mysql_father --name mysql_son mysql:5.7

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

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

10.3 全面理解 Docker file

10.3.1 docker file 介绍

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

构建步骤:

1. 编写一个docker file 文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像( Docker Hub、阿里云镜像仓库!)

很多官方镜像只是基础镜像，很多功能没有，需要自行构建补充！

10.3.2 docker file 构建

基础知识：

1. 每个保留关键字（指令）都是必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交!

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

Docker镜像逐渐成为企业交付的标准，必须要掌握!

步骤：开发，部署，运维……缺一不可!

Docker File : 构建文件，定义了一切的步骤，源代码

Docker images : 通过 Docker File 构建生成的镜像，最终发布和运行的产品!

Docker 容器: 容器就是镜像运行起来提供服务器

Docker File 指令

FROM			# 基础镜镜像,一切从这里开始构建
MAINTAINER		# 镜境像是谁写的,姓名 + 邮箱
RUN				# 境像构建的时候需要运行的命令
ADD				# 添加内容 例如：加入一个 tomcat镜像,这个tomcat 压缩包!参数就是这个压缩包
wORKDIR			# 镜像的工作目录
VOLUME			# 挂载的目录
EXPOSE			# 暴露端口配置
CMD				# 指定这个容器启动的时候要运行的命令,只有最后一个会生效，可被替代
ENTRYPOINT		# 指定这个容器启动的时候要运行的命令,可以追加命令
ONBUILD			# 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 的指令。触发指令。
COPY			# 类似 ADD ,将我们文件拷贝到镜像中
ENV				# 构建的时候设置环境变量!

实战 创建自己的centos

# 1. 编写 Docker File 文件
FROM centos
MAINTAINER tiimme<1976214615@qq.com>

ENV MYPATH "/usr/local"
WORKDIR $MYPATH

RUN yum -y install vim

EXPOSE 80

CMD echo $MYPATH
CMD /bin/bash

# 2. 使用 docker file 构建镜像
docker build -f mydockerfile-centos -t mycentos-with-vim:0.1 .

# Successfully built 998fb54b2e49
# Successfully tagged mycentos-with-vim:0.1

# 3. 启动测试

还可以使用 docker history 命令查看镜像的构建历史

CMD 和 ENTRYPOINT 的区别

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

11. Docker 网络

11.1 理解 Dokcer0

查看 Docker0

ifconfig / ip addr

三个网络，Docker0 就是 Docker 创建的默认网卡

思考：docker 是如何处理容器网络访问的？

# 启动一个 tomcat 测试 
docker run -d -P--name tomcat01 tomcat

# 查看容器的 ip 发现容器启动的时候会得到一个eth0@if262 ip地址，docker分配的!
docker exec -it tomcat01 ip addr

1: lo:<L0OPBACK ,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 1o
valid_1ft forever preferred_ift forever
261: eth0@if262:<BROADCAST,MLTICAST,UP ,LOWER_UP> mtu 1500 qdisc noqueue state uP group default
link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid o
inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
valid_lft forever preferred_lft forever

# 思考：1iunx 能不能 ping 通容器内部？
ping 172.18.0.2

PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 tt1=64 time=0.067 ms
64 bytes from 172.18.0.2: icmp_seq=2 tt1=64 time=0.055 ms

# linux可以ping通docker容器内部

原理

我们每启动一个 docker 容器，docker 就会给 docker 容器分配一个 ip，我们只要安装了docker，就会有一个网卡 docker0 桥接模式，使用的技术是 veth-pair 技术!

再次测试ip addr 发现多了一个网卡，这是前面启动的 tomcat 容器的网卡，我们在启动一个 tomcat 容器，会发现网卡又多了一个

# 我们发现这个容器带来网卡,都是一对对的
# veth-pair就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连
# 正因为有这个特性，evth-pair 充当一个桥梁，连接各种虚拟网络设备的
# openStack，Docker 容器之间的连接，0VS的连接，都是使用veth-pair 技术

最后，测试 tomcat01 能否 ping 通 tomcat02 发现也是可行的

网络模型图如下：

结论: tomcat01 和 tomcat02 是公用的一个路由器, docker0。

所有的容器不指定网络的情况下，都是 docker0 路由的，docker 会给我们的容器分配一个默认的可用IP

小结

Docker 中的所有的网络接口都是虚拟的。虚拟的转发效率高!(内网传递文件!)

只要容器关闭了, 对应网桥一对就没了!

11.2 – link

思考：我们编写了一个微服务，database url=ip:，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以名字来进行访问容器?

# 能否直接通过容器名 ping 通？
docker exec -it tomcat02 ping tomcat01 
ping: tomcato1: Name or service not known

# 如何可以解决呢?
# 通过--1ink既可以解决了网络连通间题
docker run -d -p --name tomcat03 --1ink tomcat02 tomcat

# 再 ping 一次
docker exec -it tomcat03 ping tomcat02

PING tomcat02 (172.18.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.18.0.3): icmp_seq=1 tt1=64 time=0.100 ms64 bytes from tomcat02 (172.18.0.3): icmp_seq=2 ttl=64 time=0.066 ms64 bytes from tomcat02 (172.18.0.3): icmp_seq=3 ttl=64 time=0.067 ms

# 那么反向可以 ping 通吗?
docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known
# 显然是不行的

本质探究：

其实这个tomcat03就是在本地配置了tomcat02的配置?

# 查看hosts配置,在这里原理发现!
docker exec -it tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1 		localhost ip6-localhost ip6-1oopback
fe00::0 	ip6-localnet
ff00::0 	ip6-mcastprefix
ff02::1 	ip6-al1nodes
ff02::2	 	ip6-a11routers
172.18.0.3 	tomcat02 312857784cd4
172.18.0.4	5ca72d80ebb0

总结：

• --link 就是我们在 hosts 配置中增加了一个172.18.0.3 tomcat02 312857784cd4
• 我们现在玩Docker 已经不建议使用--link了!
• 自定义网络!不适用 docker0 !
• docker0 问题:他不支持容器名连接访问!

11.3 自定义网络

11.3.1 查看 docker 网络

docker network

docker network ls

网络模式：

• bridge：桥接模式（ docker0 默认的模式，自定义网络也是使用这种模式）
• None：不配置网络
• host：与主机共享网络
• container：容器网络联通（局限多，很少使用）

#我们直接启动的命令--net bridge，而这个就是我们的docker0
docker run -d -p --name tomcat01 tomcat
docker run -d -p --name tomcat01 --net bridge tomcat

# docker0 特点:默认,域名不能访问, --link可以打通连接!

# 我们可以自定义一个网络!
# --driver bridge
#--subnet 192.168.0.0/16
# --gateway 192.168.0.1

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1mynet

docker network ls
NETWORKID		NAME					DRIVER	SCOPE
5a008c015cac	bridge					bridge	1ocal	
db44649a9bff	composetest_default		bridge	loca1
ae2b6209c2ab	host					host	local
eb21272b3a35	mynet					bridge	local

至此，我们自己的网络就创建好了

使用我们自己的网络创建容器：

# tomcat01 
docker run -d -P--name tomcat-net-01 --net mynet tomcat
19f243d9c95bd771979a5e0bb3033dbf3f9ceacdd34ce231a5d6982573706ca9

# tomca02
docker run -d -P --name tomcat-net-02 --net mynet tomcat
aff29160a5e2ea5594c4950f34cd7c932c8e8cfae54eec979863ae09947bee73

# 再次查看我们的网络
docker network inspect mynet

再次 ping 测试

# 通过 ip ping 容器
docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3)56(84)bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 tt1=64 time=0.085 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.070 msAc
--- 192.168.0.3 ping statistics ---
2 packets transmitted，2 received，0% packet loss,time 999msrtt min/avg/max/mdev = 0.070/0.077/0.085/0.011 ms

# 通过容器名 ping
# 现在不使用 --1ink 也能 ping 容器名了
docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3)56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.055ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.063 mS

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络!

好处︰

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

11.4 网络连通

如何使 tomcat01 与 tomcat-net-01连通？

docker network connect

测试：

# 使用 docker network connect 命令
docker network connect mynet tomcat01

# 查看 mynet 网络详细信息
docker network inspect mynet

发现mynet 网络里多了一个tomcat01 的容器，连通命令就是把 tomcat01 加入到 mynet 网络中

这就是一个容器，两个 ip 地址

**结论：**假设要跨网络操作容器，就需要使用docker network connect 连通！

再次 ping 测试

# 通过 ip ping 容器
docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3)56(84)bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 tt1=64 time=0.085 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.070 msAc
--- 192.168.0.3 ping statistics ---
2 packets transmitted，2 received，0% packet loss,time 999msrtt min/avg/max/mdev = 0.070/0.077/0.085/0.011 ms

# 通过容器名 ping
# 现在不使用 --1ink 也能 ping 容器名了
docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3)56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.055ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.063 mS

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络!

好处︰

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

11.4 网络连通

如何使 tomcat01 与 tomcat-net-01连通？

docker network connect

测试：

# 使用 docker network connect 命令
docker network connect mynet tomcat01

# 查看 mynet 网络详细信息
docker network inspect mynet

发现mynet 网络里多了一个tomcat01 的容器，连通命令就是把 tomcat01 加入到 mynet 网络中

这就是一个容器，两个 ip 地址

**结论：**假设要跨网络操作容器，就需要使用docker network connect 连通！

12. 学习感悟

本来是为了部署Adachi bot才去学习的Docker，学习完 Docker 真香！学完一遍后，使用别人的镜像部署那是顺手拈来，不过对于的如何构建自己的项目的 Docker 镜像还是不太清晰，自己日常使用就没问题，后续应该会继续学习 Docker compose 和 Docker swarm的内容。
原视频学习地址：https://www.bilibili.com/video/BV1og4y1q7M4