docker学习 - 《Docker相关》

1.docker概述&历史
2.docker做什么
3.docker安装
4.docker底层原理
5.docker的常用命令：
6.常用其他命令
7.作业练习
- Apache Tomcat/9.0.38
8.可视化
9.Docker镜像之联合文件系统
10.容器数据卷
11.DockerFile
12Docker网络

1.docker概述&历史

将开发人员开发的jar包与运行所需环境打包成镜像（Hadoop）
docker核心：隔离，镜像互不影响，
容器化技术，也是一种虚拟技术
开源
相比于VMware等虚拟机轻巧的多
基于go语言开发的

2.docker做什么

虚拟机技术缺点：1.资源占用多2.冗余步骤多3.启动慢
DevOps：开发、运维：
应用更快速的交付和部署
更便捷的升级和扩缩容
更简单的系统运维
更高效的计算资源利用

3.docker安装

1）docker的基本组成
架构图
2）安装docker
官方网站
阿里云加速（网址需要自己申请）
3）设置docker 开机自启动
启动docker
systemctl daemon-reload && systemctl restart docker
设置开机启动
systemctl enable docker.service

4.docker底层原理

docker是怎么工作的
Docker是一个Client、Server结构的系统；Docker的守护进程运行在主机上，通过Socket从客户端访问。
DockerServer接收到DockerClient的指令，就会执行这个命令。
docker快的原因：
1）docker比虚拟机的抽象层更少。

2）docker利用的是宿主机的内核，VM需要的是Guest OS系统（例如centos等）

5.docker的常用命令：

1）帮助命令

docker version #显示docker的版本信息
docker info #显示docker的系统信息，包括docker的镜像和容器的数量
docker 命令 —help #帮助命令

帮助文档的地址：http://docs.docker.com/reference/
2）镜像命令

docker images #查看所有本地主机上的镜像
docker search 镜像名 #搜索镜像
docker pull 镜像名[:tag] #下载镜像[:指定镜像版本官方存在，不写就默认最新版本lastet]
分层下载docker image核心
https://hub.docker.com/官方镜像仓库

docker rmi -f 镜像ID… #删除镜像 remove image -force 强制删除镜像
docker rmi -f $(docker images -aq)#列出所有镜像并递归删除
3）容器命令
有了镜像才可以创建容器

docker run [可选参数] images #运行容器
#####参数说明
—name 容器名字，用来区分容器
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器端口
-p ip：主机端口：容器端口
-p 主机端口:容器端口（常用）
-p 容器端口
-P 随机指定端口
创建新的容器但不启动：docker create [OPTIONS] image
启动（创建）并进入容器：

[root@jerry ~]# docker run -it centos /bin/bash #centos是镜像名/bin/bash是镜像运行文件
[root@3343fa353e67 /]#
docker run -it mycentos:0.1
运行自定义的镜像一定带版本号，不然系统会默认去dockerhub上面找最新版

停止并退出容器：exit
容器不停止退出：Ctrl+p+q

docker ps #查看运行容器
docker ps -a #列出当前正在运行的容器及历史运行过的容器
docker ps -n=? #显示最近创建的容器
docker ps -q #只显示容器的编号
删除容器：
docker rm 容器ID #删除指定容器，不能删除正在运行的容器，需要加-f
docker rm -f $(docker ps -aq) #删除所有容器
docker ps -a -q | xargs docker rm #删除所有容器
启动和停止容器：

docker start 容器id
docker restart 容器id
docker stop 容器id #停止
docker kill 容器id #强制停止
容器与镜像的关系：

6.常用其他命令

docker top 容器id #查看容器中进程信息
docker logs -ft —tail 10 容器id #查看容器运行日志
docker inspect 容器id #查看元数据
docker exec -it 容器id /bin/bash #进入正在运行的容器并开启一个新终端可以执行命令
注意后面的/bin/bash
docker attach 容器id #进入正在运行的容器的正在运行的终端
把容器内文件拷贝到主机上：
docker cp 容器id:容器内路径主机目录

docker删除所有容器命令：
docker rm -f $(docker ps -aq)
docker删除所有镜像命令：
docker rmi -f $(docker images -aq)

