Share via

Zelfstudie: Verbinding maken naar PostgreSQL Database vanuit een Java Quarkus-container-app zonder geheimen met behulp van een beheerde identiteit

  • Artikel

Azure Container Apps biedt een beheerde identiteit voor uw app. Dit is een kant-en-klare oplossing voor het beveiligen van toegang tot Azure Database for PostgreSQL en andere Azure-services. Beheerde identiteiten in Container Apps maken uw app veiliger door geheimen uit uw app te elimineren, zoals referenties in de omgevingsvariabelen.

In deze zelfstudie wordt u begeleid bij het bouwen, configureren, implementeren en schalen van Java-container-apps in Azure. Aan het einde van deze zelfstudie hebt u een Quarkus-toepassing die gegevens opslaat in een PostgreSQL-database met een beheerde identiteit die wordt uitgevoerd in Container Apps.

U leert het volgende:

  • Configureer een Quarkus-app voor verificatie met behulp van Microsoft Entra-id met een PostgreSQL-database.
  • Maak een Azure-containerregister en push er een Java-app-installatiekopieën naartoe.
  • Een container-app maken in Azure.
  • Maak een PostgreSQL-database in Azure.
  • Verbinding maken naar een PostgreSQL-database met beheerde identiteit met behulp van service Verbinding maken or.

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

1. Vereisten

2. Een containerregister maken

Een resourcegroep maken met de opdracht az group create. Een Azure-resourcegroep is een logische container waarin Azure-resources worden geïmplementeerd en beheerd.

In het volgende voorbeeld wordt een resourcegroep gemaakt met de naam myResourceGroup in de Azure-regio VS - oost.

az group create --name myResourceGroup --location eastus

Maak een Azure Container Registry-exemplaar met behulp van de opdracht az acr create . De registernaam moet uniek zijn binnen Azure en mag 5-50 alfanumerieke tekens bevatten. Alle letters moeten in kleine letters worden opgegeven. In het volgende voorbeeld mycontainerregistry007 wordt gebruikt. Werk deze waarde bij naar een unieke waarde.

az acr create \
    --resource-group myResourceGroup \
    --name mycontainerregistry007 \
    --sku Basic

3. Kloon de voorbeeld-app en bereid de containerinstallatiekopieën voor

In deze zelfstudie wordt gebruikgemaakt van een voorbeeldapp voor fruitslijsten met een webgebruikersinterface die een Quarkus REST API aanroept die wordt ondersteund door Azure Database for PostgreSQL. De code voor de app is beschikbaar op GitHub. Zie de Quarkus Hibernate ORM met Panache Guide en de Quarkus Datasource Guide voor meer informatie over het schrijven van Java-apps met Quarkus en PostgreSQL.

Voer de volgende opdrachten in de terminal uit om de voorbeeldopslagplaats te klonen en de omgeving van de voorbeeld-app in te stellen.

git clone https://github.com/quarkusio/quarkus-quickstarts
cd quarkus-quickstarts/hibernate-orm-panache-quickstart

Uw project wijzigen

  1. Voeg de vereiste afhankelijkheden toe aan het BOM-bestand van uw project.

    <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-providers-jdbc-postgresql</artifactId>
    <version>1.0.0-beta.1</version>
</dependency>

  2. Configureer de eigenschappen van de Quarkus-app.

    De Quarkus-configuratie bevindt zich in het bestand src/main/resources/application.properties . Open dit bestand in uw editor en bekijk verschillende standaardeigenschappen. De eigenschappen waaraan %prod wordt voorafgegaan, worden alleen gebruikt wanneer de toepassing wordt gebouwd en geïmplementeerd, bijvoorbeeld wanneer deze wordt geïmplementeerd in Azure-app Service. Wanneer de toepassing lokaal wordt uitgevoerd, %prod worden eigenschappen genegeerd. Op dezelfde manier %dev worden eigenschappen gebruikt in de Live Coding/Dev-modus van Quarkus en %test worden eigenschappen gebruikt tijdens continue tests.

    Verwijder de bestaande inhoud in application.properties en vervang deze door het volgende om de database te configureren voor ontwikkel-, test- en productiemodi:

    quarkus.package.type=uber-jar

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=${AZURE_CLIENT_NAME}
%dev.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&sslmode=require\
&azure.clientId=${AZURE_CLIENT_ID}\
&azure.clientSecret=${AZURE_CLIENT_SECRET}\
&azure.tenantId=${AZURE_TENANT_ID}

