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 |