Spring Vault

Voûte de printemps

1. Vue d'ensemble

HashiCorp’s Vault est un outil pour stocker et sécuriser les secrets. Vault, en général, résout le problème de sécurité du développement logiciel lié à la gestion des secrets. Pour en savoir plus, consultezour article here.

Spring Vault fournit des abstractions Spring au coffre-fort de HashiCorp.

Dans ce didacticiel, nous allons passer en revue un exemple sur la façon de stocker et de récupérer des secrets à partir du coffre-fort.

2. Dépendances Maven

Pour commencer, examinons les dépendances dont nous avons besoin pour commencer à travailler avec Spring Vault:


    
        org.springframework.vault
        spring-vault-core
        2.0.1.RELEASE

La dernière version despring-vault-core peut être trouvée surMaven Central.

3. Configuration de Vault

Passons maintenant en revue les étapes nécessaires à la configuration de Vault.

3.1. Créer unVaultTemplate

Pour sécuriser nos secrets, nous devrons instancier unVaultTemplate pour lequel nous avons besoin des instancesVaultEndpoint etTokenAuthentication:

VaultTemplate vaultTemplate = new VaultTemplate(new VaultEndpoint(),
  new TokenAuthentication("00000000-0000-0000-0000-000000000000"));

3.2. Créer unVaultEndpoint

Il existe plusieurs façons d'instancierVaultEndpoint. Jetons un coup d'œil à certains d'entre eux.

La première consiste simplement à l'instancier à l'aide d'un constructeur par défaut, ce qui créera un point de terminaison par défaut pointant vershttp://localhost:8200:

VaultEndpoint endpoint = new VaultEndpoint();

Une autre méthode consiste à créer unVaultEndpoint en spécifiant l'hôte et le port de Vault:

VaultEndpoint endpoint = VaultEndpoint.create("host", port);

Et enfin, nous pouvons également le créer à partir de l'URL du coffre-fort:

VaultEndpoint endpoint = VaultEndpoint.from(new URI("vault uri"));

Il y a quelques points à noter ici - Vault sera configuré avec un jeton racine de00000000-0000-0000-0000-000000000000 pour exécuter cette application.

Dans notre exemple, nous avons utilisé lesTokenAuthentication, mais d’autresauthentication methodsont également pris en charge.

4. Configuration de Vault Beans à l'aide de Spring

Avec Spring, nous pouvons configurer le coffre-fort de plusieurs manières. L'un consiste à étendre lesAbstractVaultConfiguration, et l'autre à utiliserEnvironmentVaultConfiguration qui utilise les propriétés d'environnement de Spring.

Nous allons maintenant passer dans les deux sens.

4.1. Utilisation deAbstractVaultConfiguration

Créons une classe qui étendAbstractVaultConfiguration, pour configurer Spring Vault:

@Configuration
public class VaultConfig extends AbstractVaultConfiguration {

    @Override
    public ClientAuthentication clientAuthentication() {
        return new TokenAuthentication("00000000-0000-0000-0000-000000000000");
    }

    @Override
    public VaultEndpoint vaultEndpoint() {
        return VaultEndpoint.create("host", 8020);
    }
}

Cette approche est similaire à ce que nous avons vu dans la section précédente. La différence est que nous avons utilisé Spring Vault pour configurer les beans Vault en étendant la classe abstraiteAbstractVaultConfiguration.

Il suffit de fournir l'implémentation pour configurerVaultEndpoint etClientAuthentication.

4.2. Utilisation deEnvironmentVaultConfiguration

Nous pouvons également configurer Spring Vault en utilisant lesEnviromentVaultConfiguration:

@Configuration
@PropertySource(value = { "vault-config.properties" })
@Import(value = EnvironmentVaultConfiguration.class)
public class VaultEnvironmentConfig {
}

EnvironmentVaultConfiguration utilise lesPropertySource de Spring pour configurer les beans Vault. Nous devons simplement fournir au fichier de propriétés quelques entrées acceptables.

Plus d'informations sur toutes les propriétés prédéfinies peuvent être trouvées dans lesofficial documentation.

Pour configurer le coffre-fort, nous avons besoin d'au moins deux propriétés:

vault.uri=https://localhost:8200
vault.token=00000000-0000-0000-0000-000000000000

5. Sécuriser les secrets

Nous allons créer une classeCredentials simple qui correspond au nom d'utilisateur et au mot de passe:

public class Credentials {

    private String username;
    private String password;

    // standard constructors, getters, setters
}

Voyons maintenant comment nous pouvons sécuriser notre objetCredentials en utilisant lesVaultTemplate:

Credentials credentials = new Credentials("username", "password");
vaultTemplate.write("secret/myapp", credentials);

Avec ces lignes terminées, nos secrets sont maintenant stockés.

Ensuite, nous verrons comment y accéder.

6. Accéder aux secrets

Nous pouvons accéder aux secrets sécurisés en utilisant la méthoderead() dansVaultTemplate, qui renvoie les VaultResponseSupport en réponse:

VaultResponseSupport response = vaultTemplate
  .read("secret/myapp", Credentials.class);
String username = response.getData().getUsername();
String password = response.getData().getPassword();

Nos valeurs secrètes sont maintenant prêtes.

7. Conclusion

Dans cet article, nous avons découvert les bases de Spring Vault avec un exemple montrant comment le coffre-fort fonctionne dans des scénarios typiques.

Comme d'habitude, le code source présenté ici peut être trouvéover on GitHub.

TOC