GraalVM in Quarkus: Lesson 7 Guide

Lesson 7: GraalVM in Quarkus Applications
This lesson focuses on how GraalVM enhances Quarkus applications, emphasizing native image benefits, performance, and advanced integrations.

Native Image Support in Quarkus
Quarkus utilizes GraalVM to build native images, enabling ultra-fast startup times and low memory consumption. Native images are ideal for microservices and serverless architectures, as they significantly reduce cold start latency and runtime overhead compared to traditional JVM deployments.
Build-Time Optimizations
GraalVM’s integration with Quarkus allows heavy processing, such as dependency injection and classpath scanning, to occur during build time. This eliminates the need for runtime reflection and scanning, improving application performance and reducing runtime complexity.
Enhanced Performance
By combining Quarkus’s lightweight framework with GraalVM’s advanced JIT and AOT compilation capabilities, developers can achieve exceptional runtime performance. Native images result in smaller resource footprints, making applications scalable and cost-efficient.
Seamless Polyglot Support
GraalVM’s polyglot capabilities allow Quarkus to interact with other programming languages like JavaScript or Python. This enables developers to integrate multi-language workflows into their Java-based microservices, broadening the framework's use cases.
Integration with Kubernetes
GraalVM-compiled Quarkus applications are lightweight and optimized for containerization, making them perfect for Kubernetes and OpenShift deployments. These applications start and scale quickly, fitting cloud-native and edge computing needs.

5 Examples

Creating a Native Executable

mvn package -Pnative

This command builds a native executable for a Quarkus application, optimized for low memory usage and fast startup times.

Kubernetes Deployment Example

apiVersion: apps/v1
kind: Deployment
metadata:
  name: quarkus-app
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: quarkus-app
        image: my-quarkus-app:latest
        ports:
        - containerPort: 8080

A GraalVM-compiled Quarkus application deployed on Kubernetes, ensuring scalability and minimal resource use.

Polyglot Script Execution

@ApplicationScoped
public class PolyglotService {
    public void execute() {
        Context polyglot = Context.create();
        polyglot.eval("js", "console.log('Hello from JavaScript in Quarkus')");
    }
}

This demonstrates executing JavaScript within a Quarkus service using GraalVM.

Performance Monitoring with Metrics
Quarkus with GraalVM supports real-time performance metrics:

@Gauge(name = "active_users", unit = MetricUnits.NONE)
public int activeUsers() {
    return userService.getActiveUsers();
}

This exposes application metrics for monitoring tools like Prometheus.

Build-Time Initialization
A Quarkus extension enabling build-time class initialization:

quarkus.native.additional-build-args=-H:ClassInitialization=my.app.Class

This ensures faster startup by initializing specific classes at build time rather than runtime.

Lesson 7: GraalVM in Quarkus Applications

Table of contents

5 Examples