Rövid útmutató: Az első Java Native Image-alkalmazás üzembe helyezése az Azure Spring Appsben

Feljegyzés

A Alapszintű, Standardés Enterprise tervek 2025. március 17-én nyugdíjazási időszakba léptek. További információkért lásd az Azure Spring Apps kivonási bejelentését.

Ez a cikk a következőre vonatkozik: ❎ Basic/Standard ✅ Enterprise

Ez a rövid útmutató bemutatja, hogyan helyezhet üzembe Spring Boot-alkalmazást natív rendszerképként az Azure Spring Appsben.

A Natív kép funkcióval Java-alkalmazásokat fordíthat önálló végrehajtható fájlokra, más néven natív képekre. Ezek a végrehajtható fájlok jelentős előnyökkel járhatnak, beleértve a gyorsabb indítási időket és a kisebb futtatási memóriahasználatot a hagyományos JVM-hez (Java Virtuális Géphez) képest.

A mintaprojekt a Spring Petclinic alkalmazás. Az alábbi képernyőképen az alkalmazás látható:

1. Előfeltételek

• Azure-előfizetés. Ha nem rendelkezik előfizetéssel, a kezdés előtt hozzon létre egy ingyenes fiókot .
• Git.
• Java Development Kit (JDK) 17-es verzió.
• Az Azure CLI 2.45.0-s vagy újabb verziója. Az Azure Spring Apps bővítmény telepítéséhez használja a következő parancsot: az extension add --name spring

2. A Spring Petclinic projekt előkészítése

Az alkalmazás helyi klónozásához és futtatásához kövesse az alábbi lépéseket.

1. Az alábbi paranccsal klónozza a Spring Petclinic projektet a GitHubról:

   git clone https://github.com/Azure-Samples/spring-petclinic.git
   

2. A Spring Petclinic projekt létrehozásához használja a következő parancsot:

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

3. Futtassa a Spring Petclinic alkalmazást a Maven használatával a következő paranccsal:

   java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
   

4. Nyissa meg http://localhost:8080 a böngészőben a Spring Petclinic alkalmazást.

3. A felhőkörnyezet előkészítése

A Spring Petclinic-alkalmazás futtatásához szükséges fő erőforrás egy Azure Spring Apps-példány. Ez a szakasz az erőforrás létrehozásának lépéseit ismerteti.

3.1. Adja meg az egyes erőforrások nevét

Hozzon létre változókat az erőforrásnevek tárolásához az alábbi parancsokkal. Mindenképpen cserélje le a helyőrzőket a saját értékeire.

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. Új erőforráscsoport létrehozása

Az alábbi lépésekkel hozzon létre egy új erőforráscsoportot:

1. A következő paranccsal jelentkezzen be az Azure CLI-be:

   az login
   

2. Az alapértelmezett hely beállításához használja a következő parancsot:

   az configure --defaults location=${LOCATION}
   

3. A következő paranccsal listázhatja az összes elérhető előfizetést a használni kívánt előfizetés-azonosító meghatározásához:

   az account list --output table
   

4. Az alapértelmezett előfizetés beállításához használja a következő parancsot:

   az account set --subscription <subscription-ID>
   

5. Erőforráscsoport létrehozásához használja a következő parancsot:

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

6. Az újonnan létrehozott erőforráscsoportot az alábbi paranccsal állíthatja be alapértelmezett erőforráscsoportként:

   az configure --defaults group=${RESOURCE_GROUP}
   

3.3. Azure Spring Apps-példány létrehozása

Az Azure Spring Apps a Spring Petclinic alkalmazás üzemeltetésére szolgál. Az alábbi lépésekkel hozzon létre egy Azure Spring Apps-példányt és benne két alkalmazást:

1. Az alábbi paranccsal hozzon létre egy Azure Spring Apps-szolgáltatáspéldányt. A natív rendszerkép-buildek 16 Gi memóriát igényelnek a rendszerkép készítése során, ezért a buildkészlet méretét S7-ként kell konfigurálni.

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

2. Hozzon létre egy builder-native.json fájlt az aktuális könyvtárban, majd adja hozzá a következő tartalmat:

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

3. A natív képalkalmazás létrehozásához használja az alábbi parancsot egy egyéni szerkesztő létrehozásához:

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

4. Az alábbi paranccsal hozzon létre egy alkalmazást az Azure Spring Apps-példányban, amelyben a Spring Petclinic alkalmazást JAR-fájlként szeretné üzembe helyezni. Konfigurálja a memóriakorlátot 1 Gi értékre.

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

5. Az alábbi paranccsal hozzon létre egy alkalmazást az Azure Spring Apps-példányban, amelyben a Spring Petclinic alkalmazást natív rendszerképként szeretné üzembe helyezni:

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

