Docker（详解）

一、简介

基于GO语言实现的开源容器项目。利用操作系统本身已有的机制和特性，可以实现远超传统虚拟机的轻量级虚拟化。它是内核级的虚拟化。期望“一次封装，到处运行”。
利用docker创建的运行环境叫做docker容器，容器通过docker镜像创建的，docker镜像文件可以放在私有仓库中也可以放在共有仓库中。

二、特点

1. 使用者便利：
   对于开发者来说：之前在一个环境想要运行一个程序，需要配置安装环境变量、部署tomcat等，现在可以通过docker镜像运行，通过拉取镜像的方法将打好的war包丢进去。实现一次编译到处运行。
   对于运维人员来说： 可以在隔离容器中并行运行和管理应用，获得更好的计算密度。

2. 应用效率高：支持高并发运行，高并发访问取决于你的应用。
   用户只需要几分钟，就可以把程序“docker”化。Docker依赖于“写时复制”（copy-on-write）模型，使修改应用程序也非常迅速，可以达到随心所致，代码即改的境界。
   随后，就可以创建容器来运行应用程序。大多数docker容器只需要不到1秒即可启动。由于去除管理程序的开销，docker容器拥有很高的性能，同时同一台宿主机中也可以运行更多的容器，使用户尽可能的充分利用系统资源。

3. 职责明确
   使用docker,开发人员只需要关心容器中运行的应用程序，运维人员只需要关心如何管理容器，docker设计的目的就是加强开发人员写代码的开发环境与应用程序要部署的生产环境一致性，从而降低“开发时一切正常，肯定是运维的问题（测试环境都是正常的，上线后出问题就归结为肯定是运维的问题）”

4. 结构完整
   docker的目标之一就是缩短代码的开发、测试、部署、上线运行的周期，让你的应用程序具备可移植性、易于构建、易于写作。（通俗一点说就是，docker里面像一个盒子，里面可以有很多物件，如果需要这些物件的可以直接将该盒子拿走，不需要从该盒子一件件的取）。

5. 契合微服务框架
   docker还鼓励面向服务的体系结构和微服务架构。docker推荐单个容器只运行一个应用程序或进程，这样就形成一个分布式的应用程序模型，这种模型下，应用程序或者服务都可以表示为一系列内部互联的容器，从而使分布式部署应用程序，扩展或调试应用程序都变得非常简单，同时也提高了程序的内省性。（当然，可以在一个容器中运行多个应用程序。）

6. 更高效的计算资源利用
   Docker是内核级别的虚拟化，可以在一个物理机上运行很多容器实例，服务器性能压榨到极致。

7. 补充
   发布项目打包成jar包的同时携带相关环境（镜像），直接部署到Docker仓库中，下载我们发布的镜像直接运行即可。不使用docker的话需要打包成jar包，然后运维进行环境配置和保证程序的运行。
   docker核心思想是打包装箱进行隔离，不需要担心端口冲突，原来会有交叉。docker通过隔离机制，可以将服务器运行到极致。
   本质：隔离机制+镜像

三、Docker VS 虚拟机

1. 结构区别：
   
   VM：虚拟出一套硬件，运行一个完整的操作系统，在这个系统上安装和运行软件，效率低，内部安装不同的整个操作系统，冗余步骤多，启动很慢！
   容器化技术：不是一个完整的操作系统，容器内的应用直接运行在宿主机，容器没有自己的内核，也没有虚拟我们的硬件，所以很轻便，直接运行需要的环境，image镜像（准备应用所需要的环境），不依赖于第三方容器，一体化封装。

2. 应用区别：
   
   Vm：应用安装大、需要启动虚拟机系统所以开启速度慢，分钟级别，集成麻烦，面向硬件，适用于独享需求好。
   Docker：安装小，启动快，秒级别，集成效果好，面向内核、软件。
   

四、Docker 架构（仓库+宿主机）

1. Docker daemon(Docker 守护进程)
   运行在宿主机（DOCKER_HOST）的后台进 程，可以通过docker客户端与之通信。
