Come implementare app poliglotte nel piano Enterprise di Azure Spring Apps

Articolo
08/28/2024

Nota

I piani Basic, Standard ed Enterprise saranno deprecati a partire dalla metà di marzo 2025, con un periodo di ritiro di 3 anni. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.

Il piano Standard a consumo e dedicato sarà deprecato a partire dal 30 settembre 2024, con un arresto completo dopo sei mesi. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere Eseguire la migrazione del consumo di Azure Spring Apps Standard e del piano dedicato alle app Azure Container.

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

Questo articolo mostra come implementare app poliglotte nel piano Enterprise di Azure Spring Apps e come queste app poliglotte possono usare le funzionalità del servizio di compilazione fornite da pacchetti di build.

Prerequisiti

Un'istanza del piano Enterprise di Azure Spring Apps di cui è già stato effettuato il provisioning. Per altre informazioni, vedere Avvio rapido: Creare e distribuire app in Azure Spring Apps usando il piano Enterprise.
Interfaccia della riga di comando di Azure versione 2.45.0 o successive. Usare il comando seguente per installare l'estensione Azure Spring Apps: az extension add --name spring

Implementare applicazioni poliglotte in un'istanza del servizio

Questa sezione si applica alla compilazione e implementazione di applicazioni poliglotte quando il servizio di compilazione è abilitato. Se si disabilita il servizio di compilazione, è possibile implementare applicazioni solo con un'immagine del contenitore personalizzata. È possibile creare un'immagine personalizzata o usarne una compilata da un'istanza Enterprise di Azure Spring Apps. Per maggiori informazioni, vedere Implementare un'applicazione con un'immagine del contenitore personalizzata.

Gestire i generatori

Quando si crea un'istanza di Azure Spring Apps Enterprise, è necessario scegliere un generatore predefinito da uno dei seguenti pacchetti di build della famiglia di linguaggio supportati:

Per maggiori informazioni, vedere Pacchetti di build famiglia di linguaggio per VMware Tanzu.

Questi pacchetti di build supportano la compilazione con codice sorgente o artefatti per le app Java, .NET Core, Go, web static files, Node.js e Python. È anche possibile visualizzare le versioni del pacchetto di build durante la creazione o la visualizzazione di un generatore. È inoltre possibile creare un generatore personalizzato specificando i pacchetti di build e un gruppo.

Tutti i generatori configurati in un'istanza del servizio di Azure Spring Apps sono elencati nella pagina Servizio di compilazione, come illustrato nello screenshot seguente:

Selezionare Aggiungi per creare un nuovo generatore. Lo screenshot seguente mostra le risorse da usare per creare il generatore personalizzato. Il Gruppo del sistema operativo include Bionic Base, Bionic Full, Jammy Tiny, Jammy Base, e Jammy Full. Bionic si basa su Ubuntu 18.04 (Bionic Beaver) e Jammy si basa su Ubuntu 22.04 (Jammy Jellyfish). Per maggiori informazioni, vedere la sezione Consigli del gruppo del sistema operativo.

È consigliabile usare Jammy OS Stack per creare il generatore perché VMware è deprecato Bionic OS Stack.

È anche possibile modificare un generatore personalizzato quando il generatore non viene usato in una distribuzione. È possibile aggiornare i pacchetti di build o il Gruppo del sistema operativo, ma il nome del generatore è di sola lettura.

Il generatore è una risorsa che contribuisce continuamente alle distribuzioni. Fornisce le ultime immagini di runtime e i pacchetti di build più recenti.

Non è possibile eliminare un generatore quando vengono compilate distribuzioni attive esistenti con il generatore. Per eliminare un generatore in questo stato, seguire questa procedura:

Salvare la configurazione come nuovo generatore.
Implementare app con il nuovo generatore. Le distribuzioni sono collegate al nuovo generatore.
Eseguire la migrazione delle distribuzioni nel generatore precedente al nuovo generatore.
Eliminare il generatore originale.

Elementi consigliati per il Gruppo del sistema operativo

In Azure Spring Apps è consigliabile usare Jammy OS Stack per creare il generatore perché Bioinic OS Stack è in linea per la deprecazione da parte di VMware. L'elenco seguente descrive le opzioni disponibili:

