TD2 : Bases du provisionning

• 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

• Découvrir une alternative à Terraform
• Comprendre la différence déclaratif vs programmation
• Réécrire une logique Terraform avec un langage classique
• Identifier avantages et limites

Contrairement à Terraform :

• Terraform → langage déclaratif (HCL)
• Pulumi → langage de programmation (TypeScript ici)

Un module Terraform devient :

• une fonction
• ou une classe

Un for_each devient :

• une boucle classique

mkdir pulumi-td2
cd pulumi-td2

pulumi new typescript

Choisir :

• project name : pulumi-td2
• stack : dev

Installer le provider Docker :

npm install @pulumi/docker

Créer un fichier nginx.ts :

import * as docker from "@pulumi/docker";

export function createNginx(name: string, port: number) {

  const image = new docker.RemoteImage(name, {
    name: "nginx:latest",
  });

  const container = new docker.Container(name, {
    image: image.imageId,
    ports: [
      {
        internal: 80,
        external: port,
      },
    ],
  });

  return {
    url: `http://localhost:${port}`,
  };
}

Modifier index.ts :

import { createNginx } from "./nginx";

const frontend = createNginx("frontend", 8080);
const backend = createNginx("backend", 8081);

export const frontendUrl = frontend.url;
export const backendUrl = backend.url;

pulumi up

Equivalent du for_each Terraform :

import { createNginx } from "./nginx";

const environments: Record<string, number> = {
  frontend: 8080,
  backend: 8081,
  data: 8082,
};

const urls: Record<string, string> = {};

for (const [name, port] of Object.entries(environments)) {
  const nginx = createNginx(name, port);
  urls[name] = nginx.url;
}

export { urls };

const ports = Object.values(environments);

if (new Set(ports).size !== ports.length) {
  throw new Error("Ports dupliqués détectés !");
}