命令大全：https://blog.csdn.net/lisen01070107/article/details/108385257

7.作业练习

1）作业一：docker 安装Nginx
nginx（负载均衡、反向代理服务器）
思路:1）首先xshell搜索docker search nginx 以及在官网上搜索文档
2）搜索到之后下载docker pull nginx
3)下载完成后，查看镜像是否存在docker images
4)后台开启镜像：docker run -d —name nginx01 -p:3306:80 nginx
-d 后台运行
—name nginx01 命名运行容器便于区分
-p将容器内端口与宿主机（即服务器公网）开放端口进行映射
（容器内也相当于一个小的linux所以需要开启容器内部端口与本机上的linux连接）

5)测试是否映射成功：[root@jerry ~]# curl localhost:3306
6）进入nginx容器：docker exec -it nginx01 /bin/bash
7）查看nginx位置：whereis nginx
8）可以尝试修改配置文件在/etc/目录下的nginx.conf
9)思考，如何在容器外部提供一个映射修改容器内的配置文件，涉及到数据卷的知识。

2）作业二：docker安装tomcat
tomcat：轻量级web应用服务器
1）按作业一中1-3步骤
2）查看官方文档：发现命令：

—rm 的意思是运行完即删除；我们不运行这个命令
3）查看状态发现404

[root@jerry ~]# curl localhost:8888
<!doctype html>HTTP Status 404 ? Not Found
**

Apache Tomcat/9.0.38

进入容器发现没有webapps服务，因为下载镜像默认最小可运行，不必要的东西都被剔除了
需要把webapp.dist文件下内容拷贝到webapps下，才能在外网访问到容器内的tomcat

3)作业三：部署elasticsearch+kibanar
ElasticSearch : Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎[官网介绍]
Kibana:能够对 Elasticsearch 中的数据进行可视化并在 Elastic Stack 进行操作[官网介绍]
1）注意事项：es暴露端口多、占用内存大、数据需要放置到安全目录（挂载）
2）运行命令：docker run -d —name elasticsearch —net somenetwork -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” elasticsearch:7.6.2

—net somework 网络配置
3）启动后linux运行会很卡：docker stats #查看内存cpu
4）测试访问es是否启动成功：curl localhost：9200#出现下面则表示启动成功

5）测试完之后立马关闭es，增加内存限制
6）修改配置文件：-e 环境配置修改（限制es运行内存在64M到512M之间）

docker run -d —name elasticsearch02 -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” -e ES_JAVA_OPTS=”-Xms64m -Xmx512m” elasticsearch:7.6.2
7）再次查看stats：

8）测试是否连接成功：curl localhost：9200

使用kibana连接es

8.可视化

portainer&Rancher（CI/CD再用）
什么是portainer？
Docker图形化界面管理工具，提供一个后台面板供我们操作
1）安装命令：#docker run -d -p 8888:9000
—restart=always -v /var/run/docker.sock:/var/run/docker.sock —privileged=true portainer/portainer #注意内网端口要在阿里云安全组设置开放
2）访问测试http://101.200.167.167:8888/

3）可以自己设置密码登录试试

9.Docker镜像之联合文件系统

1）Docker 镜像是什么？
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码，运行时的库、环境变量和配置文件。#所有应用直接打包，可以直接跑起来
如何获得镜像：
从远程仓库下载
朋友拷贝给你=
自己制作一个镜像DockerFile
2）Docker镜像加载原理
UnionFS（联合文件系统）https://www.jianshu.com/p/5ec3d4dbf580

3）commit 镜像
docker commit #提交容器成为一个新的镜像
用法：docker commit -m=”提交的描述信息” -a=”作者” 容器id 目标镜像名:[TAG]

1、启动一个默认的tomcat
[root@jerry ~]# docker run -tid -p:8080:8080 tomcat
5eadc8f8b7c4b30df11ac356006d4d747d7a874a62c0b2baba886067e2ad0da8

2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！
docker exec -it 容器id /bin/bash
[root@jerry ~]# docker exec -it 5eadc8f8b7c4 /bin/bash
root@5eadc8f8b7c4:/usr/local/tomcat#
root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps
root@5eadc8f8b7c4:/usr/local/tomcat/webapps# ls
root@5eadc8f8b7c4:/usr/local/tomcat/webapps#