Jammy Tiny: adatto per la creazione di un'immagine minima per le dimensioni e il footprint di sicurezza più piccoli possibili. Come la compilazione di un'Immagine Nativa Java, può rendere più piccola l'immagine finale del contenitore. Le librerie integrate sono limitate. Ad esempio, non è possibile connettersi a un'istanza dell'app per la risoluzione dei problemi perché non esiste alcuna shell libreria.
- La maggior parte delle app Go.
- App Java. Alcune opzioni di configurazione di Apache Tomcat, come ad esempio l'impostazione bin/setenv.sh, non sono disponibili perché Tiny non ha shell.
Jammy Base: adatto per la maggior parte delle app senza estensioni native.
- App Java e app .NET Core.
- App Go che richiede alcune librerie C.
- Le app Node.js, Python o Server Web senza estensioni native.
Jammy Full: include la maggior parte delle librerie ed è adatto per le app con estensioni native. Ad esempio, include una libreria di tipi di carattere più completa. Se l'app si basa sull'estensione nativa, usare il Full gruppo.
- Le app Node.js o Python con estensioni native.

Per maggiori informazioni, vedere Stack Ubuntu nella documentazione di VMware.

Gestire il registro contenitori

Questa sezione mostra come gestire il registro contenitori usato dal servizio di compilazione se si abilita il servizio di compilazione con il proprio registro contenitori. Se si abilita il servizio di compilazione con un registro contenitori gestito di Azure Spring Apps, si può ignorare questa sezione.

Dopo aver abilitato un registro contenitori utente con il servizio di compilazione, è possibile visualizzare e configurare il registro usando il portale di Azure o l'interfaccia della riga di comando di Azure.

Azure portal
Interfaccia della riga di comando di Azure

Usare la procedura seguente per visualizzare, aggiungere, modificare ed eliminare il registro contenitori:

Apri il portale di Azure.
Selezionare Registro contenitori nel riquadro di spostamento.
Selezionare Aggiungi per creare un registro contenitori.
Per un registro contenitori, selezionare il pulsante con i puntini di sospensione (...) e quindi selezionare Modifica per visualizzare la configurazione del registro.
Esaminare i valori nella pagina Modifica registro contenitori.
Per eliminare un registro contenitori, selezionare il pulsante con i puntini di sospensione (...) e quindi selezionare Elimina per eliminare il registro. Se il registro contenitori viene usato dal servizio di compilazione, non può essere eliminato.

Usare il comando seguente per elencare tutti i registri contenitori per l'istanza del servizio:

az spring container-registry list \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name>

Usare il comando seguente per visualizzare il registro contenitori:

az spring container-registry show \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <your-container-registry-name>

Usare il comando seguente per aggiornare il registro contenitori:

az spring container-registry update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <your-container-registry-name> \
    --server <your-container-registry-login-server> \
    --username <your-container-registry-username> \
    --password <your-container-registry-password>

Usare il comando seguente per eliminare il registro contenitori:

az spring container-registry delete \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <your-container-registry-name>

Se il servizio di compilazione usa il registro contenitori, non è possibile eliminarlo.

Il servizio di compilazione può usare un registro contenitori e può anche modificare il registro contenitori associato. Questo processo richiede molto tempo. Quando avviene la modifica, tutte le risorse dei generatori e di compilazione nel servizio di compilazione effettuano nuovamente la compilazione, successivamente le immagini finali del contenitore vengono spostate nel nuovo registro contenitori.

Azure portal
Interfaccia della riga di comando di Azure

Usare i seguenti passaggi per cambiare il registro contenitori associato al servizio di compilazione:

Apri il portale di Azure.
Selezionare Compila servizio nel riquadro di spostamento.
Selezionare Registro contenitori di riferimento per aggiornare il registro contenitori per il servizio di compilazione.

Usare il comando seguente per visualizzare il servizio di compilazione:

az spring build-service show \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name>

Usare il comando seguente per aggiornare il servizio di compilazione con un registro contenitori specifico:

az spring build-service update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --registry-name <your-container-registry-name>

Compilare e implementare applicazioni poliglotte

È possibile compilare e implementare applicazioni poliglotte nei modi seguenti usando il registro contenitori:

