Remarque :

TASK 5 : Créer une image native d'une application Micronaut et la déployer sur Oracle Cloud

Dans cet atelier, vous allez apprendre à transformer votre application Java en exécutable Linux natif avec GraalVM Native Image. Vous le déployerez ensuite sur une machine virtuelle dans Oracle Cloud.

Temps estimé : 20 minutes

Contenu de la tâche

Dans cette tâche :

Etape 1 : exécutez une application Micronaut sur la JVM dans Oracle Cloud

Cette étape consiste à déployer une application Micronaut traditionnellement sur la JVM (à partir d'un fichier JAR) dans Oracle Cloud. Vous continuerez à utiliser le code VS où GraalVM Enterprise 22.0.0 est défini comme JDK par défaut.

  1. Accédez à Terminal, puis à New Terminal et exécutez cette commande pour vérifier la version de Java :

    java -version

    Chaque fois que vous appelez la commande java, le compilateur Graal JIT optimisé, activé par défaut dans GraalVM Enterprise, sera appliqué.

  2. Vous pouvez packager un projet Java dans un fichier JAR exécutable et démarrer l'application à partir du terminal de code VS ou en appelant l'action Exécuter la page principale.

    • Accédez à Terminal, puis à New Terminal et exécutez l'objectif mn:run :

      ./mvnw mn:run

      Si vous utilisez Gradle, exécutez la tâche run :

      ./gradlew run

    • Vous pouvez également rechercher le fichier de classe Application.java dans le code VS, puis cliquer sur Exécuter la page principale au-dessus de la méthode principale :

      Exécuter l'action rapide de la méthode principale

      L'application est démarrée sur le port 8080. Notez le temps nécessaire pour le lancer (il est attendu d'environ 6500 ms).

  3. Mettez fin à la candidature :

    CTLR +C

Etape 2 : Création d'un exécutable Linux natif d'une application Micronaut

Vous pouvez transformer n'importe quelle application Java en exécutable natif avec GraalVM Native Image. Il s'agit d'une technologie de compilation anticipée qui permet de transformer votre code exécutable Java en un code binaire natif autonome qui ne nécessite pas d'exécution de JDK et qui est conçu pour s'exécuter sur un environnement cible spécifique.

Comme mentionné précédemment, GraalVM Enterprise 22 est préinstallé sur votre machine virtuelle pour plus de commodité. Il s'agit de Native Image, qui est ajouté à toutes les bibliothèques dépendantes (par exemple, libstdc++-static, glibc, zlib, etc.). L'utilitaire native-image est placé dans le répertoire d'installation de GraalVM ($JAVA_HOME/bin).

  1. Dans la fenêtre VS Code Terminal, vérifiez la version de Native Image :

    native-image --version

  2. Exécutez cette commande unique pour créer un exécutable Linux natif :

    • Si vous utilisez Maven, indiquez le format de packaging native-image :

    ./mvnw clean package -Dpackaging=native-image
    • Si vous utilisez Gradle, exécutez la tâche nativeImage :

    ./gradlew nativeCompile

    Après un certain temps, un exécutable natif appelé ocidemo sera intégré au répertoire /target/native-image/. Si vous utilisez Gradle, l'exécutable appelé ocidemo est écrit dans le dossier /build/native/nativeCompile/.

    Remarque : la création d'un exécutable dépend de la taille et de la complexité de l'application et peut prendre un certain temps sur les machines virtuelles à faible consommation d'énergie. En utilisant les capacités de l'instance de machine virtuelle allouée pour cet exercice, le temps attendu est d'environ 5 minutes.

GraalVM Native Image crée un fichier exécutable avec toutes les classes d'application, les classes de bibliothèque dépendantes, les classes JDK dépendantes et un instantané de la portion de mémoire de l'application. Si la création d'une image native peut prendre un certain temps, les avantages incluent une réduction spectaculaire du temps de démarrage et une réduction de la consommation globale de mémoire.

