Aller au contenu

Lab 09 : Déploiement d'une infrastructure avec Terraform

À l’issue de ce lab, vous serez capable de :

  • expliquer le principe de l’infrastructure as code (IaC) et le fonctionnement de Terraform : configuration, provider, plan d’exécution et état (state) ;
  • configurer le provider Terraform OUTSCALE avec le profil octl créé au Lab 05 ;
  • décrire en code un Net (réseau virtuel), ses Subnets (sous-réseaux), son routage, ses Security Groups (groupes de sécurité), des VMs (machines virtuelles) et un load balancer ;
  • utiliser une data source pour sélectionner automatiquement la dernière OMI (OUTSCALE Machine Image) officielle ;
  • appliquer une configuration par étapes et lire un plan d’exécution avant de l’appliquer ;
  • détecter une modification faite en dehors de Terraform et revenir à l’état décrit dans la configuration ;
  • supprimer toutes les ressources du lab avec une seule commande.

Dans les Labs 06 et 08, vous avez construit des architectures à la main, ressource par ressource, en relevant les identifiants des unes pour créer les autres. Ce lab reprend l’architecture du Lab 06 et la décrit dans des fichiers texte : Terraform lit ces fichiers, calcule l’ordre de création des ressources et appelle l’API OUTSCALE à votre place.

Le lab déploie les ressources suivantes, toutes dans la Région eu-west-2 :

  • un Net architecte-lab09-net (10.0.0.0/16) ;
  • un Subnet public architecte-lab09-pub-net (10.0.1.0/24), dans la Sous-région eu-west-2a, qui accueille le NAT Service et le load balancer ;
  • deux Subnets privés, un par Sous-région : architecte-lab09-web-net-a (10.0.2.0/24, eu-west-2a) et architecte-lab09-web-net-b (10.0.3.0/24, eu-west-2b) ;
  • un Internet Service et une route table publique, pour le Subnet public ;
  • un NAT Service et une route table privée, pour que les VMs des Subnets privés installent leurs paquets au premier démarrage ;
  • un Security Group pour le load balancer, qui accepte le HTTP depuis Internet, et un Security Group pour les VMs web, qui n’accepte le HTTP que depuis le load balancer ;
  • deux VMs web architecte-lab09-vm-web-a et architecte-lab09-vm-web-b, sans IP publique, configurées par Cloud-init ;
  • un load balancer relié à Internet architecte-lab09-lb, avec un health check HTTP, qui répartit le trafic entre les deux VMs web.

Par rapport au Lab 06, ce lab ne contient ni VM bastion ni paire de clés : vous ne vous connectez jamais aux VMs. Elles sont entièrement configurées par Cloud-init, et vous les vérifiez à travers le load balancer.

Terraform s’appuie sur trois éléments :

  • la configuration : les fichiers .tf qui décrivent l’infrastructure souhaitée ;
  • le provider OUTSCALE : le plugin qui traduit chaque ressource de la configuration en appels de l’API OUTSCALE ;
  • l’état (state) : le fichier terraform.tfstate, dans lequel Terraform enregistre les identifiants des ressources qu’il a créées.

À chaque exécution, Terraform compare la configuration, l’état et les ressources réelles de votre compte, puis propose un plan d’exécution : la liste des ressources à créer, à modifier ou à supprimer pour que l’infrastructure corresponde à la configuration.

Avant de commencer, vous devez disposer :

  • d’un compte OUTSCALE actif, dont les quotas permettent de créer au moins deux VMs, un load balancer et une IP publique ;
  • d’un accès à Cockpit ;
  • d’un terminal bash avec curl ;
  • d’une connexion Internet ;
  • d’un éditeur de texte, par exemple VS Code avec l’extension HashiCorp Terraform, qui colore la syntaxe et complète les noms des ressources ;
  • d’octl, installé et configuré avec le profil default dans le Lab 05 : Terraform utilise ce même profil pour s’authentifier ;
  • des connaissances acquises dans le Lab 02 (Net, Subnets, route tables, NAT Service), le Lab 05 (octl, access key) et le Lab 06 (load balancer, health check, Security Group de load balancer).

Ce lab ne réutilise aucune ressource OUTSCALE des labs précédents.

Le lab utilise la région eu-west-2.

Remarque : sous Windows, utilisez WSL (Windows Subsystem for Linux), comme dans le Lab 05, pour suivre ce lab avec les mêmes commandes.

Important : ce lab a été rédigé avec la version 1.8.1 du provider Terraform OUTSCALE et octl v0.0.35. Si une commande ne se comporte pas comme décrit, consultez la documentation du provider et l’aide intégrée d’octl (octl iaas <commande> --help).

  1. Installez Terraform en suivant uniquement la méthode de votre système.

    Sous macOS : installez Terraform avec Homebrew, depuis le dépôt officiel de HashiCorp.

    Terminal window
    brew tap hashicorp/tap
    brew install hashicorp/tap/terraform

    Sous Linux (Ubuntu ou Debian) : ajoutez le dépôt de paquets officiel de HashiCorp, puis installez Terraform.

    Terminal window
    wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
    sudo apt update && sudo apt install terraform
  2. Vérifiez l’installation :

    Terminal window
    terraform version

    La commande affiche la version de Terraform, par exemple Terraform v1.13.4. Ce lab nécessite Terraform 1.6.0 ou une version plus récente.

