Provision Local VMs with Terraform

Provision 3 Ubuntu VMs on VirtualBox using Terraform in a single command.

Introduction

Resume en 30 Secondes

Imaginez devoir configurer trois serveurs identiques pour un projet. Cliquer dans les menus et configurer chacun a la main est lent, source d'erreurs, et impossible a reproduire de maniere fiable.

Dans ce projet, vous allez ecrire une configuration Terraform qui provisionne 3 machines virtuelles Ubuntu sur Oracle VirtualBox en une seule commande.

Ce Que Vous Allez Construire

Un projet Terraform complet qui cree, connecte et detruit automatiquement des VMs Linux sur votre machine locale en utilisant VirtualBox comme hyperviseur.

A la fin de ce projet, vous aurez :

  • Une configuration Terraform modulaire avec provider, variables et outputs qui provisionne 3 VMs Ubuntu.
  • Un reseau host-only connectant toutes les VMs entre elles et avec votre machine hote.
  • La preuve que votre infrastructure est reproductible grace a un cycle complet destroy et recreate.
  • Secret Mission : Scaler votre infrastructure dynamiquement et generer un inventaire structure pret pour Ansible.

Y a-t-il des prerequis ?

Terraform, Oracle VirtualBox et un editeur de code (VS Code ou Cursor) doivent etre installes sur votre machine.

Une familiarite avec le terminal Windows et les concepts de base de l'Infrastructure as Code est recommandee.

Vérifier l'Environnement et le Réseau

Avant d'écrire la moindre ligne de configuration, vous devez vous assurer que vos outils sont bien accessibles depuis le terminal. Terraform et VBoxManage doivent tous deux répondre à vos commandes.

Vous allez également préparer le réseau host-only de VirtualBox. Ce réseau est indispensable pour que vos futures VMs puissent communiquer entre elles et avec votre machine.

Dans cette étape, préparez-vous à :
  • Confirmer que Terraform et VBoxManage sont accessibles dans le terminal.
  • Vérifier ou créer le réseau host-only de VirtualBox.
  • Créer le répertoire du projet terraform-vbox-infra.
Vérifier que Terraform et VBoxManage sont accessibles

Les deux outils sont des commandes en ligne. Pour que votre configuration Terraform fonctionne, les deux doivent être dans le PATH de votre système.

  • Appuyez sur Cmd+Espace (macOS) ou la touche Windows (Windows) pour ouvrir la barre de recherche.
  • Tapez PowerShell et appuyez sur Entrée pour ouvrir un terminal.
  • Vérifiez que Terraform est accessible en exécutant cette commande :
terraform version

✔️ Je vois un numéro de version

Terraform est bien installé et accessible. Passez à la vérification suivante.

ⓧ Commande introuvable

Terraform n'est pas dans votre PATH. Vérifiez que le dossier contenant l'exécutable terraform est ajouté à la variable d'environnement PATH de votre système.

Consultez la page d'installation officielle de Terraform pour réinstaller correctement, puis rouvrez votre terminal et réessayez.

  • Vérifiez que le CLI de VirtualBox est accessible en exécutant cette commande :
VBoxManage --version

✔️ Je vois un numéro de version

VBoxManage est prêt. Vous pouvez passer à la suite.

ⓧ Commande introuvable

VBoxManage n'est pas dans votre PATH. Sur Windows, VBoxManage se trouve dans le dossier d'installation de VirtualBox (typiquement C:\Program Files\Oracle\VirtualBox).

Ajoutez ce chemin à votre variable d'environnement PATH, puis fermez et rouvrez votre terminal et réessayez.

Qu'est-ce que VBoxManage ?

VBoxManage est l'outil en ligne de commande de VirtualBox. Il permet de créer, configurer et gérer des machines virtuelles sans passer par l'interface graphique.

Le provider Terraform que vous utiliserez dans ce projet communique avec VirtualBox via VBoxManage. C'est pour cela qu'il doit être accessible dans votre PATH.

Vérifier ou créer le réseau host-only

Vos VMs auront besoin d'un réseau pour communiquer entre elles et avec votre machine hôte. VirtualBox propose un type de réseau appelé host-only qui crée un réseau privé isolé.

  • Vérifiez si une interface host-only existe déjà en exécutant cette commande :
VBoxManage list hostonlyifs

