Condividi tramite

Distribuire un'applicazione Java con Open Liberty nelle app Azure Container

Questo articolo illustra come eseguire Open Liberty nelle app contenitore di Azure. In questo articolo vengono eseguite le attività seguenti:

  • Eseguire l'applicazione Java, Java Enterprise Edition (EE), Jakarta EE o MicroProfile nel runtime Open Liberty.
  • Compilare l'immagine Docker dell'applicazione usando le immagini del contenitore Liberty.
  • Distribuire l'applicazione containerizzata su Azure Container Apps.

Per altre informazioni su Open Liberty, vedere la pagina del progetto Open Liberty. Questo articolo è inteso ad aiutarti ad arrivare rapidamente alla distribuzione. Prima di passare alla produzione, è consigliabile esplorare Tuning Liberty.

Se si è interessati a fornire commenti e suggerimenti o lavorare a stretto contatto con il team di progettazione che sviluppa Java in soluzioni Di Azure, compilare questo breve sondaggio sulla migrazione di Azure e includere le informazioni di contatto. Il team di responsabili del programma, architetti e ingegneri si metterà immediatamente in contatto con l'utente per avviare una stretta collaborazione.

Prerequisiti

Accedere ad Azure

Accedere alla sottoscrizione di Azure usando il comando az login e seguire le istruzioni visualizzate.

az login

Nota

È possibile eseguire la maggior parte dei comandi dell'interfaccia della riga di comando di Azure in PowerShell come in Bash. La differenza esiste solo quando si usano variabili. Nelle sezioni seguenti la differenza viene risolta in schede diverse quando necessario.

Se sono associati più tenant di Azure alle credenziali di Azure, è necessario specificare il tenant a cui si vuole accedere. È possibile specificare il tenant usando l'opzione --tenant, ad esempio az login --tenant contoso.onmicrosoft.com.

Se si hanno più sottoscrizioni all'interno di un singolo tenant, assicurarsi di essere connessi con quella che si intende utilizzare attraverso az account set --subscription <subscription-id>.

Creare un gruppo di risorse

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite.

Creare un gruppo di risorse denominato java-liberty-project usando il comando az group create nella posizione eastus2. Questo gruppo di risorse viene usato in un secondo momento per creare l'istanza di Registro Azure Container (ACR) e l'istanza di App Contenitore di Azure.

export RESOURCE_GROUP_NAME=java-liberty-project
export LOCATION=eastus2
az group create --name $RESOURCE_GROUP_NAME --location $LOCATION

Creare un'istanza di Registro Container di Azure

Usare il comando az acr create per creare l'istanza ACR. Nell'esempio seguente viene creata un'istanza di ACR denominata youruniqueacrname. Assicurarsi che youruniqueacrname sia univoco all'interno di Azure.

Nota

Questo articolo usa il meccanismo di autenticazione senza password consigliato per Registro Container. È comunque possibile usare un nome utente e una password con docker login dopo aver usato az acr credential show per ottenere il nome utente e la password. L'uso di un nome utente e di una password è meno sicuro dell'autenticazione senza password.

export REGISTRY_NAME=youruniqueacrname
az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --sku Basic

Dopo un breve periodo di tempo, dovrebbe essere visualizzato un output JSON contenente le righe seguenti:

"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "java-liberty-project",

Usare quindi il comando seguente per recuperare il server di accesso per l'istanza del Registro Container. Questo valore è necessario quando si distribuisce l'immagine dell'applicazione in App Contenitore di Azure in un secondo momento.

export ACR_LOGIN_SERVER=$(az acr show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)

Crea un ambiente

Un ambiente di App contenitore di Azure crea un limite sicuro intorno a un gruppo di app contenitore. Le app contenitore distribuite nello stesso ambiente sono implementate nella stessa rete virtuale e scrivono i log nello stesso workspace di Log Analytics. Usare il comando az containerapp env create per creare un ambiente. L'esempio seguente crea un ambiente denominato youracaenvname:

export ACA_ENV=youracaenvname
az containerapp env create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $LOCATION \
    --name $ACA_ENV

Se viene chiesto di installare un'estensione, rispondere Y.

Dopo un breve periodo di tempo, dovrebbe essere visualizzato un output JSON contenente le righe seguenti:

"provisioningState": "Succeeded",
"type": "Microsoft.App/managedEnvironments"
"resourceGroup": "java-liberty-project",

Creare un database singolo nel database SQL di Azure

In questa sezione viene creato un database singolo nel database SQL di Azure per l'uso con l'app.

Usare prima di tutto i comandi seguenti per impostare le variabili di ambiente correlate al database. Sostituire <your-unique-sql-server-name> con un nome univoco per il server database SQL di Azure.

export SQL_SERVER_NAME=<your-unique-sql-server-name>
export DB_NAME=demodb

