Kubernetes Native Java Avec Quarkus

Java domine les applications d'entreprise. Mais dans le cloud, Java est plus cher que certains concurrents. La compilation native rend Java dans le cloud moins cher : elle crée des applications qui démarrent beaucoup plus rapidement et utilisent moins de mémoire.

La compilation native soulève donc de nombreuses questions pour tous les utilisateurs de Java : comment Java natif change-t-il le développement ? Quand faut-il passer au Java natif ? Quand ne devrions-nous pas ? Et quel framework devrions-nous utiliser pour Java natif ? Cette série apportera des réponses à ces questions.

Cet article d'InfoQ fait partie de la série "Les compilations natives boostent Java". Vous pouvez vous abonner pour recevoir des notifications via RSS.

Qu'est-ce que Kubernetes Native Java ?

"[Ils] pourraient exécuter des déploiements 3 fois plus denses sans sacrifier la disponibilité et les temps de réponse du service." - Lufthansa Technik

Les organisations adoptent Kubernetes pour fournir une valeur commerciale plus rapidement et de manière plus rentable. Pourquoi ? Parce que Kubernetes facilite les tâches difficiles : il fait automatiquement évoluer les applications horizontalement lorsque la charge augmente et effectue des mises à niveau progressives.

Mais cette approche se heurte au modèle traditionnel de Java d'architectures à trois niveaux avec de grandes tailles de tas, une mise à l'échelle verticale et des processus de longue durée.

Java a historiquement atteint des performances exceptionnelles en allouant et en conservant un maximum de ressources système, en s'adaptant aux conditions de charge à la demande au fil du temps.

Les développeurs ont adopté avec plaisir le modèle Java de JVM longue durée, lourde mais très dynamique pour permettre un modèle de programmation déclarative riche tout en exécutant plusieurs applications diverses. L'analyse paresseuse et l'analyse du classpath à l'exécution nous ont permis d'inverser le contrôle et de réduire le code passe-partout, au détriment du temps de démarrage et de l'utilisation de la mémoire. Ces inconvénients n'avaient pas beaucoup d'importance dans les grandes applications monolithiques avec des tailles de tas énormes, car vous ne payiez qu'une seule fois la pénalité de démarrage.

Mais l'exécution de ces applications Java traditionnelles dans Kubernetes génère de nombreuses grosses JVM, toutes hébergeant un environnement d'exécution dynamique gourmand en ressources qui redémarrent souvent. Et les redémarrages consomment des cycles CPU inutiles en analysant la même image immuable encore et encore, en arrivant au même résultat à chaque fois. Cette analyse utilise également beaucoup de mémoire que la JVM conserve durant toute sa vie. Mais la densité compte dans Kubernetes : plus il y a d'instances d'application qui peuvent s'exécuter, plus le retour sur investissement de Kubernetes est élevé.

Kubernetes Native Java signifie que les applications Java peuvent tirer parti des capacités de Kubernetes au lieu de leur résister - de petits processus qui démarrent rapidement au lieu de JVM gourmandes en mémoire avec de longs temps de démarrage.

La motivation derrière Quarkus

"Avant d'introduire Quarkus, de nombreux clients avaient commencé à rechercher des piles alternatives comme Go et node.js pour améliorer les performances et l'efficacité. Ces clients étaient las de choisir un nouveau langage et d'avoir à embaucher de nouveaux développeurs ou à recycler leur développeurs Java existants" – Arijit Mazumdar, WiPro

Les organisations et les développeurs investissent énormément dans Java. C'est un langage incroyablement productif avec des outils et des frameworks fantastiques que les développeurs connaissent et aiment déjà. Kubernetes, cependant, exige une nouvelle direction. S'il serait dommage de renoncer aux nombreux avantages de Java, les runtimes avec une mémoire et un temps de démarrage plus efficaces, tels que Node.js et Golang, remettent en question cet investissement Java.

L'équipe Quarkus a décidé d'avoir son gâteau et de le manger aussi : fusionner les avantages de l'écosystème Java riche en fonctionnalités et mature avec les avantages opérationnels de Kubernetes. Pour ce faire, les applications Java doivent être définies de manière plus statique au moment de l'exécution, tout en restant capables d'adopter les capacités dynamiques de Java qui permettent aux développeurs d'itérer plus rapidement.

