Tutorial: Herstellen einer Verbindung mit PostgreSQL-Datenbank über eine Java Quarkus-Container-App ohne Geheimnisse mithilfe einer verwalteten Identität

Artikel
12/09/2024

Azure Container Apps stellt 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 Container Apps machen Ihre App frei von Geheimnissen (wie etwa Anmeldeinformationen in den Umgebungsvariablen) und verbessern so die Sicherheit Ihrer App.

Dieses Tutorial führt Sie durch den Prozess der Kompilierung, Konfiguration, Bereitstellung und Skalierung von Java-Container-Apps in Azure. Am Ende dieses Tutorials besitzen Sie eine Quarkus-Anwendung, die Daten in einer PostgreSQL-Datenbank mit einer verwalteten Identität unter Container Apps speichert.

Lerninhalt:

Konfigurieren Sie eine Quarkus-App für die Authentifizierung mithilfe von Microsoft Entra ID mit einer PostgreSQL-Datenbank.
Erstellen einer Azure-Containerregistrierung und Pushen eines Java-App-Images in die Registrierung
Erstellen einer Container-App in Azure
Erstellen einer PostgreSQL-Datenbank in Azure
Herstellen einer Verbindung mit der PostgreSQL-Datenbank mit einer verwalteten Identität mithilfe von Service Connector

Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.

1. Voraussetzungen

Azure CLI-Version 2.45.0 oder höher.
Git-Client
Java JDK
Maven
Docker

2. Erstellen einer Containerregistrierung

Erstellen Sie mithilfe des Befehls az group create eine Ressourcengruppe. Eine Azure-Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden.

Im folgenden Beispiel wird eine Ressourcengruppe namens myResourceGroup in der Azure-Region „USA, Osten“ erstellt:

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"

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

Erstellen Sie eine Azure Container Registry-Instanz mithilfe des Befehls az acr create, und rufen Sie den Anmeldeserver mithilfe des Befehls az acr show ab. Der Registrierungsname muss innerhalb von Azure eindeutig sein und aus 5 bis 50 alphanumerischen Zeichen bestehen. Alle Buchstaben müssen in Kleinbuchstaben angegeben werden. Im folgenden Beispiel wird mycontainerregistry007 verwendet. Ersetzen Sie diesen Namen durch einen eindeutigen Wert.

REGISTRY_NAME=mycontainerregistry007
az acr create \
    --resource-group $RESOURCE_GROUP \
    --name $REGISTRY_NAME \
    --sku Basic

REGISTRY_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv | tr -d '\r')

3. Klonen der Beispiel-App und Vorbereiten des Repository Containerimages

Dieses Tutorial verwendet eine beispielhafte Fruits-Listen-App mit einer Webbenutzeroberfläche, die eine Quarkus-REST-API aufruft, die von Azure-Datenbank für PostgreSQL unterstützt wird. Den Code für die App finden Sie auf GitHub. Weitere Informationen zum Schreiben von Java-Apps mit Quarkus und PostgreSQL finden Sie im Quarkus Hibernate ORM mit Panache Guide und im Quarkus Datasource Guide.

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/quarkusio/quarkus-quickstarts
cd quarkus-quickstarts/hibernate-orm-panache-quickstart

Ändern Ihres Projekts

Fügen Sie der POM-Datei Ihres Projekts die erforderlichen Abhängigkeiten hinzu.

<dependency>
   <groupId>com.azure</groupId>
   <artifactId>azure-identity-extensions</artifactId>
   <version>1.1.20</version>
</dependency>

Konfigurieren Sie die Quarkus-App-Eigenschaften.

Die Quarkus-Konfiguration ist in der Datei src/main/resources/application.properties enthalten. Öffnen Sie diese Datei in Ihrem Editor und beobachten Sie mehrere Standardeigenschaften. Die Eigenschaften mit dem Präfix %prod werden nur verwendet, wenn die Anwendung erstellt und bereitgestellt wird, beispielsweise bei der Bereitstellung in Azure App Service. Wenn die Anwendung lokal ausgeführt wird, werden %prod-Eigenschaften ignoriert. In ähnlicher Weise werden %dev-Eigenschaften im Live Coding / Dev-Modus von Quarkus verwendet, und %test-Eigenschaften werden während des kontinuierlichen Testens verwendet.

Löschen Sie den vorhandenen Inhalt in application.properties, und ersetzen Sie ihn durch Folgendes, um Ihre Datenbank für den Entwicklungs-, Test- und Produktionsmodus zu konfigurieren:

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=${CURRENT_USERNAME}
%dev.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&sslmode=require

%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&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-extensions::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,\
net.java.dev.jna:jna::jar

Erstellen eines Docker-Images und Pushen in die Containerregistrierung

Erstellen des Containerimages

Führen Sie den folgenden Befehl aus, um das Quarkus-App-Image zu erstellen. Sie müssen es mit dem vollqualifizierten Namen des Anmeldeservers Ihrer Registrierung markieren.

CONTAINER_IMAGE=${REGISTRY_SERVER}/quarkus-postgres-passwordless-app:v1

mvn quarkus:add-extension -Dextensions="container-image-jib"
mvn clean package -Dquarkus.container-image.build=true -Dquarkus.container-image.image=${CONTAINER_IMAGE}

