4328 字
22 分钟
镜像从 1.2 GB 瘦到 80 MB:多阶段构建、基础镜像选型与 dive 逐层验尸
2026-11-16

本地随手 docker build 出来的镜像 1.2 GB,推到服务器传半天,拉下来又等半天,磁盘上躺十几个版本就是十几 GB。很多人第一反应是「我的程序有这么大吗」——打开一看,程序本体可能只有 30 MB,剩下的全是编译时的工具链、包管理器缓存、文档、测试文件和构建上下文里混进去的垃圾。

这篇就干一件事:把镜像里不属于运行时的东西全部留在构建阶段,只把产物送进最终镜像。手段是三件套:多阶段构建负责「只带产物走」,基础镜像选型决定「地板有多厚」,dive 负责逐层验尸、找出到底哪一层在浪费空间。

项目地址:

https://github.com/wagoodman/dive

为什么镜像会胖:先搞懂层机制#

Docker 镜像是分层的。Dockerfile 里每条会产生文件变化的指令(RUN、COPY、ADD)都会叠一层,镜像总大小约等于所有层加起来。关键规则有两条:

  • 层是只增不减的。你在第 3 层装了 500 MB 的编译工具,第 5 层就算 rm 删掉,镜像体积也不会变小——删除只是在上一层打了个「遮罩」,下面的层还实打实地占着空间。
  • 拉取和分发按层算账。层越大、层数越多,每次推送、拉取、导出的成本越高。

所以瘦身的核心思路不是「装完再删」,而是「胖的东西根本不要进最终镜像的层里」。这也是为什么下面所有技巧都围绕两个动作:同层清理,以及多阶段隔离。

先学会看体积,心里有数再动手:

Terminal window
# 看每个镜像的总体积
docker images
# 逐层看某个镜像每层多大、是什么命令产生的
docker history myapp:latest
# 看 Docker 整体磁盘占用(镜像 / 容器 / 卷 / 构建缓存各占多少)
docker system df

docker history 是最快的自查工具:哪一层突然多出几百 MB,基本就是那条指令把不该带的东西带进来了。

多阶段构建实战:工具链留在 builder,最终镜像只拿产物#

多阶段构建(multi-stage build)是瘦身收益最大的一招。同一个 Dockerfile 里写多个 FROM,每个 FROM 开启一个 stage;前面的 stage 负责编译,可以放心装齐工具链,最终 stage 用 COPY --from= 只把编译产物拷过来,工具链一个字节都不进最终镜像。

以一个 Go 程序为例。Go 编译出的是单个静态二进制,最适合演示「产物思维」:

# ---------- 构建阶段:工具链随便装,反正不进最终镜像 ----------
FROM golang:1.23-bookworm AS builder
WORKDIR /src
# 先只拷依赖清单,利用层缓存:代码改了但依赖没变时,这层不重跑
COPY go.mod go.sum ./
RUN go mod download
COPY . .
# 静态编译,关掉 CGO,产物只有一个二进制
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/myapp ./cmd/myapp
# ---------- 运行阶段:只放产物 ----------
FROM scratch
COPY --from=builder /out/myapp /myapp
# scratch 里连 CA 证书都没有,调 HTTPS 接口要自己带上
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
ENTRYPOINT ["/myapp"]

golang:1.23-bookworm 本身接近 800 MB,但它只是 builder;最终镜像是 scratch 加一个十几 MB 的二进制,总大小就是十几 MB。构建和运行的写法细节在 Dockerfile 编写指南 里有系统展开,这里只盯瘦身相关的点:

  • stage 命名:FROM ... AS builder 给阶段起名,后面 COPY --from=builder 按名引用;不命名也能用 --from=0 按序号,但可读性差很多。
  • 只构建某个 stage:调试时不必跑完整流程,docker build --target builder -t myapp:debug . 只构建到指定 stage,方便进 builder 里看中间产物。
  • 依赖清单先行:先 COPY go.mod go.sum 再 COPY . .,是利用构建缓存的经典手法——源码天天改、依赖不常变,依赖下载层就能反复命中缓存。缓存机制的完整玩法见 BuildKit 缓存与构建加速。

Node.js 项目同理,思路完全一致:

FROM node:22-bookworm AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build && npm prune --omit=dev
FROM node:22-bookworm-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package.json ./
USER node
CMD ["node", "dist/main.js"]

