Szybki start: wdrażanie pierwszej natywnej aplikacji java image w usłudze Azure Spring Apps

Artykuł
01/31/2024

Uwaga

Pierwsze 50 godzin procesorów wirtualnych i 100 GB pamięci jest bezpłatne każdego miesiąca. Aby uzyskać więcej informacji, zobacz Price Reduction — Azure Spring Apps robi więcej, kosztuje mniej! w blogu Aplikacje na platformie Azure.

Uwaga

Azure Spring Apps to nowa nazwa usługi Azure Spring Cloud. Mimo że usługa ma nową nazwę, stara nazwa będzie widoczna w niektórych miejscach przez pewien czas, ponieważ pracujemy nad aktualizowaniem zasobów, takich jak zrzuty ekranu, filmy wideo i diagramy.

Ten artykuł dotyczy:❌ Podstawowa/Standardowa ✔️ Enterprise

W tym przewodniku Szybki start pokazano, jak wdrożyć aplikację Spring Boot w usłudze Azure Spring Apps jako obraz natywny.

Funkcja obrazu natywnego umożliwia kompilowanie aplikacji Java w autonomicznych plikach wykonywalnych, znanych jako obrazy natywne. Te pliki wykonywalne mogą zapewnić znaczne korzyści, w tym szybsze uruchamianie i mniejsze obciążenie pamięci środowiska uruchomieniowego w porównaniu z tradycyjną maszyną wirtualną JVM (Java Virtual Machine).

Przykładowy projekt to aplikacja Spring Petclinic. Poniższy zrzut ekranu przedstawia aplikację:

1. Wymagania wstępne

Subskrypcja Azure. Jeśli nie masz subskrypcji, przed rozpoczęciem utwórz bezpłatne konto .
Git.
Java Development Kit (JDK), wersja 17.
Interfejs wiersza polecenia platformy Azure w wersji 2.45.0 lub nowszej. Użyj następującego polecenia, aby zainstalować rozszerzenie Azure Spring Apps: az extension add --name spring
Jeśli wdrażasz wystąpienie planu Azure Spring Apps Enterprise po raz pierwszy w subskrypcji docelowej, zobacz sekcję Wymagania w sekcji Wyświetlanie oferty warstwy Azure Spring Apps Enterprise w witrynie Azure Marketplace.

2. Przygotowanie projektu Spring Petclinic

Wykonaj poniższe kroki, aby sklonować i uruchomić aplikację lokalnie.

