程序员如何编写优雅的Dockerfile

Kubernetes要从容器化开始，而容器又需要从Dockerfile开始，本文将介绍如何写出一个优雅的Dockerfile文件。

创新互联建站主要从事网站建设、网站设计、网页设计、企业做网站、公司建网站等业务。立足成都服务钦州,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

文章主要内容包括：

  • Docker容器
  • Dockerfile
  • 使用多阶构建

感谢公司提供大量机器资源及时间让我们可以实践，感谢在此专题上不断实践的部分项目及人员的支持。

一、Docker容器

1. 容器的特点

我们都知道容器就是一个标准的软件单元，它有以下特点：

  • 随处运行：容器可以将代码与配置文件和相关依赖库进行打包，从而确保在任何环境下的运行都是一致的。
  • 高资源利用率：容器提供进程级的隔离，因此可以更加精细地设置CPU和内存的使用率，进而更好地利用服务器的计算资源。
  • 快速扩展：每个容器都可作为单独的进程予以运行，并且可以共享底层操作系统的系统资源，这样一来可以加快容器的启动和停止效率。

2. Docker容器

目前市面上的主流容器引擎有Docker、Rocket/rkt、OpenVZ/Odin等等，而独霸一方的容器引擎就是使用最多的Docker容器引擎。

Docker容器是与系统其他部分隔离开的一系列进程，运行这些进程所需的所有文件都由另一个镜像提供，从开发到测试再到生产的整个过程中，Linux 容器都具有可移植性和一致性。相对于依赖重复传统测试环境的开发渠道，容器的运行速度要快得多，并且支持在多种主流云平台(PaaS)和本地系统上部署。Docker容器很好地解决了“开发环境能正常跑，一上线就各种崩”的尴尬。

Docker容器的特点：

  • 轻量：容器是进程级的资源隔离，而虚拟机是操作系统级的资源隔离，所以Docker容器相对于虚拟机来说可以节省更多的资源开销，因为Docker容器不再需要GuestOS这一层操作系统了。
  • 快速：容器的启动和创建无需启动GuestOS，可以实现秒级甚至毫秒级的启动。
  • 可移植性：Docker容器技术是将应用及所依赖的库和运行时的环境技术改造包成容器镜像，可以在不同的平台运行。
  • 自动化：容器生态中的容器编排工作(如：Kubernetes)可帮助我们实现容器的自动化管理。

二、Dockerfile

Dockerfile是用来描述文件的构成的文本文档，其中包含了用户可以在使用行调用以组合Image的所有命令，用户还可以使用Docker build实现连续执行多个命令指今行的自动构建。

通过编写Dockerfile生磁镜像，可以为开发、测试团队提供基本一致的环境，从而提升开发、测试团队的效率，不用再为环境不统一而发愁，同时运维也能更加方便地管理我们的镜像。

Dockerfile的语法非常简单，常用的只有11个：

1. 编写优雅地Dockerfile

编写优雅的Dockerfile主要需要注意以下几点：

  • Dockerfile文件不宜过长，层级越多最终制作出来的镜像也就越大。
  • 构建出来的镜像不要包含不需要的内容，如日志、安装临时文件等。
  • 尽量使用运行时的基础镜像，不需要将构建时的过程也放到运行时的Dockerfile里。

只要记住以上三点就能写出不错的Dockerfile。

为了方便大家了解，我们用两个Dockerfile实例进行简单的对比：

 
 
 
 
    
  
  
  
  
  1. FROM ubuntu:16.04 
    2. 
  
  
  
  
  2. RUN apt-get update 
    3. 
  
  
  
  
  3. RUN apt-get install -y apt-utils libjpeg-dev \      
    4. 
  
  
  
  
  4. python-pip 
    5. 
  
  
  
  
  5. RUN pip install --upgrade pip 
    6. 
  
  
  
  
  6. RUN easy_install -U setuptools 
    7. 
  
  
  
  
  7. RUN apt-get clean 
    8. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. FROM ubuntu:16.04 
    2. 
  
  
  
  
  2. RUN apt-get update && apt-get install -y apt-utils \ 
    3. 
  
  
  
  
  3.   libjpeg-dev python-pip \ 
    4. 
  
  
  
  
  4.            && pip install --upgrade pip \ 
    5. 
  
  
  
  
  5.       && easy_install -U setuptools \ 
    6. 
  
  
  
  
  6.     && apt-get clean 
    7.

