Expressions Terraform : références, types et conversion

Une expression calcule une valeur : une interpolation, un opérateur, un ternaire, une référence. C'est le tissu de toute configuration Terraform. Le déclarer est simple ; les pièges se cachent dans les détails : la syntaxe de référence d'une ressource, la conversion de types (présente pour l'arithmétique, absente pour l'égalité), et la valeur null qu'on remplace à tort par une chaîne vide.

Ce guide part de la base, où vivent les expressions et comment les tester, puis traite les références, les types et leur conversion, null, la précédence des opérateurs et les valeurs inconnues au plan. Tous les comportements ont été vérifiés sur Terraform v1.15.4 dans terraform console.

Ce que vous allez apprendre

• Où vivent les expressions, et tester avec terraform console
• La référence d'une ressource gérée, sans préfixe
• La conversion automatique de types, et l'exception de ==
• null comme absence, pas comme chaîne vide
• La précédence des opérateurs, et les valeurs inconnues au plan

Prérequis

• Un projet Terraform initialisé (installer Terraform)
• Terraform 1.15.x, la série stable courante

Tester une expression avec terraform console

terraform console évalue une expression sans rien appliquer. Il est interactif, mais s'utilise aussi en script, en lui passant des commandes sur l'entrée standard, ce qui en fait un vrai outil de test et de CI :

echo 'max(3, 7, 2)' | terraform console

7

L'option -plan évalue même les expressions contre l'état planifié. C'est le moyen le plus rapide de vérifier une expression avant de l'écrire dans une ressource.

Référencer une ressource : sans préfixe

Les valeurs nommées ont chacune leur préfixe : var.nom, local.nom, data.<type>.<nom>.<attribut>, module.<nom>.<sortie>, auxquels s'ajoutent each.key / each.value, count.index, path.module / path.root et terraform.workspace. Mais une ressource gérée fait exception : elle se référence SANS préfixe, par <type>.<nom>.<attribut> :

resource "random_string" "jeton" {
  length = 8
}

output "valeur" {
  value = random_string.jeton.result
}

Écrire resource.random_string.jeton.result est une erreur : le mot resource n'apparaît jamais dans une expression. C'est le seul cas de la liste sans préfixe, et la confusion la plus fréquente des débutants.

Types et conversion automatique

Terraform a trois types primitifs (string, number, bool) et des types complexes (list, set, tuple, map, object). Entre primitifs, il convertit automatiquement quand il le peut, notamment pour l'arithmétique :

> "5" + 3
8

La chaîne "5" devient un nombre. Mais l'égalité ne convertit pas, et c'est la règle qui surprend le plus :

> 1 == "1"
false

Le nombre 1 et la chaîne "1" ne sont pas égaux. La documentation est nette : « Automatic type conversion does not occur when using the equality operator. » Elle recommande de n'employer == et != qu'entre types identiques, ou après une conversion explicite (tostring(), tonumber()).

Le ternaire convertit, il ne plante pas

Un ternaire dont les deux branches diffèrent de type ne lève pas d'erreur : Terraform les convertit vers un type commun. true ? 12 : "hello" rend une chaîne. Beaucoup de guides présentent ce cas comme une erreur à corriger ; c'est un piège de type silencieux. Vérifiez le type, pas seulement la valeur, et convertissez explicitement en cas de doute.

null : l'absence, pas la chaîne vide

null représente l'absence d'une valeur. Affecter null à un argument de ressource revient à ne pas l'écrire du tout : Terraform applique alors le défaut du provider. La documentation le dit : « If you set an argument of a resource to null, Terraform behaves as though you had completely omitted it. »

resource "local_file" "exemple" {
  filename        = "exemple.txt"
  content         = "x"
  file_permission = var.perm != "" ? var.perm : null
}

Quand var.perm est vide, l'argument vaut null et la permission retombe sur le défaut du provider. Écrire une chaîne vide "" à la place serait une valeur bien réelle, souvent invalide, pas une omission. C'est le mécanisme standard pour rendre un argument optionnel, et le piège classique de la chaîne vide employée à sa place.

Opérateurs et précédence

Les opérateurs suivent une précédence classique : l'unaire (!, -), puis * / %, puis + -, puis les comparaisons, puis &&, puis ||. Le multiplicatif passe avant l'additif :

> 1 + 2 * 3
7

1 + 2 * 3 se lit 1 + (2 * 3), soit 7, jamais 9. En cas de doute, les parenthèses lèvent l'ambiguïté et documentent l'intention.

Une valeur peut être inconnue au plan

Enfin, une expression qui dépend d'un attribut pas encore créé vaut (known after apply). Cette inconnue se propage : une valeur connue combinée à une valeur inconnue donne une valeur inconnue. Trois conséquences concrètes : un count ne peut pas dépendre d'un attribut de ressource, la lecture d'une data source peut être reportée à l'apply, et certains outputs n'ont leur valeur qu'après l'apply. C'est le sujet le plus discriminant du niveau Professional.