Les organisations augmentent le rythme de déploiement des applications en utilisant le Cloud. De même, les entreprises d'aujourd'hui ont besoin de cycles de développement plus courts qui génèrent plus rapidement de la valeur commerciale. L'approche de Quarkus prend en charge cette augmentation du rythme d'itération et de déploiement en se concentrant fortement sur la "joie du développeur" et a prouvé que Java peut être aussi productif, sinon plus, que les langages de scripting.

Bien sûr, être productif ne se limite pas à la vitesse à laquelle vous pouvez coder. La création d'une application cloud moderne nécessite une interaction avec d'autres services où les technologies de câblage avec du YAML complexe vous ralentissent. Nous avons estimé que les fonctionnalités pour la joie du développeur telles que Dev Services et Zero Config Development, abordées plus en détail ultérieurement, étaient essentielles pour Kubernetes Native Java. Par exemple, vous écrivez du code pour accéder à une base de données, et Quarkus démarre comme par magie et connecte tout en arrière-plan au fur et à mesure que vous tapez.

De même, le déploiement sur Kubernetes ne devrait pas nécessiter la lecture d'un livre d'administration Kubernetes et la création de centaines de lignes de YAML. Avec Quarkus, nous pensions qu'il était important que Java soit tout ce que vous devez savoir. Ajoutez le flag "-Dquarkus.kubernetes.deploy" lors de la compilation, et Quarkus déploiera votre application sur Kubernetes (n'oubliez pas de vous connecter !). Si vous préférez, vous pouvez utiliser l'interface utilisateur Quarkus Dev intégrée et déclencher un déploiement directement depuis votre navigateur.

En bref, Quarkus est conçu à partir de zéro pour transformer Java en langage idéal pour créer des binaires natifs et des applications Kubernetes. Quarkus est Kubernetes Native Java !

Le temps de construction favorise la compilation native

"Quarkus a introduit un nouveau paradigme qui met les choses à l'envers sur la façon dont les choses sont exécutées sous le capot - avec le support natif, la réflexion effectuée au moment de la compilation et non de l'exécution est tout simplement incroyable !" – Roberto Cortez, Talkdesk (au moment de la citation, maintenant employé par Red Hat)

La division du cycle de vie d'une application en deux phases distinctes est essentielle pour réaliser des processus petits et légers avec un démarrage instantané, comme l'exige l'architecture Kubernetes Native. Traditionnellement, le démarrage de l'environnement d'exécution des applications Java exécute une série d'étapes complexes, longues, dynamiques et auto-introspectives pour répondre aux exigences d'un environnement de déploiement dynamique. Ces étapes se répètent à chaque démarrage d'une application.

Étant donné qu'une image de conteneur ne change pas, il n'est plus nécessaire d'effectuer ces étapes lors de l'exécution. La plupart des étapes de démarrage dynamiques peuvent être déplacées au moment de la génération. Le travail effectué au démarrage effectif devient alors beaucoup plus réduit et significativement plus rapide. De plus, il est possible de retirer du code dont une application n'a pas besoin. La personnalisation de la sortie conduit à un exécutable allégé contenant uniquement le code requis.

Quarkus apporte des avantages immédiats en matière d'efficacité de la JVM pendant que les entreprises évaluent et se préparent pour les exécutables Java natifs , car les avantages au moment de la construction s'appliquent de manière universelle : ce n'est pas seulement la compilation native qui profite de cette approche, mais également la JVM/Hotspot traditionnelle. Lorsqu'il y a moins de code qui est plus efficace, la sortie sera plus légère et plus rapide quelle que soit sa forme. Cela dit, la compilation native ahead-of-time apporte les avantages au niveau suivant : dans un monde fermé où tout est connu à l'avance, le compilateur peut effectuer des optimisations très fines jusqu'au champ, à la variable et au niveau du jeu d'instructions.

Cependant, il y a un hic : pour que le compilateur ahead-of-time (AOT) fasse son travail efficacement, il doit comprendre ce que le code Java fera finalement. Les aspects dynamiques de Java qui le rendent si hautement productif masquent également le comportement de l'application vis-à-vis du compilateur et limitent le degré d'optimisation. Par exemple, un point d'injection rend le code simple et facile à faire évoluer. Mais pour le compilateur AOT, c'est un trou indéfini et sans réponse dans une équation.

