compose 安装docker与docker docker-compose与docker

一个简单的docker教学

• 一、什么是Docker
• 二、 基本概念

• 1、镜像（image）
• 2、容器（container）
• 3、仓库（repository）
• 4、分层工作流程

• 三、安装

• 1、 安装流程
• 2、 测试docker

• 四、使用Docker

• 1、使用镜像
• 2、操作容器
• 3、简单搭建nginx
• 4、commit镜像

• 五、Docker进阶

• 1、数据卷

• （1）指定路径挂载
• （2）具名挂载
• （3）匿名挂载

• 2、数据卷容器
• 3、DockerFile

• （1）命令基础
• （2）构建自己的centos
• （3）构建自己的Tomcat
• （4）发布到DockerHub
• （5）挂载数据卷

• 4、docker-compose
• 5、容器间通信

• bridge模式
• host模式
• nono模式

• 6、打包镜像成压缩包

• 压缩镜像
• 载入镜像

一、什么是Docker

1. Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的Linux或Windows操作系统的机器上，也可以实现虚拟化。
2. 容器是完全使用沙箱机制，相互之间不会有任何接口
3. docker是client-server结构的系统，守护进程运行在主机上，通过socker与客户端访问

Docker和虚拟机

1. 快速启动
   docker容器内的应用直接运行于宿主内核，容器没有自己的内核，也没有虚拟硬件，较为轻便，大大的节约了开发、测试、部署的时间。虚拟机需要加载系统内核比较慢。
2. 高效利用系统资源
   由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker 对系统资源的利用率更高
3. 运行环境一致
   Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的，用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上。
4. 持续交付和部署
   开发人员可以通过 Dockerfile 来进行镜像构建，并结合持续集成(Continuous Integration) 系统进行集成测试，而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合持续部署(Continuous Delivery/Deployment) 系统进行自动部署。使用 Dockerfile 可以使镜像构建透明化
5. 维护和扩展
   Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单

二、 基本概念

1、镜像（image）

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

1. Docker镜像好比一个模板，通过这个模板来创建容器服务，比如一个nginx镜像=> run=>nginx容器1（提供服务）；
2. 通过这个镜像可以创建很多容器，最终的服务或者是项目就是运行在容器中的。
3. Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）
4. 镜像不包含任何动态数据，其内容在构建之后也不会被改变，只要当容器启动时才会添加一个新的可写层到镜像的顶部

（2）Unions FS 联合文件系统

UnionsFS是轻量级高性能的文件系统，支持对文件系统的修改作为一次提交来一层层叠加，可以同时将不同目录挂载到同一个虚拟文件系统下。Unions文件系统是docker镜像的基础。镜像可以通过分层来继承，基于基础镜像制作各种特定功能的镜像
（3）分层存储

1. 镜像包含操作系统完整的 root 文件系统，体积往往很庞大， Docker是利用 Union FS 技术，将其设计为分层存储的架构
2. 严格来说，镜像只是一个虚拟的概念，实际体现并不是由一个文件组成，而是由一组文件系统组成，或者说由多层文件系统联合组成。
3. 镜像构建时会一层层构建。每一层构建完成后不会再发生改变，后一层的任何改变只发生在自己这一层。比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。
4. 在构建镜像的时候，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
6. 分层存储、分层下载的特征还使得镜像的复用、定制变的更为容易。当两个应用有相同的层时可以直接复用

2、容器（container）

（1） 概念

1. 容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的命名空间。
2. 容器拥有自己的 root 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。
3. 容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全
4. Docker可以利用容器技术，独立运行一个或者一组应用，通过镜像来创建；
5. 容器可以被创建、启动、停止、删除、暂停等。

（2）镜像和容器的关系
镜像和容器的关系就像是面向对象程序设计中的类和实例 一样，镜像是静态的定义，容器是镜像运行时的实体。

（3）容器存储层

1. 容器也是分层存储的，每一个容器运行都是以镜像为基础层，在其上创建一个当前容器的存储层，我们称这个为容器运行时读写而准备的存储层为容器存储层
2. 容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡，任何保存于容器存储层的信息都会随容器删除而丢失。
3. 容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷（Volume） 或者 绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发生读写，其性能和稳定性更高。
4. 数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器删除或者重新运行之后，数据却不会丢失。

3、仓库（repository）

（1）概念

1. 镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务
2. 存放镜像的地方，分为公用仓库或者私有仓库。默认的是Docker Hub，国内有容器服务器，可以配置镜像加速

4、分层工作流程

在容器中进行操作后，还可以将容器commit成一个镜像，传到远程仓库后让别人使用

