Share via

Samouczek: Połączenie do bazy danych PostgreSQL z aplikacji kontenera Java Quarkus bez wpisów tajnych przy użyciu tożsamości zarządzanej

  • Artykuł

Usługa Azure Container Apps udostępnia tożsamość zarządzaną dla aplikacji, która jest kluczowym rozwiązaniem do zabezpieczania dostępu do usługi Azure Database for PostgreSQL i innych usług platformy Azure. Tożsamości zarządzane w usłudze Container Apps sprawiają, że aplikacja jest bezpieczniejsza, eliminując wpisy tajne z aplikacji, takie jak poświadczenia w zmiennych środowiskowych.

Ten samouczek przeprowadzi Cię przez proces tworzenia, konfigurowania, wdrażania i skalowania aplikacji kontenerów Java na platformie Azure. Na końcu tego samouczka będziesz mieć aplikację Quarkus przechowującą dane w bazie danych PostgreSQL z tożsamością zarządzaną uruchomioną w usłudze Container Apps.

Czego nauczysz się:

  • Skonfiguruj aplikację Quarkus do uwierzytelniania przy użyciu identyfikatora Entra firmy Microsoft z bazą danych PostgreSQL.
  • Utwórz rejestr kontenerów platformy Azure i wypchnij do niego obraz aplikacji Java.
  • Tworzenie aplikacji kontenera na platformie Azure.
  • Tworzenie bazy danych PostgreSQL na platformie Azure.
  • Połączenie do bazy danych PostgreSQL z tożsamością zarządzaną przy użyciu Połączenie or usługi.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

1. Wymagania wstępne

2. Tworzenie rejestru kontenerów

Utwórz grupę zasobów za pomocą polecenia az group create. Grupa zasobów platformy Azure to logiczny kontener przeznaczony do wdrażania zasobów platformy Azure i zarządzania nimi.

Poniższy przykład tworzy grupę zasobów o nazwie myResourceGroup w regionie świadczenia usługi Azure Wschodnie stany USA.

az group create --name myResourceGroup --location eastus

Utwórz wystąpienie rejestru kontenerów platformy Azure przy użyciu polecenia az acr create . Nazwa rejestru musi być unikatowa na platformie Azure, zawierać od 5 do 50 znaków alfanumerycznych. Wszystkie litery muszą być określone w małych literach. W poniższym przykładzie mycontainerregistry007 jest używany. Zaktualizuj ją do unikatowej wartości.

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

3. Sklonuj przykładową aplikację i przygotuj obraz kontenera

W tym samouczku użyto przykładowej aplikacji listy Owoce z internetowym interfejsem użytkownika, który wywołuje interfejs API REST Quarkus wspierany przez usługę Azure Database for PostgreSQL. Kod aplikacji jest dostępny w serwisie GitHub. Aby dowiedzieć się więcej na temat pisania aplikacji Java przy użyciu programów Quarkus i PostgreSQL, zobacz Quarkus Hibernate ORM with Panache Guide and the Quarkus Datasource Guide (Przewodnik po usłudze Quarkus Hibernate ORM z rozwiązaniem Panache) i Quarkus Datasource Guide (Przewodnik po źródle danych Quarkus).

Uruchom następujące polecenia w terminalu, aby sklonować przykładowe repozytorium i skonfigurować przykładowe środowisko aplikacji.

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

Modyfikowanie projektu

  1. Dodaj wymagane zależności do pliku BOM projektu.

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

  2. Skonfiguruj właściwości aplikacji Quarkus.

    Konfiguracja aplikacji Quarkus znajduje się w pliku src/main/resources/application.properties . Otwórz ten plik w edytorze i obserwuj kilka właściwości domyślnych. Właściwości poprzedzone prefiksem %prod są używane tylko podczas kompilowania i wdrażania aplikacji, na przykład podczas wdrażania w usłudze aplikacja systemu Azure Service. Gdy aplikacja działa lokalnie, %prod właściwości są ignorowane. %dev Podobnie właściwości są używane w trybie kodowania na żywo/tworzenia aplikacji Quarkus, a %test właściwości są używane podczas ciągłego testowania.

    Usuń istniejącą zawartość w pliku application.properties i zastąp element następującymi elementami, aby skonfigurować bazę danych dla trybów tworzenia, testowania i produkcji:

    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

Kompilowanie i wypychanie obrazu platformy Docker do rejestru kontenerów

  1. Skompiluj obraz kontenera.

    Uruchom następujące polecenie, aby skompilować obraz aplikacji Quarkus. Należy otagować ją przy użyciu w pełni kwalifikowanej nazwy serwera logowania rejestru. Nazwa serwera logowania jest w formacie <registry-name.azurecr.io> (musi mieć małe litery), na przykład mycontainerregistry007.azurecr.io. Zastąp nazwę własną nazwą rejestru.

    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. Zaloguj się do rejestru.

    Przed wypychaniem obrazów kontenerów należy zalogować się do rejestru. W tym celu użyj polecenia [az acr login][az-acr-login]. Określ tylko nazwę zasobu rejestru podczas logowania się przy użyciu interfejsu wiersza polecenia platformy Azure. Nie używaj w pełni kwalifikowanej nazwy serwera logowania.

    az acr login --name <registry-name>

    Po ukończeniu polecenie zwraca komunikat Login Succeeded.

  3. Wypchnij obraz do rejestru.

    Użyj polecenia [docker push][docker-push], aby wypchnąć obraz do wystąpienia rejestru. Zastąp mycontainerregistry007 ciąg nazwą serwera logowania wystąpienia rejestru. W tym przykładzie utworzono quarkus-postgres-passwordless-app repozytorium zawierające quarkus-postgres-passwordless-app:v1 obraz.

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