Remarque : les autres méthodes d’installation, dont celle pour Windows, sont détaillées dans le Lab 01 du parcours Terraform.

Terraform s’authentifie auprès de l’API OUTSCALE avec la même access key qu’octl, lue dans le même fichier ~/.osc/config.json.

  1. Affichez le profil actif :

    Terminal window
    octl profile current

    Le profil default s’affiche, avec la Région eu-west-2. Si la commande échoue, reprenez la partie 2 du Lab 05.

Attention : n’écrivez jamais votre access key ni votre Secret Key dans un fichier .tf ou .tfvars. Ces fichiers sont faits pour être partagés et versionnés dans un dépôt Git : la Secret Key finirait tôt ou tard en dehors de votre poste.

Un projet Terraform est un dossier : Terraform lit tous les fichiers .tf qu’il contient, quel que soit leur nom. Dans ce lab, vous répartissez la configuration en un fichier par thème.

  1. Créez le dossier du projet et placez-vous dedans :

    Terminal window
    mkdir ~/architecte-lab09
    cd ~/architecte-lab09
  2. Créez un fichier .gitignore pour exclure du versionnement les fichiers que Terraform génère :

    Terminal window
    cat > .gitignore <<'EOF'
    .terraform/
    *.tfstate
    *.tfstate.*
    EOF

    Ouvrez ensuite le dossier ~/architecte-lab09 dans votre éditeur : vous y créerez tous les fichiers du lab.

  1. Créez le fichier versions.tf avec le contenu suivant :

    terraform {
    required_version = ">= 1.6.0"
    required_providers {
    outscale = {
    source = "outscale/outscale"
    version = "~> 1.8"
    }
    }
    }
    • required_version : la version minimale de Terraform.
    • source : l’adresse du provider OUTSCALE dans le registre Terraform.
    • version = "~> 1.8" : toute version 1.x à partir de 1.8, mais jamais une version 2.0, qui pourrait contenir des changements incompatibles.
  2. Créez le fichier provider.tf avec le contenu suivant :

    provider "outscale" {
    profile = "default"
    }

    Le provider lit le profil default du fichier ~/.osc/config.json : l’access key, la Secret Key et la Région eu-west-2. Aucun secret n’apparaît dans la configuration.

  1. Initialisez le projet :

    Terminal window
    terraform init

    Terraform télécharge le provider OUTSCALE depuis le registre Terraform. Repérez les lignes suivantes :

    • Installing outscale/outscale v1.8.x... : la version installée, choisie selon la contrainte ~> 1.8 ;
    • Terraform has been successfully initialized! : le projet est prêt.
  2. Listez le contenu du dossier :

    Terminal window
    ls -a

    Deux éléments ont été créés :

    • le dossier .terraform/, qui contient le binaire du provider ;
    • le fichier .terraform.lock.hcl, qui enregistre la version exacte du provider et son empreinte. Ce fichier se versionne avec la configuration : toute l’équipe utilise ainsi la même version du provider.

Remarque : relancez terraform init chaque fois que vous ajoutez un provider ou changez sa contrainte de version. Les autres modifications de la configuration ne demandent pas de nouvelle initialisation.

  1. Créez le fichier variables.tf avec le contenu suivant :

    variable "prefixe" {
    description = "Préfixe du nom de toutes les ressources du lab"
    type = string
    default = "architecte-lab09"
    }
    variable "vm_type" {
    description = "Type des VMs web"
    type = string
    default = "tinav5.c1r1p2"
    }
    locals {
    # Une entrée par Sous-région : chacune reçoit un Subnet privé et une VM web
    web = {
    a = { subregion = "eu-west-2a", ip_range = "10.0.2.0/24" }
    b = { subregion = "eu-west-2b", ip_range = "10.0.3.0/24" }
    }
    }
    • Une variable (variable) est un paramètre de la configuration. Sa valeur par défaut (default) peut être remplacée au moment de l’exécution, par exemple avec l’option -var.
    • Une valeur locale (locals) est une valeur calculée ou fixée dans la configuration. La valeur locale web décrit les deux Sous-régions du niveau web : vous l’utiliserez pour créer un Subnet et une VM dans chacune.
    • tinav5.c1r1p2 est le type de VM utilisé au Lab 05 : 1 vCore, 1 Gio de mémoire et une performance high.

