Snabbstart: Distribuera ditt första Java Native Image-program till Azure Spring Apps

Artikel
10/01/2024

Kommentar

Basic-, Standard- och Enterprise-planerna kommer att vara inaktuella från och med mitten av mars 2025, med en 3-årig pensionsperiod. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i meddelandet om azure Spring Apps-pensionering.

Standardförbrukningen och den dedikerade planen kommer att vara inaktuell från och med den 30 september 2024, med en fullständig avstängning efter sex månader. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i Migrera Azure Spring Apps Standard-förbrukning och dedikerad plan till Azure Container Apps.

Den här artikeln gäller för:❌ Basic/Standard ✔️ Enterprise

Den här snabbstarten visar hur du distribuerar ett Spring Boot-program till Azure Spring Apps som en intern avbildning.

Med funktionen Native Image kan du kompilera Java-program till fristående körbara filer, så kallade interna avbildningar. Dessa körbara filer kan ge betydande fördelar, inklusive snabbare starttider och lägre minneskostnader för körning jämfört med en traditionell JVM (Java Virtual Machine).

Exempelprojektet är Spring Petclinic-programmet. Följande skärmbild visar programmet:

1. Förutsättningar

En Azure-prenumeration Om du inte har någon prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Git.
Java Development Kit (JDK), version 17.
Azure CLI version 2.45.0 eller senare. Använd följande kommando för att installera Azure Spring Apps-tillägget: az extension add --name spring
Om du distribuerar en Azure Spring Apps Enterprise-planinstans för första gången i målprenumerationen läser du avsnittet Krav i Visa Azure Spring Apps Enterprise-nivåerbjudande på Azure Marketplace.

2. Förbereda Spring Petclinic-projektet

Använd följande steg för att klona och köra appen lokalt.

Använd följande kommando för att klona Spring Petclinic-projektet från GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Använd följande kommando för att skapa Spring Petclinic-projektet:

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

Använd följande kommando för att köra Spring Petclinic-programmet med hjälp av Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Gå till http://localhost:8080 i webbläsaren för att få åtkomst till Spring Petclinic-programmet.

3. Förbereda molnmiljön

Den viktigaste resursen som krävs för att köra Spring Petclinic-programmet är en Azure Spring Apps-instans. Det här avsnittet innehåller stegen för att skapa resursen.

3.1. Ange namn för varje resurs

Skapa variabler för att lagra resursnamnen med hjälp av följande kommandon. Se till att ersätta platshållarna med dina egna värden.

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. Skapa en ny resursgrupp

Använd följande steg för att skapa en ny resursgrupp:

Använd följande kommando för att logga in på Azure CLI:
```
az login
```
Använd följande kommando för att ange standardplatsen:
```
az configure --defaults location=${LOCATION}
```
Använd följande kommando för att lista alla tillgängliga prenumerationer för att fastställa vilket prenumerations-ID som ska användas:
```
az account list --output table
```
Använd följande kommando för att ange standardprenumerationen:
```
az account set --subscription <subscription-ID>
```
Använd följande kommando för att skapa en resursgrupp:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Använd följande kommando för att ange den nyligen skapade resursgruppen som standardresursgrupp:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Skapa en Azure Spring Apps-instans

Azure Spring Apps används som värd för Spring Petclinic-appen. Använd följande steg för att skapa en Azure Spring Apps-instans och två program i den:

Använd följande kommando för att skapa en Azure Spring Apps-tjänstinstans. En inbyggd avbildningsversion kräver 16 Gi minne under avbildningsbygget, så konfigurera storlek på byggpoolen som S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Skapa en builder-native.json fil i den aktuella katalogen och lägg sedan till följande innehåll:

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

Använd följande kommando för att skapa en anpassad byggare för att skapa det interna avbildningsprogrammet:

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

Använd följande kommando för att skapa ett program i Azure Spring Apps-instansen där du kan distribuera Spring Petclinic-programmet som en JAR-fil. Konfigurera minnesgränsen till 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

Använd följande kommando för att skapa ett program i Azure Spring Apps-instansen där du distribuerar Spring Petclinic-programmet som en intern avbildning:

az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true

4. Distribuera appen till Azure Spring Apps

Nu när molnmiljön har förberetts är programmen redo att distribueras.

Använd följande kommando för att distribuera Spring Petclinic-programmet som en JAR-fil:

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

Använd följande kommando för att distribuera Spring Petclinic-programmet som en intern avbildning:

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. Verifiera intern avbildningsapp

Nu kan du komma åt den distribuerade native image-appen för att se om den fungerar. Använd följande steg för att verifiera:

När distributionen har slutförts kan du köra följande kommando för att hämta appens URL:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Du kan komma åt appen med url:en som visas i utdata som Public Url. Sidan bör visas som du såg den o localhost.
Använd följande kommando för att kontrollera appens logg för att undersöka eventuella distributionsproblem:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Jämför prestanda för JAR och intern avbildning

I följande avsnitt beskrivs hur du jämför prestanda mellan JAR-distribution och distribution av intern avbildning.

Starttid för server

Använd följande kommando för att kontrollera appens logg Started PetClinicApplication in XXX seconds för att hämta serverns starttid för en JAR-app:

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

Serverns starttid är cirka 25 s för en JAR-app.

Använd följande kommando för att kontrollera appens logg för att få starttiden för servern för en intern avbildningsapp:

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

Serverns starttid är mindre än 0,5 s för en intern avbildningsapp.

Minnesanvändning

Använd följande kommando för att skala ned minnesstorleken till 512 Mi för en intern avbildningsapp:

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

Kommandoutdata bör visa att appen Intern avbildning har startats.

Använd följande kommando för att skala ned minnesstorleken till 512 Mi för JAR-appen:

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

Kommandoutdata bör visa att JAR-appen inte kunde starta på grund av otillräckligt minne. Utdatameddelandet bör likna följande exempel: Terminating due to java.lang.OutOfMemoryError: Java heap space.

Följande bild visar den optimerade minnesanvändningen för distributionen av den interna avbildningen för en konstant arbetsbelastning på 400 begäranden per sekund i Petclinic-programmet. Minnesanvändningen är ungefär 1/5 av det minne som förbrukas av motsvarande JAR-distribution.

Interna avbildningar ger snabbare starttider och minskade minneskostnader för körning jämfört med den konventionella Virtuella Java-datorn (JVM).

7. Rensa resurser

Om du planerar att fortsätta arbeta med efterföljande snabbstarter och självstudier kanske du vill lämna dessa resurser på plats. När du inte längre behöver resurserna tar du bort dem genom att ta bort resursgruppen. Använd följande kommando för att ta bort resursgruppen:

az group delete --name ${RESOURCE_GROUP}

8. Nästa steg

Distribuera Java Native Image-appar i Azure Spring Apps Enterprise-planen

Strukturerad programlogg för Azure Spring Apps

Mappa en befintlig anpassad domän till Azure Spring Apps

Konfigurera Azure Spring Apps CI/CD med GitHub Actions

Konfigurera Azure Spring Apps CI/CD med Azure DevOps

Använda hanterade identiteter för program i Azure Spring Apps

Skapa en tjänstanslutning i Azure Spring Apps med Azure CLI

Köra de flerspråkiga ACME-apparna för fitnessbutik i Azure Spring Apps

Övervaka ditt Spring Boot Native Image-program

Mer information finns i följande artiklar:

Dela via