Avvio rapido: Implementare la prima applicazione Java Native Image in Azure Spring Apps

Note

I piani Basic, Standard ed Enterprise sono entrati in un periodo di ritiro il 17 marzo 2025. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.

Questo articolo si applica a: ❎ Basic/Standard ✅ Enterprise

Questo avvio rapido illustra come distribuire un'applicazione Spring Boot in Azure Spring Apps come Native Image.

La funzionalità Native Image 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

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. In questa sezione vengono illustrati i passi 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

Azure Spring Apps viene usato per ospitare l'app Petclinic. Usare i seguenti passi 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 una Native Image.
```
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 una 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. Convalidare l'app per immagini native

È ora possibile accedere all'app Immagine nativa distribuita per verificare se funziona. Usare la procedura seguente per convalidare:

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.

Tempo 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 Native Image:

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 della 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 create non sono più necessarie, rimuoverle 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

Registro applicazioni strutturato per Azure Spring Apps

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

Configurare l'integrazione continua e recapito continuo di Azure Spring Apps con GitHub Actions

Configurare CI/CD 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 di immagini native Spring Boot

Per altre informazioni, vedere gli articoli seguenti:

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-10-13