Schnellstart: Bereitstellen Ihres ersten Java Native-Images in Azure Spring Apps

Artikel
10/04/2024

Hinweis

Die Pläne Basic, Standard und Enterprise gelten ab Mitte März 2025 als veraltet und werden über einen Zeitraum von drei Jahren eingestellt. Es wird empfohlen, auf Azure Container Apps umzustellen. Weitere Informationen finden Sie in der Ankündigung zur Einstellung von Azure Spring Apps.

Der Plan Standardverbrauch und dediziert gilt ab dem 30. September 2024 als veraltet und wird nach sechs Monaten vollständig eingestellt. Es wird empfohlen, auf Azure Container Apps umzustellen. Weitere Informationen finden Sie unter Migrieren des Plans „Standardverbrauch und dediziert“ von Azure Spring Apps zu Azure Container Apps.

Dieser Artikel gilt für:❌ Basic/Standard ✔️ Enterprise

In dieser Schnellstartanleitung wird gezeigt, wie Sie eine Spring Boot-Web-App als Native-Image in Azure Spring Apps bereitstellen.

Mit der Funktion Native Image (natives Image) können Sie Java-Anwendungen in eigenständige ausführbare Dateien kompilieren, die als „Native Images“ bezeichnet werden. Diese ausführbaren Dateien können erhebliche Vorteile wie schnellere Startzeit und geringere Speicherauslastung für die Laufzeit im Vergleich zu einer herkömmlichen JVM (Java Virtual Machine) bieten.

Das Beispielprojekt ist die Spring Petclinic-Anwendung. Der folgende Screenshot zeigt die App:

1. Voraussetzungen

Ein Azure-Abonnement. Wenn Sie kein Abonnement besitzen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.
Git.
Java Development Kit (JDK), Version 17.
Azure CLI (ab Version 2.45.0) Verwenden Sie den folgenden Befehl, um die Azure Spring Apps-Erweiterung zu installieren: az extension add --name spring
Wenn Sie eine Azure Spring Apps Enterprise-Planinstanz zum ersten Mal im Zielabonnement bereitstellen, finden Sie Informationen hierzu unter Anzeigen des Azure Spring Apps Enterprise-Dienstebenenangebots in Azure Marketplace im Abschnitt Voraussetzungen.

2. Vorbereiten des Spring Petclinic-Projekts

Führen Sie die folgenden Schritte aus, um die App zu klonen und lokal auszuführen.

