Terraform Certification Hub
0 % complété
Se connecter

Fondamentaux de Terraform › Pratique › Leçon 8 sur 9

Lab 2 : Providers, contraintes de version et fichier de verrouillage

Domaine 2 de l'examen, 10 % des questions. 20 questions couvrant les objectifs 2a, 2b, 2c et 2d.

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"
}