我们看***个Dockerfile，乍一看条理清晰，结构合理，似乎还不错。再看第二个Dockerfile，紧凑，不易阅读，为什么要这么写?

  • ***个Dockerfile的好处是：当正在执行的过程某一层出错，对其进行修正后再次Build，前面已经执行完成的层不会再次执行。这样能大大减少下次Build的时间，而它的问题就是会因层级变多了而使镜像占用的空间也变大。
  • 第二个Dockerfile把所有的组件全部在一层解决，这样做能一定程度上减少镜像的占用空间，但在制作基础镜像的时候若其中某个组编译出错，修正后再次Build就相当于重头再来了，前面编译好的组件在一个层里，得全部都重新编译一遍，比较消耗时间。

从下表可以看出两个Dockerfile所编译出来的镜像大小：

 
 
 
 
    
  
  
  
  
  1. $ docker images | grep ubuntu       
    2. 
  
  
  
  
  2. REPOSITORY      TAG     IMAGE ID    CREATED     SIZE                                                                                                                                    
    3. 
  
  
  
  
  3. ubuntu                   16.04       9361ce633ff1  1 days ago 422MB 
    4. 
  
  
  
  
  4. ubuntu                   16.04-1   3f5b979df1a9  1 days ago  412MB 
    5.

呃…. 好像并没有特别的效果，但若Dockerfile非常长的话可以考虑减少层次，因为Dockerfile***只能有127层。

三、使用多阶构建

Docker在升级到Docker 17.05之后就能支持多阶构建了，为了使镜像更加小巧，我们采用多阶构建的方式来打包镜像。在多阶构建出现之前我们通常使用一个Dockerfile或多个Dockerfile来构建镜像。

1. 单文件构建

在多阶构建出来之前使用单个文件进行构建，单文件就是将所有的构建过程(包括项目的依赖、编译、测试、打***程)全部包含在一个Dockerfile中之下：

 
 
 
 
    
  
  
  
  
  1. FROM golang:1.11.4-alpine3.8 AS build-env 
    2. 
  
  
  
  
  2. ENV GO111MODULE=off 
    3. 
  
  
  
  
  3. ENV GO15VENDOREXPERIMENT=1 
    4. 
  
  
  
  
  4. ENV BUILDPATH=github.com/lattecake/hello 
    5. 
  
  
  
  
  5. RUN mkdir -p /go/src/${BUILDPATH} 
    6. 
  
  
  
  
  6. COPY ./ /go/src/${BUILDPATH} 
    7. 
  
  
  
  
  7. RUN cd /go/src/${BUILDPATH} && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go install –v 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. CMD [/go/bin/hello] 
    10.

这种的做法会带来一些问题：

  1. Dockerfile文件会特别长，当需要的东西越来越多的时候可维护性指数级将会下降;
  2. 镜像层次过多，镜像的体积会逐步增大，部署也会变得越来越慢;
  3. 代码存在泄漏风险。

以Golang为例，它运行时不依赖任何环境，只需要有一个编译环境，那这个编译环境在实际运行时是没有任务作用的，编译完成后，那些源码和编译器已经没有任务用处了也就没必要留在镜像里。

上表可以看到，单文件构建最终占用了312MB的空间。

2.  多文件构建

在多阶构建出来之前有没有好的解决方案呢?有，比如采用多文件构建或在构建服务器上安装编译器，不过在构建服务器上安装编译器这种方法我们就不推荐了，因为在构建服务器上安装编译器会导致构建服务器变得非常臃肿，需要适配各个语言多个版本、依赖，容易出错，维护成本高。所以我们只介绍多文件构建的方式。

多文件构建，其实就是使用多个Dockerfile，然后通过脚本将它们进行组合。假设有三个文件分别是：Dockerfile.run、Dockerfile.build、build.sh。

  • Dockerfile.run就是运行时程序所必须需要的一些组件的Dockerfile，它包含了最精简的库;
  • Dockerfile.build只是用来构建，构建完就没用了;
  • build.sh的功能就是将Dockerfile.run和Dockerfile.build进行组成，把Dockerfile.build构建好的东西拿出来，然后再执行Dockerfile.run，算是一个调度的角色。

Dockerfile.build

 
 
 
 
    
  
  
  
  
  1. FROM golang:1.11.4-alpine3.8 AS build-env 
    2. 
  
  
  
  
  2. ENV GO111MODULE=off 
    3. 
  
  
  
  
  3. ENV GO15VENDOREXPERIMENT=1 
    4. 
  
  
  
  
  4. ENV BUILDPATH=github.com/lattecake/hello 
    5. 
  
  
  
  
  5. RUN mkdir -p /go/src/${BUILDPATH} 
    6. 
  
  
  
  
  6. COPY ./ /go/src/${BUILDPATH} 
    7. 
  
  
  
  
  7. RUN cd /go/src/${BUILDPATH} && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go install –v 
    8.