Remarque : si plusieurs stagiaires partagent le même compte OUTSCALE, chacun doit utiliser un préfixe différent, car les noms des Security Groups et des load balancers sont uniques dans un compte. Ajoutez alors l’option -var 'prefixe=architecte-lab09-<VOS_INITIALES>' à toutes les commandes terraform plan, apply et destroy du lab.

  1. Créez le fichier network.tf avec le contenu suivant :

    # Net et Subnet public
    resource "outscale_net" "lab09" {
    ip_range = "10.0.0.0/16"
    tags {
    key = "Name"
    value = "${var.prefixe}-net"
    }
    }
    resource "outscale_subnet" "public" {
    net_id = outscale_net.lab09.net_id
    ip_range = "10.0.1.0/24"
    subregion_name = "eu-west-2a"
    tags {
    key = "Name"
    value = "${var.prefixe}-pub-net"
    }
    }
    # Un Subnet privé par Sous-région
    resource "outscale_subnet" "web" {
    for_each = local.web
    net_id = outscale_net.lab09.net_id
    ip_range = each.value.ip_range
    subregion_name = each.value.subregion
    tags {
    key = "Name"
    value = "${var.prefixe}-web-net-${each.key}"
    }
    }

    Chaque bloc resource décrit une ressource OUTSCALE. Il porte deux étiquettes : le type de ressource (outscale_net, outscale_subnet) et un nom local (lab09, public, web), qui sert uniquement à y faire référence dans la configuration.

    Observez trois mécanismes :

    • la référence outscale_net.lab09.net_id : le Subnet utilise l’identifiant du Net, que Terraform ne connaîtra qu’après la création du Net. Terraform en déduit l’ordre de création : d’abord le Net, puis les Subnets. Vous n’avez plus à relever d’identifiant, comme avec octl au Lab 06 ;
    • le tag Name : c’est le nom affiché dans Cockpit, et celui que filtre l’option --tag-value d’octl ;
    • for_each : le bloc outscale_subnet.web crée une ressource par entrée de local.web. each.key vaut a puis b, et each.value contient la Sous-région et l’IP range correspondantes.
  1. Mettez en forme les fichiers selon les conventions de Terraform :

    Terminal window
    terraform fmt

    La commande aligne les signes = et corrige l’indentation. Elle affiche le nom des fichiers modifiés, ou rien s’ils étaient déjà bien formatés.

  2. Vérifiez la syntaxe et la cohérence de la configuration :

    Terminal window
    terraform validate

    Le message Success! The configuration is valid. s’affiche. En cas d’erreur, Terraform indique le fichier, la ligne et la cause : un attribut mal orthographié, une accolade manquante, une référence vers une ressource qui n’existe pas.

Remarque : terraform validate ne contacte pas l’API OUTSCALE. Il ne détecte donc pas, par exemple, une IP range déjà utilisée ou un quota atteint : ces erreurs n’apparaissent qu’au moment de l’application.

  1. Affichez le plan d’exécution :

    Terminal window
    terraform plan
  2. Lisez le plan :

    • chaque ressource à créer est précédée du symbole + et de la mention will be created ;
    • les valeurs que vous avez fixées apparaissent en clair (ip_range, subregion_name, tags) ;
    • les valeurs calculées par OUTSCALE (net_id, subnet_id) apparaissent sous la forme (known after apply) ;
    • les deux Subnets privés apparaissent sous les noms outscale_subnet.web["a"] et outscale_subnet.web["b"].

    La dernière ligne résume le plan :

    Terminal window
    Plan: 4 to add, 0 to change, 0 to destroy.

terraform plan ne modifie rien : il montre ce que Terraform ferait.

  1. Appliquez la configuration :

    Terminal window
    terraform apply

    Terraform recalcule le plan, l’affiche, puis demande une confirmation.

  2. Vérifiez le plan, puis saisissez yes et validez.

    Terraform crée d’abord le Net, puis les trois Subnets en parallèle, et termine par :

    Terminal window
    Apply complete! Resources: 4 added, 0 changed, 0 destroyed.
  3. Listez les ressources enregistrées dans l’état :

    Terminal window
    terraform state list

    Les quatre ressources s’affichent. Le fichier terraform.tfstate est apparu dans le dossier du projet : il associe chaque ressource de la configuration à l’identifiant de la ressource OUTSCALE créée.

  4. Vérifiez les ressources avec octl :

    Terminal window
    octl iaas net list --tag-value architecte-lab09-net
    octl iaas subnet list \
    --tag-value architecte-lab09-pub-net,architecte-lab09-web-net-a,architecte-lab09-web-net-b

    Le Net et les trois Subnets s’affichent, avec leurs IP ranges et leurs Sous-régions.

  5. Dans Cockpit, sélectionnez Network > Nets & Subnets : le Net architecte-lab09-net et ses trois Subnets apparaissent, comme s’ils avaient été créés à la main.

Attention : ne supprimez pas et ne modifiez pas le fichier terraform.tfstate. Sans lui, Terraform ne sait plus quelles ressources il a créées : un nouveau terraform apply créerait un second Net au lieu de reconnaître le premier.

