démarrer avec vagrant et virtualbox

DIY
durée du labo : 19 min
  1. 1. Préparation
  2. 2. Box
  3. 3. Vagrantfile
    1. 3.1. Nom, box et dimensionnement
    2. 3.2. Interace réseau
    3. 3.3. Répertoire partagé
  4. 4. Ansible
    1. 4.1. Inventaire
    2. 4.2. Playbook
    3. 4.3. Vagrantfile
  5. 5. Construction
  6. 6. Destruction
  7. 7. Bonus : utilisateur
  8. 8. à voir aussi

Si vous êtes comme moi utilisateur de virtualbox afin d’avoir toujours sous la main votre linux préféré, il est parfois nécessaire de construire une nouvelle instance afin de faire des tests mais que cette opération est toujours un peu fastidieuse. Avec vagrant et quelques fichiers de configuration bien construits, c’est assez simple et ouvre des possibilités.

Tout d’abord vagrant : un outil assez simple, apporté par Hashicorp et qui permet de gérer des instances de machine virtuelle. Que l’on soit développeur à la recherche d’un environnement simple à construire et reproductible ou un ops à la recherche d’un moyen de se faire la main et de tester des nouvelles solutions sans infrastructure particulière, vagrant permet de simplifier les opérations de construction et destruction de VM.

Préparation

Pour ce petit démarrage, je suis parti sur une configuration classique de virtualbox sur mon poste windows ; en toute rigueur, ceci doit également être fonctionnel sur un linux ou un mac.

Tout d’abord, il vous faudra installer vagrant, rien de bien complexe, je vous laisse faire. A l’issue, vous disposerez d’une commande, tout se fera désormais avec un éditeur de texte et des commandes en ligne. La version utilisée dans ce billet est la 2.0.1 de vagrant :

vagrant -v
1
Vagrant 2.0.1

Maintenant, créer un répertoire dans lequel seront déposés les fichiers de paramétrage et executer la commande vagrant init, ceci va simplement créer un fichier de paramétrage par défaut que nous allons remplacer après coup, c’est juste histoire de valider que tout est bien opérationnel.

Box

Vagrant propose de démarrer des VM sur la base de modèle, ici on parle de box qui sont téléchargées à la demande sur le site de Vagrant Cloud. Il est également possible de créer des box soit même, mais pour démarrer nous allons utiliser le modèle propopsé par CentOS avec sa version 7.

Le téléchargement de modèle est particulièrement long puisque les fichiers disques sont récupérés, lancez dès maintenant une commande de récupération de la box centos, il peut y en avoir pour une heure…

1
vagrant box add centos/7 --provider virtualbox

Vagrantfile

Le fichier de configuration principal permet de définir la VM qui sera construite et les actions de paramétrage la rendant opérationnelle.

Je vous propose :

  • créer une marchine nomée : node01
  • basée sur centos 7
  • en spécifiant un dimensionnement : 4 vCPU et 4G de RAM (à adapter à votre besoin)
  • avec une interface réseau de type “bridge”, qui sera donc visible sur votre réseau local
  • paramétrée avec ansible en mode local

Nom, box et dimensionnement

Vagrantfile
1
2
3
4
5
6
7
8
9
10
Vagrant.configure("2") do |config|
config.vm.box = "centos/7"
config.vm.define 'node01' do |machine|
config.vm.provider "virtualbox" do |v|
v.memory = 4096
v.cpus = 4
end
end
end

Interace réseau

Par défaut vagrant va créer une interface de type NAT qui est parfaite afin d’avoir accès aux ressources externes via l’interface et l’adresse IP de votre PC, mais ne rend pas simple l’exposition de service sauf à votre poste. Cette interface NAT sera équipée d’une redirection de port afin que le service SSH soit disponible et rende la VM accessible via la commande vagrant ssh. On peut tout à fait ajouter d’autres règles afin de disposer des services uniquement pour son poste, parfait donc en autonomie de développement par exemple.

S’il vous est nécessaire de pouvoir accéder à cette VM depuis d’autres postes ou tout simplement d’exposer des services sur le réseau local, il faudra alors ajouter une interface supplémentaire. Pour ce faire, on ajoute dans la définition de la machine node01 la ligne suivante :

Vagrantfile
1
config.vm.network "public_network"

Attention, si votre VM est ainsi exposée sur votre réseau, il faudra supprimer l’accès via l’utilisateur vagrant, ceci est assez avec ansible, mais nécessitera également la création d’un utilisateur. Je vous le mets en bonus en fin d’article.

Répertoire partagé

Il est nécessaire à la VM en cours de construction d’utiliser quelques fichiers avec le ansible en mode local, pour cela on demande de synchroniser un répertoire sur votre poste avec un répertoire sur la VM en construction. Ici, on copiera l’ensemble des fichiers du répertoire local vers /vagrant sur la VM.

Vagrantfile
1
config.vm.synced_folder ".", "/vagrant"

