Condividi tramite

Distribuire un'applicazione Java con Open Liberty o WebSphere Liberty nelle app contenitore di Azure

  • Articolo

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

  • Eseguire l'applicazione Java, Java EE, Jakarta EE o MicroProfile nel runtime Open Liberty o WebSphere Liberty.
  • Compilare l'immagine Docker dell'applicazione usando le immagini del contenitore Liberty.
  • Distribuire l'applicazione in contenitori in App Azure Container.

Per altre informazioni su Open Liberty, vedere la pagina del progetto Open Liberty. Per altre informazioni su IBM WebSphere Liberty, vedere la pagina del prodotto WebSphere Liberty.

Questo articolo è progettato per facilitare rapidamente la distribuzione. Prima di passare alla produzione, è consigliabile esplorare Tuning Liberty.

Se si è interessati a fornire commenti e suggerimenti o lavorare sugli scenari di migrazione in stretta collaborazione con il team di progettazione che sviluppa WebSphere nelle soluzioni di Azure, compilare questo breve sondaggio sulla migrazione di WebSphere 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

Se non è già stato fatto, 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 eseguire questa operazione con l'opzione --tenant , az login --tenant contoso.onmicrosoft.comad esempio .

Se sono presenti più sottoscrizioni all'interno di un singolo tenant, assicurarsi di aver eseguito l'accesso con quello che si intende usare usando 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 località eastus . 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
az group create --name $RESOURCE_GROUP_NAME --location eastus

Creare un'istanza di Registro Azure Container

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

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

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

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

Connettersi all'istanza di Registro Azure Container

È necessario accedere all'istanza di Registro Azure Container prima di poter eseguire il push di un'immagine. Se si sceglie di eseguire i comandi in locale, assicurarsi che il daemon Docker sia in esecuzione ed eseguire i comandi seguenti per verificare la connessione:

