Distribuzione di un'applicazione Quarkus in App contenitore di Azure

In questa unità si crea il pacchetto dell'applicazione Quarkus e lo si distribuisce in App contenitore di Azure con la password del database specificata come segreto di runtime.

Continuare nella shell Bash locale dell'unità precedente, nella directory del progetto generato todo . Mantenere tutte le variabili di risorsa e database esportate in tale shell. Arrestare la modalità di sviluppo Quarkus in primo piano con CTRL+C prima della creazione del pacchetto e non eseguire nuovamente il blocco di password e nome casuale.

Configurare il Dockerfile per l'applicazione Quarkus

Container Apps viene usato per distribuire applicazioni containerizzate. È quindi prima necessario containerizzare l'applicazione Quarkus in un'immagine Docker. Questo processo è semplice perché il plug-in Quarkus Maven ha già generato alcuni Dockerfile in src/main/docker.

Usare questo comando per rinominare uno di questi Dockerfile, Dockerfile.jvm, in Dockerfile e spostarlo nella cartella radice:

mv src/main/docker/Dockerfile.jvm ./Dockerfile

Sostituire il contenuto dopo il commento lungo nel Dockerfile con quanto segue:

FROM registry.access.redhat.com/ubi8/openjdk-17:1.18

ENV LANGUAGE='en_US:en'