3、从webapps.dist拷贝文件进去webapp
root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps.dist
root@5eadc8f8b7c4:/usr/local/tomcat/webapps.dist# ls
ROOT docs examples host-manager manager
root@5eadc8f8b7c4:/usr/local/tomcat/webapps.dist# cd ..
root@5eadc8f8b7c4:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps
root@5eadc8f8b7c4:/usr/local/tomcat/webapps# ls
ROOT docs examples host-manager manager

4、将操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，而不需要每次都重新拷贝webapps.dist下的文件到webapps了，这就是我们自己的一个修改的镜像。
[root@jerry ~]# docker commit -m=”add webapps app” -a=”jerry” 5eadc8f8b7c4 tomcat02
sha256:1820873e4dec68dc782e034320745ec6732bc505683021a7798ab0c92e7846df

5、用自己创建的tomcat镜像重新运行一个容器出现如下界面：
[root@jerry ~]# docker run -tid -p:8080:8080 tomcat02

10.容器数据卷

1）什么是容器数据卷？
容器之间可以有一个数据共享的技术，将Docker容器中产生的数据同步到本地。
这就是卷技术：目录的挂载，将我们容器内的目录，挂载到linux上面，实现双向数据同步。
总结：容器的持久化操作。容器内也是可以数据共享的！
2）使用数据卷：
挂载的第一种方式：直接使用命令挂载 -v
docker run -it -v 主机目录:容器内目录容器名 /bin/bash
例：docker run -it -v /home/ceshi:/home centos /bin/bash
将centos容器中/home目录下文件挂载到主机下/home/ceshi目录下
挂载成功检测（在主机下输入）：docker inspect 容器id

分别在容器和主机对应目录下新建文件，发现可以同步；
将容器停止，修改主机上测试文件内容，再重新将容器启动，发现数据仍然同步。
3）实战：安装MySQL（失败后成功了，不是端口问题，因该是MySQL版本太新，客户端不支持，换成mysql:5.7就可以）

获取mysql镜像
docker pull mysql:5.7

运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
参考官网hub
docker run —name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

启动option
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
— name 容器名字
$ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 —name mysql01 mysql:5.7

启动成功之后，我们在本地使用sqlyog来测试一下
sqlyog-连接到服务器的3306—和容器内的3306映射
在本地测试创建一个数据库，查看一下我们映射的路径是否ok！

假设我们将包含mysql的容器删除时，
发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。
4）具名和匿名挂载
docker volume ls #列出所有挂载
匿名挂载：-v 容器内目录
具名挂载：-v 卷名:容器内目录
指定路径挂载：-v /宿主机目录:容器内目录
通过docker inspect 容器id 查看具体挂载目录
“ 所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/自定义的卷名/_data下，如果指定了目录，docker volume ls 是查看不到的。”
5）拓展

通过 -v 容器内路径： ro rw 改变读写权限；默认rw可读可写

ro #readonly 只读
rw #readwrite 可读可写
$ docker run -d -P —name nginx05 -v juming:/etc/nginx:ro nginx
$ docker run -d -P —name nginx05 -v juming:/etc/nginx:rw nginx
一旦设定了ro，则容器的权限随之改变为只读，所以只能从宿主机操作。

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

11.DockerFile

挂载的第二种方式：编写dockerfile脚本设置挂载目录
DockerFile 就是用来构建docker镜像的构建文件，就是命令脚本！
通过脚本可以生成镜像，镜像是一层一层的，所以脚本是一个一个的命令，每个命令就是一层！
编写dockerfile，设置挂载目录

创建一个dockerfile文件

Dockerfile
dockerfile1 文件中的内容：指令(大写) + 参数
$ vi dockerfile1
FROM centos # 当前这个镜像是以centos为基础的
VOLUME [“volume01”,”volume02”] # 挂载卷的卷目录列表(多个目录)
CMD echo “——-end——-“ # 输出一下用于测试
CMD /bin/bash # 默认走bash控制台

这里的每个命令，就是镜像的一层！

按层构出这个镜像