2. Client(Docker 客户端)
   Docker客户端是Docker的用户界面，可以接受用户命令和配置标识，并与Docker daemon通信。上图中docker build等都是docker的相关命令。
3. Images(Docker 镜像)
   Docker镜像是一个只读模板，可以通过这个模板来创建容器服务。它包含创建docker容器的说明，它和系统安装光盘有点像——我们使用系统安装光盘安装系统，同理，我们使用docker镜像运行docker镜像中的程序。只有创建才可以写，完整的环境使用镜像运行镜像中的容器。
4. Container(容器)
   通过镜像创建，正在运行的应用或代码。容器是镜像的可运行实例。镜像和容器的关系类似于面向对象中，类和对象的关系，可以通过docker API 或者 CLI命令来启停、移动、删除容器。docker利用容器技术，独立运行一个或者一个组应用，通过镜像来创建。
5. Registry(仓库)
   专门管理镜像，远程仓库通过远程访问的方式来访问。Docker Registry是一个集中存储与分发镜像的服务，我们构建完docker镜像后，就可在当前宿主机上运行，但如果想要在其他机器上运行这个镜像，就需要手动拷贝，此时可以借助docker registry来避免镜像的手动拷贝。
   一个docker registry可以包含多个docker仓库，每个仓库包含多个镜像标签，每个标签对应一个docker镜像，这和maven仓库有点类似。如果把docker registry比作maven仓库的话，那么docker仓库就可以理解为某jar包的路径，而镜像标签则可以理解为jar包版本号。
   仓库分为公有和私有仓库，DockerHub。

五、Docker 安装与启动

可以参考docker官方文档：https://docs.docker.com/
中文版：https://www.coonote.com/docker/docker-tutorial.html

1. 环境准备
   a. 会linux基础
   b. CentOS 7
   c. 链接服务器的软件（我使用的是final Shell）
2. 环境查看
   保证自己的系统内核是3.10以上的！！！

# 查看系统环境
 uname -r
# 查看系统具体性能配置
 cat /etc/os-release 

3. 帮助文档

# 1、卸载旧的版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \ 
docker-engine 

4. 安装方式
   a. 脚本安装（多用于测试和开发环境）
   b. 使用仓库（repository）安装（推荐）
   c. 使用RPM程序包安装（适用于没有互联网接入的情况）

# 1、下载所需要的安装包
yum install -y yum-utils 

# 2、设置镜像的仓库
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 # 使用国内阿里云安装，安装十分快速

# 3、更新yum软件包索引
yum makecache fast

# 4、安装docker相关引擎 docker-ce 社区版 ee企业版
yum install docker-ce docker-ce-cli containerd.io

5. 启动
   查看是否安装成功：docker version
   启动命令：systemctl start docker
   查看状态：docker info
   运行hello world: sudo docker run hello-world
   查看hello world镜像: docker images

结果：



6. 了解：删除docker

# 1、卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
# 2、删除资源
rm -rf /var/lib/docker #docker的默认工作路径

7. 使用国内镜像加速：阿里云、腾讯云
   默认情况下docker从docker hab 上下载镜像资源，速度很慢，可以通过配资国内镜像加速器来解决。
   a. 阿里云镜像加速：进入容器镜像服务—>镜像加速器–>加速地址
   
   b. 查看镜像加速器
   

# 1、创建文件夹
sudo mkdir -p /etc/docker
# 2、编写配置文件
vim /etc/docker/daemon.json
# 按 i切换至编辑模式，添加以下内容，并保存。
{
"registry-mirrors": [
"镜像地址" #腾讯云的：https://mirror.ccs.tencentyun.com
]
}
# 3、重启docker
sudo systemctl daemon-reload
sudo systemctl restart docker 

六、Docker 镜像

docker镜像是文件系统叠加而成（是一种文件存储形式），最底端是一个文件引导系统，即bootfs，这很像典型的linux/unix的引导文件系统。docker用户几乎永远不会和引导系统有什么交互。实际上，当一个容器启动后，它将会移动到内存中，而引导文件系统则会被卸载，以留出更多的内存供磁盘镜像使用。docker容器启动是需要一些文件的，而这些文件可以成为docker镜像。

