Externaliser vos configurations avec Vault pour des déploiements évolutifs

Table des matières:

introduction
1. La solution
Configuration du coffre-fort
1. Création d’une règle d’administration d’API
2. Création d’une stratégie utilisateur en lecture seule
3. Création d’un jeton attaché avec une règle de lecture seule de l’API
1. Intégration du shell Linux
2. Intégration Java
3. Intégration Python
4. Intégration de Nodejs
5. Intégration Ansible
Conclusion

Introduction:

Pour mettre en œuvre l’automatisation des microservices ou des applications déployées sur un grand nombre de systèmes, il devient essentiel d’externaliser les configurations vers un magasin de configuration sécurisé, évolutif et centralisé. Cela est nécessaire pour pouvoir déployer l’application dans plusieurs environnements avec des paramètres spécifiques à l’environnement sans nécessiter d’intervention humaine et sans nécessiter de modification de l’application principale pendant les déploiements automatisés, la mise à l’échelle et les récupérations de basculement.

Outre le fait que les configurations gérées manuellement impliquent un risque d’erreur humaine, elles ne sont pas non plus évolutives pour les déploiements à grande échelle 24h/24 et 7j/7, en particulier lorsque nous déployons plusieurs instances de microservices sur diverses plates-formes d’infrastructure.

La rotation périodique des informations d’identification de l’application est une bonne pratique de sécurité standard afin d’assurer la maintenance et d’éviter les abus au fil du temps. L’externalisation des informations d’identification garantit la fiabilité du système et réduit les erreurs/dépendances humaines. Si l’entière responsabilité du maintien des informations d’identification incombe à peu de super-héros, cela est considéré comme une menace pour la continuité des activités. Il existe divers outils disponibles dans le domaine de sécurité pour gérer l’accès fédéré aux informations d’identification privilégiées.

La solution

Dans cet article, nous examinons l’une des solutions à ce problème à l’aide de l’outil appelé Vault. Voici quelques-unes des raisons pour lesquelles nous avons choisi Vault :

Vault est un projet open source avec une grande communauté qui contribue activement. Le support d’entreprise est disponible auprès de HashiCorp avec différents modèles de licence pour s’adapter au SLA de l’organisation.
Il existe une large gamme de bibliothèques de langages de programmation disponibles pour l’intégration du coffre-fort.
Vault fonctionne bien avec un grand nombre de backends d’authentification. De nombreuses organisations permettent principalement au backend LDAP de s’intégrer à Active Directory central ; cependant, Vault a la capacité de fédérer différentes méthodes d’authentification.
Vault peut facilement être configuré dans une configuration à haute disponibilité avec deux variables simples dans config. Dans le backend, les données Vault peuvent être stockées dans divers backends de stockage haute disponibilité.
Il existe un large éventail de types de données de configuration que nous pouvons conserver et consommer facilement dans les moteurs secrets disponibles du coffre-fort. Dans cet exemple, nous allons regarder le plus simple : le stockage Key-Value.

Dans cet article, j’ai essayé de consolider certaines des méthodes les plus simples pour intégrer Vault avec 5 langages/outils de programmation principaux avec lesquels nous travaillons principalement. Si j’ai raté l’un des langages courants, il est probable que la bibliothèque d’API existe pour le même et puisse conceptuellement être implémentée de la même manière.

Nous allons examiner les exemples suivants :

Shell : intégration simple du script shell avec les variables d’environnement de Vault ; nous examinons également certains scripts basés sur Python pour certains cas d’utilisation avancés
Python : intégration de l’API Flask à l’aide de la bibliothèque client hvac
Java : application de démarrage Spring utilisant l’API VaultConfig pour utiliser directement les secrets Vault dans l’application.properties
Node.js : intégration avec Node.js à l’aide de la bibliothèque node-vault
Ansible : intégration à Ansible pour utiliser directement les variables de HashiCorp Vault (pas Ansible Vault) à l’aide du plugin hashi_vault.

Bien qu’il existe beaucoup de documentation sur ce sujet, la question me revient sans cesse, car notre équipe a trouvé les exemples et la documentation un peu difficiles à démarrer. J’ai donc décidé d’écrire ces kickstarts simples pour nous aider à démarrer avec le moins d’étapes.

Le code de cet article est hébergé sur GitHub.

D’accord, commençons d’abord par configurer Vault.

Configuration du coffre-fort

