Een Spring-app implementeren in App Service met MySQL

  • Artikel
  • 7 minuten om te lezen

In deze zelfstudie worden de ontwikkeling, configuratie, implementatie, probleemoplossing en schaling van Java-web-apps in App Service Linux stapsgewijs besproken.

In deze zelfstudie wordt gebruikgemaakt van de populaire Spring PetClinic-voorbeeld-app. In dit onderwerp test u lokaal een HSQLDB-versie van de app en implementeert u deze vervolgens in Azure App Service. Daarna configureert en implementeert u een versie die gebruikmaakt van Azure Database for MySQL. Ten slotte leert u hoe u toegang krijgt tot de logboeken van apps en deze kunt uitschalen door het aantal werkrollen te vergroten waarmee uw app wordt uitgevoerd.

Vereisten

Het voorbeeld ophalen

Om aan de slag te gaan met de voorbeeld-app moet u de bronopslagplaats klonen en voorbereiden met de volgende opdrachten.

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

Het HSQLDB-voorbeeld ontwikkelen en lokaal uitvoeren

Eerst testen we het voorbeeld lokaal met behulp van HSQLDB als de database.

Bouw de HSQLDB-versie van de voorbeeld-app.

mvn package

Stel vervolgens de TOMCAT_HOME-omgevingsvariabele in op de locatie van uw Tomcat-installatie.

export TOMCAT_HOME=<Tomcat install directory>

Werk vervolgens het pom.xml bij voor het implementeren van het WAR-bestand. Voeg de volgende XML toe als een onderliggend element van het bestaande element <plugins>. Wijzig indien nodig in 1.9.8 de huidige versie van de Cargo 1.9.8.

<plugin>
    <groupId>org.codehaus.cargo</groupId>
    <artifactId>cargo-maven3-plugin</artifactId>
    <version>1.9.8</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>

Als deze configuratie tot stand is gebracht, kunt u de app lokaal implementeren in Tomcat.

mvn cargo:deploy

Start vervolgens Tomcat.

${TOMCAT_HOME}/bin/catalina.sh run

U kunt nu in uw browser navigeren naar http://localhost:8080 om de actieve app te bekijken en te zien hoe deze werkt. Wanneer u klaar bent, selecteert u Ctrl+C in de Bash-prompt om Tomcat te stoppen.

Implementeren naar Azure App Service

Nu u hebt gezien hoe de app lokaal wordt uitgevoerd, implementeren we deze in Azure.

Stel eerst de volgende omgevingsvariabelen in. Gebruik REGION of andere West US 2 regio's REGIONvoor .

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

Maven gebruikt deze waarden om de Azure-resources te maken met de namen die u opgeeft. Met behulp van omgevingsvariabelen kunt u uw accountgeheimen uit uw projectbestanden houden.

Werk vervolgens het bestand pom.xml bij om Maven te configureren voor een Azure-implementatie. Voeg de volgende XML-code toe na het <plugin>-element dat u eerder hebt toegevoegd. Wijzig zo nodig 2.2.3 in de huidige versie van de 2.2.3.

<plugin>
  <groupId>com.microsoft.azure</groupId>
  <artifactId>azure-webapp-maven-plugin</artifactId>
  <version>2.2.3</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>

Meld u daarna aan bij Azure.

az login

Implementeer vervolgens de app in App Service Linux.

mvn azure-webapp:deploy

U kunt nu naar https://<app-name>.azurewebsites.net navigeren (nadat u <app-name> hebt vervangen) om de actieve app te bekijken.

Azure Database for MySQL instellen

Vervolgens gaan we MySQL gebruiken in plaats van HSQLDB. We maken een MySQL-serverinstantie in Azure en voegen een database toe. Vervolgens werken we de app-configuratie bij met de verbindingsgegevens van de nieuwe database.

Stel eerst de volgende omgevingsvariabelen in zodat u deze in latere stappen kunt gebruiken.

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