1、常用命令

1. 帮助命令：

docker version 		# 显示docker信息
docker info			# 查看docker详细信息
docker 命令 --help 	# 帮助命令

2. 镜像命令

docker images				# 查看所有镜像 -a，--all 列出所有镜像；-aq 显示所有镜像id 
docker search（镜像名）		#搜索镜像 --filter=""="" 按条件搜索
docker pull （镜像名）		#下载镜像 :版本号 下载指定版本
docker rmi -f $IMAGE_ID		#删除镜像 根据镜像id
docker rmi -f $(docker images -aq)		#删除所有镜像
docker rmi $REPOSITORY:$TAG	#删除镜像
 

docker pull 下载详情：

[root@VM-8-7-centos docker]# docker pull mysql
Using default tag: latest  #如果不写 tag，默认最新的 latest
latest: Pulling from library/mysql
824b15f81d65: Pull complete			#分层下载，docker images的核心 联合文件系统
c559dd1913db: Pull complete 
e201c19614e6: Pull complete 
f4247e8f6125: Pull complete 
dc9fefd8cfb5: Pull complete 
af3787edd16d: Pull complete 
b6bb40f875d3: Pull complete 
75f6b647ddb1: Pull complete 
a09ca0f0cb24: Pull complete 
9e223e3cd2fd: Pull complete 
2b038d826c65: Pull complete 
d33ac6052fc9: Pull complete 
Digest: sha256:a840244706a5fdc3c704b15a3700bfda39fdc069262d7753fa09de2d9faf5f83	#签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest		#真实地址

2、镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。所有的应用，不需要打包docker镜像，就可以直接跑起来。
如何得到镜像：

• 远程仓库下载
• 自己制作
  

3、分层原理

当下载同一镜像不同版本时，第二次下载时的文件会提示已经存在，每一层对一个每一个操作，就像安全补丁一样。如果有其他文件需要在原有文件上进行升级，则会新增一个文件覆盖原文件，但总数是累加的。优点是下载镜像时分层下载可以复用以前的文件。
镜像下载原理：下载一个镜像时，分层下载然后打包成一个镜像。我们运行等命令的操作是基于容器层的，docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像顶部，这一层就是容器层。当容器启动时，实际上会将原镜像加上容器层的镜像再次打包成为一个层级。

4、commit镜像

#提交容器成为一个新的副本
docker commit
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

启动一个默认的Tomcat，发现这个默认的Tomcat是没有webapps应用，镜像的原因，官方镜像默认没有webapps下面的文件，可以自己拷贝，拷贝之后的容器作为一个镜像进行提交，这样就封装了一个自己的镜像。

5、发布镜像到docker hub

1. 登录docker hub网站注册登录
2. 确定这个账号可以使用
3. docker登录 login
4. 在我们服务器上提交自己的镜像 docker push

#docker 登录
[root@VM-8-7-centos dockerfile]# 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

# push镜像
docker push kanlina/diycentos:1.0

登录成功：
push成功：使用tag命令修改镜像名格式为 登录用户名/镜像名

6、发布镜像到阿里云

1. 创建命名空间
2. 创建镜像仓库
   
3. 本地使用：

7、发布镜像到腾讯云

1. 登录腾讯云控制台，找到服务器
   

2. 填写镜像仓库信息

3. 到镜像中就可以显示制作完成的镜像（很慢！！！）

阿里云创建镜像后官方会直接给出使用方法，腾讯云么有找到~~~

七、Docker 容器

可以看作简单版的linux(包括root用户权限，进程空间，用户空间和网络空间等)和运行在其中的应用程序。

1. 容器命令

# 下载centos
docker pull centos

# 运行centos 参数说明：  
#--name="Name" 起别名;
#-d 后台方式运行;
#-ice t 使用交互方式运行，进入容器查看内容
#-P 指定容器的端口 主机端口:容器端口;容器端口;ip:主机端口:容器端口
#-p 随机指定端口
docker run [可选参数] 镜像名称 路径 

#最终运行 
docker run -it centos /bin/bash

#退出容器 ctrl+p+q 容器不停止退出  
exit