✔️ Je vois une interface avec une IP en 192.168.56.x

  • Notez le nom de l'interface affiché. Sur Windows, il s'agit typiquement de VirtualBox Host-Only Ethernet Adapter.
  • Vérifiez que l'adresse IP est dans la plage 192.168.56.x. C'est la plage par défaut du réseau host-only.

Votre réseau host-only est prêt.

ⓧ Aucune interface listée

  • Créez une nouvelle interface host-only en exécutant cette commande :
VBoxManage hostonlyif create

Vous devriez voir un message confirmant la création, suivi du nom de la nouvelle interface.

  • Vérifiez que l'interface a bien été créée en exécutant à nouveau :
VBoxManage list hostonlyifs
  • Notez le nom de l'interface (typiquement VirtualBox Host-Only Ethernet Adapter sur Windows) et confirmez que l'IP est dans la plage 192.168.56.x.

Pourquoi un réseau host-only ?

Un réseau host-only crée un réseau privé entre votre machine physique (l'hôte) et les VMs. Les VMs peuvent communiquer entre elles et avec l'hôte, mais elles n'ont pas accès à Internet.

VirtualBox inclut un serveur DHCP intégré pour les réseaux host-only, activé par défaut. Ce serveur attribue automatiquement des adresses IP aux VMs dans la plage 192.168.56.x, sans configuration manuelle de votre part.

Créer le répertoire du projet

Votre environnement est vérifié. Il ne reste plus qu'à créer le dossier qui contiendra vos fichiers Terraform.

  • Déplacez-vous sur votre Bureau en exécutant cette commande :
cd ~/Desktop
  • Créez le dossier du projet et déplacez-vous dedans en exécutant ces commandes :
mkdir terraform-vbox-infra
cd terraform-vbox-infra
  • Confirmez que le dossier existe en exécutant :
ls

La sortie devrait être vide puisque le dossier vient d'être créé.

  • Appuyez sur Cmd+Espace (macOS) ou la touche Windows (Windows) pour ouvrir la barre de recherche.
  • Tapez le nom de votre éditeur de code (par exemple VS Code ou Cursor) et appuyez sur Entrée.
  • Cliquez sur File, puis Open Folder.
  • Sélectionnez le dossier terraform-vbox-infra sur votre Bureau, puis cliquez sur Select Folder.

Le dossier n'apparaît pas sur le Bureau ?

Vérifiez que vous avez bien exécuté cd ~/Desktop avant mkdir terraform-vbox-infra. Sans cette première commande, le dossier a pu être créé dans un autre emplacement.

Aidez-moi à retrouver mon dossier terraform-vbox-infra

Votre environnement est prêt et votre dossier de projet est ouvert dans l'éditeur. Dans la prochaine étape, vous écrirez la configuration Terraform qui provisionnera vos 3 machines virtuelles.

Écrire la Configuration Terraform

Votre environnement est vérifié et votre réseau host-only est en place. Il est temps d'écrire la configuration qui va provisionner vos machines virtuelles.

Terraform utilise des fichiers de configuration au format HCL pour décrire l'infrastructure souhaitée. Dans cette étape, vous allez créer trois fichiers qui définissent tout ce dont Terraform a besoin pour provisionner vos VMs.

Dans cette étape, préparez-vous à :
  • Déclarer le provider eran132/vbox et la ressource VM dans main.tf.
  • Définir les variables d'entrée dans variables.tf.
  • Configurer les outputs dans outputs.tf.
Créer main.tf avec le provider et les ressources VM

Le fichier main.tf est le cœur de votre configuration Terraform. Il déclare quel provider utiliser et quelles ressources créer.

  • Dans votre éditeur, créez un nouveau fichier nommé main.tf dans le dossier terraform-vbox-infra.
  • Déclarez le provider VirtualBox en ajoutant ce code :
# Declare le provider VirtualBox (eran132/vbox)
terraform {
  required_providers {
    virtualbox = {
      source  = "eran132/vbox"
      version = "2.1.1"
    }
  }
}

# Initialise le provider (aucune config requise)
provider "virtualbox" {}

Que fait ce code ?

  • Le bloc required_providers dit à Terraform de télécharger le provider eran132/vbox en version 2.1.1. Ce provider communique directement avec VBoxManage pour gérer vos VMs.
  • Le bloc provider "virtualbox" {} initialise le provider. Le bloc est vide car aucune configuration supplémentaire n'est nécessaire.

Pourquoi le nom local est "virtualbox" et pas "vbox" ?

Le nom local dans required_providers doit être virtualbox car tous les types de ressources utilisent le préfixe virtualbox_ (par exemple virtualbox_vm). Terraform associe automatiquement le nom local au préfixe des ressources.

Vous ne verrez pas de changement visible pour l'instant. Le prochain bloc de code ajoute la définition des VMs.

  • Définissez la ressource VM en ajoutant ce code à la suite dans main.tf, après le bloc provider :
# Cree var.vm_count VMs avec un reseau host-only
resource "virtualbox_vm" "node" {
  count  = var.vm_count
  name   = format("node-%02d", count.index + 1)
  image  = var.vm_image
  cpus   = var.vm_cpus
  memory = var.vm_memory

  # Connecte chaque VM au reseau host-only
  network_adapter {
    type           = "hostonly"
    host_interface = var.host_interface
  }
}

Que fait cette ressource ?

  • count = var.vm_count crée plusieurs VMs à partir d'une seule définition de ressource. La valeur par défaut sera 3.
  • format("node-%02d", count.index + 1) génère des noms numérotés : node-01, node-02, node-03.
  • Le bloc network_adapter connecte chaque VM au réseau host-only que vous avez vérifié à l'étape précédente.
  • Toutes les valeurs (var.vm_image, var.vm_cpus, var.vm_memory) sont des variables que vous définirez dans le fichier suivant.
  • Sauvegardez main.tf.
  • Vous ne verrez pas de résultat visible avant d'exécuter terraform init à l'étape suivante.

Erreur de syntaxe dans main.tf ?

  • Vérifiez que les accolades {} sont bien appariées. Chaque bloc ouvert doit être fermé.
  • Assurez-vous que les guillemets "" entourent les valeurs string comme "hostonly" et "2.1.1".
  • Vérifiez que le nom local du provider est bien virtualbox (pas vbox).

Mon fichier main.tf a une erreur de syntaxe, peux-tu m'aider à trouver le problème ?

Vérifiez le code complet de votre fichier avant de continuer.

✔️ C'est bon, j'ai tout !

Parfait. Vérifiez que main.tf est bien sauvegardé avant de passer au fichier suivant.

ⓧ Je veux vérifier le code complet

Voici le contenu complet de main.tf pour comparaison :

terraform {
  required_providers {
    virtualbox = {
      source  = "eran132/vbox"
      version = "2.1.1"
    }
  }
}

provider "virtualbox" {}

resource "virtualbox_vm" "node" {
  count  = var.vm_count
  name   = format("node-%02d", count.index + 1)
  image  = var.vm_image
  cpus   = var.vm_cpus
  memory = var.vm_memory

  network_adapter {
    type           = "hostonly"
    host_interface = var.host_interface
  }
}
Créer variables.tf avec les variables d'entrée

Plutôt que de coder en dur les valeurs dans la ressource VM, Terraform utilise des variables pour rendre la configuration flexible. Le fichier variables.tf centralise tous les paramètres configurables.

  • Créez un nouveau fichier nommé variables.tf dans le dossier terraform-vbox-infra.
  • Définissez les cinq variables d'entrée en ajoutant ce code :
# Nombre de VMs a provisionner
variable "vm_count" {
  description = "Nombre de VMs a creer"
  type        = number
  default     = 3
}

# Image systeme pour les VMs
variable "vm_image" {
  description = "URL de l image Vagrant box"
  type        = string
  default     = "https://app.vagrantup.com/ubuntu/boxes/bionic64/versions/20180903.0.0/providers/virtualbox.box"
}

# Ressources CPU par VM
variable "vm_cpus" {
  description = "Nombre de CPUs par VM"
  type        = number
  default     = 1
}

# Memoire allouee par VM
variable "vm_memory" {
  description = "Memoire par VM"
  type        = string
  default     = "512mib"
}

# Interface reseau host-only (nom Windows par defaut)
variable "host_interface" {
  description = "Nom de l interface reseau host-only"
  type        = string
  default     = "VirtualBox Host-Only Ethernet Adapter"
}

Que font ces variables ?

  • vm_count contrôle combien de VMs Terraform crée. La valeur par défaut est 3.
  • vm_image pointe vers une image Vagrant box Ubuntu 18.04. Terraform télécharge cette image automatiquement au premier déploiement.
  • vm_memory utilise le format "512mib" (sans espace). Ce format normalisé est requis par le provider à partir de la version 2.0.
  • host_interface correspond au nom exact de l'interface réseau host-only sur Windows : VirtualBox Host-Only Ethernet Adapter.

Pourquoi chaque variable a un default ?

Les valeurs default permettent d'exécuter terraform apply sans passer de paramètres. Vous pourrez les surcharger plus tard avec un fichier terraform.tfvars ou via la ligne de commande.

  • Sauvegardez variables.tf.
  • Vous ne verrez pas de résultat visible. Le fichier suivant complète la configuration.

Erreur sur l'URL de l'image ?

  • L'URL de l'image Vagrant doit être sur une seule ligne, sans retour à la ligne.
  • Vérifiez que la valeur de vm_memory est bien "512mib" sans espace entre le nombre et l'unité.

Mon fichier variables.tf ne fonctionne pas, peux-tu vérifier ma syntaxe ?

Vérifiez le code complet de votre fichier avant de continuer.

✔️ C'est bon, j'ai tout !

Parfait. Vérifiez que variables.tf est bien sauvegardé.

ⓧ Je veux vérifier le code complet

Voici le contenu complet de variables.tf pour comparaison :

variable "vm_count" {
  description = "Nombre de VMs a creer"
  type        = number
  default     = 3
}

variable "vm_image" {
  description = "URL de l image Vagrant box"
  type        = string
  default     = "https://app.vagrantup.com/ubuntu/boxes/bionic64/versions/20180903.0.0/providers/virtualbox.box"
}

variable "vm_cpus" {
  description = "Nombre de CPUs par VM"
  type        = number
  default     = 1
}

variable "vm_memory" {
  description = "Memoire par VM"
  type        = string
  default     = "512mib"
}

variable "host_interface" {
  description = "Nom de l interface reseau host-only"
  type        = string
  default     = "VirtualBox Host-Only Ethernet Adapter"
}
Créer outputs.tf

Après le déploiement, vous aurez besoin de connaître les noms et adresses IP de vos VMs. Les outputs Terraform affichent ces informations automatiquement à la fin de chaque terraform apply.

  • Créez un nouveau fichier nommé outputs.tf dans le dossier terraform-vbox-infra.
  • Définissez les deux outputs en ajoutant ce code :
# Liste des noms de VMs creees
output "vm_names" {
  description = "Noms des VMs creees"
  value       = virtualbox_vm.node[*].name
}

# Liste des adresses IP assignees par DHCP
output "vm_ips" {
  description = "Adresses IP des VMs"
  value       = virtualbox_vm.node[*].network_adapter.0.ipv4_address
}

Que font ces outputs ?

  • virtualbox_vm.node[*].name utilise l'expression splat [*] pour collecter le nom de chaque VM dans une liste.
  • network_adapter.0.ipv4_address récupère l'adresse IP assignée par le serveur DHCP de VirtualBox à la première carte réseau de chaque VM.
  • Sauvegardez outputs.tf.
  • Confirmez que les trois fichiers existent en exécutant cette commande dans votre terminal :
ls
  • Vous devriez voir main.tf, variables.tf et outputs.tf dans la sortie.

Les fichiers ne s'affichent pas ?

  • Vérifiez que votre terminal est bien dans le dossier terraform-vbox-infra. Exécutez pwd pour vérifier le répertoire courant.
  • Assurez-vous que chaque fichier a bien l'extension .tf et pas .tf.txt (Windows peut ajouter une extension cachée).

Mes fichiers Terraform ne s'affichent pas avec ls, peux-tu m'aider ?

Vérifiez le code complet de votre dernier fichier.

✔️ C'est bon, j'ai tout !

Parfait. Vérifiez que outputs.tf est bien sauvegardé.

ⓧ Je veux vérifier le code complet

Voici le contenu complet de outputs.tf pour comparaison :

output "vm_names" {
  description = "Noms des VMs creees"
  value       = virtualbox_vm.node[*].name
}

output "vm_ips" {
  description = "Adresses IP des VMs"
  value       = virtualbox_vm.node[*].network_adapter.0.ipv4_address
}

Vos trois fichiers de configuration sont prêts. Dans l'étape suivante, vous allez initialiser Terraform et déployer vos VMs en une seule commande.

Déployer l'Infrastructure

Vos fichiers de configuration sont en place. Terraform sait quel provider utiliser, quelles ressources créer, et quelles valeurs appliquer.

Il est temps de transformer cette configuration en infrastructure réelle. Terraform suit un cycle précis pour déployer : initialiser, planifier, puis appliquer.

Dans cette étape, préparez-vous à :
  • Initialiser Terraform et télécharger le provider VirtualBox.
  • Prévisualiser le plan de déploiement avant d'appliquer.
  • Appliquer la configuration pour créer les 3 VMs.
Initialiser Terraform

Avant de pouvoir créer quoi que ce soit, Terraform doit télécharger le provider déclaré dans votre configuration. C'est le rôle de la commande d'initialisation.

  • Initialisez Terraform en exécutant cette commande dans votre terminal :
terraform init
  • Vous devriez voir le message Terraform has been successfully initialized! dans le terminal.

Que fait terraform init ?

terraform init télécharge le provider eran132/vbox version 2.1.1 depuis le registre Terraform et l'installe dans un dossier .terraform.

Un fichier .terraform.lock.hcl est aussi créé pour verrouiller la version exacte du provider utilisé. Cela garantit que chaque membre d'une équipe utilise les mêmes versions.

Terraform init échoue ?

  • Vérifiez que vous êtes bien dans le dossier terraform-vbox-infra. Exécutez cd pour vérifier votre emplacement actuel.
  • Vérifiez votre connexion internet. Terraform a besoin de télécharger le provider depuis le registre en ligne.
  • Pourquoi terraform init échoue-t-il dans mon projet ?
Prévisualiser le plan

Terraform ne crée jamais de ressources sans vous montrer ce qu'il va faire. La commande terraform plan affiche un aperçu de tous les changements avant de les appliquer.

  • Prévisualisez les changements en exécutant cette commande :
terraform plan
  • En bas du plan, vous devriez voir la ligne Plan: 3 to add, 0 to change, 0 to destroy.

Comment lire le plan ?

Terraform compare votre configuration avec l'état actuel de l'infrastructure. Comme aucune ressource n'existe encore, les 3 VMs sont marquées comme "à créer".

Chaque ligne précédée de + représente un attribut d'une ressource à créer. Le résumé en bas confirme le nombre total de ressources à ajouter, modifier ou détruire.

Le plan affiche des erreurs ?

  • Vérifiez que VBoxManage est accessible en exécutant VBoxManage --version dans votre terminal.
  • Vérifiez la syntaxe de vos fichiers .tf. Terraform indique le fichier et la ligne exacte de chaque erreur dans le message.
  • Pourquoi terraform plan affiche-t-il des erreurs ?
Appliquer et créer les VMs

Le plan confirme que 3 VMs vont être créées. Lors du premier déploiement, Terraform télécharge l'image Vagrant Ubuntu (~600 Mo). Cette opération peut prendre quelques minutes.

  • Déployez votre infrastructure en exécutant cette commande :
terraform apply
  • Terraform affiche le plan et vous demande de confirmer. Tapez yes puis appuyez sur Entrée.
  • Attendez que Terraform crée les 3 VMs. Le premier apply prend plus de temps à cause du téléchargement de l'image.

Que se passe-t-il pendant l'apply ?

Terraform télécharge l'image Ubuntu bionic64 depuis Vagrant (~600 Mo). Ce téléchargement n'a lieu qu'au premier terraform apply. Les prochaines exécutions utiliseront l'image en cache.

VirtualBox crée ensuite chaque VM avec 1 CPU et 512 MiB de RAM, puis les connecte au réseau host-only. Terraform enregistre l'état de chaque ressource dans un fichier terraform.tfstate.

  • Vous devriez voir le message Apply complete! Resources: 3 added, 0 changed, 0 destroyed.
  • Juste en dessous, les outputs affichent les noms (node-01, node-02, node-03) et les adresses IP de vos 3 VMs.

L'apply échoue ou reste bloqué ?

  • Si le téléchargement de l'image échoue, vérifiez votre connexion internet et relancez terraform apply.
  • Si VirtualBox affiche une erreur, assurez-vous qu'aucune VM existante ne porte déjà les noms node-01, node-02, ou node-03.
  • Vérifiez que VirtualBox est bien lancé sur votre machine. Le provider communique avec VirtualBox via VBoxManage.
  • Pourquoi terraform apply échoue-t-il lors de la création des VMs ?

Vos 3 VMs tournent sur VirtualBox. Dans l'étape suivante, vous allez vérifier qu'elles communiquent entre elles et avec votre machine.

Vérifier l'Infrastructure

Vos 3 VMs Ubuntu tournent sur VirtualBox grâce à une seule commande terraform apply. Déployer une infrastructure n'est cependant que la moitié du travail.

Dans cette étape, vous allez confirmer que chaque VM est active, joignable sur le réseau, et correctement suivie par Terraform. C'est une habitude essentielle en Infrastructure as Code : toujours valider ce que l'on déploie.

Dans cette étape, préparez-vous à :
  • Confirmer que les 3 VMs sont en cours d'exécution dans VirtualBox.
  • Tester la connectivité réseau entre votre machine hôte et chaque VM.
  • Inspecter l'état Terraform pour vérifier les ressources gérées.
Vérifier les VMs dans VirtualBox

Votre terminal a affiché les outputs après terraform apply, mais ce sont les outputs de Terraform. Vous allez maintenant interroger VirtualBox directement pour confirmer que les VMs existent bien côté hyperviseur.

  • Listez les VMs actives en exécutant cette commande dans votre terminal :
VBoxManage list runningvms

Vous devriez voir 3 lignes, une par VM. Chaque ligne affiche le nom de la VM entre guillemets suivi de son identifiant unique (UUID) entre accolades.

Qu'est-ce que VBoxManage ?

VBoxManage est le CLI de VirtualBox. Il permet de gérer toutes les VMs depuis le terminal sans ouvrir l'interface graphique.

Le provider Terraform eran132/vbox utilise aussi VBoxManage en coulisses pour créer et configurer vos VMs.

Aucune VM listée ?

Vérifiez que vous avez bien exécuté terraform apply dans l'étape précédente et que le message de confirmation indiquait 3 ressources ajoutées.

Vérifiez également que VBoxManage est bien dans votre PATH en exécutant VBoxManage --version.

Pourquoi est-ce que VBoxManage ne liste aucune VM en cours d'exécution ?

Vous pouvez aussi vérifier visuellement. VirtualBox dispose d'une interface graphique qui affiche toutes vos VMs avec leur statut.

  • Appuyez sur Cmd+Espace (macOS) ou la touche Windows (Windows) pour ouvrir votre barre de recherche.
  • Tapez VirtualBox et appuyez sur Entrée pour ouvrir VirtualBox Manager.

Dans le panneau de gauche, vous devriez voir node-01, node-02 et node-03 avec un indicateur vert signalant qu'elles sont en cours d'exécution.

Vérifier la connectivité réseau

Les VMs tournent, mais peuvent-elles communiquer avec votre machine hôte ? Le réseau host-only que vous avez configuré attribue une adresse IP à chaque VM dans la plage 192.168.56.x. Vous allez le vérifier avec ping.

  • Récupérez les adresses IP de vos VMs en exécutant cette commande :
terraform output vm_ips

Vous devriez voir une liste de 3 adresses IP, une par VM. Notez ces adresses pour l'étape suivante.

Pourquoi utiliser terraform output ?

La commande terraform output lit les valeurs directement depuis le fichier d'état Terraform (terraform.tfstate). C'est la façon recommandée de récupérer les informations sur votre infrastructure, plutôt que de les chercher manuellement dans VirtualBox.

  • Testez la connectivité vers votre première VM en exécutant cette commande :
ping [[VM_IP="adresse IP de votre premiere VM"]]

Vous devriez voir des réponses avec le temps de latence en millisecondes. Cela confirme que votre machine hôte peut communiquer avec la VM.

  • Répétez la commande ping avec les adresses IP des deux autres VMs pour confirmer que les 3 répondent.

Le ping ne reçoit aucune réponse ?

Vérifiez que vous utilisez bien une adresse IP affichée par terraform output vm_ips. Une faute de frappe dans l'adresse empêchera la connexion.

Si le pare-feu Windows bloque la requête, essayez de l'exécuter dans un terminal PowerShell lancé en tant qu'administrateur.

Pourquoi est-ce que mes VMs VirtualBox ne répondent pas au ping ?

Inspecter l'état Terraform

Terraform maintient un fichier d'état (terraform.tfstate) qui associe chaque ressource déclarée dans votre code à la ressource réelle créée sur l'hyperviseur. C'est grâce à ce fichier que Terraform sait quoi modifier, ajouter ou supprimer lors du prochain apply.

  • Affichez les ressources suivies par Terraform en exécutant cette commande :
terraform state list

Vous devriez voir 3 ressources listées :

virtualbox_vm.node[0]
virtualbox_vm.node[1]
virtualbox_vm.node[2]

Que signifie cette sortie ?

Chaque ligne correspond à une instance de la ressource virtualbox_vm.node déclarée dans main.tf. L'index entre crochets ([0], [1], [2]) vient du count = 3 dans votre configuration.

Ce lien entre le code et les ressources réelles est le cœur de l'Infrastructure as Code. Terraform ne crée pas des VMs "en aveugle". Il sait exactement quelles ressources existent et les compare à votre configuration à chaque exécution.

Moins de 3 ressources listées ?

Assurez-vous d'être dans le dossier terraform-vbox-infra qui contient votre fichier terraform.tfstate. Terraform lit l'état depuis le répertoire courant.

Pourquoi terraform state list affiche moins de ressources que prévu ?

Vos 3 VMs sont vérifiées : actives dans VirtualBox, joignables par le réseau, et correctement suivies par Terraform. Dans la prochaine étape, vous allez prouver la puissance de l'IaC en détruisant puis recréant toute cette infrastructure en quelques commandes.

Le Cycle IaC — Destroy et Recreate

Dans l'etape precedente, vous avez verifie que vos 3 VMs sont actives et connectees au reseau host-only. Votre infrastructure Terraform fonctionne.

La vraie puissance de l'Infrastructure as Code se revele quand on detruit tout et qu'on reconstruit a l'identique. Dans cette etape, vous allez prouver que votre configuration est reproductible.

In this step, get ready to:
  • Detruire les 3 VMs avec terraform destroy.
  • Recreer l'infrastructure identique avec terraform apply et prouver la reproductibilite.
Detruire l'infrastructure

La commande terraform destroy lit le fichier terraform.tfstate et supprime chaque ressource que Terraform gere. C'est l'inverse exact de terraform apply.

  • Detruisez les 3 VMs en executant cette commande :
terraform destroy
  • Terraform affiche un plan de destruction listant les 3 ressources a supprimer. Tapez yes et appuyez sur Enter pour confirmer.

Que fait terraform destroy ?

Terraform lit le fichier terraform.tfstate pour identifier chaque ressource qu'il gere. Il contacte ensuite VBoxManage pour eteindre et supprimer chaque VM une par une.

Une fois termine, le fichier d'etat est vide. Les VMs n'existent plus sur votre machine.

  • Vous devriez voir un message se terminant par Destroy complete! Resources: 3 destroyed.
  • Confirmez que les VMs ont disparu en executant cette commande :
VBoxManage list runningvms

La commande ne retourne aucun resultat. Aucune VM n'est en cours d'execution.

La destruction a echoue ?

Verifiez que vous etes bien dans le dossier terraform-vbox-infra qui contient vos fichiers .tf et le fichier terraform.tfstate.

Si une VM est bloquee, ouvrez VirtualBox Manager et arretez-la manuellement via clic droit puis Close et Power Off. Relancez ensuite terraform destroy.

Pourquoi terraform destroy n'arrive pas a supprimer mes VMs ?

Recreer l'infrastructure depuis zero

Votre infrastructure a completement disparu. Le fichier d'etat est vide, les VMs sont supprimees.

Lancez maintenant la meme commande terraform apply que vous avez utilisee precedemment. Si l'IaC fonctionne, vous devriez obtenir une infrastructure identique a celle que vous venez de detruire.

  • Recreez les 3 VMs en executant cette commande :
terraform apply
  • Terraform affiche un plan avec 3 ressources a creer. Tapez yes et appuyez sur Enter pour confirmer.

Pourquoi c'est plus rapide cette fois ?

L'image Vagrant (~600 Mo) a ete telechargee lors du premier terraform apply et mise en cache localement. Terraform reutilise ce cache pour creer les nouvelles VMs sans retelecharger l'image.

  • Vous devriez voir un message confirmant que 3 ressources ont ete ajoutees, suivi des outputs avec les noms et IPs des VMs.
  • Verifiez que les VMs sont bien en cours d'execution en executant cette commande :
VBoxManage list runningvms

Vous devriez voir 3 VMs listees : node-01, node-02 et node-03.

C'est la preuve IaC : votre infrastructure est entierement reproductible a partir du code.

Les VMs ne se recreent pas ?

Verifiez que le reseau host-only existe toujours en executant VBoxManage list hostonlyifs. Si aucune interface n'est listee, recreez-en une avec VBoxManage hostonlyif create.

Verifiez aussi que le nom de l'interface dans variables.tf correspond exactement a celui affiche par VBoxManage list hostonlyifs.

Pourquoi terraform apply echoue quand je recree mes VMs ?

Secret mission

Scaler et inventorier l'infrastructure

Votre infrastructure de 3 VMs fonctionne parfaitement. Et si vous pouviez la scaler sans tout reconstruire ? Ajoutez une 4e VM en modifiant une seule variable, puis generez un inventaire structure pret pour Ansible.

Clean Up Your Resources

Clean Up Your Resources

Ce projet tourne entierement en local sur votre machine. Il n'y a aucun cout cloud associe. Decidez si vous souhaitez garder vos ressources actives, les mettre en pause, ou les supprimer.

Ressources que vous avez utilisees :

  • 4 VMs VirtualBox (node-01, node-02, node-03, node-04) tournant localement sur votre machine.
  • Dossier de projet terraform-vbox-infra sur votre Bureau contenant les fichiers de configuration Terraform (main.tf, variables.tf, outputs.tf, terraform.tfvars).

Keep everything running

Aucune action necessaire. Choisissez cette option si vous comptez continuer a travailler avec vos VMs.

  • Vos 4 VMs restent actives en arriere-plan. Chaque VM utilise 512 Mo de RAM et 1 CPU.
  • Cette configuration est utile si vous prevoyez de poursuivre avec un projet Ansible ou HAProxy par la suite.
  • Pour verifier que vos VMs tournent toujours, executez VBoxManage list runningvms dans votre terminal.

Pause - I'll come back to this later

Sauvegardez l'etat de chaque VM pour liberer la RAM et le CPU sans perdre votre progression. Vous pourrez les redemarrer plus tard.

  • Sauvegardez l'etat de chaque VM en executant ces commandes dans votre terminal :
VBoxManage controlvm node-01 savestate
VBoxManage controlvm node-02 savestate
VBoxManage controlvm node-03 savestate
VBoxManage controlvm node-04 savestate
  • Verifiez qu'aucune VM n'est en cours d'execution en executant :
VBoxManage list runningvms

La commande ne devrait retourner aucun resultat. Vos VMs sont sauvegardees et pretes a etre relancees avec VBoxManage startvm quand vous le souhaitez.

Delete - I don't want to use this again

Supprimez toutes les VMs et les fichiers du projet pour liberer completement les ressources de votre machine.

  • Ouvrez votre terminal et naviguez dans le dossier terraform-vbox-infra sur votre Bureau.
  • Detruisez toutes les VMs en executant :
terraform destroy
  • Confirmez avec yes lorsque Terraform vous le demande.
  • Verifiez qu'aucune VM ne tourne en executant :
VBoxManage list runningvms

La commande ne devrait retourner aucun resultat.

  • Supprimez le dossier du projet. Sur Windows, executez :
cd ~\Desktop
rmdir /s /q terraform-vbox-infra
  • Sur macOS ou Linux, executez :
cd ~/Desktop
rm -rf terraform-vbox-infra

Toutes les ressources du projet sont supprimees.

That's a Wrap!

That's a Wrap!

Nice work! You just built a complete Terraform configuration that provisions and destroys an entire infrastructure of Ubuntu VMs on VirtualBox with a single command.

You've learned how to:

  • Written a modular Terraform configuration with a provider, variables, and outputs to provision 3 VMs in a single command.
  • Configured a host-only network and verified connectivity between VMs and your host machine using ping.
  • Demonstrated the full Infrastructure as Code lifecycle: terraform plan, terraform apply, terraform destroy, and a full recreate proving your infrastructure is reproducible.
  • (Secret Mission) Scaled your infrastructure dynamically with terraform.tfvars and generated a structured inventory ready for Ansible.

Ready to quiz yourself?