Maak daarna de databaseserver en initialiseer deze. Gebruik az mysql up voor de eerste configuratie. Gebruik vervolgens az mysql server configuration set om de time-out voor de verbinding te verhogen en de tijdzone voor de server in te stellen.

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

Gebruik vervolgens de MySQL CLI om verbinding te maken met uw database in Azure.

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

Voer bij de MySQL CLI-prompt de volgende opdracht uit om uw database met de naam te controleren met dezelfde waarde die u eerder hebt opgegeven voor de MYSQL_DATABASE_NAME omgevingsvariabele.

show databases;

MySQL is nu klaar voor gebruik.

De app voor MySQL configureren

Vervolgens voegen we de verbindingsgegevens toe aan de MySQL-versie van de app en implementeren we deze vervolgens in App Service.

Werk het pom.xml bij om van MySQL de actieve configuratie te maken. Verwijder het <activation> element uit het H2-profiel en plaats het in plaats daarvan in het MySQL-profiel, zoals hier wordt weergegeven. In de rest van het fragment wordt de bestaande configuratie weergegeven. De omgevingsvariabelen die u eerder hebt ingesteld, worden door Maven gebruikt voor het configureren van uw MySQL-toegang.

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

Werk vervolgens het bestand pom.xml bij om Maven te configureren voor een Azure-implementatie en voor gebruik van MySQL. Voeg de volgende XML-code toe na het <plugin>-element dat u eerder hebt toegevoegd. Wijzig zo nodig 2.2.3 in de huidige versie van de 2.2.3.

<plugin>
  <groupId>com.microsoft.azure</groupId>
  <artifactId>azure-webapp-maven-plugin</artifactId>
  <version>2.2.3</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>

Vervolgens ontwikkelt u de app en test u deze lokaal door de app met Tomcat te implementeren en uit te voeren.

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

U kunt de app nu lokaal weergeven op http://localhost:8080. De app heeft hetzelfde uiterlijk en gedrag als voorheen, maar maakt gebruik van Azure Database for MySQL in plaats van HSQLDB. Wanneer u klaar bent, selecteert u Ctrl+C in de Bash-prompt om Tomcat te stoppen.

Implementeer ten slotte de app in App Service.

mvn azure-webapp:deploy

U kunt nu naar https://<app-name>.azurewebsites.net navigeren om de actieve app te bekijken met behulp van App Service en Azure Database for MySQL.

Toegang verkrijgen tot de app-logboeken

Als u problemen moet oplossen, kunt u de logboeken van de app bekijken. Gebruik de volgende opdracht om de externe logboekstroom op uw lokale computer te openen.

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

Wanneer u klaar bent met het bekijken van de logboeken, selecteert u Ctrl+C om de stroom te stoppen.

De logboekstroom is ook beschikbaar op https://<app-name>.scm.azurewebsites.net/api/logstream.

Uitschalen

Als u meer verkeer naar uw app mogelijk wilt maken, kunt u uitschalen naar meerdere instanties met behulp van de volgende opdracht.

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

Gefeliciteerd U hebt een Java-web-app ontwikkeld en uitgeschaald met behulp van Spring Framework, JSP, Spring Data, Hibernate, JDBC, App Service Linux en Azure Database for MySQL.

Resources opschonen

In de voorgaande secties hebt u Azure-resources in een resourcegroep gemaakt. Als u denkt dat u deze resources niet meer gaat gebruiken, verwijdert u de resourcegroep door de volgende opdracht uit te voeren.

az group delete --name ${RESOURCEGROUP_NAME}

Volgende stappen

Bekijk vervolgens de andere configuratie- en CI/CD-opties die voor Java met App Service beschikbaar zijn.

Een Linux Java-app voor Azure App Service configureren

Een Java-web-app ontwikkelen en implementeren met Azure Pipelines

Implementeren in Azure App Service met behulp van de Jenkins-invoegtoepassing