Vous complétez maintenant la configuration. Terraform ne recrée pas les ressources existantes : il ajoute seulement celles qui manquent.

  1. Créez le fichier routing.tf avec le contenu suivant :

    # Accès Internet du Subnet public : Internet Service et route table publique
    resource "outscale_internet_service" "lab09" {
    tags {
    key = "Name"
    value = "${var.prefixe}-is"
    }
    }
    resource "outscale_internet_service_link" "lab09" {
    internet_service_id = outscale_internet_service.lab09.internet_service_id
    net_id = outscale_net.lab09.net_id
    }
    resource "outscale_route_table" "public" {
    net_id = outscale_net.lab09.net_id
    tags {
    key = "Name"
    value = "${var.prefixe}-rt-public"
    }
    }
    resource "outscale_route" "public_internet" {
    route_table_id = outscale_route_table.public.route_table_id
    destination_ip_range = "0.0.0.0/0"
    gateway_id = outscale_internet_service.lab09.internet_service_id
    depends_on = [outscale_internet_service_link.lab09]
    }
    resource "outscale_route_table_link" "public" {
    route_table_id = outscale_route_table.public.route_table_id
    subnet_id = outscale_subnet.public.subnet_id
    }
    # Accès sortant des Subnets privés : NAT Service et route table privée
    resource "outscale_public_ip" "nat" {
    tags {
    key = "Name"
    value = "${var.prefixe}-nat-ip"
    }
    }
    resource "outscale_nat_service" "lab09" {
    subnet_id = outscale_subnet.public.subnet_id
    public_ip_id = outscale_public_ip.nat.public_ip_id
    tags {
    key = "Name"
    value = "${var.prefixe}-nat"
    }
    depends_on = [outscale_route.public_internet]
    }
    resource "outscale_route_table" "private" {
    net_id = outscale_net.lab09.net_id
    tags {
    key = "Name"
    value = "${var.prefixe}-rt-private"
    }
    }
    resource "outscale_route" "private_nat" {
    route_table_id = outscale_route_table.private.route_table_id
    destination_ip_range = "0.0.0.0/0"
    nat_service_id = outscale_nat_service.lab09.nat_service_id
    }
    resource "outscale_route_table_link" "web" {
    for_each = outscale_subnet.web
    route_table_id = outscale_route_table.private.route_table_id
    subnet_id = each.value.subnet_id
    }

    Vous retrouvez la configuration des parties 1 et 2 du Lab 06. Deux points sont propres à Terraform :

    • depends_on déclare une dépendance que Terraform ne peut pas déduire des références. La route vers l’Internet Service ne fonctionne que si l’Internet Service est associé au Net (outscale_internet_service_link), et le NAT Service n’a d’accès à Internet que si cette route existe. Aucune de ces ressources ne fait référence à l’autre : sans depends_on, Terraform pourrait les créer en parallèle ;
    • for_each = outscale_subnet.web crée une association de la route table privée pour chacun des deux Subnets privés : each.value est alors le Subnet lui-même.
  1. Créez le fichier security.tf avec le contenu suivant :

    # Security Group du load balancer : HTTP depuis Internet
    resource "outscale_security_group" "lb" {
    security_group_name = "${var.prefixe}-sg-lb"
    description = "Lab 09 - load balancer"
    net_id = outscale_net.lab09.net_id
    tags {
    key = "Name"
    value = "${var.prefixe}-sg-lb"
    }
    }
    resource "outscale_security_group_rule" "lb_http" {
    flow = "Inbound"
    security_group_id = outscale_security_group.lb.security_group_id
    ip_protocol = "tcp"
    from_port_range = 80
    to_port_range = 80
    ip_range = "0.0.0.0/0"
    }
    # Security Group des VMs web : HTTP uniquement depuis le load balancer
    resource "outscale_security_group" "web" {
    security_group_name = "${var.prefixe}-sg-web"
    description = "Lab 09 - VMs web"
    net_id = outscale_net.lab09.net_id
    tags {
    key = "Name"
    value = "${var.prefixe}-sg-web"
    }
    }
    resource "outscale_security_group_rule" "web_http_from_lb" {
    flow = "Inbound"
    security_group_id = outscale_security_group.web.security_group_id
    rules {
    ip_protocol = "tcp"
    from_port_range = 80
    to_port_range = 80
    security_groups_members {
    account_id = outscale_security_group.lb.account_id
    security_group_id = outscale_security_group.lb.security_group_id
    }
    }
    }
    • La règle lb_http autorise une IP range : 0.0.0.0/0, c’est-à-dire toutes les adresses.
    • La règle web_http_from_lb autorise un Security Group, avec le bloc rules et son sous-bloc security_groups_members : seul le load balancer, associé au Security Group architecte-lab09-sg-lb, peut joindre le port 80 des VMs web. C’est la règle de l’étape 3.3 du Lab 06.

