Maîtrisez Vagrant pour vos environnements

Ce guide vous permet de créer votre première VM reproductible en 10 minutes avec Vagrant. Vous apprendrez à écrire un Vagrantfile, démarrer une machine virtuelle et la configurer automatiquement. Vagrant est l’outil idéal pour les équipes DevOps qui veulent des environnements de développement identiques pour tous les développeurs.

Ce que vous allez apprendre

Installer Vagrant sur Linux, Windows ou macOS
Créer et gérer des VMs avec les commandes essentielles
Écrire un Vagrantfile pour personnaliser réseau, ressources et provisionnement
Utiliser le multi-machines pour simuler des architectures complexes

Prérequis : un hyperviseur installé (VirtualBox 7.x recommandé) et 10 minutes.

Qu’est-ce que Vagrant ?

Vagrant est un outil open source créé par HashiCorp qui automatise la création et la configuration de machines virtuelles. Pensez-y comme un “Dockerfile pour VMs” : vous décrivez votre environnement dans un fichier texte (le Vagrantfile), et Vagrant crée une VM identique à chaque fois.

Aspect	Sans Vagrant	Avec Vagrant
Création d’une VM	Cliquer dans l’interface graphique, configurer manuellement	Une commande : `vagrant up`
Reproductibilité	”Ça marche sur ma machine”	Environnement identique pour tous
Documentation	Instructions textuelles à suivre	Le Vagrantfile EST la documentation
Versioning	Impossible	Vagrantfile versionné avec Git

Petit historique

Vagrant a été créé en 2010 par Mitchell Hashimoto, alors étudiant en informatique, dans le but de résoudre un problème que beaucoup de développeurs rencontrent : les fameux “ça marche pas !”. Il voulait un outil capable de rendre les environnements de développement reproductibles et uniformes, quel que soit l’ordinateur utilisé.

Initialement, Vagrant s’appuyait uniquement sur VirtualBox comme fournisseur de machines virtuelles. Ce choix a permis une adoption rapide grâce à la gratuité et à la popularité de VirtualBox. Peu de temps après, HashiCorp, la société derrière Vagrant, a été fondée pour poursuivre le développement et intégrer davantage de fournisseurs comme VMware, Docker, ou encore des services cloud tels qu’AWS.

Au fil des années, Vagrant a évolué pour inclure des fonctionnalités avancées comme le provisionnement avec des outils tels que Ansible, Chef, ou Puppet, permettant de configurer automatiquement les machines virtuelles après leur création. Aujourd’hui, Vagrant reste un incontournable pour les développeurs et les équipes DevOps, grâce à son approche orientée infrastructure as code.

Comment fonctionne Vagrant ?

À première vue, Vagrant semble magique : une seule commande et vous avez une machine virtuelle fonctionnelle. Mais voyons ce qui se passe réellement sous le capot. Spoiler : ce n’est pas de la magie, mais une ingénieuse combinaison de concepts bien pensés. Voici les bases.

Le fonctionnement de Vagrant repose sur un fichier clé : le Vagrantfile. C’est un fichier de configuration écrit en Ruby (mais pas besoin de connaître ce langage pour l’utiliser). Il définit tout ce dont Vagrant a besoin pour créer et gérer votre environnement. Voici quelques exemples de ce qu’on y configure :

La box : une image système de base, comme generic/ubuntu2204
Le provider : l’hyperviseur (VirtualBox, libvirt, Docker)
Le provisionnement : les scripts ou outils pour configurer la VM (Ansible, Shell, Chef, Puppet)

Voici un exemple minimal de Vagrantfile :

Vagrant.configure("2") do |config|
  config.vm.box = "generic/ubuntu2204"
end

Avec ces 3 lignes, Vagrant télécharge automatiquement une image Ubuntu 22.04 et crée une VM basée dessus. Le chiffre "2" indique la version du format de configuration Vagrant (la version actuelle).

