Partager via

Tutoriel : Déployer une application Spring sur Azure Spring Apps avec une connexion sans mot de passe à une base de données Azure

  • Article

Cet article explique comment utiliser des connexions sans mot de passe aux bases de données Azure dans les applications Spring Boot déployées sur Azure Spring Apps.

Dans ce tutoriel, vous allez effectuer les tâches suivantes à l’aide du portail Azure ou d’Azure CLI. Les deux méthodes sont expliquées dans les procédures suivantes.

  • Provisionnez une instance d’Azure Spring Apps.
  • Créer et déployer des applications sur Azure Spring Apps.
  • Exécutez des applications connectées à des bases de données Azure à l’aide d’une identité managée.

Remarque

Ce didacticiel ne fonctionne pas pour R2DBC.

Prérequis

  • Un abonnement Azure. Si vous n’en avez pas encore, créez un compte gratuit avant de commencer.
  • Azure CLI 2.45.0 ou version ultérieure requise.
  • L’extension Azure Spring Apps. Vous pouvez installer l’extension à l’aide de la commande : az extension add --name spring.
  • Kit de développement Java (JDK), version 8, 11 ou 17.
  • Un client Git.
  • cURL ou un utilitaire HTTP similaire pour tester la fonctionnalité.
  • Client de ligne de commande MySQL si vous choisissez d’exécuter Azure Database pour MySQL. Vous pouvez vous connecter à votre serveur avec Azure Cloud Shell à l’aide d’un outil client populaire, l’outil en ligne de commande mysql.exe . Vous pouvez aussi utiliser la ligne de commande de mysql dans votre environnement local.
  • ODBC Driver 18 pour SQL Server si vous choisissez d’exécuter Azure SQL Database.

Préparer l’environnement de travail

Tout d’abord, configurez des variables d’environnement à l’aide des commandes suivantes :

export AZ_RESOURCE_GROUP=passwordless-tutorial-rg
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=demodb
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_SPRING_APPS_SERVICE_NAME=<YOUR_AZURE_SPRING_APPS_SERVICE_NAME>
export AZ_SPRING_APPS_APP_NAME=hellospring
export AZ_DB_ADMIN_USERNAME=<YOUR_DB_ADMIN_USERNAME>
export AZ_DB_ADMIN_PASSWORD=<YOUR_DB_ADMIN_PASSWORD>
export AZ_USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>

Remplacez les espaces réservés par les valeurs suivantes, qui sont utilisées dans cet article :

  • <YOUR_DATABASE_SERVER_NAME>: nom de votre serveur Azure Database, qui doit être unique sur Azure.
  • <YOUR_AZURE_REGION>: région Azure que vous souhaitez utiliser. Vous pouvez utiliser eastus par défaut, mais nous vous recommandons de configurer une région plus proche de l’endroit où vous vivez. Vous pouvez voir la liste complète des régions disponibles à l’aide az account list-locationsde .
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: nom de votre instance Azure Spring Apps. Le nom doit comporter entre 4 et 32 caractères, et contenir uniquement des lettres minuscules, des chiffres et des traits d’union. Le premier caractère du nom du service doit être une lettre, et le dernier doit être une lettre ou un chiffre.
  • <AZ_DB_ADMIN_USERNAME>: nom d’utilisateur administrateur de votre serveur de base de données Azure.
  • <AZ_DB_ADMIN_PASSWORD>: mot de passe administrateur de votre serveur de base de données Azure.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME> : Le nom du serveur d’identité managée affectée par l’utilisateur, qui doit être unique dans tout Azure.

Provisionner une instance d’Azure Spring Apps

Procédez comme suit pour provisionner une instance d’Azure Spring Apps.

  1. Mettez à jour Azure CLI avec l’extension Azure Spring Apps à l’aide de la commande suivante :

    az extension update --name spring

  2. Connectez-vous à Azure CLI et choisissez votre abonnement actif à l’aide des commandes suivantes :

    az login
az account list --output table
az account set --subscription <name-or-ID-of-subscription>

  3. Utilisez les commandes suivantes pour créer un groupe de ressources pour contenir votre service Azure Spring Apps et une instance du service Azure Spring Apps :

    az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION
az spring create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_SPRING_APPS_SERVICE_NAME

Créer une instance de base de données Azure

Procédez comme suit pour provisionner une instance Azure Database.

  1. Créez un serveur Azure Database pour MySQL à l’aide de la commande suivante :

    az mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_DB_ADMIN_USERNAME \
    --admin-password $AZ_DB_ADMIN_PASSWORD \
    --yes

Remarque

Si vous ne fournissez pas ou ne fournissez admin-user pas de admin-password paramètres, le système génère un utilisateur administrateur par défaut ou un mot de passe administrateur aléatoire par défaut.

  1. Créez une base de données à l’aide de la commande suivante :

    az mysql flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME

Créer une application avec un point de terminaison public affecté

Utilisez la commande suivante pour créer l’application.

az spring app create \
    --resource-group $AZ_RESOURCE_GROUP \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --name $AZ_SPRING_APPS_APP_NAME \
    --runtime-version=Java_17
    --assign-endpoint true

Connecter Azure Spring Apps à la base de données Azure

Tout d’abord, installez l’extension sans mot de passe du service Connecter or pour Azure CLI :

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

