Aller au contenu principal

Maitriser Vagrant

Vagrant, développé par HashiCorp, est un outil qui a considérablement simplifié la vie des développeurs et des ingénieurs en informatique. Sa conception est centrée sur la création et la gestion d'environnements de développement virtuels. Ce qui distingue Vagrant des autres solutions de virtualisation, c'est sa capacité à offrir des environnements de développement cohérents, reproductibles et portables.

Dans le passé, l'une des principales difficultés rencontrées par les développeurs était la divergence entre les environnements de développement, de test et de production. Ces différences entraînaient souvent des bugs difficiles à tracer et à corriger. Vagrant répond à ce défi en permettant aux développeurs de travailler dans un environnement qui soit une réplique exacte de la configuration de production, réduisant ainsi les surprises désagréables lors du déploiement du logiciel.

L'utilisation de Vagrant ne se limite pas uniquement à la facilitation du développement logiciel. Elle apporte également une grande flexibilité dans la gestion des ressources. Les développeurs peuvent démarrer, arrêter et reconstruire des environnements virtuels en quelques commandes, rendant le processus de développement plus agile et efficace.

En plus de sa facilité d'utilisation, Vagrant se distingue par son intégration transparente avec d'autres outils et technologies. Que ce soit pour des applications basées sur des conteneurs, comme Docker, ou pour des outils de provisionnement tels que Ansible, Puppet ou Chef, Vagrant fonctionne de manière complémentaire, renforçant ainsi son rôle incontournable dans les cycles de développement modernes.

En résumé, Vagrant est un outil puissant qui a redéfini les normes de développement logiciel. Il ne s'agit pas simplement d'un outil de virtualisation, mais d'une solution complète qui améliore la productivité, la cohérence et l'efficacité des équipes de développement à travers le monde.

Petit Historique de Vagrant​

L'histoire de Vagrant débute en 2010, lorsque Mitchell Hashimoto, un passionné d'informatique et de développement logiciel, a identifié un besoin crucial dans le monde du développement : celui de standardiser et de simplifier la création d'environnements de développement. Cette idée a conduit à la création de Vagrant, un outil qui allait révolutionner la manière dont les développeurs travaillent avec des machines virtuelles.

Initialement, Vagrant a été conçu comme une solution pour rendre les environnements de développement aussi proches que possible de l'environnement de production. Cette approche avait pour but d'éliminer les fameux problèmes du type "ça fonctionne sur ma machine". Rapidement, Vagrant s'est imposé comme un outil incontournable dans le domaine du développement logiciel, grâce à sa simplicité d'utilisation et à sa capacité à gérer de manière homogène les environnements de développement.

Au fil des années, Vagrant a évolué pour intégrer de nombreuses fonctionnalités et améliorations. Sa compatibilité avec une multitude de fournisseurs de services de virtualisation, tels que VirtualBox, VMware et Hyper-V, a élargi son accessibilité à un plus grand nombre d'utilisateurs. De plus, l'intégration de Vagrant avec des outils de provisionnement automatisé tels que Ansible, Chef et Puppet, a permis aux développeurs de configurer et de gérer des environnements de manière encore plus efficace.

En 2012, la création de HashiCorp, l'entreprise derrière Vagrant, a marqué une étape clé dans l'évolution de l'outil. Avec le soutien et les ressources d'une entreprise dédiée, Vagrant a continué à se développer, ajoutant de nouvelles fonctionnalités et étendant son influence dans l'écosystème du développement logiciel.

Aujourd'hui, Vagrant est reconnu comme un outil standard dans le développement et la gestion d'environnements virtuels. Son impact va au-delà de la simple virtualisation, jouant un rôle important dans le mouvement DevOps et dans la promotion de pratiques de développement plus efficaces et reproductibles.

L'histoire de Vagrant est celle d'une innovation constante, guidée par les besoins et les retours de sa vaste communauté d'utilisateurs. C'est cette capacité d'adaptation et d'évolution qui a fait de Vagrant un outil indispensable pour les développeurs du monde entier.

Fonctionnement de Vagrant​

Au cœur de Vagrant se trouve le concept de boîte (box en anglais), qui représente une image de base pour créer une machine virtuelle. Ces boîtes sont des environnements préconfigurés qui peuvent inclure un système d'exploitation spécifique, des logiciels préinstallés et des paramètres personnalisés. Elles servent de point de départ pour la création d'environnements de développement.