Remarque : chaque Security Group est créé avec sa règle sortante par défaut, qui autorise tout le trafic sortant. Les VMs web en ont besoin pour joindre le NAT Service, et le load balancer pour joindre ses VMs backend.

  1. Vérifiez la configuration, puis affichez le plan :

    Terminal window
    terraform fmt
    terraform validate
    terraform plan

    Le plan se termine par :

    Terminal window
    Plan: 15 to add, 0 to change, 0 to destroy.

    Les quatre ressources de la partie 3 n’apparaissent pas dans le plan : elles existent déjà et correspondent à la configuration. Terraform ajoute uniquement les 15 nouvelles ressources.

  2. Appliquez la configuration, puis saisissez yes :

    Terminal window
    terraform apply

    Observez l’ordre de création : l’Internet Service et son association, puis la route publique, puis le NAT Service. La création du NAT Service prend une à deux minutes : Terraform affiche Still creating... toutes les 10 secondes, jusqu’à ce que le NAT Service soit disponible.

  3. Vérifiez le NAT Service avec octl :

    Terminal window
    octl iaas natservice list --tag-value architecte-lab09-nat

    Le NAT Service s’affiche à l’état available.

  1. Créez le fichier cloud-init.yaml avec le contenu suivant :

    #cloud-config
    package_update: true
    packages:
    - apache2
    - php
    - libapache2-mod-php
    write_files:
    - path: /var/www/html/health.html
    owner: www-data:www-data
    permissions: "0644"
    content: |
    OK
    - path: /var/www/html/index.php
    owner: www-data:www-data
    permissions: "0644"
    content: |
    <!DOCTYPE html>
    <html lang="fr">
    <head>
    <meta charset="UTF-8">
    <title>OUTSCALE - Lab 09</title>
    </head>
    <body>
    <h1>Lab 09 - Infrastructure déployée avec Terraform</h1>
    <p>VM web : <?php echo htmlspecialchars(gethostname()); ?></p>
    </body>
    </html>
    runcmd:
    - rm -f /var/www/html/index.html
    - systemctl enable --now apache2

    Le script installe Apache et PHP, puis crée deux pages : index.php, qui affiche le nom d’hôte de la VM, et health.html, réservée au health check du load balancer, comme au Lab 08.

  1. Créez le fichier vms.tf avec le contenu suivant :

    # OMI Ubuntu 22.04 officielle la plus récente
    data "outscale_image" "ubuntu" {
    filter {
    name = "account_aliases"
    values = ["Outscale"]
    }
    filter {
    name = "image_names"
    values = ["Ubuntu-22.04-*"]
    }
    most_recent = true
    }
    # Une VM web par Sous-région, sans IP publique
    resource "outscale_vm" "web" {
    for_each = local.web
    image_id = data.outscale_image.ubuntu.image_id
    vm_type = var.vm_type
    subnet_id = outscale_subnet.web[each.key].subnet_id
    security_group_ids = [outscale_security_group.web.security_group_id]
    user_data = base64encode(file("${path.module}/cloud-init.yaml"))
    tags {
    key = "Name"
    value = "${var.prefixe}-vm-web-${each.key}"
    }
    # Cloud-init télécharge les paquets au premier démarrage, par le NAT Service
    depends_on = [outscale_route.private_nat, outscale_route_table_link.web]
    }
    • Un bloc data est une data source : il ne crée rien, il lit une information existante dans votre compte. Ici, il recherche les OMI Ubuntu 22.04 publiées par OUTSCALE et retient la plus récente (most_recent = true). C’est la recherche de l’étape 3.3 du Lab 05, sans identifiant d’OMI codé en dur.
    • outscale_subnet.web[each.key] place la VM a dans le Subnet a et la VM b dans le Subnet b.
    • user_data transmet le script Cloud-init, encodé en Base64 comme l’exige l’API OUTSCALE.
    • depends_on reprend l’avertissement des Labs 06 et 08 : les VMs ne doivent démarrer qu’une fois la route vers le NAT Service en place, sinon Cloud-init ne peut pas installer les paquets.