#查看正在运行的容器
# -a 列出当前正在运行的容器，带出历史运行过的
# -n=个数 显示最近创建的容器
# -q 只显示容器编号 

docker ps

#删除容器
docker rm 容器id #不能删除正在运行的容器，rm -f强制删除
docker rm -f $(docker ps -aq)

#启动容器
docker start 容器id
docker restart 容器ID #重启

#停止当前正在运行的容器
docker stop 容器id
docker kill 容器id #强制停止当前正在运行的容器

#查看容器日志：docker logs -f -t --tail 行数 容器ID(-f 参数代表长期监控日志数据；-t参数代表额外增加时间戳；--tail 代表行数 显示末尾多少行日志) 
docker logs -f -t --tail 5 容器id

#查看容器中的进程
docker top 容器ID

#显示指定条数的日志
docker logs -tf --tail 条数 容器id

#查看容器内部详情,查看容器元数据
docker inspect 容器ID

#复制容器数据到宿主机
docker cp 容器ID:容器内路径 宿主机路径
docker cp mysql:/etc/mysql~/tmp/conf

#进入当前正在运行的容器
docker exec -it 容器id /bin/bash  
docker attach 容器id #进入正在运行的容器，不会打开新的终端

2. 出现的坑：使用docker run -d 容器id ，发现并没有启动，docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就没有程序了。

八、Docker 仓库

1. 创建阿里云镜像仓库

2. 创建命名空间
   
   
   删除的话需要删除仓库、版本的方式

3. 下载本地镜像仓库

docker pull registry

4. 修改docker service配置

vi/usr/lib/systemd/system/docker.service

5. 重启docker服务：
   systemctl daemon-reload systemctl restart docker
6. 启动容器:docker run -p 5000:5000 -v/opt/registry --name registry -d registry
7. 容器启动状态:docker ps -l
8. 浏览器查看本地仓库:http://ip:5000/v2
   
   

九、Docker File 管理（如何手动自主创建镜像文件）

Dockerfile就是用来构建docker镜像的构建文件，命令脚本，通过这个脚本可以生成一层一层的镜像，就是一个文件脚本

1、构建过程

1. 编写一个dockerfile文件
2. docker build构建成为一个镜像docker build -f 构建文件 -t 镜像名称:TAG

#例子：
docker build -f /root/docker/buildFile -t eureka:1.0 .

3. 运行镜像 docker run

#例子
docker run --name eureka -p 8761:8761 -d eureka:1.0

4. 发布镜像 docker push

2、dockerfile基础知识

基础知识：

• 每个保留关键字都是大写；
• 执行从上到下；
• ‘#’ 表示注释
• 每一个指令都会创建体积哦啊一个新的镜像层并提交！

3、dockerfile命令

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

4、实战测试 创建自己的centos

DockerHub中的99%镜像都是从这个基础镜像过来的FROM sratch ，然后配置需要的软件和配置进行构建。
本地服务器创建一个目录，用来存放自己的dockerfile
/home/dockerfile/mydockerfile，升级一下centos命令，例如vim，ifconfig命令

# 1、构建dockerfile文件
[root@VM-8-7-centos dockerfile]# cat mydockerfile 
FROM centos:7
MAINTAINER kanlina<203096126@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 mydockerfile -t mycentos:01 .
# 3、运行容器，进入容器查看是否可以使用vim
docker run -it mycentos:01

运行一个centos容器，发现默认路径均为/，该用户下的地址，这个地址可以改变，通过dockerfile中的WORKDIR参数指定运行时进入的目录！
可以通过docker history 镜像id [--no-trunc] 来查看镜像的构建历史[完整信息]。

十、使用IDEA构建镜像（IDEA远程访问，IP+端口）

重启：systemctl daemon-reload
从阿里云找依赖

十一、Docker 生命周期（指容器生命周期）

• 圆形：
  created:初建状态
  running:不经过created状态，经过start命令进入运行状态
  pause:暂停–>paused状态
  stopped：优雅关闭状态 stop kill 内存溢出、容器进程问题等异常杀死
  deleted: rm删除
  
  
  
  