Per il servizio di compilazione usando il registro contenitori gestito di Azure Spring Apps, è possibile compilare un'applicazione in un'immagine e quindi implementarla nell'istanza del servizio di Azure Spring Apps corrente. La compilazione e la distribuzione vengono eseguite insieme usando il az spring app deploy comando.
Per il servizio di compilazione usando un registro contenitori gestito dall'utente, è possibile compilare un'applicazione in un'immagine del contenitore e quindi implementare l'immagine nell'istanza Enterprise di Azure Spring Apps corrente e in altre istanze. I comandi di compilazione e implementazione sono separati. È possibile usare il comando di compilazione per creare o aggiornare una compilazione, quindi usare il comando implementare per implementare l'immagine del contenitore nell'istanza del servizio.

Per maggiori informazioni, vedere la sezione Compilare un servizio su richiesta di Usare il servizio di compilazione Tanzu.

Gli esempi seguenti mostrano alcuni comandi di compilazione utili da usare.

az configure --defaults group=<resource-group-name> spring=<service-name>

az spring build-service build list
az spring build-service build show --name <build-name>
az spring build-service build create --name <build-name> --artifact-path <artifact-path>
az spring build-service build update --name <build-name> --artifact-path <artifact-path>
az spring build-service build delete --name <build-name>

Gli esempi seguenti dell'interfaccia della riga di comando di Azure mostrano la compilazione e implementazione di un file di artefatti per due scenari del registro contenitori:

Registro contenitori gestito di Azure Spring Apps.
Registro contenitori gestito dall'utente.

Registro contenitori gestito di Azure Spring Apps
Registro contenitori gestito dall'utente

Questo esempio compila e implementa in un unico comando. Il comando seguente specifica un generatore per compilare un'applicazione in un'immagine del contenitore e quindi implementa l'applicazione direttamente nell'istanza del servizio Enterprise di Azure Spring Apps.

Se non si specifica il generatore, viene usato un default generatore.

az spring app deploy \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <app-name> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Questo esempio compila o aggiorna un'applicazione e la implementa usando due comandi. Con un registro contenitori gestito dall'utente, è possibile implementare un'applicazione solo da un'immagine del contenitore personalizzata. Per maggiori informazioni, vedere Implementare un'applicazione con un'immagine del contenitore personalizzata.

Il comando seguente compila un'applicazione:

az spring build-service build create \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente aggiorna una compilazione esistente:

az spring build-service build update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente implementa un'applicazione.

az spring app deploy \
   --resource-group <resource-group-name> \
   --service <Azure-Spring-Apps-instance-name> \
   --name <app-name> \
   --container-image <your-container-image> \
   --container-registry <your-container-registry> \
   --registry-password <your-password> \
   --registry-username <your-username>

Se si implementa l'app con un file di artefatti, usare --artifact-path per specificare il percorso del file. I file JAR e WAR sono entrambi accettabili.

Se l'interfaccia della riga di comando di Azure rileva il pacchetto WAR come file JAR sottile, usare --disable-validation per disabilitare la convalida.

Nell'esempio seguente la cartella del codice sorgente viene implementata in una distribuzione attiva usando il --source-path parametro per specificare la cartella.

Registro contenitori gestito di Azure Spring Apps
Registro contenitori gestito dall'utente

az spring app deploy \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <app-name> \
    --builder <builder-name> \
    --source-path <path-to-source-code>

Il comando seguente compila un'applicazione:

az spring build-service build create \
   --resource-group <resource-group-name> \
   --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --builder <builder-name> \
    --source-path <path-to-source-code>

Il comando seguente aggiorna una compilazione esistente:

az spring build-service build update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --builder <builder-name> \
    --source-path <path-to-source-code>

Per implementare l'applicazione, vedere Implementare un'applicazione con un'immagine del contenitore personalizzata.

È anche possibile configurare l'ambiente di compilazione per compilare l'app. Ad esempio, in un'applicazione Java è possibile specificare la versione JDK usando l'ambiente BP_JVM_VERSION di compilazione.

Per specificare gli ambienti di compilazione, usare --build-env, come illustrato nell'esempio seguente. Le variabili di ambiente di compilazione disponibili sono descritte più avanti in questo articolo.

Registro contenitori gestito di Azure Spring Apps
Registro contenitori gestito dall'utente

Il comando seguente implementa un'applicazione:

