Modules Terraform

Introduction

Imaginez que vous êtes architecte et que vous concevez un quartier. Vous ne dessineriez pas chaque maison de zéro, brique par brique. Vous créeriez plutôt le plan d’une « maison standard », puis vous le copieriez 50 fois.

Dans Terraform, ces plans réutilisables s’appellent des modules.

Les modules sont le principal moyen utilisé par Terraform pour passer de petits exemples à de véritables bases de code d’infrastructure. Ils permettent aux équipes de définir des modèles une seule fois, puis de les réutiliser autant de fois que nécessaire.

Au lieu de répéter la même configuration encore et encore, vous l’écrivez une fois dans un module, puis vous la réutilisez. Les modules sont importants, car les bases de code d’infrastructure réelles grandissent rapidement et ont besoin d’une structure, tout comme le code d’une application.

Dans cet atelier, vous allez créer un module simple qui génère des fichiers de configuration de serveurs, puis vous utiliserez ce module pour créer deux serveurs différents.

Créer le répertoire du module

Nous avons d’abord besoin d’un emplacement où stocker nos plans. Les modules Terraform sont simplement des répertoires ordinaires contenant des fichiers Terraform.

C’est un point important : du point de vue du format des fichiers, un module n’est pas une nouvelle fonctionnalité spéciale du langage. Il s’agit simplement d’une configuration Terraform regroupée derrière une interface réutilisable.

Par convention, nous créons généralement un répertoire nommé modules afin de garder une structure claire. À l’intérieur, nous créerons un répertoire pour notre module spécifique, nommé « webserver ».

Configurez cette structure :

cd ~/project
mkdir -p modules/webserver

Vérifiez votre travail :

ls -R

Vous devez voir un répertoire modules contenant un répertoire webserver. Ce répertoire webserver servira de mini-projet autonome.

Définir le module

Nous devons maintenant écrire le plan lui-même.

Un module fonctionne comme un projet racine : il contient un fichier main.tf pour définir les ressources et un fichier variables.tf pour accepter les entrées.

Dans cet atelier, nous utiliserons une ressource simple appelée local_file. Elle crée simplement un fichier texte sur le disque. Elle est idéale pour apprendre les modules, car son exécution est rapide et ne nécessite pas de configuration cloud complexe.

Commencez par créer le fichier main.tf du module avec nano :

nano modules/webserver/main.tf

Ajoutez ce contenu. Il indique à Terraform de créer un fichier contenant un texte précis.

resource "local_file" "server_config" {
  content  = "Server Name: ${var.server_name}\nEnvironment: ${var.env}"
  filename = "${path.root}/${var.server_name}-config.txt"
}

Enregistrez le fichier et quittez nano (Ctrl+O, Entrée, Ctrl+X).

Attendez, que signifie var.server_name ? Nous ne l’avons pas encore défini ! Un module doit déclarer les entrées qu’il accepte, tout comme une fonction en programmation.

Cette comparaison avec une fonction est une bonne façon de comprendre le fonctionnement d’un module. Un module expose des entrées et des sorties, tout en masquant à l’appelant les détails de ses ressources internes.

Créez le fichier variables.tf du module :

nano modules/webserver/variables.tf

Ajoutez ces définitions d’entrées :

variable "server_name" {
  description = "The name of the server"
  type        = string
}

variable "env" {
  description = "The environment (e.g., dev, prod)"
  type        = string
  default     = "dev"
}

Enregistrez le fichier et quittez nano.

Notre plan, c’est-à-dire le module, est maintenant terminé. Il sait comment créer un fichier et il sait quelles informations sont nécessaires, à savoir le nom et l’environnement.

Appeler le module

Nous allons maintenant endosser le rôle du responsable de site. Nous voulons construire un serveur, sans avoir à nous préoccuper des détails. Nous allons simplement « engager » le module pour qu’il s’en charge.

Pour cela, nous créons un bloc module dans le fichier main.tf racine, celui qui se trouve dans ~/project.

Créez le fichier main.tf racine :

cd ~/project
nano main.tf

Ajoutez ce contenu pour « appeler » le module :

module "my_first_server" {
  source      = "./modules/webserver"
  server_name = "web-01"
  env         = "production"
}

N’oubliez pas d’enregistrer le fichier et de quitter nano.

Voici ce que signifie chaque élément :

module "my_first_server" : il s’agit du nom de cette instance précise.
source : ce paramètre est essentiel. Il indique à Terraform où trouver le répertoire contenant le plan (./modules/webserver).
server_name et env : ce sont les entrées que nous transmettons au module.

Ainsi, un appel de module permet à la configuration racine d’exprimer une intention à un niveau plus élevé. Au lieu de retaper chaque ressource de bas niveau, vous indiquez : « instanciez ce modèle réutilisable avec ces entrées ».

IMPORTANT : chaque fois que vous ajoutez un nouveau module, vous devez demander à Terraform de le préparer. Exécutez init pour installer le module :

terraform init

Appliquez maintenant la configuration :

terraform apply -auto-approve

Vérifiez le résultat. Vous devez voir un nouveau fichier créé par le module :

cat web-01-config.txt

C’est réussi ! Le module a utilisé nos entrées (web-01 et production) et s’est chargé du travail.

Réutiliser le module

C’est ici que la magie opère. Nous voulons créer un deuxième serveur. Au lieu de copier tout le code de la ressource, nous réutilisons simplement le plan une fois de plus.

Ouvrez de nouveau le fichier main.tf racine avec nano :

nano main.tf

Utilisez les touches fléchées pour aller en bas du fichier et ajoutez ce bloc à la suite :

module "my_second_server" {
  source      = "./modules/webserver"
  server_name = "web-02"
  ## We are not setting 'env' here, so it will use the default value "dev"
}

Enregistrez le fichier et quittez nano.

Remarquez comme cette configuration est claire. Nous indiquons simplement : « Je veux un autre serveur nommé web-02 ». Il n’est pas nécessaire de connaître le fonctionnement interne de local_file. Il suffit d’utiliser l’interface du module.

Appliquez les modifications :

terraform init
terraform apply -auto-approve

Vérifiez que vous disposez maintenant de deux fichiers de serveur distincts :

ls -l *-config.txt

Vérifiez ensuite que le deuxième fichier utilise l’environnement par défaut, "dev" :

cat web-02-config.txt

Vous venez de maîtriser le principe de base d’une infrastructure réutilisable !

Résumé

Félicitations ! Vous avez fait un grand pas vers l’écriture d’un code Terraform professionnel.

Dans cet atelier, vous avez appris :

Modules : regrouper du code dans des répertoires réutilisables, vos « plans ».
Entrées : utiliser des variables pour rendre les modules flexibles.
Appeler des modules : utiliser le bloc module pour créer des instances de votre plan.
Réutilisation : créer facilement plusieurs copies d’une infrastructure avec un minimum de code.

Au lieu d’un tas de briques désordonné, vous disposez maintenant d’un ensemble de composants réutilisables. Vous pouvez ainsi créer une infrastructure plus rapidement, plus sûrement et plus proprement.