Remarque : dans Cockpit, le script Cloud-init s’accompagne de la section OUTSCALE filter_private_section=true. Avec Terraform, le script est transmis tel quel dans les user data de la VM : cette section n’est pas nécessaire.

  1. Créez le fichier lb.tf avec le contenu suivant :

    # Load balancer relié à Internet, dans le Subnet public
    resource "outscale_load_balancer" "lab09" {
    load_balancer_name = "${var.prefixe}-lb"
    load_balancer_type = "internet-facing"
    subnets = [outscale_subnet.public.subnet_id]
    security_groups = [outscale_security_group.lb.security_group_id]
    listeners {
    load_balancer_protocol = "HTTP"
    load_balancer_port = 80
    backend_protocol = "HTTP"
    backend_port = 80
    }
    tags {
    key = "Name"
    value = "${var.prefixe}-lb"
    }
    depends_on = [outscale_route.public_internet, outscale_route_table_link.public]
    }
    # Health check HTTP rapide, comme au Lab 06
    resource "outscale_load_balancer_attributes" "health_check" {
    load_balancer_name = outscale_load_balancer.lab09.load_balancer_name
    health_check {
    protocol = "HTTP"
    port = 80
    path = "/health.html"
    check_interval = 10
    timeout = 5
    healthy_threshold = 2
    unhealthy_threshold = 2
    }
    }
    # Enregistrement des deux VMs web comme VMs backend
    resource "outscale_load_balancer_vms" "web" {
    load_balancer_name = outscale_load_balancer.lab09.load_balancer_name
    backend_vm_ids = [for vm in outscale_vm.web : vm.vm_id]
    }

    Chaque ressource correspond à une commande octl du Lab 06 :

    Ressource TerraformCommande octl du Lab 06
    outscale_load_balanceroctl iaas loadbalancer create
    outscale_load_balancer_attributesoctl iaas loadbalancer update --health-check-*
    outscale_load_balancer_vmsoctl iaas api LinkLoadBalancerBackendMachines

    L’expression [for vm in outscale_vm.web : vm.vm_id] construit la liste des identifiants des deux VMs web : elle remplace la commande octl iaas vm list ... | paste -sd, - du Lab 06.

  1. Créez le fichier outputs.tf avec le contenu suivant :

    output "lb_dns_name" {
    description = "Nom DNS du load balancer"
    value = outscale_load_balancer.lab09.dns_name
    }
    output "vm_web_private_ips" {
    description = "IP privée de chaque VM web"
    value = { for k, vm in outscale_vm.web : k => vm.private_ip }
    }

    Une sortie (output) affiche une valeur à la fin de chaque terraform apply. Vous pouvez aussi la relire à tout moment avec terraform output.

  1. Vérifiez la configuration, puis affichez le plan :

    Terminal window
    terraform fmt
    terraform validate
    terraform plan
    • Au début du plan, la ligne data.outscale_image.ubuntu: Reading... montre que Terraform interroge l’API OUTSCALE pour trouver l’OMI.
    • Dans le détail des deux VMs, image_id affiche l’identifiant de l’OMI trouvée (il commence par ami-).
    • Le plan se termine par Plan: 5 to add, 0 to change, 0 to destroy. et par les deux sorties, dont les valeurs sont (known after apply).
  2. Appliquez la configuration, puis saisissez yes :

    Terminal window
    terraform apply

    Terraform crée les deux VMs et le load balancer en parallèle, puis configure le health check et enregistre les VMs backend. À la fin, les sorties s’affichent :

    Terminal window
    Outputs:
    lb_dns_name = "architecte-lab09-lb-123456789.eu-west-2.lbu.outscale.com"
    vm_web_private_ips = {
    "a" = "10.0.2.15"
    "b" = "10.0.3.48"
    }

Remarque : pendant le plan et l’application, le provider affiche un avertissement Resource 'outscale_load_balancer_vms' Considerations. Il signale que la liste des VMs backend enregistrée dans l’état de la ressource outscale_load_balancer n’est mise à jour qu’à l’exécution suivante. Cet avertissement est normal et n’empêche pas le load balancer de fonctionner.

  1. Affichez l’état des VMs backend du load balancer :

    Terminal window
    octl iaas loadbalancer backends architecte-lab09-lb
  2. Relancez la commande jusqu’à ce que les deux VMs backend soient à l’état UP. Cloud-init doit d’abord terminer l’installation d’Apache et de PHP : comptez quelques minutes après la création des VMs.

Remarque : terraform apply se termine dès que l’API OUTSCALE a accepté la création des ressources. Il n’attend pas que Cloud-init ait configuré les VMs : une infrastructure créée n’est pas encore une application qui fonctionne.

  1. Enregistrez le nom DNS du load balancer dans la variable LB_DNS, à partir de la sortie Terraform :

    Terminal window
    LB_DNS=$(terraform output -raw lb_dns_name)
    echo $LB_DNS

    L’option -raw affiche la valeur sans guillemets, pour pouvoir l’utiliser dans une commande.

  2. Envoyez six requêtes au load balancer :

    Terminal window
    for i in 1 2 3 4 5 6; do
    curl -s http://$LB_DNS/ | grep "VM web"
    done

    Le résultat ressemble à ceci, avec vos propres adresses :

    Terminal window
    <p>VM web : ip-10-0-2-15</p>
    <p>VM web : ip-10-0-3-48</p>
    <p>VM web : ip-10-0-2-15</p>

    Le nom d’hôte alterne entre 10.0.2.x (Sous-région eu-west-2a) et 10.0.3.x (Sous-région eu-west-2b) : le load balancer répartit les requêtes entre les deux VMs web.

  3. Ouvrez l’URL http://<LB_DNS> dans votre navigateur, en remplaçant <LB_DNS> par la valeur de la variable LB_DNS.

Remarque : si curl n’affiche rien, le nom DNS du load balancer n’est peut-être pas encore résolu : attendez une minute et relancez la boucle. Vérifiez aussi que les deux VMs backend sont à l’état UP (étape 6.1).

6.3 Comparer l’état Terraform et les ressources réelles

