Charger un secret à partir de Azure Key Vault dans une application Spring Boot

Ce tutoriel vous montre comment charger un secret à partir de Azure Key Vault dans une application Spring Boot pour sécuriser les données de configuration sensibles. Azure Key Vault fournit un stockage sécurisé pour les secrets tels que les mots de passe et les chaînes de connexion de base de données.

Prérequis

Un abonnement Azure - créez-en un gratuitement.
Java Kit de développement (JDK) version 8 ou ultérieure.
Apache Maven
Service de contrôle d’accès Azure (CLI)
Instance de Key Vault. Si vous n'en avez pas, consultez Quickstart : Créer un coffre de clés à l'aide du portail Azure. Notez également l’URI de l’instance de Key Vault, car vous en avez besoin pour l’application de test pour ce didacticiel.
Une application Spring Boot. Si vous n’en avez pas, créez un projet Maven avec Spring Initializr. Veillez à sélectionner Maven Project et, sous Dependencies, ajoutez le Spring Web, Spring Data JPA et H2 Database dépendances, puis sélectionnez Java version 8 ou ultérieure.

Important

Spring Boot version 2.5 ou supérieure est nécessaire pour effectuer les étapes de cet article.

Définir un secret sur Azure Key Vault

Ce tutoriel explique comment lire les informations d’identification de base de données à partir de Key Vault dans une application Spring Boot. Pour lire les informations d’identification de Key Vault, vous devez d’abord stocker les informations d’identification de base de données dans Key Vault.

Pour stocker l’URL d’une base de données H2 en tant que nouveau secret dans Key Vault, consultez Démarrage rapide : Définit et récupère un secret dans Azure Key Vault à l'aide du portail Azure. Dans ce tutoriel, vous définissez un secret avec nom h2url et valeur jdbc:h2:~/testdb;user=sa;password=password.

Remarque

Après avoir défini le secret, accordez à votre application l’accès à Key Vault en suivant les instructions de Assigner une stratégie d’accès Key Vault.

Lire un secret à partir de Azure Key Vault

Une fois les informations d’identification de base de données enregistrées dans Key Vault, vous pouvez les récupérer à l’aide de Spring Cloud Azure.

Pour installer le module Spring Cloud Azure Key Vault Starter, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Bill of Materials (BOM) Spring Cloud Azure :
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>7.4.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

L'artefact Spring Cloud Azure Key Vault Démarreur :

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

Spring Cloud Azure fournit plusieurs méthodes pour lire des secrets à partir de Key Vault. Voici les options disponibles que vous pouvez utiliser seules ou en combinaison pour différents cas d'utilisation :

Utilisez Kit de développement logiciel (SDK) Azure pour Key Vault.
Utilisez Spring KeyVault PropertySource.

Utiliser Kit de développement logiciel (SDK) Azure pour Key Vault

Kit de développement logiciel (SDK) Azure pour Key Vault fournit SecretClient pour gérer les secrets dans Key Vault.

L’exemple de code suivant montre comment utiliser SecretClient pour récupérer les informations d’identification de base de données H2 à partir de Azure Key Vault.

Pour lire un secret à partir de Key Vault à l’aide de Kit de développement logiciel (SDK) Azure, configurez l’application en procédant comme suit :

Configurez un point de terminaison Key Vault dans le fichier de configuration application.properties.
```
spring.cloud.azure.keyvault.secret.endpoint=https://<your-keyvault-name>.vault.azure.net/
```
Injectez le bean SecretClient dans votre application Spring et utilisez la méthode getSecret pour récupérer un secret, comme le montre l'exemple suivant :
```
import com.azure.security.keyvault.secrets.SecretClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SecretClientApplication implements CommandLineRunner {

    // Spring Cloud Azure will automatically inject SecretClient in your ApplicationContext.
    private final SecretClient secretClient;

    public SecretClientApplication(SecretClient secretClient) {
        this.secretClient = secretClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(SecretClientApplication.class, args);
    }

    @Override
    public void run(String... args) {
        System.out.println("h2url: " + secretClient.getSecret("h2url").getValue());
    }
}
```
Conseil

