乐趣区

关于前端:Spring-Boot-layered分层-jar-构建docker镜像

jiezi

文章目录

Docker 分层

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

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

Spring Boot 分层

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

这里能够看到应用层是独立一层，咱们在批改利用代码的时候就只用构建应用层即可。spring-boot-loader、dependencies 层就能够应用缓存，从而缩小 docker 镜像的创立和启动工夫。

分层打包

  • 传统打包 

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>11</source>
                <target>11</target>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

    这种形式是将整个 Spring Boot 打成一个 jar，没有分层

在 Spring Boot 2.3 之后增加了分层配置咱们在打包插件中开启分层打包

  • 分层打包 

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>11</source>
                <target>11</target>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
            <configuration>
                <layers>
                    <enabled>true</enabled>
                </layers>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

    这样打进去的 jar 是分层的

创立 Spring Boot demo 我的项目

我的项目构造

pom 依赖 

<?xml version="1.0" encoding="UTF-8"?>
<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-kubernetes</artifactId>
        <groupId>com.zou</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-boot-kuberntes-docker</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

测试代码

  • 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";}
}

    编写 Dockerfile

    # 指定根底镜像，这是分阶段构建的后期阶段
FROM adoptopenjdk/openjdk11 as builder
# 执行工作目录
WORKDIR application # 配置参数
ARG JAR_FILE=target/*.jar
# 将编译构建失去的 jar 文件复制到镜像空间中
COPY ${JAR_FILE} application.jar # 通过工具 spring-boot-jarmode-layertools 从 application.jar 中提取拆分后的构建后果
RUN java -Djarmode=layertools -jar application.jar extract 
# 正式构建镜像
FROM adoptopenjdk/openjdk11
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"]

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

    mvn clean package -U -DskipTests

    如果咱们解压咱们的 jar 就会发现多了 layers.idx 文件，关上文件咱们会发现有如下内容 

    dependencies
spring-boot-loader
snapshot-dependencies
application

    构建 docker 镜像

咱们在 Dockerfile 根目录执行如下命令 

docker build -t dockerlayerdemo:0.0.5 .

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

运行 docker 镜像

执行如下命令

<pre class=”prettyprint hljs dockerfile”>docker run -d -p 8080:8080 dockerlayerdemo:0.0.5</pre>

启动实现后咱们拜访测试接口 

localhost:8080/test

能够看到能够失常拜访

自定义分层

如果咱们认真看下面的会发现依赖不会在构建的时候共享，所以咱们须要自定义配置调整下

在 Spring Boot 中咱们能够通过配置文件来调优自定义分层

咱们建设一个 layers.xml

<layers xmlns="http://www.springframework.org/schema/boot/layers"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/boot/layers
                     https://www.springframework.org/schema/boot/layers/layers-2.3.xsd">
    <application>
        <into layer="spring-boot-loader">
            <include>org/springframework/boot/loader/**</include>
        </into>
        <into layer="application" />
    </application>
    <dependencies>
        <into layer="snapshot-dependencies">
            <include>*:*:*SNAPSHOT</include>
        </into>
        <into layer="dependencies" />
    </dependencies>
    <layerOrder>
        <layer>dependencies</layer>
        <layer>spring-boot-loader</layer>
        <layer>snapshot-dependencies</layer>
        <layer>application</layer>
    </layerOrder>
</layers>

而后再 maven 中指定配置文件 

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <layers>
            <enabled>true</enabled>
            <configuration>${project.basedir}/src/layers.xml</configuration>
        </layers>
    </configuration>
</plugin>

这样咱们能够自定义分层了

总的来说要构建高效的 Docker 镜像并不是那么简略，也是有很多学识要钻研的，后续有机会持续深入研究下

对文章中内容感兴趣的小伙伴能够搜寻微信公众号：敲代码的老贾，支付相应材料

退出移动版