Terraform Infrastructure as Code · Leçon

Introduction aux modules Terraform

Comprenez les avantages des modules pour encapsuler et réutiliser des modèles d’infrastructure courants, tout en améliorant l’organisation et la maintenabilité du code.

Introduction aux modules Terraform est une leçon Terraform Infrastructure as Code gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Terraform Infrastructure as Code, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

Que sont les modules Terraform ?

Un module Terraform est un ensemble autonome de configurations Terraform. Voyez-le comme une fonction ou une classe dans un langage de programmation. Il vous permet de regrouper des ressources liées et de les gérer comme une seule unité.

Les modules vous aident à organiser le code de votre infrastructure et à le rendre plus facile à gérer, surtout pour les projets de grande envergure.

Pourquoi utiliser des modules Terraform ?

Les modules offrent plusieurs avantages essentiels pour votre infrastructure sous forme de code :

Réutilisabilité : définissez une partie de l’infrastructure une seule fois et utilisez-la plusieurs fois dans différents projets ou environnements.
Organisation : décomposez les configurations complexes en composants plus petits, gérables et logiques.
Cohérence : assurez-vous que les ressources sont approvisionnées de manière standardisée à chaque fois, ce qui réduit la dérive de configuration et les erreurs.
Collaboration : les équipes peuvent développer et partager des modules, accélérer le développement et préserver les standards.

Structure d’un module expliquée

Un module Terraform est essentiellement un répertoire contenant un ou plusieurs fichiers .tf. Bien que la structure soit flexible, elle comprend généralement :

main.tf : définit les ressources principales créées par le module.
variables.tf : déclare les variables d’entrée qui personnalisent le comportement du module.
outputs.tf : définit les valeurs de sortie que le module expose à ses appelants.
versions.tf : précise les contraintes de version de Terraform et du fournisseur pour le module.

Cette structure organisée contribue à maintenir un code propre et compréhensible.

Le code de votre premier module

Définissons un module très simple qui crée un compartiment AWS S3. Ce code se trouverait généralement dans son propre répertoire, par exemple modules/my_s3_bucket/main.tf.

Ce fichier complet pourrait être exécuté comme module racine pour observer son fonctionnement, mais son objectif principal ici est de présenter la structure interne d’un module.

provider "aws" {
  region = "us-east-1" # Example region
}

variable "bucket_name" {
  description = "Name for the S3 bucket."
  type        = string
}

variable "acl_setting" {
  description = "ACL for the S3 bucket."
  type        = string
  default     = "private"
}

resource "aws_s3_bucket" "example_bucket" {
  bucket = var.bucket_name
  acl    = var.acl_setting

  tags = {
    Environment = "Dev" # Example tag
  }
}

output "bucket_id" {
  description = "The ID of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.id
}

output "bucket_arn" {
  description = "The ARN of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.arn
}

Entrées d’un module : variables

Les variables d’entrée vous permettent de personnaliser le comportement de votre module sans modifier son code principal. Elles sont définies dans un fichier variables.tf situé dans le répertoire du module.

Lorsque vous appelez un module, vous transmettez des valeurs à ces variables, ce qui rend le module très réutilisable dans différents scénarios et environnements. Considérez-les comme les arguments d’une fonction.

variable "bucket_name" {
  description = "Name for the S3 bucket."
  type        = string
}

variable "acl_setting" {
  description = "ACL for the S3 bucket."
  type        = string
  default     = "private"
}

Sorties d’un module : exposer des données

Les valeurs de sortie servent à exposer des données d’un module à la configuration qui l’appelle. C’est ainsi que vous pouvez accéder aux informations importantes concernant les ressources créées par le module.

Les sorties sont définies dans un fichier outputs.tf situé dans le répertoire du module et peuvent être référencées par d’autres parties de votre configuration Terraform, voire par d’autres modules.

output "bucket_id" {
  description = "The ID of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.id
}

output "bucket_arn" {
  description = "The ARN of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.arn
}