注意 npm prune --omit=dev 在 builder 里先把 devDependencies 剃掉,再拷 node_modules——拷过来的就已经是瘦的了。

WARNING

多阶段构建最常见的翻车是「最终 stage 把整个 builder 的工作目录全拷过来」,比如 COPY --from=builder /app ./,那工具链、源码、缓存又全回来了,和没分阶段一样。COPY —from 只拷明确列出的产物路径,不要整目录照单全收。

基础镜像选型:地板厚度决定下限#

多阶段决定了「带多少东西走」,基础镜像决定「起步就有多重」。同一个程序,基础镜像从完整版换到 distroless,轻松差出几百 MB:

基础镜像体积量级包管理器有 shell适用场景
debian / ubuntu 完整版100–200 MB 起apt 齐全有构建阶段、需要大量系统工具调试时
*-slim(如 debian-slim、node)比完整版少一半左右apt 可用(精简了文档等)有通用运行镜像的稳妥选择
alpine约 5–10 MBapk有(sh)体积敏感、依赖简单的服务
distroless(gcr.io/distroless)20–100 MB(按语言分)无无生产环境跑静态语言 / JVM / Node 成品
scratch0 MB无无静态编译的单二进制(Go、Rust 静态产物)

选型原则很简单:能静态编译的语言优先 scratch 或 distroless,需要运行时解释器的选对应语言的 distroless 或 slim,alpine 不要无脑上。

alpine 的三个坑#

alpine 只有几 MB 很诱人,但它的 C 库是 musl libc,和主流发行版的 glibc 不是一回事,坑都出在这里:

  • 二进制不兼容:为 glibc 编译的预编译二进制(很多官方发布的 .tar.gz 成品、某些 Node 原生模块、Python 的 manylinux wheel)拷进 alpine 直接跑不起来,报的还是迷惑性的 not found——文件明明在,是动态链接器找不到。
  • DNS 解析差异:musl 的解析器行为和 glibc 不完全一致,老问题包括不支持 DNS 搜索域的某些展开方式、并发查询行为不同,偶发「在别的镜像里能解析、在 alpine 里间歇失败」。
  • 时区数据缺失:alpine 默认没有 tzdata,容器里时间显示成 UTC、定时任务按错时区跑,要 apk add tzdata 另装,或者挂载宿主机的 /etc/localtime。
WARNING

不要为了省几十 MB,把一个在 debian 下跑得好好的服务硬迁到 alpine。musl 兼容性问题往往在上线后才以诡异的方式爆出来,省下的体积远不抵排障的成本。先 slim,确认依赖都兼容再考虑 alpine。

合并 RUN 与同层清理#

不方便多阶段的老镜像,先做同层清理也能瘦一圈。原则是:安装和清理必须写在同一条 RUN 里,跨层删除不减小体积。

