0Pricing
Terraform Infrastructure as Code · Leçon

Expressions conditionnelles et splats

Mettez en œuvre une logique conditionnelle dans vos configurations à l’aide d’opérateurs ternaires et comprenez les expressions splat pour transformer des listes d’objets.

Expressions conditionnelles et splats est une leçon Terraform Infrastructure as Code gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Terraform Infrastructure as Code, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

La logique dynamique dans Terraform

Terraform ne se limite pas aux déclarations statiques ! Pour rendre vos configurations d'infrastructure plus intelligentes et plus adaptables, nous utilisons une logique dynamique.

Cette leçon présente deux outils puissants : les expressions conditionnelles et les expressions splat. Ils permettent à votre infrastructure de s'adapter à différentes situations et de transformer efficacement les données.

Expressions conditionnelles : notions de base

Les expressions conditionnelles, souvent appelées opérateurs ternaires, vous permettent de choisir l'une de deux valeurs selon qu'une condition est vraie ou fausse. C'est l'équivalent d'une simple instruction « if-else » appliquée à des valeurs.

  • Syntaxe : condition ? value_if_true : value_if_false
  • Elles sont idéales pour rendre les configurations flexibles et réutilisables, en les adaptant à différents environnements ou paramètres.

Conditionnelle : exemple avec une valeur simple

Voyons comment une expression conditionnelle peut définir dynamiquement la valeur d'une variable locale en fonction d'une variable d'entrée. Essayez de remplacer default = "dev" par default = "prod", puis réexécutez le code.

variable "env" {
  description = "Deployment environment (dev or prod)"
  type        = string
  default     = "dev"
}

locals {
  instance_type = var.env == "prod" ? "t3.medium" : "t3.micro"
}

output "chosen_instance_type" {
  value = local.instance_type
  description = "The instance type selected based on environment."
}

Conditionnelle : exemple avec un attribut de ressource

Vous pouvez également utiliser des expressions conditionnelles pour contrôler les attributs d'une ressource, voire déterminer si une ressource est créée ou non ! Ici, nous créons conditionnellement un compartiment S3 à l'aide de l'argument méta count.

variable "create_bucket" {
  description = "Whether to create an S3 bucket"
  type        = bool
  default     = true
}

resource "aws_s3_bucket" "my_bucket" {
  # If create_bucket is true, count is 1 (create one bucket).
  # If create_bucket is false, count is 0 (create no buckets).
  count  = var.create_bucket ? 1 : 0
  bucket = "coddykit-unique-bucket-12345" # IMPORTANT: Replace with a globally unique name!
  acl    = "private"
}

output "bucket_id" {
  value = var.create_bucket ? aws_s3_bucket.my_bucket[0].id : "No bucket created"
  description = "The ID of the created S3 bucket, or a message if not created."
}

Comprendre les expressions splat

Les expressions splat ([*]) servent à transformer une liste d'objets en une liste d'attributs précis de ces objets. C'est un raccourci puissant pour extraire simultanément des données de plusieurs éléments.

  • Syntaxe : LIST_OF_OBJECTS[*].ATTRIBUTE
  • Elles simplifient l'utilisation des collections, comme plusieurs ressources créées avec count ou des variables de type liste complexes.

Splat : exemple avec les sorties de ressources

Imaginez que vous créez plusieurs instances EC2. Comment obtenir facilement la liste de toutes leurs adresses IP publiques ? Les expressions splat sont parfaites pour cela ! Remarque : vous aurez besoin d'une AMI valide pour votre région AWS.

resource "aws_instance" "web" {
  count         = 2 # Creates two instances
  ami           = "ami-0abcdef1234567890" # Replace with a valid AMI ID for your region
  instance_type = "t2.micro"
  tags = {
    Name = "web-instance-${count.index}"
  }
}

output "web_instance_public_ips" {
  value = aws_instance.web[*].public_ip
  description = "A list of public IP addresses for all web instances."
}

