SpringBoot 2.3.x 分层构建 Docker 镜像实践

2020-12-08 21:38:00 docker springboot dockerfile

文章目录

系统环境：

Docker 版本： 19.03.13
Open JDK 基础镜像版本： openjdk:8u275
私有的 Harbor 镜像仓库：自建 Harbor 私库
项目 Github： SpringBoot 2.3.x 分层构建 Docker 镜像示例

参考地址：

Docker 官方文档-镜像分层机制介绍

一、什么是镜像分层

镜像的构成

现在一谈起镜像大部分都是指 Docker 引擎构建的镜像，一般 Docker 镜像是由很多层组成，底层是操作系统，然后在其之上是基础镜像或者用户自定义 Dockerfile 脚本中定义的中间层。其中镜像在构建完成后，用户只能对镜像进行读操作，而不能进行写操作，只有镜像启动后变为容器，才能进行读写操作。镜像整体结构，可以观看下图：

该图中展示了镜像的基本组成，但是图中这一个个中间层是什么呢？要想了解这些层具体是什么，那得知道如何构建 Docker 镜像了。平时我们构建 Docker 镜像时候，都是编写 Dockerfile 脚本，然后使用 Docker 镜像构建命令，按照脚本一行行执行构建。

如下就是一个 Dockerfile 脚本，脚本内容就构建 Java 项目镜像常用的 Dockerfile 命令：

