Charger un secret depuis Azure Key Vault dans une application Spring Boot

Article
10/07/2024

Ce tutoriel montre comment intégrer Key Vault dans des applications Spring Boot pour sécuriser les données de configuration sensibles et récupérer les propriétés de configuration à partir de Key Vault. Key Vault offre un stockage sécurisé des secrets génériques, tels que les mots de passe et les chaînes de connexion de base de données.

Prérequis

Un abonnement Azure - En créer un gratuitement
Java Development Kit (JDK) version 8 ou supérieure.
Apache Maven
Azure CLI
Une instance de Key Vault. Si vous n'en possédez pas, consultez le guide Démarrage rapide : Créer un coffre-fort de clés avec le portail Azure. Notez également l'URI de l'instance de Key Vault, car il sera nécessaire pour tester l'application dans ce tutoriel.
Une application Spring Boot. Si vous n’en avez pas, créez un projet Maven avec Spring Initializr. Veillez à sélectionner Projet Maven et, sous Dépendances, ajoutez les dépendances Spring Web, Spring Data JPA et Base de données H2, puis sélectionnez la version 8 ou supérieure de Java.

Important

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

Définir un secret pour Azure Key Vault

Ce tutoriel vous explique comment lire les informations d'identification de la base de données depuis Key Vault dans une application Spring Boot. Pour cela, commencez par stocker les informations d'identification de la base de données dans Key Vault.

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

Remarque

Une fois le secret défini, accordez à votre application l'accès à Key Vault en suivant les étapes de la section Attribuer une stratégie d'accès à Key Vault.

Lire un secret dans Azure Key Vault

Maintenant que les informations d'identification de la base de données sont stockées dans Key Vault, vous pouvez les récupérer avec Spring Cloud Azure.

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

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>5.19.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

L'artefact Spring Cloud Azure Key Vault Starter :

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

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

Utiliser Azure SDK pour Key Vault
Utilisez Spring KeyVault PropertySource.

Utiliser Azure SDK pour Key Vault

Azure SDK for Key Vault fournit SecretClient pour gérer les secrets dans Key Vault.

L'exemple de code suivant vous montrera comment utiliser SecretClient pour récupérer les informations d'identification de la base de données H2 depuis Azure Key Vault.

Pour lire un secret avec l'Azure SDK depuis Key Vault, configurez l'application en suivant ces étapes :

Ajoutez 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. Cependant, la connexion aux services Azure nécessite une authentification. Pour effectuer l’authentification, vous devez utiliser Identité Azure. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque Azure Identity fournit pour vous aider à obtenir des informations d'identification sans modifier le 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 réaliser 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 la section Authentification Azure dans les environnements de développement Java. Pour compléter l'authentification dans les environnements d'hébergement Azure, nous vous recommandons d'utiliser l'identité gérée attribuée à l'utilisateur. Pour plus d’informations, consultez Que sont les identités managées pour les ressources Azure ?
Lancez l’application. Les journaux générés ressembleront à l'exemple suivant :
```
h2url: jdbc:h2:~/testdb;user=sa;password=password
```

Vous pouvez construire le bean SecretClient par 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 de l'environnement Spring, vous ne pouvez pas avoir de conseils IDE dans votre fichier application.properties.
Si vous travaillez dans un environnement de microservices, le code doit être dupliqué dans chaque projet, ce qui augmente le risque d'erreurs et réduit la cohérence.

Heureusement, construire le bean SecretClient par vous-même n'est pas nécessaire avec Spring Cloud Azure. Au lieu de cela, vous pouvez injecter directement SecretClient et utiliser 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 de détails, consultez la section Configuration globale pour les SDK de services Azure 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 la section Se connecter à différents clouds Azure.

Utilisez Spring Key Vault PropertySource

Les sections précédentes vous ont montré comment utiliser SecretClient dans CommandLineRunner pour lire le secret après le démarrage de l'application. Dans les applications Spring Boot, il est nécessaire de lire les secrets avant que l'application ne démarre. 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 fonctionnera pas si vous souhaitez stocker le mot de passe de la source de données dans Key Vault tout en utilisant l'auto-configuration de Spring pour générer une source de données.

Dans ce cas, Spring Cloud Azure permet l'intégration avec l'environnement Spring pour charger les secrets depuis Key Vault avant de construire 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 de Key Vault, et aucune modification du code n'est nécessaire.

L'exemple de code suivant vous montre comment utiliser PropertySource pour récupérer les informations d'identification de la base de données H2 afin de construire la source de données à partir d'Azure Key Vault.

Pour récupérer l'URL d'une base de données H2 à partir de Key Vault et stocker les données dans cette base à l'aide de Spring Data JPA, suivez les étapes suivantes :

Ajoutez les propriétés de point de terminaison et de source de données Key Vault 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 des exemples de configuration des propriétés de Spring Cloud Azure, consultez la section Exemples de configuration du guide du développeur Spring Cloud Azure.

Conseil

Cet exemple décrit un scénario simple avec une base de données H2. Dans un environnement de production, il est recommandé d'utiliser Azure Database for MySQL ou Azure Database for PostgreSQL, et de stocker l'URL de la base, le nom d'utilisateur, ainsi que 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 nouvelle classe Java Todo. Cette classe est un modèle de domaine mappé sur la table todo qui sera automatiquement créée par JPA. Le code suivant ignore les méthodes getters et setters.

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.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 y stocke des données. Les journaux générés ressembleront à 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 des 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 assure la gestion du cycle de vie en utilisant des outils complets, tels que la supervision et les diagnostics, la gestion des configurations, la découverte de services, l’intégration CI/CD, les déploiements bleus-verts, etc. Pour déployer votre application sur Azure Spring Apps, voir Déployer votre première application sur Azure Spring Apps.

Étapes suivantes

Azure pour les développeurs Spring Exemples de KeyVault pour Spring Cloud Azure

Partager via