Terraform Vault Gestion : des credentials dynamique pour IAC
Sommaire
Introduction
Dans un monde où l’infrastructure as code (IaC) est devenue la norme, la question de la gestion des secrets se pose plus que jamais. Déployer des ressources cloud, provisionner des bases de données ou configurer des services nécessite souvent de manipuler des identifiants sensibles : mots de passe, clés API, tokens d’authentification… Mal gérés, ces secrets peuvent devenir des failles de sécurité critiques.
Une mauvaise pratique encore trop répandue consiste à hardcoder des credentials dans les fichiers Terraform ou à les stocker dans des systèmes de versionnement comme Git. Cela expose l’organisation à des risques importants : fuites accidentelles, difficulté de rotation, non-conformité avec les politiques de sécurité ou les normes réglementaires.
Pour répondre à ces enjeux, deux outils de l’écosystème HashiCorp se distinguent : Terraform, pour la gestion déclarative de l’infrastructure, et Vault, pour la gestion sécurisée des secrets. Utilisés ensemble, ils permettent une approche élégante et robuste : fournir à Terraform des credentials dynamiques, à durée de vie limitée, générés à la demande par Vault.
Dans cet article, nous verrons comment ces deux outils peuvent s’intégrer pour sécuriser votre infrastructure as code, en évitant le stockage statique de secrets tout en automatisant leur gestion. Nous commencerons par une présentation rapide de Terraform et Vault, avant de plonger dans le fonctionnement des credentials dynamiques et d’illustrer le tout avec un cas concret d’intégration.
Présentation des outils – Terraform et Vault
Avant de plonger dans la gestion de credentials dynamiques, il est essentiel de comprendre les deux piliers de cette approche : Terraform et Vault, tous deux développés par HashiCorp.
Terraform : l’infrastructure as code
Terraform est un outil open source permettant de gérer l’infrastructure via du code déclaratif. Concrètement, il permet de décrire son infrastructure (serveurs, bases de données, réseaux, services cloud, etc.) dans des fichiers .tf, puis de l’appliquer de façon automatique et reproductible.
Terraform se distingue par sa capacité à automatiser totalement le provisionnement de ressources, à assurer une traçabilité via le versioning Git, et à s’intégrer avec un large éventail de fournisseurs de services cloud comme AWS, GCP, Azure ou encore Kubernetes. Il s’inscrit naturellement dans les workflows CI/CD modernes, en transformant l’infrastructure en une entité décrite, testée et déployée comme n’importe quel code applicatif.
Avec Terraform, l’infrastructure devient une pièce de code versionnée et auditable. Mais cette puissance soulève aussi une question centrale : comment sécuriser les secrets nécessaires au déploiement ?
Vault : la gestion sécurisée des secrets
Vault est une solution de gestion de secrets conçue pour stocker, contrôler et distribuer de manière sécurisée des données sensibles : mots de passe, tokens, certificats, clés API, etc. Mais Vault va plus loin : il ne se contente pas de stocker des secrets, il peut aussi en générer dynamiquement à la demande.
Vault permet, par exemple, de générer des identifiants temporaires pour accéder à une base de données ou à un compte cloud, tout en appliquant des politiques d’accès fines pour contrôler précisément qui peut accéder à quoi. Il prend également en charge la rotation automatique des secrets, et fournit des capacités d’audit complètes pour suivre toutes les interactions avec les données sensibles. En d’autres termes, Vault agit comme un courtier sécurisé de secrets, capable de délivrer des accès temporaires qui expirent automatiquement après un certain temps.
Pourquoi les utiliser ensemble ?
Terraform a besoin de credentials pour provisionner certains services, comme créer une base de données ou déployer des ressources dans un cloud provider. Vault, de son côté, est capable de fournir ces credentials à la volée, en s’assurant qu’ils sont éphémères, sécurisés, et qu’ils ne traînent jamais dans le code source ni dans les fichiers d’état de Terraform.
Ce duo permet donc de concilier automatisation et sécurité : une infrastructure déployée rapidement, mais sans compromettre la gestion des secrets.
Les credentials dynamiques avec Vault
Traditionnellement, les identifiants utilisés pour accéder à des ressources — bases de données, services cloud, APIs — sont générés manuellement et stockés de façon statique. Cela implique de devoir les partager, les protéger, les faire tourner régulièrement, et espérer qu’ils ne finissent pas exposés quelque part. Cette méthode est non seulement fastidieuse, mais surtout peu adaptée aux exigences de sécurité actuelles.
Vault introduit une approche radicalement différente avec ce qu’on appelle les credentials dynamiques. Il ne s’agit plus de stocker un mot de passe pour le réutiliser plus tard, mais de générer un identifiant temporaire à la demande, avec une durée de vie limitée, et des permissions précisément définies.
Prenons un exemple concret : au lieu de créer manuellement un utilisateur MySQL avec des droits spécifiques pour Terraform, Vault peut être configuré pour générer cet utilisateur automatiquement, uniquement au moment où Terraform en a besoin. Une fois le TTL (Time To Live) expiré, l’utilisateur est automatiquement révoqué par Vault. Le secret n’existe donc que pendant le laps de temps nécessaire, ce qui limite considérablement la surface d’attaque.
Ce fonctionnement repose sur ce que Vault appelle des backends secrets dynamiques. Il en existe pour de nombreux services : bases de données (PostgreSQL, MySQL, MongoDB…), cloud providers (AWS, GCP, Azure), services internes, etc. Chaque backend est configuré avec un accès administrateur, et Vault se charge de générer les comptes d’accès de manière éphémère, contrôlée et auditable.
Les bénéfices sont multiples : une sécurité renforcée par la réduction des secrets persistants, une meilleure conformité grâce à l’audit et à la rotation automatique, et une gestion simplifiée sans intervention manuelle. L’approche dynamique permet d’inscrire la gestion des secrets dans une logique on demand, parfaitement alignée avec les pratiques DevOps et l’automatisation de l’infrastructure.
Dans la prochaine partie, nous verrons comment intégrer ce duo dans un workflow Terraform, avec un exemple concret à la clé.
Cas pratique – Déploiement d’une instance EC2 avec des credentials AWS dynamiques via Vault et Terraform
Dans cette partie, nous allons illustrer une intégration simple et concrète de Vault avec Terraform, en déployant une instance EC2 sur AWS. A noter qu’il existe plusieurs façons de configurer ce déploiement de manière plus sécurisée ou optimisée, nous allons volontairement voir une approche très simplifiée pour nous focaliser sur le principe de credentials dynamique.
Pré-requis :
- Terraform et Vault installé (une installation local est suffisante pour cet exemple)
- Un compte AWS avec les permissions nécessaires pour créer des instances EC2
- AWS CLI (configuré avec votre compte AWS)
Vault et Terraform peuvent être installer depuis ces liens :
https://developer.hashicorp.com/vault/install /
https://developer.hashicorp.com/terraform/install
Configuration de Vault
1. Démarrer Vault en mode Développement
vault server -devNotez l’adresse du serveur Vault (http://127.0.0.1:8200) et le token racine fourni dans la sortie
2. Configurer l’environnement
export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_TOKEN='your-root-token'
3. Activer le Backend AWS dans Vault
vault secrets enable aws
4. Configurer les Credentials AWS dans Vault
Configurez Vault avec les credentials d’un utilisateur IAM ayant les permissions nécessaires pour créer des rôles et des utilisateurs IAM. Remplacez your-access-key et your-secret-key par vos propres credentials AWS.
vault write aws/config/root \
access_key=your-access-key \
secret_key=your-secret-key \
region=us-west-2
5. Créer un Rôle AWS dans Vault
Créez un rôle dans Vault qui définit les permissions AWS nécessaires pour déployer votre infrastructure
vault write aws/roles/my-role \
credential_type=iam_user \
policy_document=-<<EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:*",
"Resource": "*"
},
{
"Sid": "AllowSelfGetUser",
"Effect": "Allow",
"Action": "iam:GetUser",
"Resource": "*"
}
]
}
EOF
ttl=1h
6. Vérifier la Configuration
vault read aws/config/root
vault read aws/roles/my-role
A ce stade, vous êtes en droit de vous poser la question suivante : Pourquoi ai-je besoin d’un utilisateur IAM disposant déjà des droits nécessaires ?
Vous avez besoin d’un utilisateur IAM avec des droits étendus uniquement pour initialiser Vault : c’est-à-dire lui donner la capacité de créer des credentials temporaires via l’API AWS (iam:CreateUser, iam:CreateAccessKey, etc.). Une fois cette étape faite (typiquement lors de l’aws/config/root), cet utilisateur ne sera plus utilisé dans le workflow courant et pourra même être désactivé par la suite ou gardé en backup.
Configuration de Terraform
1. Créer vos fichiers .tf
terraform-project/
│
├── main.tf
├── data.tf
├── provider.tf
La segmentation des fichiers dans un projet Terraform est une pratique essentielle pour maintenir l’organisation, la lisibilité et la maintenabilité de votre infrastructure en tant que code (IaC). Il est recommandé de séparer les configurations en plusieurs fichiers en fonction de leur type.
main.tf
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 4.0"
}
}
required_version = ">= 1.0"
}
resource "aws_instance" "example" {
ami = "ami-05572e392e80aee89" # Remplacez par une AMI valide dans votre région
instance_type = "t2.micro"
tags = {
Name = "Terraform-Vault-Example"
}
}
data.tf
data "vault_aws_access_credentials" "creds" {
role = "my-role"
backend = "aws"
}
provider.tf
provider "aws" {
region = "us-west-2"
access_key = data.vault_aws_access_credentials.creds.access_key
secret_key = data.vault_aws_access_credentials.creds.secret_key
}
provider "vault" {
address = "http://127.0.0.1:8200/"
token = "your-vault-token" # Remplacez par le token racine fourni par Vault en mode développement
}
2. Initialiser Terraform
terraform init
3. Générer un plan
terraform plan
4. Appliquer la configuration
terraform apply
Depuis la console AWS
Une fois le déploiement effectué, nous pouvons vérifier plusieurs choses depuis la console AWS :
- Le déploiement de l’instance EC2
- L’utilisateur IAM crée dynamiquement
- Le rôle utilisé
1. Création de l’instance
L’instance a bien été crée conforme à nos configuration
2. Utilisateur crée dynamiquement par Vault
L’utilisateur IAM a bien été crée et sera supprimé dans 1h (ttl)
3. Rôle associé à l’utilisateur
En cliquant sur l’utilisateur dynamiquement crée, nous pouvons voir le rôle configuré depuis Vault « my-role »
Conclusion
Dans cet article, nous avons exploré comment utiliser Terraform et Vault pour gérer les credentials dynamiques pour l’infrastructure as code. En intégrant Vault avec Terraform, nous avons pu générer des credentials AWS temporaires et sécurisés, améliorant ainsi la sécurité et la gestion des accès dans nos déploiements.
Cet article n’est qu’une introduction au vaste sujet de la gestion des credentials dynamiques avec Terraform et Vault. Les outils sont bien plus poussés et méritent d’y passer du temps pour explorer leurs fonctionnalités avancées.
N’hésitez pas à expérimenter et à adapter ces concepts à vos besoins spécifiques pour tirer le meilleur parti de ces outils.