4. Az alkalmazás üzembe helyezése az Azure Spring Appsben

Most, hogy a felhőkörnyezet elkészült, az alkalmazások készen állnak az üzembe helyezésre.

A Spring Petclinic-alkalmazás JAR-fájlként való üzembe helyezéséhez használja a következő parancsot:

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

A Spring Petclinic alkalmazás natív rendszerképként való üzembe helyezéséhez használja a következő parancsot:

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. Natív képalkalmazás ellenőrzése

Most hozzáférhet az üzembe helyezett natív kép alkalmazáshoz, hogy lássa, működik-e. Az ellenőrzéshez kövesse az alábbi lépéseket:

1. Az üzembe helyezés befejezése után az alábbi parancs futtatásával lekérheti az alkalmazás URL-címét:

   az spring app show \
       --service ${AZURE_SPRING_APPS_NAME} \
       --name ${NATIVE_APP_NAME} \
       --output table
   

   Az alkalmazást a kimenetben Public Urllátható URL-címmel érheti el. A lapnak úgy kell megjelennie, ahogy látta, o localhost.

2. Az alábbi paranccsal ellenőrizze az alkalmazás naplóját az üzembehelyezési problémák kivizsgálásához:

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

6. A JAR és a natív rendszerkép teljesítményének összehasonlítása

A következő szakaszok bemutatják, hogyan hasonlítható össze a JAR és a natív rendszerkép üzembe helyezése közötti teljesítmény.

Kiszolgáló indítási ideje

Az alábbi paranccsal ellenőrizze az alkalmazás naplóját Started PetClinicApplication in XXX seconds , hogy lekérje a kiszolgáló indítási idejét egy JAR-alkalmazáshoz:

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

A kiszolgáló indítási ideje a JAR-alkalmazások esetében körülbelül 25 s.

Az alábbi paranccsal ellenőrizze az alkalmazás naplóját, hogy megkapja a kiszolgáló indítási idejét egy natív rendszerkép-alkalmazáshoz:

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

A kiszolgáló indítási ideje kisebb, mint 0,5 s a natív rendszerkép-alkalmazások esetében.

Memóriahasználat

A következő paranccsal skálázhatja le a memória méretét 512 Mi-re natív képalkalmazás esetén:

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

A parancs kimenetének azt kell mutatnia, hogy a natív kép alkalmazás sikeresen elindult.

A jar alkalmazás memóriaméretének 512 mi-re való leskálázásához használja az alábbi parancsot:

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

A parancs kimenetének azt kell mutatnia, hogy a JAR-alkalmazás nem indult el a memória elégtelensége miatt. A kimeneti üzenetnek a következő példához hasonlónak kell lennie: Terminating due to java.lang.OutOfMemoryError: Java heap space.

Az alábbi ábra a natív rendszerkép üzembe helyezéséhez optimalizált memóriahasználatot mutatja be másodpercenként 400 kérés állandó számítási feladatához a Petclinic-alkalmazásba. A memóriahasználat körülbelül 1/5-ed része annak a memóriának, amelyet az azzal egyenértékű JAR-üzembe helyezés használ fel.

A natív képek gyorsabb indítási időt és csökkentett futásidejű memóriaterhelést kínálnak a hagyományos Java virtuális géphez (JVM) képest.

7. Erőforrások törlése

Ha további rövid útmutatókkal és oktatóanyagokkal szeretne dolgozni, érdemes lehet ezeket az erőforrásokat a helyén hagyni. Ha már nincs szüksége az erőforrásokra, törölje őket az erőforráscsoport törlésével. Az erőforráscsoport törléséhez használja a következő parancsot:

az group delete --name ${RESOURCE_GROUP}

8. Következő lépések

Java Native Image-alkalmazások üzembe helyezése az Azure Spring Apps Enterprise-csomagban

Strukturált alkalmazásnapló az Azure Spring Appshez

Meglévő egyéni tartomány leképezése az Azure Spring Appsbe

Az Azure Spring Apps CI/CD beállítása a GitHub Actions használatával

Az Azure Spring Apps CI/CD beállítása az Azure DevOpsszal

Felügyelt identitások használata alkalmazásokhoz az Azure Spring Appsben

Szolgáltatáskapcsolat létrehozása az Azure Spring Appsben az Azure CLI-vel

Futtassa a többplatformos ACME fitnesztár-alkalmazásokat az Azure Spring Appsben

A Spring Boot natív rendszerkép-alkalmazás figyelése

További információért tekintse át az alábbi cikkeket:

• Azure Spring Apps-minták.
• A Spring használata az Azure-ban
• Spring Cloud Azure