%prod.quarkus.datasource.username=${AZURE_MI_NAME}
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&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-providers-core::jar,\
com.azure:azure-identity-providers-jdbc-postgresql::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

Een Docker-installatiekopieën bouwen en pushen naar het containerregister

  1. Bouw de containerinstallatiekopieën.

    Voer de volgende opdracht uit om de quarkus-app-installatiekopieën te bouwen. U moet deze taggen met de volledig gekwalificeerde naam van uw registeraanmeldingsserver. De naam van de aanmeldingsserver heeft de notatie <registry-name.azurecr.io> (moet allemaal kleine letters bevatten), bijvoorbeeld mycontainerregistry007.azurecr.io. Vervang de naam door uw eigen registernaam.

    mvnw quarkus:add-extension -Dextensions="container-image-jib"
mvnw clean package -Pnative -Dquarkus.native.container-build=true -Dquarkus.container-image.build=true -Dquarkus.container-image.registry=mycontainerregistry007 -Dquarkus.container-image.name=quarkus-postgres-passwordless-app -Dquarkus.container-image.tag=v1

  2. Meld u aan bij het register.

    Voordat u containerinstallatiekopieën pusht, moet u zich aanmelden bij het register. Gebruik hiervoor de opdracht [az acr login][az-acr-login]. Geef alleen de naam van de registerresource op wanneer u zich aanmeldt met de Azure CLI. Gebruik niet de volledig gekwalificeerde aanmeldingsservernaam.

    az acr login --name <registry-name>

    Met de opdracht wordt een Login Succeeded-bericht geretourneerd nadat deze is voltooid.

  3. Push de -installatiekopie naar het register.

    Gebruik [docker push][docker-push] om de installatiekopieën naar het registerexemplaren te pushen. Vervang mycontainerregistry007 door de aanmeldingsnaam van het registerexemplaar. In dit voorbeeld wordt de quarkus-postgres-passwordless-app opslagplaats gemaakt die de quarkus-postgres-passwordless-app:v1 installatiekopie bevat.

    docker push mycontainerregistry007/quarkus-postgres-passwordless-app:v1

4. Een container-app maken in Azure

  1. Maak een Container Apps-exemplaar door de volgende opdracht uit te voeren. Zorg ervoor dat u de waarde van de omgevingsvariabelen vervangt door de werkelijke naam en locatie die u wilt gebruiken.

    RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"
CONTAINERAPPS_ENVIRONMENT="my-environment"

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

  2. Maak een container-app met uw app-installatiekopieën door de volgende opdracht uit te voeren. Vervang de tijdelijke aanduidingen door de waarden. Zie Verifiëren met een Azure-containerregister voor meer informatie over het beheerdersaccount van het containerregister

    CONTAINER_IMAGE_NAME=quarkus-postgres-passwordless-app:v1
REGISTRY_SERVER=mycontainerregistry007
REGISTRY_USERNAME=<REGISTRY_USERNAME>
REGISTRY_PASSWORD=<REGISTRY_PASSWORD>

az containerapp create \
    --resource-group $RESOURCE_GROUP \
    --name my-container-app \
    --image $CONTAINER_IMAGE_NAME \
    --environment $CONTAINERAPPS_ENVIRONMENT \
    --registry-server $REGISTRY_SERVER \
    --registry-username $REGISTRY_USERNAME \
    --registry-password $REGISTRY_PASSWORD

5. Een PostgreSQL-database maken en verbinden met identiteitsconnectiviteit

