alpine镜像源_alpine 镜像源

2026-04-08 11:13:26 6

现在，请允许我来为大家详细解释一下alpine镜像源的问题，希望我的回答能够帮助到大家。关于alpine镜像源的讨论，我们正式开始。

1.alpine镜像密码有效期

2.Docker镜像的导出和导入，打标签，提交到本地仓库

3.一文教您如何通过 Docker 快速搭建各种测试环境

4.超值一篇分享，Docker：从入门到实战过程全记录

alpine镜像密码有效期

alpine镜像密码有效期是30天。

alpine镜像在构建镜像过程中作为基础镜像占比越来越高，下面是alpine镜像中包管理工具apk使用相关示例：

1、apk-help命令查看完整的包管理命令。

2、apk update：从远程镜像源中更新本地镜像源索引。

3、apk add：安装PACKAGES并自动解决依赖关系，也可以从第三方仓库添加软件包。

Alpine 操作系统是一个面向安全的轻型 Linux 发行版。它不同于通常 Linux 发行版，Alpine 采用了 musl libc 和 busybox 以减小系统的体积和运行时资源消耗，但功能上比 busybox 又完善的多，因此得到开源社区越来越多的青睐。

在保持瘦身的同时，Alpine 还提供了自己的包管理工具 apk，可以通过网站上查询包信息，也可以直接通过 apk 命令直接查询和安装各种软件。

总结如下：

Alpine Linux Docker镜像基于Alpine Linux操作系统，后者是一个面向安全的轻型Linux发行版。不同于通常Linux发行版，Alpine Linux采用了musl libc和busybox以减小系统的体积和运行时资源消耗。在保持瘦身的同时。

Alpine Linux还提供了自己的包管理工具apk，可以在其网站上查询，或者直接通过apk命令查询和安装。

Docker镜像的导出和导入，打标签，提交到本地仓库

## 背景 ##

我最初使用Docker的时候，每个人都在说它用起来有多简单方便，它内部的机制是有多么好，它为我们节省了多少时间。但是当我一使用它就发现，几乎所有镜像都是臃肿而且不安全的（没有使用包签名，盲目相信上游的镜像库以<code>curl

| sh</code>的方式安装)，而且也没有一个镜像能实现Docker的初衷：隔离，单进程，容易分发，简洁。

Docker镜像本来不是为了取代复杂的虚拟机而设计的，后者有完整的日志、监控、警报和资源管理模块。而Docker则倾向于利用内核的<code>cgroups</code>和<code>namespaces</code>特性进行封装组合，这就好像：

在物理机器环境下，一旦内核完成了初始化，<code>init</code>进程就起来了。

这也是为什么当你在Dockerfile的<code>CMD</code>指令启动的进程PID是1，这是与Unix中的进程机制类似的。

现在请查看一下你的进程列表，使用<code>top</code>或者<code>ps</code>，你会看到<code>init</code>进程占用的也是这个PID，这是每个类Unix系统的核心进程，所有进程的父进程，一旦你理解这个概念：在类Unix系统上每个进程都是init进程的子进程，你会理解Docker容器里不应该有无关的修饰文件，它应该是刚好满足进程运行需要。

如何开始

现在的应用多数是大型复杂的系统，通常都需要很多依赖库，例如有调度，编译和很多其他相关工具类应用，它们的架构通常封装性良好，通过一层层的抽象和接口把底层细节隐藏了，从某种程度上说，这也算是一种容器，但是从系统架构视角看，我们需要一种比以往虚拟环境更简单的方案了。

以Java为例

从零开始，思考你要构建一个最通用的基础容器，想想你的应用本身，它运行需要什么？

可能性有很多，如果你要运行Java应用，它需要Java运行时；如果运行Rails应用，它需要Ruby解释器，对Python应用也一样。Go和其他一些编译型语言有些许不同，我以下会提到。

在Java例子中，下一步要想的是：JRE需要什么依赖才能运行？因为它是让应用能运行的最重要的组件，所以很自然的下一步就是要想清楚JRE运行依赖于什么。

而实际上JRE并没太多依赖，它本来就是作为操作系统的抽象层，使代码不依赖于宿主系统运行，因此安装好JRE就基本准备就绪了。

（实际上，对操作系统的独立性并不是理所当然的事，有非常多的系统特有API和专有的系统扩展，但是便于举例，我们把注意力放在简单的情况下）

