Déployer une application Spring sur App Service avec MySQL
Remarque
Pour les applications Spring, nous vous recommandons d’utiliser Azure Spring Apps. Toutefois, vous pouvez toujours utiliser Azure App Service comme destination. Pour plus d’informations, consultez Choisir les services Azure appropriés pour vos applications Java.
Ce tutoriel va vous guider lors du processus de génération, de configuration, de déploiement, de dépannage et de mise à l’échelle des applications web Java dans App Service sur Linux.
Ce tutoriel s’appuie sur l’exemple d’application populaire Spring PetClinic. Dans cette rubrique, vous allez tester une version HSQLDB de l’application localement, puis la déployer sur Azure App Service. Après cela, vous allez configurer et déployer une version qui utilise Azure Database pour MySQL. Enfin, vous allez apprendre à accéder aux journaux d’activité de l’application et à effectuer un scale-out en augmentant le nombre de workers exécutant votre application.
Prérequis
Obtenir l’exemple
Pour utiliser l’exemple d’application, clonez puis préparez le référentiel source à l’aide des commandes suivantes.
git clone https://github.com/spring-petclinic/spring-framework-petclinic.git
cd spring-framework-petclinic
Générer et exécuter l’exemple HSQLDB localement
Tout d’abord, nous allons tester l’exemple localement en utilisant HSQLDB comme base de données.
Créez la version HSQLDB de l’exemple d’application.
mvn package
Ensuite, définissez la variable d’environnement TOMCAT_HOME sur l’emplacement de votre installation Tomcat.
export TOMCAT_HOME=<Tomcat install directory>
Ensuite, mettez à jour le fichier pom.xml pour déployer le fichier WAR. Ajoutez le code XML suivant en tant qu’enfant de l’élément <plugins> existant. Si nécessaire, remplacez 1.9.11 par la version actuelle du plug-in Cargo Maven 3.
<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven3-plugin</artifactId>
<version>1.9.11</version>
<configuration>
<container>
<containerId>tomcat9x</containerId>
<type>installed</type>
<home>${TOMCAT_HOME}</home>
</container>
<configuration>
<type>existing</type>
<home>${TOMCAT_HOME}</home>
</configuration>
<deployables>
<deployable>
<groupId>${project.groupId}</groupId>
<artifactId>${project.artifactId}</artifactId>
<type>war</type>
<properties>
<context>/</context>
</properties>
</deployable>
</deployables>
</configuration>
</plugin>
Une fois cette configuration en place, vous pouvez déployer l’application localement sur Tomcat.
mvn cargo:deploy
Ensuite, lancez Tomcat.
${TOMCAT_HOME}/bin/catalina.sh run
Dans votre navigateur, vous pouvez maintenant accéder à http://localhost:8080 pour voir l’application en cours d’exécution et avoir une idée de son fonctionnement. Lorsque vous avez terminé, sélectionnez Ctrl+C à l’invite Bash pour arrêter Tomcat.
Déployer vers Azure App Service
Maintenant que vous avez vu comment elle s’exécute localement, nous allons déployer l’application sur Azure.
Tout d’abord, ajoutez les variables d’environnement suivantes. Pour REGION, utilisez West US 2 ou d’autres régions que vous trouverez ici.
export RESOURCEGROUP_NAME=<resource group>
export WEBAPP_NAME=<web app>
export WEBAPP_PLAN_NAME=${WEBAPP_NAME}-appservice-plan
export REGION=<region>
Maven utilise ces valeurs pour créer des ressources Azure qui porteront les noms que vous aurez fournis. Les variables d’environnement vous permettent de ne pas inclure les secrets de votre compte dans vos fichiers projet.
Ensuite, mettez à jour le fichier pom.xml afin de configurer Maven pour un déploiement Azure. Ajoutez le code XML suivant après l’élément <plugin> que vous avez ajouté précédemment. Si nécessaire, replacez 2.5.0 par la version actuelle du plug-in Maven pour Azure App Service.
<plugin>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure-webapp-maven-plugin</artifactId>
<version>2.5.0</version>
<configuration>
<schemaVersion>v2</schemaVersion>
<subscriptionId>${SUBSCRIPTION_ID}</subscriptionId>
<resourceGroup>${RESOURCEGROUP_NAME}</resourceGroup>
<appName>${WEBAPP_NAME}</appName>
<region>${REGION}</region>
<pricingTier>P1v2</pricingTier>
<runtime>
<os>Linux</os>
<javaVersion>Java 8</javaVersion>
<webContainer>TOMCAT 9.0</webContainer>
</runtime>
<deployment>
<resources>
<resource>
<directory>${project.basedir}/target</directory>
<includes>
<include>*.war</include>
</includes>
</resource>
</resources>
</deployment>
</configuration>
</plugin>
Ensuite, connectez-vous à Azure.
az login
À présent, déployez l’application sur App Service Linux.
mvn azure-webapp:deploy
Vous pouvez maintenant accéder à https://<app-name>.azurewebsites.net (après avoir remplacé <app-name>) pour voir l’application en cours d’exécution.
Configurer Azure Database pour MySQL
Maintenant, nous allons utiliser MySQL à la place de HSQLDB. Nous allons créer une instance de serveur MySQL sur Azure et ajouter une base de données. Ensuite, nous allons mettre à jour la configuration de l’application avec les nouvelles informations de connexion de base de données.
Commencez par définir les variables d’environnement suivantes afin de les utiliser dans les étapes ultérieures.
export MYSQL_SERVER_NAME=<server>
export MYSQL_SERVER_FULL_NAME=${MYSQL_SERVER_NAME}.mysql.database.azure.com
export MYSQL_SERVER_ADMIN_LOGIN_NAME=<admin>
export MYSQL_SERVER_ADMIN_PASSWORD=<password>
export MYSQL_DATABASE_NAME=<database>
export DOLLAR=\$
Ensuite, créez et initialisez le serveur de base de données. Utilisez la commande az mysql up pour la configuration initiale. Ensuite, utilisez la commande az mysql server configuration set pour augmenter le délai d’expiration de la connexion et définir le fuseau horaire du serveur.
az extension add --name db-up
az mysql up \
--resource-group ${RESOURCEGROUP_NAME} \
--server-name ${MYSQL_SERVER_NAME} \
--database-name ${MYSQL_DATABASE_NAME} \
--admin-user ${MYSQL_SERVER_ADMIN_LOGIN_NAME} \
--admin-password ${MYSQL_SERVER_ADMIN_PASSWORD}
az mysql server configuration set --name wait_timeout \
--resource-group ${RESOURCEGROUP_NAME} \
--server ${MYSQL_SERVER_NAME} --value 2147483
az mysql server configuration set --name time_zone \
--resource-group ${RESOURCEGROUP_NAME} \
--server ${MYSQL_SERVER_NAME} --value=-8:00
Utilisez ensuite l’interface CLI MySQL pour vous connecter à votre base de données sur Azure.
mysql -u ${MYSQL_SERVER_ADMIN_LOGIN_NAME}@${MYSQL_SERVER_NAME} \
-h ${MYSQL_SERVER_FULL_NAME} -P 3306 -p
À l’invite de commandes de l’interface CLI MySQL, exécutez la commande suivante pour vérifier votre base de données nommée avec la valeur que vous avez spécifiée précédemment pour la variable d’environnement MYSQL_DATABASE_NAME.
show databases;
MySQL est maintenant prêt à être utilisé.
Configurer l’application pour MySQL
Ensuite, nous allons ajouter les informations de connexion à la version MySQL de l’application, puis la déployer sur App Service.
Mettez à jour le fichier pom.xml pour que MySQL soit la configuration active. Supprimez l’élément <activation> du profil H2, puis placez-le dans le profil MySQL, comme indiqué ici. Le reste de l’extrait de code montre la configuration existante. Remarquez comment les variables d’environnement que vous avez définies précédemment sont utilisées par Maven pour configurer votre accès MySQL.
<profile>
<id>MySQL</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<db.script>mysql</db.script>
<jpa.database>MYSQL</jpa.database>
<jdbc.driverClassName>com.mysql.jdbc.Driver</jdbc.driverClassName>
<jdbc.url>jdbc:mysql://${DOLLAR}{MYSQL_SERVER_FULL_NAME}:3306/${DOLLAR}{MYSQL_DATABASE_NAME}?useUnicode=true</jdbc.url>
<jdbc.username>${DOLLAR}{MYSQL_SERVER_ADMIN_LOGIN_NAME}@${DOLLAR}{MYSQL_SERVER_FULL_NAME}</jdbc.username>
<jdbc.password>${DOLLAR}{MYSQL_SERVER_ADMIN_PASSWORD}</jdbc.password>
</properties>
...
</profile>
Ensuite, mettez à jour le fichier pom.xml afin de configurer Maven pour un déploiement Azure et pour l’utilisation de MySQL. Ajoutez le code XML suivant après l’élément <plugin> que vous avez ajouté précédemment. Si nécessaire, replacez 2.5.0 par la version actuelle du plug-in Maven pour Azure App Service.
<plugin>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure-webapp-maven-plugin</artifactId>
<version>2.5.0</version>
<configuration>
<schemaVersion>v2</schemaVersion>
<subscriptionId>${SUBSCRIPTION_ID}</subscriptionId>
<resourceGroup>${RESOURCEGROUP_NAME}</resourceGroup>
<appName>${WEBAPP_NAME}</appName>
<region>${REGION}</region>
<pricingTier>P1v2</pricingTier>
<runtime>
<os>Linux</os>
<javaVersion>Java 8</javaVersion>
<webContainer>TOMCAT 9.0</webContainer>
</runtime>
<appSettings>
<property>
<name>MYSQL_SERVER_FULL_NAME</name>
<value>${MYSQL_SERVER_FULL_NAME}</value>
</property>
<property>
<name>MYSQL_SERVER_ADMIN_LOGIN_NAME</name>
<value>${MYSQL_SERVER_ADMIN_LOGIN_NAME}</value>
</property>
<property>
<name>MYSQL_SERVER_ADMIN_PASSWORD</name>
<value>${MYSQL_SERVER_ADMIN_PASSWORD}</value>
</property>
<property>
<name>MYSQL_DATABASE_NAME</name>
<value>${MYSQL_DATABASE_NAME}</value>
</property>
</appSettings>
<deployment>
<resources>
<resource>
<directory>${project.basedir}/target</directory>
<includes>
<include>*.war</include>
</includes>
</resource>
</resources>
</deployment>
</configuration>
</plugin>
Ensuite, générez l’application, puis testez-la localement en la déployant et en l’exécutant avec Tomcat.
mvn package
mvn cargo:deploy
${TOMCAT_HOME}/bin/catalina.sh run
Vous pouvez désormais voir l’application localement à l’adresse http://localhost:8080. L’application conservera la même apparence et le même comportement, mais elle utilisera Azure Database pour MySQL au lieu de HSQLDB. Lorsque vous avez terminé, sélectionnez Ctrl+C à l’invite Bash pour arrêter Tomcat.
Enfin, déployez l’application sur App Service.
mvn azure-webapp:deploy
Vous pouvez maintenant accéder à https://<app-name>.azurewebsites.net pour voir l’application s’exécuter à l’aide d’App Service et d’Azure Database pour MySQL.
Accéder aux journaux des applications
Si vous devez résoudre des problèmes, vous pouvez consulter les journaux des applications. Pour ouvrir le flux de journaux distant sur votre ordinateur local, utilisez la commande suivante.
az webapp log tail --name ${WEBAPP_NAME} \
--resource-group ${RESOURCEGROUP_NAME}
Lorsque vous avez terminé d’afficher les journaux, sélectionnez Ctrl+C pour arrêter le flux.
Le flux de journaux est également disponible ici : https://<app-name>.scm.azurewebsites.net/api/logstream.
Scale-out
Pour prendre en charge l’augmentation du trafic vers votre application, vous pouvez effectuer un scale-out sur plusieurs instances à l’aide de la commande suivante.
az appservice plan update --number-of-workers 2 \
--name ${WEBAPP_PLAN_NAME} \
--resource-group ${RESOURCEGROUP_NAME}
Félicitations ! Vous avez créé une application web Java, puis vous avez effectué un scale-out pour celle-ci en utilisant Spring Framework, JSP, Spring Data, Hibernate, JDBC, App Service Linux et Azure Database pour MySQL.
Nettoyer les ressources
Au cours des étapes précédentes, vous avez créé des ressources Azure au sein d’un groupe de ressources. Si vous ne pensez pas avoir besoin de ces ressources à l’avenir, supprimez le groupe de ressources en exécutant la commande suivante.
az group delete --name ${RESOURCEGROUP_NAME}
Étapes suivantes
Ensuite, consultez les autres options de configuration et de CI/CD qui sont disponibles pour Java avec App Service.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour