Tutoriel : Se connecter à une base de données PostgreSQL à partir d’une application de conteneur Java Quarkus sans secrets à l’aide d’une identité managée

Article
11/05/2024

Azure Container Apps offre une identité managée pour votre application, qui constitue une solution clé en main permettant de sécuriser l’accès à Azure Database pour PostgreSQL et à d’autres services Azure. Les identités managées dans Container Apps sécurisent votre application en éliminant les secrets de celle-ci, par exemple les informations d’identification dans les variables d’environnement.

Ce tutoriel vous guide tout au long du processus de création, de configuration, de déploiement et de mise à l’échelle des applications de conteneur Java sur Azure. À la fin de ce tutoriel, vous disposerez d’une application Quarkus stockant des données dans une base de données PostgreSQL avec une identité managée s’exécutant sur Container Apps.

Contenu :

Configurez une application Quarkus pour vous authentifier à l’aide de Microsoft Entra ID avec une base de données PostgreSQL.
Créez un registre de conteneurs Azure et envoyez-lui (par push) une image d’application Java.
Créez une application de conteneur dans Azure.
Créez une base de données PostgreSQL dans Azure.
Connectez-vous à une base de données PostgreSQL avec une identité managée à l’aide d’un connecteur de services.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.

1. Prérequis

Azure CLI : version 2.45.0 ou ultérieure.
Git
Java JDK
Maven
Docker

2. Créer un registre de conteneurs

Créez un groupe de ressources avec la commande az group create. Un groupe de ressources Azure est un conteneur logique dans lequel les ressources Azure sont déployées et gérées.

L’exemple suivant crée un groupe de ressources nommé myResourceGroup dans la région Azure USA Est.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"

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

Créez une instance de registre de conteneurs Azure avec la commande az acr create et récupérez son serveur de connexion avec la commande az acr show. Le nom du registre doit être unique dans Azure et contenir entre 5 et 50 caractères alphanumériques. Toutes les lettres doivent être indiqués en minuscules. mycontainerregistry007'exemple suivant. Mettez à jour le nom de façon à utiliser une valeur unique.

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. Cloner l’exemple d’application et préparer l’image de conteneur

Ce tutoriel utilise un exemple d'application de liste Fruits avec une interface utilisateur Web qui appelle une API REST Quarkus soutenue par Azure Database for PostgreSQL. Le code pour l’application est disponible sur GitHub. Pour en savoir plus sur l'écriture d'applications Java à l'aide de Quarkus et de PostgreSQL, consultez le guide Quarkus Hibernate ORM avec Panache et le guide Quarkus Datasource.

Exécutez les commandes suivantes dans votre terminal pour cloner l’exemple de dépôt et configurer l’exemple d’environnement d’application.

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

Modifier votre projet

Ajoutez les dépendances nécessaires au fichier BOM de votre projet.

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

Configurez les propriétés de l’application Quarkus.

La configuration de Quarkus se trouve dans le fichier src/main/resources/application.properties. Ouvrez ce fichier dans votre éditeur et observez plusieurs propriétés par défaut. Les propriétés préfixées avec%prod sont utilisées uniquement lorsque l’application est générée et déployée, par exemple lorsqu’elle est déployée sur Azure App Service. Lorsque l’application s’exécute localement, les propriétés %prod sont ignorées. De même, les propriétés %dev sont utilisées dans le mode Live Coding /Dev de Analysisus, et les propriétés %test sont utilisées pendant les tests continus.

Supprimez le contenu existant dans application.properties et remplacez-le par ce qui suit pour configurer la base de données pour les modes de développement, de test et de production :

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

Générer une image Docker et l’envoyer (push) au registre de conteneurs

Générez l’image de conteneur.

Exécutez la commande suivante pour générer l’image de l’application Quarkus. Vous devez la marquer avec le nom complet de votre serveur de connexion au registre.

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}

Connectez-vous au registre.

Avant d’envoyer (push) des images conteneur, vous devez vous connecter au registre. Pour ce faire, utilisez la commande .
```
az acr login --name $REGISTRY_NAME
```
Une fois l’opération terminée, la commande retourne un message Login Succeeded.
Envoyez (push) l’image vers le registre.

