Terraform Certification Hub
0 % complété
Se connecter

Infrastructure as Code avec Terraform › Pratique › Leçon 7 sur 8

Lab 1 : Premier apply, idempotence et dérive de configuration

Domaine 1 de l'examen, 8 % des questions. 16 questions couvrant les objectifs 1a, 1b et 1c.

Ce lab observe les mécanismes du modèle déclaratif sans aucun compte cloud. Nous utilisons les providers random et local, qui produisent des valeurs et des fichiers sur le poste de travail. L'absence de latence réseau rend les mécanismes lisibles : ce qui est observé ici se comporte de la même manière sur un provider cloud.

1. Prérequis et variables d'environnement

Aucun compte cloud, aucune carte bancaire, aucun coût.

# Répertoire de travail du lab
export LAB_DIR="$HOME/terraform-lab/01-premier-apply"
mkdir -p "${LAB_DIR}" && cd "${LAB_DIR}"

1.1 Installer Terraform

Sur macOS avec Homebrew :

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

Sur Linux (Debian ou Ubuntu) :

wget -O- https://apt.releases.hashicorp.com/gpg | \
    sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
    https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
    sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform
terraform version

Résultat attendu : la version installée s'affiche, par exemple Terraform v1.10.4. Une version 1.5 ou supérieure est requise pour ce cours, car le bloc import du module 7 n'existe pas avant.

Activer la complétion de commandes, utile pour la suite :

terraform -install-autocomplete

2. Écrire la première configuration

Créer main.tf dans le répertoire du lab.

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    random = {
      source  = "hashicorp/random"
      version = "~> 3.6"
    }
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}

# Génère un identifiant lisible. Aucune API externe n'est appelée : la valeur
# est produite localement puis conservée dans le state.
resource "random_pet" "environnement" {
  length    = 2
  separator = "-"
}

# La référence à random_pet.environnement.id crée une dépendance implicite.
# Terraform en déduit l'ordre : random_pet est résolu avant local_file.
resource "local_file" "inventaire" {
  filename        = "${path.module}/inventaire.txt"
  file_permission = "0644"

  content = <<-EOT
    Environnement : ${random_pet.environnement.id}
    Gere par      : Terraform
    Modifier ce fichier a la main cree une derive de configuration.
  EOT
}

Puis outputs.tf :

output "nom_environnement" {
  description = "Identifiant genere pour cet environnement."
  value       = random_pet.environnement.id
}

output "chemin_inventaire" {
  description = "Chemin du fichier gere par Terraform."
  value       = local_file.inventaire.filename
}

Le découpage en plusieurs fichiers .tf est une convention de lisibilité. Terraform concatène tous les .tf du répertoire avant de construire le graphe : les noms de fichiers et l'ordre des blocs n'ont aucune incidence sur le résultat.

3. Initialiser le répertoire de travail

terraform init

init télécharge les providers déclarés dans required_providers, les installe sous .terraform/, et écrit .terraform.lock.hcl avec les versions exactes et leurs empreintes.

Vérification :

ls -a
# .terraform  .terraform.lock.hcl  main.tf  outputs.tf

Point d'examen : init ne crée aucune ressource. Il prépare le répertoire de travail. Le fichier .terraform.lock.hcl se commite dans le dépôt Git, .terraform/ ne se commite pas.

4. Planifier puis appliquer

terraform plan

Le plan affiche les actions prévues avec leurs symboles : + création, - destruction, ~ modification en place, -/+ destruction puis recréation.

terraform apply

Terraform réaffiche le plan et demande une confirmation explicite, à laquelle il faut répondre yes. Toute autre saisie annule l'opération.

Résultat attendu :

random_pet.environnement: Creation complete after 0s [id=sought-starling]
local_file.inventaire: Creation complete after 0s [id=e0cfcdf84d65d04075e60c8e22c8b661d84d1c71]

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Outputs:

chemin_inventaire = "./inventaire.txt"
nom_environnement = "sought-starling"

L'identifiant généré sera différent chez vous, c'est le principe de random_pet.

Vérification du contenu produit :

cat inventaire.txt

5. Observer l'idempotence

Relancer la même commande, sans avoir modifié quoi que ce soit.