Section intitulée « 6.3 Comparer l’état Terraform et les ressources réelles »
  1. Listez les ressources de l’état :

    Terminal window
    terraform state list

    Les 24 ressources du lab s’affichent, ainsi que la data source data.outscale_image.ubuntu.

  2. Affichez le détail d’une VM web dans l’état :

    Terminal window
    terraform state show 'outscale_vm.web["a"]'

    Repérez vm_id, private_ip, image_id et subregion_name. Les guillemets simples autour du nom de la ressource empêchent bash d’interpréter les crochets.

  3. Affichez les mêmes VMs avec octl :

    Terminal window
    octl iaas vm list --tag-value architecte-lab09-vm-web-a,architecte-lab09-vm-web-b

    Les identifiants et les IP privées sont les mêmes que dans l’état Terraform. La colonne de l’IP publique est vide : les VMs web ne sont joignables que par le load balancer.

  1. Relancez le plan sans rien modifier :

    Terminal window
    terraform plan

    Terraform interroge l’API OUTSCALE pour relire chaque ressource de l’état (Refreshing state...), puis affiche :

    Terminal window
    No changes. Your infrastructure matches the configuration.

    Appliquer plusieurs fois la même configuration produit toujours la même infrastructure : c’est l’idempotence. Un terraform apply relancé par erreur ne crée pas de doublon.

7.2 Corriger une modification faite en dehors de Terraform

Section intitulée « 7.2 Corriger une modification faite en dehors de Terraform »

Une ressource gérée par Terraform peut être modifiée par un autre outil : Cockpit, octl ou un script. Vous simulez ici un renommage manuel du Subnet public.

  1. Renommez le Subnet public avec octl, en remplaçant la valeur de son tag Name :

    Terminal window
    SUBNET_ID=$(octl iaas subnet list --tag-value architecte-lab09-pub-net \
    -o text --jq '.SubnetId')
    octl iaas tag create --resource-id $SUBNET_ID \
    --key Name --value modifie-hors-terraform

    Dans Cockpit, le Subnet s’appelle désormais modifie-hors-terraform.

  2. Affichez le plan :

    Terminal window
    terraform plan
    • La section Objects have changed outside of Terraform signale la modification détectée en relisant le Subnet.
    • Le Subnet est marqué will be updated in-place, avec le symbole ~ : Terraform propose de remettre le tag Name à la valeur architecte-lab09-pub-net.
    • Le plan se termine par Plan: 0 to add, 1 to change, 0 to destroy.
  3. Appliquez la configuration, puis saisissez yes :

    Terminal window
    terraform apply

    Le Subnet retrouve son nom architecte-lab09-pub-net. La configuration reste la référence : toute modification manuelle d’un attribut qu’elle décrit est annulée au prochain terraform apply.

Important : Terraform ne détecte que les écarts sur les attributs décrits dans la configuration. Par exemple, une règle ajoutée à la main dans le Security Group architecte-lab09-sg-web n’apparaît dans aucun plan : la configuration décrit les règles qu’elle crée, pas l’absence d’autres règles. Pour une infrastructure gérée par Terraform, la règle d’équipe est de ne plus rien modifier à la main.

Certaines modifications ne peuvent pas être faites sur la ressource existante : Terraform doit supprimer la ressource, puis la recréer. Le plan l’indique, et c’est pourquoi on le lit toujours avant de l’appliquer.

  1. Dans le fichier variables.tf, remplacez l’IP range du Subnet b :

    10.0.3.0/24

    par :

    10.0.4.0/24
  2. Affichez le plan, sans l’appliquer :

    Terminal window
    terraform plan

    Lisez le plan :

    • outscale_subnet.web["b"] est marqué must be replaced, avec le symbole -/+ ;
    • la ligne ip_range porte la mention # forces replacement : l’IP range d’un Subnet ne peut pas être modifiée, il faut un nouveau Subnet ;
    • outscale_vm.web["b"] est aussi marquée must be replaced : sa ligne subnet_id porte la mention # forces replacement, car une VM ne peut pas changer de Subnet ;
    • le résumé annonce des ressources à supprimer (to destroy).

    Un changement d’une seule valeur dans un fichier supprime une VM. Ici, la VM b est sans état et l’application reste servie par la VM a pendant le remplacement ; avec une base de données, les données seraient perdues.

  3. Remettez la valeur d’origine 10.0.3.0/24 dans le fichier variables.tf.

  4. Vérifiez que la configuration correspond de nouveau à l’infrastructure :

    Terminal window
    terraform plan

    Le message No changes. Your infrastructure matches the configuration. s’affiche.

Conseil : en équipe, enregistrez le plan dans un fichier avec terraform plan -out=plan.tfplan, faites-le relire, puis appliquez exactement ce plan avec terraform apply plan.tfplan. Terraform refuse d’appliquer un plan enregistré si l’infrastructure a changé entre-temps.

