DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesTerraform : variables, modules et gestion du state

Module

Variables, outputs, state management et modules réutilisables avec Terraform.

  • 1h30
  • Intermédiaire
  • 6 exercices
Voir les exercices

Formation 100 % Linux

Tous les modules nécessitent un environnement Linux. Si vous êtes sur Windows, installez d'abord WSL (Windows Subsystem for Linux) avant de continuer.

Terraform : variables, modules et gestion du state

🎯 Objectifs

  • ✅ Paramétrer vos configurations avec des variables et outputs
  • ✅ Utiliser les locals et data sources
  • ✅ Comprendre et gérer le state Terraform
  • ✅ Configurer un backend distant pour le travail en équipe
  • ✅ Créer et utiliser des modules réutilisables

📋 Prérequis

  • Terraform Débutant (workflow init/plan/apply maîtrisé)

📦 Variables

Les variables rendent vos configurations flexibles et réutilisables.

Syntaxe

hcl
variable "container_name" {
  type        = string
  description = "Nom du conteneur Docker"
  default     = "mon-app"
}

Types disponibles

TypeExempleUsage
string"nginx"Noms, chemins
number8080Ports, tailles
booltrueFlags on/off
list(string)["a", "b"]Listes de valeurs
map(string){env = "dev"}Paires clé-valeur
object({...}){name = string}Structures complexes

Fichier variables.tf

hcl
variable "image_name" {
  type    = string
  default = "nginx:alpine"
}

variable "external_port" {
  type        = number
  description = "Port exposé sur l'hôte"
  default     = 8080
}

Utilisation dans main.tf

hcl
resource "docker_container" "web" {
  name  = var.container_name
  image = var.image_name

  ports {
    internal = 80
    external = var.external_port
  }
}

Fournir les valeurs

bash
# Via fichier terraform.tfvars
container_name = "prod-nginx"
external_port  = 80

# Via ligne de commande
terraform apply -var="external_port=9090"

💡 Ordre de priorité : CLI -var > *.auto.tfvars > terraform.tfvars > valeur default.

Validation

hcl
variable "external_port" {
  type    = number
  default = 8080

  validation {
    condition     = var.external_port > 1023 && var.external_port < 65536
    error_message = "Le port doit être entre 1024 et 65535."
  }
}

📤 Outputs

Les outputs exposent des valeurs après terraform apply.

Fichier outputs.tf

hcl
output "container_id" {
  value       = docker_container.web.id
  description = "ID du conteneur créé"
}

output "access_url" {
  value = "http://localhost:${var.external_port}"
}

Commandes

bash
terraform output              # Affiche tous les outputs
terraform output access_url   # Affiche un output spécifique

💡 Les outputs servent aussi à passer des valeurs entre modules.


🏷️ Locals

Les locals définissent des valeurs calculées, utiles pour éviter la répétition.

hcl
locals {
  project = "formation-devops"
  env     = "dev"
  prefix  = "${local.project}-${local.env}"

  common_tags = {
    project     = local.project
    environment = local.env
    managed_by  = "terraform"
  }
}

resource "docker_container" "web" {
  name = "${local.prefix}-nginx"
  labels {
    label = "project"
    value = local.common_tags.project
  }
}

🔍 Data Sources

Les data sources permettent de lire des ressources existantes non gérées par Terraform.

hcl
data "docker_network" "existing" {
  name = "mon-reseau"
}

resource "docker_container" "web" {
  name  = "nginx"
  image = "nginx:alpine"

  networks_advanced {
    name = data.docker_network.existing.id
  }
}

💡 data = lecture seule. resource = création et gestion.


🗄️ State Management

Le fichier terraform.tfstate est la source de vérité de Terraform - il mappe le code aux ressources réelles.

Commandes de diagnostic

bash
terraform state list           # Liste toutes les ressources
terraform state show docker_container.web  # Détails d'une ressource

Manipulation du state

bash
# Renommer une ressource (après refactoring du code)
terraform state mv docker_container.web docker_container.app

# Retirer une ressource du state (sans la détruire)
terraform state rm docker_container.old