Les quatre familles d'expressions et leurs guides

Cette page pose le cadre. Quatre familles d'expressions ont leur guide dédié :

• les conditions et le ternaire, traités dans les conditions Terraform ;
• les expressions for et le splat [*], dans les boucles for ;
• les blocs dynamic, dans les blocs dynamiques ;
• les fonctions intégrées, dans les fonctions Terraform.

Pour produire du JSON ou du YAML, préférez d'ailleurs jsonencode() et yamlencode() à un heredoc <<-, plus sûrs sur l'échappement.

Dépannage

Ces symptômes viennent presque tous d'une règle de type ou de référence. Le tableau les relie à leur cause.

Symptôme	Cause	Solution
Reference to undeclared resource	Un préfixe resource. écrit dans l'expression	Référencer sans préfixe : type.nom.attribut
Une égalité vraie attendue rend false	== ne convertit pas les types	Comparer entre types identiques, ou convertir (tostring, tonumber)
Un ternaire censé rendre un nombre rend une chaîne	Conversion silencieuse vers un type commun	Convertir explicitement, ou aligner les deux branches
Un argument mis à "" provoque une erreur du provider	La chaîne vide est une valeur, pas une omission	Utiliser null pour omettre l'argument
Invalid count argument (valeur inconnue)	count dépend d'un attribut known after apply	Le fonder sur une variable ou une valeur connue au plan

Glissez pour voir

À retenir

1. terraform console évalue une expression sans appliquer, et s'utilise en script (entrée standard, -plan).
2. Une ressource gérée se référence sans préfixe : type.nom.attribut.
3. L'arithmétique convertit les types ("5" + 3 = 8), == non (1 == "1" = false).
4. Un ternaire convertit ses branches vers un type commun, sans erreur.
5. null omet un argument ; une chaîne vide est une valeur.
6. Précédence : * avant + ; 1 + 2 * 3 = 7.
7. Une valeur inconnue au plan (known after apply) se propage.

FAQ : questions fréquentes

Les questions ci-dessous reprennent les confusions les plus fréquentes sur les expressions : la référence sans préfixe, la conversion de types, et null.

Comment référencer une ressource dans une expression Terraform ?

Par type.nom.attribut, sans aucun préfixe : random_pet.hote.id. Le mot resource n'apparaît jamais dans une expression. C'est la seule valeur nommée sans préfixe, contrairement à var., local., data. et module., et la confusion la plus fréquente des débutants.

Pourquoi 1 == "1" renvoie-t-il false en Terraform ?

Parce que l'opérateur == ne convertit pas les types : la documentation précise que la conversion automatique n'a pas lieu pour l'égalité. Le nombre 1 et la chaîne "1" sont donc différents. Il faut comparer entre types identiques, ou convertir avec tostring() ou tonumber().

Un ternaire Terraform plante-t-il si les branches ont des types différents ?

Non. Terraform convertit les deux branches vers un type commun sans erreur : true ? 12 : "hello" renvoie une chaîne. Ce n'est pas une erreur à corriger mais un piège de type silencieux : vérifiez le type du résultat, et convertissez explicitement si besoin.

Quelle différence entre null et une chaîne vide en Terraform ?

null représente l'absence : affecter null à un argument revient à l'omettre, et Terraform applique le défaut du provider. Une chaîne vide est une valeur bien réelle, souvent invalide. Pour rendre un argument optionnel, on utilise null, jamais "".

Quelle est la précédence des opérateurs en Terraform ?

Du plus fort au plus faible : l'unaire (! et -), puis * / %, puis + -, puis les comparaisons, puis &&, puis ||. La multiplication passe avant l'addition, donc 1 + 2 * 3 vaut 7, pas 9. En cas de doute, les parenthèses lèvent l'ambiguïté.

Que signifie known after apply dans une expression Terraform ?

C'est la valeur d'une expression qui dépend d'un attribut pas encore créé, connu seulement à l'apply. L'inconnue se propage : une valeur connue combinée à une inconnue donne une inconnue. Conséquence : un count ne peut pas dépendre d'un attribut de ressource.

Peut-on utiliser terraform console dans un script ?

Oui. terraform console lit aussi des commandes sur l'entrée standard, ce qui permet de l'utiliser en script ou en CI : echo 'expression' | terraform console. L'option -plan évalue les expressions contre l'état planifié. C'est le moyen le plus rapide de tester une expression.

Pour aller plus loin

• Les conditions Terraform : Détaille le ternaire et le count conditionnel, suite directe des expressions.
• Conditions personnalisées : Place validation, precondition et check pour rejeter une valeur dès le plan.
• Les boucles for : Transforme listes et maps, l'usage le plus courant des expressions.

×

📖 Voir la documentation →