Create a Java GraalVM Docker Image

GraalVM employs its Ahead-Of-Time (AOT) compiler to translate Java applications into machine executables. These binaries execute directly on the target machine, bypassing the need for a Just-In-Time (JIT) compiler resulting in GraalVM binaries boasting smaller sizes, quick start-up times, and peak performance from the outset, requiring no warm-up period. Additionally, they exhibit reduced memory usage and CPU demands compared to JVM-based applications. Let us delve into understanding the creation of the Java GraalVM Docker image.

1. Introduction

Docker is an open-source platform used for the containerization of applications. It allows developers to package their applications along with their dependencies, libraries, and other necessary components into a single container that can run reliably and consistently on any platform. The containerization technology provided by Docker ensures that the application behaves the same way regardless of the underlying infrastructure. Some benefits of Docker are:

  • Portability: Docker containers can run on any platform, regardless of the underlying infrastructure. This makes it easy to move applications between development, testing, and production environments.
  • Scalability: Docker allows you to quickly and easily scale your application by adding or removing containers as needed, without having to make changes to the underlying infrastructure.
  • Isolation: Docker provides a high level of isolation between applications, ensuring that each container runs independently of others, without interfering with each other.
  • Efficiency: Docker containers are lightweight and efficient, consuming fewer resources than traditional virtual machines. This allows you to run more applications on the same hardware.
  • Consistency: Docker ensures that applications behave the same way across different environments, making it easier to test and deploy new versions of your application.
  • Security: Docker provides built-in security features that help protect your applications from external threats. Docker containers are isolated from each other and the underlying infrastructure, reducing the risk of attacks.

If someone needs to go through the Docker installation, please watch this video.

2. What Is a Native Image?

A native image refers to a compiled executable generated ahead of time (AOT) from source code written in a high-level programming language like Java. Unlike traditional just-in-time (JIT) compilation, where code is compiled during runtime, AOT compilation converts code into machine code before execution, resulting in a standalone binary that can be directly executed by the target platform without the need for an interpreter or virtual machine.

2.1 Benefits of Native Image

Native images offer several advantages over traditional runtime-based execution:

  • Improved Performance: Native images typically exhibit faster startup times and lower memory consumption compared to their JIT-compiled counterparts. This is because the compilation process optimizes the code for the specific target environment, eliminating the need for runtime optimizations.
  • Reduced Dependencies: Since native images include all necessary dependencies and libraries at compile time, they do not rely on external runtime environments or interpreters, making deployment and distribution simpler.
  • Enhanced Security: With fewer runtime components and reduced attack surface, native images can offer improved security compared to runtime-based applications.
  • Scalability: Native images can be easily deployed in containerized environments, such as Docker, and scaled horizontally to accommodate varying workloads without incurring additional overhead.

3. Building a GraalVM Native Image

Here’s a simple Java application along with the commands to compile it into a GraalVM native image:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, GraalVM!");

Save this code in a file named Now, let’s compile this Java application into a GraalVM native image. Open a terminal or command prompt and run the following commands:

# Compile the Java application to a class file

# Generate the native image using GraalVM's native-image utility
native-image HelloWorld

After running these commands, you should see a native executable named HelloWorld or HelloWorld.exe depending on your operating system.

4. Creating a Docker Image for GraalVM Native Image

To create a Docker image for a GraalVM native image, follow these steps:

  • Compile Java Application into GraalVM Native Image: Use GraalVM’s native-image utility to compile your Java application into a native image. This utility statically analyzes the application’s code and dependencies, producing a standalone executable that does not require a Java runtime.
  • Create a Dockerfile: Create a Dockerfile in your project directory with the following content:
    # Use a minimal base image
    FROM scratch
    # Copy your GraalVM native image into the container
    COPY your-application /your-application
    # Set the command to run when the container starts
    CMD ["/your-application"]

    Replace your-application with the name of your GraalVM native image file.

  • Build the Docker Image: Open a terminal or command prompt, navigate to your project directory containing the Dockerfile and the GraalVM native image file, and run the following command:
    docker build -t my-graalvm-app .

    This command builds a Docker image with the tag my-graalvm-app using the Dockerfile (. indicates the current directory).

  • Run the Docker Container: After the Docker image is built successfully, you can run it as a Docker container using the following command:
    docker run my-graalvm-app

    This command starts a Docker container based on the my-graalvm-app image.

5. Conclusion

In conclusion, native images, as produced by GraalVM, represent compiled executables generated ahead of time (AOT) from source code, such as Java applications. These executables eschew the need for interpretation or virtual machines during runtime, executing directly on the target platform. Their creation involves utilizing GraalVM’s native-image utility, a process that results in binaries optimized for size, performance, and startup time. The benefits of native images extend beyond mere efficiency; they boast smaller footprints, faster start-up times, and peak performance from the outset without the need for warm-up periods. Furthermore, the deployment of native images can be streamlined by encapsulating them within Docker containers, providing an easily distributable and portable solution. By leveraging the combined capabilities of GraalVM’s native image compilation and Docker’s containerization, developers can enhance their application’s performance, scalability, and deployment agility, thus facilitating a more efficient and streamlined development process.


An experience full-stack engineer well versed with Core Java, Spring/Springboot, MVC, Security, AOP, Frontend (Angular & React), and cloud technologies (such as AWS, GCP, Jenkins, Docker, K8).
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button