在Linux上，JVM主要是调用系统的C语言库，Oracle的官方JRE，使用的是libc，也就是glibc，这意味着你要运行任何Java程序，都需要先装好glibc。另外你可能需要某种shell来管理环境，还有一个与外部通讯的接口，例如网络和资源的接口。

我们总结一下Java应用示例需要的最低配置是：

JRE，在例子中我们使用Oracle JRE

glibc，JRE的依赖

一个基础环境（包含网络、内存、文件系统等资源管理工具）

## 走进Alpine Linux ##

Alpine Linux最近得到很多关注，主要是因为它打包了一系列的经过验签的可信任的依赖，并且还保持体积在2MB！而在本文发布时，其他的一些镜像分发版如下：

ubuntu:latest: 66MB (已经瘦身了非常多了，以前有些版本超过600MB)

debian:latest: 55MB (同上，一开始是200MB以上的）

arch:latest: 145MB

busybox:latest: 676KB (是的！KB，我稍后会讨论它)

alpine:latest: 2MB (2MB，包含一个包管理工具的Linux系统)

** Busybox是最小的竞争者？**

从上边的对比中你可以看到，在体积上唯一能打败Alpine Linux的是Busybox，所以现在几乎所有嵌入式系统都是使用它，它被应用在路由器，交换机，ATM，或者你的吐司机上。它作为一个最最基础的环境，但是又提供了足够容易维护的shell接口。

在网上有很多文章解释了为什么人们会选择Alpine Linux而不是Busybox，我在这总结一下：

开放活跃的软件包仓库：Alpine

Linux使用apk包管理工具，它集成在Docker镜像中，而Busybox你需要另外安装一个包管理器，例如opkg，更甚者，你需要寻找一个稳定的包仓库源（这几乎没有），Alpine的包仓库中提供了大量常用的依赖包，例如，如果你仍然需要在容器中编译NodeJS或Ruby之类的代码，你可以直接运行apk来添加nodejs和ruby，这在几秒内便可以完成。

体积确实重要，但是当你在功能性，灵活性，易用性和1.5MB之间衡量，体积就不那么重要了，Alpine上添加的包使这些方面都大大增强了。

广泛的支持：Docker公司已经聘请了Alpine Linux的作者来维护它，所有官方镜像，在以后都将基于Alpine Linux来构建。没有比这个更有说服力的理由去让你在自己的容器中使用它了吧。

希云cSphere 很早就意识到镜像越来越庞大的问题，因此在去年推出微镜像，也是引导大家如何更好地构建和理解镜像，镜像只是一种软件包格式而已。

** 构建一个Java环境基镜像 **

正如我刚解释的，Alpine Linux是一个构建自有镜像时不错的选择，因此，我们在此将使用它来构建简洁高效的Docker镜像，我们开始吧!

组合：Alpine + bash

每个Dockerfile第一个指令都是指定它的父级容器，通常是用于继承，在我们的例子中是<code>alpine:latest</code>:

FROM alpine:latest

MAINTAINER cSphere <docker@csphere.cn>

我们同时声明了谁为这个镜像负责，这个信息对上传到Docker Hub的镜像是必要的。

就这样，你就有了往下操作的基础，接下来安装我们选好的shell,把下边的命令加上：

RUN apk add --no-cache --update-cache bash

CMD ["/bin/bash"]

最终的Dockerfile是这样：

```sh

FROM alpine:latest

MAINTAINER cSphere < docker@csphere.cn >

RUN apk add --no-cache --update-cache bash

CMD ["/bin/bash"]

```

好了，现在我们构建容器：

$ docker build -t my-java-base-image .

Sending build context to Docker daemon 2.048 kB

Step 1 : FROM alpine:latest

---> 2314ad3eeb90

Step 2 : MAINTAINER cSphere <docker@csphere.cn>

---> Running in 63433312d77e

---> bfe94713797a

Removing intermediate container 63433312d77e

... 省略若干行

Step 4 : CMD /bin/bash

---> Running in d2291684b797

---> ecc443d68f27

Removing intermediate container d2291684b797

Successfully built ecc443d68f27

并且运行它：

$ docker run --rm -ti my-java-base-image

bash-4.3#

一文教您如何通过 Docker 快速搭建各种测试环境

docker save -o 镜像名.tar 源镜像名

docker load -i 镜像名.tar

或者docker load < 镜像名.tar

docekr tag 现有镜像名镜像名:tag名

如：将nginx镜像打tag为v1

docker tag docker.io/nginx docker.io/nginx:v1

如将php镜像上传到本地仓库（地址为192.168.1.252）

1.打标签(私有仓库地址IP或域名:端口/镜像名:tag)

docker tag php-alpine:v7.3 192.168.1.252:5000/php:v7.3

2.上传

docker push 192.168.1.252:5000/php:v7.3

3.测试查看

超值一篇分享，Docker：从入门到实战过程全记录

一、镜像加速

Docker 默认是从官方镜像地址 Docker Hub 下下载镜像，由于服务器在国外的缘故，导致经常下载速度非常慢。为了提升镜像的下载速度，我们可以手动配置国内镜像加速器，让下载速度飚起来。

国内的镜像加速器选项较多，如：阿里云，DaoCloud 等。

本文主要说说如何配置阿里云的镜像加速器。

2.1 登录阿里云获取加速信息

2.2 配置 Docker

2.2.1 确定 Docker Client 版本

在配置之前，首先需要 确定 Docker Client 的版本，推荐是 1.10.0+ :

2.2.2 配置镜像加速器

PS: 这里以 CentOS 系统为例，如果你是别的系统，可以参考阿里云配置加速器官方文档。

通过修改 daemon 配置文件 /etc/docker/daemon.json 来使用加速器：

执行下面命令：

2.3 验证一下速度

以下载 mongodb 为例，看下速度：

配置了加速器过后，速度终于飚起来了。

二、快速安装&搭建 Mysql 环境

本节中，我们将学习如何通过 Docker 快速安装与搭建 Mysql 环境。

2.1 下载 Mysql 镜像

这里以 Mysql 5.7 为例：

下载完成后，通过 docker images 检查一下镜像是否下载成功:

2.2 先以最简单方式启动

先以简单的方式启动：

命令执行完成后，你也可以通过 docker ps 命令来确认下容器是否启动成功。若成功，我们需要将容器中的目录文件复制到宿主机中，分别包括：

完成这一切后，让我们将刚刚运行的容器删除掉。

PS: mysql 是我们运行容器时，指定的名称，当然，你也可以先执行 docker ps , 通过容器 ID 来删除。

2.3 正式运行 Mysql 容器

接下来，正式运行 Mysql 容器：

其他不变，额外添加了两个挂载子命令：

执行命令完成后，查看下容器是否启动：

可以看到，容器运行成功

2.4 通过 Mysql 客户端连接一下试试

通过 MySQL 客户端连接刚刚创建的 mysql, 看看能否连接成功：

连接成功了！

三、快速安装&搭建 Redis 环境

本节中，我们将学习如何利用 Docker 安装&搭建 Redis 环境。

3.1 下载 Redis 镜像

首先拉取 Redis 镜像, 这里我选择的是 redis:alpine 轻量级镜像版本：

下载完成后，通过 docker images 确认镜像是否已经下载到本地：

3.2 运行 Redis 容器

命令说明：

命令运行完成后，查看容器是否启动成功：

可以看到 redis 容器已经启动成功了！

3.3 连接刚刚创建好的容器

执行如下命令，连接 redis：

四、快速安装&搭建 MongDB 环境

本节中，我们将学习如何通过 Docker 快速安装与搭建 MongoDB 环境。

4.1 下载 MongoDB 镜像

这里以 mongo 4 版本为例，下载镜像：

下载完成后，确认一下镜像是否下载成功:

4.2 运行 MongoDB 镜像

下载成功后，运行 mongoDB 镜像：

执行命令完成后，查看下容器是否启动：

4.3 添加管理员账号

执行命令：

然后，创建一个拥有最高权限 root 账号:

创建成功后，你会看到 Successfully added user :

4.4 用新创建的 root 账户连接，测试一下

连接成功后，我们可以执行相关 sql：

显示所有的数据库：

使用某个数据库：

输入命令 exit ，退出连接！

五、快速安装&搭建 Elasticsearch 环境

本节中，我们将学习如何通过 Docker 快速安装与搭建 Elasticsearch 环境。

5.1 下载 Elasticsearch 镜像

这里以 Elasticsearch 6.5.0 为快速安装&搭建 Elasticsearch 环境例：

下载完成后，通过 docker images 检查一下镜像是否下载成功:

5.2 先简单运行 Elasticsearch 镜像

下载成功后，简单运行 Elasticsearch 镜像：

命令执行完成后，你也可以通过 docker ps 命令来确认下容器是否启动成功。

可以看到 es 容器运行成功了，接下来，进入容器中：

安装 analysis-ik 中文分词插件：

PS: es 从 v5.5.1 版本开始支持自带的 es 插件命令来安装，如果你安装的版本不是 6.5.0，需要将命令中的版本号修改一下，具体参考 /medcl/elasticsearch-analysis-ik

安装成功后，退出容器：

删除刚刚运行的容器：

PS: 当然了，你也可以通过容器的 ID 来删除。

5.3 复制相关文件

5.4 修改 es 相关配置

进入我们刚刚指定的 config 配置目录，修改 jvm.options 文件：

PS: 因为小哈测试服务器就 2G 内存，这里我改成了 JVM 内存占用 300m, 如果你的内存够用，可不用改。

修改 elasticsearch.yml 文件, 添加如下配置：

解释一下添加的配置，设置节点为 master 节点，并允许跨域访问，以便后面使用 head 插件图形化界面访问。

5.5 运行 Elasticsearch 容器

这次，我们额外添加了相关挂载命令：

5.6 测试一下，瞅瞅 es 是否能够正常访问

测试一下，看 es 是否启动成功：

OK, 到此 es 的单节点环境就搭建好了！

欢迎工作一到五年的Java工程师朋友们加入Java程序员开发： 721575865

群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用"没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

作者 | 天元浪子

来源 | CSDN博客

想要真正理解Docker，就不得不从虚拟化技术的发展历程说起。普遍认为虚拟化技术经历了物理机时代、虚拟机时代，目前已经进入到了容器化时代。可以说，Docker是虚拟化技术不断发展的必然结果。

那么，什么是容器呢？容器和虚拟机有什么不同？Docker和容器又是什么关系呢？搞明白这几个问题，Docker的概念就清晰了。

1.1 虚拟机和容器

借助于VMWare等软件，可以在一台计算机上创建多个虚拟机，每个虚拟机都拥有独立的操作系统，可以各自独立的运行程序。这种分身术虽然隔离度高（操作系统级），使用方便（类似物理机），但占用存储资源多（GB级）、启动速度慢（分钟级）的缺点也是显而易见的。

相较于虚拟机，容器（Container）是一种轻量型的虚拟化技术，它虚拟的是最简运行环境（类似于沙盒）而非操作系统，启动速度快（秒级）、占用存储资源少（KB级或MB级），容器间隔离度为进程级。在一台计算机上可以运行上千个容器，这是容器技术对虚拟机的碾压式优势。

1.2 容器、镜像和Docker

Docker是一个开源的应用容器引擎，可以创建容器以及基于容器运行的程序。Docker可以让开发者打包他们的应用和依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。

听起来很简单，但是在Docker和容器之间，还隐藏着一个镜像的概念，令初学者颇感困惑。本质上，Docker镜像是一个特殊的文件系统，它提供容器运行时所需的程序、库、资源、配置等文件。Docker镜像类似于一个py文件，它需要Docker的运行时（类似于Python解释器）运行。镜像被运行时，即创建了一个镜像的实例，一个实例就是一个容器。

1.3 Docker 和 k8s

作为容器引擎，Docker为容器化的应用程序提供了开放的标准，使得开发者可以用管理应用程序的方式来管理基础架构，实现快速交付、测试和部署代码。随着容器的大量使用，又产生了如何协调、调度和管理容器的问题，Docker的容器编排应运而生。

k8s是Google开源的一个容器编排引擎，它支持自动化部署、大规模可伸缩、应用容器化管理，是一个开源的，用于管理云平台中多个主机上的容器化的应用，k8s的目标是让部署容器化的应用简单并且高效，k8s提供了应用部署、规划、更新、维护的一种机制。

Docker和k8sr都是以containerd（容器化标准）作为运行时，因此使用Docker创建的镜像完全可以在k8s中无障碍的使用。

2.1 在ubuntu中安装

在linux系统中安装Docker非常简单，官方为我们提供了一键安装脚本。这个方法也适用于Debian或CentOS等发行版。

安装过程如果出现超时，不要灰心，多试几次，总会成功的。安装完成后，Docker只能被root用户使用，可以使用下面的命令取消权限限制：

然后，重启docker服务：

最后，关闭当前的命令行，重新打开新的命令行就可以了。

顺便提一下，如果在CentOS下安装，可能会出现一堆类似于下面的错误：

这是由于docker和Podman冲突造成的，需要先卸载Podman：

2.2 在Win10中安装

Docker的运行，依赖linux的环境，官方提供了Docker Desktop for Windows，但是它需要安装Hyper-V，Hyper-V是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。这个虚拟机一旦启用，QEMU、VirtualBox 或 VMWare Workstation 15 及以下版本将无法使用！如果你必须在电脑上使用其他虚拟机（例如开发 Android 应用必须使用的模拟器），请不要使用 Hyper-V！

我的电脑是win10家庭版，不能直接安装hyper-v，需要将下面的命令保存到cmd文件中：

然后在cmd文件上点击右键，选择使用管理员运行。执行完毕后会重启，在重启的过程中进行安装。

2.3 Hello world

docker服务启动的情况下，运行下面的命令：

此命令的含义是：

第一次运行时，因为本地没有ubuntu:20.04镜像，docker会自动从镜像服务器下载。下载过程可能需要多试几次，只要成功一次，以后执行就不再需要下载了。

docker官方还提供了一个hello-world镜像，可以直接运行：

此命令省略了镜像版本和运行参数，docker使用latest作为版本，即最新版本。

从hello world的例子中，也可以体验到，docker实例的运行是非常快的。

docker官方的镜像库比较慢，在进行镜像操作之前，需要将镜像源设置为国内的站点。

新建文件/etc/docker/daemon.json，输入如下内容：

然后重启docker的服务：

3.1 列出本地所有镜像

执行命令 docker images 可以查看

当前我本地只有刚才安装的两个镜像。

3.2 从镜像库中查找镜像

执行命令 docker search 镜像名称可以从docker镜像库中查找镜像。

最好选择官方（OFFICIAL）的镜像，这样的镜像最稳定一些。

3.3 下载新的镜像

执行命令docker pull 镜像名称:版本号即可下载新的镜像。

镜像下载后，就可以使用镜像来创建容器了。

4.1 启动容器

执行命令docker run即可启动容器，也就是创建某个镜像的实例。docker run命令非常复杂，可以先执行一个docker run --help来查看帮助：

比如我们要执行python的shell，需要添加-it参数，即：docker run -it python:3.8

4.2 将宿主机的文件挂载到容器

docker容器与宿主机是隔离的，要想让容器内的程序能访问宿主机上的文件，需要通过-v参数将宿主机的文件挂载到容器中。

比如我们在宿主机上有一个hello.py，可以打印hello，想要在python容器中执行，就需要进行挂载。-v后还需要接两个参数，分别是宿主机的目录和容器内的目录，两者使用:分隔，路径必须都是绝对路径。

我的hello.py保存在主目录的/docker_test目录中，将这个目录挂载到容器的/docker_test目录，然后在容器内执行python /docker_test/hello.py：

4.3 容器的端口映射

我们修改一下hello.py，创建一个socket服务端，并监听5000端口，当有客户端连接时，打印客户端的地址，先客户端发送hello，然后关闭连接：

在容器内执行：

接下来，尝试用telnet命令连接，结果却是失败的。原因是，127.0.0.1是宿主机的ip地址，5000是容器的端口，这与我们的习惯稍微有些不同。事实上，docker的容器是非常轻量的，它并没有自己的网络，要想访问容器的端口，需要进行端口映射，将容器的某端口映射到宿主机的端口，客户端连接时，只要与宿主机的端口进行连接就可以了。

需要注意的是，上面的代码创建的服务器，无论如何也不可能被客户端连接，因为代码中绑定了127.0.0.1的ip，在容器中运行时，需要绑定所有ip，即0.0.0.0。

然后，再使用-p参数，-p还需要三个参数，即宿主机的ip地址、宿主机的端口、容器的端口，三者之间使用:分隔。一般的，可以将宿主机的ip地址省略，只写宿主机的端口：容器的端口即可。

这样，就将容器的5000端口映射到了宿主机的5001端口，使用：

即可与容器中的服务器进行连接。

4.4 容器管理

上面的服务运行之后，可以使用docker ps命令，查看运行中的容器：

显示的内容有下面几列：

要想结束容器，可以使用docker kill 容器ID命令。

一般而言，当我们的程序开发完成后，会连同程序文件与运行环境一起制作成一个新的镜像。

要制作镜像，需要编写Dockerfile。DockeFile由多个命令组成，常用的命令有：

注意，Docker镜像中有一个层的概念，每执行一个RUN命令，就会创建一个层，层过多会导致镜像文件体积增大。尽量在RUN命令中使用&&连接多条shell命令，减少RUN命令的个数，可以有效减小镜像文件的体积。

5.1 自制显示文本文件内容镜像

编写cat.py，接收一个文件名，由python读取文件并显示文件的内容：

这个例子比较简单，缩写Dockerfile如下：

这个Dockerfile的含义是：

需要说明的是，ENTRYPOINT有两种写法：

这里采用第二种写法，是因为我们要在外部给容器传递参数。执行命令编译Docker镜像：

这个命令中，-t的含义是目标，即生成的镜像名为hello，版本号为1.0，别忘了最后那个.，这叫到上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。

这样，我们的第一个镜像就制作完成了，使用下面的命令执行它：

即可看到~/docker_test/cat/files/test.txt的内容。

5.2 自制web服务器镜像

我们使用tornado开发一个网站，而python的官方镜像是没有tornado库的，这就需要在制作镜像时进行安装。

测试的ws.py如下：

编写Dockerfile文件如下：

在此我们验证一下CMD与ENTRYPOINT的区别。在Dockerfile所在有目录下执行如下命令：

执行完成后，再使用docker images使用就可以看到生成的镜像了，然后使用下面的命令运行：

在浏览器中输入宿主机的ip和8000端口，就可以看到页面了。

在这个例子中，我使用的运行命令是CMD，如果在docker run中指定的其他的命令，此命令就不会被执行，如：

此时，容器中被执行的是python命令，而不是我们的服务。在更多情况下，我们希望在docker run命令中为我们的服务传参，而不是覆盖执行命令，那么，我们应该使用ENTRYPOINT而不是CMD：

上面这种写法，是不支持传递参数的，ENTRYPOINT和CMD还支持另一种写法：

使用这种写法，docker run命令中的参数才可以传递给hello.py：

这个命令中，--port=9000被作为参数传递到hello.py中，因此容器内的端口就成了9000。

在生产环境中运行时，不会使用-it选项，而是使用-d选项，让容器在后台运行：

这种方式下，即使当前的控制台被关闭，该容器也不会停止。

5.3 自制apscheduler服务镜像

接下来，制作一个使用apscheduler编写的服务镜像，代码如下：

Dockerfile也是信手拈来：

生成镜像：

应该可以运行了，文件复制需要两个目录，在运行时，可以使用两次-v来挂载不同的目录：

前面用到的官方python镜像大小足足882MB，在这个基础上，再安装用到的第三方库，添加项目需要的等资源，大小很容易就超过1个G，这么大的镜像，网络传给客户非常的不方便，因此，减小镜像的体积是非常必要的工作。

docker hub上有个一python:3.8-alpine镜像，大小只有44.5MB。之所以小，是因为alpine是一个采用了busybox架构的操作系统，一般用于嵌入式应用。我尝试使用这个镜像，发现安装一般的库还好，但如果想安装numpy等就会困难重重，甚至网上都找不到解决方案。

还是很回到基本的路线上来，主流的操作系统镜像，ubuntu的大小为72.9MB，centos的大小为209MB——这也算是我更喜欢使用ubuntu的一个重要原因吧！使用ubuntu作为基础镜像，安装python后的大小为139MB，再安装pip后的大小一下子上升到了407MB，要是再安装点其他东西，很容易就赶上或超过python官方镜像的大小了。

看来，寻常路线是很难压缩镜像文件体积了。幸好，还有一条曲线救国的路可走，这就是多阶段构建法。

多阶段构建的思想其实很简单，先构建一个大而全的镜像，然后只把镜像中有用的部分拿出来，放在一个新的镜像里。在我们的场景下，pip只在构建镜像的过程中需要，而对运行我们的程序却一点用处也没有。我们只需要安装pip，再用pip安装第三方库，然后将第三方库从这个镜像中复制到一个只有python，没有pip的镜像中，这样，pip占用的268MB空间就可以被节省出来了。

1、在ubuntu镜像的基础上安装python：

然后运行：

这样，就生成了python:3.8-ubuntu镜像。

2、在python:3.8-ubuntu的基础上安装pip：

然后运行：

这样，就生成了python:3.8-ubuntu-pip镜像。

3、多阶段构建目标镜像：

这个dockerfile需要解释一下了，因为它有两个FROM命令。

第一个是以python:3.8-ubuntu-pip镜像为基础，安装numpy，当然，在实际应用中，把所有用到的第三方库出写在这里。

第二个FROM是以FROM python:3.8-ubuntu镜像为基础，将第三方库统统复制过来，COPY命令后的–from=0的意思是从第0阶段进行复制。实际应用中再从上下文中复制程序代码，添加需要的ENTRYPOINT等。

最后，再运行：

这然，用于我们项目的镜像就做好了。比使用官方python镜像构建的版本，小了大约750MB。