Distribuire un'app Spring nel servizio app con MySQL

  • Articolo

Nota

Per le applicazioni Spring, è consigliabile usare Azure Spring Apps. Tuttavia, è comunque possibile usare app Azure Servizio come destinazione. Per altre informazioni, vedere Scegliere i servizi di Azure corretti per le applicazioni Java.

Questa esercitazione illustra il processo per compilare, configurare, distribuire e ridimensionare app Web Java nel servizio app per Linux e risolverne i problemi.

L'esercitazione si basa sulla popolare app di esempio Spring PetClinic. In questo argomento si testerà una versione HSQLDB dell'app in locale e quindi la si distribuirà nel servizio app Azure. Successivamente, si configurerà e si distribuirà una versione che usa Database di Azure per MySQL. Infine, si apprenderà come accedere ai log dell'app e aumentare il numero di ruoli di lavoro che eseguono l'app.

Prerequisiti

Ottenere l'esempio

Per iniziare a usare l'app di esempio, clonare e preparare il repository di origine con i comandi seguenti.

git clone https://github.com/spring-petclinic/spring-framework-petclinic.git
cd spring-framework-petclinic

Compilare ed eseguire l'esempio HSQLDB in locale

Per prima cosa si testerà l'esempio in locale usando HSQLDB come database.

Creare la versione HSQLDB dell'app di esempio.

mvn package

Successivamente, impostare la variabile di ambiente TOMCAT_HOME sul percorso dell'installazione di Tomcat.

export TOMCAT_HOME=<Tomcat install directory>

Aggiornare quindi il file pom.xml per la distribuzione del file WAR. Aggiungere il codice XML seguente come figlio dell'elemento <plugins> esistente. Se necessario, passare 1.9.11 alla versione corrente del 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>

Dopo aver implementato questa configurazione, è possibile distribuire l'app localmente in Tomcat.

mvn cargo:deploy

Avviare quindi Tomcat.

${TOMCAT_HOME}/bin/catalina.sh run

È ora possibile passare con il browser a http://localhost:8080 per visualizzare l'app in esecuzione e acquisire familiarità con il funzionamento. Al termine, selezionare CTRL+C al prompt di Bash per arrestare Tomcat.

Distribuire nel Servizio app di Azure

Dopo averne osservato l'esecuzione in locale, si distribuirà l'app in Azure.

Per prima cosa, impostare le variabili di ambiente seguenti. Per REGION, usare West US 2 o altre aree disponibili qui.

export RESOURCEGROUP_NAME=<resource group>
export WEBAPP_NAME=<web app>
export WEBAPP_PLAN_NAME=${WEBAPP_NAME}-appservice-plan
export REGION=<region>

Maven userà questi valori per creare le risorse di Azure con i nomi specificati. Usando le variabili di ambiente, è possibile mantenere i segreti dell'account al di fuori dei file di progetto.

Aggiornare quindi il file pom.xml per configurare Maven per una distribuzione di Azure. Aggiungere il codice XML seguente dopo l'elemento <plugin> aggiunto in precedenza. Se necessario, sostituire 2.5.0 con la versione corrente del plug-in Maven per il servizio app di Azure.

<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>

Successivamente, accedere ad Azure.

az login

Distribuire quindi l'app nel servizio app per Linux.

mvn azure-webapp:deploy

È ora possibile passare a https://<app-name>.azurewebsites.net (dopo aver sostituito <app-name>) per visualizzare l'app in esecuzione.

Configurare Database di Azure per MySQL

Successivamente si userà MySQL al posto di HSQLDB. Si creerà un'istanza del server MySQL in Azure e si aggiungerà un database, quindi si aggiornerà la configurazione dell'app con le nuove informazioni di connessione al database.

Per prima cosa, impostare le variabili di ambiente seguenti, necessarie nei passaggi successivi.

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=\$

Creare e inizializzare quindi il server di database. Usare az mysql up per la configurazione iniziale. Usare quindi az mysql server configuration set per aumentare il timeout della connessione e impostare il fuso orario del server.

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