Par exemple, vous pouvez facilement obtenir un exécutable natif en marquant chaque classe comme utilisable par réflexion. Mais le résultat sera probablement décevant : l'utilisation de la mémoire et le temps de démarrage ne sont que légèrement meilleurs que sur une JVM. En d'autres termes, vous avez besoin d'un modèle de construction entièrement englobant pour libérer tous les avantages de la compilation native. Comme celui qu'emploie Quarkus !

Désormais, Quarkus résout chaque dépendance au moment de la construction et génère une application complète en monde fermé. L'exemple d'injection décrit ci-dessus devient entièrement résolu pour le compilateur AOT - il connaît maintenant la classe à utiliser et peut éliminer le reste du code.

En résumé, la combinaison des capacités d'optimisation de GraalVM avec la capacité de construction de Quarkus conduit à la plus petite empreinte mémoire et temps de démarrage possibles. Limiter cette surcharge est essentiel pour tirer pleinement parti de Kubernetes Native Java.

Compilation native de première classe

"Nous utilisons Quarkus en mode JVM sur des conteneurs mais à l'avenir, nous prévoyons déjà d'utiliser Quarkus en mode natif sur Kubernetes et des environnements serverless, où le mode natif sera idéal" – Edouard Lamotte, Sedona

Étant donné que Quarkus et ses extensions (bibliothèques optimisées pour Quarkus) adoptent l'optimisation du temps de construction, vous pouvez créer n'importe quelle application en tant qu'exécutable natif à faible encombrement. Quarkus s'occupe de tout le travail ! D'autres solutions nécessitent souvent une plus grande implication des développeurs : vous pourrez peut-être compiler en natif, mais uniquement si votre application utilise un sous-ensemble d'API explicitement pris en charge ou si vous annotez le code avec des astuces GraalVM. Même si vous suivez les règles GraalVM, vous devez souvent maintenir à jour une configuration JSON distincte. De plus, Quarkus permet aux développeurs d'écrire facilement des tests qui s'exécutent sur l'exécutable natif, garantissant que ce que vous avez créé s'exécute comme prévu dans un exécutable natif.

Nous pensons que le large support d'une plate-forme de compilation native est essentiel pour permettre l'utilisation efficace de la technologie. Pour cette raison, nous nous efforçons de rendre l'adoption de la compilation native aussi simple que possible. De plus, nous nous assurons que chaque extension livrée dans Quarkus la prend en charge. Nous recommandons fortement que toutes les extensions "Quarkiverse" (notre référentiel pour les extensions fournies par la communauté) prennent également en charge la compilation native. Toutes les bibliothèques Java ne sont pas compatibles avec la compilation native de GraalVM. Cependant, étant donné que Quarkus possède un grand nombre d'extensions (près de 500 en accroissement !), il y a de fortes chances que tous les cas d'utilisation auxquels vous pouvez penser soient couverts. Sinon, écrire une extension Quarkus pour votre cas d'utilisation n'est pas difficile.

La joie du développeur

"Quarkus a été à l'origine d'innovations assez étonnantes dans l'expérience des développeurs. Leur console en mode développement et la prise en charge de Testcontainer sont au niveau supérieur." – James Ward, Java Champion

Comme mentionné précédemment, Kubernetes Native Java n'est pas seulement une question d'économie d'énergie. Il est tout aussi essentiel d'améliorer et d'étendre la productivité de Java et d'étendre son avantage de productivité par rapport aux autres langages compilés en natif, comme Golang. Chaque outil, framework et runtime prétend augmenter la productivité des développeurs. Mais Quarkus passe au niveau supérieur en proposant la joie du développeur (Developer Joy). Qu'est-ce que nous entendons par là ?

Quarkus s'efforce de fournir une expérience de développement amusante et agréable qui maintient l'engagement des développeurs Java. Quarkus vise à garder chaque développeur concentré sur le codage actif, car nous savons à quel point il est contre-productif de s'arrêter, d'exécuter un tas d'outils et d'attendre que quelque chose se termine. Quarkus est si productif que les développeurs se sentent encouragés à essayer des scénarios "et si" - quelque chose que les délais n'auraient peut-être pas permis dans le passé ! Considérez les fonctionnalités Developer Joy suivantes :

• Live Coding. Toutes les modifications de code sont en live, même lors de la modification des dépendances ou des fichiers de configuration. À chaque accès à l'application, Quarkus évalue les modifications de code, régénère le bytecode nécessaire et recharge l'application en arrière-plan pour renvoyer des résultats mis à jour, généralement en une demi-seconde ou moins. Live Coding fonctionne avec pratiquement toutes les modifications et refactorisations de code, quelle que soit leur complexité, sans plug-ins dans l'IDE ni outils spéciaux requis.
• Dev Services. Quarkus utilise Testcontainers pour instancier et configurer automatiquement des services pendant le développement et les tests, tels que les bases de données, les caches et Kafka. Ajoutez simplement une extension et commencez à coder pendant que le conteneur se télécharge et démarre automatiquement en arrière-plan !
• Développement Zero-Config. La convention plutôt que la configuration signifie qu'aucune configuration n'est requise pour les services de développement. Le YAML de déploiement de Kubernetes est automatiquement généré spécifiquement pour toute distribution cible, qu'il s'agisse de Minishift, d'OpenShift ou de Kubernetes générique.
• Tests continus. Exécutez automatiquement des tests à chaque fois qu'un fichier est enregistré. Exécutez tous les tests, les tests ayant échoué ou uniquement les tests pertinents pour les modifications de code (ce que Quarkus a compris). L'image suivante montre les résultats d'un changement de code en direct et sa sortie de test continue, rendant le développement Java aussi productif qu'un langage de script !

• Dev UI. Visualisez et utilisez les fonctionnalités d'extension Quarkus dans un navigateur Web pendant le développement. L'image suivante montre un exemple d'application avec des composants Dev UI qui permettent aux développeurs de mettre à jour une configuration en direct, d'afficher des beans CDI, de déployer sur OpenShift, d'ouvrir Swagger UI, etc.

• Mode commande. Complète l'interface utilisateur de développement en offrant des fonctionnalités similaires de l'interface utilisateur de développement à partir du clavier dans le terminal où le mode développeur de Quarkus a été lancé, comme la modification du niveau de journalisation d'une seule touche sans redémarrer la JVM.
• CLI Quarkus. Un outil en ligne de commande pour gérer un projet Quarkus. L'interface en ligne de commande peut générer et créer un projet, gérer les dépendances, exécuter des tests, etc.
• Prise en charge des standards et des meilleurs frameworks. Quarkus prend en charge des normes telles que MicroProfile et certaines spécifications Jakarta EE telles que JAX-RS, JPA et JTA, ainsi que les API Apache Camel, Hibernate, Kafka, Spring Compatibility et des dizaines d'autres.
• Support de Kotlin. En plus de Java, Quarkus prend en charge un langage alternatif populaire pour la JVM : Kotlin.
• Intégration avec les IDE. Les plug-ins Quarkus sont disponibles pour les IDE comme IntelliJ, Visual Studio Code et Eclipse avec des fonctionnalités telles que la complétion de code améliorée. Cependant, Quarkus ne nécessite pas d'IDE. Developer Joy fonctionne avec n'importe quel éditeur, même vi et Notepad !

Lorsqu'elles sont combinées, ces capacités accélèrent une équipe de développement, lui permettant de se concentrer sur ce qu'elle fait le mieux. Ces avantages accélèrent la livraison d'un projet, répondent plus rapidement aux exigences des clients et, enfin, améliorent la qualité des applications en consacrant plus de temps à la logique métier qu'à la plomberie.

Impératif et réactif

"[Quarkus est] capable de gérer naturellement le réactif ou l'impératif" – LogicDrop

Les performances d'exécution sont importantes. Le modèle de programmation réactive s'adapte beaucoup plus efficacement et avec une meilleure réactivité grâce à une utilisation globale des ressources plus faible. Mais l'obtention de performances d'exécution maximales ne doit pas nécessiter une réécriture et ne doit pas se faire au détriment de la facilité d'utilisation et de la flexibilité des développeurs. C'est pourquoi Quarkus est construit sur une pile d'E/S unifiée bloquante/réactive basée sur la boîte à outils Eclipse Vert.x.

