Implémentation des Modules Terraform

Introduction

Les modules Terraform sont un concept fondamental dans l'Infrastructure as Code (IaC) qui vous permettent de créer des composants réutilisables, configurables et organisés. Au lieu d'écrire le même bloc de code à plusieurs endroits, vous pouvez l'encapsuler dans un module et l'appeler chaque fois que nécessaire. Cette pratique améliore considérablement la maintenabilité du code et la cohérence entre vos projets.

Dans ce laboratoire, vous apprendrez les bases de l'implémentation des modules Terraform. Vous commencerez par créer une structure de répertoire de module standard. Ensuite, vous définirez un module simple qui crée un fichier local. Vous rendrez ce module configurable à l'aide de variables et exposerez ses résultats à l'aide de sorties (outputs). Enfin, vous appellerez ce module depuis votre configuration Terraform racine pour déployer la ressource.

À la fin de ce laboratoire, vous aurez une compréhension pratique de la manière de construire et d'utiliser vos propres modules Terraform.

Créer le répertoire des modules à la racine du projet

Dans cette étape, vous allez créer la structure de répertoire standard pour un module Terraform local. Il est de coutume de placer tous les modules locaux dans un répertoire modules à la racine de votre projet. Chaque sous-répertoire à l'intérieur de modules représente alors un module unique et autonome.

Tout d'abord, créons un répertoire pour nos modules et un sous-répertoire spécifique pour un module que nous nommerons localfile_creator. Toutes les opérations seront effectuées dans le répertoire ~/project.

Exécutez la commande suivante pour créer la structure de répertoire imbriquée :

mkdir -p modules/localfile_creator

L'option -p garantit que mkdir crée le répertoire parent modules s'il n'existe pas déjà.

Maintenant, vous pouvez vérifier que les répertoires ont été créés correctement en utilisant la commande tree. Si tree n'est pas installé, vous pouvez utiliser ls -R.

tree

Vous devriez voir la sortie suivante, confirmant votre nouvelle structure de répertoire :

.
└── modules
    └── localfile_creator

2 directories, 0 files

Cette structure sépare clairement votre code de module réutilisable de la configuration racine qui l'utilisera.

Créer main.tf dans le module pour la ressource local_file

Dans cette étape, vous allez créer le fichier de configuration principal pour votre nouveau module. Chaque module est un projet Terraform autonome, il possède donc son propre ensemble de fichiers .tf. Le fichier main.tf est généralement l'endroit où les ressources principales du module sont définies.

Nous allons définir une ressource local_file, qui fait partie du fournisseur (provider) hashicorp/local. Cette ressource est excellente à des fins d'apprentissage car elle gère simplement des fichiers sur le système de fichiers local sans nécessiter d'informations d'identification de fournisseur de cloud.

Tout d'abord, créez le fichier main.tf à l'intérieur du répertoire de votre module en utilisant l'éditeur nano :

nano modules/localfile_creator/main.tf

Maintenant, ajoutez le code HCL (HashiCorp Configuration Language) suivant au fichier. Ce code définit une ressource de type local_file nommée example.

resource "local_file" "example" {
  content  = "This is a file created by a Terraform module."
  filename = "${path.module}/module_output.txt"
}

Décortiquons ce code :

• resource "local_file" "example" : Ceci déclare une ressource de type local_file et lui donne un nom local example.
• content : Cet argument définit le contenu qui sera écrit dans le fichier.
• filename : Cet argument spécifie le chemin et le nom du fichier à créer. Nous utilisons la variable intégrée path.module, qui fait toujours référence au chemin du système de fichiers du module où l'expression est placée. Cela rend le chemin du fichier relatif au module lui-même.

Enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, suivi de Y, puis Enter.

Définir les variables et les sorties du module

Dans cette étape, vous allez rendre votre module configurable et capable de renvoyer des informations. Le codage en dur (hardcoding) de valeurs telles que les noms de fichiers et le contenu limite la réutilisabilité d'un module. Nous utiliserons des variables d'entrée (input variables) pour transmettre des valeurs personnalisées et des valeurs de sortie (output values) pour exposer des informations sur les ressources que le module crée.

Par convention, les variables sont définies dans un fichier variables.tf et les sorties dans un fichier outputs.tf.

Tout d'abord, créez le fichier variables.tf pour votre module :

nano modules/localfile_creator/variables.tf

Ajoutez le code suivant pour définir deux variables d'entrée : file_content et file_name.

variable "file_content" {
  description = "The content of the file."
  type        = string
  default     = "Default content."
}

variable "file_name" {
  description = "The name of the file to create."
  type        = string
}

Ensuite, créez le fichier outputs.tf pour déclarer quelles informations le module retournera :

nano modules/localfile_creator/outputs.tf

Ajoutez le code suivant pour renvoyer le chemin complet du fichier créé :

output "filename" {
  description = "The full path to the created file."
  value       = local_file.example.filename
}

Enfin, vous devez mettre à jour le main.tf du module pour utiliser ces nouvelles variables au lieu des valeurs codées en dur. Ouvrez à nouveau le fichier :

nano modules/localfile_creator/main.tf

