Teilen über

Tutorial: Verbindungsherstellung mit einer PostgreSQL-Datenbank aus einem Java Tomcat App Service ohne Geheimnisse mithilfe einer verwalteten Identität

  • Artikel

Azure App Service bietet einen hochgradig skalierbaren Webhostingdienst mit Self-Patching in Azure. Außerdem steht eine verwaltete Identität für Ihre App zur Verfügung. Hierbei handelt es sich um eine vorgefertigte Lösung zum Schutz des Zugriffs auf Azure Database for PostgreSQL und andere Azure-Dienste. Verwaltete Identitäten in App Service machen Ihre App frei von Geheimnissen (wie etwa Anmeldeinformationen in den Umgebungsvariablen) und verbessern so die Sicherheit Ihrer App. In diesem Tutorial lernen Sie Folgendes:

  • Erstellen einer PostgreSQL-Datenbank.
  • Bereitstellen der Beispiel-App für Azure App Service auf Tomcat mithilfe von WAR-Paketen.
  • Konfigurieren Sie eine Tomcat-Webanwendung für die Verwendung der Microsoft Entra-Authentifizierung mit einer PostgreSQL-Datenbank.
  • Herstellen einer Verbindung mit der PostgreSQL-Datenbank mit einer verwalteten Identität mithilfe von Service Connector.

Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein kostenloses Azure-Konto, bevor Sie beginnen.

Voraussetzungen

Klonen Sie die Beispiel-App und bereiten Sie das Repository vor

Führen Sie die folgenden Befehle in Ihrem Terminal aus, um das Beispielrepository zu klonen und die Beispiel-App-Umgebung einzurichten.

git clone https://github.com/Azure-Samples/Passwordless-Connections-for-Java-Apps
cd Passwordless-Connections-for-Java-Apps/Tomcat/

Erstellen einer Azure-Datenbank für PostgreSQL

Führen Sie die folgenden Schritte aus, um einen Azure Database for PostgreSQL-Server in Ihrem Abonnement zu erstellen. Die Tomcat-App stellt eine Verbindung mit dieser Datenbank her und speichert ihre Daten während der Ausführung, wobei der Anwendungszustand erhalten bleibt, unabhängig davon, wo Sie die Anwendung ausführen.

  1. Melden Sie sich bei der Azure CLI an, und legen Sie optional Ihr Abonnement fest, wenn Sie mehr als eines mit Ihren Anmeldeinformationen verbunden haben.

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

  2. Erstellen Sie eine Azure-Ressourcengruppe, und notieren Sie den Namen der Ressourcengruppe.

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

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

  3. Erstellen Sie einen Azure Database for PostgreSQL-Server. Der Server wird mit einem Administratorkonto erstellt, das aber nicht verwendet wird, da Sie das Microsoft Entra-Administratorkonto verwenden, um Verwaltungsaufgaben auszuführen.

    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. Erstellen einer Datenbank für die Anwendung.

    export DATABASE_NAME=checklist

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

Bereitstellen der Anwendung in App Service

Führen Sie diese Schritte aus, um eine WAR-Datei zu erstellen und mithilfe eines WAR-Pakets in Azure App Service auf Tomcat bereitzustellen.

  1. Die Beispiel-App enthält eine Datei pom.xml, die die WAR-Datei generieren kann. Führen Sie den folgenden Befehl aus, um die App zu erstellen:

    mvn clean package -f pom.xml

  2. Erstellen Sie eine Azure App Service-Ressource unter Linux mithilfe von 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. Stellen Sie das WAR-Paket in App Service bereit.

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

Verbinden der PostgreSQL-Datenbank mit Identitätskonnektivität

Verbinden Sie als Nächstes die Datenbank mithilfe des Dienstconnectors.

Installieren Sie die kennwortlose Dienstconnector-Erweiterung für die Azure CLI:

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

Verbinden Sie dann Ihre App mithilfe des Dienstconnectors mit einer PostgreSQL-Datenbank mit einer systemseitig zugewiesenen verwalteten Identität.

Führen Sie zum Herstellen der Verbindung den Befehl az webapp connection create aus.

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

Dieser Befehl erstellt eine Verbindung zwischen Ihrer Web-App und Ihrem PostgreSQL-Server und verwaltet die Authentifizierung über eine systemseitig zugewiesene verwaltete Identität.

Aktualisieren Sie als Nächstes die App-Einstellungen und fügen Sie das Plug-In in der Verbindungszeichenfolge hinzu.

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

Testen der Beispiel-Web-App

Führen Sie den folgenden Befehl aus, um die Anwendung zu testen:

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

Bereinigen von Ressourcen

In den vorherigen Schritten haben Sie Azure-Ressourcen in einer Ressourcengruppe erstellt. Wenn Sie diese Ressourcen in Zukunft nicht mehr benötigen, löschen Sie die Ressourcengruppe, indem Sie den folgenden Befehl in Cloud Shell ausführen:

az group delete --name myResourceGroup

Die Ausführung dieses Befehls kann eine Minute in Anspruch nehmen.

Nächste Schritte

Im Entwicklerhandbuch finden Sie weitere Informationen zum Ausführen von Java-Apps in App Service für Linux.

Java-Entwicklerleitfaden für App Service unter Linux

Erfahren Sie, wie Sie Ihre App mit einer benutzerdefinierten Domäne und einem Zertifikat schützen.

 Schützen mit benutzerdefinierter Domäne und einem Zertifikat