Quarkus - Building a Native Executable

This guide covers:

• Compiling the application to a native executable

• Packaging the native executable in a container

This guide takes as input the application developed in the Getting Started Guide.

Prerequisites

To complete this guide, you need:

• less than 15 minutes

• an IDE

• JDK 8 installed with JAVA_HOME configured appropriately

• A working C development environment

• GraalVM version 19.2.1 installed and configured appropriately

• A working container runtime (Docker, podman)

• The code of the application developed in the Getting Started Guide.

# dnf (rpm-based)sudo dnf install gcc glibc-devel zlib-devel# Debian-based distributions:sudo apt-get install build-essential libz-dev zlib1g-dev

xcode-select —install

Configuring GraalVM

Version 19.2.1 is required. Using the community edition is enough.

• Install GraalVM if you haven’t already. You have a few options for this:

• Use platform-specific install tools like homebrew or sdkman.

• Download the appropriate Community Edition archive from https://github.com/oracle/graal/releases, and unpack it like you would any other JDK.

• Configure the runtime environment. Set GRAALVM_HOME environment variable to the GraalVM installation directory, for example:

export GRAALVM_HOME=$HOME/Development/graalvm/

On macOS, point the variable to the Home sub-directory:

export GRAALVM_HOME=$HOME/Development/graalvm/Contents/Home/

• Install the native-image tool using gu install:

${GRAALVM_HOME}/bin/gu install native-image

Some previous releases of GraalVM included the native-image tool by default. This is no longer the case; it must be installed as a second step after GraalVM itself is installed. Note: there is an outstanding issue using GraalVM with macOS Catalina.

• (Optional) Set the JAVA_HOME environment variable to the GraalVM installation directory.

export JAVA_HOME=${GRAALVM_HOME}

• (Optional) Add the GraalVM bin directory to the path

export PATH=${GRAALVM_HOME}/bin:$PATH

“gu” cannot be opened because the developer cannot be verified

xattr -r -d com.apple.quarantine $HOME/Development/graalvm/

Solution

We recommend that you follow the instructions in the next sections and package the application step by step. However, you can go right to the completed example.

Clone the Git repository: git clone https://github.com/quarkusio/quarkus-quickstarts.git, or download an archive.

The solution is located in the getting-started directory.

Producing a native executable

The native executable for our application will contain the application code, required libraries, Java APIs, and a reduced version of a VM. The smaller VM base improves the startup time of the application and produces a minimal disk footprint.

If you have generated the application from the previous tutorial, you can find in the pom.xml the following profile:

<profiles>
    <profile>
        <id>native</id>
        <properties>
            <quarkus.package.type>native</quarkus.package.type>
        </properties>
    </profile>
</profiles>

We use a profile because, you will see very soon, packaging the native executable takes a few minutes. You couldjust pass -Dquarkus.package.type=native as a property on the command line, however it is better to use a profile asthis allows native image tests to also be run.

Create a native executable using: ./mvnw package -Pnative.

In addition to the regular files, the build also produces target/getting-started-1.0-SNAPSHOT-runner.You can run it using: ./target/getting-started-1.0-SNAPSHOT-runner.

Testing the native executable

Producing a native executable can lead to a few issues, and so it’s also a good idea to run some tests against the application running in the native file.

In the pom.xml file, the native profile contains:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>${surefire-plugin.version}</version>
    <executions>
        <execution>
            <goals>
                <goal>integration-test</goal>
                <goal>verify</goal>
            </goals>
            <configuration>
                <systemProperties>
                    <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                </systemProperties>
            </configuration>
        </execution>
    </executions>
</plugin>

This instructs the failsafe-maven-plugin to run integration-test and indicates the location of the produced native executable.

Then, open the src/test/java/org/acme/quickstart/NativeGreetingResourceIT.java. It contains:

package org.acme.quickstart;
import io.quarkus.test.junit.NativeImageTest;
@NativeImageTest (1)
public class NativeGreetingResourceIT extends GreetingResourceTest { (2)
    // Run the same tests
}

To see the NativeGreetingResourceIT run against the native executable, use ./mvnw verify -Pnative:

