Självstudie: Ansluta till PostgreSQL Database från en Java Quarkus Container App utan hemligheter med hjälp av en hanterad identitet

Artikel
10/17/2024

Azure Container Apps tillhandahåller en hanterad identitet för din app, vilket är en nyckelfärdig lösning för att skydda åtkomsten till Azure Database for PostgreSQL och andra Azure-tjänster. Hanterade identiteter i Container Apps gör din app säkrare genom att eliminera hemligheter från din app, till exempel autentiseringsuppgifter i miljövariablerna.

Den här självstudien beskriver hur du skapar, konfigurerar, distribuerar och skalar Java-containerappar i Azure. I slutet av den här självstudien har du ett Quarkus-program som lagrar data i en PostgreSQL-databas med en hanterad identitet som körs i Container Apps.

Vad du kommer att lära dig:

Konfigurera en Quarkus-app för att autentisera med hjälp av Microsoft Entra-ID med en PostgreSQL-databas.
Skapa ett Azure-containerregister och skicka en Java-appavbildning till det.
Skapa en containerapp i Azure.
Skapa en PostgreSQL-databas i Azure.
Anslut till en PostgreSQL-databas med hanterad identitet med hjälp av Service Connector.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

1. Förutsättningar

Azure CLI version 2.45.0 eller senare.
Git
Java JDK
Maven
Docker

2. Skapa ett containerregister

Skapa en resursgrupp med kommandot az group create. En Azure-resursgrupp är en logisk container där Azure-resurser distribueras och hanteras.

I följande exempel skapas en resursgrupp med namnet myResourceGroup i Azure-regionen USA, östra.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"

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

Skapa en Azure-containerregisterinstans med kommandot az acr create och hämta dess inloggningsserver med kommandot az acr show . Registernamnet måste vara unikt i Azure och innehålla 5–50 alfanumeriska tecken. Alla bokstäver måste anges i gemener. I följande exempel mycontainerregistry007 används. Uppdatera det här till ett unikt värde.

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. Klona exempelappen och förbered containeravbildningen

I den här självstudien används en exempelapp för fruktlistan med ett webbgränssnitt som anropar ett Quarkus REST API som backas upp av Azure Database for PostgreSQL. Koden för appen är tillgänglig på GitHub. Mer information om hur du skriver Java-appar med Quarkus och PostgreSQL finns i Quarkus Hibernate ORM med Panache Guide och Quarkus Datasource Guide.

Kör följande kommandon i terminalen för att klona exempelrepo och konfigurera exempelappmiljön.

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

Ändra projektet

Lägg till nödvändiga beroenden i projektets BOM-fil.

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

Konfigurera quarkus-appegenskaperna.

Quarkus-konfigurationen finns i filen src/main/resources/application.properties . Öppna den här filen i redigeringsprogrammet och observera flera standardegenskaper. Egenskaperna som prefixet har %prod används endast när programmet skapas och distribueras, till exempel när det distribueras till Azure App Service. När programmet körs lokalt %prod ignoreras egenskaperna. %dev På samma sätt används egenskaper i Quarkus Live Coding/Dev-läge, och %test egenskaper används under kontinuerlig testning.

Ta bort det befintliga innehållet i application.properties och ersätt med följande för att konfigurera databasen för utvecklings-, test- och produktionslägen:

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

Skapa och push-överföra en Docker-avbildning till containerregistret

Skapa containeravbildningen.

Kör följande kommando för att skapa Quarkus-appbilden. Du måste tagga den med det fullständigt kvalificerade namnet på registerinloggningsservern.

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}

Logga in på registret.

Innan du skickar containeravbildningar måste du logga in i registret. Det gör du med kommandot [az acr login][az-acr-login].
```
az acr login --name $REGISTRY_NAME
```
Kommandot returnerar meddelandet Login Succeeded när det har slutförts.
Push-överför avbildningen till registret.

Använd [docker push][docker-push] för att skicka avbildningen till registerinstansen. Det här exemplet skapar lagringsplatsen quarkus-postgres-passwordless-app som innehåller avbildningen quarkus-postgres-passwordless-app:v1 .
```
docker push $CONTAINER_IMAGE
```

4. Skapa en containerapp i Azure

Skapa en Container Apps-instans genom att köra följande kommando. Se till att du ersätter värdet för miljövariablerna med det faktiska namn och den plats som du vill använda.
```
CONTAINERAPPS_ENVIRONMENT="my-environment"

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

Skapa en containerapp med din appavbildning genom att köra följande kommando:

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

Kommentar

Alternativen --registry-username och --registry-password stöds fortfarande men rekommenderas inte eftersom det är säkrare att använda identitetssystemet.

5. Skapa och ansluta en PostgreSQL-databas med identitetsanslutning

Skapa sedan en PostgreSQL-databas och konfigurera containerappen så att den ansluter till en PostgreSQL-databas med en systemtilldelad hanterad identitet. Quarkus-appen ansluter till den här databasen och lagrar sina data när den körs, vilket bevarar programtillståndet oavsett var du kör programmet.

Skapa databastjänsten.
```
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
```
Kommentar

Alternativen --admin-user och --admin-password stöds fortfarande men rekommenderas inte eftersom det är säkrare att använda identitetssystemet.

Följande parametrar används i ovanstående Azure CLI-kommando:
- resource-group → Använd samma resursgruppsnamn där du skapade webbappen , till exempel msdocs-quarkus-postgres-webapp-rg.
- namn → PostgreSQL-databasserverns namn. Det här namnet måste vara unikt i hela Azure (serverslutpunkten blir https://<name>.postgres.database.azure.com). Tillåtna tecken är A-Z,-09 och .- Ett bra mönster är att använda en kombination av företagets namn och serveridentifierare. (msdocs-quarkus-postgres-webapp-db)
- plats → Använd samma plats som används för webbappen. Ändra till en annan plats om den inte fungerar.
- public-access → None som anger servern i offentligt åtkomstläge utan brandväggsregler. Regler skapas i ett senare steg.
- sku-name → Namnet på prisnivån och beräkningskonfigurationen , till exempel Standard_B1ms. Mer information finns i Priser för Azure Database for PostgreSQL.
- nivå → Serverns beräkningsnivå. Mer information finns i Priser för Azure Database for PostgreSQL.
- active-directory-auth → Enabled för att aktivera Microsoft Entra-autentisering.

Skapa en databas med namnet fruits i PostgreSQL-tjänsten med det här kommandot:

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

Installera det lösenordslösa tillägget för Service Connector för Azure CLI:

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

Anslut databasen till containerappen med en systemtilldelad hanterad identitet med hjälp av anslutningskommandot.

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. Granska dina ändringar

Du hittar programmets URL (FQDN) med hjälp av följande kommando:

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

När den nya webbsidan visar din lista över frukter ansluter appen till databasen med hjälp av den hanterade identiteten. Nu bör du kunna redigera fruktlistan som tidigare.

Rensa resurser

I de föregående stegen skapade du Azure-resurser i en resursgrupp. Om du inte tror att du behöver dessa resurser i framtiden tar du bort resursgruppen genom att köra följande kommando i Cloud Shell:

az group delete --name myResourceGroup

Det kan några minuter att köra kommandot.

Nästa steg

Läs mer om att köra Java-appar på Azure i utvecklarguiden.

Azure för Java-utvecklare

Dela via