Démarrage rapide : déployer votre première application Java Native Image sur Azure Spring Apps

Article
10/04/2024

Remarque

Les plans Essentiel, Standard et Entreprise seront déconseillés à compter de la mi-mars 2025, avec une période de mise hors service de 3 ans. Nous vous recommandons de passer à Azure Container Apps. Pour plus d’informations, consultez l’annonce de mise hors service d’Azure Spring Apps.

Le plan de consommation standard et dédiée sera déconseillé à compter du 30 septembre 2024, avec un arrêt complet après six mois. Nous vous recommandons de passer à Azure Container Apps. Pour plus d’informations, consultez Migrer le plan de consommation standard et dédiée Azure Spring Apps vers Azure Container Apps.

Cet article s’applique à :❌ De base/Standard ✔️ Entreprise

Ce guide de démarrage rapide montre comment déployer une application Spring Boot sur Azure Spring Apps en tant que Native Image.

La fonctionnalitéNative Image vous permet de compiler des applications Java sur des exécutables autonomes, appelés images natives. Ces exécutables peuvent offrir des avantages significatifs, notamment des temps de démarrage plus rapides et une surcharge de mémoire d’exécution plus faible par rapport à une machine virtuelle Java (JVM) traditionnelle.

L’exemple de projet est l’application Spring Petclinic. La capture d’écran suivante montre l’application :

1. Prérequis

Un abonnement Azure. Si vous n’avez pas d’abonnement, créez un compte gratuit avant de commencer.
Git.
Kit de développement Java (JDK), version 17.
Azure CLI version 2.45.0 ou ultérieure. Utilisez la commande suivante pour installer l’extension Azure Spring Apps : az extension add --name spring
Si vous déployez pour la première fois une instance de plan Enterprise d’Azure Spring Apps dans l’abonnement cible, consultez la section Exigences dans Afficher l’offre Azure Spring Apps de niveau Enterprise dans la place de marché Azure.

2. Préparer le projet Spring Petclinic

Procédez comme suit pour cloner et exécuter l’application localement.