4. Tworzenie aplikacji kontenera na platformie Azure

  1. Utwórz wystąpienie usługi Container Apps, uruchamiając następujące polecenie. Pamiętaj, aby zastąpić wartość zmiennych środowiskowych rzeczywistą nazwą i lokalizacją, której chcesz użyć.

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

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

  2. Utwórz aplikację kontenera przy użyciu obrazu aplikacji, uruchamiając następujące polecenie. Zastąp tekst zastępczy własnymi wartościami. Aby znaleźć szczegóły konta administratora rejestru kontenerów, zobacz Uwierzytelnianie za pomocą rejestru kontenerów platformy Azure

    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. Tworzenie i łączenie bazy danych PostgreSQL z łącznością tożsamości

Następnie utwórz bazę danych PostgreSQL Database i skonfiguruj aplikację kontenera w celu nawiązania połączenia z bazą danych PostgreSQL przy użyciu przypisanej przez system tożsamości zarządzanej. Aplikacja Quarkus połączy się z tą bazą danych i zapisze jej dane podczas działania, utrwalając stan aplikacji niezależnie od tego, gdzie jest uruchamiana aplikacja.

  1. Utwórz usługę bazy danych.

    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

Następujące parametry są używane w powyższym poleceniu interfejsu wiersza polecenia platformy Azure:

  • grupa zasobów → Użyj tej samej nazwy grupy zasobów, w której utworzono aplikację internetową, na przykład msdocs-quarkus-postgres-webapp-rg.

  • name → nazwa serwera bazy danych PostgreSQL. Ta nazwa musi być unikatowa na całej platformie Azure (punkt końcowy serwera staje się ).https://<name>.postgres.database.azure.com Dozwolone znaki to A-Z, 0-9i .- Dobrym wzorcem jest użycie kombinacji nazwy firmy i identyfikatora serwera. (msdocs-quarkus-postgres-webapp-db)

  • location → Użyj tej samej lokalizacji używanej dla aplikacji internetowej.

  • administrator-użytkownik → nazwa użytkownika dla konta administratora. Nie może to być azure_superuser, , adminadministrator, root, guest, lub public. Na przykład demoadmin jest w porządku.

  • hasło administratora → hasło użytkownika administratora. Musi zawierać od 8 do 128 znaków z trzech z następujących kategorii: wielkie litery angielskie, małe litery angielskie, cyfry i znaki inne niż alfanumeryczne.

    Ważne

    Podczas tworzenia nazw użytkowników lub haseł nie należy używać $ znaku . W dalszej części tego samouczka utworzysz zmienne środowiskowe z tymi wartościami, w których $ znak ma specjalne znaczenie w kontenerze systemu Linux używanym do uruchamiania aplikacji Java.

  • →None dostępu publicznego, który ustawia serwer w trybie dostępu publicznego bez reguł zapory. Reguły zostaną utworzone w późniejszym kroku.

  • sku-name → Nazwa warstwy cenowej i konfiguracji obliczeniowej, na przykład GP_Gen5_2. Aby uzyskać więcej informacji, zobacz Cennik usługi Azure Database for PostgreSQL.

  1. Utwórz bazę danych o nazwie fruits w usłudze PostgreSQL za pomocą tego polecenia:

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

  2. Zainstaluj rozszerzenie service Połączenie or passwordless dla interfejsu wiersza polecenia platformy Azure:

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

  3. Połączenie bazę danych do aplikacji kontenera z tożsamością zarządzaną przypisaną przez system przy użyciu polecenia połączenia.

    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. Przejrzyj zmiany

Adres URL aplikacji (FQDN) można znaleźć przy użyciu następującego polecenia:

az containerapp list --resource-group $RESOURCE_GROUP

Gdy nowa strona internetowa wyświetla listę owoców, aplikacja łączy się z bazą danych przy użyciu tożsamości zarządzanej. Teraz powinno być możliwe edytowanie listy owoców tak jak poprzednio.

Czyszczenie zasobów

W poprzednich krokach utworzono zasoby platformy Azure w grupie zasobów. Jeśli te zasoby nie będą raczej potrzebne w przyszłości, usuń grupę zasobów, uruchamiając następujące polecenie w usłudze Cloud Shell:

az group delete --name myResourceGroup

Wykonanie tego polecenia może potrwać około minutę.

Następne kroki

Dowiedz się więcej na temat uruchamiania aplikacji Java na platformie Azure w przewodniku dla deweloperów.

Azure dla deweloperów języka Java