Skip to content
Skillpedia
Deploy & cloud (DevOps)40k · #5322

quarkus-native-and-container

Enables your agent to build native executables and container images for Quarkus projects. It also helps set up Kubernetes deployments.

What it does

This tool helps create faster and more efficient versions of your Quarkus code, called 'native executables'. It also assists in fixing common errors that arise during this process and in creating packages to run in containers like Docker or on platforms like Kubernetes.

When to use it

  • ✓When you want your Quarkus application to start much faster.
  • ✓When preparing your application to run in cloud environments like Kubernetes.
  • ✓If you encounter errors when trying to build the native version of your application.

Example of what to ask your AI

“How do I create a native executable of my Quarkus application and package it into a Docker container?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/github/awesome-copilot/blob/main/skills/quarkus-native-and-container/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/github/awesome-copilot/blob/main/skills/quarkus-native-and-container/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool uses specific Maven or Gradle commands to compile your Quarkus code into a native executable. If errors occur, it provides ways to register parts of the code that need special access during native compilation or to include necessary files.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add github/awesome-copilot --skill quarkus-native-and-container

Or download just the file:

curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/quarkus-native-and-container/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Quarkus Native and Container

Check the project's Quarkus version first. For generic (non-Quarkus) GraalVM work, use the optional java-add-graalvm-native-image-support skill if installed (otherwise see the GraalVM docs, https://www.graalvm.org/latest/reference-manual/native-image/).

Native build

# container build: no local GraalVM needed (Docker/Podman required)
./mvnw package -Dnative -Dquarkus.native.container-build=true
# local Mandrel/GraalVM (JAVA_HOME / GRAALVM_HOME must point to it)
./mvnw package -Dnative
# Gradle, Quarkus 3.10+ (add -Dquarkus.native.container-build=true without a local Mandrel)
./gradlew build -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false
# Gradle, older Quarkus
./gradlew build -Dquarkus.package.type=native

quarkus.package.type was deprecated in 3.10 (the 3.10 migration guide replaces it with quarkus.native.enabled and quarkus.package.jar.*); it is still accepted in 3.40 with a warning. Version gate verified with Gradle: on 3.9.5 -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false is ignored ("Unrecognized configuration key" warnings) and only a JVM quarkus-app is built, while -Dquarkus.package.type=native produces the native runner; on 3.10.0, 3.27.6 and 3.40.1 the new keys produce the native runner (3.10.0 also accepts the old key with the deprecation warning). The Maven native profile in the generated pom.xml already sets quarkus.native.enabled=true, quarkus.package.jar.enabled=false and skipITs=false when -Dnative is passed.

Local build verified on macOS arm64 with the Mandrel tarball for your Quarkus line from https://github.com/graalvm/mandrel/releases (mandrel-java25-macos-aarch64-25.0.4.1-Final.tar.gz for 3.40.1, extracted anywhere, JAVA_HOME pointing at its Contents/Home; Xcode command line tools are enough): 3.40.1 Maven package -Dnative took about 70 s and Gradle build with the two flags about 2.5 min; the runner is a Mach-O executable that starts in about 0.04 s, and ./mvnw verify -Dnative ran the *IT against it successfully. Quarkus checks the Mandrel/GraalVM version: 3.40 refuses 23.1 ("Out of date version of GraalVM or Mandrel detected ... Quarkus currently supports 25.0.0"), so use Mandrel 25 with 3.40 and mandrel-java21-macos-aarch64-23.1.12.1-Final with 3.27.6 (Maven verify -Dnative and Gradle both verified there).

Binary: target/*-runner (Maven) or build/*-runner (Gradle). A container build on macOS or Windows produces a Linux ELF that cannot run on the host: run it in a Linux container (for example docker run -v "$PWD/target:/w:ro" registry.access.redhat.com/ubi9/ubi-minimal /w/<name>-runner with the datasource passed through QUARKUS_DATASOURCE_* env vars), and note that ./mvnw verify -Dnative then fails in the *IT with Exit code is: '126'. Mandrel is Red Hat's GraalVM distribution for Quarkus; the container build pulls a Mandrel builder image matching the project (3.40.1 used quay.io/quarkus/ubi9-quarkus-mandrel-builder-image:jdk-25, Mandrel 25.0.4.1, about 2.5 minutes including the image pull); override it with quarkus.native.builder-image if needed. Native builds are slow and memory-hungry (several GB); do them in CI or on demand, not on every test run.

Common native failures

Symptom Fix
ClassNotFoundException / NoSuchMethodException at runtime (reflection, JSON serialization of DTOs) annotate with @RegisterForReflection (or @RegisterForReflection(targets = ...) on a holder class for third-party types), or put a reflection-config.json in src/main/resources and set quarkus.native.additional-build-args=-H:ReflectionConfigurationFiles=reflection-config.json
Missing resource files quarkus.native.resources.includes=templates/**
Library not supporting native look for a Quarkus extension, or choose another library
Class initialized at build time breaks --initialize-at-run-time=... through quarkus.native.additional-build-args
OutOfMemoryError during build raise container memory or quarkus.native.native-image-xmx
Dynamic proxies / serialization register via annotations or extension
@RegisterForReflection(targets = ExternalDto.class)
public record ProductDto(String name) {}

…

FAQ

What is a 'native executable'?

It's a version of your program that is compiled directly to run on the machine, without needing a full Java environment. This makes it start faster and generally consume fewer resources.

Why is creating a native executable slow?

The native compilation process is complex and requires a lot of memory and processing power, as it analyzes all the code to optimize it and prepare it to run without the Java Virtual Machine (JVM).

What should I do if I get a 'ClassNotFoundException' error when creating the native executable?

This usually means the native compiler doesn't know that a certain class needs to be included or accessed in a special way. You can fix this by adding specific annotations in your code or by creating a configuration file to inform the compiler.

Details

Original description by the author

Build Quarkus native executables (Mandrel/GraalVM), fix native failures with reflection registration, test the native binary, and produce container images and Kubernetes/OpenShift manifests. Use for native, Docker, Jib or Kubernetes work in a Quarkus project.

repo: github/awesome-copilot

Popularity

GitHub stars
40k
Ranking position
#5322
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills