~/blog/2023/07/graalvm-fuer-jdk-17-ist-frei.md

GraalVM für JDK 17 ist frei: Native Images ohne Lizenzsorgen

6 min
Beitragsbild: GraalVM für JDK 17 ist frei: Native Images ohne Lizenzsorgen

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Seit dem 13. Juni 2023 gibt es „Oracle GraalVM for JDK 17“ und „for JDK 20“ unter den GraalVM Free Terms and Conditions, kostenlos auch für den Produktivbetrieb.
  • Die Optimierungen, die früher nur in GraalVM Enterprise steckten, etwa G1 für Native Images und profilgesteuerte Optimierung (PGO), sind jetzt enthalten.
  • Die Versionsnummern richten sich nach den JDK-Versionen; die Community Edition unter GPL mit Classpath Exception bleibt bestehen.
  • Native Images starten schnell und brauchen wenig Speicher, kosten aber längere Builds und Konfigurationsaufwand, etwa bei Reflection.
  • Lohnend sind CLI-Tools, Serverless und Scale-to-zero; für lange laufende Server bleibt die JIT-Variante oft die bessere Wahl.

Ich muss gestehen, dass ich bei GraalVM lange eine Hürde im Kopf hatte, und die war nicht technisch. Native Images sind ein spannendes Thema, aber sobald es um den produktiven Einsatz ging, tauchte bei mir sofort die Frage auf: Welche Edition, welche Lizenz, wer darf das wofür benutzen? Wenn ich ehrlich bin, hat das mehr als einmal dazu geführt, dass ich das Thema ein Stück nach hinten geschoben habe.

Diese Frage hat sich im Juni deutlich entschärft. Deshalb hier eine Einordnung, was sich geändert hat und wann sich Native Images aus meiner Sicht lohnen.

Was sich geändert hat

Am 13. Juni hat Oracle „Oracle GraalVM for JDK 17“ und „Oracle GraalVM for JDK 20“ veröffentlicht, und zwar unter einer neuen Lizenz, den „GraalVM Free Terms and Conditions“, kurz GFTC. Wie ich es gelesen habe, darf man das Ergebnis kostenlos benutzen, auch in Produktion. Die genauen Bedingungen sollte jeder selbst nachlesen, besonders wenn es um Weitergabe an Dritte geht, ich bin kein Jurist und gebe hier nur wieder, wie ich den Text verstanden habe.

Interessanter finde ich den Inhalt. In diesem Paket stecken Optimierungen, die vorher der kostenpflichtigen Enterprise-Edition vorbehalten waren. Dazu zählen G1 als Garbage Collector für Native Images und die profilgesteuerte Optimierung (PGO). Das Prinzip bei PGO: Man baut eine instrumentierte Variante, lässt sie mit typischer Last laufen, sammelt ein Profil und übersetzt danach mit diesem Wissen erneut. Das Ergebnis ist meist schneller als ein Build ohne Profil.

Außerdem hat sich die Versionierung geändert. Die Versionen richten sich jetzt nach den JDK-Versionen, es heißt also nicht mehr „22.3“, sondern die Zahl des JDK, auf dem es aufbaut. Das macht die Zuordnung einfacher: Wer Java 17 benutzt, nimmt GraalVM für JDK 17. Und die Community Edition gibt es weiterhin, unter GPL mit Classpath Exception, also in der bisherigen Form.

Hinzu kommt eine Meldung vom Dezember: Oracle hat angekündigt, Teile von GraalVM in das OpenJDK einzubringen. Wie weit das geht und was daraus wird, ist offen. Ich lese es als Signal, dass die Technik langfristig näher an das Standard-JDK heranrücken soll, aber mehr als ein Signal ist es bisher nicht.

Native Images in zwei Absätzen

Falls jemand das Prinzip noch nicht kennt: Normalerweise läuft Java-Code auf der JVM, wird dort interpretiert und durch den JIT-Compiler im laufenden Betrieb in Maschinencode übersetzt. Ein Native Image macht das vorab. Das Werkzeug native-image analysiert die Anwendung, übersetzt alles, was erreichbar ist, in eine ausführbare Datei und legt dabei eine Art minimale Laufzeitumgebung bei. Am Ende hat man ein Binary, das ohne installierte JVM startet.

Der Vorteil liegt auf der Hand: Der Start dauert nur einen Bruchteil der Zeit, und der Speicherbedarf liegt deutlich niedriger als bei einer klassischen JVM. Konkrete Zahlen nenne ich bewusst nicht, weil sie stark von der Anwendung abhängen, aber die Richtung stimmt nach allem, was ich gesehen habe. Der Preis: Die Übersetzung ist aufwendig, die Builds dauern länger und brauchen mehr Arbeitsspeicher, und man baut für ein bestimmtes Betriebssystem und eine bestimmte Architektur.

Die Einschränkungen

