一、Docker 简介

Docker 是一个开源的应用容器引擎，是一个轻量级容器技术。
Docker 支持将软件编译成一个镜像，然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像。
运行中的这个镜像称为容器，容器启动是非常快的。
image.png
image.png

二、核心概念

docker 主机（Host）：安装了Docker程序的机器（Docker 直接安装在操作系统之上）
docker客户端（Client）：连接docker主机进行操作
docker仓库（Registry）：用来保存各种打包好的镜像
docker镜像（Images）：软件打包好的镜像，放在docker仓库中
docker容器（Container）：镜像运行之后的实例称为容器，容器是独立运行的一个或一组应用
image.png
Docker运行步骤：
1）安装Docker
2）去Docker仓库中找到这个软件对应的镜像
3）使用Docker运行这个镜像，这个镜像运行后会生成一个Docker容器
4）通过对容器的启停，来实现软件的启停。启停容器就是对软件的启停

三、安装Docker

安装Linux虚拟机

1）VMWare、 VirtualBox 虚拟机软件的安装
2）导入虚拟机文件contos.ova文件
3）启动Linux虚拟机，使用root账号登录
4）使用客户端工具连接Linux服务器进行操作
5）设置虚拟网络。桥接网络=选好网卡===接入网线
6）设置好网络后使用命令重启虚拟机网络

  1. service network restart

7）查看Linux 系统的IP

  1. ip addr

8）使用客户端工具连接Linux

安装Docker

1）检查内核版本，必须是3.10及以上

  1. uname -r

image.png
2）升级软件包（选做）如果软件版本低于3.10的需要做该步骤

  1. yum update

image.png
4)安装过程中如果出现是否确认安装，选择“是”
image.png
5）启动Docker

  1. systemctl start docker

image.png
6）检查Docker版本，通过查看docker的版本。

  1. docker -v

image.png
7）将Docker 设为开机启动

  1. systemctl enable docker

image.png
8）停止Docker

  1. systemctl stop docker

image.png

卸载Docker

  1. 停止docker
  2. systemctl stop docker 
  3. 删除docker-ce
  4. yum -y remove docker-ce
  5. 删除docker目录
  6. rm -rf /var/lib/docker

配置阿里云镜像加速器

  1. 注册一个属于自己的阿里云账户(可复用淘宝账号)
  2. 获得加速器地址连接
    • 登陆阿里云开发者平台
    • 获取加速器地址
  3. 配置本机Docker运行镜像加速器

鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，我们可以需要配置加速器来解决，
我使用的是阿里云的本人自己账号的镜像地址(需要自己注册有一个属于你自己的)： https://xxxx.mirror.aliyuncs.com

  1. 编辑docker文件
  2. vim /etc/sysconfig/docker
  4. 配置将自己账户下的阿里云加速器地址
  5. other_args="--registry-mirror=https://你自己的账号加速信息.mirror.aliyuncs.com"

  1. 重新启动Docker后台服务

    1. service docker restart

    Docker 工作原理

    Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。 容器，是一个运行时环境，就是我们前面说到的集装箱。

    为什么Docker比较比VM快

  2. docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

  3. docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。

    四、Docker 镜像

    什么是Docker镜像

  4. UnionFS（联合文件系统）

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

  1. 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这里才200M？？
对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

  1. 分层的镜像

以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

  1. 为什么 Docker 镜像要采用这种分层结构呢

最大的一个好处就是 - 共享资源
比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，
同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

特点

  1. Docker镜像都是只读的。
  2. 当容器启动时，一个新的可写层被加载到镜像的顶部。
  3. 这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

五、Docker常用命令

镜像操作

操作 命令 说明
检索 docker search 关键字:eg 我们经常去Docker Hub上去检索镜像的详细信息，如：镜像的TAG
拉取 docker pull 镜像名:tag :tag 是可选的，表示标签。多为软件的版本，默认版本是latest
列表 docker images 查看所有本地镜像
删除 docker rmi image-id 删除指定的本地镜像，image-id 镜像id.

容器操作

操作 命令 说明
运行 docker run—name contailner name -d 镜像名字 运行镜像
列表 docker ps 查看所有当前正在运行的容器
列表 docker ps -a 查看所有容器
停止 docker stop container-name/container-id 停止当前运行的容器
启动 docker start container-name/container-id 启动指定容器
删除 docker rm container-name/container-id 删除指定容器
修改 docker update container —restart=always 修改容器命令
停止退出 exit 容器停止退出
停止 ctrl+P+Q 容器不停止退出
重启 docker restart 容器ID或者容器名 重新启动容器
停止 docker kill 容器ID或者容器名 强制停止容器