Maak vervolgens een PostgreSQL-database en configureer uw container-app om verbinding te maken met een PostgreSQL-database met een door het systeem toegewezen beheerde identiteit. De Quarkus-app maakt verbinding met deze database en slaat de bijbehorende gegevens op wanneer deze wordt uitgevoerd, waarbij de toepassingsstatus behouden blijft, ongeacht waar u de toepassing uitvoert.

  1. Maak de databaseservice.

    DB_SERVER_NAME='msdocs-quarkus-postgres-webapp-db'
ADMIN_USERNAME='demoadmin'
ADMIN_PASSWORD='<admin-password>'

az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name $DB_SERVER_NAME \
    --location $LOCATION \
    --admin-user $DB_USERNAME \
    --admin-password $DB_PASSWORD \
    --sku-name GP_Gen5_2

De volgende parameters worden gebruikt in de bovenstaande Azure CLI-opdracht:

  • resourcegroep → Gebruik dezelfde naam van de resourcegroep waarin u bijvoorbeeld msdocs-quarkus-postgres-webapp-rgde web-app hebt gemaakt.

  • naam → de naam van de PostgreSQL-databaseserver. Deze naam moet uniek zijn in alle Azure (het servereindpunt wordt https://<name>.postgres.database.azure.com). Toegestane tekens zijn A-Z,-09 en .- Een goed patroon is het gebruik van een combinatie van de bedrijfsnaam en server-id. (msdocs-quarkus-postgres-webapp-db)

  • locatie → Gebruik dezelfde locatie die wordt gebruikt voor de web-app.

  • gebruiker met beheerdersrechten → gebruikersnaam voor het beheerdersaccount. Het kan niet zijn, , , , root, of publicguest. administratoradminazure_superuser Is bijvoorbeeld demoadmin in orde.

  • admin-password → Password of the administrator user. Het moet 8 tot 128 tekens bevatten uit drie van de volgende categorieën: Engelse hoofdletters, Nederlandse kleine letters, cijfers en niet-alfanumerieke tekens.

    Belangrijk

    Bij het maken van gebruikersnamen of wachtwoorden wordt het $ teken niet gebruikt. Verderop in deze zelfstudie maakt u omgevingsvariabelen met deze waarden waarbij het $ teken een speciale betekenis heeft binnen de Linux-container die wordt gebruikt om Java-apps uit te voeren.

  • openbare toegang → None waarmee de server wordt ingesteld in de modus openbare toegang zonder firewallregels. Regels worden in een latere stap gemaakt.

  • sKU-naam → De naam van de prijscategorie en rekenconfiguratie, bijvoorbeeld GP_Gen5_2. Zie Prijzen voor Azure Database for PostgreSQL voor meer informatie.

  1. Maak een database met de naam fruits in de PostgreSQL-service met deze opdracht:

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

  2. Installeer de service-Verbinding maken of de extensie zonder wachtwoord voor de Azure CLI:

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

  3. Verbinding maken de database naar de container-app met een door het systeem toegewezen beheerde identiteit met behulp van de verbindingsopdracht.

    az containerapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name my-container-app \
    --target-resource-group $RESOURCE_GROUP \
    --server $DB_SERVER_NAME \
    --database fruits \
    --managed-identity

6. Controleer uw wijzigingen

U vindt de toepassings-URL (FQDN) met behulp van de volgende opdracht:

az containerapp list --resource-group $RESOURCE_GROUP

Wanneer op de nieuwe webpagina uw lijst met vruchten wordt weergegeven, maakt uw app verbinding met de database met behulp van de beheerde identiteit. U moet nu de fruitlijst kunnen bewerken zoals voorheen.

Resources opschonen

In de voorgaande stappen hebt u Azure-resources in een resourcegroep gemaakt. Als u deze resources niet meer nodig denkt te hebben, verwijdert u de resourcegroep door de volgende opdracht in Cloud Shell uit te voeren:

az group delete --name myResourceGroup

Het kan een minuut duren voordat deze opdracht is uitgevoerd.

Volgende stappen

Meer informatie over het uitvoeren van Java-apps in Azure in de ontwikkelaarshandleiding.

Azure for Java Developers (Azure voor Java-ontwikkelaars)