Condividi tramite

Esercitazione: Connettersi a un database PostgreSQL da servizio app di Tomcat Java senza memorizzazione di segreti usando una identità gestita

Servizio app di Azure offre un servizio di hosting Web altamente scalabile e auto-patch in Azure. Fornisce anche un'identità managed identity per la tua app, che è una soluzione chiavi in mano per proteggere l'accesso a Database di Azure per PostgreSQL e ad altri servizi 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 verranno illustrate le procedure per:

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

Se non si ha un account Azure, creare un account free prima di iniziare.

Prerequisiti

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/

Crea un database Azure per PostgreSQL

Seguire questa procedura per creare un database Azure per Postgres nella sottoscrizione. L'app Tomcat si connette a questo database e ne archivia i dati durante l'esecuzione, mantenendo lo stato dell'applicazione indipendentemente dal punto in cui si esegue l'applicazione.

  1. Accedere al interfaccia della riga di comando di Azure e, facoltativamente, impostare la sottoscrizione se sono presenti più di una connessione alle credenziali di accesso.

    az login
az account set --subscription <subscription-ID>

  2. Creare un gruppo di risorse Azure, notando il nome del gruppo di risorse.

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

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

  3. Creare un server di database di Azure per PostgreSQL. Il server viene creato con un account amministratore, ma non viene usato perché si userà l'account amministratore 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

  4. 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 creare un file WAR e distribuirlo in Servizio app di Azure in Tomcat usando un pacchetto WAR.

  1. L'app di esempio contiene un filepom.xml che può generare il file WAR. Per compilare l'app, eseguire il comando seguente.

    mvn clean package -f pom.xml

  2. Creare una risorsa Servizio app di Azure su Linux tramite 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"

  3. 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 Service Connector.

Installare l'estensione senza password di Service Connector per il 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 in 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

Testare l'applicazione eseguendo il comando seguente.

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

Negli step precedenti, hai creato risorse di Azure in un gruppo di risorse. Se non si prevede che queste risorse siano necessarie in futuro, eliminare il gruppo di risorse eseguendo il comando seguente nel 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 Servizio app in Linux sono disponibili nella guida per sviluppatori.

Java nella guida per sviluppatori di Servizio App Linux

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

  Proteggere con dominio e certificato personalizzati

  • Last updated on