Użyj następującego polecenia, aby sklonować projekt Spring Petclinic z usługi GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```
Użyj następującego polecenia, aby skompilować projekt Spring Petclinic:
```
cd spring-petclinic
./mvnw clean package -DskipTests -Pnative package
```
Użyj następującego polecenia, aby uruchomić aplikację Spring Petclinic przy użyciu narzędzia Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Przejdź do http://localhost:8080 strony w przeglądarce, aby uzyskać dostęp do aplikacji Spring Petclinic.

3. Przygotowanie środowiska chmury

Głównym zasobem wymaganym do uruchomienia aplikacji Spring Petclinic jest wystąpienie usługi Azure Spring Apps. Ta sekcja zawiera kroki tworzenia zasobu.

3.1. Podaj nazwy dla każdego zasobu

Utwórz zmienne do przechowywania nazw zasobów przy użyciu następujących poleceń. Pamiętaj, aby zastąpić symbole zastępcze własnymi wartościami.

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. Tworzenie nowej grupy zasobów

Aby utworzyć nową grupę zasobów, wykonaj następujące czynności:

Użyj następującego polecenia, aby zalogować się do interfejsu wiersza polecenia platformy Azure:
```
az login
```
Użyj następującego polecenia, aby ustawić lokalizację domyślną:
```
az configure --defaults location=${LOCATION}
```
Użyj następującego polecenia, aby wyświetlić listę wszystkich dostępnych subskrypcji, aby określić identyfikator subskrypcji do użycia:
```
az account list --output table
```
Użyj następującego polecenia, aby ustawić domyślną subskrypcję:
```
az account set --subscription <subscription-ID>
```
Użyj następującego polecenia, aby utworzyć grupę zasobów:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Użyj następującego polecenia, aby ustawić nowo utworzoną grupę zasobów jako domyślną grupę zasobów:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Tworzenie wystąpienia usługi Azure Spring Apps

Usługa Azure Spring Apps służy do hostowania aplikacji Spring Petclinic. Wykonaj następujące kroki, aby utworzyć wystąpienie usługi Azure Spring Apps i dwie aplikacje w nim:

Użyj następującego polecenia, aby utworzyć wystąpienie usługi Azure Spring Apps. Kompilacja obrazu natywnego wymaga 16 Gi pamięci podczas kompilacji obrazu, dlatego skonfiguruj rozmiar puli kompilacji jako S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Utwórz plik builder-native.json w bieżącym katalogu, a następnie dodaj następującą zawartość:

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

Użyj następującego polecenia, aby utworzyć konstruktor niestandardowy w celu skompilowania aplikacji obrazów natywnych:

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

Użyj następującego polecenia, aby utworzyć aplikację w wystąpieniu usługi Azure Spring Apps, w którym można wdrożyć aplikację Spring Petclinic jako plik JAR. Skonfiguruj limit pamięci do 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Użyj następującego polecenia, aby utworzyć aplikację w wystąpieniu usługi Azure Spring Apps, w którym wdrożysz aplikację Spring Petclinic jako obraz natywny:
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Wdrażanie aplikacji w usłudze Azure Spring Apps

Po przygotowaniu środowiska w chmurze aplikacje są gotowe do wdrożenia.

Użyj następującego polecenia, aby wdrożyć aplikację Spring Petclinic jako plik JAR:

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

Użyj następującego polecenia, aby wdrożyć aplikację Spring Petclinic jako obraz natywny:

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. Zweryfikuj natywną aplikację obrazu

Teraz możesz uzyskać dostęp do wdrożonej aplikacji Obraz natywny, aby sprawdzić, czy działa. Aby sprawdzić poprawność, wykonaj następujące czynności:

Po zakończeniu wdrażania możesz uruchomić następujące polecenie, aby uzyskać adres URL aplikacji:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Dostęp do aplikacji można uzyskać przy użyciu adresu URL wyświetlanego w danych wyjściowych jako Public Url. Strona powinna zostać wyświetlona w sposób widoczny dla hosta lokalnego.
Użyj następującego polecenia, aby sprawdzić dziennik aplikacji w celu zbadania dowolnego problemu z wdrażaniem:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Porównanie wydajności jar i obrazu natywnego

W poniższych sekcjach opisano sposób porównywania wydajności między wdrożeniem pliku JAR i obrazu natywnego.

Czas uruchamiania serwera

Użyj następującego polecenia, aby sprawdzić dziennik Started PetClinicApplication in XXX seconds aplikacji, aby uzyskać czas uruchamiania serwera dla aplikacji JAR:

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

Czas uruchamiania serwera wynosi około 25 s dla aplikacji JAR.

Użyj następującego polecenia, aby sprawdzić dziennik aplikacji, aby uzyskać czas uruchamiania serwera dla aplikacji obrazu natywnego:

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

Czas uruchamiania serwera wynosi mniej niż 0,5 s dla aplikacji obrazu natywnego.

Użycie pamięci

Użyj następującego polecenia, aby skalować w dół rozmiar pamięci do 512 Mi dla aplikacji obrazu natywnego:

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

Dane wyjściowe polecenia powinny wskazywać, że aplikacja Obrazu natywnego została pomyślnie uruchomiona.

Użyj następującego polecenia, aby skalować w dół rozmiar pamięci do 512 Mi dla aplikacji JAR:

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

Dane wyjściowe polecenia powinny wskazywać, że uruchomienie aplikacji JAR nie powiodło się z powodu niewystarczającej ilości pamięci. Komunikat wyjściowy powinien być podobny do następującego przykładu: Terminating due to java.lang.OutOfMemoryError: Java heap space.

Na poniższej ilustracji przedstawiono zoptymalizowane użycie pamięci dla wdrożenia obrazu natywnego dla stałego obciążenia 400 żądań na sekundę w aplikacji Petclinic. Użycie pamięci wynosi około 1/5 pamięci używanej przez jego równoważne wdrożenie JAR.

Obrazy natywne oferują szybsze czasy uruchamiania i mniejsze obciążenie pamięci środowiska uruchomieniowego w porównaniu z konwencjonalną maszyną wirtualną Java (JVM).

7. Czyszczenie zasobów

Jeśli planujesz kontynuować pracę z kolejnymi przewodnikami Szybki start i samouczkami, możesz pozostawić te zasoby na miejscu. Gdy zasoby nie są już potrzebne, usuń je, usuwając grupę zasobów. Użyj następującego polecenia, aby usunąć grupę zasobów:

az group delete --name ${RESOURCE_GROUP}

8. Następne kroki

How to deploy Java Native Image apps in the Azure Spring Apps Enterprise plan (Jak wdrożyć aplikacje java native image w planie Usługi Azure Spring Apps Enterprise)

Dziennik aplikacji ze strukturą dla usługi Azure Spring Apps

Mapuj istniejącą domenę niestandardową na usługę Azure Spring Apps

Konfigurowanie ciągłej integracji/ciągłego wdrażania usługi Azure Spring Apps za pomocą funkcji GitHub Actions

Konfigurowanie ciągłej integracji/ciągłego wdrażania usługi Azure Spring Apps za pomocą usługi Azure DevOps

Używanie tożsamości zarządzanych dla aplikacji w usłudze Azure Spring Apps

Tworzenie połączenia usługi w usłudze Azure Spring Apps przy użyciu interfejsu wiersza polecenia platformy Azure

Uruchamianie aplikacji wielolotowego sklepu fitness ACME w usłudze Azure Spring Apps

Monitorowanie aplikacji Spring Boot Native Image

Aby uzyskać więcej informacji, zobacz następujące artykuły:

Przykłady usługi Azure Spring Apps.
Oprogramowanie Spring na platformie Azure
Spring Cloud Azure