Bina imej asli daripada Aplikasi Spring Boot dengan pembina GraalVM

Gambaran keseluruhan

Bahagian ini menerangkan cara membuat imej asli daripada aplikasi Spring Boot menggunakan pembina imej asli GraalVM dan cara menjalankan imej asli ini dalam bekas Docker.

Objektif

Dalam seni bina perisian dan reka bentuk seni bina perkhidmatan mikro, kami perlu mempertimbangkan kebolehskalaan, prestasi aplikasi kami. Aplikasi kami harus bermula dengan cepat berskala dan menggunakan sumber dengan cekap apabila bilangan permintaan meningkat dalam aplikasi kami.

Saya sedang mempertimbangkan untuk menggunakan Kompilasi Spring Boot Ahead of Time (AOT) dengan GraalVM untuk menjalankan executable dalam bekas, bersama-sama dengan Java Virtual Threads (tersedia dalam JDK 21 dan lebih tinggi).

• Kompilasi AOT berfaedah untuk senario di mana masa permulaan yang cepat dan prestasi yang boleh diramal adalah penting, dengan pertukaran kebolehsuaian masa jalan yang kurang.
• Bekas adalah ringan dan menggunakan sumber yang lebih sedikit berbanding mesin maya (VM) kerana ia berkongsi kernel OS hos. Bekas boleh bermula dan berhenti lebih cepat daripada VM, membolehkan penskalaan dan penggunaan lebih cepat.
• Benang maya boleh meningkatkan prestasi aplikasi yang mengendalikan sejumlah besar tugas serentak. Ini amat berfaedah untuk aplikasi seperti pelayan web, pangkalan data dan sistem terikat I/O lain. Benang maya menggunakan sumber yang lebih sedikit daripada benang tradisional. Ia diuruskan oleh masa jalan dengan cara yang meminimumkan penggunaan memori dan overhed CPU.

Dalam keputusan reka bentuk seni bina ini, kami mendapat faedah tetapi juga mesti mempertimbangkan cabaran pelaksanaan berikut dan pertimbangan reka bentuk:

• Benang Maya: Kita harus mengelak daripada menggunakan benang maya jika logik perniagaan kita intensif CPU, seperti senario yang memerlukan pengiraan memori yang luas.
• Kompilasi Mendahului Masa (AOT): Pengkompil AOT mungkin tidak mengendalikan pantulan, pengekodan proksi atau siri dengan betul. Selain itu, GraalVM ialah teknologi yang agak baharu, menimbulkan cabaran dalam mencipta imej asli daripada aplikasi Spring Boot dan membawa kepada peningkatan masa binaan.
• Bekas: Bekas memberikan banyak faedah tetapi beberapa cabaran berkaitan keselamatan kawasan, rangkaian, prestasi, CI/CD, dll. Beberapa contohnya ialah
  • Bekas boleh memasukkan kelemahan daripada imej asas atau kebergantungan.
  • Menyepadukan bekas ke dalam saluran paip CI/CD sedia ada boleh mencabar, memerlukan perubahan untuk membina, menguji dan proses penggunaan.
  • Mengurus platform orkestrasi kontena seperti Kubernetes boleh menjadi rumit dan memerlukan pengetahuan khusus.
  • Menskalakan kontena ke atas dan ke bawah dengan cekap untuk mengendalikan beban yang berbeza-beza tanpa menyediakan sumber berlebihan atau kekurangan peruntukan.

Aplikasi Spring Boot
Untuk menguji kes penggunaan ini, saya sedang membina aplikasi Spring Boot yang mendedahkan titik akhir REST di "/hello". Saya menggunakan konfigurasi, perpustakaan dan alatan berikut:

• Spring Boot 3.2.8 dengan REHAT
• Spring Boot AOT Compile
• Imej Asli GraalVM But Musim Bunga
• Alat Binaan Maven 3.9.8
• Jawa 22

Kami perlu menambah konfigurasi berikut dalam fail XML POM.

Konfigurasi Harta But Spring

<properties>
    <java.version>22</java.version>
    <spring-native.version>0.12.1</spring-native.version>
</properties>

Konfigurasi pemalam Spring Boot AOT

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
       <execution>
          <id>process-aot</id>
          <goals>
             <goal>process-aot</goal>
          </goals>
       </execution>
    </executions>
</plugin>

Konfigurasi pemalam GraalVM

