Guida introduttiva: Distribuire la prima applicazione Java Native Image in Azure Spring Apps

Articolo
02/01/2024

Nota

Le prime 50 ore vCPU e 100 GB di memoria sono gratuite ogni mese. Per altre informazioni, vedere Riduzione dei prezzi - Azure Spring Apps fa di più, meno costi! nel blog di App in Azure.

Nota

Azure Spring Apps è il nuovo nome del servizio Azure Spring Cloud. Anche se il servizio ha un nuovo nome, il nome precedente verrà visualizzato in alcune posizioni per un po' mentre si lavora per aggiornare gli asset, ad esempio screenshot, video e diagrammi.

Questo articolo si applica a:❌ Basic/Standard ✔️ Enterprise

Questa guida introduttiva illustra come distribuire un'applicazione Spring Boot in Azure Spring Apps come immagine nativa.

La funzionalità Immagine nativa consente di compilare applicazioni Java in file eseguibili autonomi, noti come immagini native. Questi eseguibili possono offrire vantaggi significativi, inclusi tempi di avvio più rapidi e un sovraccarico di memoria di runtime inferiore rispetto a una JVM tradizionale (Macchina virtuale Java).

Il progetto di esempio è l'applicazione Spring Petclinic. Lo screenshot seguente mostra l'applicazione:

1. Prerequisiti

Una sottoscrizione di Azure. Se non si ha già una sottoscrizione, creare un account gratuito prima di iniziare.
Git.
Java Development Kit (JDK) versione 17.
Interfaccia della riga di comando di Azure versione 2.45.0 o successiva. Usare il comando seguente per installare l'estensione Azure Spring Apps: az extension add --name spring
Se si distribuisce un'istanza del piano Enterprise di Azure Spring Apps per la prima volta nella sottoscrizione di destinazione, vedere la sezione Requisiti di Visualizzare l'offerta del livello Enterprise di Azure Spring Apps in Azure Marketplace.

2. Preparare il progetto Spring Petclinic

Usare la procedura seguente per clonare ed eseguire l'app in locale.

Usare il comando seguente per clonare il progetto Spring Petclinic da GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Usare il comando seguente per compilare il progetto Spring Petclinic:

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

Usare il comando seguente per eseguire l'applicazione Spring Petclinic usando Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Passare a http://localhost:8080 nel browser per accedere all'applicazione Spring Petclinic.

3. Preparare l'ambiente cloud

La risorsa principale necessaria per eseguire l'applicazione Spring Petclinic è un'istanza di Azure Spring Apps. Questa sezione illustra i passaggi per creare la risorsa.

3.1. Specificare i nomi per ogni risorsa

Creare variabili per contenere i nomi delle risorse usando i comandi seguenti. Assicurarsi di sostituire i segnaposto con i propri valori.

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. Creare un nuovo gruppo di risorse

Usare la procedura seguente per creare un nuovo gruppo di risorse:

Usare il comando seguente per accedere all'interfaccia della riga di comando di Azure:
```
az login
```
Usare il comando seguente per impostare il percorso predefinito:
```
az configure --defaults location=${LOCATION}
```
Usare il comando seguente per elencare tutte le sottoscrizioni disponibili per determinare l'ID sottoscrizione da usare:
```
az account list --output table
```
Usare il comando seguente per impostare la sottoscrizione predefinita:
```
az account set --subscription <subscription-ID>
```
Usare il comando seguente per creare un gruppo di risorse:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Usare il comando seguente per impostare il gruppo di risorse appena creato come gruppo di risorse predefinito:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Creare un'istanza di Azure Spring Apps

App Spring di Azure viene usata per ospitare l'app Spring Petclinic. Usare la procedura seguente per creare un'istanza di Azure Spring Apps e due applicazioni al suo interno:

Usare il comando seguente per creare un'istanza del servizio Azure Spring Apps. Una compilazione di immagine nativa richiede 16 Gi di memoria durante la compilazione dell'immagine, quindi configurare le dimensioni del pool di compilazione come S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Creare un file builder-native.json nella directory corrente e quindi aggiungere il contenuto seguente:

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

