Esercitazione: Connettersi a un database PostgreSQL dal servizio app Tomcat Java senza segreti usando un'identità gestita

Articolo
08/01/2024

Il Servizio app di Azure fornisce un servizio di hosting Web ad alta scalabilità e con funzioni di auto-correzione in Azure. Offre anche un'identità gestita per l'app, una soluzione chiavi in mano per proteggere l'accesso a Database di Azure per PostgreSQL e ad altri servizi di Azure. Le identità gestite nel servizio app rendono l'app più sicura eliminando i segreti dall'app, ad esempio le credenziali nelle variabili di ambiente. In questa esercitazione apprenderai a:

Creare un database PostgreSQL.
Distribuire l'app di esempio in Servizio app di Azure in Tomcat usando la creazione di pacchetti WAR.
Configurare un'applicazione Web Tomcat per l'uso dell'autenticazione di Microsoft Entra con il database PostgreSQL.
Connettersi al database PostgreSQL con identità gestita tramite la funzionalità Connettore servizio.

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

Prerequisiti

Git
Java JDK
Maven
Interfaccia della riga di comando di Azure versione 2.45.0 o successiva.

Clonare l'app di esempio e preparare il repository

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/Azure-Samples/Passwordless-Connections-for-Java-Apps
cd Passwordless-Connections-for-Java-Apps/Tomcat/

Creare un database di Azure per PostgreSQL

Seguire questi passaggi per creare un'istanza di Database di Azure per Postgres nella propria sottoscrizione. L'app Tomcat si connetterà a questo database e archivierà i propri dati durante l'esecuzione, rendendo persistente lo stato dell'applicazione indipendentemente dalla posizione in cui viene eseguita.

Accedere all'interfaccia della riga di comando di Azure e facoltativamente impostare la sottoscrizione se sono presenti più sottoscrizioni collegate alle proprie credenziali di accesso.
```
az login
az account set --subscription <subscription-ID>
```

Creare un gruppo di risorse di Azure prendendo nota del nome.

export RESOURCE_GROUP=<resource-group-name>
export LOCATION=eastus

az group create --name $RESOURCE_GROUP --location $LOCATION

Creare un Database di Azure per PostgreSQL. Il server viene creato con un account Administrator, ma non viene usato perché si userà l'account Administrator di Microsoft Entra per eseguire attività amministrative.

export POSTGRESQL_ADMIN_USER=azureuser
# PostgreSQL admin access rights won't be used because Azure AD authentication is leveraged to administer the database.
export POSTGRESQL_ADMIN_PASSWORD=<admin-password>
export POSTGRESQL_HOST=<postgresql-host-name>

# Create a PostgreSQL server.
az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name $POSTGRESQL_HOST \
    --location $LOCATION \
    --admin-user $POSTGRESQL_ADMIN_USER \
    --admin-password $POSTGRESQL_ADMIN_PASSWORD \
    --public-access 0.0.0.0 \
    --sku-name Standard_D2s_v3

Creare un database per l'applicazione.

export DATABASE_NAME=checklist

az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP \
    --server-name $POSTGRESQL_HOST \
    --database-name $DATABASE_NAME

Distribuire l'applicazione nel servizio app

Seguire questa procedura per compilare un file WAR e distribuirlo nel Servizio app di Azure in Tomcat usando un pacchetto WAR.

L'app di esempio contiene un file pom.xml che può generare il file WAR. Eseguire il comando seguente per compilare l'app.
```
mvn clean package -f pom.xml
```

Creare una risorsa del servizio app di Azure in Linux usando Tomcat 9.0.

export APPSERVICE_PLAN=<app-service-plan>
export APPSERVICE_NAME=<app-service-name>
# Create an App Service plan
az appservice plan create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_PLAN \
    --location $LOCATION \
    --sku B1 \
    --is-linux

# Create an App Service resource.
az webapp create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --plan $APPSERVICE_PLAN \
    --runtime "TOMCAT:10.0-java11"

Distribuire il pacchetto WAR nel servizio app.

az webapp deploy \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --src-path target/app.war \
    --type war

Connettere il database Postgres con la connettività di identità

Connettere quindi il database usando la funzionalità Connettore di servizi.

Installare l'estensione senza password Connettore di servizi per l'interfaccia della riga di comando di Azure:

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

Connettere quindi l'app a un database Postgres con un'identità gestita assegnata dal sistema usando la funzionalità Connettore di servizi.

Per stabilire questa connessione, eseguire il comando az webapp connection create.

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type java

Questo comando crea una connessione tra l'app Web e il server PostgreSQL e gestisce l'autenticazione tramite un'identità gestita assegnata dal sistema.

Aggiornare quindi le impostazioni dell'app e aggiungere il plug-in nella stringa di connessione

export AZURE_POSTGRESQL_CONNECTIONSTRING=$(\
    az webapp config appsettings list \
        --resource-group $RESOURCE_GROUP \
        --name $APPSERVICE_NAME \
    | jq -c -r '.[] \
    | select ( .name == "AZURE_POSTGRESQL_CONNECTIONSTRING" ) \
    | .value')

az webapp config appsettings set \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --settings 'CATALINA_OPTS=-DdbUrl="'"${AZURE_POSTGRESQL_CONNECTIONSTRING}"'&authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin"'

Testare l'app Web di esempio

Eseguire il comando seguente per testare l'applicazione.

export WEBAPP_URL=$(az webapp show \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --query defaultHostName \
    --output tsv)

# Create a list
curl -X POST -H "Content-Type: application/json" -d '{"name": "list1","date": "2022-03-21T00:00:00","description": "Sample checklist"}' https://${WEBAPP_URL}/checklist

# Create few items on the list 1
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 1"}' https://${WEBAPP_URL}/checklist/1/item
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 2"}' https://${WEBAPP_URL}/checklist/1/item
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 3"}' https://${WEBAPP_URL}/checklist/1/item

# Get all lists
curl https://${WEBAPP_URL}/checklist

# Get list 1
curl https://${WEBAPP_URL}/checklist/1

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 nel Servizio app in Linux sono disponibili nella Guida per gli sviluppatori.

Guida dello sviluppatore Java per il servizio app in Linux

Informazioni su come proteggere l'app con un dominio e un certificato personalizzati.

Proteggere con dominio personalizzato e certificato di protezione

Condividi tramite