Environnement de test web avec Vagrant et Ansible

Cet article montre comment mettre en place un environnement de test web avec Vagrant et Ansible. Nous utilisons LAMP pour la partie applicative. C'est à dire Apache (service web), MySQL (base de données) et PHP sur un système d'exploitation de type Linux (ici Debian).

Avant de commencer, voici la description des outils employés pour gérer notre environnement de test :

  • VirtualBox est le logiciel pour créer et gérer des machines virtuelles (VM)
  • Vagrant est l'outil qui va permettre de contruire et distribuer des environnemnets virtualisés de développement. Dans notre cas il se base sur VirtualBox pour gérer les VMs
  • Ansible est un gestionnaire de configuration qui déploit et exécute des tâches sur plusieurs systèmes au travers de SSH. Ici Vagrant l'utilise pour provisionner la VM. C'est à dire installer les prerequis systèmes et gérer la configuration des applications

Prérequis

Nous pouvons maintenant installer les prérequis système :

apt install virtualbox vagrant ansible
vagrant plugin install vagrant-vbguest

Pour information le plugin vagrant-vbguest s'assure que la boxe utilisée à les suppléments invité d'installés. Si ce n'est pas le cas, elle les installe. Sans ces suppléments nous ne pourrions pas avoir le partage de fichiers vboxsf entre le système hôte (notre poste de travail) et le système invité (la VM).

Espace de travail

Voici la structure de l'espace de travail :

~/git/app/

~/vagrant/project/
├── app.sql
├── lamp.yml
└── Vagrantfile
  • ~/git/app/ : contient le code source de l'application du développeur (il sera monté sur la VM)
  • ~/vagrant/project/ : contient l'environnemnet de test (il sera synchronisé sur la VM)
  • Vagrantfile : fichier de configuration de l'environnemnet de test. C'est lui qui précise quelle VM utiliser, comment interagir avec celle-ci (accès aux ports de la VM, partage de fichiers, configuration diverses ...) et comment l'approvisionner
  • lamp.yml : playbook Ansible qui décrit les tâches à réaliser lors du premier démarrage de la VM (installation, configuration ...)
  • app.sql : script SQL utiliser pour créer la base de données de test

Configuration de Vagrant

Créer son répertoire de travail et le fichier de configuration vagrant :

mkdir -p ~/vagrant/project
cd ~/vagrant/project
vagrant init -m debian/stretch64

Editer le fichier de configuration Vagrantfile :

Vagrant.configure("2") do |config|
  config.vm.box = "debian/stretch64"
  config.vm.network "forwarded_port", guest: 80, host: 8080
  config.vm.synced_folder "~/git/app/", "/var/www/html", owner: "www-data", group: "www-data"

  config.vm.provision "ansible" do |ansible|
    ansible.playbook = "lamp.yml"
  end
end
  • config.vm.box = "debian/stretch64" : Nous utilisons une VM 64 bits ayant comme système d'exploitation Debian Stretch
  • config.vm.network "forwarded_port", guest: 80, host: 8080 : mise en place d'une redirection de port entre le système invité et hôte. Autrement dit nous redirigeons le port 80 de la VM sur le port 8080 de notre poste de travail. Pour accéder à l'application web il faudra donc se connecter sur l'url http://127.0.0.1:8080
  • config.vm.synced_folder "~/git/app/", "/var/www/html", owner: 'www-data', group: 'www-data' : mise en place d'un partage de fichiers entre le système hôte et invité. Ici le répertoire contenant le code source de l'application ~/git/app/ de notre poste de travail est monté sur le répertoire /var/www/html/ de la VM. Nous en profitons pour attribuer la propriété du répertoire à l'usager www-data et au groupe www-data sur la VM
  • config.vm.provision : nous utilisons le playbook Ansible lamp.yml pour provisionner la VM (installer et configurer LAMP)

Provisionning Ansible

Création du playbook lamp.yml :

- hosts: default
  gather_facts: no
  become: yes

  tasks:
  - name: system update
    apt:
      update_cache: yes
      upgrade: yes
      force_apt_get: yes
  - name: install ansible pre-requisite package
    apt:
      name: python-mysqldb
      state: present
  - name: install LAMP packages
    apt:
      name:
        - apache2
        - mysql-server
        - php
        - php-mysql
        - libapache2-mod-php
      state: present
  - name: create database
    mysql_db:
      name: app
      state: present
  - name: import database
    mysql_db:
      name: app
      target: /vagrant/app.sql
      state: import
  - name: create database user
    mysql_user:
      name: app
      password: MyP@ssword
      priv: 'app.*:ALL'
      state: present
  • hosts: default : on indique l'hôte sur lequel le playbook sera joué. Ici default identifie la VM instanciée par Vagrant
  • gather_facts: no : afin de gagner du temps on désactive la récupération des informations système de la VM
  • become: yes : l'utilisateur par défaut utilisé par Vagrant et Ansible pour provisionner la VM se nomme vagrant. Ici nous le forçons à devenir root pour la suite des opérations (équivalent sudo su)
  • tasks : descriptions de toute les tâches à réaliser. Il suffit de lire la valeur de name de chacune des tâches pour en comprendre le but. Dans l'ordre : s'assurer que le système soit à jour, installer le prérequis Ansible (ici il est utile pour les tâches relatives à MySQL), installer LAMP et mettre en place la base de données

On remarquera que nous n'avons pas eu besoins de configurer Apache car nous utilisons le vhost par défaut qui pointe sur notre montage /var/www/html.

Utilisation

Tout est prêt, il ne reste plus qu'à lancer l'environnement de test :

vagrant up

L'environnement se met en place en quelques minutes. L'application web est maintenant accessible via l'url http://127.0.0.1:8080.

Pour gérer la VM :

# se connecter en ssh sur la VM
vagrant ssh
# eteindre la VM
vagrant halt
# demarrer la VM
vagrant up

Une fois le travail terminé il ne reste plus qu'à détruire l'environnement de test :

vagrant destroy
By @Mikael FLORA in
Tags : #web, #virtualisation, #automatisation,