Appeler votre module personnalisé

Maintenant que notre module my_s3_bucket est défini, appelons-le depuis une configuration racine. L’attribut source indique où Terraform peut trouver le module.

Pour les modules locaux, il s’agit d’un chemin relatif vers le répertoire du module. Nous transmettons des valeurs aux variables d’entrée du module et pouvons accéder aux sorties qu’il expose.

provider "aws" {
  region = "us-east-1"
}

module "my_website_bucket" {
  source      = "./modules/my_s3_bucket" # Path to your local module
  bucket_name = "my-unique-website-bucket-12345"
  acl_setting = "public-read"
}

output "website_bucket_arn" {
  description = "ARN of the website S3 bucket."
  value       = module.my_website_bucket.bucket_arn
}

output "website_bucket_id" {
  description = "ID of the website S3 bucket."
  value       = module.my_website_bucket.bucket_id
}

Différentes sources de modules

Les modules ne sont pas uniquement locaux ! Terraform peut récupérer des modules depuis différentes sources, ce qui vous offre davantage de flexibilité :

Chemins locaux : ./modules/my_module (comme dans notre exemple)
Registre Terraform : hashicorp/vpc/aws (modules accessibles publiquement)
Référentiels Git : git::https://example.com/repo.git
Compartiments S3 : s3::https://s3-us-west-2.amazonaws.com/example-bucket/module.zip

Le registre Terraform est un excellent endroit pour trouver des modules préconstruits et validés par la communauté, destinés aux modèles d’infrastructure courants.

L’impact pratique des modules

Imaginez que vous gériez des centaines de ressources dans plusieurs environnements (développement, préproduction, production). Sans modules, vous auriez d’énormes fichiers de configuration répétitifs.

Les modules vous permettent de définir une fois un modèle de « serveur web » ou de « base de données ». Il vous suffit ensuite d’appeler ce module pour chaque instance, en transmettant des variables différentes selon les paramètres propres à l’environnement. Cela réduit considérablement les erreurs, simplifie les mises à jour et rend votre infrastructure véritablement évolutive.

Vérification rapide

Vous avez découvert la structure et les avantages des modules Terraform. Vérifions si vous pouvez identifier un avantage essentiel.

Récapitulatif et prochaines étapes

Dans cette leçon, nous avons présenté les modules Terraform comme des outils puissants pour organiser et réutiliser le code de votre infrastructure. Vous avez appris que :

les modules encapsulent les ressources dans des unités réutilisables ;
ils améliorent l’organisation, la cohérence et la réutilisabilité du code ;
les modules utilisent variables.tf pour les entrées et outputs.tf pour les données exposées ;
vous pouvez appeler des modules depuis des chemins locaux, des registres ou des référentiels Git.

Ensuite, nous approfondirons la création de vos propres modules réutilisables et explorerons des modèles plus avancés ainsi que les bonnes pratiques.

Questions Fréquemment Posées

La leçon « Introduction aux modules Terraform » est-elle gratuite ?

Oui — le texte complet de « Introduction aux modules Terraform » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Terraform Infrastructure as Code, passe à CoddyKit PRO. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Introduction aux modules Terraform » ?

Comprenez les avantages des modules pour encapsuler et réutiliser des modèles d’infrastructure courants, tout en améliorant l’organisation et la maintenabilité du code. Tu pratiques Terraform Infrastructure as Code avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Terraform Infrastructure as Code ?

Aucune expérience préalable n'est requise. Terraform Infrastructure as Code sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Introduction aux modules Terraform » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Terraform Infrastructure as Code ?

Oui. Chaque leçon Terraform Infrastructure as Code inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Introduction aux modules Terraform
Créer des modules réutilisables
Utiliser les espaces de travail pour les environnements
Publier des modules dans un registre

← Retour à Terraform Infrastructure as Code

Que sont les modules Terraform&nbsp;?

Pourquoi utiliser des modules Terraform&nbsp;?