容器操作流程

image.png

  1. 1、搜索镜像
  2. [root@instance-8aaq05i8 ~]# docker search redis
  3. 2、拉取镜像,如果tag就带tag,根据实际情况按tag标签拉去镜像
  4. [root@instance-8aaq05i8 ~]# docker pull redis:tag
  5. 3、根据镜像启动容器，不同镜像的参数设置请参考不同镜像的运行方式. --name 自定义镜像名称,-p 设置端口号,-d 后台运行,--requirepass redis密码
  6. [root@instance-8aaq05i8 /]# docker run -d --name 自定义镜像名称 -p 6379:6379 redis --requirepass "mypassword"
  7. 4、查看运行中的容器
  8. [root@instance-8aaq05i8 /]# docker ps
  9. 5、查看所有容器
  10. [root@instance-8aaq05i8 /]# docker ps -a
  11. 6、停止容器
  12. [root@instance-8aaq05i8 /]# docker stop 容器id
  13. 7、启动容器
  14. [root@instance-8aaq05i8 /]# docker start 容器id
  15. 8、删除容器
  16. [root@instance-8aaq05i8 /]# docker rm 容器id
  17. 9、查看容器日志
  18. [root@instance-8aaq05i8 /]# docker logs 容器名字/容器id
  19. 10、进入容器目录（非后台运行）
  20. [root@instance-8aaq05i8 /]# docker exec -it 容器名字/容器id /bin/bash
  21. 11、进入容器目录（后台运行）
  22. [root@instance-8aaq05i8 /]# docker exec -d 容器名字/容器id /bin/bash
  23. 12、进入容器目录
  24. [root@instance-8aaq05i8 /]# docker  attach -it 容器名字/容器id  路径
  25. [root@instance-8aaq05i8 /]# docker  exec -it 容器名字/容器id   路径
  26. 13、修改容器名字
  27. [root@centos-7 ~]# docker rename jenkins_cppcc cppcc_jenkins
  28. 14、将容器提交为一个新的镜像
  29. docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]
  31. 更多命令参看
  32. https://docs.docker.com/engine/reference/commandline/docker/
  33. 可以参考每一个镜像的文档

帮助命令

  1. docker version
  2. docker info
  3. docker --help

常用命令

  1. attach    Attach to a running container                 # 当前 shell 下 attach 连接指定运行镜像
  2. build     Build an image from a Dockerfile              # 通过 Dockerfile 定制镜像
  3. commit    Create a new image from a container changes   # 提交当前容器为新的镜像
  4. cp        Copy files/folders from the containers filesystem to the host path   #从容器中拷贝指定文件或者目录到宿主机中
  5. create    Create a new container                        # 创建一个新的容器，同 run，但不启动容器
  6. diff      Inspect changes on a container's filesystem   # 查看 docker 容器变化
  7. events    Get real time events from the server          # 从 docker 服务获取容器实时事件
  8. exec      Run a command in an existing container        # 在已存在的容器上运行命令
  9. export    Stream the contents of a container as a tar archive   # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
  10. history   Show the history of an image                  # 展示一个镜像形成历史
  11. images    List images                                   # 列出系统当前镜像
  12. import    Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
  13. info      Display system-wide information               # 显示系统相关信息
  14. inspect   Return low-level information on a container   # 查看容器详细信息
  15. kill      Kill a running container                      # kill 指定 docker 容器
  16. load      Load an image from a tar archive              # 从一个 tar 包中加载一个镜像[对应 save]
  17. login     Register or Login to the docker registry server    # 注册或者登陆一个 docker 源服务器
  18. logout    Log out from a Docker registry server          # 从当前 Docker registry 退出
  19. logs      Fetch the logs of a container                 # 输出当前容器日志信息
  20. port      Lookup the public-facing port which is NAT-ed to PRIVATE_PORT    # 查看映射端口对应的容器内部源端口
  21. pause     Pause all processes within a container        # 暂停容器
  22. ps        List containers                               # 列出容器列表
  23. pull      Pull an image or a repository from the docker registry server   # 从docker镜像源服务器拉取指定镜像或者库镜像
  24. push      Push an image or a repository to the docker registry server    # 推送指定镜像或者库镜像至docker源服务器
  25. restart   Restart a running container                   # 重启运行的容器
  26. rm        Remove one or more containers                 # 移除一个或者多个容器
  27. rmi       Remove one or more images             # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
  28. run       Run a command in a new container              # 创建一个新的容器并运行一个命令
  29. save      Save an image to a tar archive                # 保存一个镜像为一个 tar 包[对应 load]
  30. search    Search for an image on the Docker Hub         # 在 docker hub 中搜索镜像
  31. start     Start a stopped containers                    # 启动容器
  32. stop      Stop a running containers                     # 停止容器
  33. tag       Tag an image into a repository                # 给源中镜像打标签
  34. top       Lookup the running processes of a container   # 查看容器中运行的进程信息
  35. unpause   Unpause a paused container                    # 取消暂停容器
  36. version   Show the docker version information           # 查看 docker 版本号
  37. wait      Block until a container stops, then print its exit code   # 截取容器停止时的退出状态值