Utilisez [docker push][docker-push] pour envoyer l’image vers l’instance du registre. Cet exemple crée le référentiel quarkus-postgres-passwordless-app qui contient l’image quarkus-postgres-passwordless-app:v1.
```
docker push $CONTAINER_IMAGE
```

4. Créer une application de conteneur sur Azure

Créez une instance Container Apps en exécutant la commande suivante. Veillez à remplacer la valeur des variables d’environnement par le nom et l’emplacement réels que vous souhaitez utiliser.
```
CONTAINERAPPS_ENVIRONMENT="my-environment"

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

Créez une application de conteneur avec votre image d’application en exécutant la commande suivante :

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

Remarque

Les options --registry-username et --registry-password sont toujours prises en charge, mais ne sont pas recommandées parce que l’utilisation du système d’identité est plus sécurisée.

5. Créer et connecter une base de données PostgreSQL avec une connectivité d’identité

Ensuite, créez une base de données PostgreSQL et configurez votre application de conteneur pour vous connecter à une base de données PostgreSQL avec une identité managée affectée par le système. L’application Quarkus se connecte à cette base de données et stocke ses données lors de l’exécution, entraînant la persistance de l’état de l’application, quel que soit l’endroit où vous exécutez cette dernière.

Créez le service de la base de données.
```
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
```
Remarque

Les options --admin-user et --admin-password sont toujours prises en charge, mais ne sont pas recommandées parce que l’utilisation du système d’identité est plus sécurisée.

Les paramètres suivants sont utilisés dans la commande Azure CLI ci-dessus :
- resource-group → Utilisez le nom du groupe de ressources dans lequel vous avez créé l’application web, par exemple msdocs-quarkus-postgres-webapp-rg.
- name → Nom du serveur de base de données PostgreSQL. Ce nom doit être unique dans Azure (le point de terminaison de serveur devient https://<name>.postgres.database.azure.com). Les caractères autorisés sont A-Z, 0-9 et -. Une bonne approche consiste à utiliser une combinaison du nom de votre société et d’un identificateur de serveur. (msdocs-quarkus-postgres-webapp-db)
- location → Utilisez l’emplacement que vous avez utilisé pour l’application web. Changez d’emplacement s’il ne fonctionne pas.
- public-access → None qui définit le serveur en mode d’accès public sans règles de pare-feu. Les règles seront créées à une étape ultérieure.
- sku-name → Nom du niveau tarifaire et de la configuration de calcul, par exemple Standard_B1ms. Pour plus d’informations, consultez Niveaux tarifaires d’Azure Database pour PostgreSQL.
- tier → niveau de calcul du serveur. Pour plus d’informations, consultez Niveaux tarifaires d’Azure Database pour PostgreSQL.
- active-directory-auth → Enabled pour activer l’authentification Microsoft Entra.

Créez une base de données nommée fruits dans le service PostgreSQL avec cette commande :

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

Installez l’extension sans mot de passe Connecteur de services pour Azure CLI :

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

Connectez la base de données à l’application de conteneur avec une identité managée affectée par le système à l’aide de la commande de connexion.

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. Passer en revue les modifications apportées

Vous pouvez trouver l’URL (FQDN) de l’application à l’aide de la commande suivante :

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

Lorsque la nouvelle page web affiche votre liste de fruits, votre application se connecte à la base de données à l’aide de l’identité managée. Vous devez désormais être en mesure de modifier la liste de fruits comme auparavant.

Nettoyer les ressources

Au cours des étapes précédentes, vous avez créé des ressources Azure au sein d’un groupe de ressources. Si vous ne pensez pas avoir besoin de ces ressources à l’avenir, supprimez le groupe de ressources en exécutant la commande suivante dans Cloud Shell :

az group delete --name myResourceGroup

L’exécution de cette commande peut prendre une minute.

Étapes suivantes

Découvrez-en plus sur l’exécution des applications Java sur Azure dans le guide du développeur.

Azure pour les développeurs Java

Partager via