Comment créer un labo d'admin DevOps en local avec Vagrant ?

Publié le

Évaluer une solution technique demande souvent de mettre au point un PoC (Proof of Concept). Nous avons donc besoin de déployer des services sur des serveurs, manuellement dans un premier temps, puis en automatisant le process avec des outils comme Terraform et/ou Ansible.

Une solution est de remplacer l'étape de provisioning dans le cloud par des machines virtuelles ou des containers (via Docker) en local. Cette tâche peut être automatisée avec Hashicorp Vagrant.

Quels avantages à avoir un labo de test en local ?

Installer les services dont on a besoin est parfois compliqué. Dans cette situation, on doit multiplier les essais pour arriver à un résultat concluant.

Avec Vagrant on a la possibilité de gérer tout le cycle de vie des machines virtuelles : démarrer, mettre en pause, arrêter complètement, etc. On va aussi pouvoir créer des snapshots, ce qui va nous permettre de « sauvegarder » l'état de notre infrastructure, et donc éventuellement de revenir en arrière. Tout ceci est rapide à mettre en œuvre.

Monter son labo avec Vagrant

Pour fonctionner, Vagrant s'appuie sur un service de virtualisation (Hyperviseur) qu'il va piloter via un type de plugin qu'on appelle « provider ». Quand on utilise Vagrant, il n'est pas nécessaire de connaître dans les détails le fonctionnement de chaque Hyperviseur, et il est tout à fait possible de faire fonctionner son labo avec plusieurs providers différents. Vagrant fera de son mieux pour reproduire un environnement uniforme.

Actuellement, Vagrant supporte un grand nombre de providers. Par défaut, Vagrant tentera d'utiliser le provider pour VirtualBox. Celui-ci a l'avantages d'être disponible gratuitement sur les trois plateformes principales (Linux, macOS, et Windows). La documentation cite aussi directement :

  • VMWare, qui fonctionnera via le VMWare Vagrant provider. Ce provider nécessite une license payante.
  • Hyper-V de Microsoft.
  • Docker, dans ce cas Vagrant provisionnera quand même une machine virtuelle pour lui servir d'hôte. L'environnement d'exécution ne sera pas cette machine virtuelle mais les containers qui y seront lancés.

J'ai pu personnellement utiliser Vagrant avec :

Comment installer Vagrant sous macOS ?

  • Télécharger la dernière version de Vagrant, depuis la page officielle.
  • Télécharger la dernière version de VirtualBox, depuis la page officielle. Il y a un lien  « OS X hosts ».
  • Si on souhaite utiliser Docker, installer la dernière version de Docker Desktop, depuis la page officielle.
  • Installer les outils précités (peu importe dans quel ordre).

Comment installer Vagrant sous Linux ?

  • Télécharger la dernière version de Vagrant, depuis la page officielle. Il est aussi certainement possible d'utiliser le gestionnaire de paquets de votre distribution Linux.
  • Pour installer VirtualBox, consulter la documentation officielle à ce sujet.
  • Si on souhaite utiliser Docker, il faudra suivre la documentation en fonction de votre distribution Linux (Debian, Ubuntu, Fedora, CentOS).

Sous Ubuntu 20.04, l'ensemble des étapes peut se faire de la façon suivante :

# installation de vagrant (à adapter avec l'URL du bouton "Download" de la page de téléchargement)
VAGRANT_URL="https://releases.hashicorp.com/vagrant/2.2.14/vagrant_2.2.14_linux_amd64.zip"
curl -O $VAGRANT_URL
unzip vagrant_2.2.14_linux_amd64.zip vagrant
sudo install vagrant

# VirtualBox
sudo apt install virtualbox

# Installation de Docker depuis le dépôt officiel
sudo apt-get update
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

sudo add-apt-repository \
    "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
    $(lsb_release -cs) stable"

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

Sous Linux mais avec libvirt/kvm ?

kvm est un hyperviseur de type 1 : il va fonctionner directement à « l'intérieur » du noyau Linux, et aura accès directement à votre matériel. Avec kvm, on peut s'attendre à des performances supérieures par rapport à une solution comme VirtualBox. En effet, VirtualBox est un hyperviseur de type 2, et doit donc passer par le système d'exploitation pour accéder au matériel (c'est un process qui tourne en espace utilisateur, le userspace). La documentation du provider pour libvirt est disponible sur le GitHub du projet.

Sous Ubuntu, l'installation se résume à lancer les commandes suivantes (en partant du principe que Vagrant est déjà installé, voir section précédente) :

# Installation des dépendances du plugin vagrant-libvirt
apt-get build-dep vagrant ruby-libvirt
apt-get install qemu libvirt-daemon-system libvirt-clients ebtables dnsmasq-base
apt-get install libxslt-dev libxml2-dev libvirt-dev zlib1g-dev ruby-dev

# Installation du provider
vagrant plugin install vagrant-libvirt

Définir son labo : le Vagrantfile

Une fois Vagrant et l'hyperviseur installés, il suffira de créer pour chaque labo un *Vagrantfile *dont le rôle est de décrire l'ensemble des machines virtuelles à créer, ainsi que leurs propriétés.

Pour créer une infrastructure locale avec 3 noeuds de contrôle et 3 workers, voici un exemple de Vagrantfile:

SERVER_COUNT = 3
NODE_COUNT = 3
IMAGE = "ubuntu/bionic64"

Vagrant.configure("2") do |config|
  (1..SERVER_COUNT).each do |server_index|
    config.vm.define "server#{server_index}" do |server|
      server.vm.box = IMAGE
      server.vm.hostname = "server-#{server_index}"
      server.vm.network  :private_network, ip: "10.0.0.#{server_index + 10}"
    end
  end

  (1..NODE_COUNT).each do |server_index|
    config.vm.define "node#{server_index}" do |node|
      node.vm.box = IMAGE
      node.vm.hostname = "node-#{server_index}"
      node.vm.network  :private_network, ip: "10.0.0.#{server_index + 20}"
    end
  end
end

Ce Vagrantfile fonctionnera avec VirtualBox (provider par défaut). Il définit 3 variables : SERVER_COUNT, NODE_COUNT, et IMAGE.

On définit 3 machines (SERVER_COUNT) dont les noms vont être "server1", "server2", et "server3" avec les adresse IP "10.0.0.11", "10.0.0.12", "10.0.0.13".

On définit ensuite 3 autres machines (NODE_COUNT) dont les noms vont être "node1", "node2", et "node3" avec les adresse IP "10.0.0.21", "10.0.0.22", "10.0.0.23".

Ces 6 machines utilisent l'image définie dans la variable IMAGE. Dans le jargon de Vagrant, une image de système d'exploitation est une box.

Une fois ce fichier créé, il suffit de lancer la commande vagrant up. Vagrant va alors créer les machines virtuelles, et les démarrer. On peut alors se connecter aux machines (via vagrant ssh) pour faire ses tests.

Pour mettre en pause les machines virtuelles, c'est la commande vagrant suspend, pour les détruire, c'est la commande vagrant destroy.

Conclusion

On a vu dans ce billet que créer son labo local pour mettre au point le provisioning de son infrastructure n'est pas très compliqué. Avec Vagrant et un hyperviseur, cette tâche est automatisable, ce qui rend le prototypage de solutions plus rapide et flexible.

PHILIPPE CHEPY

Administrateur Système et Développeur