<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <configuration>
       <imageName>app-native-binary</imageName>
       <metadataRepository>
          <enabled>true</enabled>
       </metadataRepository>
       <buildArgs>
          <buildArg>--static --libc=musl</buildArg>
          <buildArg>-H:+ReportExceptionStackTraces</buildArg>
       </buildArgs>
       <mainClass>com.developerhelperhub.tutorial.springboot.tutorial.TutorialStartupPerformanceApplication</mainClass>
    </configuration>
    <executions>
       <execution>
          <id>add-reachability-metadata</id>
          <goals>
             <goal>add-reachability-metadata</goal>
          </goals>
       </execution>
    </executions>
</plugin>

• "Kelas utama": Mengkonfigurasi kelas mel aplikasi but musim bunga
• "Nama imej": Mengkonfigurasi nama imej asli
• "buildArgs": Mengkonfigurasi —libc=”msul”, Kami sedang mengkonfigurasi GraalVM untuk membina imej asli dengan pustaka serasi "libc musl" kerana kami akan menjalankan imej ini pada kotak Alpine Linux. Musl direka bentuk agar lebih kecil dan menggunakan kurang memori berbanding perpustakaan standard lain, menjadikannya sangat sesuai untuk persekitaran yang terhad sumber.

Bina Perduaan dan Cipta Imej Docker

Kami perlu membina imej asli untuk hos OS tertentu dan seni bina CPU di mana imej asli akan dijalankan dalam bekas.

Kami menggunakan Alpine Linux untuk saiznya yang kecil, kesederhanaan dan keselamatan untuk menjalankan aplikasi kami dalam bekas. Untuk mencapai matlamat ini, kami perlu menggunakan konfigurasi GraalVM yang sesuai untuk membina aplikasi kami. Keperluan sistem untuk Alpine ialah sistem pengendalian dan seni bina CPU.

• "Seni Bina": "amd64"
• "Os": "linux"
• Pustaka biasa C: “libc musl”

Mengikut arahan yang boleh kita gunakan untuk memeriksa imej "amd64/alpine"

docker pull amd64/alpine # pull the image

docker image inspect amd64/alpine # inspect the image

We can use docker container to build the native image instead of setup the GraalVM and Java related configuration in our locally. I am using “ghcr.io/graalvm/native-image-community:22-muslib” docker image to build the native.

Following command we can use to inspect the “ghcr.io/graalvm/native-image-community:22-muslib” image

docker pull ghcr.io/graalvm/native-image-community:22-muslib # pull the image

docker image inspect ghcr.io/graalvm/native-image-community:22-muslib # inspect the image

I am creating a build image to test and debug the container, ensuring that all configurations and services are installed correctly. This approach will help us quickly identify and resolve any issues.

Following steps are added in the docker file, the file name “DockerfileBuild”

FROM ghcr.io/graalvm/native-image-community:22-muslib as build

# Install necessary tools
RUN microdnf install wget 
RUN microdnf install xz

# Install maven for build the spring boot application
RUN wget https://dlcdn.apache.org/maven/maven-3/3.9.8/binaries/apache-maven-3.9.8-bin.tar.gz
RUN tar xvf apache-maven-3.9.8-bin.tar.gz

# Set up the environment variables needed to run the Maven command.
ENV M2_HOME=/app/apache-maven-3.9.8
ENV M2=$M2_HOME/bin
ENV PATH=$M2:$PATH

# Install UPX (Ultimate Packer for eXecutables) to compress the executable binary and reduce its size.
RUN wget https://github.com/upx/upx/releases/download/v4.2.4/upx-4.2.4-amd64_linux.tar.xz
RUN tar xvf upx-4.2.4-amd64_linux.tar.xz

# Set up the environment variables required to run the UPX command.
ENV UPX_HOME=/app/upx-4.2.4-amd64_linux
ENV PATH=$UPX_HOME:$PATH

#Copy the spring boot source code into container
RUN mkdir -p /app/spring-boot-rest-api-app
COPY spring-boot-rest-api-app /app/spring-boot-rest-api-app

#Compile the native image
RUN cd /app/spring-boot-rest-api-app && mvn -Pnative native:compile

#Compressed binary file
RUN upx -7 -k /app/spring-boot-rest-api-app/target/app-native-binary
WORKDIR /app
ENTRYPOINT ["/bin/bash"]

I am using the UPX compression tool in the build process to reduce the image size, UPX will typically reduce the file size of programs and DLLs by around 50%-70%, thus reducing disk space, network load times, download times and other distribution and storage costs.

Use the following command to build the Docker image.

docker build --no-cache -f DockerfileBuild -t alpine-graalvm-build .

After the build is complete, the image size will be 1.85 GB.

REPOSITORY                               TAG         IMAGE ID       CREATED          SIZE
alpine-graalvm-build                     latest      81d23bc1bc99   36 seconds ago   1.85GB