Utilisez la commande suivante pour cloner le projet Spring Petclinic depuis GitHub :
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```
Utilisez la commande suivante pour générer le projet Spring Petclinic :
```
cd spring-petclinic
./mvnw clean package -DskipTests -Pnative package
```
Utilisez la commande suivante pour exécuter l’application Spring Petclinic à l’aide de Maven :
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Accédez à http://localhost:8080 dans votre navigateur pour accéder à l’application Spring Petclinic.

3. Préparer l’environnement cloud

La ressource principale requise pour exécuter l’application Spring Petclinic est une instance Azure Spring Apps. Cette section décrit les étapes de création de cette ressource.

3.1. Donner des noms à chaque ressource

Créez des variables destinées à contenir les noms de ressources à l’aide des commandes suivantes. Veillez à remplacer les espaces réservés par vos valeurs.

export RESOURCE_GROUP=<resource-group-name>
export LOCATION=<location>
export AZURE_SPRING_APPS_NAME=<Azure-Spring-Apps-service-instance-name>
export NATIVE_BUILDER=native-builder
export JAR_APP_NAME=jar-app
export NATIVE_APP_NAME=native-app
export JAR_PATH=target/spring-petclinic-3.1.0-SNAPSHOT.jar

3.2. Création d’un groupe de ressources

Procédez comme suit pour créer un groupe de ressources :

Utilisez la commande suivante pour vous connecter à Azure CLI :
```
az login
```
Utilisez la commande suivante pour définir la localisation par défaut :
```
az configure --defaults location=${LOCATION}
```
Utilisez la commande suivante pour répertorier tous les abonnements disponibles, puis déterminez l’ID d’abonnement à utiliser :
```
az account list --output table
```
Utilisez la commande suivante pour définir votre abonnement par défaut :
```
az account set --subscription <subscription-ID>
```
Utilisez la commande suivante pour créer un groupe de ressources :
```
az group create --resource-group ${RESOURCE_GROUP}
```
Utilisez la commande suivante pour définir le groupe de ressources nouvellement créé comme groupe de ressources par défaut :
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Créer une instance Azure Spring Apps

Azure Spring Apps est utilisé pour héberger l’application Spring Petclinic. Procédez comme suit pour créer une instance Azure Spring Apps et deux applications à l’intérieur de celle-ci :

Utilisez la commande suivante pour créer une instance de service Azure Spring Apps. La génération d’une image native nécessite 16 Gio de mémoire pendant la génération de l’image. Par conséquent, configurez la taille du pool de build en tant que S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Créez un fichier builder-native.json dans le répertoire actif, puis ajoutez le contenu suivant :

{
   "stack": {
     "id": "io.buildpacks.stacks.jammy",
     "version": "tiny"
   },
   "buildpackGroups": [
     {
       "name": "default",
       "buildpacks": [
         {
           "id": "tanzu-buildpacks/java-native-image"
         }
       ]
     }
   ]
 }

Utilisez la commande suivante pour créer un générateur personnalisé afin de générer l’application Native Image :

az spring build-service builder create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_BUILDER} \
    --builder-file builder-native.json

Utilisez la commande suivante pour créer une application dans l’instance Azure Spring Apps dans laquelle déployer l’application Spring Petclinic en tant que fichier JAR. Configurez la limite de mémoire à 1 Gio.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Utilisez la commande suivante pour créer une application dans l’instance Azure Spring Apps dans laquelle déployer l’application Spring Petclinic en tant que Native Image :
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Déployer l’application sur Azure Spring Apps

Maintenant que l’environnement cloud est prêt, les application sont prêtes à être déployées.

Utilisez la commande suivante pour déployer l’application Spring Petclinic en tant que fichier JAR :

az spring app deploy \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --artifact-path ${JAR_PATH} \
    --build-env BP_JVM_VERSION=17

Utilisez la commande suivante pour déployer l’application Spring Petclinic en tant que Native Image :

az spring app deploy \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --builder ${NATIVE_BUILDER} \
    --build-cpu 8 \
    --build-memory 16Gi \
    --artifact-path ${JAR_PATH} \
    --build-env BP_JVM_VERSION=17 BP_NATIVE_IMAGE=true

5. Valider l’application Native Image

Vous pouvez maintenant accéder à l’application déployée pour vérifier son fonctionnement. Utilisez les étapes suivantes pour valider :

Une fois le déploiement terminé, vous pouvez exécuter la commande suivante pour obtenir l’URL de l’application :
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Vous pouvez accéder à l’application avec l’URL indiquée dans la sortie en tant que Public Url. La page doit apparaître telle que vous l’avez vue dans le localhost.
Utilisez la commande suivante pour vérifier le journal de l’application afin d’examiner tout problème de déploiement :
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Comparer les performances de JAR et de Native Image

Les sections suivantes décrivent comment comparer les performances entre les déploiements JAR et Native Image.

Temps de démarrage du serveur

Utilisez la commande suivante pour vérifier le journal Started PetClinicApplication in XXX seconds de l’application afin d’obtenir le temps de démarrage du serveur pour une application JAR :

az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME}

Le temps de démarrage du serveur est d’environ 25 s pour une application JAR.

Utilisez la commande suivante pour vérifier le journal de l’application afin d’obtenir le temps de démarrage du serveur pour une application Native Image :

az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}

Le temps de démarrage du serveur est inférieur à 0,5 s pour une application Native Image.

Utilisation de la mémoire

Utilisez la commande suivante pour réduire la taille de la mémoire à 512 Mi pour une application Native Image :

az spring app scale \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --memory 512Mi

La sortie de la commande doit indiquer que l’application Native Image a démarré avec succès.

Utilisez la commande suivante pour réduire la taille de la mémoire à 512 Mio pour l’application JAR :

az spring app scale \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --memory 512Mi

La sortie de la commande doit indiquer que l’application JAR n’a pas pu démarrer en raison d’une mémoire insuffisante. Le message de la sortie doit ressembler à l’exemple suivant : Terminating due to java.lang.OutOfMemoryError: Java heap space.

La figure suivante montre l’utilisation optimisée de la mémoire pour le déploiement Native Image pour une charge de travail constante de 400 requêtes par seconde dans l’application Petclinic. L’utilisation de la mémoire est d’environ 1/5e de la mémoire consommée par le déploiement JAR équivalent.

Les images natives offrent des temps de démarrage plus courts et une surcharge de mémoire d’exécution réduite par rapport à la machine virtuelle Java (JVM) conventionnelle.

7. Nettoyer les ressources

Si vous prévoyez d’utiliser d’autres guides de démarrage rapide et tutoriels, vous pouvez conserver ces ressources. Lorsque vous n’avez plus besoin des ressources, supprimez-les en supprimant le groupe de ressources. Utilisez la commande suivante pour supprimer le groupe de ressources :

az group delete --name ${RESOURCE_GROUP}

8. Étapes suivantes

Comment déployer des applications Java Native Image dans le plan Enterprise Azure Spring Apps

Journal des applications structuré pour Azure Spring Apps

Mapper un domaine personnalisé existant à Azure Spring Apps

Configurer Azure Spring Apps CI/CD avec GitHub Actions

Configurer Azure Spring Apps CI/CD avec Azure DevOps

Utiliser des identités managées pour les applications dans Azure Spring Apps

Créer une connexion de service dans Azure Spring Apps avec Azure CLI

Exécuter les applications polyglottes ACME Fitness Store sur Azure Spring Apps

Surveiller votre application image native Spring Boot

Pour plus d’informations, consultez les articles suivants :

Partager via