Vagrant

Vagrant est un des outils en ligne de commande qui permet de virtualiser rapidement des machines en utilisant la plupart des hyperviseurs comme HyperV, Libvirt, Parallels, VMWare, VirtualBox et même des conteneurs Dockers. Créer par HashiCorp, createur de Terraform, c’est un outil d’infrastructure as code.

Installation

Il suffit se rendre sur la page officiel et de telecharger la version de vagrant compatible avec son systeme.

utilisation basique

Pour commencer il faut creer un fichier vagrantfile dans le quel on va definir les paramettre de creation des ou de la machione virtuel.

Vagrant fonctionne aussi avec un systeme de provider comme Terraform pour definir l’hyperviseur qui est utiliser. Par defaut, il fonctionne sans precision de provider avec VirtualBox.

Vagrant.configure('2') do |config|
  config.vm.box = 'debian/bullseye64'
end

Ce fichier permet de faire conprendre a vagrant qu’il va devoir creer une machine virtuel par defaut sur virtualbox avec une image Debian bullseye en AMD64 qu’il ira chercher de lui-même pas besoin de télécharger l’iso en avance.

un fois fait, il suffit de taper la commande :

vagrant up

pour s’y connecter, il faut utiliser ssh avec la commande

vagrant ssh

par defaut, vagrant creer un jeu de clef de connexion ssh entre la machine qu’il créé et lui meme en redirigent le prot 22 sur 2222 sans avoir besoin de passphrase ou de mot de passe.

pour arreter la machine

vagrant halt

pour supprimer la machine virtuel , il suffit de faire:

vagrant destroy

configuration du vagrantfile

la majorité de la personnalisation du déploiement de Vagrant se fait dans le vagrant file.

Si nous voulons créer un 3 machines virtuelles, voici un exemple de vagrant file utilisable pour cela.

Vagrant.configure('2') do |config|
  config.vm.box = 'debian/bullseye64'
  config.vm.provider :virtualbox do |hv|
    hv.cpus = "1"
    hv.memory = "512"
  end
  config.vm.define "host1" do |host1|
    host1.vm.hostname = "host1"
  end
  config.vm.define "host2" do |host2|
    host2.vm.hostname = "host2"
  end
  config.vm.define "host3" do |host3|
    host3.vm.hostname = "monitor"
  end
end

Dans ce fichier, nous avons précisé le provider Virtualbox qui peut être remplacer par les hyperviseurs citer en introduction. Le groupe hv va permettre de définir la configuration des VM. Ensuite nous définitions les machines qui utiliseront virtualbox et la configuration déclarer plus haut. ce qui veut dire que si une VM doit avoir une configuration différente comme l’host3 il suffit d’utiliser un autre groupe que hv pour la nouvelle configuration et de faire ainsi.

Vagrant.configure('2') do |config|
  config.vm.box = 'debian/bullseye64'
  config.vm.provider :virtualbox do |hv|
    hv.cpus = "1"
    hv.memory = "512"
  end
  config.vm.define "host1" do |host1|
    host1.vm.hostname = "host1"
  end
  config.vm.define "host2" do |host2|
    host2.vm.hostname = "host2"
  end
  config.vm.provider :virtualbox do |hvo|
    hvo.cpus = "2"
    hvo.memory = "1024"
  end
  config.vm.define "host3" do |host3"|
    host3.vm.hostname = "host3"
  end
end

il est possible de réutiliser les commande Vagrant cite plus haut en précisant le hostname de la machine référencer dans le vagrantfile.

Variables Vagrants

Il est possible déclarer des variables pour pouvoir structurer son vagrantfile en déclarant des variables comme dans un langage de code afin de réutiliser des éléments déclarer. Voici un exemple ci-dessous qui montre la déclaration des machines virtuelles que l’on veut créer. Avec pour chacune Une variable : hostname, ip, os, ram, cpu, script_de_provision et autres éléments nécessaire.

machines=[
  {
    :hostname => "host1",
    :ip => "192.168.100.11",
    :box => "debian/bullseye64",
    :ram => 1024,
    :cpu => 1,
    :logi => "./script.sh"
  },
 {
    :hostname => "host2",
    :ip => "192.168.100.12",
    :box => "debian/bullseye64",
    :ram => 1024,
    :cpu => 1,
    :logi => "./script.sh"
  },
  {
    :hostname => "host3",
    :ip => "192.168.100.10",
    :box => "debian/bullseye64",
    :ram => 2048,
    :cpu => 2,
    :logi => "./script.sh"
  }
]

Vagrant.configure(2) do |config|
    machines.each do |machine|
        config.vm.define machine[:hostname] do |node|
            node.vm.box = machine[:box]
            node.vm.hostname = machine[:hostname]
            node.vm.network "private_network", ip: machine[:ip]
      	    node.vm.provision "shell", path: machine[:logi]
            node.vm.provider "virtualbox" do |vb|
                vb.gui = false
                vb.memory = machine[:ram]
                vb.cpus = machine[:cpu]
            end
        end
    end
end

Provisioning

Il est possible d’exécuter des scripts Bash/Powershell lors des créations de machines virtuelles par vagrant. On appelle cela le provisionning. Il se fait avec l’argument Il est possible d’éxecuter des scripts Bash/Powershell lors des créations de machines virtuelles par vagrant. On appelle cela le provisionning. Il se fait avec l’argument node.vm.provision "shell", path: machine[:nom_de_la_variable_qui_déclare_le_script] ou node.vm.provision "shell", path: chemin_du_script_qui_provisionne