Rychlý start: Nasazení první aplikace nativní image v Javě do Azure Spring Apps

Článek
01/31/2024

Poznámka:

Prvních 50 vCPU hodin a 100 GB paměti je každý měsíc zdarma. Další informace najdete v tématu Snížení cen – Azure Spring Apps dělá více, náklady na méně! na blogu o aplikacích v Azure.

Poznámka:

Azure Spring Apps je nový název služby Azure Spring Cloud. Přestože má služba nový název, na některých místech uvidíte starý název, protože pracujeme na aktualizaci prostředků, jako jsou snímky obrazovky, videa a diagramy.

Tento článek se vztahuje na:❌ Basic/Standard ✔️ Enterprise

V tomto rychlém startu se dozvíte, jak nasadit aplikaci Spring Boot do Azure Spring Apps jako nativní image.

Funkce nativní bitové kopie umožňuje kompilovat aplikace Java do samostatných spustitelných souborů, označovaných jako Nativní bitové kopie. Tyto spustitelné soubory můžou přinést významné výhody, včetně rychlejšího spouštění a nižší režie za běhu v porovnání s tradičním prostředím JVM (Java Virtual Machine).

Ukázkový projekt je aplikace Spring Petclinic. Následující snímek obrazovky ukazuje aplikaci:

1. Požadavky

Předplatné Azure. Pokud předplatné nemáte, vytvořte si před zahájením bezplatný účet .
Git
Java Development Kit (JDK) verze 17.
Azure CLI verze 2.45.0 nebo vyšší K instalaci rozšíření Azure Spring Apps použijte následující příkaz: az extension add --name spring
Pokud nasazujete instanci plánu Azure Spring Apps Enterprise poprvé v cílovém předplatném, přečtěte si část Požadavky nabídky služby Azure Spring Apps Enterprise na Azure Marketplace.

2. Příprava projektu Spring Petclinic

Pomocí následujícího postupu naklonujte a spusťte aplikaci místně.

Pomocí následujícího příkazu naklonujte projekt Spring Petclinic z GitHubu:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Pomocí následujícího příkazu sestavte projekt Spring Petclinic:

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

Pomocí následujícího příkazu spusťte aplikaci Spring Petclinic pomocí Mavenu:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Přejděte v http://localhost:8080 prohlížeči a získejte přístup k aplikaci Spring Petclinic.

3. Příprava cloudového prostředí

Hlavním prostředkem potřebným ke spuštění aplikace Spring Petclinic je instance Azure Spring Apps. Tato část obsahuje postup vytvoření prostředku.

3.1. Zadejte názvy jednotlivých prostředků.

Pomocí následujících příkazů vytvořte proměnné, které budou obsahovat názvy prostředků. Zástupné symboly nezapomeňte nahradit vlastními hodnotami.

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. Vytvoření nové skupiny prostředků

Pomocí následujících kroků vytvořte novou skupinu prostředků:

Pomocí následujícího příkazu se přihlaste k Azure CLI:
```
az login
```
K nastavení výchozího umístění použijte následující příkaz:
```
az configure --defaults location=${LOCATION}
```
Pomocí následujícího příkazu vypíšete všechna dostupná předplatná a určíte ID předplatného, které se má použít:
```
az account list --output table
```
K nastavení výchozího předplatného použijte následující příkaz:
```
az account set --subscription <subscription-ID>
```
Pomocí následujícího příkazu vytvořte skupinu prostředků:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Pomocí následujícího příkazu nastavte nově vytvořenou skupinu prostředků jako výchozí skupinu prostředků:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Vytvoření instance Azure Spring Apps

Azure Spring Apps se používá k hostování aplikace Spring Petclinic. Pomocí následujících kroků vytvořte instanci Azure Spring Apps a dvě aplikace v ní:

Pomocí následujícího příkazu vytvořte instanci služby Azure Spring Apps. Sestavení nativní bitové kopie vyžaduje během sestavování image 16 Gi paměti, proto nakonfigurujte velikost fondu sestavení jako S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

V aktuálním adresáři vytvořte soubor builder-native.json a přidejte následující obsah:

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

Pomocí následujícího příkazu vytvořte vlastní tvůrce pro sestavení aplikace nativní bitové kopie:

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