⚠️ Ne jamais modifier terraform.tfstate à la main ! Utilisez uniquement les commandes terraform state.


☁️ Remote State

En équipe, le state local pose problème : conflits, pas de verrouillage, perte possible.

Backend S3 (exemple AWS)

hcl
terraform {
  backend "s3" {
    bucket         = "mon-tfstate-bucket"
    key            = "projet/terraform.tfstate"
    region         = "eu-west-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

Terraform Cloud (alternative simple)

hcl
terraform {
  cloud {
    organization = "mon-org"
    workspaces {
      name = "mon-projet"
    }
  }
}
AvantageDescription
🔒 VerrouillageUn seul apply à la fois
👥 PartageToute l'équipe utilise le même state
💾 SauvegardeState stocké de façon sécurisée
📝 HistoriqueVersions précédentes accessibles

🧱 Modules

Les modules sont des composants réutilisables d'infrastructure.

Structure d'un module

modules/
└── docker-app/
    ├── main.tf         # Ressources
    ├── variables.tf    # Paramètres d'entrée
    └── outputs.tf      # Valeurs de sortie

modules/docker-app/main.tf

hcl
resource "docker_image" "app" {
  name = var.image
}

resource "docker_container" "app" {
  name  = var.name
  image = docker_image.app.image_id

  ports {
    internal = var.internal_port
    external = var.external_port
  }
}

modules/docker-app/variables.tf

hcl
variable "name"          { type = string }
variable "image"         { type = string }
variable "internal_port" { type = number, default = 80 }
variable "external_port" { type = number }

Utiliser le module

hcl
module "frontend" {
  source        = "./modules/docker-app"
  name          = "frontend"
  image         = "nginx:alpine"
  external_port = 8080
}

module "backend" {
  source        = "./modules/docker-app"
  name          = "api"
  image         = "node:alpine"
  internal_port = 3000
  external_port = 3000
}

💡 Le Terraform Registry propose des milliers de modules publics prêts à l'emploi.


🎯 Points clés

  1. Les variables rendent les configurations réutilisables - séparez-les dans variables.tf
  2. Les outputs exposent des valeurs utiles et connectent les modules entre eux
  3. Le state est sacré - utilisez un backend distant en équipe
  4. Les modules sont la clé d'une infrastructure maintenable et DRY
  5. Les data sources lisent l'existant sans le gérer

📚 Ressources

  • Terraform Variables
  • Terraform Modules
  • Terraform State
  • Terraform Registry

🚀 Prochaines étapes

Vous gérez variables et modules Terraform. Passez aux patterns de production :

  1. Terraform en production : workspaces, import et CI/CD - Workspaces, CI/CD integration et patterns de production

Exercices Pratiques

6 exercices pour mettre en pratique

01

01 - Variables avancées et validation

20 minutesIntermédiaire
02

02 - Utiliser les locals et les data sources

20 minutesIntermédiaire
03

03 - Comprendre et gérer le state Terraform

20 minutesIntermédiaire
04

04 - Créer et utiliser des modules réutilisables

25 minutesIntermédiaire
05

05 - Configurer un backend pour le state distant

25 minutesIntermédiaire
06

07 - Projet Capstone : Infrastructure modulaire avec variables, modules et state distant

45 minutesAvancé
Retour aux modules

Sur cette page

  • 🎯 Objectifs
  • 📋 Prérequis
  • 📦 Variables
  • Syntaxe
  • Types disponibles
  • Fichier variables.tf
  • Utilisation dans main.tf
  • Fournir les valeurs
  • Validation
  • 📤 Outputs
  • Fichier outputs.tf
  • Commandes
  • 🏷️ Locals
  • 🔍 Data Sources
  • 🗄️ State Management
  • Commandes de diagnostic
  • Manipulation du state
  • ☁️ Remote State
  • Backend S3 (exemple AWS)
  • Terraform Cloud (alternative simple)
  • 🧱 Modules
  • Structure d'un module
  • modules/docker-app/main.tf
  • modules/docker-app/variables.tf
  • Utiliser le module
  • 🎯 Points clés
  • 📚 Ressources
  • 🚀 Prochaines étapes