六、Docker容器数据卷

什么是容器卷

先来看看Docker的理念：

  1. 将运用与运行的环境打包形成容器运行 ，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
  2. 容器之间希望有可能共享数据
  3. Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了。为了能保存数据在docker中我们使用卷。

  4. 一句话：有点类似我们Redis里面的rdb和aof文件

    容器卷能干什么

    卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性，卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷
    特点：

  5. 数据卷可在容器之间共享或重用数据

  6. 卷中的更改可以直接生效
  7. 数据卷中的更改不会包含在镜像的更新中
  8. 数据卷的生命周期一直持续到没有容器使用它为止

  9. 容器的持久化，容器间继承+共享数据

    添加容器卷

  10. 直接命令添加

    1. #添加容器卷命令，通过-v添加容器卷
    2. docker run -it -v /宿主机绝对路径目录:/容器内目录      镜像名
    3. #查看数据卷是否挂载成功
    4. docker inspect 容器ID

  11. DockerFile添加

根目录下新建mydocker文件夹并进入

  1. mkdir /mydocker

可在Dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷

  1. VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
  2. 说明：
  3. 出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
  4. 由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

File构建

  1. # volume test
  2. FROM centos
  3. VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
  4. CMD echo "finished,--------success1"
  5. CMD /bin/bash

步骤四：build后生成镜像，获得一个新镜像zzyy/centos
步骤五：run容器
通过上述步骤，容器内的卷目录地址已经知道对应的主机目录地址哪
注意：Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个—privileged=true参数即可

数据卷容器

数据容器卷是命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器
以上一步新建的镜像zzyy/centos为模板并运行容器dc01/dc02/dc03
步骤一：先启动一个父容器dc01，在dataVolumeContainer2新增内容

  1. docker run -it --name dc01

步骤二：dc02/dc03继承自dc01

  1. #容器间传递共享(--volumes-from)
  2. docker run -it --name dc02 --volumes-from dc01 zzyy/centos

步骤三：dc02/dc03分别在dataVolumeContainer2各自新增内容
步骤四：回到dc01可以看到02/03各自添加的都能共享了
步骤五：删除dc01，dc02修改后dc03可否访问
步骤六：删除dc02后dc03可否访问
步骤七：新建dc04继承dc03后再删除dc03
结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

七、DockerFile 解析

DockerFile 介绍

  1. Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

  2. DockerFile构建三个步骤

    1. 编写Dockerfile文件
    2. docker build
    3. docker run

    DockerFile构建过程解析

  3. Dockerfile内容基础知识

  • 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
  • 指令按照从上到下，顺序执行

  • 表示注释

  • 每条指令都会创建一个新的镜像层，并对镜像进行提交
  1. Docker执行Dockerfile的大致流程
  • docker从基础镜像运行一个容器
  • 执行一条指令并对容器作出修改
  • 执行类似docker commit的操作提交一个新的镜像层
  • docker再基于刚提交的镜像运行一个新容器
  • 执行dockerfile中的下一条指令直到所有指令都执行完成
  1. 总结

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段

  • Dockerfile是软件的原材料
  • Docker镜像是软件的交付品
  • Docker容器则可以认为是软件的运行态。
    Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

1 Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
2 Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;
3 Docker容器，容器是直接提供服务的。