export ACR_LOGIN_SERVER=$(az acr show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
export ACR_USER_NAME=$(az acr credential show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --query 'username' \
    --output tsv)
export ACR_PASSWORD=$(az acr credential show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --query 'passwords[0].value' \
    --output tsv)

docker login $ACR_LOGIN_SERVER -u $ACR_USER_NAME -p $ACR_PASSWORD

Se è stato eseguito correttamente l'accesso all'istanza di Registro Azure Container, verrà visualizzato Login Succeeded alla fine dell'output del comando.

Crea un ambiente

Un ambiente di App contenitore di Azure crea un limite sicuro intorno a un gruppo di app contenitore. Le app contenitore nello stesso ambiente vengono distribuite nella stessa rete virtuale e scrivono log nella stessa area di lavoro 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 eastus \
    --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 SQL di Azure

In questa sezione viene creato un database singolo database SQL di Azure da usare con l'app.

Creare un database singolo in database SQL di Azure seguendo i passaggi dell'interfaccia della riga di comando di Azure in Avvio rapido: Creare un database singolo - database SQL di Azure. Eseguire i passaggi fino a , ma non includere Eseguire query sul database. Seguire questa procedura durante l'articolo, quindi tornare a questo documento dopo aver creato e configurato il server di database:

Quando si raggiunge la sezione Impostare i valori dei parametri della guida introduttiva, l'output e salvare i valori delle variabili nell'esempio di codice etichettato Variable block, tra cui resourceGroup,serverdatabase , login, e password. Definire le variabili di ambiente seguenti dopo aver sostituito i segnaposto <resourceGroup>, <database><server>, , <login>e <password> con questi valori.

export DB_RESOURCE_GROUP=<resourceGroup>
export DB_SERVER_NAME=<server>.database.windows.net
export DB_NAME=<database>
export DB_USER=<login>
export DB_PASSWORD=<password>

Se si vuole testare l'applicazione in locale in un secondo momento, seguire questa procedura per assicurarsi che l'indirizzo IPv4 client sia autorizzato a connettersi:

  1. Nel portale cercare e selezionare Database SQL, quindi selezionare il database nell'elenco.

  2. Selezionare Panoramica.

  3. Verificare che la scheda Attività iniziali sia selezionata al centro della pagina.

  4. In Configura accesso selezionare Configura.

  5. Selezionare Aggiungi l'indirizzo IPv4 del client.

  6. Seleziona Salva.

  7. È possibile trovare e configurare le regole del firewall nel riquadro Rete e nella scheda Accesso pubblico.

    Screenshot delle regole del firewall: consente l'accesso client.

Configurare e compilare l'immagine dell'applicazione

Per distribuire ed eseguire l'applicazione Liberty in App Azure Container, inserire l'applicazione come immagine Docker usando immagini del contenitore Open Liberty o immagini del contenitore WebSphere 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
git checkout 20231026

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

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

java-app
├─ src/main/
│  ├─ liberty/config/
│  │  ├─ server.xml
│  ├─ java/
│  ├─ resources/
│  ├─ webapp/
├─ Dockerfile
├─ Dockerfile-wlp
├─ pom.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 sono disponibili due file per creare l'immagine dell'applicazione con Open Liberty o WebSphere Liberty.

Nella directory liberty/config il file server.xml viene usato per configurare la connessione db per il cluster Open Liberty e WebSphere Liberty.

Compilare il progetto

Usare il comando seguente per compilare l'applicazione:

cd <path-to-your-repo>/java-app
mvn clean install

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, risolvere e risolvere il problema prima di continuare.

(Facoltativo) 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 .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 sia stato attivato in modalità di sospensione. Un modo per eseguire questa operazione consiste nell'accedere all'editor di query del database come descritto in Avvio rapido: Usare l'editor di query portale di Azure (anteprima) per eseguire query database SQL di Azure.

  1. Avviare l'applicazione usando liberty:run. liberty:run usa le variabili di ambiente correlate al database definite nel passaggio precedente.

    cd <path-to-your-repo>/java-app
mvn liberty:run

  2. Verificare che l'applicazione funzioni come previsto. Se ha esito positivo, verrà visualizzato un messaggio simile a [INFO] [AUDIT] CWWKZ0003I: The application javaee-cafe updated in 1.930 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 arrestarsi.

Compilare l'immagine

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

cd <path-to-your-repo>/java-app

# If you are running with Open Liberty
docker buildx build --platform linux/amd64 -t javaee-cafe:v1 --pull --file=Dockerfile .

# If you are running with WebSphere Liberty
docker buildx build --platform linux/amd64 -t javaee-cafe:v1 --pull --file=Dockerfile-wlp .

(Facoltativo) Testare l'immagine Docker in locale

È ora possibile usare la procedura seguente per testare l'immagine Docker in locale prima di eseguire la distribuzione in Azure:

  1. Eseguire l'immagine usando il comando seguente. Questo comando usa le variabili di ambiente correlate al database definite in precedenza.

    docker run -it --rm -p 9080:9080 \
    -e DB_SERVER_NAME=${DB_SERVER_NAME} \
    -e DB_NAME=${DB_NAME} \
    -e DB_USER=${DB_USER} \
    -e DB_PASSWORD=${DB_PASSWORD} \
    javaee-cafe:v1

  2. Dopo l'avvio del contenitore, passare a http://localhost:9080/ nel browser per accedere all'applicazione.

  3. Premere CTRL+C per arrestarsi.

Caricare un'immagine nel record di controllo di accesso

Caricare quindi l'immagine compilata nel Registro Azure Container creato nei passaggi precedenti.

Se non è già stato fatto, usare il comando seguente per accedere al Registro Azure Container:

docker login -u ${ACR_USER_NAME} -p ${ACR_PASSWORD} ${ACR_LOGIN_SERVER}

Usare i comandi seguenti per contrassegnare ed eseguire il push dell'immagine del contenitore:

docker tag javaee-cafe:v1 ${ACR_LOGIN_SERVER}/javaee-cafe:v1
docker push ${ACR_LOGIN_SERVER}/javaee-cafe:v1

Distribuire l'applicazione in App Azure Container

Usare i comandi seguenti per creare un'istanza di App Contenitore di Azure per eseguire l'app dopo il pull dell'immagine dal Registro Azure Container. Questo esempio crea un'istanza di App Contenitore di Azure denominata nomenomeistanza.

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-username $ACR_USER_NAME \
    --registry-password $ACR_PASSWORD \
    --target-port 9080 \
    --env-vars \
        DB_SERVER_NAME=${DB_SERVER_NAME} \
        DB_NAME=${DB_NAME} \
        DB_USER=${DB_USER} \
        DB_PASSWORD=${DB_PASSWORD} \
    --ingress 'external'

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

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)

Aprire un Web browser all'URL per accedere e testare l'applicazione. 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
az group delete --name $DB_RESOURCE_GROUP --yes --no-wait

Usare quindi il comando seguente per rimuovere l'immagine del contenitore dal server Docker locale:

docker rmi -f ${ACR_LOGIN_SERVER}/javaee-cafe:v1

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?