Gestion centralisee des secrets avec HashiCorp Vault

Ce projet montre qu'une application Python peut recuperer un mot de passe PostgreSQL depuis Vault au demarrage, sans stocker ce mot de passe dans le code, dans Git ou dans un fichier local.

Le problème

Dans beaucoup de projets, les secrets finissent dans un .env, un docker-compose.yml ou directement dans le code. Des qu'un secret est duplique a plusieurs endroits, il devient difficile a proteger et a revoquer.

Ce que fait ce projet

Le projet suit un flux tres simple:

1. vault.py prepare Vault et stocke le mot de passe de la base.
2. vault.py cree un acces applicatif avec AppRole.
3. app.py recupere le secret au demarrage, se connecte a PostgreSQL et garde le mot de passe uniquement en memoire.

Apercu HashiCorp Vault en local

Mode d'authentification utilise

Ce projet utilise le mode AppRole de Vault, et non le mode userpass.

• userpass sert plutot a authentifier un utilisateur humain avec un login et un mot de passe.
• AppRole sert plutot a authentifier une application ou une machine.

Dans ce projet, AppRole est plus adapte car l'objectif est de faire authentifier une application Python automatiquement au demarrage.

Comment fonctionne AppRole ici

Le fonctionnement est volontairement simple:

1. vault.py cree un role AppRole pour l'application.
2. Vault genere un role_id.
3. Vault genere aussi un secret_id, mais il est transmis sous forme de wrapped token pour eviter de l'exposer directement.
4. app.py ouvre d'abord ce wrapped token pour recuperer le secret_id.
5. Ensuite, app.py envoie role_id + secret_id a Vault.
6. Vault renvoie alors un token temporaire limite par la policy app-read-db.
7. Avec ce token temporaire, l'application peut lire uniquement secret/app/db.

En resume:

• role_id = identifiant de l'application
• secret_id = secret d'authentification de l'application
• token Vault = acces temporaire donne par Vault apres verification

L'application n'utilise donc jamais le root token pour lire les secrets.

Schema du flux

flowchart LR
    A[app.py] -->|unwrap du wrapped token| B[Vault]
    B -->|retourne secret_id| A
    A -->|role_id + secret_id| B
    B -->|retourne un token temporaire| A
    A -->|lit secret/app/db| B
    B -->|retourne le mot de passe DB| A
    A -->|connexion avec le secret en memoire| C[PostgreSQL]

Loading

Structure

Projet_Vault/
├── app.py
├── vault.py
├── docker-compose.yml
├── requirements.txt
└── vault/
    ├── vault-config.hcl
    └── app-policy.hcl

A quoi sert chaque fichier

• docker-compose.yml lance Vault et PostgreSQL en local.
• vault.py configure Vault et prepare l'acces de l'application.
• app.py simule une application cliente qui lit son secret au demarrage.
• vault/app-policy.hcl limite l'application a la lecture de son secret.
• vault/vault-config.hcl contient la configuration locale du serveur Vault.

Commandes a lancer

Premier lancement

PowerShell

cd C:\repertoire-projet
python -m pip install -r requirements.txt
docker compose up -d
python vault.py

Git Bash

cd ~/repertoire-projet
python -m pip install -r requirements.txt
docker compose up -d
python vault.py

Au premier lancement, conserve bien:

• VAULT_UNSEAL_KEY
• VAULT_ROOT_TOKEN
• VAULT_ROLE_ID
• VAULT_WRAPPED_SECRET_ID

Lancer l'application apres vault.py

PowerShell

$env:VAULT_ADDR='http://127.0.0.1:8200'
$env:VAULT_ROLE_ID='COLLER_LE_ROLE_ID'
$env:VAULT_WRAPPED_SECRET_ID='COLLER_LE_WRAPPED_SECRET_ID'
python app.py

Git Bash

export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_ROLE_ID='COLLER_LE_ROLE_ID'
export VAULT_WRAPPED_SECRET_ID='COLLER_LE_WRAPPED_SECRET_ID'
python app.py

Si Vault a deja ete initialise puis redemarre

Vault se rescelle apres redemarrage. Il faut donc remettre la cle d'unseal et le root token avant de relancer vault.py.

PowerShell

$env:VAULT_UNSEAL_KEY='COLLER_LA_CLE_UNSEAL'
$env:VAULT_ROOT_TOKEN='COLLER_LE_ROOT_TOKEN'
python vault.py

Git Bash

export VAULT_UNSEAL_KEY='COLLER_LA_CLE_UNSEAL'
export VAULT_ROOT_TOKEN='COLLER_LE_ROOT_TOKEN'
python vault.py

Tester le projet en local

1. Aller dans le dossier du projet

cd C:\repertoire-projet

2. Installer les dependances Python

python -m pip install -r requirements.txt

3. Demarrer Vault et PostgreSQL

docker compose up -d
docker compose ps

Tu dois voir vault_server et postgres_container en cours d'execution.

Note: PostgreSQL est expose sur le port 5433 pour eviter un conflit avec un PostgreSQL local deja present sur la machine.

4. Configurer Vault et generer les identifiants applicatifs

python vault.py

Le script affiche:

• VAULT_UNSEAL_KEY et VAULT_ROOT_TOKEN au premier lancement,
• VAULT_ROLE_ID,
• VAULT_WRAPPED_SECRET_ID.

Si Vault a deja ete initialise et que le conteneur a redemarre, il faut d'abord definir VAULT_UNSEAL_KEY et VAULT_ROOT_TOKEN, puis relancer python vault.py.

5. Lancer l'application

$env:VAULT_ADDR='http://127.0.0.1:8200'
$env:VAULT_ROLE_ID='COLLER_LE_ROLE_ID'
$env:VAULT_WRAPPED_SECRET_ID='COLLER_LE_WRAPPED_SECRET_ID'
python app.py

6. Resultat attendu

L'application doit:

• ouvrir le wrapped token,
• se connecter a Vault avec AppRole,
• lire le secret dans Vault,
• se connecter a PostgreSQL,
• afficher la ligne de demo lue dans la base.

Exemple de sortie:

Connexion OK a la base 'db_vault' avec l'utilisateur 'vault_app'.
Ligne de demo lue en base : secret recupere depuis Vault au demarrage

7. Si le token a expire

Le VAULT_WRAPPED_SECRET_ID est temporaire. Pour en generer un nouveau:

python vault.py

8. Arreter le projet

docker compose down

Pour tout supprimer, y compris les volumes:

docker compose down -v

Pourquoi ce projet est interessant

• aucun mot de passe n'est ecrit en dur dans le repo,
• l'application n'utilise pas le root token,
• l'acces Vault est limite a un seul secret,
• le mot de passe est utilise uniquement en memoire.

Ce que j'ai appris

• pourquoi AppRole est plus adapte qu'un simple login/mot de passe pour une application,
• comment limiter l'acces a un secret avec une policy Vault,
• comment transmettre un secret_id de maniere plus propre avec un wrapped token,
• pourquoi il faut penser aux conflits de ports et aux volumes persistants dans Docker,
• comment garder un secret uniquement en memoire dans une application.

Licence

Ce projet est sous licence MIT — voir le fichier LICENSE pour plus de détails.