Share via

Esercitazione: Connessione a Postgre database SQL da un'app contenitore Quarkus Java senza segreti usando un'identità gestita

  • Articolo

App Azure Container offre un'identitàgestita per l'app, una soluzione chiavi in volta per proteggere l'accesso alle Database di Azure per PostgreSQL e ad altri servizi di Azure. Le identità gestite nelle app contenitore rendono l'app più sicura eliminando i segreti dall'app, ad esempio le credenziali nelle variabili di ambiente.

Questa esercitazione illustra il processo di compilazione, configurazione, distribuzione e ridimensionamento di app contenitore Java in Azure. Al termine di questa esercitazione si avrà un'applicazione Quarkus che archivia i dati in un database PostgreSQL con un'identità gestita in esecuzione in App contenitore.

Contenuto dell'esercitazione:

  • Configurare un'app Quarkus per l'autenticazione usando Microsoft Entra ID con postgre database SQL.
  • Creare un registro Azure Container ed eseguirne il push di un'immagine dell'app Java.
  • Creare un'app contenitore in Azure.
  • Creare un database PostgreSQL in Azure.
  • Connessione a un postgre database SQL con identità gestita tramite Service Connessione or.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

1. Prerequisiti

2. Creare un registro contenitori

Creare un gruppo di risorse con il comando az group create. Un gruppo di risorse di Azure è un contenitore logico in cui le risorse di Azure vengono distribuite e gestite.

L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nell'area Stati Uniti orientali di Azure.

az group create --name myResourceGroup --location eastus

Creare un'istanza del Registro Azure Container usando il comando az acr create . Il nome del Registro di sistema deve essere univoco in Azure e contenere 5-50 caratteri alfanumerici. Tutte le lettere devono essere specificate in lettere minuscole. Nell'esempio mycontainerregistry007 seguente viene usato . Aggiornarlo a un valore univoco.

az acr create \
    --resource-group myResourceGroup \
    --name mycontainerregistry007 \
    --sku Basic

3. Clonare l'app di esempio e preparare l'immagine del contenitore

Questa esercitazione usa un'app di elenco Di frutta di esempio con un'interfaccia utente Web che chiama un'API REST Quarkus supportata da Database di Azure per PostgreSQL. Il codice per l'app è disponibile in GitHub. Per altre informazioni sulla scrittura di app Java con Quarkus e PostgreSQL, vedere la Guida all'istanza di Quarkus Hibernate ORM con Panache Guide (Guida all'origine dati Quarkus e Quarkus).

Eseguire i comandi seguenti nel terminale per clonare il repository di esempio e configurare l'ambiente dell'app di esempio.

git clone https://github.com/quarkusio/quarkus-quickstarts
cd quarkus-quickstarts/hibernate-orm-panache-quickstart

Modificare il progetto

  1. Aggiungere le dipendenze necessarie al file bom del progetto.

    <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-providers-jdbc-postgresql</artifactId>
    <version>1.0.0-beta.1</version>
</dependency>

  2. Configurare le proprietà dell'app Quarkus.

    La configurazione di Quarkus si trova nel file src/main/resources/application.properties . Aprire questo file nell'editor e osservare diverse proprietà predefinite. Le proprietà con prefisso %prod vengono usate solo quando l'applicazione viene compilata e distribuita, ad esempio quando viene distribuita in app Azure Servizio. Quando l'applicazione viene eseguita localmente, %prod le proprietà vengono ignorate. Analogamente, %dev le proprietà vengono usate nella modalità Live Coding/Dev di Quarkus e %test le proprietà vengono usate durante i test continui.

    Eliminare il contenuto esistente in application.properties e sostituire con quanto segue per configurare il database per le modalità di sviluppo, test e produzione:

    quarkus.package.type=uber-jar

quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.datasource.db-kind=postgresql
quarkus.datasource.jdbc.max-size=8
quarkus.datasource.jdbc.min-size=2
quarkus.hibernate-orm.log.sql=true
quarkus.hibernate-orm.sql-load-script=import.sql
quarkus.datasource.jdbc.acquisition-timeout = 10

%dev.quarkus.datasource.username=${AZURE_CLIENT_NAME}
%dev.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&sslmode=require\
&azure.clientId=${AZURE_CLIENT_ID}\
&azure.clientSecret=${AZURE_CLIENT_SECRET}\
&azure.tenantId=${AZURE_TENANT_ID}

%prod.quarkus.datasource.username=${AZURE_MI_NAME}
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&sslmode=require