az spring app deploy \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <app-name> \
    --build-env <key1=value1> <key2=value2> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente compila un'applicazione:

az spring build-service build create \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --build-env <key1=value1> <key2=value2> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente aggiorna una compilazione esistente:

az spring build-service build update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --build-env <key1=value1> <key2=value2> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Per implementare l'applicazione, vedere Implementare un'applicazione con un'immagine del contenitore personalizzata.

Per ogni compilazione, è anche possibile specificare le risorse di compilazione, come illustrato nell'esempio seguente.

Registro contenitori gestito di Azure Spring Apps
Registro contenitori gestito dall'utente

Il comando seguente implementa un'applicazione:

az spring app deploy \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <app-name> \
    --build-env <key1=value1> <key2=value2> \
    --build-cpu <build-cpu-size> \
    --build-memory <build-memory-size> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente compila un'applicazione:

az spring build-service build create \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --build-env <key1=value1> <key2=value2> \
    --build-cpu <build-cpu-size> \
    --build-memory <build-memory-size> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Il comando seguente aggiorna una compilazione esistente:

az spring build-service build update \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-instance-name> \
    --name <build-name> \
    --build-env <key1=value1> <key2=value2> \
    --build-cpu <build-cpu-size> \
    --build-memory <build-memory-size> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Per implementare l'applicazione, vedere Implementare un'applicazione con un'immagine del contenitore personalizzata.

La risorsa CPU/memoria di compilazione predefinita è 1 vCPU, 2 Gi. Se l'applicazione richiede una quantità di memoria minore o maggiore, usare --build-memory per specificare le risorse di memoria, ad esempio, 500Mi 1Gi, 2Gi e così via. Se l'applicazione richiede una quantità minore o maggiore di risorse di CPU, usare --build-cpu per specificare le risorse del CPU, ad esempio 500m, 1, 2 e così via. Il limite massimo di risorse CPU/memoria per una compilazione è 8 vCPU, 16Gi.

Le risorse CPU e memoria sono limitate dalle dimensioni del pool di agenti del servizio di compilazione. Per maggiori informazioni, vedere la sezione Pool di agenti di compilazione di Usare il servizio di compilazione Tanzu. La somma della quota delle risorse di compilazione di elaborazione non può superare le dimensioni del pool di agenti.

Il numero parallelo di attività di compilazione dipende dalle dimensioni del pool di agenti e da ogni risorsa di compilazione. Ad esempio, se la risorsa di compilazione è l'impostazione predefinita 1 vCPU, 2 Gi e le dimensioni del pool di agenti sono 6 vCPU, 12 Gi, il numero di compilazione parallelo è 6.

Altre attività di compilazione vengono bloccate per un periodo di tempo a causa delle limitazioni della quota di risorse.

L'applicazione deve essere in ascolto sulla porta 8080. Le applicazioni Spring Boot eseguono l'override di SERVER_PORT per usare automaticamente 8080.

Lingue supportate per le distribuzioni

La tabella seguente indica le funzionalità supportate per ogni lingua.

Funzionalità	Java	Python	Nodo	.NET Core	Go	File statici	Immagine Nativa Java	PHP
Gestione del ciclo di vita dell’app	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Assegna endpoint	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Monitoraggio di Azure	✔️	✔️	✔️	✔️	✔️	✔️		✔️
Integrazione APM preconfigurata	✔️
Distribuzione blu/verde	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Dominio personalizzato	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Ridimensionamento - Ridimensionamento automatico	✔️	✔️	✔️	✔️	✔️	✔️		✔️
Ridimensionamento: ridimensionamento manuale (in/out, aumento/riduzione)	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Identità gestita	✔️	✔️	✔️	✔️	✔️	✔️	️	✔️
Portale API per VMware Tanzu	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Spring Cloud Gateway per VMware Tanzu	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Servizio di configurazione dell'applicazione per Tanzu VMware	✔️						✔️
Registro dei servizi VMware Tanzu	✔️						✔️
Visualizzazione live dell'app per VMware Tanzu	✔️						✔️
Rete virtuale	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Indirizzo IP in uscita	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
E2E TLS	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Risoluzione dei problemi avanzata - thread/heap/JFR dump	✔️
Usare risorse di archiviazione personali	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Integrare l'associazione di servizi con Connettore di risorse	✔️						✔️
Availability Zone (Zona di disponibilità)	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Eventi del ciclo di vita dell'app	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Dimensioni dell'app ridotte - 0,5 vCPU e 512 MB	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Automatizzare le distribuzioni di app con Terraform e attività di Azure Pipeline	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Eliminazione temporanea	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Esperienza di diagnostica interattiva (basata su AppLens)	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Contratto di servizio	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Personalizzare i probe di integrità	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Connessione della shell Web per la risoluzione dei problemi	✔️	✔️	✔️	✔️	✔️	✔️	️ ✔️	✔️
Debug remoto	✔️				️	️	️