Usare il comando seguente per creare un generatore personalizzato per compilare l'applicazione Immagine nativa:

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

Usare il comando seguente per creare un'applicazione nell'istanza di Azure Spring Apps in cui distribuire l'applicazione Spring Petclinic come file JAR. Configurare il limite di memoria a 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Usare il comando seguente per creare un'applicazione nell'istanza di Azure Spring Apps in cui distribuire l'applicazione Spring Petclinic come immagine nativa:
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Distribuire l'app in Azure Spring Apps

Dopo aver preparato l'ambiente cloud, le applicazioni sono pronte per la distribuzione.

Usare il comando seguente per distribuire l'applicazione Spring Petclinic come file JAR:

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

Usare il comando seguente per distribuire l'applicazione Spring Petclinic come immagine nativa:

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. Convalidare l'app per immagini native

È ora possibile accedere all'app Immagine nativa distribuita per verificare se funziona. Per convalidare, seguire questa procedura:

Al termine della distribuzione, è possibile eseguire il comando seguente per ottenere l'URL dell'app:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
È possibile accedere all'app con l'URL visualizzato nell'output come Public Url. La pagina dovrebbe essere visualizzata come si è visto o localhost.
Usare il comando seguente per controllare il log dell'app per analizzare eventuali problemi di distribuzione:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Confrontare le prestazioni per JAR e Immagine nativa

Le sezioni seguenti descrivono come confrontare le prestazioni tra la distribuzione jar e quella delle immagini native.

Ora di avvio del server

Usare il comando seguente per controllare il log Started PetClinicApplication in XXX seconds dell'app per ottenere l'ora di avvio del server per un'app JAR:

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

Il tempo di avvio del server è di circa 25 s per un'app JAR.

Usare il comando seguente per controllare il log dell'app per ottenere l'ora di avvio del server per un'app Immagine nativa:

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

Il tempo di avvio del server è inferiore a 0,5 s per un'app immagine nativa.

Utilizzo memoria

Usare il comando seguente per ridurre le dimensioni della memoria a 512 Mi per un'app immagine nativa:

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

L'output del comando dovrebbe indicare che l'app Immagine nativa è stata avviata correttamente.

Usare il comando seguente per ridurre le dimensioni della memoria a 512 Mi per l'app JAR:

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

L'output del comando dovrebbe indicare che l'app JAR non è stata avviata a causa di memoria insufficiente. Il messaggio di output dovrebbe essere simile all'esempio seguente: Terminating due to java.lang.OutOfMemoryError: Java heap space.

La figura seguente illustra l'utilizzo ottimizzato della memoria per la distribuzione dell'immagine nativa per un carico di lavoro costante di 400 richieste al secondo nell'applicazione Petclinic. L'utilizzo della memoria è circa 1/5 della memoria utilizzata dalla distribuzione JAR equivalente.

Le immagini native offrono tempi di avvio più rapidi e un sovraccarico di memoria di runtime ridotto rispetto alla JVM (Java Virtual Machine) convenzionale.

7. Pulire le risorse

Se si prevede di usare le guide di avvio rapido e le esercitazioni successive, è consigliabile non cancellare le risorse create. Quando le risorse non sono più necessarie, eliminarle eliminando il gruppo di risorse. Usare il comando seguente per eliminare il gruppo di risorse:

az group delete --name ${RESOURCE_GROUP}

8. Passaggi successivi

Come distribuire app Java Native Image nel piano Enterprise di Azure Spring Apps

Log applicazioni strutturato per Azure Spring Apps

Eseguire il mapping di un dominio personalizzato esistente ad Azure Spring Apps

Configurare l'integrazione continua/distribuzione continua di Azure Spring Apps con GitHub Actions

Configurare l'integrazione continua/distribuzione continua di Azure Spring Apps con Azure DevOps

Usare le identità gestite per le applicazioni in Azure Spring Apps

Creare una connessione al servizio in Azure Spring Apps con l'interfaccia della riga di comando di Azure

Eseguire le app polyglot ACME fitness store in Azure Spring Apps

Monitorare l'applicazione Spring Boot Native Image

Per altre informazioni, vedere gli articoli seguenti:

Share via