Une box, c’est une image préconfigurée d’un système d’exploitation. Pensez-y comme un point de départ. Vous pouvez choisir parmi des centaines de boxes disponibles sur le Vagrant Cloud ou en créer une personnalisée.

Par exemple, pour lancer une box Ubuntu officielle :

vagrant init generic/ubuntu2204
vagrant up

Que fait cette commande ? vagrant init génère un Vagrantfile minimal. vagrant up télécharge la box si nécessaire, crée la VM et la démarre. En quelques minutes, vous avez un environnement Ubuntu 22.04 fonctionnel.

Vagrant ne crée pas directement les machines virtuelles. Il s’appuie sur des fournisseurs (ou “providers”) comme :

VirtualBox : parfait pour un usage local.
Libvirt : pour des environnements KVM/QEMU.
Docker : idéal pour des environnements légers et rapides.
AWS ou Azure : pour des environnements cloud.

Le fournisseur est défini dans le Vagrantfile, mais vous pouvez aussi en changer via des commandes spécifiques.

Une fois la machine virtuelle en place, le provisionnement entre en jeu. C’est ici que vous automatisez l’installation des logiciels et des configurations nécessaires. Vagrant supporte plusieurs outils de provisionnement, comme :

Des scripts Shell (simples et efficaces) :

config.vm.provision "shell", inline: "sudo apt-get update && sudo apt-get install -y nginx"

Des outils avancés comme Ansible, Chef, ou Puppet.

L’avantage ? Vous gagnez du temps et limitez les erreurs. Une seule configuration suffit pour que tout fonctionne chez tout le monde.

Pour interagir avec vos environnements, Vagrant propose une série de commandes simples mais puissantes :*

vagrant init : initialise un projet Vagrant et crée un Vagrantfile.
vagrant up : démarre l’environnement.
vagrant halt : arrête la machine virtuelle.
vagrant destroy : supprime l’environnement.
vagrant ssh : se connecter à la machine virtuelle via SSH.

Quand utiliser Vagrant ?

Vagrant est l’outil idéal pour de nombreux cas de figure où des environnements reproductibles et faciles à gérer sont nécessaires. Voici les principales situations où il brille :

Créer des environnements de développement homogènes : Assurez que toute votre équipe travaille dans des conditions identiques, peu importe le système d’exploitation ou la configuration de chaque machine. Fini les “ça marche chez moi, pas chez toi”.
Tester dans des environnements variés : Besoin de tester une application sur plusieurs systèmes d’exploitation ou configurations ? Avec Vagrant, vous pouvez basculer entre Ubuntu, CentOS ou Windows sans effort, directement sur votre poste.
Automatiser les tests dans les pipelines CI/CD : Intégrez Vagrant dans vos pipelines d’intégration et de livraison continues. Il crée des environnements propres pour chaque build, garantissant des tests fiables avant déploiement.
Former et enseigner plus facilement : Fournissez des machines virtuelles préconfigurées aux étudiants ou stagiaires. Cela leur permet de se concentrer sur l’apprentissage, sans perdre de temps sur les installations ou configurations.
Partager des environnements avec l’équipe : Distribuez simplement un Vagrantfile pour que chaque développeur puisse reproduire exactement le même environnement. Un gros gain pour la collaboration en équipe.
Prototyper et expérimenter sans risque : Testez de nouvelles technologies, configurations ou architectures en créant rapidement des environnements jetables, sans impacter votre système principal.

En résumé, utilisez Vagrant dès que vous avez besoin de flexibilité, d’homogénéité et d’automatisation dans la gestion de vos environnements. C’est un vrai couteau suisse pour les développeurs et les équipes DevOps.

Comment installer Vagrant ?

Vagrant fonctionne sur la plupart des systèmes d’exploitation dont Linux, MacOs et Windows.

Installation de Vagrant sur Linux

Je ne vais documenter que l’installation de Vagrant sur une distribution de la famille Debian (Ubuntu, kali, Pop OS) :