Per maggiori informazioni sulle configurazioni supportate per app per lingue diverse, vedere la sezione corrispondente più avanti in questo articolo.

Limitazioni di Immagine Nativa Java

Immagine nativa è una tecnologia per compilare il codice Java in anticipo in un eseguibile nativo. Le immagini native offrono vari vantaggi, ad esempio un avvio istantaneo e un consumo ridotto di memoria. È possibile creare un pacchetto di immagini native in un'immagine contenitore leggera per una distribuzione più rapida ed efficiente. Per l'Ottimizzazione Closed World, si applicano le limitazioni seguenti:

Le funzionalità Java seguenti richiedono la configurazione in fase di compilazione eseguibile:
- Caricamento di classi dinamiche
- Reflection
- Proxy dinamico
- JNI (Interfaccia Nativa Java)
- Serializzazione
Bytecode non è più disponibile in fase di esecuzione, quindi il debug e il monitoraggio con gli strumenti destinati a JVMTI non sono possibili.

Le funzionalità seguenti non sono supportate in Azure Spring Apps a causa della limitazione di Immagine Nativa Java. Azure Spring Apps li supporterà quando l'Immagine Nativa Java e la community superano la limitazione.

Funzionalità	Perché non è supportato
Monitoraggio di Azure	Le immagini native compilate da GraalVM non supportano le metriche JVM.
Ridimensionamento: scalabilità automatica	Le immagini native compilate da GraalVM non supportano le metriche JVM.
Integrazione APM preconfigurata	APM Vendor & Pacchetti di build non supporta l'immagine nativa.
Identità gestita	Gli SDK di Azure non supportano l'immagine nativa.
Risoluzione dei problemi avanzata: thread/heap/JFR dump	Le immagini native compilate da GraalVM non supportano il thread/heap/JFR dump.
Debug remoto	Le immagini native GraalVM non supportano il Debug Remoto.
Connessione senza password con Connettore di servizi	Azure Java SDK non supporta l'immagine nativa.

Nota

Nelle diverse sezioni di compilazione e implementazione della lingua seguenti, --build-env significa che l'ambiente viene usato nella fase di compilazione. --env indica che l'ambiente viene usato nella fase di runtime.

È consigliabile specificare la versione della lingua nel caso in cui la versione predefinita cambi. Ad esempio, usare --build-env BP_JVM_VERSION=11.* per specificare Java 11 come versione JDK. Per altre lingue, è possibile ottenere il nome della variabile di ambiente nelle descrizioni seguenti per ogni lingua.

Implementare applicazioni Java

Il pacchetto di build per l’implementazione di applicazioni Java è tanzu-buildpacks/java-azure.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Fornisce Microsoft OpenJDK.	Configura la versione di JVM. La versione predefinita di JDK è 17. Attualmente supportato: JDK 8, 11, 17 e 21.	`BP_JVM_VERSION`	`--build-env BP_JVM_VERSION=11.*`
	Runtime env. Configura se Java Native Memory Tracking (NMT) è abilitato. Il valore predefinito è true. Non supportato in JDK 8.	`BPL_JAVA_NMT_ENABLED`	`--env BPL_JAVA_NMT_ENABLED=true`
	Configura il livello di dettaglio per l'output Java Native Memory Tracking (NMT). Il valore predefinito è riepilogo. Impostare su dettaglio per l'output di NMT dettagliato.	`BPL_JAVA_NMT_LEVEL`	`--env BPL_JAVA_NMT_ENABLED=summary`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Integrare con Application Insights, Dynatrace, Elastic, New Relic, App Dynamic APM agent.	Vedere Come configurare l'integrazione APM e i certificati CA.	N/D	N/D
