Expressions Terraform : construire des valeurs dynamiques

Vous ouvrez un fichier Terraform et vous voyez var.environment, local.vm_name, une condition ternaire, une fonction comme format() et parfois une boucle for dans un output. Sans comprendre cette couche, le code paraît plus compliqué qu’il ne l’est réellement.

Les expressions Terraform servent à calculer des valeurs, pas à créer directement des ressources. Elles permettent de construire un nom, choisir une valeur selon l’environnement, transformer une collection ou réutiliser proprement un attribut déjà connu. Cette page vous donne le socle pour les lire et les écrire sans vous perdre. Ensuite, si un sujet devient plus riche, vous basculez vers le guide dédié : conditions, fonctions, boucles for, count ou for_each.

Ce que vous allez apprendre

ce qu’est une expression Terraform et où on en trouve ;
comment lire les références var., local., data. et les attributs de ressources ;
comment tester une expression avec terraform console ;
quand rester dans ce guide et quand passer à une page plus spécialisée.

Prérequis

avoir vu le workflow Terraform : workflow Terraform
connaître les blocs de base : providers, resources et data sources
comprendre la syntaxe HCL générique : syntaxe HCL de base

Qu’est-ce qu’une expression Terraform ?

Une expression Terraform est une valeur calculée à partir d’autres valeurs déjà connues. Cela peut être aussi simple qu’une référence à une variable, ou plus riche avec une concaténation, une condition, une fonction ou une transformation de collection.

Pensez à une formule dans un tableur : vous ne retapez pas tout à la main, vous combinez des cellules pour obtenir un résultat. Dans Terraform, c’est la même idée : on combine des variables, des valeurs locales, des attributs de ressources et des fonctions pour produire une valeur utilisable ailleurs.

Les références que vous verrez partout

Avant de lire des expressions plus riches, il faut reconnaître les sources de données qu’elles utilisent.

Référence	Ce que cela signifie concrètement
`var.nom`	lire une variable d’entrée
`local.nom`	réutiliser une valeur calculée dans `locals`
`data.type.nom.attribut`	lire une information récupérée depuis une data source
`ressource.type.nom.attribut`	lire un attribut d’une ressource gérée
`module.nom.output`	lire un output exposé par un module enfant

Exemple très simple :

variable "environment" {
  type    = string
  default = "dev"
}

locals {
  vm_name = "${var.environment}-web"
}

output "vm_name" {
  value = local.vm_name
}

Ici, l’expression la plus visible est "${var.environment}-web" : on part de la variable environment pour construire une nouvelle valeur nommée dans locals.

Les formes d’expressions les plus courantes

Cette page ne remplace pas les guides détaillés, mais elle vous aide à reconnaître les familles d’expressions que vous croiserez dès les premiers projets.

Référencer et interpoler une chaîne

locals {
  full_name = "${var.environment}-${var.vm_name}"
}

Cette expression construit une chaîne à partir de deux variables. C’est souvent le premier usage concret des expressions : fabriquer un nom, un chemin ou un tag.

Utiliser des opérateurs

locals {
  memory_mib = var.environment == "prod" ? 2048 : 512
  disk_size  = var.base_disk_size + 10
}

Vous retrouverez surtout des opérateurs de comparaison, des opérateurs logiques et des calculs simples. Quand la logique conditionnelle devient le sujet principal, passez au guide dédié sur les conditions Terraform.

Appeler une fonction

locals {
  hostname = lower(format("%s-%s", var.environment, var.vm_name))
}

Une fonction transforme une valeur. Ici, format() construit une chaîne, puis lower() la normalise en minuscules.

Transformer une collection

locals {
  vm_labels = [for name in var.vm_names : upper(name)]
}

On ne crée aucune ressource ici. On transforme simplement une liste existante en une autre liste. Quand cette mécanique devient centrale, utilisez le guide sur les boucles for.

Exemple minimal complet

Cet exemple reste volontairement simple : il ne crée aucune ressource. L’objectif est seulement de voir comment des expressions se combinent dans un projet Terraform.

terraform {
  required_version = ">= 1.11.0"
}

variable "environment" {
  type    = string
  default = "dev"
}

variable "vm_name" {
  type    = string
  default = "web"
}

variable "vm_names" {
  type    = list(string)
  default = ["web", "db", "cache"]
}

locals {
  prefix       = var.environment == "prod" ? "prod" : "lab"
  full_name    = "${local.prefix}-${var.vm_name}"
  memory_mib   = var.environment == "prod" ? 2048 : 512
  vm_names_up  = [for name in var.vm_names : upper(name)]
}

output "full_name" {
  value = local.full_name
}

output "memory_mib" {
  value = local.memory_mib
}

output "vm_names_up" {
  value = local.vm_names_up
}

Ce petit fichier montre déjà quatre idées importantes :

une référence avec var.environment ;
une condition avec l’opérateur ternaire ;
une interpolation de chaîne ;
une transformation de collection avec une expression for.

Tester vos expressions avec terraform console

La meilleure manière de comprendre une expression reste de la tester seule avant de l’intégrer dans un vrai projet.

terraform init -backend=false
terraform validate
terraform console

Puis dans la console :

> local.full_name
"lab-web"

> local.memory_mib
512

> local.vm_names_up
[
  "WEB",
  "DB",
  "CACHE",
]

Quand faut-il passer à un guide dédié ?

Le but de cette page est de poser le cadre, pas de tout développer au même niveau de détail.

Si votre besoin principal est…	Lisez ensuite…
écrire une logique `si / sinon` propre	conditions Terraform
transformer des valeurs avec `format`, `merge`, `join`, `lookup`	fonctions Terraform
transformer des listes et des maps avec `for`	boucles for Terraform
centraliser des calculs réutilisés	locals Terraform
répéter des ressources	count Terraform ou for_each Terraform

Erreurs fréquentes

Symptôme	Cause probable	Correction
Expression difficile à relire	Trop de logique inline dans un attribut	Déplacer le calcul dans `locals`
Erreur de type dans une condition	Les deux branches du ternaire ne produisent pas un type cohérent	Vérifier les types retournés
Confusion entre `for` et `for_each`	Vous essayez de créer des ressources avec une expression de transformation	Utiliser `for_each` pour les ressources, `for` pour les valeurs
Débogage pénible	Vous testez directement dans un gros projet	Isoler l’expression dans `terraform console`

À retenir

Une expression Terraform calcule une valeur à partir d’autres valeurs.
Les références var., local., data. et les attributs de ressources sont le vocabulaire de base à reconnaître.
terraform console est le meilleur outil pour comprendre et tester une expression.
Cette page pose le cadre général ; les conditions, fonctions et boucles for ont chacune leur guide dédié.
Quand une expression devient difficile à lire, déplacez-la dans locals.

Prochaines étapes

Locals Terraform Centraliser des expressions calculées pour garder un code lisible

Conditions Terraform Aller plus loin sur l'opérateur ternaire et les validations

Fonctions Terraform Transformer et composer les valeurs avec les fonctions intégrées

Boucles for Terraform Transformer des listes et des maps sans créer de ressources