Lorsqu'un utilisateur initialise Vagrant, il spécifie d'abord une boîte via un fichier de configuration nommé Vagrantfile. Ce fichier est le cœur de tout projet Vagrant, c'est de l'infra-as-code. Il contient des instructions détaillées sur la manière dont la machine virtuelle doit être configurée. Par exemple, il peut définir le fournisseur de virtualisation (comme VirtualBox ou VMware, Libvirt...), les ressources allouées à la machine (comme la mémoire vive ou le nombre de cœurs CPU) et les scripts de provisionnement pour installer et configurer le logiciel nécessaire.

Une fois que le Vagrantfile est configuré, l'utilisateur peut lancer la machine virtuelle avec une simple commande vagrant up. Cette commande déclenche le téléchargement de la boîte spécifiée (si elle n'est pas déjà téléchargée), la création de la machine virtuelle et l'exécution de tout script de provisionnement défini dans le Vagrantfile.

L'un des avantages majeurs de Vagrant est sa capacité à synchroniser les fichiers entre l'hôte et la machine virtuelle. Cela signifie que les développeurs peuvent utiliser leurs outils favoris sur l'hôte tout en exécutant le code dans un environnement qui imite fidèlement la production.

En plus de lancer des environnements, Vagrant permet également de les gérer de manière fluide. Les commandes comme vagrant halt pour arrêter la machine, vagrant destroy pour la supprimer et vagrant reload pour la redémarrer avec de nouveaux paramètres dans le Vagrantfile, offrent une gestion complète du cycle de vie de l'environnement virtuel.

Cas d'Usage Communs de Vagrant​

Vagrant, avec sa polyvalence et sa facilité d'utilisation, s'adapte à une multitude de scénarios dans le monde du développement logiciel. Cette section explore plusieurs cas d'usage courants de Vagrant, démontrant son rôle essentiel dans divers aspects du cycle de développement.

Environnements de Développement Homogènes​

L'un des principaux avantages de Vagrant est sa capacité à créer des environnements de développement homogènes. Cela est particulièrement utile dans les équipes où chaque membre peut avoir une configuration de système différente. Avec Vagrant, chaque membre de l'équipe utilise une machine virtuelle qui est une réplique exacte de l'environnement de production. Cela réduit considérablement les problèmes de compatibilité et les fameux "ça marche sur ma machine" en assurant que le code fonctionne de manière identique pour tous les développeurs.

Simplification des Tests​

Vagrant permet aux développeurs de tester facilement leurs applications dans différents environnements et systèmes d'exploitation sans avoir besoin de plusieurs machines physiques. Par exemple, un développeur peut tester une application sur Ubuntu, CentOS et Windows en utilisant différentes configurations de Vagrant, sans quitter son poste de travail. Cette capacité à simuler divers environnements aide à identifier et à corriger les problèmes spécifiques à une plateforme bien avant le déploiement.

Intégration et Livraison Continues​

Dans le cadre de l'intégration continue (CI) et de la livraison continue (CD), Vagrant s'avère être un outil précieux. Il peut être utilisé pour créer des environnements de test qui imitent la production, permettant ainsi aux équipes de tester les déploiements de manière fiable et automatisée. Les environnements Vagrant peuvent être configurés pour démarrer et s'arrêter avec les pipelines CI/CD, assurant que chaque build est testé dans un environnement propre et isolé.

Formation et Éducation​

Vagrant est également un outil idéal pour les environnements éducatifs et de formation. Les formateurs peuvent fournir des boîtes Vagrant préconfigurées aux étudiants, s'assurant que tous disposent d'un environnement de développement cohérent et contrôlé. Cela élimine les problèmes techniques courants et permet aux étudiants de se concentrer sur l'apprentissage plutôt que sur la configuration de leurs machines.

Collaboration et Partage d'Environnements​

Avec Vagrant, partager un environnement de développement spécifique avec d'autres est simple et efficace. En partageant le Vagrantfile et les scripts de provisionnement, les développeurs peuvent rapidement mettre en place un environnement identique. Cette facilité de partage améliore la collaboration au sein des équipes et entre les équipes, car elle permet à chacun de travailler dans un environnement qui reflète exactement celui des autres membres de l'équipe.

Prototypage et Expérimentation​

Enfin, Vagrant est parfait pour le prototypage et l'expérimentation. Les développeurs peuvent rapidement mettre en place et démolir des environnements, tester de nouvelles technologies, architectures ou configurations sans risquer d'affecter leur système principal. Cette flexibilité favorise l'innovation et l'expérimentation, des aspects essentiels dans le développement logiciel moderne.

Installation de 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 apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
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

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 qemu-kvm libvirt-daemon-system 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.

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, il suffit de lancer l'installation via la commande brew :

