docker镜像瘦身&优化

快来打我* 2022-01-19 23:23 292阅读 0赞

> 原文首发于我的博客: [lailin.xyz/post/51252.…][lailin.xyz_post_51252.]

> 为什么在存储如此便宜的今天我们仍然需要对 Docker 镜像进行瘦身?

## 小镜像的优点 ##

1.  加速构建/部署
    
    虽然存储资源较为廉价，但是网络 IO 是有限的，在带宽有限的情况下，部署一个 1G 的镜像和 10M 的镜像带来的时间差距可能就是分钟级和秒级的差距。特别是在**出现故障**，服务被调度到其他节点时，这个时间尤为宝贵。
2.  提高安全性，减少攻击面积
    
    越小的镜像表示无用的程序越少，可以大大的减少被攻击的目标
3.  减少存储开销

## 小镜像的制作原则 ##

1.  选用最小的基础镜像
2.  减少层，去除非必要的文件
    
    在实际制作镜像的过程中，一味的合并层不可取，需要学会充分的利用 Docker 的缓存机制，提取公共层，加速构建。
    
     *  **依赖文件和实际的代码文件单独分层**
     *  **团队/公司采用公共的基础镜像等**
3.  使用多阶段构建
    
    往往我们在构建阶段和实际运行阶段需要的依赖环境是不同的，例如`golang`编写的程序实际运行的时候仅仅需要一个二进制文件即可，对于`Node`来说，可能最后运行的只是一些打包之后的`js`文件而不需要包含`node_modules`里成千上万的依赖

## 基础镜像 ##

*  [distroless][]
    
    > "Distroless" images contain only your application and its runtime dependencies. They do not contain package managers, shells or any other programs you would expect to find in a standard Linux distribution.
    
    `distroless`是 Google 推出的一个仅仅包含运行时环境，不包含包管理器，`shell`等其他程序。如果你的程序没有其他依赖的话，这是一个不错的选择
 *  [alpine][]
    
    > Alpine Linux is a security-oriented, lightweight Linux distribution based on musl libc and busybox.
    
    alpine 是一个基于`musl`, `busybox`的安全的`linux`发行版。麻雀虽小五脏俱全，虽然不到 10M, 但是包含了一个包管理器和`shell`环境，这在我们实际的使用调试当中将非常有用。
    
    但是请注意，由于`alpine`使用了更小的`muslc`替代`glibc`，会导致某些应用无法使用，需要重新编译
 *  [scratch][]
    
    scratch 是空白镜像，一般用于基础镜像构建，例如`alpine`镜像的`dockerfile`便是从`scratch`开始的
    
        FROM scratch
        ADD alpine-minirootfs-20190228-x86_64.tar.gz / CMD ["/bin/sh"] 复制代码
 *  [busybox][]

一般而言，`distroless`相对会更加的安全，但是在实际使用的过程中可能会遇到添加依赖以及调试方面的问题，`alpine`更小，自带包管理器，更加贴合使用习惯，但是`muslc`可能会带来兼容性的问题，一般而言我会选择`alpine`作为基础镜像使用。

除此之外，在[Docker Hub][]当中我们可以发现常用的`Debian`的镜像也会提供的只包含基础功能的小镜像

### 基础镜像对比 ###

此处直接拉取基础镜像，查看镜像大小， 通过观察我们可以发现，`alpine`只有 5M 左右为`debian`的 20 分之一

alpine      latest    5cb3aa00f899        3 weeks ago         5.53MB
    debian      latest    0af60a5c6dd0        3 weeks ago         101MB
    ubuntu      18.04     47b19964fb50        7 weeks ago         88.1MB
    ubuntu      latest    47b19964fb50        7 weeks ago         88.1MB
    alpine      3.8       3f53bb00af94        3 months ago        4.41MB
    复制代码

似乎从上面看，感觉差距不大，实践中，不同语言的基础镜像都会提供一些采用不同基础镜像制作的 tag，下面我们以`ruby`的镜像为例，查看不同基础镜像的差异。可以看到默认的 latest 镜像`881MB`而`alpine`仅仅只有不到`50MB`这个差距就十分的可观了