./mvnw verify -Pnative
...
[getting-started-1.0-SNAPSHOT-runner:18820]     universe:     587.26 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      (parse):   2,247.59 ms
[getting-started-1.0-SNAPSHOT-runner:18820]     (inline):   1,985.70 ms
[getting-started-1.0-SNAPSHOT-runner:18820]    (compile):  14,922.77 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      compile:  20,361.28 ms
[getting-started-1.0-SNAPSHOT-runner:18820]        image:   2,228.30 ms
[getting-started-1.0-SNAPSHOT-runner:18820]        write:     364.35 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      [total]:  52,777.76 ms
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:integration-test (default) @ getting-started ---
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running org.acme.quickstart.NativeGreetingResourceIT
Executing [/data/home/gsmet/git/quarkus-quickstarts/getting-started/target/getting-started-1.0-SNAPSHOT-runner, -Dquarkus.http.port=8081, -Dtest.url=http://localhost:8081, -Dquarkus.log.file.path=build/quarkus.log]
2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Quarkus 999-SNAPSHOT started in 0.002s. Listening on: http://[::]:8081
2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Installed features: [cdi, resteasy]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.387 s - in org.acme.quickstart.NativeGreetingResourceIT
...

By default, native tests runs using the prod profile.This can be overridden using the quarkus.test.native-image-profile property.For example, in your application.properties file, add: quarkus.test.native-image-profile=test.Alternatively, you can run your tests with: ./mvnw verify -Pnative -Dquarkus.test.native-image-profile=test.However, don’t forget that when the native executable is built the prod profile is enabled.So, the profile you enable this way must be compatible with the produced executable.

Excluding tests when running as a native executable

When running tests this way, the only things that actually run natively are you application endpoints, whichyou can only test via HTTP calls. Your test code does not actually run natively, so if you are testing codethat does not call your HTTP endpoints, it’s probably not a good idea to run them as part of native tests.

If you share your test class between JVM and native executions like we advise above, you can mark certain testswith the @DisabledOnNativeImage annotation in order to only run them on the JVM.

Creating a container

You can run the application in a container using the JAR produced by the Quarkus Maven Plugin.However, in this guide we focus on creating a container image using the produced native executable.

By default, the native executable is tailored for your operating system (Linux, macOS, Windows etc).Because the container may not use the same executable format as the one produced by your operating system,we will instruct the Maven build to produce an executable from inside a container:

./mvnw package -Pnative -Dquarkus.native.container-build=true

# Docker./mvnw package -Pnative -Dquarkus.native.container-runtime=docker# Podman./mvnw package -Pnative -Dquarkus.native.container-runtime=podman

The produced executable will be a 64 bit Linux executable, so depending on your operating system it may no longer be runnable.However, it’s not an issue as we are going to copy it to a container.The project generation has provided a Dockerfile.native in the src/main/docker directory with the following content:

FROM registry.access.redhat.com/ubi8/ubi-minimal
WORKDIR /work/
COPY target/*-runner /work/application
RUN chmod 775 /work
EXPOSE 8080
CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]

Then, if you didn’t delete the generated native executable, you can build the docker image with:

docker build -f src/main/docker/Dockerfile.native -t quarkus-quickstart/getting-started .

And finally, run it with:

docker run -i --rm -p 8080:8080 quarkus-quickstart/getting-started

Creating a container with a multi-stage Docker build

The previous section showed you how to build a native executable using Maven, but implicitly required that the proper GraalVM version be installed on the building machine (be it your local machine or your CI/CD infrastructure).

In cases where the GraalVM requirement cannot be met, you can use Docker to perform the Maven build by using a multi-stage Docker build. A multi-stage Docker build is like two Dockerfile files combined in one, the first is used to build the artifact used by the second.

In this guide we will use the first stage to generate the native executable using Maven and the second stage to create our runtime image.

## Stage 1 : build with maven builder image with native capabilities
FROM quay.io/quarkus/centos-quarkus-maven:19.2.1 AS build
COPY src /usr/src/app/src
COPY pom.xml /usr/src/app
USER root
RUN chown -R quarkus /usr/src/app
USER quarkus
RUN mvn -f /usr/src/app/pom.xml -Pnative clean package
## Stage 2 : create the docker final image
FROM registry.access.redhat.com/ubi8/ubi-minimal
WORKDIR /work/
COPY --from=build /usr/src/app/target/*-runner /work/application
RUN chmod 775 /work
EXPOSE 8080
CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]

Save this file in src/main/docker/Dockerfile.multistage as it is not included in the getting started quickstart.

docker build -f src/main/docker/Dockerfile.multistage -t quarkus-quickstart/getting-started .

And finally, run it with:

docker run -i --rm -p 8080:8080 quarkus-quickstart/getting-started

Configuring the Native Image

There are a lot of different configuration options that can affect how the native image is generated.These are provided in application.properties the same as any other config property.

The properties are shown below:

Configuration property fixed at build time - ️ Configuration property overridable at runtime

What’s next?

This guide covered the creation of a native (binary) executable for your application.It provides an application exhibiting a swift startup time and consuming less memory.However, there is much more.

We recommend continuing the journey with the deployment to Kubernetes and OpenShift.