brew install hashicorp/tap/hashicorp-vagrant

Pour vérifier que tout fonctionne comme attendu et exécutez la commande vagrant --version dans une fenêtre Terminal.

Premiers tours de roue​

astuce

À partir de cette section, la plupart des exemples seront faits une machine Linux où est installé libvirt.

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

vagrant box add centos/8
vagrant init centos/8
vagrant up
vagrant ssh

La première commande télécharge la box, vous pouvez en trouver en grand nombre sur ce site, mais faites bien attention à utiliser des images sûres. Nous proposerons bientôt des images que nous construirons avec packer et contentant tout ce qu'il faut pour développer rapidement.

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

export VAGRANT_DEFAULT_PROVIDER=libvirt

La seconde commande, vagrant init centos\8 créé le fichier de configuration Vagrantfile par défaut avec le minimum syndical en utilisant une des box ajouté avec la commande box add.

vagrant up lance le provisionnement en lui-même. Attention beaucoup de données sont ajoutée à un dossier caché .vagrant dans votre répertoire de travail !

vagrant ssh permet de se connecter à votre VM.

Pour détruire une VM, il suffit de lancer la commande vagrant destroy.

Le fichier de déclaration Vagrantfile​

Ce fichier de déclaration Vagrantfile utilise un langage proche de ruby.

Quelques règles de syntaxe pour les fichiers Vagrantfile​

  • Les commentaires sur une seule ligne commencent avec un #
  • Les commentaires sur plusieurs lignes sont encadrés par /* et */
  • Les variables Vagrantfile sont assignées avec la syntaxe key = value (aucune importance concernant les espaces). Les valeurs peuvent être des primitives string, number ou boolean ou encore une list ou une map.
  • Les chaînes de caractères sont encadrées par des "doubles-quotes".
  • Les valeurs booléennes peuvent être true ou false.

Premières lignes de Vagrantfile​

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

Ici, on ne fait que configurer avec la version ("2") de vagrant un objet config qui utilise une image ubuntu precise 32 bits.

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

  • config.vm : pour paramétrer la machine
  • config.ssh : pour définir comment Vagrant accédera à votre machine
  • config.vagrant : pour modifier le comportement de Vagrant en lui-même.

En fait, on se limitera pour le moment à la partie paramétrage de la VM.

Paramétrage de la VM config.vm​

Vous pouvez retrouver toute la documentation de cette partie sur le site de vagrant. Je vais vous expliquer quelques-uns de ces paramètres :

Prenons cet exemple de fichier Vagrantfile:

Vagrant.configure("2") do |config|
  config.vm.box = "ol8"
  config.vm.provider "libvirt" do |hv|
    hv.cpus = "1"
    hv.memory = "512"
  end
  config.vm.synced_folder '.', '/vagrant', disabled: true

  config.vm.define "host1" do |host1|
    host1.vm.network :private_network, ip: "192.168.3.10"
    host1.vm.hostname = "host1"
  end
end

network​

On configure ici la partie réseau. Dans notre exemple, on fixe l'adresse IP.

box​

Je vous dis plus qu'on retrouve ici la box que l'on va utiliser. Ces box peuvent être installé avec la commande vagrant box add. Pour les lister vagrant box list et vagrant box remove pour les retirer.

provider​

Attention ici bien indiquée l'hyperviseur utilisé. On ouvre une autre boucle pour configurer propre à chaque hyperviseur. La doc de celui de libvirt est ici.

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

provision​

Cette partie permet de définir ce qu'il se passe une fois que la machine est démarrée. Vous avez le choix d'utiliser langage dont les plus courants sont le shell, ansible et bien d'autre encore.

Dans notre exemple, on utilise Ansible avec comme paramètre le playbook et le niveau de verbosité utilisé. Le playbook doit se trouver à la racine ou si vous lui indiquez le chemin relatif dans un sous dossier.

Quelques tips​

Avec la gestion des VM​

Ne pas détruire la VM en cas d'erreur​

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 restorer des VM​

Vagrant propose une fonctionnalité permettant de suspendre les VM provisionnées, afin par exemple de changer de projet ou vous pouvez démarrer de nouvelles VMS.

Il s'agit des commandes vagrant suspend et vagrant resume

Un exemple de configuration plus complexe​

Si vous voulez des exemples un peu plus complexes, je vous propose de vous rendre sur mes projets CKASandbox.

Plus d'infos​

Site officiel vagrantup.com Documentation vagrantup.com/docs

Sites​

Vidéos​