Usare quindi i comandi seguenti per creare un database singolo nel database SQL di Azure e impostare l'utente connesso corrente come amministratore di Microsoft Entra. Per altre informazioni, vedere Avvio rapido: Creare un database singolo - Database SQL di Azure.

export ENTRA_ADMIN_NAME=$(az account show --query user.name --output tsv)

az sql server create \
    --name $SQL_SERVER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --enable-ad-only-auth \
    --external-admin-principal-type User \
    --external-admin-name $ENTRA_ADMIN_NAME \
    --external-admin-sid $(az ad signed-in-user show --query id --output tsv)
az sql db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name $DB_NAME \
    --edition GeneralPurpose \
    --compute-model Serverless \
    --family Gen5 \
    --capacity 2

Usare quindi i comandi seguenti per aggiungere l'indirizzo IP locale alle regole del firewall del server di database SQL di Azure per consentire al computer locale di connettersi al database per i test locali in un secondo momento.

export AZ_LOCAL_IP_ADDRESS=$(curl -s https://whatismyip.akamai.com)
az sql server firewall-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name AllowLocalIP \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

Nota

Si crea un server SQL di Azure con autenticazione SQL disabilitata per considerazioni sulla sicurezza. Solo l'ID Microsoft Entra viene usato per eseguire l'autenticazione al server. Se è necessario abilitare l'autenticazione SQL, vedere az sql server create.

Configurare e compilare l'immagine dell'applicazione

Per distribuire ed eseguire l'applicazione Liberty su Azure Container Apps, containerizzare l'applicazione come immagine Docker usando immagini container Open Liberty.

Seguire i passaggi descritti in questa sezione per distribuire l'applicazione di esempio nel runtime Liberty. Questi passaggi usano Maven.

Consultare l'applicazione

Usare i comandi seguenti per preparare il codice di esempio per questa guida. L'esempio è disponibile in GitHub.

git clone https://github.com/Azure-Samples/open-liberty-on-aca.git
cd open-liberty-on-aca
export BASE_DIR=$PWD
git checkout 20250327

Se viene visualizzato un messaggio relativo all'essere in detached HEAD stato, questo messaggio è sicuro da ignorare. Significa semplicemente che hai controllato un tag.

Questo articolo usa java-app. Ecco la struttura di file dei file importanti dell'applicazione:

java-app
├─ src/main/
│  ├─ liberty/config/
│  │  ├─ server.xml
│  ├─ java/
│  ├─ resources/
│  ├─ webapp/
├─ Dockerfile
├─ pom.xml
├─ pom-azure-identity.xml

Le directory java, resources e webapp contengono il codice sorgente dell'applicazione di esempio. Il codice dichiara e usa un'origine dati denominata jdbc/JavaEECafeDB.

Nella directory radice java-app è presente un Dockerfile per creare l'immagine dell'applicazione con Open Liberty.

Nella directory liberty/config viene usato il file server.xml per configurare la connessione di database per Open Liberty. Definisce una variabile azure.sql.connectionstring usata per connettersi al database SQL di Azure.

Il file pom.xml è il file POM (Project Object Model) di Maven che contiene le informazioni di configurazione per il progetto. Il file pom-azure-identity.xml dichiara la dipendenza azure-identity, usata per eseguire l'autenticazione ai servizi di Azure usando l'ID Microsoft Entra.

Nota

Questo esempio usa azure-identity libreria per eseguire l'autenticazione nel database SQL di Azure usando l'autenticazione Microsoft Entra, consigliata per considerazioni sulla sicurezza. Se è necessario usare l'autenticazione SQL nell'applicazione Liberty, vedere Connessioni di database relazionali con JDBC.

Compilare il progetto

Usare i comandi seguenti per compilare l'applicazione:

cd $BASE_DIR/java-app
mvn clean install
mvn dependency:copy-dependencies -f pom-azure-identity.xml -DoutputDirectory=target/liberty/wlp/usr/shared/resources

Se la compilazione ha esito positivo, verrà visualizzato un output simile al seguente alla fine della compilazione.

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  22.651 s
[INFO] Finished at: 2023-10-26T18:58:40-04:00
[INFO] ------------------------------------------------------------------------

Se questo output non viene visualizzato, diagnosticare e risolvere il problema prima di continuare.

Testare il progetto in locale

È ora possibile usare i passaggi seguenti per eseguire e testare il progetto in locale prima di eseguire la distribuzione in Azure. Per praticità, usare il liberty-maven-plugin. Per altre informazioni su liberty-maven-plugin, vedere Compilazione di un'applicazione Web con Maven. Per l'applicazione, è possibile eseguire operazioni simili usando qualsiasi altro meccanismo, ad esempio l'IDE locale.

Nota

Se è stata selezionata una distribuzione di database "serverless", verificare che il database SQL non abbia immesso la modalità di sospensione. Un modo per eseguire la verifica consiste nell'accedere all'editor di query del database come descritto in Avvio rapido: Usare l'editor di query del portale di Azure (anteprima) per eseguire query sul database SQL di Azure.

  1. Avviare l'applicazione usando liberty:run.

    cd $BASE_DIR/java-app

# The value of environment variable AZURE_SQL_CONNECTIONSTRING is read by the configuration variable azure.sql.connectionstring in server.xml.
export AZURE_SQL_CONNECTIONSTRING="jdbc:sqlserver://$SQL_SERVER_NAME.database.windows.net:1433;databaseName=$DB_NAME;authentication=ActiveDirectoryDefault"
mvn liberty:run

  2. Verificare che l'applicazione funzioni come previsto. In caso di esito positivo, verrà visualizzato un messaggio simile a [INFO] [AUDIT ] CWWKZ0001I: Application javaee-cafe started in 11.086 seconds. nell'output del comando. Passare a http://localhost:9080/ nel browser per verificare che l'applicazione sia accessibile e che tutte le funzioni funzionino.

  3. Premere CTRL+C per interrompere. Selezionare Y se viene chiesto di terminare il processo batch.

Al termine, eliminare la regola del firewall che consente all'indirizzo IP locale di accedere al database SQL di Azure usando il comando seguente:

az sql server firewall-rule delete \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name AllowLocalIP

Creare l'immagine per la distribuzione di App Azure Container

È ora possibile eseguire il az acr build comando per compilare l'immagine, come illustrato nell'esempio seguente:

cd $BASE_DIR/java-app

az acr build \
    --registry ${REGISTRY_NAME} \
    --image javaee-cafe:v1 \
    .

Il az acr build comando carica gli artefatti specificati nel Dockerfile nell'istanza del Registro Container, compila l'immagine e la archivia nell'istanza del Registro Container.

Distribuire l'applicazione su Azure Container Apps

Usare i seguenti comandi per creare un'istanza di Azure Container Apps e eseguire l'app dopo il recupero dell'immagine dall'Azure Container Registry. Questo esempio crea un'istanza di App Contenitore di Azure denominata youracainstancename:

export ACA_NAME=youracainstancename
az containerapp create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --image ${ACR_LOGIN_SERVER}/javaee-cafe:v1 \
    --environment $ACA_ENV \
    --registry-server $ACR_LOGIN_SERVER \
    --registry-identity system \
    --target-port 9080 \
    --ingress 'external' \
    --min-replicas 1

L'output riuscito è un oggetto JSON che include la proprietà "type": "Microsoft.App/containerApps".

Connettere quindi il server di database SQL di Azure all'app contenitore usando Service Connector attenendosi alla procedura seguente:

  1. Aprire il portale di Azure nel browser e passare all'istanza di App Contenitore di Azure creata nel passaggio precedente.
  2. Nel riquadro di spostamento selezionare Impostazioni>Service Connector (anteprima).
  3. Fare clic su Crea. Verrà visualizzata la finestra popup Crea connessione.
  4. Nel riquadro Di base , per Tipo di servizio, selezionare Database SQL. Per Tipo di client selezionare Java. Lasciare i valori predefiniti di altri campi, quindi selezionare Avanti: Autenticazione.
  5. Nel riquadro Autenticazione , per Tipo di autenticazione, selezionare Identità gestita assegnata dal sistema e quindi selezionare Avanti: Rete.
  6. Nel riquadro Rete selezionare Avanti: Rivedi e crea.
  7. Nel riquadro Rivedi e crea attendere il superamento della convalida e quindi selezionare Crea in Cloud Shell. Cloud Shell si apre e quindi esegue i comandi per creare la connessione. Attendere il completamento dei comandi e quindi chiudere Cloud Shell.

Nota

Service Connector crea un segreto nell'app contenitore che contiene il valore per AZURE_SQL_CONNECTIONSTRING, ovvero una stringa di connessione senza password al database SQL di Azure. Per ulteriori informazioni, vedere il valore di esempio nella sezione identità gestita assegnata dall'utente di Integrare il database SQL di Azure con il connettore di servizio.

Testare l'applicazione

Usare il comando seguente per ottenere un URL completo per accedere all'applicazione:

echo https://$(az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --query properties.configuration.ingress.fqdn \
    --output tsv)

Per accedere e testare l'applicazione, aprire un Web browser all'URL. Lo screenshot seguente mostra l'applicazione in esecuzione:

Screenshot che mostra l'applicazione Java liberty distribuita correttamente in App Azure Container.

Pulire le risorse

Per evitare addebiti per Azure, è necessario eliminare le risorse non necessarie. Quando il cluster non è più necessario, usare il comando az group delete per rimuovere il gruppo di risorse, il registro contenitori, le app contenitore, il server di database e tutte le risorse correlate.

az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Passaggi successivi

Per altre informazioni, vedere i riferimenti usati in questa guida:

Per esplorare le opzioni per eseguire prodotti WebSphere in Azure, vedere Quali sono le soluzioni per eseguire la famiglia di prodotti WebSphere in Azure?

  • Last updated on