Führen Sie den folgenden Befehl aus, um das Spring Petclinic-Projekt von GitHub zu klonen:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```
Verwenden Sie den folgenden Befehl, um das Spring Petclinic-Projekt zu erstellen:
```
cd spring-petclinic
./mvnw clean package -DskipTests -Pnative package
```
Verwenden Sie den folgenden Befehl, um die Spring Petclinic-App mithilfe von Maven auszuführen:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Wechseln Sie in Ihrem Browser zu http://localhost:8080, um auf die Spring Petclinic-Anwendung zuzugreifen.

3. Cloudumgebung vorbereiten

Die wichtigste Ressource, die zum Ausführen der Spring Petclinic-Anwendung erforderlich ist, ist eine Azure Spring Apps-Instanz. Dieser Abschnitt beschreibt die Schritte zum Erstellen der Ressource.

3.1. Geben Sie einen Namen für jede Ressource an.

Erstellen Sie Variablen zur Aufnahme der Ressourcennamen, indem Sie die folgenden Befehle verwenden. Ersetzen Sie die Platzhalter durch Ihre eigenen Werte.

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. Erstellen einer neuen Ressourcengruppe

Führen Sie die folgenden Schritte aus, um eine neue Ressourcengruppe zu erstellen:

Verwenden Sie den folgenden Befehl, um sich bei der Azure CLI anzumelden:
```
az login
```
Verwenden Sie den folgenden Befehl, um den Standardspeicherort festzulegen:
```
az configure --defaults location=${LOCATION}
```
Verwenden Sie den folgenden Befehl, um alle verfügbaren Abonnements aufzulisten, um die zu verwendende Abonnement-ID zu bestimmen:
```
az account list --output table
```
Verwenden Sie den folgenden Befehl, um das Standardabonnement festzulegen:
```
az account set --subscription <subscription-ID>
```
Verwenden Sie den folgenden Befehl, um eine Ressourcengruppe zu erstellen:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Verwenden Sie den folgenden Befehl, um die neu erstellte Ressourcengruppe als Standardressourcengruppe festzulegen:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Erstellen einer Azure Spring Apps-Instanz

Azure Spring Apps wird als Host für die Spring Petclinic-App verwendet. Führen Sie die folgenden Schritte aus, um eine Azure Spring Apps-Instanz mit zwei darin enthaltenen Apps zu erstellen:

Verwenden Sie den folgenden Befehl, um eine Azure Spring Apps-Dienstinstanz zu erstellen: Eine native Imageerstellung erfordert während der Imageerstellung 16 Gi Arbeitsspeicher. Konfigurieren Sie daher die Poolgröße des Builds mit „S7“.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Erstellen Sie im aktuellen Verzeichnis eine builder-native.json-Datei, und fügen Sie dann den folgenden Inhalt hinzu:

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

Verwenden Sie den folgenden Befehl, um einen benutzerdefinierten Generator zum Erstellen der Native Image-App zu erstellen:

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

Verwenden Sie den folgenden Befehl, um eine Anwendung in der Azure Spring Apps-Instanz zu erstellen, in der die Spring Petclinic-App als JAR-Datei bereitgestellt wird. Konfigurieren Sie das Arbeitsspeicherlimit auf 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Verwenden Sie den folgenden Befehl, um eine Anwendung in der Azure Spring Apps-Instanz zu erstellen, in der die Spring Petclinic-App als Native Image bereitgestellt wird:
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Bereitstellen der App in Azure Spring Apps

Nachdem die Cloudumgebung nun vorbereitet ist, kann die App bereitgestellt werden.

Verwenden Sie den folgenden Befehl, um die Spring Petclinic-App als JAR-Datei bereitzustellen:

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

Verwenden Sie den folgenden Befehl, um die Spring Petclinic-App als Native Image-Datei bereitzustellen:

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. Überprüfen der Native Image-App

Sie können jetzt auf die bereitgestellte Native Image-App zugreifen, um festzustellen, ob sie funktioniert. Verwenden Sie die folgenden Schritte zur Überprüfung:

Nach Abschluss der Bereitstellung können Sie den folgenden Befehl ausführen, um die App-URL abzurufen:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Sie können mithilfe der URL, die in der Ausgabe als Public Urlangezeigt wird, auf die App zugreifen. Die Seite sollte wie in Localhost angezeigt werden.
Verwenden Sie den folgenden Befehl, um das Protokoll der App zu überprüfen, um Bereitstellungsprobleme zu untersuchen:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Vergleichen der Leistung von JAR und Native Image

In den folgenden Abschnitten wird beschrieben, wie Sie die Leistung der Bereitstellung von JAR und Native Image vergleichen.

Serverstartzeit

Verwenden Sie den folgenden Befehl, um das App-Protokoll Started PetClinicApplication in XXX seconds zu überprüfen, um die Serverstartzeit für eine JAR-App zu erhalten:

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

Die Serverstartzeit beträgt etwa 25 Sek. für eine JAR-App.

Verwenden Sie den folgenden Befehl, um das App-Protokoll zu überprüfen, um die Serverstartzeit für eine Native Image-App zu erhalten:

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

Die Startzeit des Servers beträgt weniger als 0,5 Sek. für eine Native Image-App.

Speicherauslastung

Verwenden Sie den folgenden Befehl, um die Arbeitsspeichergröße für eine Native Image-App auf 512 Mi herunterzuskalieren:

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

Die Befehlsausgabe sollte zeigen, dass die Native Image-App erfolgreich gestartet wurde.

Verwenden Sie den folgenden Befehl, um die Arbeitsspeichergröße für die JAR-App auf 512 Mi herunterzuskalieren:

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

Die Befehlsausgabe sollte anzeigen, dass die JAR-App aufgrund von unzureichendem Arbeitsspeicher nicht gestartet werden konnte. Die ausgegebene Meldung sollte ungefähr wie das folgende Beispiel aussehen: Terminating due to java.lang.OutOfMemoryError: Java heap space.

Die folgende Abbildung zeigt die optimierte Speicherauslastung für die Native Image-Bereitstellung für einen konstanten Workload mit 400 Anforderungen pro Sekunde in der Petclinic-App. Die Speicherauslastung beträgt etwa ein Fünftel des Arbeitsspeichers, der von der entsprechenden JAR-Bereitstellung verbraucht wird.

Native Images bieten im Vergleich zur herkömmlichen Java Virtual Machine (JVM) schnellere Startzeiten und eine geringere Speicherauslastung für die Laufzeit.

7. Bereinigen von Ressourcen

Falls Sie mit weiteren Schnellstartanleitungen und Tutorials fortfahren möchten, sollten Sie die Ressourcen nicht bereinigen. Wenn Sie die Ressourcen nicht mehr benötigen, löschen Sie sie, indem Sie die Ressourcengruppe löschen. Führen Sie den folgenden Befehl aus, um die Ressourcengruppe zu löschen:

az group delete --name ${RESOURCE_GROUP}

8. Nächste Schritte

Bereitstellen von Java Native Image-Apps im Azure Spring Apps-Enterprise-Plan

Strukturiertes Anwendungsprotokoll für Azure Spring Apps

Zuordnen einer vorhandenen benutzerdefinierten Domäne zu Azure Spring Apps

Einrichten von Azure Spring Apps-CI/CD mit GitHub Actions

Verwenden verwalteter Identitäten für Anwendungen in Azure Spring Apps

Erstellen einer Dienstverbindung in Azure Spring Apps mit der Azure-Befehlszeilenschnittstelle

Ausführen der mehrsprachigen ACME-Fitness Store-Apps in Azure Spring Apps

Überwachen Ihrer systemeigenen Spring Boot Image-Anwendung

Weitere Informationen finden Sie in den folgenden Artikeln:

Teilen über