Implementare il pacchetto WAR con Apache Tomcat o TomEE.	Impostare il server applicazioni da usare. Impostare su tomcat per usare Tomcat e tomee per usare TomEE. Il valore predefinito è tomcat.	`BP_JAVA_APP_SERVER`	`--build-env BP_JAVA_APP_SERVER=tomee`
Supportare Applicazioni Spring Boot.	Indica se contribuire al supporto di Associazioni Spring Cloud per l'immagine in fase di compilazione. Il valore predefinito è false.	`BP_SPRING_CLOUD_BINDINGS_DISABLED`	`--build-env BP_SPRING_CLOUD_BINDINGS_DISABLED=false`
	Indica se configurare automaticamente le proprietà dell'ambiente Spring Boot dalle associazioni in fase di esecuzione. Questa funzionalità richiede che le Associazioni Spring Cloud siano già state installate in fase di compilazione altrimenti non fa nulla. Il valore predefinito è false.	`BPL_SPRING_CLOUD_BINDINGS_DISABLED`	`--env BPL_SPRING_CLOUD_BINDINGS_DISABLED=false`
Supportare la compilazione di applicazioni basate su Maven dall'origine.	Usato per un progetto multi modulo. Indica il modulo in cui trovare l'artefatto dell'applicazione. Il valore predefinito è il modulo radice (vuoto).	`BP_MAVEN_BUILT_MODULE`	`--build-env BP_MAVEN_BUILT_MODULE=./gateway`
Supporto per la compilazione di applicazioni basate su Gradle dall'origine.	Usato per un progetto multi modulo. Indica il modulo in cui trovare l'artefatto dell'applicazione. Il valore predefinito è il modulo radice (vuoto).	`BP_GRADLE_BUILT_MODULE`	`--build-env BP_GRADLE_BUILT_MODULE=./gateway`
Abilitare la configurazione delle etichette nell'immagine creata.	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`
Integrare l'agente JProfiler.	Indica se integrare il supporto JProfiler. Il valore predefinito è false.	`BP_JPROFILER_ENABLED`	fase di compilazione: `--build-env BP_JPROFILER_ENABLED=true` fase di runtime: `--env BPL_JPROFILER_ENABLED=true` `BPL_JPROFILER_PORT=<port>` (facoltativo, il valore predefinito è 8849) `BPL_JPROFILER_NOWAIT=true` (facoltativo. Indica se la JVM viene eseguita prima che JProfiler venga collegato. Il valore predefinito è vero.)
	Indica se abilitare il supporto JProfiler in fase di esecuzione. Il valore predefinito è false.	`BPL_JPROFILER_ENABLED`	`--env BPL_JPROFILER_ENABLED=false`
	Indica la porta su cui è in ascolto l'agente JProfiler. Il valore predefinito è 8849.	`BPL_JPROFILER_PORT`	`--env BPL_JPROFILER_PORT=8849`
	Indica se la JVM viene eseguita prima che JProfiler venga collegato. Il valore predefinito è true.	`BPL_JPROFILER_NOWAIT`	`--env BPL_JPROFILER_NOWAIT=true`
Integrare l'agente JRebel.	L'applicazione deve contenere un file rebel-remote.xml.	N/D	N/D
AES crittografa un'applicazione in fase di compilazione e la decrittografa in fase di avvio.	Chiavi AES da usare in fase di compilazione.	`BP_EAR_KEY`	`--build-env BP_EAR_KEY=<value>`
	Chiavi AES da usare in fase di esecuzione.	`BPL_EAR_KEY`	`--env BPL_EAR_KEY=<value>`
Integrare l'agente AspectJ Weaver.	`<APPLICATION_ROOT>`/aop.xml esiste easpectj-weaver.*.jar esiste.	N/D	N/D

Implementare applicazioni .NET

Il pacchetto di build per l’implementazione di applicazioni .NET è tanzu-buildpacks/dotnet-core.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Configurare la versione di runtime .NET Core.	Supporta Net6.0 e Net8.0. È possibile configurare tramite un runtimeconfig.json o un file di progetto MSBuild. Il runtime predefinito è 6.0.*.	N/D	N/D
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Integrare con gli agenti Dynatrace e New Relic APM.	Vedere Come configurare l'integrazione APM e i certificati CA.	N/D	N/D
Abilitare la configurazione delle etichette nell'immagine creata.	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`