%dev.quarkus.class-loading.parent-first-artifacts=com.azure:azure-core::jar,\
com.azure:azure-core-http-netty::jar,\
io.projectreactor.netty:reactor-netty-core::jar,\
io.projectreactor.netty:reactor-netty-http::jar,\
io.netty:netty-resolver-dns::jar,\
io.netty:netty-codec::jar,\
io.netty:netty-codec-http::jar,\
io.netty:netty-codec-http2::jar,\
io.netty:netty-handler::jar,\
io.netty:netty-resolver::jar,\
io.netty:netty-common::jar,\
io.netty:netty-transport::jar,\
io.netty:netty-buffer::jar,\
com.azure:azure-identity::jar,\
com.azure:azure-identity-providers-core::jar,\
com.azure:azure-identity-providers-jdbc-postgresql::jar,\
com.fasterxml.jackson.core:jackson-core::jar,\
com.fasterxml.jackson.core:jackson-annotations::jar,\
com.fasterxml.jackson.core:jackson-databind::jar,\
com.fasterxml.jackson.dataformat:jackson-dataformat-xml::jar,\
com.fasterxml.jackson.datatype:jackson-datatype-jsr310::jar,\
org.reactivestreams:reactive-streams::jar,\
io.projectreactor:reactor-core::jar,\
com.microsoft.azure:msal4j::jar,\
com.microsoft.azure:msal4j-persistence-extension::jar,\
org.codehaus.woodstox:stax2-api::jar,\
com.fasterxml.woodstox:woodstox-core::jar,\
com.nimbusds:oauth2-oidc-sdk::jar,\
com.nimbusds:content-type::jar,\
com.nimbusds:nimbus-jose-jwt::jar,\
net.minidev:json-smart::jar,\
net.minidev:accessors-smart::jar,\
io.netty:netty-transport-native-unix-common::jar

Compilare ed eseguire il push di un'immagine Docker nel registro contenitori

  1. Compilare l'immagine del contenitore.

    Eseguire il comando seguente per compilare l'immagine dell'app Quarkus. È necessario contrassegnarlo con il nome completo del server di accesso del Registro di sistema. Il nome del server di accesso è nel formato registry-name.azurecr.io> (deve essere tutto minuscolo), ad esempio mycontainerregistry007.azurecr.io.< Sostituire il nome con il proprio nome del Registro di sistema.

    mvnw quarkus:add-extension -Dextensions="container-image-jib"
mvnw clean package -Pnative -Dquarkus.native.container-build=true -Dquarkus.container-image.build=true -Dquarkus.container-image.registry=mycontainerregistry007 -Dquarkus.container-image.name=quarkus-postgres-passwordless-app -Dquarkus.container-image.tag=v1

  2. Accedere al Registro di sistema.

    Prima di eseguire il push delle immagini del contenitore, è necessario accedere al Registro di sistema. A tale scopo, usare il comando [az acr login][az-acr-login]. Specificare solo il nome della risorsa del Registro di sistema durante l'accesso con l'interfaccia della riga di comando di Azure. Non usare il nome completo del server di accesso.

    az acr login --name <registry-name>

    Il comando restituisce un messaggio Login Succeeded al termine dell'esecuzione.

  3. Eseguire il push dell'immagine nel registro.

    Usare [docker push][docker-push] per eseguire il push dell'immagine nell'istanza del Registro di sistema. Sostituire mycontainerregistry007 con il nome del server di accesso dell'istanza del registro. In questo esempio viene creato il quarkus-postgres-passwordless-app repository contenente l'immagine quarkus-postgres-passwordless-app:v1 .

    docker push mycontainerregistry007/quarkus-postgres-passwordless-app:v1

4. Creare un'app contenitore in Azure

  1. Creare un'istanza di App contenitore eseguendo il comando seguente. Assicurarsi di sostituire il valore delle variabili di ambiente con il nome e la posizione effettivi da usare.

    RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"
CONTAINERAPPS_ENVIRONMENT="my-environment"

az containerapp env create \
    --resource-group $RESOURCE_GROUP \
    --name $CONTAINERAPPS_ENVIRONMENT \
    --location $LOCATION

  2. Creare un'app contenitore con l'immagine dell'app eseguendo il comando seguente. Sostituire i segnaposto con i valori. Per trovare i dettagli dell'account amministratore del registro contenitori, vedere Eseguire l'autenticazione con un registro Azure Container

    CONTAINER_IMAGE_NAME=quarkus-postgres-passwordless-app:v1