Quarkus met en œuvre un routage intelligent, faisant de la combinaison d'API impératives et réactives une expérience de développement naturelle.

Lorsqu'une application utilise des API réactives Quarkus, le code s'exécute sur les threads d'E/S. Cela réduit le changement de contexte de thread et maximise le débit tout en minimisant la consommation de ressources.

Lorsque vous développez avec des API impératives, Quarkus répartit le travail sur des threads worker et renvoie le travail au thread d'E/S lorsqu'il est terminé.

Développez avec des API bloquantes, impératives ou des API asynchrones et réactives, même dans la même application (ou la même classe) ! Quarkus autorise les deux approches côte à côte de manière transparente et naturelle à l'aide du routage intelligent Quarkus. Les développeurs n'ont pas besoin de faire le choix à l'avance avant d'écrire une ligne de code.

Au revoir Boilerplate !

"[J'ai constaté] une amélioration de la productivité des développeurs de 30 à 40 %..." – Christos Sotiriou, Vodafone Grèce

La communauté Quarkus croit fermement que tout ce que vous tapez dans un projet Quarkus doit être super concis, facile à comprendre et ne pas épuiser vos touches de curseur ! Quarkus inclut de nombreuses API populaires, les améliorant pour tirer parti des connaissances de Quarkus en matière de temps de construction.

Par exemple, Quarkus a amélioré Hibernate avec "Panache", un ensemble d'API d'extensions qui rendent l'accès aux données aussi naturel que le Java moderne. Ce fragment de code est tout ce dont vous avez besoin pour exprimer une entité JPA. Pas de getters, pas de setters, pas de boilerplate (sauf si vous les aimez, alors gardez-les bien sûr) !

@Entity
public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;
}

Interroger une base de données est désormais également trivial :

List<Person> allPersons = Person.listAll();

Les extensions Quarkus peuvent détecter la présence d'autres extensions et s'intégrer à elles, réduisant ainsi la quantité de code que vous devez écrire, favorisant ce que nous pensons être les meilleurs modèles et pratiques.

Par exemple, si l'extrait de code "Panache" appartient à une application qui inclut les extensions datasource et health check, l'extension datasource définira automatiquement une vérification de l'état de la base de données pour l'application et une sonde Readiness pour Kubernetes. Par conséquent, Kubernetes n'enverra pas de trafic vers le conteneur d'applications lorsque la base de données n'est pas disponible.

De plus, si la même application inclut une extension metrics, l'extension datasource exposera automatiquement les métriques pour les outils de surveillance tels que Prometheus.

Kubernetes en tant que plateforme de premier ordre

"Cela signifie-t-il que je peux recommencer à écrire du code puisque je n'ai plus à gérer les configurations de service [Kubernetes] car Quarkus le fait pour moi ?" -- Ingénieur DevOps, LogicDrop

Quarkus est intrinsèquement Kubernetes Native, obtenant une efficacité d'exécution à la fois à partir du bytecode Java et d'un exécutable natif. De plus, Quarkus prend en charge Kubernetes en tant que plate-forme de premier ordre, offrant les extensions et fonctionnalités suivantes :

• Configuration. Quarkus peut utiliser l'API Kubernetes pour accéder à la configuration stockée dans un ConfigMap ou un secret sans le monter sur le système de fichiers du pod.
• Santé des applications. Expose l'intégrité de l'application aux sondes d'intégrité Kubernetes pour la redirection potentielle du trafic et les redémarrages de pod à l'aide de MicroProfile Health.
• Client Kubernetes. Enveloppe un modèle d'objets Java autour des objets Kubernetes et offre une API Java pour manipuler ces objets.
• Découverte de services et équilibrage de charge. Les applications peuvent utiliser le DNS au sein d'un cluster Kubernetes pour la découverte de services avec l'équilibrage de charge round-robin de Kubernetes. Ou ils peuvent utiliser le framework Stork d'équilibrage de charge côté client de Quarkus pour un algorithme d'équilibrage de charge plus sophistiqué ou personnalisé.
• Configuration et déploiement simplifiés vers Kubernetes et Knative. Quarkus génère le YAML requis pour le déploiement sur Kubernetes ou Knative, ce dernier ajoutant des fonctionnalités serverless à Kubernetes. La génération YAML peut être personnalisée à l'aide des propriétés Quarkus.
• Observabilité. Obtenez des informations sur les applications en cours d'exécution à l'aide de Micrometer ou MicroProfile Metrics et suivez les demandes de suivi sur plusieurs services à l'aide de MicroProfile OpenTracing ou OpenTelemetry.
• Functions as a Service (FaaS). Quarkus propose Funqy en tant qu'API pour développer des fonctions portables qui s'exécutent sur Knative avec des événements Knative et dans des environnements FaaS comme AWS Lambda, Azure Functions et Google Cloud Functions.
• Développement à distance. Quarkus prend en charge le Live Coding à distance prêt à l'emploi sans outils supplémentaires. Vous pouvez coder en direct une application s'exécutant dans un pod Kubernetes (ou un autre environnement distant) ; aucun outil IDE spécial n'est requis !
• SDK Quarkus Operator. Simplifie l'écriture des opérateurs Kubernetes avec Quarkus.

