Come distribuire app polyglot nel piano Enterprise di Azure Spring Apps

Articolo
02/02/2024

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

Questo articolo illustra come distribuire app poliglotte nel piano Enterprise di Azure Spring Apps e come queste app poliglotte possono usare le funzionalità del servizio di compilazione fornite da buildpacks.

Prerequisiti

Un'istanza del piano Enterprise di Azure Spring Apps già di cui è 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 successiva. Usare il comando seguente per installare l'estensione Azure Spring Apps: az extension add --name spring

Distribuire applicazioni polyglot in un'istanza del servizio

Questa sezione si applica alla compilazione e alla distribuzione di applicazioni poliglotte quando il servizio di compilazione è abilitato. Se si disabilita il servizio di compilazione, è possibile distribuire applicazioni solo con un'immagine del contenitore personalizzata. È possibile creare un'immagine personalizzata o usarne una compilata da un'istanza di Azure Spring Apps Enterprise. Per altre informazioni, vedere Distribuire 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 buildpack della famiglia di linguaggio supportati seguenti:

Per altre informazioni, vedere Language Family Buildpacks for VMware Tanzu .For more information, see Language Family Buildpacks for VMware Tanzu.

Questi buildpack 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 buildpack durante la creazione o la visualizzazione di un generatore. È anche possibile creare un generatore personalizzato specificando buildpack e uno stack.

Tutti i generatori configurati in un'istanza del servizio 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. Lo stack del sistema operativo include Bionic Base, Bionic FullJammy 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 altre informazioni, vedere la sezione Raccomandazioni dello stack 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 buildpack o lo stack del sistema operativo, ma il nome del generatore è di sola lettura.

Il generatore è una risorsa che contribuisce continuamente alle distribuzioni. Fornisce le immagini di runtime più recenti e i buildpack 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.
Distribuire 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.

Raccomandazioni per lo stack 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, ad esempio l'impostazione di 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.
- Passare ad app che richiedono alcune librerie C.
- 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 lo Full stack.
- Node.js o app Python con estensioni native.

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

Gestire il registro contenitori

Questa sezione illustra 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 gestiti di Azure Spring Apps, è possibile 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 di sistema.
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 di sistema. 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 si verifica la modifica, tutti i generatori e le risorse di compilazione nel servizio di compilazione ricompilano e quindi le immagini finali del contenitore vengono sottoposte a push nel nuovo registro contenitori.

Azure portal
Interfaccia della riga di comando di Azure

Usare la procedura seguente 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 a cui si fa 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 distribuire applicazioni polyglot

È possibile compilare e distribuire applicazioni polyglot nei modi seguenti usando il registro contenitori:

Per il servizio di compilazione usando il Registro Azure Spring Apps managed container, è possibile compilare un'applicazione in un'immagine e quindi distribuirla nell'istanza corrente del servizio Azure Spring Apps. 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 distribuire l'immagine nell'istanza corrente di Azure Spring Apps Enterprise e in altre istanze. I comandi di compilazione e distribuzione sono separati. È possibile usare il comando di compilazione per creare o aggiornare una compilazione, quindi usare il comando deploy per distribuire l'immagine del contenitore nell'istanza del servizio.

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

Gli esempi seguenti illustrano 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 la distribuzione di un file di artefatto per due scenari del registro contenitori:

Registro Azure Spring Apps managed container.
Registro contenitori gestito dall'utente.

Registro Azure Spring Apps managed container
Registro contenitori gestito dall'utente

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

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 distribuisce usando due comandi. Con un registro contenitori gestito dall'utente, è possibile distribuire un'applicazione solo da un'immagine del contenitore personalizzata. Per altre informazioni, vedere Distribuire 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 build 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 distribuisce 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 distribuisce l'app con un file di artefatto, usare --artifact-path per specificare il percorso del file. I file JAR e WAR sono 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 distribuita in una distribuzione attiva usando il --source-path parametro per specificare la cartella .

Registro Azure Spring Apps managed container
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 build 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 distribuire l'applicazione, vedere Distribuire 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 Azure Spring Apps managed container
Registro contenitori gestito dall'utente