terraform apply

Résultat attendu :

No changes. Your infrastructure matches the configuration.

C'est l'idempotence : l'état réel correspond déjà à l'état désiré, Terraform n'a rien a faire. Cette propriété est ce qui autorise à rejouer un apply dans une chaîne d'intégration continue sans redouter un effet de bord.

À noter : random_pet n'a pas régénéré de nouvelle valeur. La valeur produite au premier apply est conservée dans le state et réutilisée. Un provider random qui régénérerait sa valeur à chaque exécution rendrait toute configuration instable.

6. Provoquer une dérive de configuration

Nous simulons ici le correctif appliqué à la main en production, hors du code.

echo "ligne ajoutee a la main" >> inventaire.txt
cat inventaire.txt

Le fichier réel ne correspond plus à ce que décrit la configuration. Demandons à Terraform de comparer.

terraform plan

Résultat attendu :

random_pet.environnement: Refreshing state... [id=sought-starling]
local_file.inventaire: Refreshing state... [id=e0cfcdf84d65d04075e60c8e22c8b661d84d1c71]

  # local_file.inventaire will be created
  + resource "local_file" "inventaire" {
      + content = <<-EOT
            Environnement : sought-starling
        ...

Plan: 1 to add, 0 to change, 0 to destroy.

Deux observations importantes.

D'abord, la phase Refreshing state : avant de calculer le plan, Terraform interroge la réalité pour chaque ressource du state. C'est là que la dérive est détectée, pas à la lecture du code.

Ensuite, le provider local compare l'empreinte du fichier à celle enregistrée. L'empreinte ayant changé, il considère que la ressource qu'il gérait n'existe plus, d'où l'action create plutôt que update. Le comportement exact dépend du provider : un provider cloud afficherait le plus souvent une modification en place ~.

Corriger la dérive :

terraform apply
cat inventaire.txt

Résultat attendu : la ligne ajoutée à la main a disparu. La configuration est la source de vérité, la modification manuelle a été écrasée.

Risque métier à retenir : ce comportement est celui que l'on veut, mais il coupe dans les deux sens. Si le correctif appliqué à la main était le bon et que le code n'a pas été mis à jour, le prochain apply le supprime en silence. C'est la raison pour laquelle un accès en écriture direct à une infrastructure gérée par Terraform doit rester exceptionnel et trace.

7. Observer le graphe de dépendances

terraform graph

Résultat attendu :

digraph G {
  rankdir = "RL";
  "local_file.inventaire" [label="local_file.inventaire"];
  "random_pet.environnement" [label="random_pet.environnement"];
  "local_file.inventaire" -> "random_pet.environnement";
}

L'arc entre les deux ressources n'a été déclaré nulle part. Terraform l'a déduit de l'interpolation ${random_pet.environnement.id} présente dans le bloc local_file. C'est une dépendance implicite, et c'est la manière recommandée d'exprimer un ordre.

Inspecter le state pour voir ce que Terraform a mémorisé :

terraform state list
terraform state show random_pet.environnement

8. Nettoyage de l'environnement

terraform destroy

Résultat attendu :

local_file.inventaire: Destruction complete after 0s
random_pet.environnement: Destruction complete after 0s

Destroy complete! Resources: 2 destroyed.

L'ordre de destruction est l'inverse de l'ordre de création : Terraform parcourt le même graphe à rebours. Sur une infrastructure réelle, c'est ce qui évite de tenter de supprimer un réseau avant les machines qui l'utilisent.

Supprimer enfin les artefacts locaux :

rm -rf .terraform terraform.tfstate terraform.tfstate.backup

.terraform.lock.hcl, main.tf et outputs.tf sont conservés : ce sont les fichiers versionnés.

9. Ce qu'il faut retenir

Observation Objectif d'examen
init prépare le répertoire et ne crée rien 3b
Le second apply ne fait rien : idempotence 1a, 1b
Refreshing state précède le calcul du plan 1a, 6d
Une modification manuelle est écrasée au prochain apply 1b
L'ordre des blocs et le nom des fichiers .tf sont sans effet 1a
Le graphe déduit l'ordre des interpolations 1a, 4f
destroy parcourt le graphe en sens inverse 3f