1FROM openjdk:8u275
2VOLUME /tmp
3ADD target/*.jar app.jar
4ENV TZ="Asia/Shanghai"
5ENV JAVA_OPTS=""
6ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
7ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS -jar /app.jar"]

有了 Dockerfile 脚本，我们需要执行 Docker 的构建镜像命令对执行 Dockerfile 脚本构建镜像，其中构建镜像的过程如下：

 1## 构建镜像的命令
 2$ docker build -t java-test:latest . 
 3
 4## 命令执行的过程
 5Step 1/7 : FROM openjdk:8u275
 6 ---> 82f24ce79de6
 7Step 2/7 : VOLUME /tmp
 8 ---> Running in a6361fdfc193
 9Removing intermediate container a6361fdfc193
10 ---> a43948bf1b98
11Step 3/7 : ADD target/*.jar app.jar
12 ---> 18f4bc60818f
13Step 4/7 : ENV TZ="Asia/Shanghai"
14 ---> Running in cc738aa5865b
15Removing intermediate container cc738aa5865b
16 ---> 538adb85609e
17Step 5/7 : ENV JAVA_OPTS=""
18 ---> Running in f8b635d32b2b
19Removing intermediate container f8b635d32b2b
20 ---> 34e7a8cd7b6e
21Step 6/7 : ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
22 ---> Running in 9331cb6e443e
23Removing intermediate container 9331cb6e443e
24 ---> 232b9c6c1d29
25Step 7/7 : ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS -jar /app.jar" ]
26 ---> Running in c3a24fba3a10
27Removing intermediate container c3a24fba3a10
28 ---> a41974d5f0e3

可以看到总共存在 7 个构建步骤，每步都与 Dockerfile 里面一行指令对应。样子和下图相似：

如果这时候，我们改变原来 Dockerfile 内容，创建一个新的镜像，其 Dockerfile 如下：

1FROM openjdk:8u275
2VOLUME /tmp
3ADD target/*.jar app.jar
4ENV TZ="Asia/Macao"                  #与原来 Dockerfile 不同
5ENV JVM_OPTS="-Xmx512m -Xss256k"     #与原来 Dockerfile 不同
6ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS -jar /app.jar" ]

执行 Docker 命令构建镜像：

 1$ docker build -t java-test2:latest .
 2
 3Step 1/6 : FROM openjdk:8u275
 4 ---> 82f24ce79de6
 5Step 2/6 : VOLUME /tmp
 6 ---> Using cache
 7 ---> a43948bf1b98
 8Step 3/6 : ADD target/*.jar app.jar
 9 ---> Using cache
10 ---> 18f4bc60818f
11Step 4/6 : ENV TZ="Asia/Macao"
12 ---> Running in fd98b90a5485
13Removing intermediate container fd98b90a5485
14 ---> afab3fcdab07
15Step 5/6 : ENV JVM_OPTS="-Xmx512m -Xss256k"
16 ---> Running in 19a99576fba9
17Removing intermediate container 19a99576fba9
18 ---> 4eeab7d7c720
19Step 6/6 : ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS -jar /app.jar" ]
20 ---> Running in 2dba72e1eef4
21Removing intermediate container 2dba72e1eef4
22 ---> 7c706ecf7698

可以观察到执行过程中，从一开始执行的构建步骤中显示，并没有生成新的中间层镜像，而是直接使用了已经存在的缓存镜像。直至 4/6 这部中，由于新的 Dockerfile 与原来 Dockerfile 发生变动，所以这部中间层镜像直接是新创建的，并没有使用缓存中间层镜像。

然后往下观察，发现之后的全部构建都是新创建的中间层镜像，即是脚本最后的一行和原来相同，也没有使用缓存中间层镜像。

上面现象说明，Docker 镜像在构建过程中按照 Dockerfile 自上往下的执行顺序中，如果从最上层开始，其脚本内容和已有的缓存中间层镜像内容一致，就会引入缓存中的中间层镜像（并不是直接复制缓存镜像，而是引入镜像文件地址，多个镜像共享这些中间层镜像）。但是，如果执行过程中中间任意一行镜像构建的内容发生变化，那么当前行和之后的全部行在执行时就不会使用缓存中的中间层镜像，而是全部创建新的镜像。

这就是 Docker 镜像中缓存中间层镜像的复用，学会使用缓存构建镜像将大大减少存储空间的占用以及镜像的构建的构建速度，镜像的缓存不仅仅体现在镜像的构建上，在执行"镜像推送"、"镜像拉取"操作时都能观察到其的好处。

镜像缓在镜像推送的体现： 如镜像推送时候，也是将镜像整体构成的中间层镜像并行推送到镜像仓库，如果镜像仓库中已经存某个中间层镜像，那么推送过程就不会再次将该层镜像推送到镜像仓库，而是将仓库中并不存在中间层镜像推送到其中。
镜像缓存在镜像拉取的体现： 在拉取镜像时候，如果本地某个大镜像的中间层镜像的组成中，已经包含新拉取镜像的中间层部分镜像，那么将直接复用本地已经镜像的中间层镜像，不必再将其进行拉取，而本地不存在的中间层镜像将会被继续拉取。

说了这么多，相信大家已经对镜像缓存的使用有了初步了解，那么再谈及为什么需要镜像分层就很好解释，其原因就是 Docker 想提高资源的复用率，将一个大镜像拆分成很多层小镜像组成，以达到镜像中间层的复用的目的。

二、SpringBoot 2.3.x 新增对分层的支持

SpringBoot 2.3.x 以后支持分层打包应用，需要 Pom.xml 中引入 SpringBoot 2.3.x 后的父依赖和使用 SpringBoot 打包插件 spring-boot-maven-plugin，并且开启 layers 功能，然后执行 Maven 编译源码构建 Jar 包，使用该 Jar 包就可以构建基于分层模式的 Docker 镜像：

项目 pom.xml 中引入 SpringBoot 2.3.x 依赖：

1<parent>
2    <groupId>org.springframework.boot</groupId>
3    <artifactId>spring-boot-starter-parent</artifactId>
4    <version>2.3.6.RELEASE</version>
5    <relativePath/>
6</parent>

项目 pom.xml 中引入 spring-boot-maven-plugin 打包插件，并且开启分层功能：

 1<build>
 2    <plugins>
 3        <plugin>
 4            <groupId>org.springframework.boot</groupId>
 5            <artifactId>spring-boot-maven-plugin</artifactId>
 6            <configuration>
 7                <!--开启分层编译支持-->
 8                <layers>
 9                    <enabled>true</enabled>
10                </layers>
11            </configuration>
12        </plugin>
13    </plugins>
14</build>

执行 Maven 命令，构建分层的 JAR 包，命令和平时的 Maven 构建命令相同：

1$ mvn install

观察 Jar 结构，可以看到里面多了 classpath.idx 与 layers.idx 两个文件：

classpath.idx： 文件列出了依赖的 jar 包列表，到时候会按照这个顺序载入。
layers.idx： 文件清单，记录了所有要被复制到 Dokcer 镜像中的文件信息。

根据官方介绍，在构建 Docker 镜像前需要从 Jar 中提起出对应的分层文件到 Jar 外面，可用使用下面命令列出可以从分层 Jar 中提取出的文件夹信息：

1$ java -Djarmode=layertools -jar target/springboot-layer-0.0.1.jar list

可用该看到以下输出，下面的内容就是接下来使用分层构建后，生成的 Jar 提取出对应资源后的结构：

1dependencies
2spring-boot-loader
3snapshot-dependencies
4application

上面即是使用分层工具提取 Jar 的内容后生成的文件夹，其中各个文件夹作用是：

dependencies： 存储项目正常依赖 Jar 的文件夹。
snapshot-dependencies： 存储项目快照依赖 Jar 的文件夹。
resources： 用于存储静态资源的文件夹。
application： 用于存储应用程序类相关文件的文件夹。

三、创建测试的 SpringBoot 应用

创建测试的 SpringBoot 项目，并且在 pom.xml 中开启镜像分层。

1、Maven 中引入相关依赖和插件

 1<?xml version="1.0" encoding="UTF-8"?>
 2<project xmlns="http://maven.apache.org/POM/4.0.0"
 3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5    <modelVersion>4.0.0</modelVersion>
 6
 7    <parent>
 8        <groupId>org.springframework.boot</groupId>
 9        <artifactId>spring-boot-starter-parent</artifactId>
10        <version>2.3.6.RELEASE</version>
11    </parent>
12
13    <artifactId>springboot-dockerfile-layer</artifactId>
14    <packaging>jar</packaging>
15    <name>springboot-dockerfile-layer</name>
16    <description>springboot build layer example</description>
17
18    <dependencies>
19        <dependency>
20            <groupId>org.springframework.boot</groupId>
21            <artifactId>spring-boot-starter-web</artifactId>
22        </dependency>
23    </dependencies>
24
25    <build>
26        <plugins>
27            <plugin>
28                <groupId>org.springframework.boot</groupId>
29                <artifactId>spring-boot-maven-plugin</artifactId>
30                <configuration>
31                    <layers>
32                        <enabled>true</enabled>
33                    </layers>
34                </configuration>
35            </plugin>
36        </plugins>
37    </build>
38
39</project>

2、创建测试的 Controller 类

 1import org.springframework.web.bind.annotation.GetMapping;
 2import org.springframework.web.bind.annotation.RestController;
 3
 4@RestController
 5public class TestController {
 6
 7    @GetMapping("/hello")
 8    public String hello() {
 9        return "hello world!";
10    }
11
12}

3、创建 SpringBoot 启动类

 1import org.springframework.boot.SpringApplication;
 2import org.springframework.boot.autoconfigure.SpringBootApplication;
 3
 4@SpringBootApplication
 5public class Application {
 6
 7    public static void main(String[] args) {
 8        SpringApplication.run(Application.class, args);
 9    }
10
11}

四、创建两种构建镜像的 Dockerfile 脚本

为了方便体现出 SpringBoot 2.3.x 支持的分层构建 Dockerfile 的优点，这里在 Java 源码文件夹下，创建普通与分层两种构建镜像的 Dockerfile 脚本，后续会使用这两种脚本构建 Docker 镜像进行构建速度、推送速度、拉取速度的对比。

1、普通镜像构建脚本文件 dockerfile-normal

1FROM openjdk:8u275
2VOLUME /tmp
3ADD target/*.jar app.jar
4RUN sh -c 'touch /app.jar'
5ENV TZ="Asia/Shanghai"
6RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
7ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
8ENV JAVA_OPTS=""
9ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar $APP_OPTS" ]

说明：

TZ： 时区设置，而 Asia/Shanghai 表示使用中国上海时区。
JVM_OPTS： 指定 JVM 启动时候的参数，-XX:MaxRAMPercentage 参数和 -Xmx 类似，都是限制堆内存大小，只不过 -Xmx 需要手动指定限制大小，而 -XX:MaxRAMPercentage 则是根据虚拟机可用内存百分比限制。
JAVA_OPTS： 在镜像启动时指定的自定义 Java 参数，例如 -Dspring.application.name=xxx。

2、分层镜像构建脚本文件 dockerfile-layer

 1FROM openjdk:8u275 as builder
 2WORKDIR application
 3COPY target/*.jar application.jar
 4RUN java -Djarmode=layertools -jar application.jar extract
 5
 6FROM openjdk:8u275
 7WORKDIR application
 8COPY --from=builder application/dependencies/ ./
 9COPY --from=builder application/snapshot-dependencies/ ./
10COPY --from=builder application/spring-boot-loader/ ./
11COPY --from=builder application/application/ ./
12ENV TZ="Asia/Shanghai"
13RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
14ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
15ENV JAVA_OPTS=""
16ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS org.springframework.boot.loader.JarLauncher"]

说明：

TZ： 时区设置，而 Asia/Shanghai 表示使用中国上海时区。
-Djarmode=layertools： 指定构建 Jar 的模式。
extract： 从 Jar 包中提取构建镜像所需的内容。
-from=builder 多级镜像构建中，从上一级镜像复制文件到当前镜像中。

五、使用两种 Dockerfile 构建项目镜像

1、在服务器一构建普通 Docker 镜像

(1)、第一次构建

1## 执行 Maven 命令，将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.1 .

Docker 镜像构建总共花费 24.98s 时间。

(2)、第二次构建（修改依赖 pom.xml 文件）

1## 修改 pom.xml 里面的依赖，随意添加一个新的依赖包，然后再次将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.2 .

Docker 镜像构建总共花费 1.27s 时间。

(3)、第三次构建（修改代码内容）

1## 修改源代码任意内容后，然后再次将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.3 .

Docker 镜像构建总共花费 1.32s 时间。

2、在服务器二构建分层 Docker 镜像

(1)、第一次构建

1## 执行 Maven 命令，将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.1 .

Docker 镜像构建总共花费 26.12s 时间。

(2)、第二次构建（修改依赖 pom.xml 文件）

1## 修改 pom.xml 里面的依赖，随意添加一个新的依赖包，然后再次将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.2 .

Docker 镜像构建总共花费 3.44s 时间。

(3)、第三次构建（修改代码内容）

1## 修改源代码任意内容后，然后再次将源代码构建 Jar 包
2$ mvn clean install
3
4## 构建 SpringBoot 应用的 Docker 镜像
5$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.3 .

Docker 镜像构建总共花费 2.82s 时间。

六、镜像推送到镜像仓库测试

1、推送镜像到镜像仓库测试

服务器一推送普通镜像到镜像仓库1：

 1## 第一次推送镜像
 2$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1
 3
 4real    0m35.215s
 5
 6## 第二次推送镜像
 7$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2
 8
 9real    0m14.051s
10
11## 第三次推送镜像
12$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3
13
14real    0m14.183s

服务器二推送分层镜像到镜像仓库2：

 1## 第一次推送镜像
 2$ time docker push hub.mydlq.club/library/springboot-layer:0.0.1
 3
 4real    0m34.121s
 5
 6## 第二次推送镜像
 7$ time docker push hub.mydlq.club/library/springboot-layer:0.0.2
 8
 9real    0m13.605s
10
11## 第三次推送镜像
12$ time docker push hub.mydlq.club/library/springboot-layer:0.0.3
13
14real    0m4.805s

2、镜像仓库拉取镜像测试

服务器一从镜像仓库1拉取镜像：

 1## 清理全部镜像
 2$ docker rm --force $(docker images -qa)
 3
 4## 拉取镜像 springboot-normal:0.0.1
 5$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1
 6
 7real    0m35.395s
 8
 9## 拉取镜像 springboot-normal:0.0.2
10$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2
11
12real    0m6.501s
13
14## 拉取镜像 springboot-normal:0.0.3
15$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3
16
17real    0m6.993s

服务器二从镜像仓库2拉取镜像：

 1## 清理全部镜像
 2$ docker rm --force $(docker images -qa)
 3
 4## 拉取镜像 springboot-layer:0.0.1
 5$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1
 6
 7real    0m30.615s
 8
 9## 拉取镜像 springboot-layer:0.0.2
10$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2
11
12real    0m4.811s
13
14## 拉取镜像 springboot-layer:0.0.3
15$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3
16
17real    0m1.293s

七、镜像构建、推送、拉取时间汇总

1、不使用分层构建镜像

次数\阶段	构建(s)	推送(s)	拉取(s)
第一次构建	24.98	35.21	35.39
第二次构建-修改依赖包	1.27	14.05	6.50
第三次构建-修改代码	1.32	14.18	6.99

如下图：

2、使用分层构建镜像

次数\阶段	构建(s)	推送(s)	拉取(s)
第一次构建	26.12	34.12	30.61
第二次构建-修改依赖包	3.44	13.60	4.81
第三次构建-修改代码	2.82	4.80	1.29

如下图：

3、总结

上面进行了使用 SpringBoot2.3.x 分层的方式构建镜像与普通的方式构建镜像，在镜像的构建、推送、拉取方面进行了执行速度对比，总结出如下结论：

镜像构建： 在构建上，使用分层 Jar 构建镜像可能比普通方式构建镜像更繁琐，所以也更耗时，故而在构建上分层 Jar 构建镜像没有太多优势。
镜像推送： 在推送上，如果每次构建镜像都只是修改构建镜像项目的源码，使用分层 Jar 构建镜像，可以大大加快镜像推送速度。如果是修改构建镜像项目中的依赖包，则和普通构建一样速度很慢。
镜像拉取： 拉取和推送类似，如果只修改构建镜像项目的源码，只会拉取源码相关的中间层镜像，该层非常小（一般几百KB），拉取速度自然非常快。而对构建镜像项目的依赖包进行变动（增加依赖、删除依赖、修改依赖版本等），则会和普通方式构建镜像一样，拉取速度很慢，这是因为依赖包层是中间层镜像最大的一层（一般在10MB~200MB之间），如果该层发生变动则整个层会进行重新拉取，这样速度自然会很慢。

---END---