$ terraform init
Initializing provider plugins...
- Installing hashicorp/aws v5.82.0...
Terraform has been successfully initialized!
$ terraform plan
# aws_instance.web will be created
Plan: 1 to add, 0 to change, 0 to destroy.
terraform plan -out=tfplan puis terraform apply tfplan. Le apply applique exactement ce qui a été relu — pas de recalcul entre la revue et l'exécution.$ terraform apply
aws_instance.web: Creating...
aws_instance.web: Creation complete after 32s [id=i-0abc123]
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
$ terraform destroy
Destroy complete! Resources: 1 destroyed.
apply, l'état est enregistré dans terraform.tfstateplan compare code ↔ state ↔ réalité → c'est le mécanisme de détection du driftGère (des milliers de ressources)
N'est PAS
aws_instance n'a pas d'équivalent automatique en Azure.brew install terraform # macOS
apt install terraform # Debian/Ubuntu
choco install terraform # Windows
terraform version # Vérification
required_version. En équipe, des versions différentes du binaire peuvent produire des states incompatibles (le format de state n'est rétrocompatible que vers le haut).terraform {
required_version = ">= 1.5.0, < 2.0.0"
}
MAJOR.MINOR.PATCH — ex. 1.12.2
.tf) : un code écrit pour une ancienne 1.x tourne sur une plus récente ; l'inverse échoue seulement s'il utilise une nouveauté (ex. import {} → 1.5+)required_version contraint la version utilisable ; combiné à required_providers, il rend le projet reproductible.| Version | Année | Apport clé |
|---|---|---|
| 0.12 | 2019 | HCL2 — refonte du langage |
| 0.13 | 2020 | for_each / count sur les modules |
| 0.14 | 2020 | .terraform.lock.hcl, valeurs sensitive |
| 1.0 | 2021 | Stabilité & promesse de compatibilité |
| 1.5 | 2023 | Blocs import & check |
| 1.6 | 2023 | terraform test natif · licence BSL |
| 1.10 | 2024 | Ressources / valeurs ephemeral |
| 1.12 | 2025 | Version testée par la certif 004 |
| 1.17 | 2026 | Branche courante (octobre 2026) — deux branches maintenues à la fois |
terraform plan — en lecture seule (dry run).terraform.tfstate — le fichier d'état.Le pont entre Terraform et vos plateformes
Un plugin qui contient :
resources et data sources utilisables ;Il gère le cycle de vie CRUD complet des ressources. Il est versionné et téléchargé au terraform init.
Sans provider, Terraform ne sait rien faire.
init, stockés dans .terraform/, et leurs versions exactes verrouillées dans .terraform.lock.hcl.| Catégorie | Exemples | Maintenu par |
|---|---|---|
| Cloud public | AWS, Azure, GCP | HashiCorp / éditeur |
| Virtualisation | vSphere, Proxmox, Nutanix | Communauté / éditeur |
| Conteneurs | Kubernetes, Docker, Helm | HashiCorp |
| DNS / CDN | Cloudflare, Route53, OVH | Éditeur / communauté |
| SaaS | GitHub, GitLab, Datadog | Éditeur |
Trois niveaux de confiance sur registry.terraform.io : Official (HashiCorp) · Partner (éditeur vérifié) · Community.
terraform {
required_providers {
aws = {
source = "hashicorp/aws" # namespace/nom
version = "~> 5.0" # contrainte
}
}
}
| Syntaxe | Signification |
|---|---|
= 5.0.0 |
Exactement cette version |
>= 5.0 |
Cette version ou supérieure |
~> 5.0 |
>= 5.0.0 et < 6.0.0 |
~> 5.0.1 |
>= 5.0.1 et < 5.1.0 |
~> est très testé. ~> 5.0 autorise les mineures (5.x), ~> 5.0.1 seulement les patchs (5.0.x).$ terraform init
- Finding hashicorp/aws versions matching "~> 5.0"...
- Installing hashicorp/aws v5.82.0...
- Installed hashicorp/aws v5.82.0 (signed by HashiCorp)
.terraform.lock.hcl : il garantit la même version de provider pour toute l'équipe et la CI.
.terraform.lock.hcl# This file is maintained automatically by "terraform init".
# Manual edits may be lost in future updates.
provider "registry.terraform.io/hashicorp/azurerm" {
version = "4.81.0" # version EXACTE installée
constraints = "~> 4.0" # ce que le code demandait
hashes = [
"h1:3kQ…=", # hash du zip, par plateforme
"zh:0a4…", # hashes du contenu
"zh:1f9…",
]
}
Ce qu'il fait
init — la contrainte n'est plus réévaluéeinit (Terraform ≥ 0.14), verrouille les providers — pas les modules ; init -upgrade est la seule façon légitime de le faire évoluer..terraform.lock.hcl — c'est l'inverse de .terraform/ (ignoré) : l'équipe et la CI installent exactement les mêmes providersterraform init -upgradeh1 sont par plateforme → sans ceux de la CI, son init échoueterraform providers lock -platform=linux_amd64 -platform=darwin_arm64 -platform=windows_amd64
plan à blanc)provider "aws" { # via variables d'env AWS_*
region = "eu-west-3"
}
provider "google" {
project = "mon-projet-gcp"
credentials = file("sa-key.json") # service account
}
provider "azurerm" {
features {}
subscription_id = var.subscription_id
}
azurerm ci-dessus, features {} obligatoire). Les blocs aws et google montrent que le même Terraform pilote les trois : on aurait pu bâtir la formation sur AWS ou GCP à l'identique.provider "aws" { region = "eu-west-3" } # par défaut
provider "aws" {
alias = "us"
region = "us-east-1"
}
resource "aws_s3_bucket" "backup" {
provider = aws.us # cible l'alias
bucket = "mon-backup-us"
}
us-east-1 — l'alias est alors la seule solution propre.| Resource | Data source | |
|---|---|---|
| Rôle | Créer / modifier / supprimer | Interroger l'existant |
| Mode | Lecture / écriture | Lecture seule |
| Syntaxe | resource "aws_instance" "web" {} |
data "aws_ami" "ubuntu" {} |
| Cycle de vie | Géré par plan/apply |
Évalué à chaque refresh |
data source ne crée rien — elle lit. Sa documentation et la distinction avec resource sont au programme (domaine « configuration »).| Variable | Ce qu'elle fait |
|---|---|
TF_LOG=DEBUG |
tout : le cœur de Terraform et les providers — très verbeux |
TF_LOG_PROVIDER=DEBUG |
uniquement le provider : ses requêtes à l'API du cloud et les réponses |
TF_LOG_PATH=./terraform.log |
écrit les logs dans un fichier au lieu du terminal |
TF_LOG_PROVIDER=DEBUG TF_LOG_PATH=./terraform.log terraform plan
grep -iE 'status|error' terraform.log # le code HTTP et le message de l'API
AuthorizationFailed (rôle manquant, mauvais RG) ou secret refusé (faux, expiré). ⚠️ Les logs contiennent des valeurs sensibles : ne pas les committer, supprimer terraform.log après usage.~> 5.0 autorise-t-elle la version 6.0 ?.terraform.lock.hcl ?terraform init (seul à télécharger les providers).~> 5.0 signifie >= 5.0.0 et < 6.0.0.alias de provider et cibler provider = aws.us.env | grep ARM : un Service Principal) et créer une ressource avec az — sans Terraformaz répond avec votre Service Principal et votre ressource de test a été créée puis supprimée Site des labs Retengr → Configuration, puis Authentification › Azure
Blocs, références, variables, outputs, interpolation
HCL organise la configuration en blocs composés de couples clé/valeur. Types : string, number, bool, list, map, object.
| Bloc | Rôle |
|---|---|
resource |
Ressource à créer |
variable |
Entrée de la configuration |
output |
Sortie à afficher / exporter |
data |
Interroge l'existant (lecture seule) |
terraform {}, provider {}, module {}, locals {}.resource "aws_instance" "web" { # <type> <nom local>
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t3.micro"
tags = { Name = "mon-serveur-web" }
}
# Référence : <TYPE>.<NOM>.<ATTRIBUT>
aws_instance.web.public_ip
aws_instance.web.id
aws_instance.web.id ailleurs, vous créez une dépendance automatique. Terraform ordonne la création/destruction tout seul. N'utilisez depends_on que pour les dépendances invisibles (IAM, ordre d'API).variable "region" {
description = "Région AWS"
type = string
default = "eu-west-3"
}
provider "aws" { region = var.region } # usage : var.<NOM>
| Type | Exemple de valeur | Usage var.… |
|---|---|---|
string / number / bool |
"eu-west-3" / 3 / true |
var.region · var.nb_vm · var.debug |
list(string) |
zones = ["1","2","3"] |
var.zones[0] → "1" · length(var.zones) → 3 |
map(string) |
tags = { env = "prod" } |
var.tags["env"] ou var.tags.env → "prod" |
object({ name=string, port=number }) |
srv = { name = "web", port = 80 } |
var.srv.name → "web" · var.srv.port → 80 |
description est une bonne pratique attendue.output "instance_ip" {
description = "IP publique du serveur web"
value = aws_instance.web.public_ip
}
resource "aws_instance" "web" {
tags = { Name = "server-${var.environment}" } # interpolation ${...}
}
output affichent après apply et exposent des valeurs entre modulesvar.region) ; ${...} sert à insérer dans une chaînesensitive = true ; sinon ils s'affichent en clair dans la sortie apply et dans la CI.mon-projet/
├── main.tf # Ressources principales
├── variables.tf # Déclaration des variables
├── outputs.tf # Valeurs de sortie
├── terraform.tfvars # Valeurs des variables
└── providers.tf # Providers + backend
*.tf du répertoire, sans ordre garanti (le graphe de dépendances détermine l'ordre réel).data peut-il créer une ressource ?.tf détermine l'ordre d'exécution.resource, variable, output, data.<TYPE>.<NOM>.<ATTRIBUT> — ex. aws_instance.web.id.data interroge l'existant en lecture seule.${...}.Valorisation, précédence, locals, fonctions built-in
Règle : variabilisez ce qui change entre environnements, pas ce qui est constant.
plan imprévisible. Une variable doit représenter une vraie décision d'environnement, pas un réflexe.Du plus faible au plus fort :
default dans la déclarationTF_VAR_keyterraform.tfvars (auto-chargé)*.auto.tfvars (auto-chargé, ordre alphabétique)-var-file="fichier.tfvars" / -var="key=value" (ligne de commande — en cas de conflit, le dernier écrit l'emporte)TF_VAR_* est parmi les plus faibles (juste au-dessus de default), tandis que -var/-var-file sont les plus forts — c'est un piège classique de QCM.terraform apply -var-file="production.tfvars" # par environnement
terraform apply -var="region=us-east-1" # ponctuel
export TF_VAR_region="us-east-1"; terraform apply # CI/CD
# terraform.tfvars
region = "eu-west-3"
instance_type = "t3.micro"
environment = "dev"
tfvars par environnement, non secret versionné, secrets injectés via TF_VAR_* en CI. Les *.auto.tfvars sont pratiques mais « magiques » : en équipe, préférez l'explicite -var-file.variable "availability_zones" {
type = list(string)
default = ["eu-west-3a", "eu-west-3b"]
}
variable "environment" {
type = string
validation {
condition = contains(["dev","staging","prod"], var.environment)
error_message = "L'environnement doit être dev, staging ou prod."
}
}
validation font échouer le plan tôt, avec un message clair, plutôt qu'une erreur d'API obscure 5 minutes plus tard. Avec object({...}), optional(type, defaut) rend des attributs facultatifs.variable "db_password" {
type = string
sensitive = true # jamais affichée dans les logs
}
var.region # variable d'entrée
aws_instance.web.public_ip # attribut de ressource
data.aws_ami.ubuntu.id # attribut de data source
module.network.vpc_id # output d'un module enfant
local.common_tags # valeur locale
sensitive = true masque la valeur en sortie — mais elle reste en clair dans le state. D'où le besoin d'un backend chiffré (module 06).locals {
project_name = "demo-${var.environment}"
common_tags = {
Project = local.project_name
ManagedBy = "terraform"
}
}
resource "aws_instance" "web" { tags = local.common_tags }
$ terraform console
> upper("hello") "HELLO"
> format("server-%02d", 3) "server-03"
locals = valeurs calculées internes (DRY), variable = entrées de l'utilisateur. Ne confondez pas : un local ne se surcharge pas en ligne de commande.| Catégorie | Exemples |
|---|---|
| String | upper, format, split, join |
| Numérique | max, min, ceil, abs |
| Collection | length, merge, flatten, keys |
| Réseau | cidrsubnet, cidrnetmask |
| Fichier | file, templatefile, fileexists |
user_data = templatefile("${path.module}/init.sh", {
hostname = "web-server"
environment = var.environment
})
terraform console est votre bac à sable pour tester une expression avant de l'écrire. cidrsubnet() évite de calculer les masques à la main pour découper un VPC.-var ou terraform.tfvars ?sensitive = true sur une variable ?variable et un local ?-var — chargé en dernier (précédence la plus forte), l'emporte sur terraform.tfvars.variable = entrée surchargeable ; local = valeur calculée interne, non surchargeable.terraform console.applyterraform -version (déjà installé sur la VM), créer le module root ~/www (main.tf / variables.tf / outputs.tf), déclarer azurerm, puis déployer la VM en passant par des variablesterraform apply est vert, terraform state list montre vos ressources et terraform output donne l'IP publique Site des labs Retengr → Premiers pas › Azure
Le cœur de Terraform — protégez-le
terraform.tfstate)plan, il compare : le code (ce que vous voulez) ↔ le state (ce qu'il connaît) ↔ la réalité (ce qui existe)terraform.tfstate{
"version": 4,
"terraform_version": "1.16.7",
"serial": 17,
"lineage": "9f1c2b3a-…-7e21",
"resources": [
{
"mode": "managed",
"type": "azurerm_linux_virtual_machine",
"name": "vm",
"provider": "provider[\"registry.terraform.io/hashicorp/azurerm\"]",
"instances": [ {
"schema_version": 0,
"attributes": { "id": "/subscriptions/…/web1", "size": "Standard_B1s" },
"dependencies": [ "azurerm_network_interface.main" ]
} ]
}
]
}
version — format du state (4 depuis Terraform 0.12) ; ne bouge presque jamaisterraform_version — le binaire qui l'a écrit ; un binaire plus ancien refuse de le relire (migration vers le haut seulement)serial — compteur +1 à chaque écriture : c'est le verrou optimiste du backend, qui refuse un state au serial plus petit que le sienlineage — identifiant de naissance (UUID), jamais modifié : deux states de lineages différents ne se mélangent pas (lineage mismatch)resources[] — mode (managed / data), adresse type.name, puis par instance les attributs réels renvoyés par l'API (secrets en clair compris) et ses dependencies (ordre de destruction)serial ou un lineage faux, et le backend refuse le push (ou pire, l'accepte). Toutes les retouches passent par terraform state …, moved {}, import — qui gèrent serial pour vous.{
"version": 4,
"resources": [{
"type": "aws_instance", "name": "web",
"instances": [{ "attributes": {
"id": "i-0abc123", "public_ip": "54.37.12.45"
}}]
}]
}
| Local (défaut) | Distant (remote backend) | |
|---|---|---|
| Stockage | terraform.tfstate sur disque |
S3, GCS, Azure Blob, HCP Terraform |
| Usage | Développeur seul | Indispensable en équipe |
| Locking | Non | Oui (DynamoDB, GCS…) |
| Sécurité | Fichier en clair | Chiffrement côté serveur |
| Partage | Manuel | Automatique |
apply concurrents qui corrompent le state).terraform {
backend "s3" {
bucket = "mon-bucket-tfstate"
key = "projet/terraform.tfstate"
region = "eu-west-3"
dynamodb_table = "terraform-locks" # verrou
encrypt = true
}
}
terraform init -migrate-state # migrer un state local vers S3
terraform init -backend-config=prod.s3.tfbackend pour cibler des buckets différents par environnement.terraform state list # lister
terraform state show aws_instance.web # détailler
terraform state rm aws_instance.web # retirer du state (sans détruire)
terraform state mv aws_instance.web aws_instance.app # renommer/déplacer
terraform state pull > backup.tfstate # exporter
state rm (oublie la ressource, qui survit dans le cloud) de destroy (supprime la ressource réelle). Sujet fréquent.terraform state pull pour une sauvegarde. En 1.7+, le bloc moved {} remplace souvent state mv (versionné, revu en MR).terraform plan, Terraform détecte l'écart (drift).terraform apply pour remettre l'infrastructure dans l'état décrit par le code.terraform plan (par exemple chaque nuit via la CI) afin de détecter rapidement les dérives (drift) et d'alerter l'équipe avant qu'elles ne s'accumulent.terraform apply -refresh-only
# Met à jour le state pour refléter l'état réel d'une ressource
# déjà présente dans le state, sans modifier l'infrastructure.
À ne pas confondre avec
terraform import:
terraform import(ou le blocimport {}) ajoute une ressource existante au state afin que Terraform commence à la gérer.terraform apply -refresh-onlyne peut pas découvrir une nouvelle ressource. Il synchronise uniquement le state des ressources déjà gérées par Terraform.
random_id, suffixes, AWS sans nom), l'apply réussit — et vous avez deux fois l'infra, l'ancienne orpheline et facturée. Réflexe avant tout apply suspect : terraform state list doit lister ce que vous savez exister.terraform state rm détruit-il la ressource réelle ?apply concurrents de corrompre le state.terraform apply -refresh-only.tfstate indiqués dans l'énoncé) et observer le verrouaz storage blob list) et un plan lancé pendant un autre plan est refusé (verrou) Site des labs Retengr → Gestion de l'état › Azure
ubuntu), créer le NSG · 5 : un enregistrement DNS <prénom>.labs.retengr.com — la zone est chez AWS (Route 53) : vous déclarez un second provider, aws, dans le même projetssh -i thekey ubuntu@<prénom>.labs.retengr.com répond Site des labs Retengr → Accéder à votre VM › Azure, puis Gestion du DNS › Azure
Organiser, réutiliser, partager
Un module est un conteneur d'un ensemble de ressources. Tout projet Terraform est un module (le Root module).
apply, un seul par projet) et child module (appelé, réutilisable, instanciable plusieurs fois).modules/webserver/
├── main.tf # Ressources
├── variables.tf # Entrées
├── outputs.tf # Sorties
└── README.md # Documentation
module "webserver" {
source = "./modules/webserver"
instance_type = "t3.micro"
environment = "production"
server_count = 3
}
module "vpc" {
source = "terraform-aws-modules/vpc/aws"
version = "~> 5.0"
name = "mon-vpc"
cidr = "10.0.0.0/16"
azs = ["eu-west-3a", "eu-west-3b"]
private_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
}
version n'est valable que pour les sources Registry (pas pour les sources locales/Git, où l'on épingle via la ref Git).terraform-aws-modules) plutôt que réinventer un VPC. Mais épinglez la version : une montée majeure peut recréer des ressources.# Dans le module : outputs.tf
output "public_ips" { value = aws_instance.web[*].public_ip }
# Dans le root : consommer l'output
output "server_ips" { value = module.webserver.public_ips }
| Source | Exemple |
|---|---|
| Locale | ./modules/webserver |
| Registry | terraform-aws-modules/vpc/aws |
| GitHub | github.com/org/repo//modules/vpc |
| Git | git::https://example.com/module.git?ref=v1.2.0 |
// cible un sous-dossier, le ?ref= épingle un tag/commit Git. Toujours épingler une ref immuable (tag), jamais une branche mouvante comme main.module "bucket_us" {
source = "./modules/bucket"
providers = { aws = aws.us } # injecter un alias
}
module "team" {
source = "./modules/user"
for_each = toset(["alice", "bob"])
username = each.key
}
count et for_each s'appliquent aussi aux modules, pas seulement aux ressources — puissant pour instancier un même périmètre par région/compte. Passez les providers explicitement quand le module crée des ressources multi-régions.version fonctionne pour quelle source de module ?module.<NOM>.<OUTPUT> — ex. module.webserver.public_ips.?ref=<tag ou commit> — jamais une branche mouvante.zone_id écrit en dur par une data source Route 53, et créer une VM sur l'image personnalisée du lab (data "azurerm_image") · 7 : sortir la VM dans un module local ./modules/vm, l'appeler (module "mon_serveur"), puis découvrir les modules du Registryterraform state list montre module.mon_serveur.… et votre nom DNS répond toujours Site des labs Retengr → Les datasources › Azure, puis Les Modules › Azure
count, for_each, expressions, lifecycle, dépendances
resource "aws_instance" "app" {
count = 3
ami = var.ami_id
instance_type = "t3.micro"
tags = { Name = "app-${count.index}" } # app-0, app-1, app-2
}
# Référence : aws_instance.app[0]
count : les ressources sont indexées (0,1,2…). Supprimer l'élément du milieu décale tous les suivants → Terraform détruit et recrée les ressources décalées. Dangereux sur du stateful.variable "users" {
type = map(string)
default = { alice = "admin", bob = "developer", carol = "viewer" }
}
resource "aws_iam_user" "team" {
for_each = var.users
name = each.key
tags = { Role = each.value }
}
# Référence : aws_iam_user.team["alice"]
count |
for_each |
|
|---|---|---|
| Identifiant | Index numérique | Clé de la map/set |
| Suppression | Décale les index | Stable |
| Usage | Homogène/jetable | Paramétré |
for_each par défaut, count seulement pour un simple compteur ou un on/off conditionnel. Distinguer count.index de each.key/each.value.[for s in var.names : upper(s)] # ["ALICE","BOB"]
[for s in var.names : upper(s) if s != ""] # filtrer
{for s in var.names : s => upper(s)} # produire une map
# splat : équivalents
[for i in aws_instance.app : i.public_ip]
aws_instance.app[*].public_ip
for transforment des collections sans boucle externe. Le splat [*] est le raccourci idiomatique pour récupérer un attribut sur toutes les instances d'un count/for_each.data "aws_ami" "ubuntu" {
most_recent = true
owners = ["099720109477"] # Canonical
filter {
name = "name"
values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-*"]
}
}
resource "aws_instance" "web" { ami = data.aws_ami.ubuntu.id }
most_recent = true + filtre large = l'AMI peut changer entre deux plan, provoquant un remplacement d'instance surprise. Épinglez l'AMI ou filtrez précisément en prod.# 1. Expression conditionnelle : si var.environment = prod → t3.large, sinon → t3.micro
instance_type = var.environment == "prod" ? "t3.large" : "t3.micro"
# 2. Ressource optionnelle : créée uniquement si create_eip est vrai
resource "aws_eip" "web" {
count = var.create_eip ? 1 : 0 # 1 = créée, 0 = aucune
}
# 3. lifecycle : piloter le cycle de vie de la ressource
resource "aws_instance" "web" {
lifecycle {
prevent_destroy = true # interdit la destruction
ignore_changes = [tags] # ignore les changements de tags
create_before_destroy = true # crée le nouveau avant de détruire l'ancien
}
}
lifecycle (create_before_destroy, prevent_destroy, ignore_changes) et le pattern count = condition ? 1 : 0 pour rendre une ressource optionnelle.| Mécanisme | Porte sur | Évalué | Si ça échoue |
|---|---|---|---|
validation (bloc variable) |
une entrée | au plan, avant tout |
erreur : rien ne bouge |
precondition (dans lifecycle) |
une ressource / data source, avant | au plan (ou à l'apply si valeur inconnue) |
erreur : la ressource n'est pas touchée |
postcondition (dans lifecycle) |
le résultat de la ressource (self) |
après création / lecture | erreur : l'apply s'arrête, les dépendants ne sont pas créés |
check (1.5+, bloc autonome) |
l'infra déployée, dans son ensemble | à chaque plan et apply |
avertissement seulement — n'empêche rien |
validation, precondition, postcondition bloquent — ce sont des garde-fous. check observe — c'est un test de santé qui tourne à chaque exécution.check. Et self n'est utilisable que dans une postcondition.resource "azurerm_linux_virtual_machine" "vm" {
# ...
lifecycle {
precondition {
condition = contains(["Standard_B1s", "Standard_B2s"], var.vm_size)
error_message = "Taille hors du catalogue autorisé."
}
}
}
resource "azurerm_public_ip" "main" {
# ...
lifecycle {
postcondition {
condition = self.ip_address != ""
error_message = "Pas d'IP attribuée : sku/allocation ?"
}
}
}
# check : la page web répond-elle ?
check "site_web" {
data "http" "page" { # data source « scopée »
url = "http://${var.prenom}.labs.retengr.com"
}
assert {
condition = data.http.page.status_code == 200
error_message = "La page ne répond pas 200."
}
}
Warning: Check block assertion failed
on checks.tf line 7, in check "site_web":
La page ne répond pas 200.
check automatise le test « mon service répond-il ? » — il tourne à chaque plan, donc il signale une panne sans qu'on le lui demande. Il exige le provider hashicorp/http.resource "aws_instance" "web" {
ami = data.aws_ami.ubuntu.id
instance_type = "t3.micro"
depends_on = [aws_iam_role_policy.web_policy]
}
depends_on que lorsque la dépendance n'est pas détectable via une référence (ex. une policy IAM qui doit exister avant que l'instance puisse l'utiliser, sans attribut partagé). En abuser sérialise inutilement le graphe et ralentit l'apply.depends_on est l'exception explicite.Renommer une ressource ou la déplacer dans un module change son adresse : sans précaution, Terraform la détruit puis la recrée. Le bloc moved (Terraform 1.1+) déclare que c'est la même ressource, à une autre adresse.
# moved.tf — un bloc par ressource déplacée
moved {
from = azurerm_linux_virtual_machine.vm
to = module.mon_serveur.azurerm_linux_virtual_machine.vm
}
# azurerm_linux_virtual_machine.vm has moved to module.mon_serveur.azurerm_linux_virtual_machine.vm
Plan: 0 to add, 0 to change, 0 to destroy.
moved.tf va dans le module qui appelle (ici le root), jamais dans le module déplacéapply reste nécessaire, même à « 0 to add » : c'est lui qui écrit les nouvelles adresses dans le stateterraform state mv, fait la même chose sans laisser de trace dans le code : à réserver au dépannageplan sans moved (5 à détruire), puis avec (0 à détruire).count ou for_each pour des clés stables ?for_each ?prevent_destroy ?count = var.x ? 1 : 0 ?depends_on ?for_each — clé stable, pas de décalage à la suppression.aws_iam_user.team["alice"].for_eachfor_each sur une map), avec le provider AWS ou GCP — même méthode, autre cloudterraform destroy laisse un state vide Site des labs Retengr → Cas pratique
Qualité, sécurité, migration, environnements, CI/CD
terraform fmt -recursive # formate tout le code HCL
terraform validate # valide syntaxe & cohérence (HORS cloud)
# → Success! The configuration is valid.
fmt reformate, validate vérifie sans contacter le cloud (donc utilisable hors authentification, en CI early-stage). Piège classique de QCM.fmt -check, validate, tflint) pour bloquer le code mal formé avant le commit, pas en revue.terraform test : tester son code (1.6+)Des fichiers *.tftest.hcl (dans tests/), lancés par terraform test : chaque bloc run exécute la configuration puis vérifie des assert.
run en… |
Ce qui se passe | Coût / durée | Sert à |
|---|---|---|---|
command = plan |
plan seulement, rien n'est créé | gratuit, secondes | test unitaire : noms, tailles, logique, conditions |
command = apply (défaut) |
crée pour de vrai, puis détruit à la fin | facturé, minutes | test d'intégration : l'infra fonctionne |
+ mock_provider (1.7+) |
le provider est simulé : aucun appel API | gratuit, sans credentials | tester un module hors cloud, en CI |
expect_failures = [var.x] : le test réussit si la validation (ou la condition) échoue — on teste les garde-fousmodules/vmvalidate dit « le code est bien écrit », plan dit « voici ce qui changera », test dit « le code fait ce que j'attends ». En CI : fmt -check → validate → test (mocks) → plan.vm sans Azure# modules/vm/tests/vm.tftest.hcl
mock_provider "azurerm" {} # aucun appel à Azure
variables {
nom = "test"
resource_group_name = "rg-test"
location = "francecentral"
subnet_id = "/subscriptions/0000/…/subnets/s"
ssh_public_key = file("../../thekey.pub")
image_id = "/subscriptions/0000/…/images/image4lab"
}
run "nommage_et_taille" {
command = plan
assert {
condition = azurerm_linux_virtual_machine.vm.name == "vm-test"
error_message = "La VM doit s'appeler vm-<nom>."
}
}
run "taille_hors_catalogue_refusee" {
command = plan
variables { vm_size = "Standard_D4s_v5" }
expect_failures = [var.vm_size]
}
# modules/vm/variables.tf : le garde-fou testé
variable "vm_size" {
type = string
default = "Standard_B1s"
validation {
condition = contains(["Standard_B1s", "Standard_B2s"], var.vm_size)
error_message = "Taille hors du catalogue autorisé."
}
}
$ cd modules/vm && terraform init && terraform test
tests/vm.tftest.hcl... in progress
run "nommage_et_taille"... pass
run "taille_hors_catalogue_refusee"... pass
tests/vm.tftest.hcl... pass
Success! 2 passed, 0 failed.
.tftest.hcl · run / assert · plan vs apply (défaut, détruit à la fin) · expect_failures# .gitignore Terraform
.terraform/ # plugins téléchargés
*.tfstate # state (données sensibles)
*.tfstate.backup
*.tfvars # variables sensibles
!terraform.tfvars # …sauf celui-ci si non secret
crash.log
.terraform.lock.hcl (reproductibilité des versions de providers). C'est l'inverse du .terraform/.sensitive = true0.0.0.0/0 en productionencrypt = true)tfsec/checkov/trivy scannent les configs à risque (bucket public, SG ouvert) ; infracost estime le coût d'un plan ; terraform-docs génère la doc des modules. À brancher en CI.TF_VAR_* (injectées en CI)sensitive = true masque les logs, pas le stateoutput non sensitiveLe provider vault lit des secrets via des data sources :
provider "vault" {
address = "https://vault.example.com:8200" # token via VAULT_TOKEN / AppRole / OIDC
}
data "vault_kv_secret_v2" "db" {
mount = "secret"
name = "prod/database"
}
resource "aws_db_instance" "main" {
username = "admin"
password = data.vault_kv_secret_v2.db.data["password"] # ⚠ transite par le state
}
ephemeral et les arguments write-only permettent de manipuler un secret sans l'écrire dans le state — la direction recommandée pour les nouveaux projets.terraform import aws_instance.web i-0abc123def456 # CLI (puis écrire le HCL)
import { # bloc import — Terraform 1.5+
to = aws_instance.web
id = "i-0abc123def456"
}
# Générer le code :
# terraform plan -generate-config-out=generated.tf
resource "azurerm_resource_group" "rg" {
name = "rg-prod"
location = "France Central"
}
import {
to = azurerm_resource_group.rg
id = "/subscriptions/xxxxxxxx/resourceGroups/rg-prod"
}
import rattache une ressource existante au state. Le bloc import (1.5+) est déclaratif et versionnable, et peut générer le HCL — approche recommandée vs la commande impérative.terraform workspace new staging
terraform workspace select production
instance_type = terraform.workspace == "production" ? "t3.large" : "t3.micro"
infra/
├── modules/ # code partagé
│ ├── network/
│ ├── compute/
│ └── database/
└── environments/
├── dev/
│ ├── main.tf # appelle les modules
│ ├── backend.tf # state dev (clé dédiée)
│ └── terraform.tfvars
├── staging/
│ ├── main.tf
│ ├── backend.tf # state staging
│ └── terraform.tfvars
└── prod/
├── main.tf
├── backend.tf # state prod
└── terraform.tfvars
modules/, appelé partouttfvars et le backend diffèrent# environments/prod/main.tf
module "network" {
source = "../../modules/network"
cidr = var.cidr
}
terraform apply depuis le dossier de l'environnement. Avantages vs workspaces : backends/clés distincts, droits IAM séparés par env, et un destroy sur dev ne peut pas toucher prod.stages: [validate, plan, apply]
validate: { script: [terraform fmt -check, terraform init, terraform validate] }
plan: { script: [terraform plan -out=tfplan] }
apply: { script: [terraform apply tfplan], when: manual } # approbation humaine
Pièges à éviter : committer le state · modifier l'infra à la main · ignorer le plan · hardcoder les valeurs · négliger le nommage.
apply applique le plan figé (tfplan), jamais un recalcul. Gate manuel sur prod, plan automatique en MR pour la revue.terraform validate contacte-t-il le cloud ?.terraform.lock.hcl ?*.tfstate ?import {} (générable en HCL via -generate-config-out).Rester à jour sans casser la prod — pinner, verrouiller, monter par petits sauts
Avant de parler « version », il faut distinguer les produits, qui n'ont pas le même cycle :
| Produit | Description | Versionnage |
|---|---|---|
| Terraform CLI (core) | L'outil en ligne de commande, open source* | SemVer X.Y.Z |
| Terraform Enterprise | Plateforme self-hosted | Trimestriel x.y.z (depuis août 2025) |
| HCP Terraform | SaaS managé (ex-Terraform Cloud) | Continu (rolling) |
| OpenTofu | Fork open source communautaire (Linux Foundation) | SemVer indépendant |
Format MAJOR.MINOR.PATCH (ex. 1.16.7) :
.Z) → corrections de bugs uniquement, iso-fonctionnel.Y) → nouvelles fonctionnalités, compatibilité préservée.X) → changements potentiellement cassants1.16.3 → 1.16.7 est quasi sans risque. Un passage 1.16 → 1.17 mérite un coup d'œil au CHANGELOG.| Branche | Sortie | Support sécurité | Dernier patch |
|---|---|---|---|
| 1.17 | Oct 2026 | 1.17.2 (nov. 2026) | |
| 1.16 | Aoû 2026 | 1.16.7 | |
| 1.15 | Avr 2026 | 1.15.9 | |
| 1.14 | Nov 2025 | 1.14.9 | |
| ≤ 1.13 | — | — |
endoflife.date/terraform. (instantané au 18/11/2026 — à réactualiser)La règle d'or : pinner, mais pas trop.
terraform {
# Module racine : on borne pour éviter les mauvaises surprises
required_version = "~> 1.16.0" # accepte 1.16.x, refuse 1.17
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 4.0" # accepte 4.x, refuse 5.x (majeure de juil. 2026)
}
}
}
~> 1.16.0)>= 1.15.0) pour laisser de la flexibilité aux consommateursReproductibilité = même version partout (dev, CI, prod) :
.terraform.lock.hcl → versionner ce fichier dans Git (verrouille les providers)tfenv / tenv + un fichier .terraform-version → verrouille la CLI par projetlatest dans le pipeline# .terraform-version
1.15.9
| Quoi | Contrainte (dans le code) | Verrou (version exacte) | Qui l'écrit | Dans Git ? | Pour monter |
|---|---|---|---|---|---|
| CLI Terraform | required_version = "~> 1.16.0" — refuse un binaire hors plage |
.terraform-version → tenv / tfenv (outil externe, pas Terraform) |
vous | éditer le fichier, tenv install |
|
| Providers | required_providers { version = "~> 4.0" } |
.terraform.lock.hcl — version + hashes |
terraform init |
changer la contrainte, init -upgrade |
|
| Modules | version = "~> 2.0" (Registry) ou tag/ref git dans source |
aucun — la contrainte est le verrou | vous | changer la contrainte, init -upgrade |
Ce qui n'est jamais dans Git
.terraform/ (providers et modules téléchargés)*.tfstate (secrets, cf. module 06)La règle d'or
Une contrainte dit ce qu'on accepte ; un verrou dit ce qu'on a. Sans verrou, deux init à un mois d'écart n'installent pas la même chose — et personne ne le voit.
version ni tag (le code change sous vos pieds au prochain init -upgrade).| Type de saut | Risque | Process |
|---|---|---|
Patch (1.16.3→1.16.7) |
Faible | Auto via Renovate/Dependabot, merge après CI verte |
Mineure (1.16→1.17) |
Moyen | Lire le CHANGELOG, tester en sandbox, terraform plan à blanc |
Majeure (1.x→2.x) |
Élevé | Lire le guide de migration, environnement non-critique d'abord, rollback planifié |
terraform apply direct en prod après un saut majeur.Adapter le rythme à votre contexte, pas à l'idéal théorique :
required_version + .terraform-versionterraform init -upgrade puis terraform plan (diff à blanc)tflint, scan tfsec/trivy)| Besoin | Où |
|---|---|
| Releases + CHANGELOG | github.com/hashicorp/terraform/releases |
| EoL & versions supportées | endoflife.date/terraform |
| Contraintes de version | developer.hashicorp.com/terraform/language/expressions/version-constraints |
| Guides de migration (upgrade) | developer.hashicorp.com/terraform/language/upgrade-guides |
| Cycle Terraform Enterprise | developer.hashicorp.com/terraform/enterprise/releases |
| Vérifier sa version locale | terraform version |
required_version, required_providers)tfenv, CI figée)azurermLe plugin Terraform qui pilote Azure Resource Manager — versionné à part
azurerm ?hashicorp/azurerm sur le Terraform Registry| Terraform Core (CLI) | Provider azurerm |
|
|---|---|---|
| Rôle | Moteur d'exécution | Connecteur Azure |
| Versionnage | SemVer 1.X.Z |
SemVer 4.X.Z |
| Cadence | Mineures ~tous les 3-6 mois | Mineures quasi hebdomadaires |
| Déclaré dans | required_version |
required_providers |
Format MAJOR.MINOR.PATCH, mais avec une dynamique propre :
| Version | Sortie | Marqueur |
|---|---|---|
| 1.0 | 2018 | Première version stable |
| 2.0 | Févr. 2020 | Refonte, séparation des ressources |
| 3.0 | Mars 2022 | Auth MSAL, ressources figées |
| 4.0 | Août 2024 | Exige Terraform ≥ 1.0, nettoyage majeur |
| 4.81 | 14 juil. 2026 | Dernière mineure de la branche 4.x |
| 5.0 | 28 juil. 2026 | Nouvelle majeure (voir slide suivante) |
| 5.14 | 13 nov. 2026 | Dernière mineure en date |
Sortie le 28 juillet 2026. Ce qu'elle change, et pourquoi les labs restent en 4.x (épinglés en 4.14.0) :
| Changement 5.0 | Impact concret |
|---|---|
resource_provider_registrations vaut none par défaut ; skip_provider_registration supprimé |
Le provider n'enregistre plus rien sur la souscription — exactement ce que nous forçons déjà en 4.x |
enhanced_validation déplacé dans features {}, preflight_enabled (API Preflight au plan) |
Nouvelles options, pas de rupture si on ne les utilisait pas |
Ressources supprimées : azurerm_app_service, azurerm_function_app, la plupart des azurerm_postgresql_*, azurerm_hpc_cache_* |
Un projet qui les utilise encore ne passe plus init → c'est le « saut de majeure se prépare » |
azurerm_subnet : service_endpoints → bloc service_endpoint ; azurerm_key_vault : rbac_authorization_enabled obligatoire |
Diffs de code à faire, visibles au plan |
plan. C'est la règle, pas l'exception. 📚 Source : azurerm 5.0 Upgrade Guide, HashiCorp, juillet 2026.Une ressource ne disparaît jamais brutalement — elle suit un parcours :
Active → Dépréciée → Feature-frozen → Supprimée (majeure suivante)
plan, une remplaçante existeLe provider impose une version minimale de Core :
terraform {
required_version = ">= 1.0" # exigé par azurerm v4
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 4.0" # accepte 4.x, refuse 5.x
}
}
}
terraform init ou plan peut casser même si le binaire « tourne » encore.| Contexte | Contrainte | Effet |
|---|---|---|
| Prod critique | = 4.81.0 |
Version exacte, zéro surprise |
| Standard | ~> 4.0 |
Toutes les 4.x, bloque la 5.x |
| Module réutilisable | >= 4.0 |
Souple pour les consommateurs |
.terraform.lock.hcl dans Git : il fige la version exacte et les checksums (intégrité supply-chain).Le rythme du provider est rapide : adopter une stratégie incrémentale.
4.x → 5.x) → projet à part entière :
terraform plan à blancterraform init -upgradeterraform plan : analyser le diff (drift, recréations)tflint, tfsec)| Besoin | Où |
|---|---|
| Doc + version courante | registry.terraform.io/providers/hashicorp/azurerm/latest |
| Upgrade guides (3.0, 4.0…) | Section Guides du Registry |
| Toutes les releases / binaires | releases.hashicorp.com/terraform-provider-azurerm |
| CHANGELOG détaillé | github.com/hashicorp/terraform-provider-azurerm/releases |
| Historique versions (Microsoft) | learn.microsoft.com/azure/developer/terraform |
azurermNe pas paniquer : votre infra est toujours là — c'est la mémoire de Terraform qu'il faut reconstruire
Le state perdu ≠ infrastructure détruite.
Avant d'agir, répondre à 3 questions :
terraform.tfstate sur disque vs Azure Blob / S3 / HCP)Terraform garde automatiquement une copie de l'avant-dernier state :
ls -la
# terraform.tfstate <- perdu / corrompu
# terraform.tfstate.backup <- la copie de secours !
cp terraform.tfstate.backup terraform.tfstate
terraform plan # vérifier que tout colle
.backup est écrit à chaque apply. C'est la récupération la plus rapide — à tenter en premier en local.Si le state est sur un backend distant avec versionnage, tout est récupérable.
| Backend | Mécanisme |
|---|---|
| Azure Blob Storage | Blob versioning / soft delete → restaurer la version |
| AWS S3 | Bucket versioning → restaurer une version antérieure |
| HCP Terraform | Onglet States → historique, rollback en 1 clic |
Aucun backup ? Il faut reconstruire le state depuis l'infra existante.
# Commande terraform import (historique, une ressource à la fois)
terraform import azurerm_resource_group.rg \
/subscriptions/xxxx/resourceGroups/mon-rg
# Blocs import {} (Terraform 1.5+, déclaratif, idéal en masse)
import {
to = azurerm_resource_group.rg
id = "/subscriptions/xxxx/resourceGroups/mon-rg"
}
-generate-config-out).plan va reconstruire le state »Non. terraform plan est en lecture seule : il ne modifie jamais le state.
Avec un state vide, le plan affiche donc :
Plan: 12 to add, 0 to change, 0 to destroy.
apply ferait des doublons. C'est l'import qui reconstruit le state, jamais le plan.import # crée le lien state ↔ ressource réelle
↓
plan # vérifie l'écart code ↔ réalité (lecture seule)
↓
ajuster HCL # corriger valeurs / defaults / attributs
↓
plan vide # "No changes" = state reconstruit et cohérent
import {} (1.5+), le plan prévisualise l'import, mais c'est l'apply qui l'exécute et écrit le state.Réimporter à la main des dizaines de ressources est pénible. Pour Azure :
aztfexport (Azure Export for Terraform, maintenu par Microsoft)
# Réimporte un resource group entier : génère HCL + state
aztfexport resourcegroup mon-rg
# Mode --append pour s'intégrer à un backend distant existant
aztfexport resource --append <resource_id>
import avec for_each (TF 1.7+) pour l'import scripté.L'import ne suffit pas — il faut converger code ↔ réalité.
terraform planNo changes)apply sur un plan non vide après import peut recréer ou détruire des ressources. Le plan propre est la condition de sécurité absolue.apply à l'aveugle → risque de recréation/destructionapply complet en pensant « recréer » → doublons et conflitsterraform state mv / terraform state rm aux éditions manuelles.| Mesure | Bénéfice |
|---|---|
| Backend distant (Azure Blob, S3, HCP) | Plus de fichier sur un poste |
| Versionnage activé sur le backend | Rollback en 1 clic |
| State locking | Pas de corruption concurrente |
| Backups / snapshots réguliers | Filet de sécurité supplémentaire |
| State jamais dans Git | Pas de fuite de secrets, pas de conflit |
State perdu ?
├─ Backup local (.tfstate.backup) ? → restaurer
├─ Backend distant versionné ? → rollback version
├─ Snapshot / autre copie ? → restaurer
└─ Rien du tout ?
└─ Reconstruire par import
├─ Azure → aztfexport
├─ Multi → Terraformer / blocs import
└─ puis : plan → ajuster → plan vide
HashiCorp Terraform Associate (004)
| Associate (004) | Authoring & Operations Pro | |
|---|---|---|
| Niveau | Fondamentaux | Professionnel |
| Format | QCM | Labs pratiques + QCM |
| Durée | 1 h | 4 h (pause 15 min incluse) |
| Passage | En ligne surveillé | En ligne surveillé |
| Version testée | Terraform 1.12 | Terraform 1.6 |
| Prix | 70,50 $ US | 295 $ US (retake inclus) |
| Validité | 2 ans | 2 ans |
| Prérequis | Bases terminal & cloud | Associate recommandé · HCL/CLI avancé |
Associate — objectifs
IaC, fondamentaux, workflow init/plan/apply, config (resources/data), modules, state & backends, HCP Terraform.
Professional — objectifs
Cycle de vie des ressources, config dynamique, workflows collaboratifs, création/maintenance de modules, providers, workspaces HCP Terraform.
Format
Spécificités 004
import, moved, removed, checkterraform test, ressources ephemeraldeveloper.hashicorp.com/terraform/tutorials/certification-004 — Exam Content List + Study Guide + sample questions.Fourni par le formateur, en PDF
Mode d'emploi — comme le jour J
taint et -replace, entre moved et state mv, c'est là que se joue la marge. Refaites les questions ratées une semaine plus tard.| # | Domaine | Modules |
|---|---|---|
| 1 | Concepts de l'IaC | 01 |
| 2 | Finalité de Terraform | 01 · 02 |
| 3 | Fondamentaux de Terraform | 02 · 03 · 04 |
| 4 | CLI hors workflow principal | 06 · 08 · 09 |
| 5 | Interagir avec les modules | 07 |
| 6 | Workflow principal | 02 · 04 |
| 7 | Implémenter & maintenir le state | 06 |
| 8 | Lire, générer, modifier la config | 04 · 05 · 08 |
| 9 | Capacités de HCP Terraform | Annexe D |
| Commande | Rôle |
|---|---|
init |
Providers, backend, modules |
plan / apply / destroy |
Workflow principal |
fmt / validate |
Qualité (validate hors-ligne) |
state list/show/mv/rm |
Manipulation du state |
import |
Rattacher l'existant |
output / console |
Sorties / évaluer une expression |
taint / -replace |
Forcer une recréation |
workspace |
États multiples |
plan/apply exécutés dans le cloudapply)plan modifie l'infra → il est en lecture seulevalidate contacte le cloud → hors-lignestate rm (oublie) et destroy (supprime)count.index et each.keyFormation Terraform — Retengr · version 1.1.1
===================================================================== Formation Terraform — Édition Retengr Fichier : formation-terraform-retengr-1.1.1.md Basé sur : formation-terraform-sparks-1.1.0.md (contenu enrichi depuis formation-terraform-complete-1.5.3, © Retengr) + support officiel Retengr terraform-1.8.0-prerelease.8 (comparé module par module) --------------------------------------------------------------- HISTORIQUE DES VERSIONS (édition Retengr) --------------------------------------------------------------- v1.0.0 — 2026-11-18 — Édition Retengr à partir de l'édition Sparks 1.1.0 : charte Retengr (bleu #4A5CA6 / #3C4C90, corail #E8755C, logo rtg-logo.png), titres au format « Titre : sous-titre » (comme le support officiel 1.8.0), ajout des deux slides de la 1.8.0 absentes (« Déboguer un provider », « Renommer sans détruire : moved »), versions actualisées au 18/11/2026 (Terraform 1.16 / 1.17, fin de vie de la 1.15 ; azurerm 5.14). v1.1.0 — 2026-11-18 — Environnement Retengr : VM mise à disposition (pas de code-server), slides d'exercices réécrites sur les labs Retengr (site des labs, page Configuration, ~/www, ubuntu, zone labs.retengr.com sur Route 53 → provider aws, image4lab, module mon_serveur, cas pratique AWS/GCP), examen blanc fourni en PDF, exemples alignés (Standard_B1s, azurerm 4.14.0, prénom). v1.1.1 — 2026-11-18 — Slides d'exercices sur fond anthracite (#2E3440) avec liseré corail, pour les distinguer des intercalaires de module. --------------------------------------------------------------- Faire évoluer le support : incrémenter la version (PATCH = correction, MINOR = ajout de contenu, MAJOR = refonte), mettre à jour le footer (frontmatter) + la slide de garde + la slide « Merci », et ajouter une ligne d'historique ci-dessus. =====================================================================
formateur : ⏱ 20 min. Faire remplir la page Configuration AVANT tout : le prénom sert de suffixe à toutes les ressources.
formateur : ⏱ 1 h 15, après le module Variables. Points chauds : bloc features {}, version azurerm épinglée (4.14.0), taille Standard_B1s.
formateur : ⏱ 25 min, clôt la journée 1. Démo d'un verrou bloqué (plan dans deux terminaux).
formateur : ⏱ 1 h en ouverture de J2. L'exo 5 est le bon moment pour montrer deux providers dans un même init (et le lock file qui s'enrichit).
formateur : ⏱ 1 h 35. Exo 7 : montrer le plan SANS moved (destroy/create) avant de réorganiser — cf. slide « Renommer sans détruire : moved ».
formateur : ⏱ 45 min, pour les rapides. Bon moment pour rappeler « Terraform unifie le workflow, pas les ressources ».