Share via

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

  • Articolo

Il Servizio app di Azure fornisce un servizio di hosting Web ad alta scalabilità e con funzioni di auto-correzione in Azure. Fornisce anche 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 in servizio app rendere 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 nel servizio app Azure in Tomcat usando la creazione di pacchetti WAR.
  • Configurare un'applicazione Web Tomcat per l'uso dell'autenticazione di Microsoft Entra con Postgre database SQL.
  • Connessione a Postgre database SQL con identità gestita tramite Connessione or del servizio.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito 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/

Creare un database di Azure per PostgreSQL

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

  1. Accedere all'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 di Azure prendendo nota del nome.

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

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

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

  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 in servizio app

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

  1. L'app di esempio contiene un file pom.xml in grado di generare il file WAR. Eseguire il comando seguente per compilare l'app.

    mvn clean package -f pom.xml

  2. Creare una risorsa del servizio app 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"

  3. Distribuire il pacchetto WAR in servizio app.

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

Connessione database Postgres con connettività di identità

Connettere quindi il database usando Service Connessione or.

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

Connettere quindi l'app a un database Postgres con un'identità gestita assegnata dal sistema usando Service Connessione or.

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 l'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

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 e certificato personalizzati