Quarkus : le framework Java nouvelle génération

Qu’est ce que Quarkus ?

Quarkus est un framework d’application Java Open Source, conçu pour fonctionner nativement avec Kubernetes.

Il est construit sur les frameworks Java populaires tels que Eclipse MicroProfile et Apache TomEE, et est optimisé pour les conteneurs et les environnements sans serveur.

L’une des principales caractéristiques de Quarkus est sa capacité à générer des exécutables natifs. Cela signifie que les applications Quarkus peuvent être compilées en code machine et exécutées sans avoir besoin d’une machine virtuelle Java (JVM). Cela entraîne des temps de démarrage plus rapides et une utilisation de mémoire inférieure par rapport aux applications Java traditionnelles.

Une application native avec Quakus ?

La construction native avec Quarkus consiste à utiliser GraalVM pour créer des images de conteneur binaires natifs à partir de votre application Java. Cela permet de créer des images de conteneur plus légères et plus rapides à démarrer, car elles ne nécessitent pas un JRE (Java Runtime Environnement) pour fonctionner.

Une fois l’image générée, vous pouvez la déployer dans un conteneur, ou l’utiliser pour des fonctions en tant que service (FaaS). La taille de l’image native sera généralement plus petite que celle d’une image JVM, car elle ne contient pas de JRE. Les temps de démarrage seront également plus rapides car l’application est compilée en binaire natif et n’a pas besoin de charger un JRE.

Comparatif Quakus JVM, Quarkus Native et SpringBoot

Les performances d’une application native sont généralement supérieures à celles d’une application JVM (Java Virtual Machine) classique. Cela est dû à plusieurs facteurs :

• La compilation à la volée n’est plus nécessaire : une application native est compilée en binaire natif, ce qui signifie qu’elle est directement exécutée par le système d’exploitation sans l’intermédiaire d’une machine virtuelle. Cela permet d’éliminer les surcharges de la JVM et de réduire les temps d’exécution.
• Utilisation de la mémoire réduite : une application native utilise moins de mémoire que son équivalent JVM, car elle ne nécessite pas de charger la JVM elle-même en mémoire.
• Temps de démarrage plus rapides : une application native démarre plus rapidement qu’une application JVM, car elle ne doit pas charger la JVM avant de démarrer.
• Taille de l’image plus petite : une application native a une image plus petite que son équivalent JVM, car elle ne nécessite pas de inclure la JVM elle-même.
• Consommation de ressources réduite : une application native consomme généralement moins de ressources système (processeur, mémoire) que son équivalent JVM, car elle est plus efficace pour utiliser les ressources disponibles.

En somme, les avantages des applications natives sont nombreux : performances plus élevées, utilisation réduite de la mémoire, temps de démarrage plus rapides, taille d’image plus petite et consommation de ressources réduite.

Voici ci dessous un tableau comparatif comprenant les temps de build et de démarrage entre les trois technologies :

Métrique	SpringBoot JVM	Quarkus JVM	Quarkus Native
Temps de build (sec)	1.75	5.24	91
Temps de lancement (sec)	1.81	1.27	0.11

Comment faire une application Quarkus ?

Créer un dossier dans le quel voulez créer votre nouveau projet quarkus puis exécuter la commande maven suivante :

mvn io.quarkus.platform:quarkus-maven-plugin:2.15.3.Final:create 
	-DprojectGroupId=com.proxiad 
	-DprojectArtifactId=quarkus

Celle-ci va permettre la création d’un squelette d’application contenant un WebService que vous pourrez ouvrir dans votre IDE préféré.

Il est également possible d’utiliser l’initialiseur de projet disponible à cette adresse : https://code.quarkus.io/ ce dernier fonctionne comme Spring initializr et permet donc de sélectionner différentes dépendances ainsi que de préconfigurer le pom.xml de votre projet.

Afin de lancer votre nouvelle application exécuter la commande :

mvn compile quarkus:dev

Votre application se lancera ainsi et vous pourrez y accéder en local à l’adresse : http://localhost:8080/

Cette page contient une page d’accueil regroupant différentes informations sur l’application en cours d’exécution ainsi que le path vers le premier webservice auto-généré :

Cette interface contient également un bouton permettant d’accéder au dev UI regroupant différentes informations complémentaires sur l’application ainsi que la possibilité de configurer cette dernière.

En parallèle de votre application Quarkus, votre CLI ayant permit le lancement de l’application reste interactive afin de pouvoir effectuer divers actions lors de vos développements. (activer ou désactiver le live reload, changer le niveau de logging dynamiques etc..). Pour éteindre l’application et quitter la console interactive, vous pouvez presser la touche “q”.

En ce qui concerne le code, voici à quoi ressemble le premier webservice :

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

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from RESTEasy Reactive";
    }
}

Et si nous passons notre application JVM en native ?

Maintenant que nous avons une application fonctionnelle, nous sommes prêt à passer notre application en native.

Premièrement, ils vous faudra installer GraalVM qui est un outil permettant d’optimiser les performances des applications Java. Il fonctionne en utilisant un compilateur pour transformer le code Java en code natif. Pour installer GraalVM vous pouvez vous référer à la documentation officiel ici :
Installation on Windows Platforms

Pour builder l’application Quarkus en native il faut impérativement lancer les commandes depuis le terminal x64 Native Tools.

mvn package -Pnative

Pour rappel, si le build est plus long qu’un build classique, cela est tout à fait normal.

Lorsque ce dernier se termine, vous retrouverez dans votre dossier /target votre application compilé reconnaissable avec le suffixe “-runner”.

Pour lancer l’application, il suffit simplement de l’exécuter comme tout exécutable.

Vous remarquerez que le serveur se lance instantanément (300 ms) .

En suivant cette logique, il est également possible de créer directement une image Docker.
Pour ce faire :

• Compiler l’application avec les paramètres supplémentaires :

mvn package -Pnative -Dquarkus.native.container-build=true -Dquarkus.container-image.build=true

• Effectuer le build Docker de l’application via le fichier Dockerfil.native :

docker build -f src/main/docker/Dockerfile.native -t proxiad/quarkus-poc:1.0.0-SNAPSHOT .

• Puis vous pouvez lancer directement via docker desktop ou via la commande suivante :

docker run -i --rm -p 8080:8080 proxiad/quarkus-poc

Vous pouvez dès à présent pousser votre image sur un hub distant afin de déployer votre application sur d’autres environnements ou la récupérer cette dernière dans Kurbenetes.

Il est important de noter que la construction native n’est pas compatible avec tous les frameworks et les bibliothèques Java, donc il est important de vérifier la compatibilité avant de l’utiliser. De plus, les fonctionnalités d’introspection et de réflexion ne sont pas supportées dans les images natives, donc il est important de vérifier si cela affectera votre application.

Qu’en concluons nous ?

En conclusion, Quarkus est un framework Java innovant qui permet de développer des applications de microservices performantes et légères. Il offre une expérience de développement moderne et agréable grâce à son intégration avec les dernières technologies comme GraalVM, Kubernetes et OpenShift. Quarkus est également très bien adapté pour les déploiements dans des environnements cloud natifs, ce qui en fait un choix judicieux pour les projets de développement de microservices. En somme, Quarkus est un outil puissant qui devrait être considéré pour les projets Java actuels et futurs.

Direction Technique
Jean-Christophe DECLUNDER
Proxiad NORD