DockerFile保留字段

  1. FROM  基础镜像，当前新镜像是基于哪个镜像的
  2. MAINTAINER  镜像维护者的姓名和邮箱地址
  3. RUN   容器构建时需要运行的命令
  4. EXPOSE   当前容器对外暴露出的端口
  5. WORKDIR   指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
  7. ENV  用来在构建镜像过程中设置环境变量
  8. ENV MY_PATH /usr/mytest
  9. 这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；也可以在其它指令中直接使用这些环境变量，
  10. 比如：WORKDIR $MY_PATH
  12. ADD   将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
  13. COPY   类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
  14. VOLUME   容器数据卷，用于数据保存和持久化工作
  16. CMD    指定一个容器启动时要运行的命令
  17. Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
  19. ENTRYPOINT 指定一个容器启动时要运行的命令
  20. ENTRYPOINT 的目的和 CMD 一样，都是在指定容器启动程序及参数
  23. ONBUILD    当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

案例

  1. Base镜像(scratch)

Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的

  1. 自定义镜像mycentos

自定义mycentos目的使我们自己的镜像具备如下：
登陆后的默认路径
vim编辑器
查看网络配置ifconfig支持

  1. 准备编写DockerFile文件

    1. #myCentOS内容DockerFile
    2. FROM centosMAINTAINER zzyy<zzyy167@126.com>
    3. ENV MYPATH /usr/localWORKDIR $MYPATH
    4. RUN yum -y install vimRUN yum -y install net-tools
    5. EXPOSE 80
    6. CMD echo $MYPATHCMD echo "success--------------ok"CMD /bin/bash

  2. 构建

    1. #会看到 docker build 命令最后有一个 . . 表示当前目录
    2. docker build -t 新镜像名字:TAG .

  3. 运行

    1. docker run -it 新镜像名字:TAG

  4. 列出镜像的变更历史

    1. docker history 镜像名

    CMD/ENTRYPOINT 镜像案例

  5. cmd和ENTRYPOINT都是指定一个容器启动时要运行的命令

  6. CMD（Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换）

    1. docker run -it -p 8888:8080 tomcat ls -l

    制作CMD版可以查询IP信息的容器

    1. FROM centosRUN yum install -y curlCMD [ "curl", "-s", "http://ip.cn" ]

  7. ENTRYPOINT （docker run 之后的参数会被当做参数传递给 ENTRYPOINT，之后形成新的命令组合）

制作ENTROYPOINT版查询IP信息的容器

  1. FROM centos
  2. RUN yum install -y curl
  3. ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]

自定义镜像Tomcat9

步骤一：mkdir -p /zzyyuse/mydockerfile/tomcat9
步骤二：在上述目录下touch c.txt
步骤三：将jdk和tomcat安装的压缩包拷贝进上一步目录
步骤四：在/zzyyuse/mydockerfile/tomcat9目录下新建Dockerfile文件

  1.  FROM         centos
  2.  MAINTAINER    zzyy<zzyybs@126.com>
  3.  #把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
  4.  COPY c.txt /usr/local/cincontainer.txt
  5.  #把java与tomcat添加到容器中
  6.  ADD jdk-8u171-linux-x64.tar.gz /usr/local/ADD apache-tomcat-9.0.8.tar.gz /usr/local/
  7.  #安装vim编辑器
  8.  RUN yum -y install vim 
  9.  #设置工作访问时候的WORKDIR路径，登录落脚点
  10.  ENV MYPATH /usr/local
  11.  WORKDIR $MYPATH
  12.  #配置java与tomcat环境变量
  13.  ENV JAVA_HOME /usr/local/jdk1.8.0_171ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
  14.  ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
  15.  ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
  16.  ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
  17.  #容器运行时监听的端口
  18.  EXPOSE  8080
  19.  #启动时运行tomcat
  20.  ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
  21.  CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
  22.  CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

步骤五：构建 DockerFile文件
步骤六：启动镜像

  1.  docker run -d -p 9080:8080 --name myt9 -v /zzyyuse/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs --privileged=true zzyytomcat9

注意：
Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个—privileged=true参数即可

本地镜像发布到阿里云

生成镜像

  1. 编写DockerFile

  2. 从容器创建一个新的镜像

    1. docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]
    2. #OPTIONS说明：
    3. #-a :提交的镜像作者；
    4. #-m :提交时的说明文字；

    将本地镜像推送到阿里云

  3. 本地镜像素材原型

  4. 阿里云开发者平台，https://dev.aliyun.com/search.html
  5. 创建仓库镜像（命名空间、仓库名称）
  6. 将镜像推送到registry
  7. 公有云可以查询到
  8. 查看详情

    将阿里云上的镜像下载到本地