Dans le monde de l'approvisionnement et de la gestion des infrastructures, Terraform est devenu un choix populaire parmi les développeurs et les équipes d'exploitation. Avec sa syntaxe déclarative (HCL - HashiCorp Configuration Language) et la prise en charge de divers fournisseurs d'infrastructure, Terraform permet des pratiques d'infrastructure en tant que code (IaC).
L'une de ses principales caractéristiques est l'utilisation de modules qui permettent de créer et de réutiliser le code de l'infrastructure modulaire. Dans cet article, nous explorerons le concept des modules Terraform et comment ils peuvent aider à organiser et simplifier notre code d'infrastructure.
Présentation des modules Terraform
Les modules Terraform sont des packages autonomes de configurations Terraform qui représentent un ensemble de ressources avec des variables d'entrée et de sortie définies. Ils fournissent un moyen d'encapsuler et de réutiliser le code d'infrastructure, ce qui facilite la gestion et la maintenance des déploiements d'infrastructure complexes.
Les modules peuvent être créés et utilisés en interne au sein d'un projet ou partagés entre plusieurs projets ou équipes.
Organisation du module
Lors de l'organisation des modules Terraform, il est courant d'avoir une structure hiérarchique composée de modules racine et enfant. Voyons comment fonctionne cette organisation.
Module racine
Le module racine représente le module de niveau supérieur dans notre configuration Terraform. C'est le point d'entrée pour définir l'infrastructure globale et gérer les relations entre les différentes ressources.
Le module racine contient généralement le fichier 'main.tf' dans lequel nous définissons les ressources et les configurations qui constituent la base de notre infrastructure. En option, nous pouvons avoir les fichiers 'variables.tf' et 'outputs.tf' avec. De plus, nous pouvons définir notre répertoire 'modules' dans le répertoire racine pour accéder facilement aux modules enfants.
Modules enfants
Les modules enfants sont des composants modulaires qui encapsulent des ensembles spécifiques de ressources ou de configurations. Ils sont conçus pour être réutilisables et représentent les unités autonomes de fonctionnalité de l'infrastructure.
Les modules enfants peuvent être utilisés dans la racine ou d'autres modules enfants qui permettent la composition et la construction d'infrastructures complexes. Chaque module enfant a généralement son répertoire qui contient les fichiers de configuration nécessaires tels que 'main.tf', 'variables.tf' et 'outputs.tf'.
Voyons maintenant comment créer un module Terraform.
Créer un module Terraform
Lors de la création de modules Terraform, nous devons créer un nouveau répertoire pour le module avec les fichiers de configuration Terraform requis. Habituellement, ce répertoire est nommé 'modules'. Le définir dans le répertoire racine de notre projet est une bonne pratique.
Prenons un exemple simple d'un module simple pour provisionner un serveur Web local à l'aide de Docker. Tout d'abord, nous définissons le module dans le répertoire 'modules' comme 'main.tf'.
Ressource 'docker_container' 'serveur Web' {nom = var.nom
image = var.image
ports {
interne = var. port_interne
externe = var.external_port
}
}
Ici, nous créons un module appelé 'docker_container' qui prend le nom du conteneur, l'image Docker, le port interne et le port externe comme variables d'entrée. Le module encapsule la logique pour créer une ressource de conteneur Docker et permet à l'appelant de personnaliser les propriétés du conteneur.
Comme illustré dans l'image suivante, nous créons un fichier séparé appelé 'variables.tf' dans le répertoire 'modules' pour définir les variables d'entrée qui peuvent être personnalisées lors de l'utilisation du module :
variable 'nom' {descriptif = 'Nom du conteneur Docker'
taper = chaîne
}
variable 'image' {
descriptif = 'Image Docker'
taper = chaîne
}
variable 'Port interne' {
descriptif = 'Port interne sur le conteneur Docker'
taper = nombre
}
variable 'port_externe' {
descriptif = 'Port externe à mapper'
taper = nombre
}
Ici, nous avons déclaré quatre variables, chacune avec 'description' et 'type' comme attributs et valeurs pertinentes pour eux.
Utiliser un module Terraform
Depuis que nous avons créé notre module, nous pouvons maintenant l'utiliser dans notre configuration Terraform principale en référençant sa source. Créons notre fichier de configuration principal qui est 'main.tf' dans le répertoire racine.
module 'container_serveur_web' {source = '../modules/docker_container'
nom = 'monserveurweb'
image = 'nginx : le plus récent'
port_interne = 80
port_externe = 8080
}
Nous utilisons le bloc 'module' dans le code précédent pour instancier le module de conteneur Docker. Nous fournissons les valeurs d'entrée nécessaires pour le module, telles que le nom du conteneur, l'image Docker et la configuration du port. Le paramètre 'source' spécifie le chemin relatif vers le répertoire 'module'.
Voyons ensuite comment utiliser les sorties Terraform à utiliser avec les modules.
Sorties des modules
Les sorties de module dans Terraform permettent d'exposer des valeurs spécifiques à partir d'un module, les rendant disponibles pour une utilisation dans la configuration principale ou par d'autres modules. Ils servent de canal de communication entre le module et l'appelant, ce qui permet au module de fournir une information ou des données qui peuvent être utiles ou nécessaires pour une configuration ou une prise de décision ultérieure.
sortir 'identifiant_conteneur' {descriptif = 'ID du conteneur Docker créé'
valeur = docker_container.webserver.id
}
Ici, nous avons créé un fichier 'outputs.tf' dans le répertoire 'modules'. Cette variable de sortie expose l'ID du conteneur Docker créé par la ressource 'docker_container' nommée 'webserver' dans le module.
Maintenant, nous pouvons accéder à l'ID du conteneur dans notre fichier de configuration racine. Reportez-vous au code mis à jour suivant du fichier 'main.tf' dans le répertoire racine :
module 'container_serveur_web' {source = '../modules/docker_container'
nom = 'monserveurweb'
image = 'nginx : le plus récent'
port_interne = 80
port_externe = 8080
}
Ressource 'docker_volume' 'données' {
# Le reste des arguments va ici
lier = module.webserver_container.container_id
}
En utilisant « module.webserver_container.container_id » comme valeur pour l'argument « bind », nous demandons à Terraform de lier le volume Docker à l'emplacement spécifié par l'ID de conteneur du module « web_container ». Cela établit une relation entre la ressource de volume Docker et le conteneur créé par le module 'webserver_container', garantissant que le volume est monté à l'emplacement approprié.
Meilleures pratiques pour les modules Terraform
Modulariser pour la réutilisation
Nous devrions considérer la réutilisabilité lors de la conception des modules. De plus, nous devons identifier les composants ou modèles logiques de notre infrastructure et les encapsuler dans des modules distincts. Cela favorise la réutilisation du code, la standardisation et une collaboration plus facile entre les équipes.
Dénomination claire et cohérente
L'utilisation de conventions de dénomination claires et cohérentes pour les modules, les variables et les ressources améliore la lisibilité et la compréhension de la base de code, ce qui facilite l'utilisation et la maintenance des modules par d'autres.
Isoler les dépendances
Il faut éviter les couplages serrés entre modules. Chaque module doit encapsuler ses propres ressources et dépendances. Cela garantit que les modules peuvent être réutilisés indépendamment et favorise une meilleure isolation et encapsulation.
Contrôle de version et registre de modules
Nous pouvons publier nos modules dans un référentiel contrôlé par version ou dans un registre de modules. Cela fournit un emplacement centralisé pour le partage et la découverte des modules, garantissant un accès et une gestion des versions faciles.
Conclusion
Nous avons pris une brève introduction aux modules Terraform et appris à les créer avec un exemple simple. Ensuite, nous avons examiné comment utiliser les variables et les sorties avec notre module pour améliorer sa flexibilité, sa réutilisation et sa maintenabilité. En conclusion, les modules Terraform sont des outils puissants pour organiser et simplifier le code de l'infrastructure. Ils nous permettent d'encapsuler un ensemble de ressources ou de configurations dans des composants réutilisables favorisant la modularité, la réutilisabilité et la collaboration au sein de nos projets d'infrastructure en tant que code.