Quindi, usare l'interfaccia della riga di comando di MySQL per connettersi al database in Azure.

mysql -u ${MYSQL_SERVER_ADMIN_LOGIN_NAME}@${MYSQL_SERVER_NAME} \
 -h ${MYSQL_SERVER_FULL_NAME} -P 3306 -p

Al prompt dell'interfaccia della riga di comando di MySQL eseguire questo comando per verificare che il database abbia lo stesso nome del valore specificato in precedenza per la variabile di ambiente MYSQL_DATABASE_NAME.

show databases;

MySQL è ora pronto per l'uso.

Configurare l'app per MySQL

Successivamente si aggiungeranno le informazioni di connessione alla versione MySQL dell'app e quindi si eseguirà la distribuzione nel servizio app.

Aggiornare il file pom.xml per impostare MySQL come configurazione attiva. Rimuovere l'elemento <activation> dal profilo H2 e inserirlo nel profilo MySQL, come illustrato di seguito. Il resto del frammento mostra la configurazione esistente. Si noti come le variabili di ambiente impostate in precedenza vengono usate da Maven per configurare l'accesso a 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>

Aggiornare quindi il file pom.xml per configurare Maven per una distribuzione di Azure e per l'uso di MySQL. Aggiungere il codice XML seguente dopo l'elemento <plugin> aggiunto in precedenza. Se necessario, sostituire 2.5.0 con la versione corrente del plug-in Maven per il servizio app di Azure.

<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>

Successivamente, compilare l'app e quindi testarla in locale distribuendola ed eseguendola con Tomcat.

mvn package
mvn cargo:deploy
${TOMCAT_HOME}/bin/catalina.sh run

È ora possibile visualizzare l'app in locale all'indirizzo http://localhost:8080. L'app avrà lo stesso aspetto e lo stesso comportamento osservati in precedenza, ma userà Database di Azure per MySQL anziché HSQLDB. Al termine, selezionare CTRL+C al prompt di Bash per arrestare Tomcat.

Distribuire infine l'app nel servizio app.

mvn azure-webapp:deploy

È ora possibile passare a https://<app-name>.azurewebsites.net per visualizzare l'app in esecuzione con il servizio app e Database di Azure per MySQL.

Accedere ai log dell'app

Se è necessario risolvere problemi, è possibile esaminare i log dell'app. Per aprire il flusso remoto di log nel computer locale, usare il comando seguente.

az webapp log tail --name ${WEBAPP_NAME} \
    --resource-group ${RESOURCEGROUP_NAME}

Al termine della visualizzazione dei log, selezionare CTRL+C per arrestare il flusso.

Il flusso di log è disponibile anche all'indirizzo https://<app-name>.scm.azurewebsites.net/api/logstream.

Aumentare il numero di istanze

Per supportare un maggiore traffico verso l'app, è possibile aumentare il numero di istanze con il comando seguente.

az appservice plan update --number-of-workers 2 \
    --name ${WEBAPP_PLAN_NAME} \
    --resource-group ${RESOURCEGROUP_NAME}

Complimenti. È stata compilata un'app Web Java e ne è stato aumentato il numero di istanze usando Spring Framework, JSP, Spring Data, Hibernate, JDBC, il servizio app per Linux e Database di Azure per MySQL.

Pulire le risorse

Nelle sezioni precedenti sono state create risorse di Azure in un gruppo di risorse. Se non si prevede di usare queste risorse in futuro, eliminare il gruppo di risorse eseguendo questo comando:

az group delete --name ${RESOURCEGROUP_NAME}

Passaggi successivi

Successivamente, vedere le altre opzioni di configurazione e CI/CD disponibili per Java con il servizio app.

Configurare un'app Java in Linux per il servizio app di Azure

Compilare e distribuire un'app Web Java con Azure Pipelines

Eseguire la distribuzione nel servizio app di Azure con il plug-in Jenkins