Docker

Docker通过读取Dockerfile中的指令自动构建镜像，Dockerfile是一个文本文件，其中依次包含构建给定镜像所需的所有命令。

2021-06-04-23-59-40-812490.png
上面的解释摘自Docker的官方文档并总结了Dockerfile的用途。Dockerfile的使用非常重要，因为它是镜像构建的蓝图。
利用BuildKit功能，这是Docker v18.09上引入的一组增强功能。集成BuildKit将提供更好的性能，存储管理和安全性。

先决条件

  • Docker概念知识
  • 已安装Docker（当前使用v19.03）

  • 一个Java应用程序（使用了一个Jenkins Maven示例应用程序）

    简单的Dockerfile示例

    以下是一个包含Java应用程序的未优化Dockerfile的示例。将逐步进行一些优化。

    1. FROM debian
    2. COPY . /app
    3. RUN apt-get update
    4. RUN apt-get -y install openjdk-11-jdk ssh emacs
    5. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    在这里，可能会问自己：构建需要多长时间？为了回答这个问题，在本地开发环境上创建该Dockerfile，并让Docker构建镜像。

    1. # enter your Java app folder
    2. cd simple-java-maven-app-master
    3. # create a Dockerfile
    4. vim Dockerfile
    5. # write content, save and exit
    6. docker pull debian:latest # pull the source image
    7. time docker build --no-cache -t docker-class . # overwrite previous layers
    8. # notice the build time
    9. 0,21s user 0,23s system 0% cpu 1:55,17 total

    此时，构建需要1m55s。
    如果仅启用BuildKit而没有其他更改，会有什么不同吗？

    启用BuildKit

    BuildKit可以通过两种方法启用：
    在调用Docker build命令时设置DOCKER_BUILDKIT = 1环境变量，例如：

    1. time DOCKER_BUILDKIT=1 docker build --no-cache -t docker-class

    将Docker BuildKit设置为默认开启，需要在/etc/docker/daemon.json进行如下设置，然后重启：

    1. { "features": { "buildkit": true } }

    BuildKit最初的效果

    1. DOCKER_BUILDKIT=1 docker build --no-cache -t docker-class .
    2. 0,54s user 0,93s system 1% cpu 1:43,00 total

    此时构建需要1m43s。在相同的硬件上，构建花费的时间比以前少了约12秒。这意味着构建几乎无需费力即可节约10％左右的时间。
    现在看看是否可以采取一些额外的步骤来进一步改善。

    从最小到最频繁变化的顺序

    因为顺序对于缓存很重要，所以将COPY命令移到更靠近Dockerfile末尾的位置。

    1. FROM debian
    2. RUN apt-get update
    3. RUN apt-get -y install openjdk-11-jdk ssh emacs
    4. RUN COPY . /app
    5. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    避免使用“COPY .”

    选择更具体的COPY参数，以避免缓存中断。仅复制所需内容。

    1. FROM debian
    2. RUN apt-get update
    3. RUN apt-get -y install openjdk-11-jdk ssh vim
    4. COPY target/my-app-1.0-SNAPSHOT.jar /app
    5. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    apt-get update 和install命令一起使用

    这样可以防止使用过时的程序包缓存。

    1. FROM debian
    2. RUN apt-get update && \
    3.   apt-get -y install openjdk-11-jdk ssh vim
    4. COPY target/my-app-1.0-SNAPSHOT.jar /app
    5. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    删除不必要的依赖

    在开始时，不要安装调试和编辑工具，以后可以在需要时安装它们。

    1. FROM debian
    2. RUN apt-get update && \
    3.   apt-get -y install --no-install-recommends \
    4.   openjdk-11-jdk
    5. COPY target/my-app-1.0-SNAPSHOT.jar /app
    6. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    删除程序包管理器缓存

    镜像不需要此缓存数据。借此机会释放一些空间。

    1. FROM debian
    2. RUN apt-get update && \
    3.   apt-get -y install --no-install-recommends \
    4.   openjdk-11-jdk && \
    5.   rm -rf /var/lib/apt/lists/*
    6. COPY target/my-app-1.0-SNAPSHOT.jar /app
    7. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    尽可能使用官方镜像

    使用官方镜像有很多理由，例如减少镜像维护时间和减小镜像尺寸，以及预先配置镜像以供容器使用。

    1. FROM openjdk
    2. COPY target/my-app-1.0-SNAPSHOT.jar /app
    3. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

    使用特定标签

    请勿使用latest标签。

    1. FROM openjdk:8
    2. COPY target/my-app-1.0-SNAPSHOT.jar /app
    3. CMD ["java", "-jar", "/app/my-app-1.0-SNAPSHOT.jar"]

    寻找最小的镜像

    以下是openjdk镜像列表。选择最适合自己的最轻的那个镜像。
    REPOSITORY TAG标签 SIZE大小
    openjdk 8 634MB
    openjdk 8-jre 443MB
    openjdk 8-jre-slim 204MB
    openjdk 8-jre-alpine 83MB

    在一致的环境中从源构建

    如果不需要整个JDK，则可以使用Maven Docker镜像作为构建基础。

    1. FROM maven:3.6-jdk-8-alpine
    2. WORKDIR /app
    3. COPY pom.xml .
    4. COPY src ./src
    5. RUN mvn -e -B package
    6. CMD ["java", "-jar", "/app/my-app-1.0-SNAPSHOT.jar"]

    在单独的步骤中获取依赖项

    可以缓存–用于获取依赖项的Dockerfile命令。缓存此步骤将加快构建速度。

    1. FROM maven:3.6-jdk-8-alpine
    2. WORKDIR /app
    3. COPY pom.xml .
    4. RUN mvn -e -B dependency:resolve
    5. COPY src ./src
    6. RUN mvn -e -B package
    7. CMD ["java", "-jar", "/app/my-app-1.0-SNAPSHOT.jar"]

    多阶段构建：删除构建依赖项

    为什么要使用多阶段构建？

  • 将构建与运行时环境分开

  • DRY方式
    • 具有开发，测试等环境的不同详细信息
  • 线性化依赖关系
  • 具有特定于平台的阶段 ```dockerfile FROM maven:3.6-jdk-8-alpine AS builder WORKDIR /app COPY pom.xml . RUN mvn -e -B dependency:resolve COPY src ./src RUN mvn -e -B package

FROM openjdk:8-jre-alpine COPY —from=builder /app/target/my-app-1.0-SNAPSHOT.jar / CMD [“java”, “-jar”, “/my-app-1.0-SNAPSHOT.jar”]

  1. 如果此时构建应用程序，
  2. ```bash
  3. time DOCKER_BUILDKIT=1 docker build --no-cache -t docker-class .
  4. 0,41s user 0,54s system 2% cpu 35,656 total

可以注意到应用程序构建需要大约35.66秒的时间。这是一个令人愉快的进步。
下面，将介绍其他场景的功能。

多阶段构建：不同的镜像风格

下面的Dockerfile显示了基于Debian和基于Alpine的镜像的不同阶段。

  1. FROM maven:3.6-jdk-8-alpine AS builder
  2. …
  3. FROM openjdk:8-jre-jessie AS release-jessie
  4. COPY --from=builder /app/target/my-app-1.0-SNAPSHOT.jar /
  5. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]
  7. FROM openjdk:8-jre-alpine AS release-alpine
  8. COPY --from=builder /app/target/my-app-1.0-SNAPSHOT.jar /
  9. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

要构建特定的镜像，可以使用–target参数：

  1. time docker build --no-cache --target release-jessie .

不同的镜像风格（DRY /全局ARG）

  1. ARG flavor=alpine
  2. FROM maven:3.6-jdk-8-alpine AS builder
  3. …
  4. FROM openjdk:8-jre-$flavor AS release
  5. COPY --from=builder /app/target/my-app-1.0-SNAPSHOT.jar /
  6. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

ARG命令可以指定要构建的镜像。在上面的例子中，指定alpine为默认的镜像，但也可以在docker build命令中，通过–build-arg flavor=参数指定镜像。

  1. time docker build --no-cache --target release --build-arg flavor=jessie .

并发

并发在构建Docker镜像时很重要，因为它会充分利用可用的CPU线程。在线性Dockerfile中，所有阶段均按顺序执行。通过多阶段构建，可以让较小的依赖阶段准备就绪，以供主阶段使用它们。
BuildKit甚至带来了另一个性能上的好处。如果在以后的构建中不使用该阶段，则在结束时将直接跳过这些阶段，而不是对其进行处理和丢弃。
下面是一个示例Dockerfile，其中网站的资产是在一个assets阶段中构建的：

  1. FROM maven:3.6-jdk-8-alpine AS builder
  2. …
  3. FROM tiborvass/whalesay AS assets
  4. RUN whalesay “Hello DockerCon!” > out/assets.html
  6. FROM openjdk:8-jre-alpine AS release
  7. COPY --from=builder /app/my-app-1.0-SNAPSHOT.jar /
  8. COPY --from=assets /out /assets
  9. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

这是另一个Dockerfile，其中分别编译了C和C ++库，并在builder以后使用该阶段。

  1. FROM maven:3.6-jdk-8-alpine AS builder-base
  2. …
  4. FROM gcc:8-alpine AS builder-someClib
  5. …
  6. RUN git clone … ./configure --prefix=/out && make && make install
  8. FROM g++:8-alpine AS builder-some CPPlib
  9. …
  10. RUN git clone … && cmake …
  12. FROM builder-base AS builder
  13. COPY --from=builder-someClib /out /
  14. COPY --from=builder-someCpplib /out /

BuildKit应用程序缓存

BuildKit具有程序包管理器缓存的特殊功能。以下是一些缓存文件夹位置的示例：

包管理器路径
  1. apt /var/lib/apt/lists
  2. go ~/.cache/go-build
  3. go-modules $GOPATH/pkg/mod
  4. npm ~/.npm
  5. pip ~/.cache/pip

可以将此Dockerfile与上面介绍的在一致的环境中从源代码构建中介绍的Dockerfile进行比较。这个较早的Dockerfile没有特殊的缓存处理。可以使用–mount=type=cache来做到这一点。

  1. FROM maven:3.6-jdk-8-alpine AS builder
  2. WORKDIR /app
  3. RUN --mount=target=. --mount=type=cache,target /root/.m2 \
  4.     && mvn package -DoutputDirectory=/
  6. FROM openjdk:8-jre-alpine
  7. COPY --from=builder /app/target/my-app-1.0-SNAPSHOT.jar /
  8. CMD ["java", "-jar", "/my-app-1.0-SNAPSHOT.jar"]

BuildKit的安全功能

BuildKit具有安全功能，下面的示例中，使用了–mount=type=secret隐藏了一些机密文件，例如~/.aws/credentials。

  1. FROM <baseimage>
  2. RUN …
  3. RUN --mount=type=secret,id=aws,target=/root/.aws/credentials,required \
  4. ./fetch-assets-from-s3.sh
  5. RUN ./build-scripts.sh

要构建此Dockerfile，需要使用–secret参数：

  1. docker build --secret id=aws,src=~/.aws/credentials

还有为了提高安全性，避免使用诸如COPY ./keys/private.pem /root .ssh/private.pem之类的命令，可以使用BuildKit中的ssh解决此问题：

  1. FROM alpine
  2. RUN apk add --no-cache openssh-client
  3. RUN mkdir -p -m 0700 ~/.ssh && ssh-keyscan github.com >> ~/.ssh/known_hosts
  4. ARG REPO_REF=19ba7bcd9976ef8a9bd086187df19ba7bcd997f2
  5. RUN --mount=type=ssh,required git clone git@github.com:org/repo /work && cd /work && git checkout -b $REPO_REF

要构建此Dockerfile，需要在ssh-agent中加载到SSH私钥。

  1. eval $(ssh-agent)
  2. ssh-add ~/.ssh/id_rsa # this is the SSH key default location
  3. docker build --ssh=default .

结论

使用Docker BuildKit优化Dockerfile，并因此加快了镜像构建时间。这些速度的提高，可以提高效率和节省计算能力。