# Pour un debian/ubuntu
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [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 vagrant
# Pouroùn redhat/oraclelinux/centos
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo yum -y install vagrant

Si vous ne maitrisez pas le gestionnaire de paquets apt, je vous recommande de lire mon guide sur apt pour mieux comprendre son fonctionnement.

Installation de libvirt (KVM)

Libvirt est une bibliothèque open-source et un ensemble d’outils de gestion pour la virtualisation. Il fournit une interface de programmation (API) pour gérer des outils de virtualisation, telles que KVM, QEMU, Xen, VirtualBox et d’autres. Ma préférence va bien sûr à l’utilisation de KVM et QEMU car plus rapide que les autres solutions pourtant plus populaires comme VirtualBox ou vmWare Player.

Je préfère utiliser libvirt avec QEMU et KVM, sur un serveur de la famille Debian :

sudo apt update
sudo apt install build-dep qemu-kvm libvirt-daemon-system libguestfs-tools ksmtuned libvirt-clients libxslt-dev libxml2-dev libvirt-dev zlib1g-dev ruby-dev ruby-libvirt ebtables
sudo usermod -aG libvirt $USER
vagrant plugin install vagrant-libvirt

Si vous n’êtes pas un pro de la commande virsh je vous conseille d’installer cockpit.

sudo apt update
sudo apt install cockpit cockpit-machines

Ensuite pour gérer vos vm cliquez sur ce lien http://localhost:9090. Pour vous connecter, entrez votre user / mdp. La gestion des machines virtuelles se retrouve dans la section du même nom.

cockpit machines vagrant

Installation de Vagrant sur Windows

Pour installer Vagrant sur une machine Windows, commencez par télécharger l’installeur Windows depuis le site web officiel. Ensuite exécutez le et suivez les étapes d’installation. Une fois l’installation terminée, ouvrez une fenêtre de terminal (par exemple, PowerShell ou CMD) pour vérifier que tout fonctionne comme attendu et exécutez la commande vagrant --version.

Installation de vagrant sur MacOS

Sur MacOS, j’ai rédigé un billet.

Premiers tours de roue

Pour vérifier que tout fonctionne, il suffit de lancer le provisionnement de votre première VM :

vagrant box add generic/ubuntu2204
vagrant init generic/ubuntu2204
vagrant up
vagrant ssh

Explication de chaque commande :

Commande	Description
`vagrant box add`	Télécharge l’image système (box) depuis Vagrant Cloud
`vagrant init`	Génère le fichier `Vagrantfile` de configuration
`vagrant up`	Crée et démarre la VM
`vagrant ssh`	Se connecte à la VM via SSH

Pour éviter de définir à chaque fois votre hyperviseur, vous pouvez ajouter ceci à votre .bashrc:

export VAGRANT_DEFAULT_PROVIDER=libvirt

Vérification : Après avoir ajouté cette ligne, relancez votre terminal et vérifiez avec echo $VAGRANT_DEFAULT_PROVIDER.

Les commandes essentielles que vous utiliserez au quotidien :

Commande	Description
`vagrant up`	Crée et démarre la VM
`vagrant halt`	Arrête la VM proprement
`vagrant destroy -f`	Détruit la VM
`vagrant ssh`	Connexion SSH à la VM
`vagrant status`	Affiche l’état de la VM
`vagrant provision`	Relance le provisionnement

Le fichier de déclaration Vagrantfile

Le Vagrantfile est le cœur de votre configuration Vagrant. C’est un fichier texte écrit dans un DSL (Domain Specific Language) basé sur Ruby. Pas d’inquiétude : vous n’avez pas besoin de connaître Ruby pour l’écrire.

Structure de base

Un Vagrantfile commence toujours par cette structure :

Vagrant.configure("2") do |config|
  # Votre configuration ici
end

Le "2" indique la version du format de configuration. Toutes les configurations se font à l’intérieur de ce bloc.

Vagrant.configure("2") do |config|
  config.vm.box = "generic/ubuntu2204"
end

Ce Vagrantfile minimal indique à Vagrant d’utiliser la box generic/ubuntu2204 (Ubuntu 22.04 LTS). Le "2" spécifie la version du format de configuration Vagrant.

À partir de là, on peut configurer plus finement la VM avec différentes sections :

Section	Description
`config.vm.box`	L’image système à utiliser
`config.vm.hostname`	Le nom d’hôte de la VM
`config.vm.network`	Configuration réseau (privé, public, port forwarding)
`config.vm.provider`	Options spécifiques à l’hyperviseur (RAM, CPU)
`config.vm.provision`	Scripts de configuration post-boot
`config.vm.synced_folder`	Dossiers partagés entre l’hôte et la VM

Un Vagrantfile complet

Voici un exemple de Vagrantfile complet et commenté, testé avec libvirt :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  # Box Ubuntu 22.04 LTS (compatible VirtualBox et libvirt)
  config.vm.box = "generic/ubuntu2204"

  # Nom d'hôte de la VM
  config.vm.hostname = "dev-server"

  # Réseau privé avec IP statique
  config.vm.network "private_network", ip: "192.168.56.10"

  # Dossier synchronisé (désactivé ici pour éviter les dépendances)
  config.vm.synced_folder ".", "/vagrant", disabled: false

  # Configuration pour libvirt
  config.vm.provider "libvirt" do |libvirt|
    libvirt.memory = 1024
    libvirt.cpus = 1
  end

  # Configuration pour VirtualBox
  config.vm.provider "virtualbox" do |vb|
    vb.memory = "1024"
    vb.cpus = 1
    vb.name = "dev-server-vm"
  end

  # Provisionnement avec Shell
  config.vm.provision "shell", inline: <<-SHELL
    apt-get update -qq
    apt-get install -y htop curl
  SHELL
end

Vérification : Testez la syntaxe avec vagrant validate avant de lancer vagrant up.

Configuration réseau

Vagrant propose plusieurs types de configuration réseau selon vos besoins :

Type	Usage	Exemple
private_network	Communication entre VMs et avec l’hôte	Tests multi-machines
public_network	La VM est accessible comme un PC du réseau	Démonstrations
forwarded_port	Redirige un port de l’hôte vers la VM	Accès web local

# Réseau privé avec IP statique
config.vm.network "private_network", ip: "192.168.56.10"

# Réseau privé avec DHCP
config.vm.network "private_network", type: "dhcp"

# Redirection de port : localhost:8080 → VM:80
config.vm.network "forwarded_port", guest: 80, host: 8080

Configuration du provider

Chaque hyperviseur a ses propres options de configuration. Voici les principales pour libvirt et VirtualBox :

libvirt
VirtualBox

config.vm.provider "libvirt" do |libvirt|
  libvirt.memory = 2048      # RAM en Mo
  libvirt.cpus = 2           # Nombre de vCPUs
  libvirt.nested = true      # Virtualisation imbriquée
  libvirt.driver = "kvm"     # Driver (kvm par défaut)
end

config.vm.provider "virtualbox" do |vb|
  vb.memory = "2048"          # RAM en Mo
  vb.cpus = 2                 # Nombre de vCPUs
  vb.name = "ma-vm"           # Nom dans VirtualBox
  vb.gui = false              # Afficher la fenêtre VM
end

Provisionnement

Le provisionnement permet d’automatiser la configuration de la VM après son démarrage. C’est ici que vous installez les logiciels, configurez les services et personnalisez l’environnement.

Vagrant supporte plusieurs types de provisioners :

Provisioner	Utilisation
shell	Scripts Bash simples, idéal pour démarrer
ansible	Playbooks Ansible pour des configurations complexes
puppet	Manifestes Puppet
chef	Recettes Chef
file	Copie de fichiers vers la VM

config.vm.provision "shell", inline: <<-SHELL
  apt-get update -qq
  apt-get install -y nginx
  systemctl enable nginx
SHELL

config.vm.provision "ansible" do |ansible|
  ansible.playbook = "playbook.yml"
  ansible.verbose = "v"
end

config.vm.provision "file",
  source: "./config/nginx.conf",
  destination: "/tmp/nginx.conf"

Multi-machines

Vagrant permet de définir plusieurs VMs dans un seul Vagrantfile. C’est idéal pour simuler des architectures complexes (web + base de données, cluster Kubernetes, etc.).

Vagrant.configure("2") do |config|
  config.vm.box = "generic/ubuntu2204"

  config.vm.provider "libvirt" do |libvirt|
    libvirt.memory = 512
    libvirt.cpus = 1
  end

  # Serveur web
  config.vm.define "web" do |web|
    web.vm.hostname = "web-server"
    web.vm.network "private_network", ip: "192.168.56.10"
    web.vm.provision "shell", inline: "apt-get update && apt-get install -y nginx"
  end

  # Base de données
  config.vm.define "db" do |db|
    db.vm.hostname = "db-server"
    db.vm.network "private_network", ip: "192.168.56.11"
    db.vm.provision "shell", inline: "apt-get update && apt-get install -y postgresql"
  end
end

Commandes multi-machines :

vagrant up           # Démarre toutes les VMs
vagrant up web       # Démarre uniquement la VM "web"
vagrant ssh db       # Se connecte à la VM "db"
vagrant destroy -f   # Détruit toutes les VMs

Boucle pour créer plusieurs machines identiques

Pour créer plusieurs machines avec une configuration similaire, utilisez une boucle Ruby :

(1..3).each do |i|
  config.vm.define "node-#{i}" do |node|
    node.vm.hostname = "node-#{i}"
    node.vm.network "private_network", ip: "192.168.56.#{10 + i}"
    node.vm.provision "shell", inline: "echo 'Nœud #{i} configuré'"
  end
end

Ce code crée 3 VMs : node-1, node-2, node-3 avec les IPs 192.168.56.11 à 192.168.56.13.

Commandes avancées

Gestion des erreurs

Dans la phase de développement d’un playbook Ansible, il peut être utile de conserver la VM et ce même en cas d’erreur à des fins de debug. Pour cela, il suffit d’utiliser l’option --no-destroy-on-error :

vagrant up --no-destroy-on-error

Vous pouvez relancer le playbook avec l’option ci-après.

Relancer le provisioning sur une VM déjà instanciée

Pour relancer le playbook sur une VM déjà démarrée, il suffit d’utiliser l’option --provision:

vagrant up --provision

Ajouter votre VM dans votre fichier /etc/hosts

Vagrant dispose de pas mal de plugins dont un des plus intéressants est hostsupdater. Pour l’installer, il suffit de taper la commande suivante :

vagrant plugin install vagrant-hostsupdater

vagrant push

La commande vagrant push permet d’invoquer une commande shell ou un script arbitraire dans le cadre d’un push.

Par exemple, vous pouvez lancer des playbooks en prenant l’inventaire généré dans la partie provisioning :

  config.push.define "local-exec" do |push|
    push.inline = <<-SCRIPT
      ansible-playbook -i .vagrant/provisioners/ansible/inventory/vagrant_ansible_inventory master.yml
      ansible-playbook -i .vagrant/provisioners/ansible/inventory/vagrant_ansible_inventory slave.yml
    SCRIPT
  end

Sur les vagrantfile

Boucle sur plusieurs machines

(1..3).each do |i|
  config.vm.define "node-#{i}" do |node|
    node.vm.provision "shell",
      inline: "echo hello from node #{i}"
  end
end

Lancer un playbook sur vos vms lors de leur création

Pour permettre d’utiliser plus facilement vos VMs, vous pouvez lancer un playbook pour autoriser la connexion par mots de passe, copier votre propre clé ssh. Tout est envisageable.

---
- hosts: all
  gather_facts: no
  become: true

  # Vagrant provison runs this file, so you don't actually need an inventory
  # it does that for you.
  # Basically we setup a bunch of environment stuff so we can ssh into the host
  # Using all the data from all.yml

  tasks:
  - name: Allow password authentication
    lineinfile:
      path: /etc/ssh/sshd_config
      regexp: "^PasswordAuthentication"
      line: "PasswordAuthentication yes"
      state: present
    notify: restart sshd

  - name: Set authorized key took from file
    authorized_key:
      user: vagrant
      state: present
      key: "{{ lookup('file', '/home/ubuntu/.ssh/id_ed25519.pub') }}"

  handlers:
  - name: restart sshd
    service:
      name: sshd
      state: restarted

Ensuite, il ne reste plus qu’à modifier votre config ssh dans le fichier ~/.ssh/config pour indiquer que pour se connecter aux VMs on utilise le user vagrant.

Host 192.168.121.*
     User vagrant
     IdentityFile /home/ubuntu/.ssh/id_ed25519.pub

Une autre solution serait d’utiliser la conf Vagrant retourné par la commande ssh-config. Mais c’est moins générique. À vous de voir.

Host host1
  HostName 192.168.121.246
  User vagrant
  Port 22
  UserKnownHostsFile /dev/null
  StrictHostKeyChecking no
  PasswordAuthentication no
  IdentityFile /home/ubuntu/Projets/ansible/playbooks/izyview/.vagrant/machines/host1/libvirt/private_key
  IdentitiesOnly yes
  LogLevel FATAL

Suspendre et restaurer des VM

Pour économiser des ressources sans détruire vos VMs, utilisez la suspension :

vagrant suspend    # Sauvegarde l'état et libère la RAM
vagrant resume     # Restaure la VM depuis l'état suspendu

Différence avec halt : La suspension sauvegarde l’état exact de la VM (comme la mise en veille), tandis que halt éteint proprement la VM.

Dépannage

Problème	Cause probable	Solution
`No usable default provider`	Aucun hyperviseur installé	Installer VirtualBox ou libvirt
`Box not found`	Box non téléchargée	`vagrant box add nom_box`
`SSH connection refused`	VM pas encore prête	Attendre ou augmenter `boot_timeout`
`Mount error`	Dossiers synchronisés incompatibles	Désactiver avec `disabled: true` ou installer `nfs-kernel-server`
`VERR_VMX_NO_VMX`	VT-x/AMD-V désactivé dans le BIOS	Activer la virtualisation dans le BIOS

À retenir

Vagrant automatise la création de VMs reproductibles via un simple fichier Vagrantfile
Le Vagrantfile décrit la box, le réseau, le provider et le provisionnement
Les boxes sont des images système préconfiguées (préférez generic/* ou les officielles)
Le provisionnement (Shell, Ansible, Puppet) configure automatiquement la VM après boot
Le multi-machines permet de simuler des architectures complexes (web + db, clusters)
Commandes essentielles : vagrant up, vagrant ssh, vagrant halt, vagrant destroy
Variable VAGRANT_DEFAULT_PROVIDER pour éviter de spécifier le provider à chaque commande

Prochaines étapes

Ansible - Gestion de configuration Automatisez la configuration de vos VMs avec Ansible

KVM/libvirt sous Linux Installez et configurez libvirt pour utiliser Vagrant avec KVM

Packer - Création de boxes Créez vos propres boxes Vagrant personnalisées avec Packer

Environnement CKA Exemple avancé : cluster Kubernetes avec Vagrant

Ressources

Site officiel : vagrantup.com
Documentation : developer.hashicorp.com/vagrant/docs
Vagrant Cloud (boxes) : app.vagrantup.com/boxes/search
Plugin vagrant-libvirt : vagrant-libvirt.github.io