TD2 : Créer un module Terraform réutilisable

• Comprendre l’intérêt des variables et des outputs
• Structurer un projet Terraform
• Créer et utiliser un module
• Manipuler Terraform de manière autonome

Vous travaillez dans une équipe DevOps.

Votre équipe doit déployer plusieurs environnements de test pour différentes équipes :

• frontend
• backend
• data

Chaque équipe a besoin :

• d’un conteneur web
• accessible via un port différent

Problème actuel :

• duplication du code Terraform
• erreurs fréquentes (ports, noms…)
• difficile à maintenir

Objectif :

Créer une solution réutilisable permettant de déployer plusieurs conteneurs rapidement et sans erreur.

mkdir -p terraform-td2/modules/nginx
cd terraform-td2

terraform-td2/
  main.tf
  modules/
    nginx/
      main.tf
      variables.tf
      outputs.tf

Objectif : créer un composant réutilisable

Fichier : modules/nginx/variables.tf

variable "container_name" {
  description = "Nom du conteneur"
}

variable "external_port" {
  description = "Port exposé"
}

Fichier : modules/nginx/main.tf

resource "docker_image" "nginx" {
  name = "nginx:latest"
}

resource "docker_container" "nginx" {
  name  = var.container_name
  image = docker_image.nginx.name

  ports {
    internal = 80
    external = var.external_port
  }
}

Fichier : modules/nginx/outputs.tf

output "url" {
  value = "http://localhost:${var.external_port}"
}

Fichier : main.tf

terraform {
  required_providers {
    docker = {
      source = "kreuzwerker/docker"
    }
  }
}

provider "docker" {}

module "nginx1" {
  source = "./modules/nginx"

  container_name = "frontend"
  external_port  = 8080
}

module "nginx2" {
  source = "./modules/nginx"

  container_name = "backend"
  external_port  = 8081
}

Dans le dossier terraform-td2 :

terraform init
terraform plan
terraform apply

Fichier : main.tf

Modifier la configuration pour utiliser le même port :

external_port = 8080

Relancer :

terraform apply

terraform output

Fichier : modules/nginx/variables.tf

Rendre le module plus flexible :

variable "image_name" {
  description = "Image Docker"
  default     = "nginx:latest"
}

Fichier : modules/nginx/main.tf

Modifier :

resource "docker_image" "nginx" {
  name = var.image_name
}

Afficher toutes les URLs sous forme de map :

output "urls" {
  value = {
    nginx1 = module.nginx1.url
    nginx2 = module.nginx2.url
  }
}

• Éviter la duplication de code
• Générer dynamiquement plusieurs ressources
• Manipuler des structures de données (map)

Jusqu’à présent, vous avez défini plusieurs modules manuellement :

• nginx1
• nginx2
• nginx3

Ce fonctionnement pose un problème :

• le code est dupliqué
• difficile à maintenir
• peu scalable (que faire avec 10 ou 20 environnements ?)

Objectif :

Factoriser la configuration pour décrire les environnements sous forme de données, et laisser Terraform générer les ressources.

Fichier : main.tf

locals {
  environments = {
    frontend = {
      port = 8080
    }
    backend = {
      port = 8081
    }
    data = {
      port = 8082
    }
  }
}

Supprimer les blocs :

module "nginx1" { ... }
module "nginx2" { ... }

Remplacer par :

module "nginx" {
  for_each = local.environments

  source = "./modules/nginx"

  container_name = each.key
  external_port  = each.value.port
}

Fichier : main.tf

output "urls" {
  value = {
    for env, mod in module.nginx :
    env => mod.url
  }
}

terraform apply
terraform output

• Réutiliser les outputs Terraform
• Introduire Ansible comme outil de configuration
• Comprendre l’intégration entre outils
• Comparer deux approches d’architecture

Vous avez déployé plusieurs conteneurs nginx avec Terraform.

Chaque conteneur est accessible via une URL différente :

• frontend → http://localhost:8080
• backend → http://localhost:8081
• data → http://localhost:8082

Problème :

• toutes les pages nginx sont identiques
• impossible d’identifier facilement l’environnement

Objectif :

Configurer dynamiquement chaque conteneur avec Ansible.

Créer un dossier :

mkdir ansible
cd ansible

Créer un fichier playbook.yml :

- name: Configuration des conteneurs nginx
  hosts: all
  gather_facts: false

  tasks:
    - name: Copier une page HTML personnalisée
      copy:
        content: |
          <h1>Environnement : {{ inventory_hostname }}</h1>
          <p>URL : http://localhost:{{ ansible_port }}</p>
        dest: /usr/share/nginx/html/index.html

Ansible a besoin d’un inventory pour savoir :

• quelles machines cibler
• comment s’y connecter

Or, ces informations sont connues par Terraform.

Comment faire le lien entre les deux ?

Modifier Terraform pour générer un fichier inventory.ini.

Indice :

• utiliser templatefile
• utiliser local_file

Exemple attendu :

[web]
frontend ansible_host=localhost ansible_port=8080
backend ansible_host=localhost ansible_port=8081
data ansible_host=localhost ansible_port=8082

Utiliser les outputs Terraform pour générer l’inventory avec un script externe.

terraform output -json > outputs.json

Transformer ce fichier en inventory.ini.

Langage au choix :

• bash
• python
• jq

Lancer Ansible :

ansible-playbook -i inventory.ini playbook.yml