# 反例:三层分开写,清理层删了也白删,前面的层照样占空间
RUN apt-get update
RUN apt-get install -y curl git
RUN rm -rf /var/lib/apt/lists/*
# 正例:一条 RUN 里装完就清,缓存只存在于构建过程,不落层
RUN apt-get update \
&& apt-get install -y --no-install-recommends curl git \
&& rm -rf /var/lib/apt/lists/*

要点:--no-install-recommends 不装推荐包(往往是一大堆用不上的东西);apt-get clean 和删 /var/lib/apt/lists/* 必须跟安装在同一层。其他生态同理:npm cache clean --force、pip install --no-cache-dir、apk 用 --no-cache,都是不让缓存落层。

dive 逐层验尸:让每一层都说清楚自己装了什么#

凭感觉瘦身容易漏,dive(wagoodman/dive,GitHub 开源工具)是专门干逐层分析的:它把镜像每一层的文件增、删、改列出来,还给出「浪费空间」的量化指标——比如同一文件在多层里被反复修改、删除后仍占空间的字节数,以及一个效率评分。

本机交互式分析:

Terminal window
# 直接分析本地镜像,进入终端界面逐层浏览
dive myapp:latest
# 也可以直接对着 Dockerfile 边构建边分析
dive build -t myapp:latest .

界面里左边是层列表,右边是该层的文件树变化:新增、修改、删除的文件分开标色。重点盯两类东西:一是单层里莫名出现的大目录(多半是缓存或误拷进来的构建上下文),二是某个大文件在后面的层里被「删除」了——文件删得掉,体积删不掉,这正是分层机制产生浪费的地方。

退出界面后,dive 还会给出几个汇总指标,看懂它们就知道该往哪砍:

指标含义怎么用
Wasted space被后续层覆盖或删除、但仍实占体积的字节数越大说明「先装后删」越多,优先改同层清理或多阶段
Efficiency score有效内容占总体积的比例明显偏低基本都有层浪费,先查清楚再动手
Wasted bytes 明细每个文件浪费了多少、分布在哪一层照着清单逐个处理,不用凭感觉猜

典型的一次验尸长这样:总体积 1.2 GB,浪费空间占了大半,其中大头是构建缓存被整目录拷进了最终镜像,其次是 apt 的包列表在独立的层里残留——两个问题分别对应多阶段隔离和同层清理,一改就见效。先量再砍,比对着经验逐条试错快得多。

CI 里可以让 dive 按阈值把关,镜像太胖直接让流水线失败:

Terminal window
# CI=true 时 dive 不进交互界面,按规则判定通过 / 失败
CI=true dive myapp:latest

阈值写在项目根目录的 .dive-ci 配置里,常用的三项是最低效率、最大浪费字节数、单层最大浪费字节数,具体字段以 dive 仓库的文档为准。瘦完的镜像建议再用 Trivy 扫一遍漏洞:换基础镜像、削层数都会改变漏洞面,瘦身和安全要一起验收。

.dockerignore:先把垃圾挡在构建上下文之外#

COPY . . 是胖镜像的另一大源头:构建上下文里有什么,它就往镜像里搬什么。.git、本地 node_modules、日志、测试产物、编辑器临时文件,全都是这么混进去的。在项目根目录放一个 .dockerignore,写法和 .gitignore 基本一致:

.git
node_modules
dist
*.log
.env
.DS_Store
.idea
.vscode
coverage

对照一张清单自查,缺哪样补哪样:

该排除的不排除的后果
.git整个仓库历史进镜像,又大又泄密
node_modules / vendor 等本地依赖目录和镜像内重新安装的依赖叠加,体积翻倍还可能版本打架
日志、coverage、测试快照纯垃圾,白占层空间
.env、密钥文件不是体积问题,是安全事故
本地构建产物(dist、target 等)旧产物污染新构建,结果不可复现

它有两个收益:一是构建上下文变小,docker build 时上传上下文更快、构建更利索;二是避免无关文件变化让 COPY 层缓存无谓失效——改一行日志文件就导致整层重建,是很常见的莫名其妙的慢。

WARNING

.env 和密钥文件一定要写进 .dockerignore。它们一旦被 COPY 进镜像,删层也删不干净,镜像推到任何仓库都等于把密钥公开了。真需要在构建时用密钥,走 BuildKit 的 secret 挂载,不要进上下文、更不要进层。

无 shell 的镜像怎么排障#

distroless 和 scratch 瘦是瘦,代价是进去之后没有 shell:docker exec -it 连不进,ls、cat、ps 全都没有。线上出问题时别慌,有三条正规路子:

1. 把文件拷出来看。 容器不用 exec 也能用 docker cp 往外拷日志和配置:

Terminal window
docker cp myapp:/var/log/app.log ./app.log
docker cp myapp:/app/config.yaml ./config.yaml

2. 用带 shell 的调试容器共享命名空间。 另起一个工具齐全的容器,加入目标容器的进程和网络命名空间,从「隔壁」看它:

Terminal window
# 共享进程命名空间:能看到目标容器的进程、/proc 下的一切
docker run -it --rm --pid=container:myapp busybox sh
# 共享网络命名空间:在目标容器的网络视角里抓包、测连通性
docker run -it --rm --net=container:myapp nicolaka/netshoot bash

另外,distroless 官方还提供带 :debug 标签的变体镜像,内置了 busybox shell,专门给排障留的:平时用无 shell 的正式版,真出问题时临时换成同版本的 :debug 镜像跑一遍,定位完再换回去。

3. 临时换回带 shell 的基础镜像定位。 把最终 stage 的基础镜像临时改成对应的 slim 版(其他不变)重新构建,进去把问题查清楚,修完再切回 distroless。这招笨但可靠,尤其适合「只有在无 shell 镜像里才复现」的怪问题,先确认是不是缺了某个运行时文件。

瘦完怎么验收:留一张对照表#

瘦身不是改完就完,每次动完 Dockerfile,用同一组命令量一遍、留个记录,避免越改越胖或者把东西削没了:

Terminal window
docker images myapp
docker history myapp:latest
docker system df

一个典型的瘦身前后对照大概是这个量级(具体数字取决于项目,这里只示意结构):

阶段做法体积量级
初始版单阶段、完整版基础镜像、整目录 COPY1 GB 以上
第一刀.dockerignore + 同层清理缓存砍掉一两百 MB 的垃圾和缓存
第二刀多阶段构建,只拷产物工具链整段消失,通常是最大的一刀
第三刀基础镜像换 slim / distroless / scratch摸到下限,几十 MB 级

验收时除了看体积,还要把容器真正跑起来过一遍核心流程:体积达标但程序起不来,等于白干。尤其是换基础镜像和削层之后,缺库、缺证书、缺时区数据这类问题只会在运行时暴露。

排障#

1. 瘦身后程序起不来,报缺库#

多阶段构建只拷了二进制,却漏了它运行时依赖的动态库(.so)。排查:先在 builder 阶段用 ldd <二进制> 列出它依赖哪些库,再确认这些库在最终镜像里有没有。对策按顺序选:能静态编译就静态编译(Go 用 CGO_ENABLED=0、Rust 选 musl 目标);不能静态的,最终镜像选带齐基础库的 distroless 对应变体或 slim,把缺的库随产物一起 COPY --from 过去。最忌讳的是图省事把整个 builder 的 /usr/lib 全拷过去,那等于把瘦身成果又还回去大半。

2. 二进制在 alpine 里跑不起来,报 not found#

文件明明存在、权限也没问题,却报 No such file or directory——这是 musl 与 glibc 不兼容的经典症状:缺的不是二进制本身,而是它要的 glibc 动态链接器(/lib64/ld-linux-x86-64.so.2),alpine 里根本没有。用 file <二进制> 看它是不是 dynamically linked、链的是哪个解释器就能确认。对策:要么在 alpine 里重新编译出 musl 版本,要么给它装 glibc 兼容层(不推荐,坑更多),要么干脆换回 glibc 系的 slim / distroless 基础镜像——多数情况下第三条最省事。

3. 清理缓存写了,体积却没降#

rm -rf /var/lib/apt/lists/* 写在单独一层里,是最常见的原因:删除只产生一个遮罩层,下面的层纹丝不动,docker history 里能清楚看到安装层还是那么大。对策是把安装、clean、删列表合并进同一条 RUN(见前面同层清理的正例),重构后逐层对照 docker history 验证。另外注意构建缓存的假象:改完 Dockerfile 如果命中了旧缓存层,体积当然不变,必要时 docker build --no-cache 强制全量重建再量。

4. 换了 distroless 之后调不通 HTTPS#

程序一调外部 HTTPS 接口就报证书错误。scratch 和部分 distroless 变体里没有预置 CA 根证书,TLS 校验无从下手。对策:从 builder 镜像里把证书文件拷进最终镜像(前面 Go 的例子里那行 COPY --from=builder /etc/ssl/certs/ca-certificates.crt ... 干的就是这件事);Java、Node 等语言的 distroless 变体一般自带证书,选型时先查对应变体的说明再动手。

小结#

镜像瘦身没有玄学,就是三件事:多阶段构建让工具链和源码留在构建阶段,最终镜像只拿产物;基础镜像选型决定地板厚度,能静态编译的走 scratch / distroless,需要运行时的用 slim,alpine 先想清楚 musl 的坑;dive 逐层验尸负责验收和防反弹,浪费在哪一层、占多少字节,全都量得出来。再加上 .dockerignore 挡住上下文垃圾、同层清理不让缓存落层,一个 1.2 GB 的镜像瘦到几十 MB 是常态。瘦完别忘了代价那一面:无 shell 镜像排障要提前练好 docker cp 和共享命名空间这两招,别等线上出事才现学。镜像瘦下来之后,推送和拉取快了,磁盘省了,攻击面也跟着小了——这笔账怎么算都划算。

镜像从 1.2 GB 瘦到 80 MB:多阶段构建、基础镜像选型与 dive 逐层验尸
https://www.anexns.cloudns.org/posts/docker-image-slimming/
作者
Anexns
发布于
2026-11-16
许可协议
CC BY-NC-SA 4.0