ruby   latest   a5d26127d8d0        4 weeks ago         881MB
    ruby   alpine   8d8f7d19d1fa        4 weeks ago         47.8MB
    ruby   slim     58dd4d3c99da        4 weeks ago         125MB
    复制代码

## 减少层，去除非必要的文件 ##

1.  删除文件不要跨行

# dockerfile 1
    FROM alpine
    
    RUN wget https://github.com/mohuishou/scuplus-wechat/archive/1.0.0.zip 
    # dockerfile 2
    FROM alpine
    
    RUN wget https://github.com/mohuishou/scuplus-wechat/archive/1.0.0.zip RUN rm 1.0.0.zip 
    # dockerfile 3
    FROM alpine
    
    RUN wget https://github.com/mohuishou/scuplus-wechat/archive/1.0.0.zip && rm 1.0.0.zip 复制代码

test   3  351a80e99c22        5 seconds ago        5.53MB
    test   2  ad27e625b8e5        49 seconds ago       6.1MB
    test   1  165e2e0df1d3        About a minute ago   6.1MB
    复制代码

可以发现 1，2 两个大小一样，但是 3 小了 0.5MB，这是因为 docker 几乎每一行命令都会生成一个层，删除文件的时候：因为底下各层都是只读的，当需要删除这些层中的文件时，AUFS 使用 whiteout 机制，它的实现是通过在上层的可写的目录下建立对应的 whiteout 隐藏文件来实现的，所以在当前层去删除上一层的文件，只是会把这个文件隐藏掉罢了

1.  使用单行命令

除了删除语句需要放在一行以外，由于层的机制，我们安装依赖的一些公共的语句最好也使用条`RUN`命令生成，减少最终的层数

1.  分离依赖包，以及源代码程序，充分利用层的缓存
    
    这是一个**最佳实践**，在实际的开发过程中，我们的依赖包往往是变动不大的，但是我们正在开发的源码的变动是较为频繁，如果我们实际的代码只有`10M`，但是依赖项有`1G`, 如果在`COPY`的时候直接`COPY . .`会导致每次修改代码都会时这一层的缓存失效，导致浪费复制以及推送到镜像仓库的时间，将 COPY 语句分开，每次 push 就可以只变更我们频繁修改的代码层，而不是连着依赖一起
2.  使用`.dockerignore`
    
    在使用`Git`时，我们可以通过`.gitignore`忽略文件，在 docker build 的时候也可以使用`.dockerignore`在 Docker 上下文中忽略文件，这样不仅可以减少一些非必要文件的导入，也可以提高安全性，避免将一些配置文件打包到镜像中

## 多阶段构建 ##

多阶段构建其实也是减少层的一种，通过多阶段构建，最终镜像可以仅包含最后生成的可执行文件，和必须的运行时依赖，大大减少镜像体积。

以`GO`语言为例，实际运行的过程中只需要最后编译生成的二进制文件即可，而`GO`语言本省以及扩展包，代码文件都是不必要的，但是我们在编译的时候这些依赖又是必须的，这时候就可以使用多阶段构建的方式，减少最终生成的镜像体积

# 使用golang镜像作为builder镜像
    FROM golang:1.12 as builder
    
    WORKDIR /go/src/github.com/go/helloworld/ 
    COPY app.go . 
    RUN go build -o app . 
    # 编译完成之后使用alpine镜像作为最终的基础镜像
    FROM alpine:latest as prod
    
    RUN apk --no-cache add ca-certificates 
    WORKDIR /root/ 
    # 从builder中复制编译好的二进制文件
    COPY --from=builder /go/src/github.com/go/helloworld/app . 
    CMD ["./app"] 复制代码

由于本文篇幅较长，这里不对多阶段构建展开讲解，详情可以参考[多阶段构建][Link 1]

## 奇淫技巧 ##

1.  使用[dive][]查看 docker 镜像的层，可以帮助你分析减少镜像体积
2.  使用[docker-slim][] 可以自动帮助你减少镜像体积，对于 Web 应用较为有用
3.  安装软件时去除依赖