三、安装

1、 安装流程

安装前首先要确认你的linux版本，这里以Ubantu为例，具体安装的要求和安装的方法可以在https://docs.docker.com/engine/install/ubuntu/官网查看，比较全面和细节

安装后可能会遇到的问题

docker进程使用Unix Socket而不是TCP端口。而默认情况下，Unix socket属于root用户，需要root权限才能访问，而在Ubuntu18.04安装docker之后，默认以登陆用户身份启动docker，这时候运行docker命令会出错

解决办法

安装docker时，会创建了一个名为docker的用户组，守护进程启动的时候，会默认赋予用户组docker读写Linux socket的权限
所以只要将当前用户加入到docker用户组中，当前用户就有权限访问Linux socket了，进而就可以执行docker相关命令

# 方法一：
sudo gpasswd -a [USER] docker     #将登陆用户加入到docker用户组中
newgrp docker     #更新用户组
sudo systemctl restart docker  #重启docker

#方法二：
sudo passwd root #设置切换root用户的密码
su       		 #切换成root用户
cd /home         #进入到home目录

如果用户组docker不存在（安装完一般就有了），则可先创建该用户组：

sudo groupadd docker     #创建docker用户组

2、 测试docker

使用hello-world进行简单测试

1. 运行hello-world容器

docker run hello-world

docker run的流程

log解读

1. 第一行显示本地未找到hello-world镜像
2. 第二行表示去官方仓库的library下去pull hello-world镜像
3. 拉取完成后通过run将容器运行起来了，显示Hello from docker

如上显示，说明docker安装测试成功

本篇文章列出的只是部分的docker命令，docker命令尤其的多，想详细了解可以去官方文档查看https://docs.docker.com/engine/reference/commandline/run/

四、使用Docker

某个镜像的详细部署细节可以在官方仓库去搜索查看https://hub.docker.com/

1、使用镜像

（1）搜索镜像

docker search mysql

（2）下载镜像

docker pull mysql[版本]
#不选择版本，默认最新版

（3） 查看镜像

docker image ls

（4）删除镜像

docker rmi  [image id]
docker rmi -f $(docker image -aq) # 以docker image -aq的查询结果未删除条件，删除相应的镜像
#注意删除镜像前需要先删除镜像对应的容器，不然会报错

2、操作容器

有了镜像才可以创建容器，这里先下载centos镜像 docker pull centos

（1）新建容器并启动

docker run [可选参数] image  # docker run -it centos /bin/bash

# --name="name"  定义容器名字
# -d             后台方式运行
# -it            前台模式交互运行
# -p             指定容器端口：-p 8080:8080
# -P             随机指定端口

docker run：运行容器，-it：前台交互运行，centos：启动的镜像，/bin/bash ：通过bash脚本来执行交互命令

（2）查看运行的容器

# 查看正在运行的容器
docker ps  # docker container ls 这俩一样
#查看正在和曾经运行过的容器
docker ps -a

（3）启动和停止容器

docker start 容器id     #启动容器
docker restart 容器id   #重启容器
docker stop 容器id      #停止容器
docker kill 容器id      #强制停止容器

（4）查看日志

docker logs
docker logs --tail number  # 查看日志的条数

（5）后台启动容器

docker run -d centos  # 后台启动

前台启动

Docker会在容器中启动进程，同时将当前的命令行窗口附着到容器的标准输入、标准输出和标准错误中。也就是说容器中所有的输出都可以在当前窗口中看到

后台启动

此时所有I/O数据只能通过网络资源或者共享卷组来进行交互。因为容器不再监听执行docker run的这个终端命令行窗口。但你可以通过执行docker attach来重新附着到该容器的会话中。

当用后台运行非持续性服务时，比如上面的hello-world，run完之后输出了一个Hello from docker之后容器就会自动退出，容器变成exited状态

（6）查看容器中的进程信息

docker top 容器id

（7）查看容器的元数据

docker inspect 容器id
#docker inspect a7e2c2cd27e4

（8）进入正在运行的容器

# 进入容器后开启一个新的进程，可以在里面进行操作
docker exec -it 容器id /bin/bash
# 进入容器正在执行的终端，不会启动新的进程
docker attach 容器id

（9）从容器内拷贝文件到宿主机上

docker cp 容器id:/文件路径 目标路径  #docker cp 0a534ad32482:/usr/share/nginx/html/index.html ~/
# linux中~/表示根目录  

#从宿主机将文件拷贝到容器内
docker cp ~/index.html 0a534ad32482:/usr/share/nginx/html/index.html

（10）退出容器