Exécuter Vault localement est assez simple. Nous pouvons télécharger le binaire https://www.vaultproject.io/downloads et exécuter le coffre-fort en mode dev vault server -dev.

Nous pouvons également exécuter Vault à partir de l’image disponible dans Docker Hub : docker run -d -p 8200:8200 --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=myroot' -e 'VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200' vault

Dans l’environnement de production, vous exécuteriez Vault en mode serveur : https://learn.hashicorp.com/tutorials/vault/getting-started-deploy. Les backends haute disponibilité et les configurations HA pour Vault sont disponibles sur Vault-HA.

Une fois que Vault est opérationnel, nous pouvons nous connecter à Vault avec le jeton fourni ci-dessus ou l’obtenir à partir de la console. Nous activerions le moteur Key Value à l’emplacement kv s’il n’est pas déjà activé. Pour ce cas d’utilisation, nous avons activé l’authentification par passe utilisateur, bien que dans les environnements d’entreprise, l’authentification LDAP soit assez standard. L’expérience utilisateur ne change pas. Vault sera en mesure de fournir une expérience API transparente, quelle que soit la méthode d’authentification. Nous avons seulement besoin de passer de /auth/userpass à /auth/ldap dans l’appel d’API.

Maintenant, pour gérer ou lire les secrets de Vault, nous aurions besoin de configurer les stratégies pour gérer/accéder aux secrets. Vous voudriez mettre en place cette structure en fonction de notre hiérarchie projet/applications. Dans cet exemple, nous allons créer deux stratégies simples. La stratégie d’administration de l’application peut être attribuée à l’administrateur de l’application qui pourrait se connecter à Vault et générer soit un jeton capable de gérer lui-même les configurations de l’application, soit un jeton en lecture seule qui n’autorise que des capacités de lecture seule pour les configurations.

Veuillez noter que dans tous les exemples ci-dessous, nous utilisons des variables assez standard qui doivent être fournies en fonction de l’emplacement de votre coffre-fort lors du lancement des échantillons respectifs.

VAULT_HOST=localhost
VAULT_PORT=8200
VAULT_ADDR=http://localhost:8200
VAULT_TOKEN=<<vault_token>>
VAULT_KEYS_PATH=<<Location of your config values. In our case it is kv/data/amitthk/vault-demo/dev>>

Création d’une règle d’administration d’API

Pour créer la stratégie, nous nous sommes connectés à Vault UI avec un jeton racine et avons créé la stratégie suivante :

voûtedemo_api_adm

Cette politique permet à l’utilisateur, tout d’abord, de pouvoir répertorier le contenu dans le key value store (kv) ; puis, permet à notre emplacement sécurisé kv/amitthk/vault-demo/dev* d’être modifiable.

path "kv/*" {
  capabilities = ["list"]
}path "kv/data/application*" {
  capabilities = ["create", "read", "update", "list"]
}path "kv/metadata/application*" {
  capabilities = ["create", "read", "update", "list"]
}path "kv/amitthk/vault-demo/dev*" {
  capabilities = ["create", "read", "update", "delete", "list"]
}path "kv/data/amitthk/vault-demo/dev*" {
  capabilities = ["create", "read", "update", "delete", "list"]
}
path "kv/metadata/amitthk/vault-demo/dev*" {
  capabilities = ["create", "read", "update", "delete", "list"]
}

Création d’une politique utilisateur en lecture seule

coffre-fortdemo_api_readonly

path "kv/application*" {
  capabilities = ["read","list"]
}path "kv/data/application*" {
  capabilities = ["read","list"]
}path "kv/amitthk/vault-demo/dev*" {
  capabilities = ["read", "list"]
}path "kv/data/amitthk/vault-demo/dev*" {
  capabilities = ["read"]
}

Nous avons créé un utilisateur nommé vaultdemoadm sous la méthode d’authentification userpass :

Pass utilisateur des méthodes d'authentification

Nous allons maintenant attribuer nos politiques à notre utilisateur qui peut se connecter avec la méthode userpass :

vault write auth/userpass/users/vaultdemoadm password=password123 policies=default,vaultdemo_api_adm,vaultdemo_api_readonly

Plus de détails : https://www.vaultproject.io/docs/concepts/policies

Notre utilisateur vaultdemoadm pourra alors se connecter au coffre-fort via l’interface utilisateur et enregistrer les paires clé-valeur comme dans l’image ci-dessous.

Les utilisateurs peuvent également se connecter à partir de l’interface CLI ou API et mettre à jour les valeurs ci-dessus.