[root@jerry ~]# docker build -f dockerfile1 -t jerry/centos .
-f dockerfile1 # f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t jerry/centos # t就代表target，指目标镜像名(注意镜像名前不能加斜杠‘/’)
. # 表示生成在当前目录下 -t后一定要加个 . 要不然不成功
运行一个容器：docker run -it jerry/centos /bin/bash
测试：在 jerry/centos 镜像运行的容器内的 volume01 挂载目录下新建一个文件container.txt ，然后不退出在宿主机上通过命令：#docker inspect 容器id 查看 mounts 中的具体匿名挂载目录，进入该目录下查看是否 container.txt 文件已经同步，若同步则成功。

数据卷容器
两个或多个mysql同步数据：双向拷贝
实现容器间的数据共享：—volumes-from
用到的命令：
docker run -it —name docker01 jerry/centos:latest #注意要加上版本号不然默认最新
docker run -it —name docekr02 —volumes-from docker01 84719eb2a4a5
docker attach 84719eb2a4a5
docker run -it —name docker03 —volumes-from docker01 jerry/centos:latest
ctrl+p+q

docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 —name mysql01 mysql:5.7
docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 —name mysql02 —volumes-from mysql01 mysql:5.7 #将mysql02挂载到mysql01上
结论：容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的

DockerFile介绍

dockerfile 是用来构建docker镜像的文件，是命令参数脚本
构建步骤：
1.编写dockerfile 文件
2.docker build 构建成为一个镜像
3.docker run 运行镜像
4.docker push 发送镜像（DockerHub、阿里云镜像）

DockerFile构建过程

基础知识：
1.每个保留关键字（指令）都必须是大写字母
2.指令从上到下顺序执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层，并提交！
dockerfile 是面向开发的，要发布项目、做镜像需要编写dockerfile文件。
DockerFile的指令
1）
FROM #基础镜像，一切从这里开始构建
MAINTAINER #镜像作者：姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤。（tomcat镜像的压缩包就是一种添加内容）
WORKDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #暴露端口配置
CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以直接追加命令
ONBUILD #当构建一个被继承 DockerFile ，这个时候就会运行 ONBUILD 的指令，是一种触发指令
COPY #类似ADD命令，将我们的文件拷贝到镜像中
ENV #构建的时候这只环境变量

2）CMD 和 ENTRYPOINT 的区别：
CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以直接追加命令

测试CMD命令和ENTRYPOINT命令的区别

编写dockerfile文件
vim dockerfile-test-cmd
FROM centos
CMD [“ls”,”-a”] # 启动后执行 ls -a 命令

构建镜像
docker build -f dockerfile-test-cmd -t cmd-test:0.1 .

运行镜像
docker run cmd-test:0.1 # 由结果可得，运行后就执行了 ls -a 命令
.
..
.dockerenv
bin
dev
etc
home

想追加一个命令 -l 成为ls -al：展示列表详细数据
docker run cmd-test:0.1 -l
报错：docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused “exec: \”-l\”:

报错原因： cmd的情况下 -l 替换了CMD[“ls”,”-l”] 而 -l 不是命令所以报错，如果输入
docker run cmd-test:0.1 ls -al,就由ls -al代替ls -a执行，不会报错。
测试ENTRYPOINT：

编写dockerfile文件
vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT [“ls”,”-a”]

构建镜像
docker build -f dockerfile-test-entrypoint -t cmd-test:0.1 .

运行镜像
docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found …

我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
docker run entrypoint-test:0.1 -l
后面 -l 的命令是直接拼接在dockerfile中entrypoint命令后面的
#注意输出结果
total 56
drwxr-xr-x 1 root root 4096 May 16 06:32 .
drwxr-xr-x 1 root root 4096 May 16 06:32 ..
-rwxr-xr-x 1 root root 0 May 16 06:32 .dockerenv
lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x 5 root root 340 May 16 06:32 dev
drwxr-xr-x 1 root root 4096 May 16 06:32 etc
drwxr-xr-x 2 root root 4096 May 11 2019 home
lrwxrwxrwx 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx 1 root root 9 May 11 2019 lib64 -> usr/lib64 ….
实战测试1：（构建一个自己的centos镜像，添加官方centos镜像中没有的命令）
DockerHub中大多数镜像都是从这个基础镜像过来的：FROM scratch
1）命令：
[root@jerry dockerfile]# vi mydockerfile-centos
[root@jerry dockerfile]# cat mydockerfile-centos
FROM centos
MAINTAINER jerry2469485159@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 #因为CMD中命令会被覆盖，所以每一个命令写在一个CMD中
2）测试运行
docker run -it mycentos:0.1 # 注意带上版本号，否则每次都回去找最新版latest
pwd
/usr/local # 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
vim # vim 指令可以使用
ifconfig # ifconfig 指令可以使用
docker history 镜像id # docker history 镜像id 查看镜像构建历史步骤

