Udostępnij za pośrednictwem

Samouczek: nawiązywanie połączenia z bazą danych PostgreSQL z poziomu aplikacji kontenera Quarkus Java 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 aplikacjach kontenerowych zwiększają bezpieczeństwo aplikacji, eliminując tajne dane 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 masz aplikację Quarkus przechowującą dane w bazie danych PostgreSQL z tożsamością zarządzaną uruchomioną w usłudze Container Apps.

Czego się nauczysz:

  • 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.
  • Nawiąż połączenie z bazą danych PostgreSQL za pomocą tożsamości zarządzanej przy wykorzystaniu łącznika 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.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"

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

Utwórz wystąpienie rejestru kontenerów platformy Azure, używając polecenia az acr create, i pobierz adres jego serwera logowania, używając polecenia az acr show. Nazwa rejestru musi być unikatowa w obrębie platformy Azure i może 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.

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. 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 frameworku Quarkus i PostgreSQL, zobacz Przewodnik po Quarkus Hibernate ORM z rozwiązaniem Panache i 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 POM projektu.

    <dependency>
   <groupId>com.azure</groupId>
   <artifactId>azure-identity-extensions</artifactId>
   <version>1.2.0</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 w przypadku wdrażania w Azure App 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.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

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 pełnej kwalifikowanej nazwy serwera logowania rejestru.

    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}

  2. Zaloguj się do rejestru.

    Przed wysyłaniem obrazów kontenerów należy zalogować się do repozytorium. W tym celu użyj polecenia [az acr login][az-acr-login].

    az acr login --name $REGISTRY_NAME

    Po ukończeniu polecenie zwraca komunikat Login Succeeded.

  3. Prześlij obraz do rejestru.

    Użyj docker push, aby wypchnąć obraz do wystąpienia rejestru. W tym przykładzie utworzono quarkus-postgres-passwordless-app repozytorium zawierające quarkus-postgres-passwordless-app:v1 obraz.

    docker push $CONTAINER_IMAGE

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

    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:

    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

    Uwaga

    Opcje --registry-username i --registry-password są nadal obsługiwane, ale nie są zalecane, ponieważ korzystanie z systemu tożsamości jest bezpieczniejsze.

5. Utwórz i połącz bazę danych PostgreSQL z funkcją łączenia 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 łączy się z tą bazą danych i przechowuje swoje dane podczas działania, utrwalając stan aplikacji bez względu na to, gdzie uruchamiasz aplikację.

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

    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

    Uwaga

    Opcje --admin-user i --admin-password nadal są obsługiwane, ale nie są zalecane, ponieważ korzystanie z systemu tożsamości jest bezpieczniejsze.

    W powyższym poleceniu wiersza polecenia platformy Azure używane są następujące parametry:

    • 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 w całym 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. Zmień na inną lokalizację, jeśli nie działa.
    • dostęp publiczny → None co ustawia serwer w trybie publicznym bez reguł zapory ogniowej. Reguły są tworzone w późniejszym kroku.
    • sku-name → Nazwa warstwy cenowej i konfiguracji obliczeniowej — na przykład Standard_B1ms. Aby uzyskać więcej informacji, zobacz Cennik usługi Azure Database for PostgreSQL.
    • warstwa → warstwa obliczeniowa serwera. Aby uzyskać więcej informacji, zobacz Cennik usługi Azure Database for PostgreSQL.
    • active-directory-auth → Enabled w celu włączenia uwierzytelniania Microsoft Entra.

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

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

  3. Zainstaluj rozszerzenie bez hasła łącznika usługi dla interfejsu wiersza polecenia platformy Azure:

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

  4. Połącz bazę danych z aplikacją kontenera przy użyciu zarządzanej tożsamości przypisanej przez system, za pomocą polecenia połączenia.

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

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

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

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