curl --request POST --data '{"password":"password123", "ttl": "1h"}' http://localhost:8200/v1/auth/userpass/login/vaultdemoadm

Cela nous donne une réponse comme ci-dessous. Ici, notre jeton est client_token :

{"request_id":"a4be2704-5079-e719-7c07-51ea105250a2","lease_id":"","renewable":false,"lease_duration":0,"data":null,"wrap_info":null,"warnings":null,"auth":{"client_token":"s.HvmpPVjnGEK1KpSJPZDhhEfi","accessor":"kodwoxRXSgzVTnhKv2nLfdNT","policies":["default","vaultdemo_api_adm","vaultdemo_api_readonly"],"token_policies":["default","vaultdemo_api_adm","vaultdemo_api_readonly"],"metadata":{"username":"vaultdemoadm"},"lease_duration":2764800,"renewable":true,"entity_id":"41df50e9-98e1-d252-b630-10ae12952397","token_type":"service","orphan":true}}

Création d’une stratégie de jeton attaché à l’API en lecture seule

Pour créer le jeton, nous créons le fichier payload.json comme ci-dessous :

{
  "policies": ["vaultdemo_api_readonly"],
  "ttl": "1h",
  "renewable": false
}

La commande suivante sera utilisée pour générer le jeton. (N’oubliez pas de remplacer <> ci-dessous par le jeton de votre connexion ci-dessus.)

curl --header "X-Vault-Token: <<api_admin_user_token>>" --request POST --data @payload.json http://localhost:8200/v1/auth/token/create

Nous pouvons également utiliser le jeton ci-dessus pour générer un jeton d’administrateur d’API pour une durée de bail plus longue.

{
   "policies": ["vaultdemo_api_adm", "default", "vaultdemo_api_readonly"],
   "ttl": "1h",
   "renewable": false
}

Utilisons maintenant les valeurs de configuration stockées dans Vault ci-dessus avec nos applications. Nous utiliserons notre jeton en lecture seule pour lire ces valeurs dans les exemples ci-dessous.

1. Intégration du shell Linux : variables d’environnement de Vault

La manière la plus basique d’interagir avec Vault ici est d’interagir avec l’API directement avec cURL, puis d’utiliser jq pour analyser la réponse. L’extrait de code suivant de /shell/vault_draw_kv.sh dans le répertoire du projet fait de même.

Remarque : Vous devez soit installer jq yum install -y jq ou utilisez Python et pip install requests.

#!/bin/bashif [[ $# -eq 0 ]] ; then
    echo 'usage ./vault_draw_kv.sh <<VAULT_ADDR>> <<VAULT_TOKEN>>  <<VAULT_KEYS_PATH>>'
    exit 1
fiVAULT_ADDR=$1
VAULT_TOKEN=$2
VAULT_KEYS_PATH=$3rm -f .envuser=$(curl  -H "X-Vault-Token: $VAULT_TOKEN" 
        -X GET $VAULT_ADDR/v1/$VAULT_KEYS_PATH)echo DB_ENDPOINT=$(echo $user | jq -r .data.data.dbendpoint) > .env
echo DB_USER=$(echo $user | jq -r .data.data.dbuser) >> .env
echo DB_PASSWORD=$(echo $user | jq -r .data.data.dbpass) >> .env

Utilisation d’un script Python simple pour récupérer la configuration à partir du coffre-fort

Jetez un œil à l’extrait de code suivant du fichier /python/vault_withdraw_secrets.py dans le répertoire du projet :

response = requests.get(request_url,headers=headers)
while retry_count >= 0:
    time.sleep(3) # wait 3 seconds then try again
    try:
        #print('response: '+str(response.json()))
        foutput=""
        for field_name in response.json()['data']['data']:
            value = str(response.json()['data']['data'][field_name])
            if should_decode is True:
                value = value.decode('base64')
            foutput = foutput + field_name + "=" + value + "n"            write_to_file(file_name=VALUE_FILE,f_output=foutput)

Pour une autre implémentation que nous utilisons essentiellement avec notre authentification LDAP (pour l’utilisateur api_readonly), veuillez vérifier https://github.com/amitthk/vault-intgs/blob/master/python/vault_withdraw_secrets_ldap-auth.py dans le répertoire du projet.

2. Intégration de l’application Java Spring Boot : variables d’environnement application.properties à partir du coffre-fort

Dans le…