Spring Native:构建GraalVM通用docker镜像编译spring应用

构建Graal镜像的用意就是利用docker特性,无须在本地开发环境安装Graal,就可以编译spring应用或者quarkus应用

1. maven官网一下最新版本

wget http://apache-mirror.rbc.ru/pub/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz

我这里用的是apache-maven-3.6.3-bin.tar.gz,最开始用的apache-maven-3.3.9,执行mvn-Pnative package命令的时候提示报错
2. 准备settings.xml改成国内镜像地址,在容器内下jar会快一些
3. 编写Dockerfile文件
基础镜像可以到docker hub上自行选择,

FROM findepi/graalvm:java8-native  #基础镜像可以自行选择
MAINTAINER alex
COPY apache-maven-3.6.3-bin.tar.gz .
RUN tar xzvf apache-maven-3.6.3-bin.tar.gz
COPY settings.xml apache-maven-3.6.3/conf/
RUN mv  apache-maven-3.6.3 /usr/local/bin
RUN rm -f /apache-maven-3.6.3-bin.tar.gz
RUN export PATH=apache-maven-3.6.3/bin:$PATH
RUN export PATH=/usr/local/bin/apache-maven-3.6.3/bin:$PATH
RUN ln -s /usr/local/bin/apache-maven-3.6.3/bin/mvn /usr/local/bin/mvn
RUN echo $PATH && mvn -v

4. 生成镜像
   env文件下放了dockerfile等提前准备好的文件
   apache-maven-3.6.3-bin.tar.gz Dockerfile settings.xml start.sh

docker build ./env/ -t native-base-java8

start.sh

#!/bin/sh
cd /project
mvn clean -Pnative package

5. 运行生成native
   maven-repo : maven仓库位置
   project : 自己项目所在位置,只要是graal支持的语言即可(例如java的springboot quarkus …其它语言的没试过)

docker run  --name=native-base-java8 -v /home/soft/gs-rest-service/complete/maven-repo:/maven-repo \
-v /home/soft/getting-started:/project -v ./start.sh:/start.sh  \
native-base-java8 /start.sh

6. 还有一些生成graal 关于生成native 使用不同框架的特定设置可以参照官网
   Graal Platforms Support

最后native是否生成,可以去看mvn执行日志
这里主要构建一环境,去执行 mvn clean -Pnative package

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <executions>
        <execution>
          <goals>
            <goal>build-image</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.graalvm.nativeimage</groupId>
      <artifactId>native-image-maven-plugin</artifactId>
      <version>${native-image.maven-plugin.version}</version>
      <configuration>
        <executable>${env.GRAALVM_HOME}/bin/native-image</executable>
        <buildArgs>
          <arg>--no-server</arg>
        </buildArgs>
        <source>${java.version}</source>
        <imageName>${project.artifactId}:${project.version}</imageName>
        <jvmArgs>-Xmx4G</jvmArgs>
        <skip>false</skip>
        <additionalBuildArgs>--enable-url-protocols=http,https --enable-all-security-services</additionalBuildArgs>
        <additionalImageBuildArgs>--enable-url-protocols=http,https --enable-all-security-services</additionalImageBuildArgs>
        <mainClass>${start-class}</mainClass>
        <docker>
          <buildArgs>
            <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
          </buildArgs>
        </docker>
        <vm>
          <executable>/path/to/bellsoft-liberica-vm-core-openjdk17.0.7+7-23.0.0+1-linux-amd64.tar.gz/bin/java</executable>
        </vm>
      </configuration>
      <executions>
        <execution>
          <goals>
            <goal>native-image</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

这个配置片段是一个Maven插件的配置，用于构建本地镜像（native-image）。

具体来说，这个配置使用了org.graalvm.nativeimage插件，该插件的版本号是${native-image.maven-plugin.version}。它定义了一系列参数和属性，包括：

executable：指定了可执行文件的路径，${env.GRAALVM_HOME}/bin/native-image表示使用环境变量GRAALVM_HOME中定义的GraalVM安装目录下的native-image可执行文件。
buildArgs：构建参数，这里只有一个--no-server参数，用于禁用服务器模式。
source：Java版本号，${java.version}表示使用项目中定义的Java版本号。
imageName：生成的镜像名称，${project.artifactId}:${project.version}表示使用项目的artifactId和version作为镜像名称。
jvmArgs：JVM参数，这里设置为-Xmx4G，表示最大堆内存为4GB。
skip：是否跳过本地镜像构建，默认为false。
additionalBuildArgs：额外的构建参数，这里设置了--enable-url-protocols=http,https --enable-all-security-services，用于启用HTTP、HTTPS协议和所有安全服务。
additionalImageBuildArgs：额外的镜像构建参数，与additionalBuildArgs类似，用于构建镜像时传递额外的参数。
mainClass：指定了应用程序的入口类，${start-class}表示使用项目中定义的启动类。
docker：Docker配置，这里设置了构建参数JAR_FILE，值为${project.build.finalName}.jar，用于在Docker构建过程中指定JAR文件的名称。
vm：虚拟机配置，指定了可执行文件的路径，/path/to/bellsoft-liberica-vm-core-openjdk17.0.7+7-23.0.0+1-linux-amd64.tar.gz/bin/java表示使用指定路径下的Java可执行文件作为虚拟机。

<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <configuration>
        <url>file:///path/to/your/local/file/bellsoft-liberica-vm-core-openjdk17.0.7+7-23.0.0+1-linux-amd64.tar.gz</url>
        <buildArgs>--no-fallback</buildArgs>
        <jvmArgs>
            <arg>-Xmx512m</arg>
            <arg>-Dsome.property=value</arg>
        </jvmArgs>
        <additionalBuildArgs>--enable-all-security-services</additionalBuildArgs>//允许你传递额外的构建参数给native-image命令。
        <reportExceptionStackTraces>true</reportExceptionStackTraces>
//设置是否在构建过程中记录异常堆栈信息。
 <reportUnsupportedElementsAtRuntime>true</reportUnsupportedElementsAtRuntime>//设置是否在运行时报告不支持的元素。
 <reflectionConfigFiles>
            <reflectionConfigFile>path/to/your/reflection-config.json</reflectionConfigFile>
        </reflectionConfigFiles>//指定自定义的反射配置文件路径，用于配置反射相关信息。
    </configuration>
</plugin>

docker pull docker.io/paketobuildpacks/builder:tiny
docker save docker.io/paketobuildpacks/builder:tiny > paketobuildpacks-builder-tiny.tar
将上述命令执行后，你会在当前目录下得到一个名为’paketobuildpacks-builder-tiny.tar’的Docker镜像文件。

接下来，你需要在Maven的配置文件（通常是settings.xml）中添加一个配置，指定本地Docker镜像的路径：

<settings>
    ...
    <profiles>
        <profile>
            <id>local-docker</id>
            <properties>
                <dockerHost>file:///path/to/your/paketobuildpacks-builder-tiny.tar</dockerHost>
            </properties>
        </profile>
    </profiles>
    ...
    <activeProfiles>
        <activeProfile>local-docker</activeProfile>
    </activeProfiles>
    ...
</settings>