Implementare applicazioni Python

Il pacchetto di build per implementare le applicazioni Python è tanzu-buildpacks/python.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Specificare una versione di Python.	Supporta 3.8., 3.9., 3.10., 3.11., 3.12.. Il valore predefinito è 3.10. È possibile specificare la versione tramite `BP_CPYTHON_VERSION` la variabile di ambiente durante la compilazione.	`BP_CPYTHON_VERSION`	`--build-env BP_CPYTHON_VERSION=3.8.*`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Abilitare la configurazione delle etichette nell'immagine creata.	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`

Implementare applicazioni Go

Il pacchetto di build per l’implementazione di applicazioni Go è tanzu-buildpacks/go.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Specificare una versione Go.	Supporta 1.21., 1.22.. Il valore predefinito è 1.21.. La versione Go viene rilevata automaticamente dal file dell'app go.mod*. È possibile eseguire l'override di questa versione impostando la `BP_GO_VERSION` variabile di ambiente in fase di compilazione.	`BP_GO_VERSION`	`--build-env BP_GO_VERSION=1.22.*`
Configurare più destinazioni.	Specificare più destinazioni per una compilazione Go.	`BP_GO_TARGETS`	`--build-env BP_GO_TARGETS=./some-target:./other-target`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Integrare con l'agente di Dynatrace APM.	Vedere Come configurare l'integrazione APM e i certificati CA.	N/D	N/D
Abilitare la configurazione delle etichette nell'immagine creata.	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`

Implementare un'applicazione Node.js

Il pacchetto di build per implementare applicazioni Node.js è tanzu-buildpacks/nodejs.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Specificare una versione del nodo.	Supporta 16., 18., 19., 20.. Il valore predefinito è 20.. È possibile specificare la versione del nodo tramite un file con estensione .nvmrc* o .node-version nella radice della directory dell'applicazione. `BP_NODE_VERSION` sostituisce le impostazioni.	`BP_NODE_VERSION`	`--build-env BP_NODE_VERSION=20.*`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Integrare con Dynatrace, Elastic, New Relic, App Dynamic APM agent.	Vedere Come configurare l'integrazione APM e i certificati CA.	N/D	N/D
Abilitare la configurazione delle etichette nell'immagine creata.	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`
Implementare un'applicazione Angular con Server di sviluppo Angular Live.	Specificare l'host prima dell'esecuzione `ng serve` nel package.json: `ng serve --host 0.0.0.0 --port 8080 --public-host <your application domain name>`. Il nome di dominio dell'applicazione è disponibile nella pagina Panoramicadell'applicazione, nella sezione URL. Rimuovere il protocollo `https://` prima di procedere.	`BP_NODE_RUN_SCRIPTS` `NODE_ENV`	`--build-env BP_NODE_RUN_SCRIPTS=build NODE_ENV=development`

Implementare applicazioni WebServer

Il pacchetto di build per implementare applicazioni WebServer è tanzu-buildpacks/web-servers.

Per altre informazioni, vedere Implementare filestatici Web.

Implementare applicazioni Immagine Nativa Java (anteprima)

Il pacchetto di build per implementare applicazioni di Immagine Nativa Java è tanzu-buildpacks/java-native-image.

È possibile implementare applicazioni di immagini native Spring Boot usando il tanzu-buildpacks/java-native-image pacchetto di build. Spring Native fornisce supporto per la compilazione di applicazioni Spring Boot in eseguibili nativi. Il pacchetto di build usa Liberica Native Image Kit (NIK) per creare immagini native delle applicazioni Spring Boot e queste applicazioni sono completamente supportate.

Quando si compila un'Immagine Nativa Java, è necessario impostare l'ambiente di compilazione BP_NATIVE_IMAGE a true e la risorsa di memoria di compilazione non deve essere inferiore a 8Gi. Le dimensioni del pool di agenti del servizio di compilazione non devono essere minori di 4 vCPU, 8 Gi. Per maggiori informazioni, vedere la sezione Pool di agenti di compilazione di Usare il servizio di compilazione Tanzu.

