Quarkus — Der cloud-native Java-Stack für die Kubernetes-Ära

Quarkus hat sich in den letzten Jahren als ernstzunehmende Alternative zu Spring Boot etabliert. Entwickelt von Red Hat und als Open-Source-Projekt unter der Commonhaus Foundation gepflegt, verfolgt Quarkus das Ziel, Java für die Cloud fit zu machen — mit blitzschnellen Startzeiten, minimalem Speicherverbrauch und nativer Unterstützung für Kubernetes.

Warum Quarkus?

Traditionelle Java-Frameworks laden per Reflection viele Klassen zur Laufzeit, was zu langen Startzeiten und hohem Speicherverbrauch führt. Quarkus dreht dieses Prinzip um: Statt zur Laufzeit arbeitet das Framework zur Build-Zeit. Es verarbeitet Annotations, konfiguriert Metamodelle und erzeugt Bytecode bereits während der Kompilierung — ein Konzept, das Quarkus selbst als „Compile-Time Boot“ bezeichnet. Das Ergebnis: Startzeiten im Millisekundenbereich und ein drastisch reduzierter Footprint.

<em>// Ein einfacher Quarkus-REST-Endpoint</em>
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hallo von Quarkus 3.36!";
    }
}
Code-Sprache: JavaScript (javascript)

Quarkus setzt auf bewährte Standards wie Jakarta EE (früher Java EE), Eclipse MicroProfile und CDI. Wer bereits mit Spring gearbeitet hat, findet über die Quarkus-Erweiterung quarkus-spring-di auch vertraute Annotations wie @Autowired.

Developer Joy — das Mantra von Quarkus

Ein zentrales Versprechen von Quarkus ist „Developer Joy“. Dazu gehört nicht nur das schnelle Booten der Anwendung, sondern vor allem der Dev Mode. Änderungen am Code werden ohne manuellen Neustart übernommen:

quarkus dev

Mit diesem Befehl startet Quarkus die Anwendung im Entwicklungsmodus. Sobald eine Java-Datei gespeichert wird, kompiliert Quarkus diese neu, tauscht die betroffene Klasse im laufenden Prozess aus und stellt die Änderung sofort zur Verfügung. Kein Neustart, kein Warten.

Datenbankzugriff mit Panache

Für den Datenbankzugriff bietet Quarkus Panache an, eine Erweiterung von Hibernate ORM, die den Persistenz-Code radikal vereinfacht:

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import jakarta.persistence.Entity;
import java.util.List;

@Entity
public class Kunde extends PanacheEntity {
    public String name;
    public String email;

    public static List<Kunde> findByEmailDomain(String domain) {
        return list("email like ?1", "%@" + domain);
    }
}
Code-Sprache: PHP (php)

Keine Repository-Interfaces, keine Boilerplate — die statischen Methoden der PanacheEntity-Oberklasse (wie list(), find(), delete()) machen SQL-Zugriffe kompakt und lesbar. Seit Mai 2026 gibt es zudem Quarkus Data Hibernate (ehemals „Hibernate with Panache Next“) als experimentellen Nachfolger, der das Jakarta-Data-Modell mit typsicheren Repositories kombiniert.

Native Image mit GraalVM/Mandrel

Quarkus ist von Anfang an auf GraalVM Native Image abgestimmt — und mit Mandrel bietet Red Hat eine eigenständige GraalVM-Distribution speziell für Quarkus. Seit Quarkus 3.36 ist das Minimum GraalVM/Mandrel 25.0 (basiert auf JDK 25):

mvn package -Pnative

Das Ergebnis ist eine einzelne ausführbare Binärdatei, die in unter 0,02 Sekunden starten kann und mit wenigen MB Arbeitsspeicher auskommt. In einer Kubernetes-Umgebung bedeutet das: weniger Ressourcenverbrauch pro Pod und kürzere Scale-out-Zeiten. Für Container-Builds ohne lokale GraalVM-Installation nutzt man:

mvn package -Pnative -Dquarkus.native.container-build=true
Code-Sprache: JavaScript (javascript)

Reaktive Programmierung mit Mutiny

Quarkus setzt für reaktive Programmierung auf Mutiny — eine ereignisbasierte Bibliothek, die intuitiver sein will als Project Reactor oder RxJava:

import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.Multi;

@Path("/reactive")
public class ReactiveResource {

    @GET
    @Path("/uni")
    public Uni<String> uni() {
        return Uni.createFrom().item("Sofort verfügbar")
            .onItem().transform(String::toUpperCase);
    }

    @GET
    @Path("/multi")
    public Multi<String> multi() {
        return Multi.createFrom().items("A", "B", "C")
            .onItem().transform(s -> "Wert: " + s);
    }
}
Code-Sprache: CSS (css)

Uni<T> repräsentiert einen asynchronen Wert (0 oder 1 Ergebnis), Multi<T> einen asynchronen Stream (0 bis N Ergebnisse). Quarkus verarbeitet reaktive Rückgabetypen automatisch auf dem I/O-Thread.

Quarkus Extensions — das Ökosystem

Eine Stärke von Quarkus ist das wachsende Extension-Ökosystem. Über 500 offizielle und Community-Extensions decken Datenbanken, Messaging, Security, Observability und KI ab:

<em># Verfügbare Extensions auflisten</em>
quarkus ext list

<em># Extensions hinzufügen</em>
quarkus ext add quarkus-smallrye-openapi,quarkus-kafka-client
Code-Sprache: HTML, XML (xml)

Highlights unter den Extensions: quarkus-oidc für Keycloak-Integration, quarkus-smallrye-graphql für GraphQL-APIs, quarkus-micrometer für Metriken und quarkus-langchain4j für LLM-Integration.

Testing mit Quarkus

Quarkus bringt exzellente Testunterstützung mit. Der @QuarkusTest-Ansatz startet die Anwendung einmal und führt alle Tests gegen dieselbe Instanz aus:

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;

@QuarkusTest
class GreetingResourceTest {

    @Test
    void testHelloEndpoint() {
        given()
            .when().get("/hello")
            .then()
            .statusCode(200)
            .body(is("Hallo von Quarkus 3.36!"));
    }
}
Code-Sprache: JavaScript (javascript)

Für Integrationstests mit externen Abhängigkeiten bietet Quarkus Dev Services: Startet man die Anwendung im Test, werden automatisch Docker-Container für PostgreSQL, Kafka, Redis und viele andere Dienste hochgefahren — ohne manuelle Konfiguration.

Fazit

Quarkus verbindet die bewährte Java-Ökosystem-Welt mit modernen Cloud-Anforderungen. Die Kombination aus Compile-Time-Optimierung, Developer-Joy-Funktionen, nativer Kubernetes-Integration und einem stark wachsenden Extension-Ökosystem (mit KI-Integration via quarkus-langchain4j) macht Quarkus zur ersten Wahl, wenn es um cloud-native Java-Anwendungen geht. Während Spring Boot durch sein riesiges Ökosystem dominiert, punktet Quarkus mit Geschwindigkeit und Effizienz — zwei Eigenschaften, die in der Cloud entscheidend sind.