REGISTRY_SERVER=mycontainerregistry007
REGISTRY_USERNAME=<REGISTRY_USERNAME>
REGISTRY_PASSWORD=<REGISTRY_PASSWORD>

az containerapp create \
    --resource-group $RESOURCE_GROUP \
    --name my-container-app \
    --image $CONTAINER_IMAGE_NAME \
    --environment $CONTAINERAPPS_ENVIRONMENT \
    --registry-server $REGISTRY_SERVER \
    --registry-username $REGISTRY_USERNAME \
    --registry-password $REGISTRY_PASSWORD

5. Creare e connettere un database PostgreSQL con connettività di identità

Creare quindi un'app Postgre database SQL e configurare l'app contenitore per connettersi a un postgre database SQL con un'identità gestita assegnata dal sistema. L'app Quarkus si connetterà a questo database e archivierà i dati durante l'esecuzione, mantenendo lo stato dell'applicazione indipendentemente da dove si esegue l'applicazione.

  1. Creare il servizio di database.

    DB_SERVER_NAME='msdocs-quarkus-postgres-webapp-db'
ADMIN_USERNAME='demoadmin'
ADMIN_PASSWORD='<admin-password>'

az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name $DB_SERVER_NAME \
    --location $LOCATION \
    --admin-user $DB_USERNAME \
    --admin-password $DB_PASSWORD \
    --sku-name GP_Gen5_2

I parametri seguenti vengono usati nel comando dell'interfaccia della riga di comando di Azure precedente:

  • gruppo di risorse → Usare lo stesso nome del gruppo di risorse in cui è stata creata l'app Web, ad esempio msdocs-quarkus-postgres-webapp-rg.

  • name → Il nome del server di database PostgreSQL. Questo nome deve essere univoco in tutti gli Azure (l'endpoint server diventa https://<name>.postgres.database.azure.com). I caratteri consentiti sono A-Z, 0-9 e -. Un modello valido consiste nell'usare una combinazione del nome della società e dell'identificatore del server. (msdocs-quarkus-postgres-webapp-db)

  • location → Usare la stessa posizione usata per l'app Web.

  • admin-user → Nome utente per l'account amministratore. Non può essere azure_superuser, admin, administrator, root, guesto public. Ad esempio, demoadmin va bene.

  • admin-password → Password dell'utente amministratore. Deve contenere da 8 a 128 caratteri da tre delle categorie seguenti: lettere maiuscole, lettere minuscole, numeri e caratteri non alfanumerici.

    Importante

    Quando si creano nomi utente o password non si usa il $ carattere . Più avanti in questa esercitazione si creeranno variabili di ambiente con questi valori in cui il $ carattere ha un significato speciale all'interno del contenitore Linux usato per eseguire app Java.

  • public-access → None che imposta il server in modalità di accesso pubblico senza regole del firewall. Le regole verranno create in un passaggio successivo.

  • sku-name → Il nome del piano tariffario e della configurazione di calcolo, ad esempio GP_Gen5_2. Per altre informazioni, vedere Piano tariffario di Database di Azure per PostgreSQL.

  1. Creare un database denominato fruits all'interno del servizio PostgreSQL con questo comando:

    az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP \
    --server-name $DB_SERVER_NAME \
    --database-name fruits

  2. Installare l'estensione senza password del servizio Connessione or per l'interfaccia della riga di comando di Azure:

    az extension add --name serviceconnector-passwordless --upgrade

  3. Connessione il database all'app contenitore con un'identità gestita assegnata dal sistema usando il comando di connessione.

    az containerapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name my-container-app \
    --target-resource-group $RESOURCE_GROUP \
    --server $DB_SERVER_NAME \
    --database fruits \
    --managed-identity

6. Esaminare le modifiche

È possibile trovare l'URL dell'applicazione (FQDN) usando il comando seguente:

az containerapp list --resource-group $RESOURCE_GROUP

Quando la nuova pagina Web mostra l'elenco di frutti, l'app si connette al database usando l'identità gestita. Dovrebbe ora essere possibile modificare l'elenco di frutta come in precedenza.

Pulire le risorse

Nei passaggi precedenti sono state create risorse di Azure in un gruppo di risorse. Se si ritiene che queste risorse non saranno necessarie in futuro, eliminare il gruppo di risorse eseguendo questo comando in Cloud Shell:

az group delete --name myResourceGroup

L'esecuzione del comando può richiedere un minuto.

Passaggi successivi

Altre informazioni sull'esecuzione di app Java in Azure sono disponibili nella guida per sviluppatori.

Azure per sviluppatori Java