Quickstart: Uw eerste Java Native Image-toepassing implementeren in Azure Spring Apps

Note

De Basic, Standarden Enterprise--plannen zijn op 17 maart 2025 buiten gebruik gesteld. Zie de aankondiging over buitengebruikstelling van Azure Spring Apps voor meer informatie.

Dit artikel is van toepassing op: ❎ Basic/Standard ✅ Enterprise

In deze quickstart wordt getoond hoe u een Spring Boot-toepassing implementeert in Azure Spring Apps als een Native Image.

Native Image-functionaliteit stelt u in staat Java-toepassingen te compileren naar zelfstandige uitvoerbare bestanden, ook wel Native Images genoemd. Deze uitvoerbare bestanden kunnen aanzienlijke voordelen bieden, waaronder snellere opstarttijden en lagere overhead van runtimegeheugen vergeleken met een traditionele JVM (Java Virtual Machine).

Het voorbeeldproject is de Spring Petclinic-toepassing. In de volgende schermopname ziet u de toepassing:

1. Vereisten

Een Azure-abonnement. Als u geen abonnement hebt, maakt u een gratis account voordat u begint.
Git.
Java Development Kit (JDK), versie 17.
Azure CLI versie 2.45.0 of hoger. Gebruik de volgende opdracht om de Azure Spring Apps-extensie te installeren: az extension add --name spring

2. Het Spring Petclinic-project voorbereiden

Gebruik de volgende stappen om de app lokaal te klonen en uit te voeren.

Gebruik de volgende opdracht om het Spring Petclinic-project te klonen vanuit GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Gebruik de volgende opdracht om het Spring Petclinic-project te bouwen:

cd spring-petclinic
./mvnw clean package -DskipTests -Pnative package

Gebruik de volgende opdracht om de Spring Petclinic-toepassing uit te voeren met behulp van Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Ga naar http://localhost:8080 in uw browser om toegang te krijgen tot de Spring Petclinic-toepassing.

3. De cloudomgeving voorbereiden

De belangrijkste resource die is vereist voor het uitvoeren van een Spring Petclinic-toepassing is een Azure Spring Apps-exemplaar. Deze sectie bevat de stappen voor het maken van de resource.

3.1. Namen opgeven voor elke resource

Maak variabelen voor het opslaan van de resourcenamen met behulp van de volgende opdrachten. Vervang de tijdelijke aanduidingen door uw eigen waarden.

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. Een nieuwe resourcegroep maken

Gebruik de volgende stappen om een nieuwe resourcegroep te maken:

Gebruik de volgende opdracht om u aan te melden bij de Azure CLI:
```
az login
```
Gebruik de volgende opdracht om de standaardlocatie in te stellen:
```
az configure --defaults location=${LOCATION}
```
Gebruik de volgende opdracht om alle beschikbare abonnementen weer te geven om de abonnements-id te bepalen die u wilt gebruiken:
```
az account list --output table
```
Gebruik de volgende opdracht om het standaardabonnement in te stellen:
```
az account set --subscription <subscription-ID>
```
Gebruik de volgende opdracht om een resourcegroep te maken:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Gebruik de volgende opdracht om de zojuist gemaakte resourcegroep in te stellen als de standaardresourcegroep:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Een Azure Spring Apps-exemplaar maken

Azure Spring Apps wordt gebruikt voor het hosten van de Spring Petclinic-app. Gebruik de volgende stappen om een Azure Spring Apps-exemplaar en twee toepassingen erin te maken:

Gebruik de volgende opdracht om een Azure Spring Apps-service-exemplaar te maken. Een native image build vereist 16 Gi aan geheugen tijdens het bouwen, dus configureer de buildpoolgrootte als S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Maak een builder-native.json-bestand in de huidige map en voeg de volgende inhoud toe:

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

Gebruik de volgende opdracht om een custom builder te maken voor het bouwen van de Native Image-toepassing.

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

