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

Kommentar

Planerna Basic, Standardoch Enterprise gick in i en pensionsperiod den 17 mars 2025. Mer information finns i meddelandet om azure Spring Apps-pensionering.

Den här artikeln gäller för: ❎ Basic/Standard ✅ Enterprise

Den här snabbstarten visar hur du distribuerar en Spring Boot-applikation till Azure Spring Apps som en native image.

Native Image-funktionalitet gör att du kan kompilera Java-applikationer till fristående körbara filer, kända som Native Images. 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

2. Förbereda Spring Petclinic-projektet

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

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

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

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

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

4. 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:

1. Använd följande kommando för att logga in på Azure CLI:

   az login
   

2. Använd följande kommando för att ange standardplatsen:

   az configure --defaults location=${LOCATION}
   

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

4. Använd följande kommando för att ange standardprenumerationen:

   az account set --subscription <subscription-ID>
   

5. Använd följande kommando för att skapa en resursgrupp:

   az group create --resource-group ${RESOURCE_GROUP}
   

6. 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:

1. Använd följande kommando för att skapa en Azure Spring Apps-tjänstinstans. En inhemsk bildversion kräver 16 GiB minne under bildskapandet, konfigurera därför byggpoolens storlek till S7.

   az spring create \
       --name ${AZURE_SPRING_APPS_NAME} \
       --sku enterprise \
       --build-pool-size S7
   

2. 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"
            }
          ]
        }
      ]
    }  
   

3. Använd följande kommando för att skapa en anpassad byggare för att bygga Native Image-applikationen:

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

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

5. Använd följande kommando för att skapa en applikation i en instans av Azure Spring Apps för att distribuera Spring Petclinic-applikationen som en Native Image.

   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 köra Spring Petclinic-applikationen som en 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. Verifiera ursprunglig bildapp

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:

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

2. 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 native avbild

I följande avsnitt beskrivs hur man jämför prestanda mellan JAR-distribution och Native Image-distribution.

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 och få starttiden för servern för en Native Image-app.

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

Serverns starttid är mindre än 0,5 s för en Native Image-app.

Minnesanvändning

Använd följande kommando för att skala ned minnesstorleken till 512 Mi för en Native Image-app:

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

Kommandoutdata bör visa att Native Image-appen har startats framgångsrikt.

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 Native Image för en konstant arbetsbelastning på 400 begäranden per sekund i Petclinic-applikationen. Minnesanvändningen är ungefär 1/5 av det minne som förbrukas av motsvarande JAR-distribution.

Native-bilder erbjuder snabbare starttider och minskad minnesbelastning under körning jämfört med den konventionella Java Virtual Machine (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ör ACME:s flerspråkiga fitnessbutiksappar på Azure Spring Apps

Övervaka ditt Spring Boot Native Image-program

Mer information finns i följande artiklar:

• Azure Spring Apps-exempel.
• Spring på Azure
• Spring Cloud Azure