Dans ce tutoriel, il n'y a pas d'opérations d'authentification dans les configurations ou le code. Toutefois, la connexion à Azure services nécessite une authentification. Pour terminer l’authentification, vous devez utiliser Azure Identity. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque Azure Identity fournit pour vous aider à obtenir des informations d’identification sans aucune modification du code.

DefaultAzureCredential prend en charge plusieurs méthodes d’authentification et détermine quelle méthode doit être utilisée au moment de l’exécution. Cette approche permet à votre application d'utiliser différentes méthodes d'authentification dans différents environnements (tels que les environnements locaux et de production) sans implémenter de code spécifique à l'environnement. Pour plus d’informations, consultez DefaultAzureCredential.

Pour terminer l’authentification dans les environnements de développement locaux, vous pouvez utiliser Azure CLI, Visual Studio Code, PowerShell ou d’autres méthodes. Pour plus d'informations, consultez l'authentification Azure dans des environnements de développement Java. Pour terminer l’authentification dans Azure environnements d’hébergement, nous vous recommandons d’utiliser l’identité managée affectée par l’utilisateur. Pour plus d’informations, consultez Qu’est-ce que les identités managées pour les ressources Azure ?
Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :
```
h2url: jdbc:h2:~/testdb;user=sa;password=password
```

Vous pouvez construire le SecretClient haricot vous-même, mais le processus est compliqué. Dans les applications Spring Boot, vous devez gérer les propriétés, apprendre le modèle de construction et enregistrer le client dans votre contexte d'application Spring. L'exemple de code suivant montre comment construire un bean SecretClient :

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.security.keyvault.secrets.SecretClient;
import com.azure.security.keyvault.secrets.SecretClientBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SecretClientConfiguration {

    @Bean
    public SecretClient createSecretClient() {
        return new SecretClientBuilder()
            .vaultUrl("https://<your-key-vault-url>.vault.azure.net/")
            .credential(new DefaultAzureCredentialBuilder().build())
            .buildClient();
    }

}

La liste suivante décrit certaines raisons pour lesquelles ce code n'est pas flexible ou élégant :

Le point de terminaison Key Vault est codé en dur.
Si vous utilisez @Value pour obtenir des configurations à partir de l’environnement Spring, vous ne pouvez pas avoir d’indicateurs IDE dans votre fichier application.properties .
Si vous avez un scénario de microservice, vous devez dupliquer le code dans chaque projet. Il est facile de faire des erreurs et difficile à être cohérent.

Heureusement, Spring Cloud Azure simplifie la création du SecretClient haricot. Au lieu de créer manuellement le haricot, vous pouvez injecter SecretClient et utiliser directement les propriétés de configuration que vous connaissez déjà pour configurer Key Vault. Pour plus d'informations, consultez les Exemples de configuration.

Spring Cloud Azure fournit également les configurations globales suivantes pour différents scénarios. Pour plus d’informations, consultez la section Global configuration for Azure Service SDKs du guide du développeur Spring Cloud Azure.

Options de proxy.
Options de réessai.
Options du client de transport HTTP.

Vous pouvez également vous connecter à différents clouds Azure. Pour plus d’informations, consultez Connect to different Azure clouds.

Utiliser Spring Key Vault PropertySource

Les sections précédentes montrent comment utiliser SecretClient dans la CommandLineRunner section pour lire le secret après le démarrage de l’application. Dans les applications Spring Boot, toutefois, vous devez lire les secrets avant le démarrage de l’application. Par exemple, la propriété de mot de passe de la source de données est requise avant le démarrage de l'application. Le scénario précédent ne fonctionne pas si vous souhaitez stocker le mot de passe de la source de données dans Key Vault et utiliser la configuration automatique Spring pour obtenir une source de données.