Splat : exemple avec des listes de variables

Les expressions splat ne servent pas uniquement aux ressources : elles fonctionnent également très bien avec les variables complexes. Ici, nous disposons d'une liste d'objets utilisateur et souhaitons en extraire uniquement les adresses e-mail.

variable "users" {
  description = "List of user objects, each with name, email, and role."
  type = list(object({
    name  = string
    email = string
    role  = string
  }))
  default = [
    { name = "Alice", email = "alice@example.com", role = "admin" },
    { name = "Bob", email = "bob@example.com", role = "viewer" },
    { name = "Charlie", email = "charlie@example.com", role = "editor" }
  ]
}

output "user_emails" {
  value = var.users[*].email
  description = "A list containing only the email addresses of the users."
}

Combiner les expressions conditionnelles et splat

Les expressions conditionnelles et splat peuvent être combinées pour créer une logique encore plus avancée et concise. Par exemple, vous pouvez sélectionner conditionnellement une liste de ressources, puis appliquer une expression splat à la liste choisie.

  • Cela permet de créer des configurations très adaptables, capables de répondre à des scénarios complexes.
  • Exemple : (var.env == "prod" ? aws_instance.prod : aws_instance.dev)[*].id peut récupérer les identifiants de différents ensembles d'instances selon l'environnement.

Bonnes pratiques pour la logique dynamique

Bien que puissante, la logique dynamique peut parfois rendre les configurations plus difficiles à comprendre si elle n'est pas utilisée avec précaution. Voici quelques conseils :

  • Privilégiez la lisibilité : décomposez les expressions complexes en parties plus petites et plus faciles à gérer.
  • Utilisez les valeurs locales : stockez les expressions conditionnelles ou splat complexes dans des blocs locals afin d'améliorer la lisibilité et d'éviter les répétitions.
  • Testez soigneusement : la logique dynamique peut entraîner des comportements inattendus. Exécutez toujours terraform plan et examinez attentivement les changements proposés.
  • Documentez : ajoutez des commentaires pour expliquer la logique complexe, en particulier lorsque vous combinez des expressions conditionnelles et splat.

Vérification rapide

Considérez la configuration Terraform suivante :

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

output "filtered_names" {
  value = var.server_names[*]
}

Récapitulatif et prochaines étapes

Excellent travail ! Vous avez appris à rendre vos configurations Terraform beaucoup plus dynamiques et flexibles :

  • Nous avons étudié les expressions conditionnelles (opérateur ternaire) pour rendre les valeurs dynamiques en fonction de conditions précises.
  • Nous maîtrisons désormais les expressions splat ([*]) pour extraire efficacement des listes d'attributs à partir de collections d'objets ou de ressources.

Ces outils sont fondamentaux pour créer une infrastructure sous forme de code évolutive, réutilisable et adaptable. Continuez à vous entraîner pour les intégrer à vos tâches Terraform quotidiennes !

Questions Fréquemment Posées

La leçon « Expressions conditionnelles et splats » est-elle gratuite ?

Oui — le texte complet de « Expressions conditionnelles et splats » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Terraform Infrastructure as Code, passe à CoddyKit PRO. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions conditionnelles et splats » ?

Mettez en œuvre une logique conditionnelle dans vos configurations à l’aide d’opérateurs ternaires et comprenez les expressions splat pour transformer des listes d’objets. Tu pratiques Terraform Infrastructure as Code avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Terraform Infrastructure as Code ?

Aucune expérience préalable n'est requise. Terraform Infrastructure as Code sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Expressions conditionnelles et splats » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Terraform Infrastructure as Code ?

Oui. Chaque leçon Terraform Infrastructure as Code inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Utiliser des boucles avec `for_each` et `count`
  2. Fonctions intégrées de Terraform
  3. Expressions conditionnelles et splats
  4. Blocs dynamiques pour une configuration imbriquée
← Retour à Terraform Infrastructure as Code