Il comando seguente distribuisce 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 build 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 distribuire l'applicazione, vedere Distribuire un'applicazione con un'immagine del contenitore personalizzata.

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

Registro Azure Spring Apps managed container
Registro contenitori gestito dall'utente

Il comando seguente distribuisce 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 build 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 distribuire l'applicazione, vedere Distribuire 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 , 500Mi1Gi, 2Gie così via. Se l'applicazione richiede una quantità minore o maggiore di risorse della CPU, usare --build-cpu per specificare le risorse della CPU, ad esempio , 500m12, 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 altre informazioni, vedere la sezione Pool di agenti di compilazione di Use Tanzu Build Service (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 build 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	Node	.NET Core	Go	File statici	Immagine nativa Java	PHP
Gestione del ciclo di vita delle app	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Assegna endpoint	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Monitoraggio di Azure	✔️	✔️	✔️	✔️	✔️	✔️		✔️
Integrazione predefinita di APM	✔️
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 VMware Tanzu	✔️						✔️
Registro dei servizi VMware Tanzu	✔️						✔️
Visualizzazione live dell'app per VMware Tanzu	✔️						✔️
Rete virtuale	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Indirizzo IP in uscita	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
E2E TLS	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Risoluzione dei problemi avanzata - dump thread/heap/JFR	✔️
Usare risorse di archiviazione personali	✔️	✔️	✔️	✔️	✔️	✔️	✔️	✔️
Integrare l'associazione di servizi con Resource Connessione or	✔️						✔️
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 altre informazioni sulle configurazioni supportate per app per lingue diverse, vedere la sezione corrispondente più avanti in questo articolo.

Limitazioni di Java Native Image

L'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. A causa dell'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 (Java Native Interface)
- 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 Java Native Image. 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 create da GraalVM non supportano le metriche JVM.
Ridimensionamento: scalabilità automatica	Le immagini native create da GraalVM non supportano le metriche JVM.
Integrazione predefinita di APM	APM Vendor & Buildpack non supporta l'immagine nativa.
Identità gestita	Gli SDK di Azure non supportano l'immagine nativa.
Risoluzione dei problemi avanzata: dump thread/heap/JFR	Le immagini native compilate da GraalVM non supportano il dump thread/heap/JFR.
Debug remoto	GraalVM Native Image non supporta il debug remoto.
Connessione senza password con service Connessione or	Azure Java SDK non supporta l'immagine nativa.

Nota

Nelle diverse sezioni di compilazione e distribuzione 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.

Distribuire applicazioni Java

Il buildpack per la distribuzione 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 nmT (Java Native Memory Tracking). 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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Eseguire l'integrazione con l'agente APM dinamico di Application Insights, Dynatrace, Elastic, New Relic.	Vedere Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Distribuire il pacchetto WAR con Apache Tomcat o Tom edizione Enterprise.	Impostare il server applicazioni da usare. Impostare su tomcat per usare Tomcat e tomee per usare Tom edizione Enterprise. Il valore predefinito è tomcat.	`BP_JAVA_APP_SERVER`	`--build-env BP_JAVA_APP_SERVER=tomee`
Supportare le applicazioni Spring Boot.	Indica se contribuire al supporto di Spring Cloud Bindings 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 o che non esesse 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 multimodulo. 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 multimodulo. 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 e 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 è true.
	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.	Chiave AES da usare in fase di compilazione.	`BP_EAR_KEY`	`--build-env BP_EAR_KEY=<value>`
	Chiave AES da usare in fase di esecuzione.	`BPL_EAR_KEY`	`--env BPL_EAR_KEY=<value>`
Integrare l'agente di AspectJ Weaver .	`<APPLICATION_ROOT>`/ aop.xml esiste ed è presente aspectj-weaver..jar*.	N/D	N/D

Distribuire applicazioni .NET

Il buildpack per la distribuzione 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 di .NET Core.	Supporta Net6.0, Net7.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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Eseguire l'integrazione con gli agenti Dynatrace e New Relic APM.	Vedere Come configurare l'integrazione di APM e i certificati della 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 e 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>`

Distribuire applicazioni Python

Il buildpack per la distribuzione di 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 la variabile di ambiente durante la `BP_CPYTHON_VERSION` 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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della 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 e 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>`

Distribuire applicazioni Go

Il buildpack per la distribuzione 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.20., 1.21.. Il valore predefinito è 1.20.*. La versione go viene rilevata automaticamente dal file go.mod dell'app. È 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.20.*`
Configurare più destinazioni.	Specifica 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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Eseguire l'integrazione con l'agente di Dynatrace APM.	Vedere Come configurare l'integrazione di APM e i certificati della 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 e 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>`

Distribuire applicazioni Node.js

Il buildpack per la distribuzione di 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` esegue l'override delle impostazioni.	`BP_NODE_VERSION`	`--build-env BP_NODE_VERSION=19.*`
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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Eseguire l'integrazione con l'agente APM dinamico Dynatrace, Elastic, New Relic, App.	Vedere Come configurare l'integrazione di APM e i certificati della 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 e 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>`
Distribuire un'applicazione Angular con Angular Live Development Server.	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 Panoramica dell'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`

Distribuire applicazioni WebServer

Il buildpack per la distribuzione di applicazioni WebServer è tanzu-buildpacks/web-servers.

Per altre informazioni, vedere Distribuire file statici Web.

Distribuire applicazioni Java Native Image (anteprima)

Il buildpack per la distribuzione di applicazioni Java Native Image è tanzu-buildpacks/java-native-image.

È possibile distribuire applicazioni di immagini native Spring Boot usando il tanzu-buildpacks/java-native-image buildpack. Spring Native fornisce supporto per la compilazione di applicazioni Spring Boot in eseguibili nativi. Il buildpack 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 BP_NATIVE_IMAGE di compilazione su e la risorsa di memoria di compilazione non deve essere inferiore a true 8Gi. Le dimensioni del pool dell'agente del servizio di compilazione non devono essere minori di 4 vCPU, 8 Gi. Per altre informazioni, vedere la sezione Pool di agenti di compilazione di Use Tanzu Build Service (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 lo stack del Jammy Tiny sistema operativo. Per altre informazioni, vedere la sezione Raccomandazioni dello stack del sistema operativo.

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

Descrizione delle funzionalità	Commento	Variabile di ambiente	Utilizzo
Eseguire l'integrazione con Bellsoft OpenJDK.	Configura la versione di JDK. Attualmente supportato: JDK 8, 11, 17 e 20.	`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 oppure 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 di APM e i certificati della 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 e 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 multimodulo. 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 Java Native Image. Per altre informazioni, vedere la sezione Limitazioni di Java Native Image.

Distribuire applicazioni PHP

Il buildpack per la distribuzione di applicazioni PHP è tanzu-buildpacks/php.

Il buildpack PHP tanzu è compatibile solo con lo stack completo del sistema operativo. È consigliabile usare un generatore con lo stack del Jammy Full sistema operativo. Per altre informazioni, vedere la sezione Raccomandazioni dello stack 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.e 8.2.. Il valore predefinito è 8.1.*	`BP_PHP_VERSION`	`--build-env BP_PHP_VERSION=8.0.*`
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 distribuzioni di app di Come configurare l'integrazione di APM e i certificati della CA.	N/D	N/D
Eseguire l'integrazione con l'agente APM dinamico Dynatrace, New Relic, App.	Vedere Come configurare l'integrazione di APM e i certificati della 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

Distribuire file statici Web

Come distribuire app polyglot nel piano Enterprise di Azure Spring Apps

Prerequisiti

Distribuire applicazioni polyglot in un'istanza del servizio

Gestire i generatori

Raccomandazioni per lo stack del sistema operativo

Gestire il registro contenitori

Compilare e distribuire applicazioni polyglot

Lingue supportate per le distribuzioni

Limitazioni di Java Native Image

Distribuire applicazioni Java

Distribuire applicazioni .NET

Distribuire applicazioni Python

Distribuire applicazioni Go

Distribuire applicazioni Node.js

Distribuire applicazioni WebServer

Distribuire applicazioni Java Native Image (anteprima)

Distribuire applicazioni PHP

Passaggi successivi

Risorse aggiuntive