Etape 3 : déploiement de l'application Micronaut dans OCI

A l'étape précédente, vous avez créé un exécutable Linux natif de votre application Micronaut. Vous allez maintenant déployer cet exécutable natif dans Oracle Cloud et comparer les temps de démarrage lors de l'exécution de la même application à partir d'un fichier JAR et d'une image native.

Pour déployer votre application en tant qu'exécutable natif, appelez un fichier binaire généré à l'étape précédente :

./target/ocidemo


./build/native/nativeCompile/ocidemo

Notez combien de temps il faut pour démarrer ce microservice Micronaut en tant qu'image native qu'à partir d'un fichier JAR à l'étape 1 (il doit passer d'environ 6500 millisecondes à 2500). Elle démarre plus rapidement car l'exécutable est un binaire autonome et ne nécessite pas l'exécution d'un JDK, ce qui en fait un moyen facile de distribuer les applications. La taille de fichier est également assez petite.

Le déploiement d'un microservice Java en tant qu'exécutable natif permet de réaliser un démarrage instantané, de réduire l'utilisation du processeur et de la mémoire, ce qui permet à GraalVM Enterprise d'être un bon candidat pour la création d'applications Java natives dans le cloud et pour les déploiements dans le cloud.

L'application s'exécute correctement à ce stade, mais pour y accéder, par exemple à partir d'un navigateur, vous devrez autoriser le trafic entrant vers votre machine virtuelle. Mettez fin à l'application, CTRL+C, puis passez à l'étape suivante.

Etape 4 : configurez le pare-feu de sorte à autoriser le trafic vers votre instance cloud (facultatif)

Pour vérifier que cette application côté serveur s'exécute dans Oracle Cloud et l'ouvrir dans un navigateur, vous devez vous assurer que le pare-feu de l'hôte autorise le trafic vers votre machine virtuelle.

  1. Revenez à la console cloud, accédez à Compute, puis à Instances.

  2. Lorsque vous êtes connecté à la console OCI, accédez à Compute et cliquez sur Instances. Assurez-vous que vous êtes dans le compartiment nécessaire (voir Tâche 1, étape 3).

    Rechercher des instances Compute

  3. Recherchez l'instance de machine virtuelle (nom commençant par graal-workshop-...) dans la vue principale et ouvrez-la.

  4. Dans la section Carte d'interface réseau virtuelle principale, cliquez sur Sous-réseau auquel l'instance est attachée (subnet-01).

  5. Sur la page du sous-réseau, cliquez sur Liste de sécurité interne.

  6. Appuyez sur Ajouter une règle entrante et remplissez les données suivantes.

    Ajouter une règle entrante pour autoriser le trafic entrant vers le port

    La règle permet au trafic de toutes les sources d'utiliser le port 8080, de sorte que l'application puisse être atteinte de n'importe où.

  7. Revenez à la fenêtre de terminal et exécutez les commandes suivantes pour redémarrer le pare-feu dans l'instance de machine virtuelle en cours d'exécution.

    sudo firewall-cmd --permanent --add-port=8080/tcp


    sudo systemctl reload firewalld

  8. Redémarrez l'application en tant qu'exécutable natif.

    Conçu avec Maven :

    ./target/ocidemo

    Conçu avec Gradle :

    ./build/native/nativeCompile/ocidemo

  9. Ouvrez l'application dans un navigateur à l'aide de http://<SERVER_IP>:8080/pets pour l'adresse /pet et de http://<SERVER_IP>:8080/owners pour l'adresse /owners. Vous pouvez également fractionner la fenêtre de terminal dans le code VS et envoyer une demande GET avec curl :

    curl -i http://<SERVER_IP>:8080/pets

Bravo ! Vous avez terminé cet exercice avec succès.

En savoir plus

Pour mettre fin à cette session, cliquez sur le bouton End Session dans la barre d'outils.