exit            # 直接容器停止并退出
ctrl+p+q        # 容器不停止就退出

（11） 删除容器

docker rm [container id]   # docker rm 080fdb857a8a
#删除正在运行的容器需要强制 rm -f
docker rm $(docker ps -aq)  # 以docker ps -aq为查询条件删除所有容器

3、简单搭建nginx

1. 搜索nginx镜像然后pull到本地

docker search nginx
docker pull nginx
docker image ls

2. 创建并运行容器

docker run -d --name nginx001 -p 8080:80 nginx
# -d后台运行  --name给容器命名  -p 宿主机端口:容器内端口

3. 本地测试

curl localhost:8080

访问localhost:8080也能看到搭建成功

访问原理

4. 关闭容器

docker stop 080fdb857a8a

容器关闭后，再通过localhost:8080就没法访问了

4、commit镜像

当你想保存一个容器的状态时，可以将其commit成一个镜像，以后可以直接使用该镜像

下面为构建镜像的原理图，先从远程仓库里push下来我们需要的基础镜像，然后在这些镜像上面加一层可写容器进行自定义功能开发，然后将整体commit成一个镜像，供日后使用。

用nginx为例，将修改过的容器commit成镜像

1. 下载nginx镜像，然后运行容器

docker pull nginx
docker run -it -p 8080:8080 nginx

2. 对nginx进行个性化设置
   nginx的默认web文件是/usr/share/nginx/html/index.html，这里简单对其进行修改

# 进入默认web目录
cd usr/share/nginx/html

# 将需要修改的文件拷贝到宿主机上
docker cp 0a534ad32482:/usr/share/nginx/html/index.html ~/ahua

# 然后在宿主机上对文件进行修改
vim index.html

#将修改后的内容拷贝回容器
docker cp ~/ahua/index.html 0a534ad32482:/usr/share/nginx/html/

3. 查看修改结果

# 进入容器
docker exec -it 0a534ad32482 /bin/bash
# 进入默认web目录
cd usr/share/nginx/html
# 查看index.html文件修改情况
cat index.html

宿主机打开localhost:8080查看

4. 将容器commit成镜像

# 和git类似
docker commit -m='描述信息' -a='作者' 容器id  提交后的镜像名:[tag]
#docker commit -m='alter nginx for test docker' -a='ahua' d7c72ba9e6e5 nginx-ahua

# 查看commit后的镜像
docker image ls

五、Docker进阶

1、数据卷

1. 概念
   数据卷是一种数据共享的技术，将数据docker容器产生的数据同步到本地，实现数据持久化和同步操作
2. 使用数据卷

（1）指定路径挂载

-v 宿主机路径:容器路径

docker run -it -v 主机目录:容器目录
# docker run -it -v ~/docker-container:/home centos
# docker run -it -v ~/docker-container:/home:ro centos  只读，只能通过宿主机来改变
# docker run -it -v ~/docker-container:/home:rw centos  可读可写

# 查看容器详细信息
docker inspect 容器id

找到mount可以查看宿主机和容器内的文件是否挂载成功

进入容器测试

# 进入容器
docker attach 0bceb638e588
# 进入挂载的容器目录
cd home
# 查看目录和宿主机内的文件
ls
# 在宿主机或者容器目录内创建一个新文件
touch ahua.js

如果看到宿主机和容器内同时出现了创建的ahua.js文件，则说明挂载成功

相同的，在宿主机这边修改文件，容器这边也会同步，即使是容器已经关闭了，再次启动容器查看，修改也会同步

所以，如果需要修改容器内的文件，只需要将其挂载到本地，通过本地进行修改即可实时同步，不用cp出去再cp回来那么麻烦了

（2）具名挂载

-v 卷名:容器内路径

# 不指定主机目录，指定容器内目录和挂载的数据卷名字
docker run -d -P --name nginx000 -v nginx-name:/ect/nginx nginx
# -P:随机匹配端口  nginx-name：指定数据卷的名字  /ect/nginx:容器内进行数据挂载的目录

# 查看卷挂载情况
docker volume ls

#查看数据卷挂载到宿主机的位置
docker inspect [volume name]
# docker inspect nginx-name

可以cd到宿主机中检查是否有这样的目录

（3）匿名挂载

-v容器路径

#不指定主机目录，只有容器内目录
docker run -d -P --name nginx007 -v /ect/nginx nginx
# nginx007:指定的容器名 

# volume name就是匿名挂载卷的名字

2、数据卷容器

实现两个或者多个容器间的数据共享，一样是利用一个容器和另一个容器共享数据

1. 启动容器