We can verify the configuration and installation within the container before creating a smaller container inside the Alpine Linux box. The following command will allow us to enter the container:

docker run --rm -it --entrypoint /bin/bash alpine-graalvm-build

java --version #verify the java version
mvn --version #verify the maven version
upx --version #verify the upx version

ls /app/spring-boot-rest-api-app/target/app-native-binary #verify the binary available

/app/spring-boot-rest-api-app/target/app-native-binary #run the executable

We know that this native image includes all the dependencies necessary to run the binary standalone, without requiring any build-related tools such as GraalVM, Maven, UPX, or source code. We can use a Docker multi-stage build approach to copy the build file into our application image. By using multiple stages, you can separate the build environment from the runtime environment. This means only the necessary artifacts are included in the final image, significantly reducing its size.

Following steps are added in the docker file, the file name “DockerfileBuildAndCreateAlpineContainer”

FROM ghcr.io/graalvm/native-image-community:22-muslib as build

# Install necessary tools
RUN microdnf install wget 
RUN microdnf install xz

# Install maven for build the spring boot application
RUN wget https://dlcdn.apache.org/maven/maven-3/3.9.8/binaries/apache-maven-3.9.8-bin.tar.gz
RUN tar xvf apache-maven-3.9.8-bin.tar.gz

# Set up the environment variables needed to run the Maven command.
ENV M2_HOME=/app/apache-maven-3.9.8
ENV M2=$M2_HOME/bin
ENV PATH=$M2:$PATH

# Install UPX (Ultimate Packer for eXecutables) to compress the executable binary and reduce its size.
RUN wget https://github.com/upx/upx/releases/download/v4.2.4/upx-4.2.4-amd64_linux.tar.xz
RUN tar xvf upx-4.2.4-amd64_linux.tar.xz

# Set up the environment variables required to run the UPX command.
ENV UPX_HOME=/app/upx-4.2.4-amd64_linux
ENV PATH=$UPX_HOME:$PATH

#Copy the spring boot source code into container
RUN mkdir -p /app/spring-boot-rest-api-app
COPY spring-boot-rest-api-app /app/spring-boot-rest-api-app

#Compile the native image
RUN cd /app/spring-boot-rest-api-app && mvn -Pnative native:compile

#Compressed binary file
RUN upx -7 -k /app/spring-boot-rest-api-app/target/app-native-binary
WORKDIR /app

#Second stage: Create the runtime image
FROM amd64/alpine

#Set the working directory
WORKDIR /app

#Copy the built application from the first stage
COPY --from=build /app/spring-boot-rest-api-app/target/app-native-binary .

#Expose port which our spring boot application is running
EXPOSE 8080 

#Command to run the application
ENTRYPOINT ["/app/app-native-binary"]

Use the following command to build the Docker image.

docker build -f DockerfileBuildAndCreateAlpineContainer -t alpine-graalvm .

After the build is complete, the image size of container will be 32.8MB.

REPOSITORY                               TAG         IMAGE ID       CREATED          SIZE
alpine-graalvm                           latest      79676c696920   11 seconds ago      32.8MB

We can verify the container.

docker run --rm -it --entrypoint sh alpine-graalvm

ls /app #verify the binary available

/app/app-native-binary #run the executable

The application startup time is just 0.074 seconds, whereas a typical Spring Boot application running on the JVM has a startup time of approximately 1.665 seconds.

Started TutorialStartupPerformanceApplication in 0.074 seconds (process running for 0.075)

Following command can be use to run the docker container for running the application

docker run -d --name test-app -p 8080:8080 alpine-graalvm #run the container

curl http://localhost:8080/hello # checking the endpoints

Spring boot and GraalVM references

• Spring Boot Introduction GraalVM Native Images
• GraalVM documentation build Spring Boot Native Executable
• GraalVM Maven Plugin Documentation
• Sample Spring Boot Application Docker Image Setup with GraalVM
• Sample Native Images with Spring Boot and GraalVM
• Spring Boot 3.2.8 GraalVM Native Images Documentation
• Spring Boot GraalVM UPX Tutorial Video
• Spring Boot Alpine Linux Docker Native Image Example ## Docker and GraalVM References
• GraalVM Containers Images
• Docker Environment Variables
• Maven Download
• UPX Documentation
• UPX Releases
• Docker Stop Container

Source Code

• Spring Boot Github Repo
• Kubernetes Related Repo

Atas ialah kandungan terperinci Bina imej asli daripada Aplikasi Spring Boot dengan pembina GraalVM. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!