Pour valider votre lab, vérifiez les points suivants :

  • terraform validate affiche Success! The configuration is valid.
  • terraform state list affiche les 24 ressources du lab et la data source data.outscale_image.ubuntu.
  • terraform plan affiche No changes. Your infrastructure matches the configuration.
  • octl iaas loadbalancer backends architecte-lab09-lb affiche deux VMs backend à l’état UP.
  • La boucle curl de l’étape 6.2 affiche des VMs web qui alternent entre les Sous-régions eu-west-2a et eu-west-2b.
  • Les VMs architecte-lab09-vm-web-a et architecte-lab09-vm-web-b n’ont pas d’IP publique.
  • Aucun fichier du projet ne contient votre access key ni votre Secret Key.

Quelques semaines après le lab, un collègue relance terraform plan sur la même configuration, sans avoir modifié aucun fichier. Le plan annonce le remplacement des deux VMs web.

Question : Pourquoi Terraform veut-il remplacer les VMs alors que personne n’a modifié la configuration ? Quel bloc de la configuration en est responsable ?

Question : Comment empêcher Terraform de remplacer les VMs dans ce cas ? Quel est l’inconvénient de votre solution ?

Pour observer le phénomène sans attendre une nouvelle publication d’OMI :

  1. Dans le fichier vms.tf, remplacez la valeur Ubuntu-22.04-* par Ubuntu-24.04-*, puis lancez terraform plan sans l’appliquer.

  2. Ajoutez le bloc suivant dans la ressource outscale_vm.web, juste avant la ligne depends_on, puis relancez terraform plan :

    lifecycle {
    ignore_changes = [image_id]
    }
  3. Remettez la valeur Ubuntu-22.04-* et supprimez le bloc lifecycle, puis vérifiez que terraform plan n’annonce aucun changement.

💡 Correction — L'OMI qui change toute seule

La data source data.outscale_image.ubuntu recherche à chaque exécution l’OMI Ubuntu 22.04 la plus récente (most_recent = true). OUTSCALE publie régulièrement de nouvelles versions des OMI officielles : dès qu’une nouvelle version est disponible, la data source renvoie un autre identifiant. Or l’attribut image_id d’une VM ne peut pas être modifié sur une VM existante : le plan affiche # forces replacement sur la ligne image_id, et propose de supprimer et de recréer les deux VMs.

À l’étape 1, le filtre Ubuntu-24.04-* produit exactement ce plan : les deux VMs sont marquées must be replaced.

Le bloc lifecycle { ignore_changes = [image_id] } demande à Terraform d’ignorer les écarts sur image_id pour les VMs existantes. À l’étape 2, le plan n’annonce plus le remplacement des VMs. L’inconvénient : les VMs existantes ne sont plus jamais mises à jour par ce biais. Seules les VMs nouvellement créées, par exemple une troisième VM web, utilisent la nouvelle OMI : les VMs d’un même niveau peuvent alors fonctionner avec des OMI différentes.

Il existe deux autres approches :

  • figer l’OMI : passer l’identifiant de l’OMI dans une variable, et le changer volontairement, après l’avoir testée ;
  • construire ses propres OMI : créer une OMI qui contient déjà Apache, PHP et l’application, et remplacer les VMs de façon planifiée à chaque nouvelle version de l’OMI. C’est l’objet du Lab 10, avec Packer.

Dans tous les cas, la règle est la même : un terraform apply ne se lance jamais sans avoir lu le plan.

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Les ressources de ce lab ne sont pas réutilisées dans les labs suivants. Conservez uniquement :

  • octl et son profil default ;
  • Terraform ;
  • le dossier ~/architecte-lab09, si vous souhaitez garder la configuration comme modèle. Supprimez-le sinon.

Toutes les ressources du lab ont été créées par Terraform : une seule commande les supprime, dans l’ordre inverse des dépendances.

  1. Afficher le plan de suppression :

    Terminal window
    terraform plan -destroy

    Le plan se termine par Plan: 0 to add, 0 to change, 24 to destroy. Chaque ressource est précédée du symbole -.

  2. Supprimer les ressources :

    Terminal window
    terraform destroy

    Vérifiez la liste des ressources, puis saisissez yes. Terraform supprime d’abord le load balancer et les VMs, puis le NAT Service, les routes et les Security Groups, et termine par les Subnets et le Net :

    Terminal window
    Destroy complete! Resources: 24 destroyed.
  3. Vérifier la suppression avec octl :

    Terminal window
    octl iaas net list --tag-value architecte-lab09-net
    octl iaas loadbalancer describe architecte-lab09-lb
    octl iaas publicip list --tag-value architecte-lab09-nat-ip

    Les commandes n’affichent plus aucune ressource.

  4. Vérifier l’état Terraform :

    Terminal window
    terraform state list

    La commande n’affiche rien : l’état est vide.

Remarque : si terraform destroy échoue sur un Security Group juste après la suppression du load balancer, attendez une minute, puis relancez terraform destroy : Terraform reprend là où il s’était arrêté et ne supprime que les ressources restantes.