# 开启第一个容器（父容器）
docker run -it --name container-centos01 ec971a4e3402 /bin/bash
# container-centos01:自定义容器名  ec971a4e3402：镜像id（镜像名也行）

# 开启第二个容器
docker run -it --name container-centos02 --volumes-from container-centos01 ec971a4e3402 /bin/bash
# container-centos02 --volumes-from container-centos01 ：container-centos02和container-centos01绑定（02继承01）

# 开启第三个容器
docker run -it --name container-centos03 --volumes-from container-centos01 ec971a4e3402 /bin/bash

这里volume01和volume02为三个容器的共享数据卷，是通过dockerFile创建的，具体创建方法在下文有讲到

三个容器共享数据卷里的内容会保持同步，停掉或者删除一个容器不会影响其他容器内的数据。容器共享卷之间的数据共享是一种双向拷贝。只有所有容器全部停止数据卷才会消失。实现数据持久化可以将数据挂载到本地

3、DockerFile

用来构建docker镜像的构建文件，是一个命令参数脚本。这个也可以去官网https://hub.docker.com/搜索具体某个镜像去查看其对应的dockerFile

构建步骤

1. 编写dockerFile文件
2. docker build构建成一个镜像
3. docker run 运行镜像
4. docker push发布镜像

（1）命令基础

1. 要求

1. 每个指令必须大写
	2. 从上到下执行
	3. #表示注释
	4. 每个指令都会创建一个新的镜像层并提交

2. 具体命令

指令	含义
FROM	基础镜像，后面的搭建都基于这里
MAINTAINER	作者信息 名字＋邮箱
RUN	镜像构建时需要运行的命令
ADD	添加内容
WORKDIR	指定容器的工作目录，容器启动后会进入该目录
VOLUME	指定数据卷挂载目录的名字
EXPOSE	暴露的端口
CMD	指定容器启动的时候需要运行的命令 ，在容器中追加的命令会替换掉CMD的命令
ENTRYPOINT	指定容器启动时运行的命令，可以在容器中追加命令
ONBUILD	构建一个被继承的DockerFile时， 会运行ONBUILD指令
COPY	将文件copy到镜像中
ENV	构建时设置环境变量

（2）构建自己的centos

1. 在本地新建一个文件夹存放dockerFIle脚本
2. 编写dockerFile命令

# base image
FROM centos

# author
MAINTAINER ahua<[e-mail]>

# Environment Variables
# MYPATH is mean the path after entering
ENV MYPATH /usr/local

# workspace
WORKDIR &MYPATH

# Execution of commands
RUN yum -y install vim
RUN yum -y install net-tools

# Exposed ports
EXPOSE 80

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

3. 通过文件构建镜像

docker build -f dockerFile文件路径 -t 镜像名:版本号 .
# docker build -f dockerFile-centos-ahua -t centos-ahua:1.0 .
# -f 指定是哪个文件  -t 生成的目标镜像 . 当前目录下

构建过程

4. 测试运行

查看镜像

docker image ls

结果

运行容器

docker run -it centos-ahua /bin/bash

安装的vim和net-tools工具都可以使用了（docker中的centos是精简版，没有集成vim和net-tools）

还可以通过docker history 镜像id 去查看镜像的构建历史

（3）构建自己的Tomcat

1. 下载Tomcat和jdk的压缩包

tomcat：https://tomcat.apache.org/download-10.cgi#10.0.14

jdk：https://www.oracle.com/java/technologies/downloads/#java8-linux

2. 创建Dockerfile文件

# base image
FROM centos

# author
MAINTAINER ahua<[e-mail]>

COPY readme.md /usr/local/readme.md

# add and decompress jdk to /usr/local
ADD jdk-8u311-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.56.tar.gz /usr/local

# Environment Variables
# MYPATH is mean the path after entering
ENV MYPATH /usr/local

# workspace
WORKDIR &MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_311
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CALALINA_HOME /usr/local/apache-tomcat-9.0.56
ENV CALALINA_BASE /usr/local/apache-tomcat-9.0.56
ENV PATH $PATH:$JAVA_HOME/bin:$CALALINA_HOME/lib:$CALALINA_HOME/bin

# Execution of commands
RUN yum -y install vim
RUN yum -y install net-tools

# Exposed ports
EXPOSE 8080

# start tomcat and show the logs
CMD /usr/local/apache-tomcat-9.0.56/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.56/bin/logscatalina.out

3. 构建镜像
   这里如果只是构建镜像的话镜像名不加用户名和版本号，如果需要提交到DockerHub的话，没有用户名和版本号是会被拒绝的