Premiers pas avec Quarkus

"J'ai pu me familiariser très rapidement avec Quarkus. Les guides Quarkus m'ont été d'une grande aide car ils se concentrent sur un sujet et vont droit au but." – Victor Gallet - Développeur Senior et Expert Kafka DECATHLON

La meilleure façon d'en savoir plus est de créer votre première application Quarkus. Cela ne prend que quelques minutes pour commencer - ce ne sont que quatre étapes ! Rendez-vous simplement au guide de démarrage qui vous guide à chaque étape. Les développeurs Spring peuvent se familiariser rapidement avec Quarkus en lisant l'ebook gratuit Quarkus for Spring Developers.

Après cela, vous voudrez peut-être profiter de notre site code.quarkus.io : choisissez simplement les extensions souhaitées et générez votre projet !

Conclusion

Kubernetes Native Java consiste à redéfinir la façon dont nous utilisons Java pour adopter le modèle Kubernetes, où la réduction du temps de démarrage et de l'utilisation de la mémoire réduit les coûts avec une efficacité accrue des ressources dans un environnement partagé. Quarkus accomplit cela en déplaçant une grande partie du traitement de démarrage vers le temps de construction. Le résultat est un environnement d'exécution efficace qui peut réduire considérablement les coûts de cloud computing avec des applications beaucoup plus économes en ressources. De plus, les organisations peuvent offrir de nouvelles fonctionnalités qui ont un impact direct sur l'entreprise sans dépasser leur budget actuel de cloud computing.

Pour maximiser les avantages de la compilation native, Quarkus s'intègre étroitement à GraalVM. Les applications sont conçues pour tirer le meilleur parti des optimisations de la compilation anticipée. Quarkus utilise le modèle d'extension de GraalVM pour améliorer ce processus et éviter une configuration supplémentaire.

Quarkus fournit la Developer Joy qui maintient le développeur engagé dans la résolution des problèmes métier avec des fonctionnalités telles que le Live Coding, les Dev Services et les tests continus. Développer avec Quarkus peut être si productif que les développeurs Java peuvent essayer plusieurs approches de résolution de problèmes et sélectionner celle qui a le plus d'impact sur le métier.

Quarkus considère également Kubernetes comme une plate-forme de premier ordre. Il fournit une collection de frameworks d'API qui permettent aux applications de tirer pleinement parti de ce qu'offre Kubernetes. Cela maximise les investissements dans Kubernetes et accélère la mise sur le marché grâce à l'intégration de la plateforme.

Lancez-vous !

Java domine les applications d'entreprise. Mais dans le cloud, Java est plus cher que certains concurrents. La compilation native rend Java dans le cloud moins cher : elle crée des applications qui démarrent beaucoup plus rapidement et utilisent moins de mémoire.

La compilation native soulève donc de nombreuses questions pour tous les utilisateurs de Java : comment Java natif change-t-il le développement ? Quand faut-il passer au Java natif ? Quand ne devrions-nous pas ? Et quel framework devrions-nous utiliser pour Java natif ? Cette série apportera des réponses à ces questions.

Cet article d'InfoQ fait partie de la série "Les compilations natives boostent Java". Vous pouvez vous abonner pour recevoir des notifications via RSS.