Dans ce cas, Spring Cloud Azure fournit l’intégration de l’environnement Spring pour charger des secrets à partir de Key Vault avant de créer le contexte de l’application. Vous pouvez utiliser le secret pour construire et configurer le bean lors de l'initialisation du contexte de l'application Spring. Cette approche est un moyen transparent pour vous d’accéder aux secrets à partir de Key Vault, et aucune modification du code n’est nécessaire.

L’exemple de code suivant montre comment récupérer PropertySource les informations d’identification de base de données H2 pour générer la source de données à partir de Azure Key Vault.

Pour récupérer l’URL d’une base de données H2 à partir de Key Vault et stocker des données à partir de la base de données H2 à l’aide de Spring Data JPA, configurez l’application en procédant comme suit :

Ajoutez les propriétés Key Vault de point de terminaison et de source de données suivantes au fichier de configuration application.properties.
```
logging.level.org.hibernate.SQL=DEBUG

spring.cloud.azure.keyvault.secret.property-sources[0].endpoint=https://<your-keyvault-name>.vault.azure.net/
spring.datasource.url=${h2url}

spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
```
Conseil

Pour obtenir des exemples de configuration de propriétés Spring Cloud Azure, consultez la section Exemples de configuration du guide du développeur Spring Cloud Azure.

Cet exemple décrit un scénario simple avec une base de données H2. Utilisez Azure Database pour MySQL ou Azure Database pour PostgreSQL dans un environnement de production et stockez l’URL de base de données, le nom d’utilisateur et le mot de passe dans Azure Key Vault. Pour éviter l'utilisation de mots de passe, les connexions sans mot de passe sont une alternative intéressante. Pour plus d’informations, consultez Connexions sans mot de passe pour les services Azure.

Créez une classe Todo Java. Cette classe est un modèle de domaine mappé sur la todo table que JPA crée automatiquement. Le code suivant ignore les méthodes getters et setters.

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    @GeneratedValue
    private Long id;

    private String description;

    private String details;

    private boolean done;

}

Modifiez le fichier de classe de démarrage pour afficher le contenu suivant.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.stream.Stream;

@SpringBootApplication
public class KeyvaultApplication {

    public static void main(String[] args) {
        SpringApplication.run(KeyvaultApplication.class, args);
    }

    @Bean
    ApplicationListener<ApplicationReadyEvent> basicsApplicationListener(TodoRepository repository) {
        return event->repository
            .saveAll(Stream.of("A", "B", "C").map(name->new Todo("configuration", "congratulations, you have set up "
                + "correctly!", true)).toList())
            .forEach(System.out::println);
    }

}

interface TodoRepository extends JpaRepository<Todo, Long> {

}

Lancez l’application. L’application récupère l’URL de la base de données H2 à partir de Key Vault, puis se connecte à la base de données H2 et stocke les données dans la base de données. Vous voyez des journaux similaires à l’exemple suivant :
```
2023-01-13 15:51:35.498 DEBUG 5616 --- [main] org.hibernate.SQL: insert into todo (description, details, done, id) values (?, ?, ?, ?)
com.contoso.keyvault.Todo@1f
```

Déployer sur Azure Spring Apps

Maintenant que l'application Spring Boot fonctionne localement, il est temps de la mettre en production. Azure Spring Apps facilite le déploiement d’applications Spring Boot sur Azure sans aucune modification du code. Le service gère l’infrastructure des applications Spring, ce qui permet aux développeurs de se concentrer sur leur code. Azure Spring Apps fournit une gestion du cycle de vie à l’aide de la supervision et des diagnostics complets, de la gestion de la configuration, de la découverte de services, de l’intégration CI/CD, des déploiements bleu-vert, etc. Pour déployer votre application sur Azure Spring Apps, consultez Deploy your first application to Azure Spring Apps.

Étapes suivantes

Azure pour les développeurs Spring Spring Cloud Azure KeyVault Samples

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-08-03