构建tomcat镜像的Dockfile（样例）：

1）准备镜像文件，tomcat压缩包、jdk压缩包（因为tomcat基于java所以也需要jdk压缩包）

2）编写dockerfile文件，官方命名：Dockerfile ，build 会自动寻找这个文件不需额外指定
Dockerfile:
FROM centos
MAINTAINTER jerry<1748553376@qq.com>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u161-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.35.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_161
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOS 8080
CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/bin/logs/catalina.out

3）构建镜像：docker build -t diytomcat . # . 表示当前目录
docker build -t diytomcat .
4）启动镜像：
docker run -d -p 9090:8080 --name jerrytomcat
-v /home/jerry/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test
-v /home/jerry/build/tomcat/logs/:/usr/local/apache-tomcat-9.0.35/logs diytomcat

5）访问测试：[root@jerry ~]# curl localhost:9090

返回网页，测试成功！
6）发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了）
在主机的挂载目录：
/home/jerry/build/tomcat/test

中新建文件web.xml并添加内容

<?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">
  </web-app>

并新建Index.jsp并写入以下代码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello jerry</title>
</head>
<body>
Hello World!<br/>
<%
System.out.println("-----my tomcat logs-----");
%>
</body>
</html>

访问成功！
需要掌握Dockerfile的编写，之后的一切都使用docker镜像来发布运行！
发布镜像到dockerhub,
1.docker login -u jerryflystudy 回车然后输入密码登录
2.docker tag imageID(要发布镜像ID) jerryfly/tomcat:1.0 这里给镜像加标签，标签名字一定要带dockerhub用户名。
3.docker push jerryfly/tomcat:1.0
发布到阿里云镜像仓库，
1.登录阿里云
2.找到容器镜像服务
3.创建命名空间
4.创建容器镜像

12Docker网络

 docker run -d -P --name tomcat01 tomcat      #直接运行tomcat（从分仓库拉取）随机开放端口
 docker exec -it tomcat01 ip addr     #进入正在运行的容器，并在后面追加命令显示IP

在主机可以直接ping 通docker容器内部

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

#我们发现这个容器带来的网卡都是成对出现的
#veth-pair就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连
#正因为有这个特性，veth-pair充当一个桥梁

使用tomcat2 ping tomcat1可以ping通

[root@iZ2ze4nuf6nscouxcmwnasZ ~]# docker exec -it tomcat02 ping 172.17.0.2

结论：
tomcat01和tomcat02都是公用一个路由器，docker0（docker安装就有的）
所有容器在不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP

Docker中所有网络接口都是虚拟的，虚拟的网络接口传递效率高。
查看开放端口：[root@jerry ~]# /sbin/iptables -L -n
查看ip：ip addr & ifconfig
link：docker run -d -P —name tomcat03 —link tomcat02 tomcat #局限性很大，得相互link两次
docker exec -it tomcat3 ping tomcat02,可以直接ping通，但是在tomcat02中ping tomcat03就不一定可以Ping通

网络模式
bridge ：桥接 docker（默认，自己创建也是用bridge模式）
none ：不配置网络，一般不用
host ：和所主机共享网络
container ：容器网络连通（用得少！局限很大）

我们直接启动的命令 —net bridge,而这个就是我们得docker0
bridge就是docker0
docker run -d -P —name tomcat01 tomcat

等价于 =>>
docker run -d -P —name tomcat01 —net bridge tomcat

假设要跨网络操作别人，就需要使用docker network connect 连通
docker network connect tomcat01 mynet
docker network connect 容器名网名