Spring Boot官方推荐的Docker镜像编译方式-分层jar包

参考

Spring Boot官方推荐的Docker镜像编译方式-分层jar包
Spring Boot layered(分层) jar 构建docker镜像
Spring Boot独立运行的jar包是如何工作的

一、普通Dockerfile的缺点

我们通常情况下要编译Spring Boot的Docker镜像，一般会写一个下面这样的Dockerfile

FROM openjdk:17
EXPOSE 8080
ARG JAR_FILE=target/my-application.jar #Maven的位置，Gradle为build/libs/my-application.jar 
ADD ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
1
2
3
4
5

这样做很简单，运行起来也没什么问题，但是它有以下的缺点：

• 镜像中的jar包是压缩文件，在容器环境中运行需要解压，这需要相当的开销，我们的jar通常要以解压后的形式运行更好。
• 更新程序后编译新的镜像效率低。Docker镜像的编译时分层构建的，而上面将依赖和程序都放在一个层中。在实际应用中，修改程序编译代码的频率将大大高于依赖的变化，所以我们最好将它们分在不同的层，这样不变的层在docker中可以直接使用缓存。

二、Docker分层

Docker 容器由基本映像和附加层组成。一旦构建了各个层，它们将保持缓存状态，后续构建，就会使用缓存，构建更快

低层次的变化也会重建较高层次的变化。因此，我们在构建镜像的时候最好将不经常变化的图层保留在底部，而经常变化的图层应该放在顶部。这样就能提高构建docker效率和启动时间。

三、Spring Boot分层

Spring boot 在2.3之后也提供了应用分层,默认分层如下

这里可以看到应用层是独立一层，我们在修改应用代码的时候就只用构建应用层即可。 spring-boot-loader 、 dependencies 层就可以使用缓存，从而减少docker镜像的创建和启动时间。

四、实践

核心理论

在Spring Boot 2.3之后添加了分层配置我们在打包插件【spring-boot-maven-plugin】中开启分层打包

<layers>
	<enabled>trueenabled>
layers>
1
2
3

<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.bootgroupId>
				<artifactId>spring-boot-maven-pluginartifactId>
				<version>${spring-boot.version}version>
				<configuration>
					<layers>
						<enabled>trueenabled>
					layers>
				configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackagegoal>
						goals>
					execution>
				executions>
			plugin>
		plugins>
	build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

新建demo工程

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<parent>
		<artifactId>spirng-boot-demoartifactId>
		<groupId>com.demogroupId>
		<version>1.0.0version>
	parent>
	<modelVersion>4.0.0modelVersion>

	<artifactId>spring-boot-kuberntes-dockerartifactId>

	<properties>
		<maven.compiler.source>11maven.compiler.source>
		<maven.compiler.target>11maven.compiler.target>
	properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-webartifactId>
		dependency>
	dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.pluginsgroupId>
				<artifactId>maven-compiler-pluginartifactId>
				<configuration>
					<source>11source>
					<target>11target>
				configuration>
			plugin>
			<plugin>
				<groupId>org.springframework.bootgroupId>
				<artifactId>spring-boot-maven-pluginartifactId>
				<version>${spring-boot.version}version>
				<configuration>
					<layers>
						<enabled>trueenabled>
					layers>
				configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackagegoal>
						goals>
					execution>
				executions>
			plugin>
		plugins>
	build>

project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

测试代码

测试代码
Application
@SpringBootApplication
public class  Application  { 

	public  static  void  main(String[] args)  { 
		TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
		SpringApplication.run(Application.class, args);
	}
}
...
...
TestController
@RestController
@RequestMapping
public class  TestController  { 

	@GetMapping("test")
	public String test() { 
		return "hello docker image";
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

编写Dockerfile

from openjdk:8 as builder
# 执行工作目录
WORKDIR application
# 将编译构建得到的jar文件复制到镜像空间中
copy target/edevp-store-biz-0.0.1.jar application.jar
expose 8101
# 通过工具spring-boot-jarmode-layertools从application.jar中提取拆分后的构建结果
RUN java -Djarmode=layertools -jar application.jar extract
# 正式构建镜像
FROM openjdk:8
WORKDIR application
# 前一阶段从jar中提取除了多个文件，这里分别执行COPY命令复制到镜像空间中，每次COPY都是一个layer
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们在项目根目录执行打包命令

mvn clean package -U -DskipTests
1

如果我们解压我们的jar就会发现多了 layers.idx 文件，打开文件我们会发现有如下内容

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

发布docker镜像

修改代码重新发布docker

第一次构建可能会有点慢，如果我们后续改了文件重新打包成镜像会快很多，因为有缓存，我们打包又是分了层，这种分层方式比打整个jar包的方式大概能快1倍的速度左右，具体性能差异还是要自己多测试