Ansible

C’est la partie la moins bien documentée et la plus importante car elle va vous permettre d’adapter à votre besoin la VM nouvellement construite sur la base d’une box simple.

Pour cela nous avons besoin :

  • d’un playbook ansible, semblable à ceux que vous avez peut-être déjà fait dans le cadre d’un usage standard d’ansible, même si ici il sera exécuté en local sur la VM
  • d’un fichier d’inventaire
  • du respect des nomages

Inventaire

Le fichier inventory va contenir :

inventory
1
2
3
4
node01 ansible_connection=local
[all]
node01

Le node01 est bien le nom de notre serveur dans la ligne config.vm.define, ligne 4 du fichier Vagrantfile actuel.

Playbook

Je vous propose ici une version très simple et minimaliste, mais qui devrait vous permettre de valider le bon fonctionnement. On y fait simplement la mise à jour des packages du centos, permettant de combler le retard de la box et on change le nom du serveur.

playbook.yml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
- name: lab
hosts: all
become: true
become_user: root
tasks:
- name: upgrade all packages
yum:
name: '*'
state: latest
- name: set hostname
hostname:
name: node01

Vous noterez que la ligne hosts reprend le tag du fichier inventory (ligne 3).

Vagrantfile

Ne reste plus qu’à indiquer dans le Vagrantfile que le playbook ansible doit être exécuté, section à positionner dans notre définition de vm :

Vagrantfile
1
2
3
4
5
config.vm.provision "ansible_local" do |ansible|
ansible.install = true
ansible.playbook = "playbook.yml"
ansible.inventory_path = "inventory"
end

Construction

Vous devez avoir dans votre répertoire les fichiers suivants :

  • inventory : la liste des hosts pour ansible
  • playbook.yml : la configuration ansible de votre VM appliquée après construction
  • Vagrantfile : la définition de la VM et comment l’installer

On y va alors (avec un peu de chance la box centos est désormais disponible, sinon, il faudra attendre…) :

1
vagrant up

Dans le log de progression, on trouve :

  • l’utilisation de la box centos/7
  • la création d’une règle de NAT exposant le port ssh (22) sur un port de votre PC
  • l’installation d’ansible
  • l’exécution des 3 étapes de notre playbook

Une fois finalisé, vous pouvez avoir accès à votre VM via la commande :

1
vagrant ssh

Elle doit se nomer node01 et l’utilisateur est vagrant, il dispose des droits nécessaires à l’utilisation de sudo sans restriction. Son interface eth0 est celle dédiée au NAT, la eth1 est connectée directement sur votre réseau local, vous pourrez accéder aux services exposés via cette adresse.

Destruction

vagrant est utile également pour supprimer la VM de votre environnement, simplement en utilisant la commande :

1
vagrant destroy

Ajouter le flag -f pour ne pas que la validation ne soit demandée.

Bonus : utilisateur

L’idée ici est d’ajouter un utilisateur de connexion (ici alex) avec sa clé ssh et de suspendre l’usage de l’utilisateur vagrant afin d’éviter les connexions sur ce compte, je vous ajoute également de quoi imposer l’utilisation d’une clé ssh pour se connecter, c’est une bonne pratique.

Ajoutez dans votre playbook :

playbook.yml
1
2
3
4
5
6
7
8
9
10
- name: add user alex
user:
name: alex
comment: "Alex Chauvin"
- name: add ssh key
authorized_key:
user: alex
key: "{{ lookup('file', 'cle_ssh.pub') }}"
key_options: 'no-port-forwarding'

Le fichier cle_ssh.pub positionné dans le répertoire sera copié dans les authorized_keys du compte crée, il reprend le format standard de ssh.

On ajoute l’utilisateur aux sudoers, le fichier alex_sudoers est copié dans le répertoire /vagrant et dont le contenu est à adapter à votre usage :

alex_sudoers
1
%alex ALL=(ALL) NOPASSWD: ALL

Puis dans le playbook :

playbook.yml
1
2
3
4
5
6
7
- name: alex sudo
copy:
src: alex_sudoers
dest: /etc/sudoers.d/alex
owner: root
group: root
mode: 0644

Le tunning du ssh :

playbook.yml
1
2
3
4
5
6
7
8
9
10
11
- name: ssh key only
lineinfile:
dest=/etc/ssh/sshd_config
regexp="^#PasswordAuthentication yes"
line="PasswordAuthentication no"
- name: ssh root pwd
lineinfile:
dest=/etc/ssh/sshd_config
regexp="^PermitRootLogin .*"
line="PermitRootLogin no"

Et la suspension de l’utilisateur vagrant

playbook.yml
1
2
3
4
- name: suppress vagrant user
user:
name: vagrant
shell: /sbin/nologin

Le second article de la série est disponible au mois de janvier, intitulé vagrant multi noeuds pour swarm.

Photo Garett Mizunaka

Alexandre Chauvin Hameau

2017-12-03T16:47:29