十二、Docker 多容器数据共享（容器数据卷）

1、什么是容器数据卷

docker的理念是将应用和环境打包成一个镜像。如果数据都在容器中，那么容器删除，数据就会丢失，此时需要将数据进行持久化。例如mysql，容器删了，数据也会随之消失，此时需要将数据同步到本地。就是将容器内的目录挂载到linux上。

2、使用数据卷

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

1. 指定路径挂载

docker run -it -v 本地主机路径:容器内部路径
docker run -it -v /test/centos01:/home centos /bin/bash

查看容器内详情docker inspect ******


好处：以后修改只需要在本地修改即可，不需要再进容器内修改。此方式只能匿名，无法设置挂载名称。

2. 具名挂载： -v后面指定具体名称
   docker run -it -v 卷的具体名称:需要挂载的容器路径 容器名
   注意：具名挂载无法设置指定的服务器挂载路径，只能通过 docker volume inspect 挂载名 查看存储路径，一般默认路径为：/var/lib/docker/volumes/容器名
3. 匿名挂载：-v 容器内路径，不需要指定主机名，直接是容器内的路径。

#匿名挂载 示例
docker run -d -p --name nginx01 -v /etc/nginx nginx
#查看所有卷情况
docker volume ls

DRIVER    VOLUME NAME
local     1a4ac0a8c4f78ff92a45e0117e136e6cd6ed4b33b8e23d4c3edaa0068a846af2
#这里发现每个参数都是匿名且真是存在的，-v的时候只写了容器内的路径，没写容器外的路径
#查看具体挂载路径
docker volume inspect 卷名

区分挂载方式：
匿名挂载：-v 容器内路径；
具名挂载：-v 卷名:容器内路径；
指定路径挂载：-v /宿主机路径:容器内路径；
拓展：-v 容器内路径:ro rw 改变读写权限；

方式二：docker file

模板：
创建一个存储dockerfile的文件夹,和dockerfile01文件(dockerfile文件)

#挂载的容器名
FROM centos
#volumn01 volumn02挂载之后生成的目录名,匿名挂载！！！
VOLUME ["volumn01","volumn02"]
CMD echo "---end---"
CMD /bin/bash

docker build -f /home/dockertest/docker-volumn-files/dockerfile01 -t kanlina/centos .



可以在容器中的挂载目录里生成一个文件，在服务器外使用docker inspect 容器id 命令查找到容易挂载的目录，cd到这个目录即可验证数据是否同步！

3、容器直接数据同步

启动三个容器：
第一个： docker run -it --name docker01 9afd849da60f
第二个： docker run -it --name docker02 kanlina/centos
第三个： docker run -it --name docker03 kanlina/centos

测试：在docker02

4、总结

容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止，一旦持久化到本地，这个时候本地数据不会删除。

十三、Docker网络

1、清空镜像

docker rmi -f $(docker images -aq)

2、查看地址

ip addr 共有三个网络

3、docker是如何处理容器网络访问的？

1. 启动容器 例如tomcat
   docker run -d -P --name tomcat01 tomcat
2. 查看容器内部网络地址 ip addr

#查看tomcat01容器的ip地址情况
 docker exec -it tomcat01 ip addr
#出现以下问题：
 Error response from daemon: Container 427f3f6416583790ae6ec86c8019eb7f4333f61cfa69a8d8c56986b
 #重新拉取Tomcat镜像 tag为7的

3. ping docker容器地址

[root@VM-8-7-centos ~]# 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.114 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.065 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.051 ms
64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.054 ms

结论：linux可以Ping通容器内部

4. 原理：
   在docker内部容器中都使用共同的网段，所以是可以ping通的。我们每安装一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0，桥接模式，使用的技术是veth-pair技术。每次启动一个容器都会多一对网卡，这就是evth-pair技术，她们都是成对出现的，一端连着协议，一端彼此相连。正因为有这个特性，veth-pair充当一个桥梁，连接各种虚拟网络设备。
   

