Come implementare app poliglotte nel piano Enterprise di Azure Spring Apps

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:

• Pacchetto di build Azure Java per VMware Tanzu
• Pacchetto di build di .NET Core per VMware Tanzu
• Pacchetto di build Go per VMware Tanzu
• Pacchetto di build di Server Web per VMware Tanzu
• Pacchetto di build Node.js per VMware Tanzu
• Pacchetto di build Python per VMware Tanzu
• Pacchetto di build Immagine Nativa Java per VMware Tanzu
• Pacchetto di build PHP per VMware Tanzu

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:

1. Salvare la configurazione come nuovo generatore.
2. Implementare app con il nuovo generatore. Le distribuzioni sono collegate al nuovo generatore.
3. Eseguire la migrazione delle distribuzioni nel generatore precedente al nuovo generatore.
4. 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.

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

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

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>

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

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.

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

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.

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>

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>

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>

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.

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>

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>

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>

È 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.

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>

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>

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 ogni compilazione, è anche possibile specificare le risorse di compilazione, come illustrato nell'esempio seguente.

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>

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>

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>

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.

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.

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:

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:

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:

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:

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:

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:

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:

Passaggi successivi

• Implementare file statici Web