Gebruik de volgende opdracht om een toepassing te maken in het Azure Spring Apps-exemplaar waarin u de Spring Petclinic-toepassing als JAR-bestand wilt implementeren. Configureer de geheugenlimiet op 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Gebruik het volgende commando om een toepassing te maken binnen het Azure Spring Apps-exemplaar waarin u de Spring Petclinic-toepassing als een Native Image wilt uitrollen.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. De app implementeren in Azure Spring Apps

Nu de cloudomgeving is voorbereid, zijn de toepassingen klaar om te implementeren.

Gebruik de volgende opdracht om de Spring Petclinic-toepassing als JAR-bestand te implementeren:

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

Gebruik de volgende opdracht om de Spring Petclinic-toepassing te implementeren als een 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. Native Image-app valideren

Nu hebt u toegang tot de geïmplementeerde Native Image-app om te zien of deze werkt. Voer de volgende stappen uit om te valideren:

Nadat de implementatie is voltooid, kunt u de volgende opdracht uitvoeren om de APP-URL op te halen:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
U kunt de app openen met de URL die wordt weergegeven in de uitvoer als Public Url. De pagina moet worden weergegeven zoals u deze hebt gezien op localhost.
Gebruik de volgende opdracht om het logboek van de app te controleren om een implementatieprobleem te onderzoeken:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Vergelijk de prestaties van JAR en Native Image

In de volgende secties wordt beschreven hoe u de prestaties tussen de JAR en de native image-implementatie kunt vergelijken.

Opstarttijd van de server

Gebruik de volgende opdracht om het logboek Started PetClinicApplication in XXX seconds van de app te controleren om de opstarttijd van de server voor een JAR-app op te halen:

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

De opstarttijd van de server is ongeveer 25 s voor een JAR-app.

Gebruik de volgende opdracht om het logboek van de app te inspecteren om de opstarttijd van de server voor een Native Image-app op te halen:

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

De server start binnen minder dan 0,5 s voor een Native Image-app.

Geheugengebruik

Gebruik de volgende opdracht om de geheugengrootte omlaag te schalen naar 512 Mi voor een Native Image app:

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

In de uitvoer van de opdracht moet worden weergegeven dat de Native Image-app met succes is gestart.

Gebruik de volgende opdracht om de geheugengrootte omlaag te schalen naar 512 Mi voor de JAR-app:

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

In de uitvoer van de opdracht moet worden weergegeven dat de JAR-app niet kon worden gestart vanwege onvoldoende geheugen. Het uitvoerbericht moet er ongeveer uitzien als in het volgende voorbeeld: Terminating due to java.lang.OutOfMemoryError: Java heap space.

In de volgende afbeelding ziet u het geoptimaliseerde geheugengebruik voor de implementatie van de Native Image-deployment voor een constante workload van 400 verzoeken per seconde in de Petclinic-applicatie. Het geheugengebruik is ongeveer 1/5e van het geheugen dat wordt verbruikt door de equivalente JAR-implementatie.

Native Images bieden snellere opstarttijden en verminderd geheugenverbruik tijdens runtime in vergelijking met de conventionele Java Virtual Machine (JVM).

7. Middelen opschonen

Als u van plan bent om verder te gaan met volgende introductiecursussen en tutorials, kunt u het beste deze middelen behouden. Wanneer u de resources niet meer nodig hebt, verwijdert u deze door de resourcegroep te verwijderen. Gebruik de volgende opdracht om de resourcegroep te verwijderen:

az group delete --name ${RESOURCE_GROUP}

8. Volgende stappen

Java Native Image-apps implementeren in het Azure Spring Apps Enterprise-plan

Gestructureerd toepassingslogboek voor Azure Spring Apps

Een bestaand aangepast domein toewijzen aan Azure Spring Apps

Azure Spring Apps CI/CD instellen met GitHub Actions

Azure Spring Apps CI/CD instellen met Azure DevOps

Beheerde identiteiten gebruiken voor toepassingen in Azure Spring Apps

Een serviceverbinding maken in Azure Spring Apps met de Azure CLI

De polyglot ACME Fitness Store-apps uitvoeren in Azure Spring Apps

Uw Spring Boot Native Image-toepassing monitoren

Zie de volgende artikelen voor meer informatie:

Feedback

Is deze pagina nuttig?

Last updated on 2025-10-31