当我们在开发一个项目的时候，假如您自己的电脑有您自己的开发环境，别人的电脑有他自己的开发环境，您开发的项目依赖您当前的配置还要依赖一些配置文件，除此之外，您的项目开发好之后还要进入测试环境，生产环境。那您希望如何在部署过程中不出现令人头疼的版本和配置问题，也无需编写代码和进行故障修复？
docker就可以解决这一问题，它给出了一个标准化的解决方案——系统平滑移植，容器虚拟化技术。
就是因为环境配置相当麻烦，每一台机器都要配置一遍，项目部署换一台服务器，就要重来一次，那么，软件可不可以带环境安装呢？即在安装的时候将需要的原始环境原封不动的复制过来。消除了在你电脑上可以运行，而在我电脑就失败的问题。
docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP及其运行环境能做到“一次镜像，处处运行”。
docker就是将应用打成镜像，通过镜像运行在Docker容器上面的实例，而docker在任何操作系统上都是一致的，这就实现了跨平台，跨服务器，只需要一次配置好环境，换到了别的机子也可以一键部署好，大大简化了操作。
一句话：docker是一个解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。
传统的开发需要提供一堆的安装程序和说明文档，安装部署后需根据配置文档进行繁杂的配置才能运行，Docker化之后，只需要交付少量的容器镜像文件，加载镜像，创建容器就能运行，应用安装配置在镜像里已经内置好，大大节省部署配置和测试验证时间。
随着微服务架构和docker的发展，大量的应用会通过微服务方式架构，运用Docker，应用的升级将变得非常容易，当现有的容器不足以支撑业务时，可通过镜像运行新的容器进行快速扩容。
应用容器化运行后，生产环境运行的应用可与开发、测试环境高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。
Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。
Docker借鉴了标准集装箱的概念，Docker将这个模型运用到自己的设计中，唯一不同的是：集装箱运输货物，而Docker运输软件。
官网：Docker官网：http://www.docker.com
仓库：Docker Hub官网: https://hub.docker.com/
docker依赖已存在并运行的Linux内核环境，Docker实质上是在已运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的Linux主机，因此，Docker必须部署在Linux内核系统上，如果其他系统想部署Docker就必须安装一个虚拟的Linux环境。
前提条件
目前，CentOS 仅发行版本中的内核支持 Docker。Docker 运行在CentOS 7 (64-bit)上，
要求系统为64位、Linux系统内核版本为 3.8以上，这里选用Centos7.x
Docker镜像（image）就是一个只读的模板。通过镜像可以创建容器，并且可以创建多个。Docker镜像文件类似于我们通过Java中的类，而Docker容器就类似于Java中new出来的实例对象
| Docker | 面向对象 |
| 容器 | 对象 |
| 镜像 | 类 |
从面向对象的角度：
Docker利用容器独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就相当于一个虚拟化的运行环境，容器是用镜像创建的运行实例，镜像是静态的定义，容器是镜像运行时的实例。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台
从镜像容器的角度：
可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。
docker仓库是集中存放镜像文件的场所。
类似于Maven仓库存放各种jar包的地方；
类似于github仓库，存放各种git项目的地方；
Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。
仓库分为公开仓库（Public）和私有仓库（Private）两种形式。最大的公开仓库是 Docker Hub(https://hub.docker.com/)。
工作原理：
Docker是一个C/S结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。
1）确定你是CentOS7及以上版本：查看版本命令：cat /etc/redhat-release
2）卸载掉旧版本
3）yum安装gcc相关： centOs要能上外网；运行命令行 yum -y install gcc 和 yum -y install gcc-c++两个命令；
4）安装需要的软件包（这个是官网的要求）：yum install -y yum-utils；
5）设置stable镜像仓库：官网要求我们：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；
6）更新yum软件包索引：yum makecache fast
7）安装DOCKER CE: yum -y install docker-ce docker-ce-cli containerd.io
8)启动docker：systemctl start docker
9）测试： docker version 查看docker的版本；
10）卸载：依次运行命令行，删除安装过的：
systemctl stop docker；
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker；
rm -rf /var/lib/containerd
1）是什么：阿里云网址：https://promotion.aliyun.com/ntms/act/kubernetes.html
2）注册一个自己的阿里云账户(可复用淘宝账号)
3）获得加速器地址链接：登陆阿里云开发者平台 -> 点击控制台 -> 选择容器镜像服务 -> 获取加速器地址
4）粘贴脚本直接运行：
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://aa25jngu.mirror.aliyuncs.com"]
}
EOF
5）重启服务器
systemctl daemon-reload
systemctl restart docker
docker run 时都做了什么：
启动docker： systemctl start docker
停止dockers： systemctl stop docker
重启docker：systemctl restart docker
查看docker状态：systemctl status docker
开机启动： systemctl enable docker
查看docker概要信息：docker info
查看docker总体帮助文档：docker --help
查看docker命令帮助文档：docker 具体命令 --help
（1）docker images：列出本地主机上的镜像：-a：列出本地所有镜像；-q：只显示镜像ID；
（2）docker search 某个xxx镜像名字：搜索某个镜像 --limit 只列出N个镜像，默认25个
例如：docker search --limit 5 redis
| 参数 | 说明 |
| NAME | 镜像名称 |
| DESCRIPTION | 镜像说明 |
| STARS | 点赞数量 |
| OFFICIAL | 是否是官方的 |
| AUTOMATED | 是否是自动构建的 |
（3）docker pull 某个xxx镜像名字：下载镜像,后面可以加上版本信息，不加就是默认的最新版latest
（4）docker pull redis 等价于 docker pull redis:latest
（5）docker rmi 某个xxx镜像名字ID：删除镜像，
删除单个：docker rmi -f 镜像ID；
删除多个：docker rmi -f 镜像名1:TAG 镜像名2:TAG
删除全部：docker rmi -f $(docker images -qa)
有镜像才能基于镜像启动容器，这个根本前提；
（1）新建+启动容器：
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
OPTIONS说明：
--name="容器的新名字" 为容器指定一个新名称
-d：后台运行容器并返回容器ID，也即启动守护式容器（后台运行）；
-i：以交互模式运行容器，通常与-t同时使用；
-t：为容器重新分配一个伪输入终端，通常与-i同时使用；也即启动交互式容器（前台有伪终端，等待交互）；
-P：随机端口映射，大写P；
-p：指定端口映射，小写p；
启动交互式容器（前台命令行）
使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。要退出终端，直接输入exit
（2）列出当前所有正在运行的容器：docker ps [OPTIONS]
OPTIONS说明：-a：列出当前所有正在运行的容器+历史上运行过的
-l：显示最近创建的容器
-n：显示最近n个创建的容器
-q：静默模式，只显示容器编号
（3）退出容器：两种退出方式;
exit: run进去容器，exit退出，容器停止
ctrl+p+q：run进去容器，ctrl+p+q退出，容器不停止
（4）启动已停止运行的容器：docker start 容器ID或容器名
（5）重启容器：docker restart 容器ID或容器名
（6）停止容器：docker stop 容器ID或容器名
（7）强制停止容器：docker kill 容器ID或容器名
（8）删除已停止的容器 docker rm 容器ID
（9）一次性删除多个容器实例：docker rm -f $(docker ps -a -q) 或 docker ps -a -q | xargs docker rm
有镜像才能创建容器，这是根本前提(下载一个Redis6.0.8镜像演示)
启动守护式容器（后台服务器）：在大部分的场景下，我们希望 docker 的服务是在后台运行的，
我们可以过 -d 指定容器的后台运行模式。docker run -d 容器名
比如启动一个redis：前台交互模式启动：docker run -it redis:6.0.8
后台守护式启动：docker run -d redis:6.0.8
查看容器日志：docker logs 容器ID
查看容器内运行的进程：docker top 容器ID
查看容器内部细节：docker inspect 容器ID
进入正在运行的容器并以命令行交互： docker exec -it 容器ID bashShell
重新进入：docker attach 容器ID
上述两个的区别：
attach直接进入容器启动命令的终端，不会启动新的进程，用exit退出，会导致容器的停止；
exec是在容器中打开新的终端，并且可以启动新的进程，用exec退出，不会导致容器停止运行。
推荐使用docker exec命令，因为退出容器终端，不会导致容器的停止。
用之前的redis容器实例进入试试：
进入redis服务：docker exec -it 容器ID bin/bash
docker exec -it 容器ID redis-cli
一般用 -d 后台启动程序，再用exec进入对应的容器实例
从容器内拷贝文件到主机上：容器 ->主机 docker cp 容器ID:容器内路径 目的主机路径
导入和导出容器：export导出容器的内容留作为一个tar归档文件[对应import命令]
import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]
docker export 容器ID >文件名.tar
cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
常用命令;
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 # 在已存在的容器上运行命令
export Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
history Show the history of an image # 展示一个镜像形成历史
images List images # 列出系统当前镜像
import Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
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 # 列出容器列表
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 # 推送指定镜像或者库镜像至docker源服务器
restart Restart a running container # 重启运行的容器
rm Remove one or more containers # 移除一个或者多个容器
rmi Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
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 # 截取容器停止时的退出状态值
是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。
只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。
有没有发现，在我们pull镜像的时候，docker好像是在一层一层的下载，这是应为镜像也是通过一个基础镜像一层一层的构建出来的。UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。
docker的镜像层都是只读的，容器层是可写的：当容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常被称为“容器层”，"容器层“之下的都叫“镜像层”。所有对容器的改动-无论添加、删除、修改都只会发生在容器层中。只有容器层是可写的，容器层下的所有镜像层都是只读的。
4.docker镜像commit操作：
docker commit 提交容器副本使之成为一个新的镜像；
docker ciommit -m=”提交的信息描述“ -a=”作者“ 容器ID 要创建的目标镜像名:[标签名]
演示ubuntu安装vim
从Hub上下载的ubuntu镜像到本地并成功运行
原始的默认Ubuntu镜像是不带着vim命令的
外网连通的情况下安装vim
安装完成后，commit我们的新镜像
启动我们的新镜像和原来的对比
总结：Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。类似Java继承于一个Base基础类，自己再按需扩展。新镜像是从base镜像一层一层叠加生成的。没安装一个软件，就在现有镜像的基础上加一层。
有点类似redis里面的rdb和aof文件，将docker容器内的数据保存进宿主机的磁盘中，进行一个带有容器卷存储功能的容器实例；
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
Docker容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了。为了能保存数据在docker中我们使用卷。
特点：
1）数据卷可以在容器之间共享或重用数据；
2）卷中的更改可以实时生效；
3）数据卷中的更改不会包含在镜像的更新中；
4）数据卷的生命周期一直持续到没有容器使用它为止。
1）直接添加命令： docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
查看数据卷是否挂载成功：docker inspect 容器ID
两个地址：一个是容器内地址，一个是宿主机路径。
2）读写规则映射添加说明：默认是可读可写的，如果只读的话，容器实例内部被限制，只能读取，不能写：docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
3）卷的继承和共享：
容器1完成和宿主机的映射：docker run -it --privileged=true -v /mydocker/u:/tmp --name u1 ubuntu
容器2继承容器1的卷规则：docker run -it --privileged=true --volumes-from u1 --name u2 ubuntu
DockeFile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。
通过DockerFile构建镜像三步骤：1.编写DocekrFile文件；2.docker build命令构建镜像；3.docekr run 依镜像运行容器实例。
（1）Dockerfile内容基础知识：
1）每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2）指令按照从上到下，顺序执行
3）#表示注释
4）每条指令都会创建一个新的镜像层并对镜像进行提交
（2）Docker执行DockerFile的大致流程
1）docker从基础镜像运行一个容器
2）执行一条指令并对容器作出修改
3）执行类似docker commit的操作提交一个新的镜像层
4）docker在基于刚提交的镜像运行一个新的容器
5）执行dockerfile中的下一条指令直到所有指令都执行完成。
（3）小总结：从应用软件的角度来看，DockerFile，Docker镜像，Docker容器分别代表软件的三个不同的阶段，
DockerFile是软件的原材料
Docker镜像是软件的交付品
Docekr容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例
Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。
1）Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
2）Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;
3）Docker容器，容器是直接提供服务的。
FROM 基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from;
MAINTAINER 镜像维护者的姓名和邮箱地址
RUN 容器构建时需要运行的指令，RUN是在docker build时运行，有两种格式：
shell格式：RUN <命令行命令> 例如：RUN yum -y install vim
exec格式：RUN ["可执行文件","参数1","参数2"] 例如 RUN ["./test.php","dev","offline"] 等价于 RUN ./test.php dev offline
EXPOSE 当前容器对外暴露出的端口
WORKDIR 指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
USER 指定该镜像以什么样的用户去执行，如果都不指定，默认是root
ENV 用来在构建镜像过程中设置环境变量，这个变量可以在后续的任何RUN指令中用，这就 如同在命令前面指定了环境变量前缀一样，也可以在其它指令中直接使用这些环境变量
ADD 将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
COPY 类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置。例如：COPY src dext 或者 COPY ["src","dest"]，<src源路径>：源文件或者源目录，<dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
VOLUME 容器数据卷，用于数据保存和持久化工作
CMD 指定容器启动后的要干的事情，CMD格式和RUN格式相似，也有shell格式和exec格式，Docker中可以有多个CMD命令，但只有最后一个生效，CMD会被docker run之后的参数替换。CMD和RUN命令的区别：CMD是在docker run时运行，RUN是在docker build时运行。
ENTRYPOINT 用来指定一个容器启动时要运行的命令，类似于 CMD 指令，但ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。
命令格式：ENTRYPOINT ["<executeable>","<param1>","<param2>",...]
ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参
当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成 <ENTRYPOINT> "<CMD>";
例子：假设已经通过了DockerFile构建了nginx:test镜像：
| 是否传参 | 按照dockerfile编写执行 | 传参运行 |
| Docker命令 | docker run nginx:test | docker run nginx:test -c /etc/nginx/new.conf |
| 衍生出的实际命令 | nginx -c /etc/nginx/nginx.conf | nginx -c /etc/nginx/new.conf |
优点：在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。
注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。
小总结：
自定义镜像mycentosjava8，
（1）要求：Centos7镜像具备vim+ifconfig+jdk8;
（2）编写DockerFile文件：注意要以Dockerfile命名，开头首字母是大写D；
---------------------------------------------------------------------------------------------------------------------------------
FROM centos
MAINTAINER zzcc<zzccbs@126.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 80
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash
---------------------------------------------------------------------------------------------------------------------------------
（3）构建：docker build -t 新镜像名字:TAG . 别忘记TAG后面有个空格，有个点
（4）运行：docker run -it 新镜像名字:TAG
当docker不启动的情况下，ifconfig命令查看的时候，默认的网络情况：ens33、lo、vibr0;
当docker启动后，就会产生出一个命名为docker0的虚拟网桥；
查看docker网络格式的命令：docker network ls；默认创建三大网络模式：bridge，host，none
查看网络：docker network ls
查看网络源数据：docker network inspect xxx网络名称
案例：
（1）容器间的互联和通信以及端口映射
（2）容器IP变动时候可以通过服务名直接网络通信而不受到影响
（1）总体介绍：
1）bridge模式：使用--network bridge指定，默认使用docker0
2）host模式：使用--network host指定
3）none模式：使用--network none指定
4）container模式：使用--network container:NAME或者容器ID指定
（2）容器实例内默认网络IP生产规则
说明：
1）先启动两个ubuntu容器实例
2）docker inspect 容器ID or 容器名字
结论：docker容器内部的ip是有可能会发生改变的
（3）案例说明：
bridge：Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。
# 查看 bridge 网络的详细信息，并通过 grep 获取名称项
docker network inspect bridge | grep name、
说明：
1 Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。
2 docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的network(后面讲)eth0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址
3 网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。
3.1 整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；
3.2 每个容器实例内部也有一块网卡，每个接口叫eth0；
3.3 docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。
通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。
命令：
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
匹配验证：
host：直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。
案例说明：容器将不会获得一个独立的Network Namespace， 而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。
命令：
docker run -d -p 8083:8080 --network host --name tomcat83 billygoo/tomcat8-jdk8
以此命令运行容器的时候，会出现如下警告：
原因：
docker启动时指定--network=host或-net=host，如果还指定了-p映射端口，那这个时候就会有此警告，
并且通过-p设置的参数将不会起到任何作用，端口号会以主机端口号为主，重复时则递增。解决:
解决的办法就是使用docker的其他网络模式，例如--network=bridge，这样就可以解决问题，或者直接无视。。。。O(∩_∩)O哈哈~，也可以不指定端口号：docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8
看容器实例内部，就没有之前的显示了：
没有设置-p的端口映射了，如何访问启动的tomcat83？？
http://宿主机IP:8080/
在CentOS里面用默认的火狐浏览器访问容器内的tomcat83看到访问成功，因为此时容器的IP借用主机的，
所以容器共享宿主机网络IP，这样的好处是外部主机与容器可以直接通信。
none：禁用网络功能，只有lo标识(就是127.0.0.1表示本地回环)
在none模式下，并不为Docker容器进行任何网络配置。 也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo，需要我们自己为Docker容器添加网卡、配置IP等。
命令：docker run -d -p 8084:8080 --network none --name tomcat84 billygoo/tomcat8-jdk8
container：新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。
错误示例：
docker run -d -p 8085:8080 --name tomcat85 billygoo/tomcat8-jdk8
docker run -d -p 8086:8080 --network container:tomcat85 --name tomcat86 billygoo/tomcat8-jdk8
运行结果：
# 相当于tomcat86和tomcat85公用同一个ip同一个端口，导致端口冲突。
正确示例：
利用Alpine来演示：Alpine操作系统是一个面向安全的轻型 Linux发行版
命令：
docker run -it --name alpine1 alpine /bin/sh
docker run -it --network container:alpine1 --name alpine2 alpine /bin/sh
运行结果：
假如关闭了alpine，alpine1会怎么样：
当关闭了alpine，etho@if16就会消失，alpine1中的也会随之消失。
自定义网络：
在没有docker网络之前，启动两个tomcat
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
启动之后，用docker exec命令进入各自容器的内部，我们按照IP地址ping各自的容器实例是能ping通的，但是按照服务名ping却ping不通了。
自定义网络默认使用的是桥接网络bridge，
1.新建自定义网络
docker network create zzyy_network
2.新建容器的时候加入上一步创建的自定义网络
docker run -d -p 8081:8080 --network zzyy_network --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --network zzyy_network --name tomcat82 billygoo/tomcat8-jdk8
进入容器内部，按照名字互ping测试
结论：
自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）
Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。
如果需要同时部署好多个服务,就可以用docker-compose多服务部署的工具。Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。
可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。
1）curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
2）chmod +x /usr/local/bin/docker-compose
3）docker-compose --version
1）编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
2）使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
3）最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线
docker-compose -h # 查看帮助
docker-compose up # 启动所有docker-compose服务
docker-compose up -d # 启动所有docker-compose服务并后台运行
docker-compose down # 停止并删除容器、网络、卷、镜像。
docker-compose exec yml里面的服务id # 进入容器实例内部 docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps # 展示当前docker-compose编排过的运行的所有容器
docker-compose top # 展示当前docker-compose编排过的容器进程
docker-compose logs yml里面的服务id # 查看容器输出日志
docker-compose config # 检查配置
docker-compose config -q # 检查配置，有问题才有输出
docker-compose restart # 重启服务
docker-compose start # 启动服务
docker-compose stop # 停止服务
6.compose编排微服务
1）编写docker-compose.yml文件
version: '3.9'
services:
mysql:
restart: always
image: mysql:5.7.34
container_name: mysql
ports:
- 3307:3306
environment:
MYSQL_ROOT_PASSWORD: root
volumes:
- ./mysql_data:/var/lib/mysql
tomcat:
restart: always
image: tomcat:8.5.75-jdk8
container_name: tomcat
ports:
- 8080:8080
volumes:
- ./webapps:/usr/local/tomcat/webapp
networks:
default:
external: true
name: global
2）执行 docker-compose up 或者 docker-compose up -d 就可以成功启动两个容器。