Modifiez le fichier pour qu'il ressemble à ceci. Nous remplaçons les chaînes codées en dur par var.file_content et var.file_name.

resource "local_file" "example" {
  content  = var.file_content
  filename = "${path.module}/${var.file_name}"
}

Enregistrez et quittez l'éditeur. Votre module est maintenant flexible et prêt à être utilisé avec différentes entrées.

Appeler le module dans le fichier main.tf racine

Dans cette étape, vous allez créer un fichier de configuration racine qui appelle le module que vous venez de construire. Le main.tf racine est le point d'entrée de votre exécution Terraform. C'est là que vous composez votre infrastructure en appelant un ou plusieurs modules.

Vous allez maintenant travailler dans la racine de votre répertoire de projet, ~/project. Créez un fichier main.tf ici :

nano main.tf

Ajoutez le code suivant à ce fichier. Cette configuration utilisera le module localfile_creator.

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "2.4.0"
    }
  }
}

module "file_creator_instance" {
  source = "./modules/localfile_creator"

  file_content = "Hello from the root module!"
  file_name    = "my_test_file.txt"
}

output "created_file_path" {
  description = "Path of the file created by the module."
  value       = module.file_creator_instance.filename
}

Analysons cette configuration racine :

• terraform { ... } : Ce bloc définit les exigences de fournisseur (provider requirements). Puisque notre module utilise le fournisseur local, le module racine qui l'appelle doit également le déclarer.
• module "file_creator_instance" { ... } : Ceci est le bloc de module. file_creator_instance est un nom local pour cette instance spécifique du module.
• source = "./modules/localfile_creator" : Ceci indique à Terraform où trouver le code source du module. Dans ce cas, il s'agit d'un chemin local.
• file_content = "..." et file_name = "..." : Ici, vous transmettez des valeurs aux variables d'entrée définies dans le variables.tf du module.
• output "created_file_path" { ... } : Ce bloc de sortie (output) au niveau racine récupère une valeur du module. La syntaxe est module.<NOM_INSTANCE_MODULE>.<NOM_SORTIE>.

Enregistrez le fichier et quittez nano. Votre projet est maintenant entièrement configuré pour utiliser le module.

Exécuter terraform apply pour le déploiement via le module

Dans cette étape finale, vous utiliserez les commandes Terraform standard pour initialiser, planifier et appliquer votre configuration. Cela exécutera le code de votre module et créera le fichier local.

Premièrement, initialisez le répertoire de travail Terraform. Cette commande télécharge les plugins de fournisseur (provider plugins) nécessaires (dans ce cas, hashicorp/local).

terraform init

Vous devriez voir un message de succès indiquant que Terraform a été initialisé.

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/local versions matching "2.4.0"...
- Installing hashicorp/local v2.4.0...
- Installed hashicorp/local v2.4.0 (signed by HashiCorp)

Terraform has been successfully initialized!
...

Ensuite, exécutez terraform plan pour voir les changements que Terraform va effectuer. Il s'agit d'une exécution à blanc (dry run) qui ne modifie rien mais vous montre le plan d'exécution.

terraform plan

Le résultat indiquera qu'une ressource (le local_file à l'intérieur de votre module) sera créée.

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

Changes to Outputs:
  + created_file_path = (known after apply)
...

Maintenant, appliquez la configuration pour créer le fichier. Nous utiliserons l'option -auto-approve pour sauter l'invite de confirmation interactive.

terraform apply -auto-approve

Terraform exécutera le plan et créera le fichier. Le résultat confirmera la création et affichera la valeur de sortie que vous avez définie.

...
module.file_creator_instance.local_file.example: Creating...
module.file_creator_instance.local_file.example: Creation complete after 0s [id=f73598097552a798110a31388c54c1194b539a53]

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

Outputs:

created_file_path = "./modules/localfile_creator/my_test_file.txt"

Enfin, vérifiez que le fichier a été créé avec le contenu correct. Listez les fichiers dans le répertoire du module, puis affichez le contenu du nouveau fichier.

ls -l modules/localfile_creator/

cat modules/localfile_creator/my_test_file.txt

Le résultat de la commande cat devrait être :

Hello from the root module!

Félicitations, vous avez réussi à créer et à utiliser un module Terraform !

Résumé

Dans ce laboratoire, vous avez réussi à apprendre les bases de la création et de l'utilisation des modules Terraform. Vous avez parcouru l'intégralité du processus, depuis la mise en place d'une structure de répertoire appropriée jusqu'au déploiement d'une ressource via un module réutilisable.

Vous avez appris à :

• Créer une structure de répertoire standard pour les modules locaux.
• Définir des ressources dans le fichier main.tf d'un module.
• Utiliser variables.tf pour rendre votre module configurable et réutilisable.
• Utiliser outputs.tf pour exposer des données de votre module à la configuration appelante.
• Appeler un module local depuis un fichier main.tf racine, en passant des variables d'entrée et en accédant aux valeurs de sortie.
• Appliquer la configuration pour voir le module en action.

En maîtrisant les modules, vous pouvez écrire un Code d'Infrastructure (Infrastructure as Code) plus propre, mieux organisé et plus évolutif. Bravo d'avoir terminé ce laboratoire !