docker build -t aaahua/tomcat-ahua:1.0 .
# 因为Dockerfile是标准文件名 所以不需要-f指定文件
# aaahua 用户名  1.0版本号

构建成功

4. 创建容器

docker run -d -p 9090:8080 --name ahua-tomcat -v /home/ahua/tomcat-ahua/test:/usr/local/apache-tomcat-9.0.56/webapps/test -v /home/ahua/tomcat-ahua/logs:/usr/local/apache-tomcat-9.0.56/logs tomcat-ahua
# /home/ahua/tomcat-ahua/test:/usr/local/apache-tomcat-9.0.56/webapps/test 表示将tomcat的test挂载到主机上进行数据共享
#/home/ahua/tomcat-ahua/logs:/url/local/pache-tomcat-9.0.56/logs 表示将tomcat的日志挂载到主机上

5. 本地测试是否部署成功

curl localhost:9090

浏览器访问localhost:9090

6. 本地项目构建

因为运行容器的时候已经将本地的/home/ahua/tomcat-ahua/test文件夹和容器的/usr/local/apache-tomcat-9.0.56/webapps/test文件夹挂载到了一起，所以可以直接在本地的test文件夹中创建自己的项目

# 查看容器的信息
docker inspect 容器id

可以看到数据挂载的详细信息

在text目录下创建index.html文件

cd home/ahua/tomcat-ahua/test
vim index.html
# index.html中的内容
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <p3>hello,阿花!</p3>
</body>
</html>

浏览器测试，访问localhost:9090/test

（4）发布到DockerHub

1. 官网注册账号 https://hub.docker.com/
2. 在自己服务器上提交镜像
   （1）登录DockerHub

docker login -u 用户名

输入密码即可

（2）提交镜像

docker push aaahua/tomcat-ahua:1.0

发布成功，可以用docker search 搜索到

（3）将镜像打成压缩包

dockers save -o 路径

（4）使用压缩好的镜像

docker load

docker整体流程图

（5）挂载数据卷

1. 在目录下创建一个dockerFile-volume文件夹，用于存放挂载的数据

mkdir dockerFile-volume

2. 创建文件夹及编写脚本文件

# 进入文件夹
cd dockerFile-volume

# 创建脚本文件
vim dockerFile01

# 编写脚本
FROM centos
VOLUME ["volume01","volume02"]
CMD echo'---------end--------------'
CMD /bin/bash

3. 生成镜像

docker build -f dockerFile01 -t ahua-centos .
#   dockerFile01:脚本文件 ahua-centos:镜像名字

镜像生成过程也是分层的，每个命令就是一层

4. 启动容器查看数据卷是否创建成功

docker image ls
docker run -it 容器id /bin/bash
ls

这volume01和volume02就是生成的数据卷

5. 回到宿主机查看挂载情况

# 可以看到mounts里面有对应的宿主机地址
docker inspect 容器id

docker运行的命令图

4、docker-compose

这部分我感觉官方写的很详细很好懂，虽然是英文的，翻译软件用一下或者直接跟着代码盲敲也不会有问题

1. 下载安装https://docs.docker.com/compose/install/
2. 配合python的flask框架一起使用https://docs.docker.com/compose/gettingstarted/

5、容器间通信

docker网络相关命令

docker network ls #查看所有docker网络

docker network inspect 网络名  #查看该网络的详细信息

docker network rm 网络名  #删除该网络

bridge模式

利用docker network进行容器间通信，相当于创建了一个虚拟以太网网桥，

bridge也是docker-compose默认创建网络的方式

① 创建docker network

docker network create [ option ]  network名    # docker network create my-net

② 将容器添加到docker network

# 1. 将容器container-ahua加入 my-net 网络
docker network connect my-net container-ahua

# 2. 运行container-ahua容器并加入网络使用--network参数
docker -d --network my-net container-ahua

③ 从网络中移除容器

docker network disconnect my-net container-ahua

host模式

host模式下容器和宿主机共ip，通过访问宿主机ip可以访问到容器。

例如宿主机ip为192.168.152.143，容器开放端口80，那么在宿主机80端口没有被占用的情况下访问192.168.152.143:80就可以访问到主机，缺点是主机和容器间无法通信

使用host方式可以在使用--network host来指定

docker run -d --network my-net  image

在docker-compose中通过 network_mode: "host"指定

nono模式

顾名思义，没有网络，默认是什么都没有只有IO，通过--network none指定即可。

6、打包镜像成压缩包

压缩镜像

docker save -o 压缩包名.tar 镜像名[版本]
# docker save -o mongo.tar mongo:3.6.8

载入镜像

docker load -i mongo.tar