Utilisez ensuite la commande suivante pour créer une identité managée affectée par l’utilisateur pour l’authentification Microsoft Entra. Pour plus d’informations, consultez Configurer l’authentification Microsoft Entra pour Azure Database pour MySQL - Serveur flexible.

export AZ_IDENTITY_RESOURCE_ID=$(az identity create \
    --name $AZ_USER_IDENTITY_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --query id \
    --output tsv)

Important

Après avoir créé l’identité affectée par l’utilisateur, demandez à votre Administrateur général ou Administrateur de rôle privilégié d’accorder les autorisations suivantes pour cette identité : User.Read.All, GroupMember.Read.All et Application.Read.ALL. Pour plus d’informations, consultez la section Autorisations d’Authentification Active Directory.

Ensuite, utilisez la commande suivante pour créer une connexion sans mot de passe à la base de données.

az spring connection create mysql-flexible \
    --resource-group $AZ_RESOURCE_GROUP \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --app $AZ_SPRING_APPS_APP_NAME \
    --target-resource-group $AZ_RESOURCE_GROUP \
    --server $AZ_DATABASE_SERVER_NAME \
    --database $AZ_DATABASE_NAME \
    --system-identity mysql-identity-id=$AZ_IDENTITY_RESOURCE_ID

Cette commande de connecteur de services effectue les tâches suivantes en arrière-plan :

  • Activez l’identité managée affectée par le système pour l’application $AZ_SPRING_APPS_APP_NAME hébergée par Azure Spring Apps.

  • Définissez l’administrateur Microsoft Entra sur l’utilisateur connecté actuel.

  • Ajoutez un utilisateur de base de données nommé $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME pour l’identité managée créée à l’étape 1 et accordez tous les privilèges de la base de données $AZ_DATABASE_NAME à cet utilisateur.

  • Ajoutez deux configurations à l’application $AZ_SPRING_APPS_APP_NAME: spring.datasource.url et spring.datasource.username.

    Remarque

    Si le message d'erreur The subscription is not registered to use Microsoft.ServiceLinker apparaît, exécutez la commande az provider register --namespace Microsoft.ServiceLinker pour enregistrer le fournisseur de ressources du connecteur de services, puis exécutez à nouveau la commande de connexion.

Génération et déploiement de l’application

Les étapes suivantes décrivent comment télécharger, configurer, générer et déployer l’exemple d’application.

  1. Utilisez la commande suivante pour cloner l’exemple de référentiel de code :

    git clone https://github.com/Azure-Samples/quickstart-spring-data-jdbc-mysql passwordless-sample

  2. Ajoutez la dépendance suivante à votre fichier pom.xml :

    <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-jdbc-mysql</artifactId>
</dependency>

    Cette dépendance ajoute la prise en charge du démarrage d’Azure Spring Cloud.

    Remarque

    Pour plus d’informations sur la gestion des versions de bibliothèque Spring Cloud Azure à l’aide d’une facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

  3. Utilisez la commande suivante pour mettre à jour le fichier application.properties :

    cat << EOF > passwordless-sample/src/main/resources/application.properties

logging.level.org.springframework.jdbc.core=DEBUG
spring.datasource.azure.passwordless-enabled=true
spring.sql.init.mode=always

EOF

  4. Utilisez les commandes suivantes pour générer le projet à l’aide de Maven :

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Utilisez la commande suivante pour déployer le fichier target/demo-0.0.1-SNAPSHOT.jar pour l’application :

    az spring app deploy \
    --name $AZ_SPRING_APPS_APP_NAME \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --artifact-path target/demo-0.0.1-SNAPSHOT.jar

  6. Interrogez l’état de l’application après le déploiement à l’aide de la commande suivante :

    az spring app list \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --output table

    Vous devez voir la sortie similaire à l’exemple suivant.

    Name               Location    ResourceGroup    Production Deployment    Public Url                                           Provisioning Status    CPU    Memory    Running Instance    Registered Instance    Persistent Storage
-----------------  ----------  ---------------  -----------------------  ---------------------------------------------------  ---------------------  -----  --------  ------------------  ---------------------  --------------------
<app name>         eastus      <resource group> default                                                                       Succeeded              1      2         1/1                 0/1                    -

Test de l’application

Pour tester l’application, vous pouvez utiliser cURL. Tout d’abord, créez un élément « todo » dans la base de données à l’aide de la commande suivante :

curl --header "Content-Type: application/json" \
    --request POST \
    --data '{"description":"configuration","details":"congratulations, you have set up JDBC correctly!","done": "true"}' \
        https://${AZ_SPRING_APPS_SERVICE_NAME}-hellospring.azuremicroservices.io

Cette commande retourne l’élément créé, comme illustré dans l’exemple suivant :

{"id":1,"description":"configuration","details":"congratulations, you have set up JDBC correctly!","done":true}

Ensuite, récupérez les données à l’aide de la requête cURL suivante :

curl https://${AZ_SPRING_APPS_SERVICE_NAME}-hellospring.azuremicroservices.io

Cette commande retourne la liste des éléments « todo », y compris l’élément que vous avez créé, comme illustré dans l’exemple suivant :

[{"id":1,"description":"configuration","details":"congratulations, you have set up JDBC correctly!","done":true}]

Nettoyer les ressources

Pour propre toutes les ressources utilisées pendant ce didacticiel, supprimez le groupe de ressources à l’aide de la commande suivante :

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Étapes suivantes