Dockerfile.run

 
 
 
 
    
  
  
  
  
  1. FROM alpine:latest 
    2. 
  
  
  
  
  2. RUN apk –no-cache add ca-certificates 
    3. 
  
  
  
  
  3. WORKDIR /root 
    4. 
  
  
  
  
  4. ADD hello . 
    5. 
  
  
  
  
  5. CMD ["./hello"] 
    6.

Build.sh

 
 
 
 
    
  
  
  
  
  1. #!/bin/sh 
    2. 
  
  
  
  
  2. docker build -t –rm hello:build . -f Dockerfile.build 
    3. 
  
  
  
  
  3. docker create –name extract hello:build 
    4. 
  
  
  
  
  4. docker cp extract:/go/bin/hello ./hello 
    5. 
  
  
  
  
  5. docker rm -f extract 
    6. 
  
  
  
  
  6. docker build –no-cache -t –rm hello:run . -f Dockerfile.run 
    7. 
  
  
  
  
  7. rm -rf ./hello 
    8.

执行build.sh完成项目的构建。

从上表可以看到，多文件构建大大减小了镜像的占用空间，但它有三个文件需要管理，维护成本也更高一些。

3. 多阶构建

***我们来看看万众期待的多阶构建。

完成多阶段构建我们只需要在Dockerfile中多次使用FORM声明，每次FROM指令可以使用不同的基础镜像，并且每次FROM指令都会开始新的构建，我们可以选择将一个阶段的构建结果复制到另一个阶段，在最终的镜像中只会留下***一次构建的结果，这样就可以很容易地解决前面提到的问题，并且只需要编写一个Dockerfile文件。这里值得注意的是：需要确保Docker的版本在17.05及以上。下面我们来说说具体操作。

在Dockerfile里可以使用as来为某一阶段取一个别名”build-env”：

 
 
 
 
    
  
  
  
  
  1. FROM golang:1.11.2-alpine3.8 AS build-env 
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. COPY –from=build-env /go/bin/hello /usr/bin/hello  
    2.

看一个简单的例子：

 
 
 
 
    
  
  
  
  
  1. FROM golang:1.11.4-alpine3.8 AS build-env 
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3. ENV GO111MODULE=off 
    4. 
  
  
  
  
  4. ENV GO15VENDOREXPERIMENT=1 
    5. 
  
  
  
  
  5. ENV GITPATH=github.com/lattecake/hello 
    6. 
  
  
  
  
  6. RUN mkdir -p /go/src/${GITPATH} 
    7. 
  
  
  
  
  7. COPY ./ /go/src/${GITPATH} 
    8. 
  
  
  
  
  8. RUN cd /go/src/${GITPATH} && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go install -v 
    9. 
  
  
  
  
  9.   
    10. 
  
  
  
  
  10. FROM alpine:latest 
    11. 
  
  
  
  
  11. ENV apk –no-cache add ca-certificates 
    12. 
  
  
  
  
  12. COPY --from=build-env /go/bin/hello /root/hello 
    13. 
  
  
  
  
  13. WORKDIR /root 
    14. 
  
  
  
  
  14. CMD ["/root/hello"] 
    15.

执行docker build -t –rm hello3 .后再执行docker images ，然后我们来看镜像的大小：

多阶构建给我们带来很多便利，***的优势是在保证运行镜像足够小的情况下还减轻了Dockerfile的维护负担，因此我们极力推荐使用多阶构建来将你的代码打包成Docker 镜像。

【本文是专栏机构宜信技术学院的原创文章，微信公众号“宜信技术学院( id: CE_TECH)”】

戳这里，看该作者更多好文

本文题目：程序员如何编写优雅的Dockerfile
文章转载：http://www.36103.cn/qtweb/news45/32345.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

营销型网站建设知识

行业网站建设

艾名斯智能　　 　香港虚拟主机空间　　 　彭州网站建设　　 　网站维护报价　　 　鼎尚理发店　　 　主机租用　　 　seo优化　　 　成都广告公司　　 　腾讯香港空间　　 　康明斯发电机　　 　微信公众号开发　　 　四川白乌鱼　　 　成都画册快印　　 　成都商城网站制作　　 　新津网站运维　　 　重庆小程序开发公司　　 　成都响应式网站　　 　响应式网站　　 　广西弘博建站　　 　成都网站改版