Comment installer HashiCorp Vault en 2026 (Guide débutant)

Introduction

HashiCorp Vault est un outil open-source essentiel pour la gestion centralisée des secrets, des certificats et des identités. Dans un monde où les breaches de données coûtent des millions, Vault offre un chiffrement dynamique, une rotation automatique des clés et un audit complet des accès. Pourquoi l'utiliser en 2026 ? Les applications cloud-native et les microservices exigent une sécurité zero-trust : Vault excelle ici en intégrant Kubernetes, AWS et Terraform.

Ce tutoriel beginner vous emmène des bases à une utilisation pratique. Vous apprendrez à installer Vault en mode dev, à initialiser un cluster, à stocker/récupérer des secrets via CLI, et à implémenter des politiques. À la fin, vous maîtriserez un setup production-ready basique. Idéal pour les développeurs et ops qui veulent sécuriser leurs APIs sans complexité excessive. Temps estimé : 20 minutes.

Prérequis

Système : Linux/macOS/Windows avec WSL
Go 1.21+ installé (optionnel, pour build from source)
Connaissances basiques en ligne de commande
Ports libres : 8200 (Vault), 8201 (cluster)
Aucun compte HashiCorp requis pour le mode dev

Télécharger et installer Vault

install-vault.sh

#!/bin/bash

# Télécharger la dernière version stable (vérifiez sur https://developer.hashicorp.com/vault/install)
VAULT_VERSION="1.17.0"
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)

if [ "$OS" = "darwin" ]; then
  OS="darwin"
fi

wget https://releases.hashicorp.com/vault/${VAULT_VERSION}/vault_${VAULT_VERSION}_${OS}_${ARCH}.zip
unzip vault_${VAULT_VERSION}_${OS}_${ARCH}.zip
sudo mv vault /usr/local/bin/
rm vault_${VAULT_VERSION}_${OS}_${ARCH}.zip LICENSE README.md

# Vérifier l'installation
vault --version

Ce script télécharge, extrait et installe Vault dans /usr/local/bin/. Il détecte automatiquement OS et architecture pour une compatibilité universelle. Évitez les pièges : vérifiez toujours la version sur le site officiel pour les correctifs de sécurité critiques.

Comprendre le fichier de configuration

Avant de démarrer Vault, créez un fichier de config minimal. Vault utilise HCL (similaire à JSON mais plus lisible). En mode dev, tout est chiffré en mémoire (idéal pour tests), mais en prod, passez à un storage persistant comme Consul ou Raft.

Créer le fichier de configuration

vault.hcl

ui = true

listener "tcp" {
  address     = "127.0.0.1"
  tls_disable = true
  port        = 8200
}

storage "file" {
  path = "/tmp/vault/data"
}

seal "transit" {
  address = "127.0.0.1:8200"
  disable_clustering = true
}

api_addr = "http://127.0.0.1:8200"
cluster_addr = "https://127.0.0.1:8201"

Cette config active l'UI web, écoute sur localhost:8200 sans TLS (dev only), et utilise un storage file temporaire. Le seal transit est pour l'auto-unseal en prod. Piège : n'utilisez jamais tls_disable=true en production pour éviter les attaques MITM.

Démarrer Vault en mode serveur

start-vault.sh

#!/bin/bash

# Créer répertoires nécessaires
mkdir -p /tmp/vault/data

# Démarrer Vault avec la config
vault server -config=vault.hcl &

# Attendre que Vault soit prêt
sleep 3

# Devenir root et initialiser (mode dev simplifié)
export VAULT_ADDR='http://127.0.0.1:8200'
vault operator init -key-shares=1 -key-threshold=1 -format=json > cluster-keys.json

# Unseal avec la clé
vault operator unseal $(vault operator unseal -address=$VAULT_ADDR -format=json | jq -r '.unseal_keys_b64[0]')

# Login avec la root token
ROOT_TOKEN=$(cat cluster-keys.json | jq -r '.root_token')
vault login $ROOT_TOKEN

echo "Vault est prêt ! Token root: $ROOT_TOKEN"

Ce script lance Vault, l'initialise avec 1 share (dev), l'unseal et logue avec le root token. Utilisez jq pour parser JSON. Attention : en prod, utilisez au moins 5 shares et ne hardcodez jamais le root token.

Stocker et lire vos premiers secrets

Maintenant, interagissez avec Vault via CLI. Les secrets sont stockés dans des 'mounts' comme kv-v2 pour key-value pairs. C'est comme un coffre-fort : vous chiffrez dynamiquement sans exposer les creds en clair.

Activer un backend secrets et stocker

secrets.sh

#!/bin/bash

export VAULT_ADDR='http://127.0.0.1:8200'
ROOT_TOKEN="PASTE_YOUR_ROOT_TOKEN_HERE"  # Remplacez par votre token
vault login $ROOT_TOKEN

# Activer KV v2 secrets engine à secret/
vault secrets enable -path=secret kv-v2

# Stocker un secret (API key exemple)
vault kv put secret/myapp/config api_key="sk-1234567890abcdef" db_url="postgres://user:pass@localhost:5432/prod"

# Lire le secret
vault kv get secret/myapp/config

# Lister les clés
vault kv list secret/myapp/

On active kv-v2 (versionné), stocke et lit des secrets. Les paths sont hiérarchiques comme /secret/myapp/config. Piège : toujours spécifier -version=1 pour les reads historiques, et rrotatez les API keys via Vault.

Créer une politique d'accès

myapp-policy.hcl

path "secret/data/myapp/*" {
  capabilities = ["create", "read", "update", "delete", "list"]
}

path "secret/metadata/myapp/*" {
  capabilities = ["list", "delete"]
}

path "sys/leases/+/lookup" {
  capabilities = ["read", "list"]
}

Cette politique HCL donne accès read/write sur secret/myapp/. capabilities contrôlent les ops fines. Appliquez-la via vault policy write myapp myapp-policy.hcl. Évitez '*' wildcards trop larges pour le least-privilege.

Appliquer la politique et tester

policy-test.sh

#!/bin/bash

export VAULT_ADDR='http://127.0.0.1:8200'

# Écrire la politique
vault policy write myapp-policy myapp-policy.hcl

# Créer un token avec la politique
TOKEN=$(vault token create -policy=myapp-policy -format=json | jq -r '.auth.client_token')

# Tester avec le nouveau token
vault login $TOKEN
vault kv get secret/myapp/config

# Révoquer le token après test
vault token revoke $TOKEN

echo "Test réussi !"

On crée un token policy-bound, teste l'accès, et révoque. Cela simule un user/app auth. Piège majeur : révoquez toujours les tokens test pour éviter les fuites de sécurité.

Accéder à l'UI Vault

Ouvrez http://127.0.0.1:8200 dans votre navigateur. Login avec le root token. Explorez Secrets > secret/, Policies et Audit Logs. L'UI facilite le debugging pour les débutants.

Bonnes pratiques

Ne jamais utiliser root token en prod : Créez des tokens/app roles éphémères.
Activez l'audit logging : vault audit enable file file_path=/var/log/vault_audit.log.
Utilisez auto-unseal : Avec AWS KMS ou GCP pour zero-downtime.
Intégrez avec CI/CD : Stockez creds GitHub Actions dans Vault.
Migrez vers Raft storage : storage "raft" { path = "/opt/vault/data" } pour HA.

Erreurs courantes à éviter

Vault sealed : Toujours vault operator unseal après redémarrage ; vérifiez vault status.
Mauvais VAULT_ADDR : Exportez-le avant toute commande CLI.
Oubli de mount : vault secrets list pour lister ; activez avant usage.
Politiques trop permissives : Testez avec vault token capabilities $TOKEN path.

Pour aller plus loin

Maîtrisez les engines avancés (PKI, DB creds). Consultez la doc officielle Vault. Découvrez nos formations Learni sur DevOps et sécurité pour un parcours certifiant HashiCorp.

Comment installer et utiliser HashiCorp Vault en 2026