Melden Sie sich bei der Registrierung an.

Bevor Sie Pushvorgänge für Containerimages ausführen können, müssen Sie sich bei der Registrierung anmelden. Verwenden Sie hierzu den Befehl [az acr login][az-acr-login].
```
az acr login --name $REGISTRY_NAME
```
Der Befehl gibt nach Abschluss die Meldung Login Succeeded zurück.
Puschen Sie das Image in die Registrierung.

Verwenden Sie docker push, um das Image in die Registrierungsinstanz zu pushen. In diesem Beispiel wird das Repository quarkus-postgres-passwordless-app mit dem Image quarkus-postgres-passwordless-app:v1 erstellt.
```
docker push $CONTAINER_IMAGE
```

4. Erstellen einer Container-App in Azure

Erstellen Sie eine Container Apps-Instanz, indem Sie den folgenden Befehl ausführen. Ersetzen Sie den Wert der Umgebungsvariablen unbedingt durch den tatsächlichen Namen und den tatsächlichen Speicherort, die Sie verwenden möchten.
```
CONTAINERAPPS_ENVIRONMENT="my-environment"

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

Erstellen Sie eine Container-App mit Ihrem App-Image, indem Sie den folgenden Befehl ausführen:

APP_NAME=my-container-app
az containerapp create \
    --resource-group $RESOURCE_GROUP \
    --name $APP_NAME \
    --image $CONTAINER_IMAGE \
    --environment $CONTAINERAPPS_ENVIRONMENT \
    --registry-server $REGISTRY_SERVER \
    --registry-identity system \
    --ingress 'external' \
    --target-port 8080 \
    --min-replicas 1

Hinweis

Die Optionen --registry-username und --registry-password werden weiterhin unterstützt, werden jedoch nicht empfohlen, da die Verwendung des Identitätssystems sicherer ist.

5. Erstellen und Verbinden einer PostgreSQL-Datenbank mit Identitätskonnektivität

Erstellen Sie als Nächstes eine Instanz von PostgreSQL-Datenbank, und konfigurieren Sie Ihre Container-App so, dass eine Verbindung mit PostgreSQL-Datenbank mit einer systemseitig zugewiesenen verwalteten Identität hergestellt wird. Die Quarkus-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.

Erstellen Sie den Datenbankdienst.
```
DB_SERVER_NAME='msdocs-quarkus-postgres-webapp-db'

az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name $DB_SERVER_NAME \
    --location $LOCATION \
    --public-access None \
    --sku-name Standard_B1ms \
    --tier Burstable \
    --active-directory-auth Enabled
```
Hinweis

Die Optionen --admin-user und --admin-password werden weiterhin unterstützt, werden jedoch nicht empfohlen, da die Verwendung des Identitätssystems sicherer ist.

Die folgenden Parameter werden im obigen Azure CLI-Befehl verwendet:
- resource-group → Verwenden Sie den gleichen Ressourcengruppennamen, unter dem Sie auch die Web-App – z. B. msdocs-quarkus-postgres-webapp-rg – erstellt haben.
- name: Der Name des PostgreSQL-Datenbankservers. Dieser Name muss innerhalb von Azure eindeutig sein. (Der Serverendpunkt isthttps://<name>.postgres.database.azure.com.) Gültige Zeichen sind A-Z, 0-9 und -. Ein bewährtes Muster ist eine Kombination aus Ihrem Firmennamen und einer Server-ID. (msdocs-quarkus-postgres-webapp-db)
- location: Verwenden Sie den gleichen Standort wie für die Web-App. Wechseln Sie zu einem anderen Speicherort, wenn er nicht funktioniert.
- public-access: None: Damit wird der Server in den Modus „Öffentlicher Zugriff“ ohne Firewallregeln versetzt. Regeln werden in einem späteren Schritt erstellt.
- sku-name → Der Name des Tarifs und der Computekonfiguration – z. B. Standard_B1ms. Weitere Informationen finden Sie unter Azure Database for PostgreSQL – Preise.
- tier → Die Computeebene des Servers. Weitere Informationen finden Sie unter Azure Database for PostgreSQL – Preise.
- active-directory-auth → Enabled, um die Microsoft Entra-Authentifizierung zu aktivieren.

Erstellen Sie mit diesem Befehl eine Datenbank namens fruits innerhalb des PostgreSQL-Diensts:

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

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

az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

Verbinden Sie mithilfe des Verbindungsbefehls die Datenbank mit der Container-App mit einer systemseitig zugewiesenen verwalteten Identität.

az containerapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APP_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $DB_SERVER_NAME \
    --database $DB_NAME \
    --system-identity \
    --container $APP_NAME

6. Überprüfen Ihrer Änderungen

Sie können mit dem folgenden Befehl die Anwendungs-URL (FQDN) ermitteln:

echo https://$(az containerapp show \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --query properties.configuration.ingress.fqdn \
    --output tsv)

Wenn die neue Webseite Ihre Liste mit Früchten anzeigt, stellt Ihre App unter Verwendung der verwalteten Identität eine Verbindung mit der Datenbank her. Die Liste der Früchte sollte sich nun wie gewohnt bearbeiten lassen.

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 Azure.

Azure für Java-Entwickler

Freigeben über