Pomocí následujícího příkazu vytvořte aplikaci v instanci Azure Spring Apps, ve které chcete nasadit aplikaci Spring Petclinic jako soubor JAR. Nakonfigurujte limit paměti na 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

Pomocí následujícího příkazu vytvořte aplikaci v instanci Azure Spring Apps, ve které chcete nasadit aplikaci Spring Petclinic jako nativní image:

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

4. Nasazení aplikace do Azure Spring Apps

Teď, když je cloudové prostředí připravené, jsou aplikace připravené k nasazení.

Pomocí následujícího příkazu nasaďte aplikaci Spring Petclinic jako soubor JAR:

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

Pomocí následujícího příkazu nasaďte aplikaci Spring Petclinic jako nativní 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. Ověření aplikace nativní bitové kopie

Teď máte přístup k nasazené aplikaci nativní bitové kopie a zjistit, jestli funguje. K ověření použijte následující postup:

Po dokončení nasazení můžete spuštěním následujícího příkazu získat adresu URL aplikace:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
K aplikaci se dostanete pomocí adresy URL zobrazené ve výstupu jako Public Url. Stránka by se měla zobrazit, jak jste viděli o localhost.
Pomocí následujícího příkazu zkontrolujte protokol aplikace a prozkoumejte případné problémy s nasazením:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Porovnání výkonu pro JAR a nativní bitovou kopii

Následující části popisují, jak porovnat výkon mezi nasazením JAR a nativní bitové kopie.

Čas spuštění serveru

Pomocí následujícího příkazu zkontrolujte protokol Started PetClinicApplication in XXX seconds aplikace a získejte čas spuštění serveru pro aplikaci JAR:

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

Čas spuštění serveru je přibližně 25 s pro aplikaci JAR.

Pomocí následujícího příkazu zkontrolujte protokol aplikace a získejte čas spuštění serveru pro aplikaci nativní bitové kopie:

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

Čas spuštění serveru je menší než 0,5 s pro aplikaci nativní bitové kopie.

Využití paměti

Pomocí následujícího příkazu vertikálně snížit velikost paměti na 512 Mi pro aplikaci nativní bitové kopie:

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

Výstup příkazu by měl ukázat, že aplikace nativní bitové kopie byla úspěšně spuštěna.

Pomocí následujícího příkazu vertikálně snížit velikost paměti na 512 Mi pro aplikaci JAR:

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

Výstup příkazu by měl ukázat, že se aplikaci JAR nepodařilo spustit kvůli nedostatku paměti. Výstupní zpráva by měla být podobná následujícímu příkladu: Terminating due to java.lang.OutOfMemoryError: Java heap space.

Následující obrázek znázorňuje optimalizované využití paměti pro nasazení nativní bitové kopie pro konstantní zatížení 400 požadavků za sekundu do aplikace Petclinic. Využití paměti je přibližně 1/5th paměti spotřebované ekvivalentním nasazením JAR.

Nativní bitové kopie nabízejí rychlejší spouštění a nižší režijní náklady na paměť za běhu v porovnání s konvenčním prostředím Java Virtual Machine (JVM).

7. Vyčištění prostředků

Pokud chcete pokračovat v práci s dalšími rychlými starty a kurzy, můžete tyto prostředky ponechat na místě. Pokud už prostředky nepotřebujete, odstraňte je odstraněním skupiny prostředků. Pomocí následujícího příkazu odstraňte skupinu prostředků:

az group delete --name ${RESOURCE_GROUP}

8. Další kroky

Nasazení aplikací Nativní image v Javě v plánu Azure Spring Apps Enterprise

Protokol strukturovaných aplikací pro Azure Spring Apps

Mapování existující vlastní domény na Azure Spring Apps

Nastavení CI/CD pro Azure Spring Apps pomocí GitHub Actions

Nastavení CI/CD azure Spring Apps pomocí Azure DevOps

Použití spravovaných identit pro aplikace v Azure Spring Apps

Vytvoření připojení služby v Azure Spring Apps pomocí Azure CLI

Spuštění aplikací polyglot ACME fitness storu v Azure Spring Apps

Monitorování aplikace Spring Boot Native Image

Další informace najdete v následujících článcích:

Share via