结论：容器容器之间是可以ping通的！tomcat01和tomcat02是共用一个路由器，docker0。所有容器不指定网络的情况下，都是docker0路由的，docker会给我们容器分配一个默认的可用ip，只要容器删除，对应网桥一对就没了。docker使用的是linux的桥接，宿主机中是一个docker的网桥 docker0，docker中的所有网络接口都是虚拟的。虚拟的转发效率高！！

4、容器互联 --link

使用场景：当服务中使用另一个的ip，项目重启ip换了，如何继续链接该服务？

#tomcat01无法ping通tomcat02
[root@VM-8-7-centos ~]# docker exec -it tomcat01 ping tomcat02
ping: tomcat02: Name or service not known
#解决：tomcat03和tomcat01互联
[root@VM-8-7-centos ~]# docker run -d -P --name tomcat03 --link tomcat01 tomcat:7 
73c07541f63b4bfff0f35e5118ddb3ed3233be7a0b4bb821aa43f82cf9cdd101
#结果：
[root@VM-8-7-centos ~]# docker exec -it tomcat03 ping tomcat01
PING tomcat01 (172.17.0.2) 56(84) bytes of data.
64 bytes from tomcat01 (172.17.0.2): icmp_seq=1 ttl=64 time=0.115 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=2 ttl=64 time=0.063 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=3 ttl=64 time=0.072 ms
^C
--- tomcat01 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2ms
rtt min/avg/max/mdev = 0.063/0.083/0.115/0.023 ms
#反向无法ping通，需要再次互联

探究：inspect

结论：其实这个tomcat03就是在本地配置了tomcat01的配置，通过docker exec -it tomcat03 cat /etc/hosts

[root@VM-8-7-centos ~]# 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      tomcat01 54a9e7519572
172.17.0.4      73c07541f63b

结论：–link 就是在我们的hosts配置中增加要ping通的那个容器的映射
不推荐使用！！！真实开发时需要更高级网络，自定义网络！不使用docker0，docker0不支持容器名连接访问！！！

5、容器互联-自定义网络 --net

1. 查看所有网络

[root@VM-8-7-centos ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
7de21d8d461f   bridge    bridge    local
7c24f8b073d5   host      host      local
c5d01d6eea4b   none      null      local

2. 网络模式
   bridge:桥接docker（默认，自己创建也使用桥接模式）
   none：不配置网络
   host：和宿主机共享网络
   container：容器内网络连通（用得少，局限性很大）
3. 创建网络

默认情况：

#我们直接启动的命令， --net bridge，这个就是我们的docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat
#docker0特点：默认，域名不能访问 

使用默认方式创建网络：

#使用默认方式创建网络
#--driver bridge
#--subnet 192.168.0.0/16
#--gateway 192.168.0.1
[root@VM-8-7-centos ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
391116bcbb3d3b849e2b752c5968f40cecedf7b1c0a3d33710a2b3a39972c033
[root@VM-8-7-centos ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
7de21d8d461f   bridge    bridge    local
7c24f8b073d5   host      host      local
391116bcbb3d   mynet     bridge    local
c5d01d6eea4b   none      null      local
#自己的网络创建完成
[root@VM-8-7-centos ~]# docker network inspect mynet 
[
    {
        "Name": "mynet",
        "Id": "391116bcbb3d3b849e2b752c5968f40cecedf7b1c0a3d33710a2b3a39972c033",
        "Created": "2022-07-11T18:32:30.44154432+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": {},
        "Options": {},
        "Labels": {}
    }
]

4. 运行的容器使用创建的网络
   docker run -d -P --name tomcat-mynet-01 --net mynet tomcat:7
docker run -d -P --name tomcat-mynet-02 --net mynet tomcat:7
5. 查看mynet内容器情况
   docker network inspect mynet
6. 直接使用容器名ping
   
7. 优点：

不同集群使用不同网络，保证集群是健康安全的；
可以通过服务名直接ping通

6、网络连通

如何打通不同网络之间的容器网络？？？

1. 可以链接tomcat0到网络mynet
   docker network connect

#将mynet1中的tomcat连接到mynet网络中
docker network connect mynet tomcat-mynet1-01

总结：实质上就是在要连通的网络中添加该容器，