Wer Native Images verwendet, muss die „Closed-World-Annahme“ akzeptieren. Das Werkzeug muss zur Build-Zeit wissen, welcher Code überhaupt erreichbar ist. Alles, was erst zur Laufzeit entschieden wird, ist ein Problem: Reflection, dynamische Proxies, Ressourcen aus dem Klassenpfad, JNI, dynamisches Nachladen von Klassen.

Dafür gibt es Konfigurationsdateien, etwa für Reflection, in denen man dem Compiler mitteilt, was er behalten soll. Für viele verbreitete Bibliotheken liegen solche Hinweise schon vor, ein Repository mit Metadaten sammelt sie. Bei eigenem Code oder weniger bekannten Bibliotheken wird es Handarbeit, und die Fehler zeigen sich nicht beim Build, sondern erst, wenn eine Klasse zur Laufzeit nicht gefunden wird. Deshalb bleibt der Weg zum Native Image ein Weg mit Tests: Es reicht nicht, dass der Build durchläuft, man muss das fertige Binary prüfen.

Ein kleines Beispiel, wie der Einstieg aussieht, wenn man ein JAR ohne Framework hat:

native-image -jar meine-app.jar meine-app
./meine-app

Mehr braucht es bei einfachen Anwendungen nicht. Bei allem, was Reflection stark nutzt, kommt man nach den ersten Versuchen aber nicht um die Konfiguration herum.

Was die Frameworks sagen

Der Aufwand lässt sich verringern, weil moderne Frameworks viel vorbereiten. Spring Boot 3 bringt Unterstützung für Native Images mit. Das Framework erledigt einen Teil der Analyse schon beim Build und erzeugt Hinweise für Reflection und Proxies. Mit dem passenden Build-Plugin reicht bei Maven ein Aufruf wie ./mvnw -Pnative native:compile, bei Gradle ./gradlew nativeCompile. Quarkus und Micronaut sind von Anfang an darauf ausgelegt, weil sie vieles, was andere Frameworks zur Laufzeit per Reflection machen, schon beim Build erledigen.

Über Quarkus habe ich 2019 geschrieben, und seitdem hat sich viel getan. Dass man Native Images aus einem normalen Maven-Build bekommt, ohne selbst Konfigurationsdateien zu schreiben, war damals nicht selbstverständlich.

Wann es sich lohnt

Mein Eindruck ist, dass die Entscheidung davon abhängt, wie lange die Anwendung läuft und wie oft sie startet.

Native Image ist eine gute Idee bei:

  • Kommandozeilenwerkzeugen, die oft und kurz laufen. Niemand will bei einem CLI-Programm auf das Aufwärmen der JVM warten.
  • Serverless-Funktionen, bei denen jeder Kaltstart zählt.
  • Diensten mit Scale-to-zero, die bei Bedarf starten und danach wieder verschwinden.
  • Umgebungen, in denen Speicher knapp ist oder viele kleine Instanzen laufen.

Die JVM mit JIT bleibt oft besser bei:

  • Lange laufenden Servern, bei denen Start und Warmlaufen kaum ins Gewicht fallen.
  • Anwendungen, bei denen die Spitzenleistung zählt. Der JIT-Compiler optimiert anhand des tatsächlichen Verhaltens zur Laufzeit und kann dabei sehr gut werden. PGO holt hier auf, aber ob es die JIT-Variante erreicht, muss man im Einzelfall messen.
  • Code mit viel Reflection, dynamischem Laden oder Plug-in-Mechanismen.
  • Teams, die schnelle Builds und einfaches Debugging im Alltag brauchen. Ein Native-Image-Build, der ein paar Minuten läuft, bremst die Entwicklung, wenn man ihn bei jeder Änderung braucht. Üblicherweise entwickelt man mit der normalen JVM und baut das Native Image in der CI.

Messen heißt hier wirklich messen, mit der eigenen Anwendung und der eigenen Last. Blogartikel, auch dieser, sind dafür kein Ersatz.

Was ich daraus mitnehme

Die neue Lizenz ändert nichts an der Technik, aber an der Frage, ob man sie anfassen darf. Bisher stand die Enterprise-Edition für alles, was Native Images erst richtig attraktiv macht, hinter einer Lizenzfrage. Dass dies jetzt wegfällt, holt für viele Projekte die Entscheidung aus der Lizenzprüfung zurück in die Technik. Das finde ich gut.

Ich werde als Nächstes ein kleines Kommandozeilenwerkzeug damit bauen, denn dort sehe ich den klarsten Nutzen, und danach schauen, ob sich ein Spring-Boot-3-Dienst sinnvoll als Native Image bauen lässt. Wenn ich dazu etwas Brauchbares herausfinde, schreibe ich es auf.

Habt ihr Native Images schon produktiv im Einsatz, und wenn ja: Hat sich der Aufwand für euch gelohnt?

Beitragsbild: GraalVM-Logo von Oracle, gemeinfrei (via Wikimedia Commons; unverändert auf eigenem Hintergrund). GraalVM ist eine Marke der Oracle Corporation.

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.