Ce lab observe ce que terraform init télécharge, comment les contraintes de version sélectionnent une version, et ce que le fichier de verrouillage empêche. Il se termine sur la déclaration d'un provider aliasé.
1. Prérequis et variables d'environnement
Aucun compte cloud pour les sections 2 à 6. La section 7 déclare le provider Docker : init et validate fonctionnent sans rien de plus, mais l'apply demande un daemon Docker en cours d'exécution.
export LAB_DIR="$HOME/terraform-lab/02-providers"
mkdir -p "${LAB_DIR}" && cd "${LAB_DIR}"
# Optionnel : cache partagé des binaires de providers, pour ne pas retélécharger
# les mêmes fichiers dans chaque répertoire de travail.
export TF_PLUGIN_CACHE_DIR="$HOME/.terraform.d/plugin-cache"
mkdir -p "${TF_PLUGIN_CACHE_DIR}"
2. Déclarer deux providers avec des contraintes différentes
Créer main.tf. Les deux contraintes utilisent l'opérateur pessimiste ~>, mais à des niveaux différents : c'est ce contraste qui sera observé.
terraform {
# Contrainte sur le Terraform Core, à ne pas confondre avec les contraintes
# de providers ci-dessous.
required_version = ">= 1.5.0"
required_providers {
# Opérateur pessimiste sur la version mineure : accepte 3.6, 3.7, 3.x,
# refuse 4.0.
random = {
source = "hashicorp/random"
version = "~> 3.6"
}
# Opérateur pessimiste sur le correctif : accepte 2.5.0 à 2.5.x,
# refuse 2.6.0.
local = {
source = "hashicorp/local"
version = "~> 2.5.0"
}
}
}
resource "random_pet" "environnement" {
length = 2
separator = "-"
}
resource "random_integer" "identifiant" {
min = 1000
max = 9999
}
resource "local_file" "rapport_providers" {
filename = "${path.module}/rapport.txt"
file_permission = "0644"
content = <<-EOT
Environnement : ${random_pet.environnement.id}
Identifiant : ${random_integer.identifiant.result}
EOT
}
3. Initialiser et lire ce qui a été sélectionné
terraform init
Résultat attendu :
- Installing hashicorp/local v2.5.3...
- Installed hashicorp/local v2.5.3 (signed by HashiCorp)
- Installing hashicorp/random v3.9.0...
- Installed hashicorp/random v3.9.0 (signed by HashiCorp)
Terraform has been successfully initialized!
Les deux contraintes ont produit des résultats de nature différente, et c'est le point de cette section :
| Déclaration |
Contrainte |
Version installée |
Ce qui a été autorisé |
random |
~> 3.6 |
3.9.0 |
L'incrément de la version mineure, de 3.6 vers 3.9 |
local |
~> 2.5.0 |
2.5.3 |
Uniquement l'incrément du correctif, de 2.5.0 vers 2.5.3 |
La mention (signed by HashiCorp) indique un provider officiel. Un provider communautaire affiche (self-signed, key ID ...).
Vérification du contenu du répertoire :
ls -a
# .terraform .terraform.lock.hcl main.tf outputs.tf
4. Lire le fichier de verrouillage
grep -E "^provider|version|constraints" .terraform.lock.hcl
Résultat attendu :
provider "registry.terraform.io/hashicorp/local" {
version = "2.5.3"
constraints = "~> 2.5.0"
provider "registry.terraform.io/hashicorp/random" {
version = "3.9.0"
constraints = "~> 3.6"
Le fichier enregistre trois informations par provider : l'adresse complète, la version effectivement sélectionnée, et la contrainte qui l'a produite. Le bloc hashes qui suit contient les empreintes des binaires.
À retenir : ce fichier se commite. C'est ce qui garantit que la CI et les postes des collègues installeront random 3.9.0 et non une version plus récente sortie entre-temps.
5. Observer ce que le verrouillage empêche
Nous durcissons la contrainte de random pour la rendre incompatible avec la version verrouillée.
# Remplacer ~> 3.6 par ~> 3.6.0 dans main.tf
sed -i '' 's|version = "~> 3.6"|version = "~> 3.6.0"|' main.tf # macOS
# sed -i 's|version = "~> 3.6"|version = "~> 3.6.0"|' main.tf # Linux
terraform init
Résultat attendu :
Error: Failed to query available provider packages
Could not retrieve the list of available versions for provider
hashicorp/random: locked provider registry.terraform.io/hashicorp/random
3.9.0 does not match configured version constraint ~> 3.6.0; must use
terraform init -upgrade to allow selection of new versions
Terraform refuse de changer de version de sa propre initiative, même quand la configuration le lui demande. Il exige une action explicite.
terraform init -upgrade
Résultat attendu :
- Installing hashicorp/random v3.6.3...
- Installed hashicorp/random v3.6.3 (signed by HashiCorp)
grep -A1 'hashicorp/random"' .terraform.lock.hcl
Le fichier de verrouillage porte désormais version = "3.6.3".
Piège d'examen : -upgrade porte sur les providers et les modules. Il ne met pas à jour le binaire Terraform lui-même, qui se met à jour par le gestionnaire de paquets.
Restaurer la contrainte initiale avant de continuer :
sed -i '' 's|version = "~> 3.6.0"|version = "~> 3.6"|' main.tf # macOS
terraform init -upgrade
6. Inspecter l'arbre des providers et le state
terraform apply -auto-approve
terraform providers
Résultat attendu :
Providers required by configuration:
.
├── provider[registry.terraform.io/hashicorp/local] ~> 2.5.0
└── provider[registry.terraform.io/hashicorp/random] ~> 3.6
Providers required by state:
provider[registry.terraform.io/hashicorp/local]
provider[registry.terraform.io/hashicorp/random]
La commande distingue deux listes. Les providers requis par la configuration viennent des blocs required_providers, y compris ceux des modules appelés. Ceux requis par le state correspondent aux ressources déjà créées. Un provider présent dans la seconde liste mais absent de la première signale des ressources orphelines, qu'il faudra détruire ou importer avant de pouvoir retirer le provider.
Observons ce que le state à enregistré :
terraform state show random_integer.identifiant
Résultat attendu :
# random_integer.identifiant:
resource "random_integer" "identifiant" {
id = "9354"
max = 9999
min = 1000
result = 9354
}
min et max viennent de la configuration. id et result ont été produits par le provider à la création et enregistrés dans le state : c'est ce qui permet à Terraform de ne pas régénérer une nouvelle valeur au prochain apply.
Regarder l'enveloppe du state :
python3 -c "
import json; d=json.load(open('terraform.tfstate'))
print('version format :', d['version'])
print('terraform :', d['terraform_version'])
print('serial :', d['serial'])
print('ressources :', [r['type']+'.'+r['name'] for r in d['resources']])"
Résultat attendu :
version format : 4
terraform : 1.10.4
serial : 3
ressources : ['local_file.rapport_providers', 'random_integer.identifiant', 'random_pet.environnement']
Le champ serial s'incrémente à chaque écriture. C'est ce compteur que les backends distants utilisent pour détecter qu'un state a été modifié entre-temps par quelqu'un d'autre.
7. Déclarer un provider aliasé
Cette section demande un daemon Docker en cours d'exécution pour l'apply. Sans daemon, init, validate et terraform providers fonctionnent, ce qui suffit à observer le mécanisme d'alias.
mkdir -p "$HOME/terraform-lab/02-providers-alias" && cd "$_"
Créer main.tf :
terraform {
required_version = ">= 1.5.0"
required_providers {
# Provider communautaire : l'espace de noms kreuzwerker est obligatoire.
# Écrire source = "docker" ferait chercher hashicorp/docker, qui n'existe pas.
docker = {
source = "kreuzwerker/docker"
version = "~> 3.0"
}
}
}
# Configuration par défaut. Une ressource qui ne précise aucun provider
# l'utilise.
provider "docker" {
host = var.hote_docker_defaut
}
# Configuration additionnelle, distinguée par son alias.
provider "docker" {
alias = "secondaire"
host = var.hote_docker_secondaire
}
resource "docker_image" "nginx" {
name = "nginx:1.27-alpine"
keep_locally = false
}
resource "docker_container" "web_defaut" {
name = "web-defaut"
image = docker_image.nginx.image_id
ports {
internal = 80
external = 8080
}
}
resource "docker_container" "web_secondaire" {
# Référence au provider aliasé, sans guillemets : c'est une référence,
# pas une chaîne de caractères.
provider = docker.secondaire
name = "web-secondaire"
image = docker_image.nginx.image_id
ports {
internal = 80
external = 8081
}
}
Et variables.tf :
variable "hote_docker_defaut" {
description = "Socket ou endpoint du daemon Docker principal."
type = string
default = "unix:///var/run/docker.sock"
}
variable "hote_docker_secondaire" {
description = "Socket ou endpoint du second daemon Docker."
type = string
default = "unix:///var/run/docker.sock"
}
terraform init
Résultat attendu :
- Installing kreuzwerker/docker v3.9.0...
- Installed kreuzwerker/docker v3.9.0 (self-signed, key ID 0DCE698927DAF8EC)
Noter la différence avec la section 3 : self-signed au lieu de signed by HashiCorp. C'est un provider communautaire, publié par un tiers.
terraform validate
terraform providers
Résultat attendu :
Success! The configuration is valid.
Providers required by configuration:
.
└── provider[registry.terraform.io/kreuzwerker/docker] ~> 3.0
Une seule entrée apparaît, bien que deux blocs provider soient déclarés : l'alias crée une seconde configuration du même provider, pas un second provider.
Si Docker fonctionne sur votre poste :
terraform apply
docker ps --format 'table {{.Names}}\t{{.Ports}}'
Résultat attendu : deux conteneurs, web-defaut sur le port 8080 et web-secondaire sur le port 8081. La ressource web_secondaire a été créée via la configuration aliasée, celle par défaut a servi aux deux autres ressources.
Transposition : ce mécanisme est celui qui sert à déployer dans deux régions GCP, deux comptes AWS ou deux souscriptions Azure depuis une seule configuration. La syntaxe est identique, seuls les arguments du bloc provider changent.
8. Nettoyage de l'environnement
# Répertoire de la section 7, si un apply a été lancé
terraform destroy -auto-approve
rm -rf .terraform terraform.tfstate terraform.tfstate.backup
# Répertoire des sections 2 à 6
cd "$HOME/terraform-lab/02-providers"
terraform destroy -auto-approve
rm -rf .terraform terraform.tfstate terraform.tfstate.backup rapport.txt
.terraform.lock.hcl et les fichiers .tf sont conservés : ce sont les fichiers versionnés.
9. Ce qu'il faut retenir
| Observation |
Objectif d'examen |
~> 3.6 autorise 3.9, ~> 3.6.0 s'arrête à 3.6.x |
2a |
| Le lock file enregistre la version sélectionnée, pas la contrainte seule |
2a |
init refuse de changer une version verrouillée sans -upgrade |
2a |
-upgrade porte sur les providers et modules, pas sur le Core |
2a |
Un provider communautaire s'installe self-signed et exige son espace de noms |
2b |
terraform providers distingue les besoins de la configuration et ceux du state |
2b |
alias crée une seconde configuration, pas un second provider |
2c |
La référence provider = docker.secondaire s'écrit sans guillemets |
2c |
| Le state enregistre les attributs calculés, ce qui évite de les régénérer |
2d |
Le champ serial s'incrémente à chaque écriture du state |
2d |
Code de référence
Les fichiers complets du lab, à recopier dans votre répertoire de travail.
02-providers/main.tf
terraform {
# Contrainte sur le Terraform Core, à ne pas confondre avec les contraintes
# de providers ci-dessous.
required_version = ">= 1.5.0"
required_providers {
# Opérateur pessimiste sur la version mineure : accepte 3.6, 3.7, 3.x,
# refuse 4.0.
random = {
source = "hashicorp/random"
version = "~> 3.6"
}
# Opérateur pessimiste sur le correctif : accepte 2.5.0 à 2.5.x,
# refuse 2.6.0.
local = {
source = "hashicorp/local"
version = "~> 2.5.0"
}
}
}
resource "random_pet" "environnement" {
length = 2
separator = "-"
}
resource "random_integer" "identifiant" {
min = 1000
max = 9999
}
# Sert de support d'observation : le state enregistre les attributs de cette
# ressource, y compris ceux calculés par le provider après création.
resource "local_file" "rapport_providers" {
filename = "${path.module}/rapport.txt"
file_permission = "0644"
content = <<-EOT
Environnement : ${random_pet.environnement.id}
Identifiant : ${random_integer.identifiant.result}
EOT
}
02-providers/outputs.tf
output "environnement" {
description = "Identifiant genere par le provider random."
value = random_pet.environnement.id
}
output "identifiant_numerique" {
description = "Entier genere par le provider random."
value = random_integer.identifiant.result
}
02-providers-alias/main.tf
terraform {
required_version = ">= 1.5.0"
required_providers {
# Provider communautaire : l'espace de noms kreuzwerker est obligatoire.
# Écrire source = "docker" ferait chercher hashicorp/docker, qui n'existe pas.
docker = {
source = "kreuzwerker/docker"
version = "~> 3.0"
}
}
}
# Configuration par défaut. Une ressource qui ne précise aucun provider
# l'utilise.
provider "docker" {
host = var.hote_docker_defaut
}
# Configuration additionnelle, distinguée par son alias. Le même mécanisme
# sert au multi-région GCP, au multi-compte AWS et au multi-souscription Azure.
provider "docker" {
alias = "secondaire"
host = var.hote_docker_secondaire
}
resource "docker_image" "nginx" {
name = "nginx:1.27-alpine"
keep_locally = false
}
resource "docker_container" "web_defaut" {
name = "web-defaut"
image = docker_image.nginx.image_id
ports {
internal = 80
external = 8080
}
}
resource "docker_container" "web_secondaire" {
# Référence au provider aliasé, sans guillemets : c'est une référence,
# pas une chaîne de caractères.
provider = docker.secondaire
name = "web-secondaire"
image = docker_image.nginx.image_id
ports {
internal = 80
external = 8081
}
}
02-providers-alias/variables.tf
variable "hote_docker_defaut" {
description = "Socket ou endpoint du daemon Docker principal."
type = string
default = "unix:///var/run/docker.sock"
}
variable "hote_docker_secondaire" {
description = <<-EOT
Socket ou endpoint du second daemon Docker. Sur un poste ne disposant que
d'un daemon, laisser la valeur par defaut : les deux configurations
pointent alors au meme endroit, ce qui suffit a observer le mecanisme
d'alias sans avoir a provisionner un second hote.
EOT
type = string
default = "unix:///var/run/docker.sock"
}