# ubuntu
    apt-get install -y — no-install-recommends
    
    #alpine
    apk add --no-cache &&  apk del build-dependencies
    
    # centos
    yum install -y ... && yum clean all
    复制代码

1.  使用`--flatten`参数，减少层(不推荐)
2.  使用[docker-squash][]压缩层

## 不同语言的示例 ##

> 添加中......

### Ruby(Rails) ###

1.  只安装生产所需的依赖
2.  删除不需要的依赖文件

bundle install --without development:test:assets -j4 --retry 3 --path=vendor/bundle \
        # Remove unneeded files (cached *.gem, *.o, *.c)
        && rm -rf vendor/bundle/ruby/2.5.0/cache/*.gem \
        && find vendor/bundle/ruby/2.5.0/gems/ -name "*.c" -delete \
        && find vendor/bundle/ruby/2.5.0/gems/ -name "*.o" -delete
    复制代码

1.  删除前端的`node_modules`以及缓存文件

rm -rf node_modules tmp/cache app/assets vendor/assets spec
    复制代码

上述内容可以结合**多阶段构建**实现

### Golang ###

Golang 在使用多阶段构建之后，只剩下了一个二进制文件，这时候再要优化，就只有使用`upx`之类的工具压缩二进制文件的体积了

## 参考资料 ##

1.  [Docker 容器镜像瘦身的三个小窍门][Docker]
2.  [基础镜像 | 再谈 Docker 瘦身][_ _ Docker]
3.  [Docker —— 从入门到实践][Docker _]这是一本很不错的 Docker 开源书
4.  [Docker 基本原理简析][Docker 1]
5.  [Ruby on Rails — Smaller docker images][Ruby on Rails _ Smaller docker images]

## License ##

*  本文作者： mohuishou [1@lailin.xyz][1_lailin.xyz]
 *  本文链接： [lailin.xyz/post/51252.…][lailin.xyz_post_51252.]
 *  版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

[lailin.xyz_post_51252.]: https://link.juejin.im?target=https%3A%2F%2Flailin.xyz%2Fpost%2F51252.html
[distroless]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2FGoogleCloudPlatform%2Fdistroless
[alpine]: https://link.juejin.im?target=https%3A%2F%2Fhub.docker.com%2F_%2Falpine
[scratch]: https://link.juejin.im?target=https%3A%2F%2Fhub.docker.com%2F_%2Fscratch
[busybox]: https://link.juejin.im?target=https%3A%2F%2Fhub.docker.com%2F_%2Fbusybox
[Docker Hub]: https://link.juejin.im?target=https%3A%2F%2Fhub.docker.com
[Link 1]: https://link.juejin.im?target=https%3A%2F%2Fyeasy.gitbooks.io%2Fdocker_practice%2Fimage%2Fmultistage-builds%2F%23%25E5%25A4%259A%25E9%2598%25B6%25E6%25AE%25B5%25E6%259E%2584%25E5%25BB%25BA
[dive]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Fwagoodman%2Fdive
[docker-slim]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Fdocker-slim%2Fdocker-slim
[docker-squash]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Fjwilder%2Fdocker-squash
[Docker]: https://link.juejin.im?target=http%3A%2F%2Fdockone.io%2Farticle%2F8174
[_ _ Docker]: https://link.juejin.im?target=https%3A%2F%2Fliulantao.com%2Fdocker-base-images.html
[Docker _]: https://link.juejin.im?target=https%3A%2F%2Flegacy.gitbook.com%2Fbook%2Fyeasy%2Fdocker_practice%2Fdetails
[Docker 1]: https://link.juejin.im?target=https%3A%2F%2Fjingwei.link%2F2018%2F07%2F18%2Fdocker-namespace-cgroups-aufs.html%23aufs
[Ruby on Rails _ Smaller docker images]: https://link.juejin.im?target=https%3A%2F%2Fmedium.com%2F%40lemuelbarango%2Fruby-on-rails-smaller-docker-images-bff240931332
[1_lailin.xyz]: https://link.juejin.im?target=mailto%3A1%40lailin.xyz