Se si vuole compilare l'immagine nativa in un'immagine contenitore di dimensioni inferiori, è consigliabile usare un generatore con il Gruppo del sistema operativoJammy Tiny. Per maggiori informazioni, vedere la sezione Consigli del gruppo del sistema operativo.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Integrare con Bellsoft OpenJDK.	Configura la versione di JDK. Attualmente supportato: JDK 8, 11, 17 e 21.	`BP_JVM_VERSION`	`--build-env BP_JVM_VERSION=17`
Configurare gli argomenti per il `native-image` comando.	Argomenti da passare direttamente al comando native-image. Questi argomenti devono essere validi e correttamente formati, altrimenti il comando native-image ha esito negativo.	`BP_NATIVE_IMAGE_BUILD_ARGUMENTS`	`--build-env BP_NATIVE_IMAGE_BUILD_ARGUMENTS="--no-fallback"`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere Come configurare l'integrazione APM e i certificati CA.	Non applicabile.	Non applicabile.
Abilitare la configurazione delle etichette nell'immagine creata	Configura entrambe le etichette specificate dall'OCI con nomi brevi di variabili di ambiente ed etichette arbitrarie usando una sintassi delimitata da spazi in una singola variabile di ambiente.	`BP_IMAGE_LABELS` `BP_OCI_AUTHORS` Vedere altre variabili di ambiente qui.	`--build-env BP_OCI_AUTHORS=<value>`
Supportare la compilazione di applicazioni basate su Maven dall'origine.	Usato per un progetto multi modulo. Indica il modulo in cui trovare l'artefatto dell'applicazione. Il valore predefinito è il modulo radice (vuoto).	`BP_MAVEN_BUILT_MODULE`	`--build-env BP_MAVEN_BUILT_MODULE=./gateway`

Esistono alcune limitazioni per Immagine Nativa Java. Per maggiori informazioni, vedere la sezione Limitazioni di Immagine Nativa Java.

Implementare applicazioni PHP

Il pacchetto di build per Implementare applicazioni PHP è tanzu-buildpacks/php.

Il pacchetto di build PHP Tanzu è compatibile solo con il Gruppo del sistema operativo Full. È consigliabile usare un generatore con il Jammy Full gruppo del sistema operativo. Per maggiori informazioni, vedere la sezione Consigli del gruppo del sistema operativo.

La tabella seguente elenca le funzionalità supportate in Azure Spring Apps:

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Specificare la versione PHP.	Configura la versione PHP. Attualmente supportato: PHP 8.1., 8.2., e 8.3.. Il valore predefinito è 8.1.	`BP_PHP_VERSION`	`--build-env BP_PHP_VERSION=8.1.*`
Aggiungere certificati CA all'archivio attendibilità del sistema in fase di compilazione e runtime.	Vedere la sezione Configurare i certificati CA per le compilazioni e le implementazioni di app di Come configurare l'integrazione di APM e i certificatidella CA.	N/D	N/D
Integrare con Dynatrace, New Relic, App Dynamic APM agent.	Vedere Come configurare l'integrazione APM e i certificati CA.	N/D	N/D
Selezionare un Server Web.	Le opzioni di impostazione sono php-server, httpd, e nginx. Il valore predefinito è php-server.	`BP_PHP_SERVER`	`--build-env BP_PHP_SERVER=httpd`
Configurare la directory Web.	Quando il server Web è HTTPD o NGINX, per impostazione predefinita la directory Web è htdocs. Quando il server Web è il server predefinito PHP, per impostazione predefinita la directory Web è /workspace.	`BP_PHP_WEB_DIR`	`--build-env BP_PHP_WEB_DIR=htdocs`

Passaggi successivi

Implementare file statici Web

Condividi tramite

Come implementare app poliglotte nel piano Enterprise di Azure Spring Apps

Prerequisiti

Implementare applicazioni poliglotte in un'istanza del servizio

Gestire i generatori

Elementi consigliati per il Gruppo del sistema operativo

Gestire il registro contenitori

Compilare e implementare applicazioni poliglotte

Lingue supportate per le distribuzioni

Limitazioni di Immagine Nativa Java

Implementare applicazioni Java

Implementare applicazioni .NET

Implementare applicazioni Python

Implementare applicazioni Go

Implementare un'applicazione Node.js

Implementare applicazioni WebServer

Implementare applicazioni Immagine Nativa Java (anteprima)

Implementare applicazioni PHP

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive