Terraform : bien gérer l’état et les modules dès le départ

Par Hamza Mechtaly · · 3 min de lecture

État distant et verrouillé, découpage par environnement, modules versionnés, plan relu en CI : ce que je mets en place dès le premier jour sur un projet Terraform.

Terraform : état et modules

Terraform est facile à démarrer et difficile à réorganiser. Une fois que l’infrastructure de production dépend d’un fichier d’état mal rangé, chaque refonte devient une opération à cœur ouvert. Autant poser les bases dès le premier jour.

L’état, c’est la vérité

Le fichier d’état (state) est la mémoire de Terraform : il fait le lien entre votre code et les ressources réelles. S’il est perdu ou corrompu, Terraform ne sait plus ce qu’il gère. Trois règles :

  1. état distant, jamais sur le poste d’un développeur : un bucket S3, un backend HTTP, Terraform Cloud, ou l’équivalent de votre fournisseur ;
  2. verrouillage, pour que deux personnes ne fassent pas apply en même temps ;
  3. chiffrement et accès restreints, car l’état contient souvent des secrets en clair.
terraform {
  backend "s3" {
    bucket       = "acme-terraform-state"
    key          = "reseau/prod.tfstate"
    region       = "eu-west-3"
    encrypt      = true
    use_lockfile = true
  }
}

Un état par périmètre et par environnement

Un état unique pour toute l’infrastructure, c’est un plan qui prend dix minutes et une erreur qui peut tout toucher. Je découpe par domaine (réseau, base de données, application) et par environnement, avec un dossier par combinaison :

envs/
  prod/reseau/
  prod/app/
  recette/reseau/
  recette/app/
modules/
  reseau/
  app/

Les workspaces Terraform existent pour ça, mais je leur préfère des dossiers séparés : on voit immédiatement où l’on se trouve, et une différence entre recette et production se lit dans le code au lieu de se cacher derrière une variable.

Des modules petits et versionnés

Un module, c’est une brique réutilisable : un réseau, un cluster, une base. Je les garde petits, avec des variables typées et documentées, et je les versionne comme une bibliothèque :

module "app" {
  source  = "git::https://git.example.com/infra/modules.git//app?ref=v2.3.0"
  name    = "facturation"
  replicas = 3
}

La production pointe sur une version précise. On peut faire évoluer le module sans casser ce qui tourne, et monter de version environnement par environnement.

Le plan se relit en revue de code

Personne ne fait terraform apply depuis son poste sur la production. Le pipeline lance terraform plan à chaque merge request et publie le résultat dans la revue. On relit le plan, pas seulement le code : c’est là qu’on voit un « destroy » inattendu.

Quelques réflexes utiles :

  • terraform fmt -check et terraform validate dans le pipeline ;
  • lifecycle { prevent_destroy = true } sur ce qui ne doit jamais disparaître (bases de données, buckets de sauvegarde) ;
  • les blocs moved pour renommer une ressource sans la détruire puis la recréer ;
  • les blocs import pour reprendre une ressource créée à la main.

Surveiller la dérive

Quelqu’un finira par modifier une ressource depuis la console « juste pour tester ». Un terraform plan planifié chaque nuit, qui alerte s’il trouve une différence, permet de le voir avant que ça ne pose problème.

Ce qu’il faut retenir

Terraform ne pardonne pas l’improvisation sur l’état. État distant et verrouillé, découpage clair, modules versionnés, plan relu : avec ces quatre points en place, l’outil devient très confortable. Sans eux, chaque apply en production se fait en retenant son souffle.

À lire aussi