# We make four distinct layers so if there are application changes the library layers can be re-used
COPY --chown=185 target/quarkus-app/lib/ /deployments/lib/
COPY --chown=185 target/quarkus-app/*.jar /deployments/
COPY --chown=185 target/quarkus-app/app/ /deployments/app/
COPY --chown=185 target/quarkus-app/quarkus/ /deployments/quarkus/

EXPOSE 8080
USER 185
ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"

ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]

Questo Dockerfile si aspetta l'applicazione Quarkus compressa nella cartella target/quarkus-app, tra cui l'utilità di avvio quarkus-run.jar e le relative directory di supporto. Mantenere le espressioni letterali con ambito del profilo dall'unità precedente in application.properties. Con Docker in esecuzione e accessibile da questo ambiente Bash, eseguire un pacchetto pulito:

./mvnw clean package

Questo comando esegue i test automatizzati su un servizio di sviluppo PostgreSQL separato e crea un pacchetto dell'applicazione in target/quarkus-app. Il test profilo non deve utilizzare il database Azure. Non saltare i test; risolvi eventuali errori di compilazione o test prima di continuare. Un pacchetto pulito evita anche di riutilizzare l'output di compilazione precedente dell'applicazione che potrebbe contenere credenziali letterali.

La ricompilazione dell'immagine corrente non rimuove le credenziali dalle immagini precedenti o dalle copie di origine. Se in precedenza è stato distribuito o esposto un artefatto contenente credenziali, ruotare le credenziali e rimuovere gli artefatti obsoleti tramite il processo di pulizia autorizzato. I passaggi di distribuzione seguenti non eseguono la rotazione né rimuovono gli artefatti precedenti.

Creare l'ambiente Container Apps e distribuire il container

Distribuire in tre fasi in modo che Quarkus non venga avviato prima che siano disponibili le impostazioni di runtime e del segreto del database. Usare solo la nuova app di proprietà dell'esercizio denominata in AZ_CONTAINERAPP, in AZ_RESOURCE_GROUP. Non eseguire il passaggio bootstrap su un'app non correlata o di produzione. Completare ogni comando correttamente prima di continuare.

Creare prima di tutto l'app e l'ambiente usando l'immagine di avvio rapido pubblico di Microsoft. Questa immagine temporanea è in ascolto sulla porta 80 e non richiede credenziali del database:

az containerapp up \
    --name "$AZ_CONTAINERAPP" \
    --environment "$AZ_CONTAINERAPP_ENV" \
    --location "$AZ_LOCATION" \
    --resource-group "$AZ_RESOURCE_GROUP" \
    --image mcr.microsoft.com/k8se/quickstart:latest \
    --ingress external \
    --target-port 80

Questa chiamata crea l'app, l'ambiente e l'area di lavoro predefinita di analisi dei log nel gruppo di risorse dell'esercizio. Non esegue ancora il deployment della tua applicazione Quarkus.

Archiviare quindi la password del database come segreto nell'app esistente prima di farvi riferimento:

az containerapp secret set \
    --name "$AZ_CONTAINERAPP" \
    --resource-group "$AZ_RESOURCE_GROUP" \
    --secrets "postgres-password=$AZ_POSTGRES_PASSWORD" \
    --output none

Infine, dalla radice del progetto todo, distribuire l'applicazione Quarkus ripulita nella stessa app, ambiente e gruppo di risorse. La porta di destinazione viene modificata in 8080. I primi due valori di runtime provengono dalla shell corrente; la password viene fornita tramite un riferimento segreto:

az containerapp up \
    --name "$AZ_CONTAINERAPP" \
    --environment "$AZ_CONTAINERAPP_ENV" \
    --location "$AZ_LOCATION" \
    --resource-group "$AZ_RESOURCE_GROUP" \
    --ingress external \
    --target-port 8080 \
    --source . \
    --env-vars \
        "AZ_POSTGRES_JDBC_URL=$AZ_POSTGRES_JDBC_URL" \
        "AZ_POSTGRES_USERNAME=$AZ_POSTGRES_USERNAME" \
        "AZ_POSTGRES_PASSWORD=secretref:postgres-password"

Questa distribuzione da origine locale crea un registro contenitori Azure, se necessario, compila l'immagine Docker dal Dockerfile radice, la invia al registro contenitori e aggiorna l'app esistente con l'immagine Quarkus e la configurazione del runtime. Mantiene il segreto del database durante la configurazione dell'accesso al registro. Il completamento dei comandi può richiedere alcuni minuti.

Tutte le risorse create da questo esercizio rimangono in AZ_RESOURCE_GROUP, quindi la pulizia del gruppo di risorse alla fine del modulo viene ancora applicata. Questo esercizio basato su password mantiene il flusso predefinito di autenticazione al registry di az containerapp up; non è un'architettura di sicurezza di produzione completa.

Convalidare la distribuzione

Verificare prima di tutto che le risorse siano state create cercando il gruppo di risorse nel portale di Azure. Dovrebbero essere visualizzate risorse simili alle seguenti: I nomi generati variano:

È anche possibile elencare le risorse nel gruppo di risorse dell'esercizio, tra cui PostgreSQL e le risorse create da az containerapp up:

az resource list \
    --location "$AZ_LOCATION" \
    --resource-group "$AZ_RESOURCE_GROUP" \
    --output table

L'output visualizzato sarà simile all'esempio seguente:

Name                               ResourceGroup        Location    Type                                       Status
---------------------------------  -------------------  ----------  -----------------------------------------  --------
caea3a6e0afeacr                     rgquarkus-12345678   eastus      Microsoft.ContainerRegistry/registries
psqlquarkus-12345678                rgquarkus-12345678   eastus      Microsoft.DBforPostgreSQL/flexibleServers
caquarkus-12345678                  rgquarkus-12345678   eastus      Microsoft.App/containerApps
caequarkus-12345678                 rgquarkus-12345678   eastus      Microsoft.App/managedEnvironments
workspace-rgquarkus12345678abcd     rgquarkus-12345678   eastus      Microsoft.OperationalInsights/workspaces

La creazione di risorse da sola non conferma l'idoneità dell'applicazione. Nel portale di Azure aprire l'app contenitore ed esaminarne la revisione attiva. Verifica che usi l'immagine Quarkus appena compilata, non mcr.microsoft.com/k8se/quickstart:latest, e si avvii correttamente. Risolvere gli errori di avvio prima di continuare con i controlli POST e GET. Una pagina di avvio rapido temporaneo funzionante non dimostra che il deployment di Quarkus è riuscito.

Verificare l'applicazione distribuita

Una volta che la revisione di Quarkus è in esecuzione, verificare l'API dell'applicazione. Prima di tutto, ottenere l'FQDN in ingresso completo nella stessa shell Bash:

export AZ_APP_URL=$(
    az containerapp show \
        --name "$AZ_CONTAINERAPP" \
        --resource-group "$AZ_RESOURCE_GROUP" \
        --query "properties.configuration.ingress.fqdn" \
        --output tsv \
)

echo "AZ_APP_URL=$AZ_APP_URL"

Usare il nome di dominio completo restituito in AZ_APP_URL. Include il suffisso DNS dell'ambiente. L'endpoint to-do dell'applicazione è https://<the AZ_APP_URL value>/api/todos. Container Apps fornisce la terminazione HTTPS/TLS per questo endpoint predefinito.

Creare un to-do usando cURL. L'opzione --include visualizza le intestazioni di risposta in modo che sia possibile verificare la presenza di HTTP 201 e il corpo JSON dell'elemento creato:

curl --include --header "Content-Type: application/json" \
    --request POST \
    --data '{"description":"Configuration","details":"Congratulations, you have set up your Quarkus application correctly!","done": "true"}' \
    "https://$AZ_APP_URL/api/todos"

Recuperare i dati usando una nuova richiesta cURL. Verificare la presenza di HTTP 200 e gli elementi creati in questa unità e nell'unità precedente:

curl --include "https://$AZ_APP_URL/api/todos"

Il corpo della risposta è un array JSON contenente gli elementi creati nel database Azure. Gli identificatori, i timestamp e l'ordine possono variare. La ripetizione di un POST crea un altro elemento; questo esempio è illustrativo, non un'asserzione di risposta esatta:

[
   {
      "description" : "Take Quarkus MS Learn",
      "details" : "Take the MS Learn on deploying Quarkus to Azure Container Apps",
      "done" : true,
      "id" : 1,
      "createdAt" : "2025-02-26T08:03:28.390854Z"
   },
   {
      "description" : "Take Azure Container Apps MS Learn",
      "details" : "Take the ACA Learn module",
      "done" : false,
      "id" : 2,
      "createdAt" : "2025-02-26T08:03:34.142249Z"
   },
   {
      "description" : "Configuration",
      "details" : "Congratulations, you have set up your Quarkus application correctly!",
      "done" : true,
      "id" : 3,
      "createdAt" : "2025-02-26T08:05:00.000000Z"
   }
]

Le risposte POST e GET riuscite della revisione di Quarkus, con le descrizioni previste, confermano il controllo dell'applicazione. Non usare solo la pagina bootstrap o l'elenco di risorse come criterio di esito positivo.

Per visualizzare in streaming i log del contenitore, eseguire questo comando nella shell Bash contenente le variabili di risorsa:

az containerapp logs show \
    --name "$AZ_CONTAINERAPP" \
    --resource-group "$AZ_RESOURCE_GROUP" \
    --follow

In un secondo terminale Bash locale sostituire <returned-fqdn> con l'FQDN completo visualizzato in precedenza e inviare altre richieste seguendo i log. Questo terminale richiede solo l'indirizzo dell'applicazione, non la password del database:

export AZ_APP_URL="<returned-fqdn>"
curl --include "https://$AZ_APP_URL/api/todos"

Quando hai finito di seguire i log, premi Ctrl+C nel terminale originale. Mantenere aperta la shell con le relative variabili di risorsa per la prossima unità.