⚙️ Provisioning — Vagrant & Ansible

🎯 Objectifs

• Créer des environnements virtuels reproductibles avec Vagrant
• Automatiser le provisioning et la configuration avec Ansible
• Écrire des Vagrantfiles et des playbooks Ansible
• Combiner Vagrant et Ansible pour déployer des infrastructures complètes
• Comprendre l'approche Infrastructure as Code (IaC)

📖 Vagrant — Environnements virtuels reproductibles

Qu'est-ce que Vagrant ?

Vagrant est un outil open source développé par HashiCorp qui permet de créer, configurer et gérer des machines virtuelles de manière automatisée et reproductible. Au lieu de configurer manuellement une VM dans VirtualBox ou VMware, on décrit l'environnement souhaité dans un fichier texte appelé Vagrantfile.

L'intérêt principal : chaque membre d'une équipe peut recréer exactement le même environnement en une seule commande (vagrant up). Fini les « ça marche sur ma machine » !

Architecture de Vagrant

• Vagrantfile : fichier Ruby décrivant la configuration de la VM (OS, réseau, provisioning)
• Providers : backends de virtualisation (VirtualBox, VMware, Hyper-V, libvirt)
• Boxes : images de base pré-packagées (ex: ubuntu/jammy64, debian/bookworm64, generic/rocky9)
• Provisioners : outils de configuration automatique (Shell, Ansible, Puppet, Chef)
• Synced folders : dossiers partagés entre l'hôte et la VM

Commandes essentielles

# Initialiser un projet Vagrant
vagrant init ubuntu/jammy64

# Démarrer la VM (télécharge la box si nécessaire)
vagrant up

# Se connecter en SSH à la VM
vagrant ssh

# Arrêter la VM (sans la supprimer)
vagrant halt

# Redémarrer la VM
vagrant reload

# Relancer uniquement le provisioning
vagrant provision

# Supprimer complètement la VM
vagrant destroy -f

# Voir l'état de toutes les VMs
vagrant status
vagrant global-status

Exemple de Vagrantfile

Vagrant.configure("2") do |config|
  # Image de base
  config.vm.box = "ubuntu/jammy64"
  config.vm.hostname = "srv-web"

  # Réseau : IP privée sur un réseau host-only
  config.vm.network "private_network", ip: "192.168.56.10"

  # Port forwarding : accès au port 80 de la VM via le port 8080 de l'hôte
  config.vm.network "forwarded_port", guest: 80, host: 8080

  # Dossier partagé
  config.vm.synced_folder "./site", "/var/www/html"

  # Ressources de la VM
  config.vm.provider "virtualbox" do |vb|
    vb.memory = 2048
    vb.cpus = 2
    vb.name = "srv-web-ubuntu"
  end

  # Provisioning avec un script Shell
  config.vm.provision "shell", inline: <<-SHELL
    apt-get update
    apt-get install -y nginx
    systemctl enable nginx
    systemctl start nginx
  SHELL
end

Vagrantfile multi-machines

Vagrant permet de décrire plusieurs VMs dans un même fichier, idéal pour simuler une infrastructure complète :

Vagrant.configure("2") do |config|

  # Serveur Web
  config.vm.define "web" do |web|
    web.vm.box = "ubuntu/jammy64"
    web.vm.hostname = "srv-web"
    web.vm.network "private_network", ip: "192.168.56.10"
    web.vm.provider "virtualbox" do |vb|
      vb.memory = 1024
      vb.cpus = 1
    end
  end

  # Serveur Base de données
  config.vm.define "db" do |db|
    db.vm.box = "ubuntu/jammy64"
    db.vm.hostname = "srv-db"
    db.vm.network "private_network", ip: "192.168.56.11"
    db.vm.provider "virtualbox" do |vb|
      vb.memory = 2048
      vb.cpus = 2
    end
  end

  # Serveur de supervision
  config.vm.define "monitor" do |mon|
    mon.vm.box = "ubuntu/jammy64"
    mon.vm.hostname = "srv-monitor"
    mon.vm.network "private_network", ip: "192.168.56.12"
    mon.vm.provider "virtualbox" do |vb|
      vb.memory = 1024
    end
  end

end

Boxes Vagrant

Les boxes sont des images de base téléchargées depuis le Vagrant Cloud. Quelques boxes populaires :

📖 Ansible — Automatisation et gestion de configuration

Qu'est-ce qu'Ansible ?

Ansible est un outil d'automatisation IT open source développé par Red Hat. Il permet de configurer des serveurs, déployer des applications et orchestrer des tâches de manière déclarative. Sa particularité : il est agentless (sans agent) — il se connecte aux machines cibles via SSH (Linux) ou WinRM (Windows) sans rien installer dessus.

Concepts fondamentaux

• Inventaire (inventory) : liste des machines cibles, organisées en groupes
• Playbook : fichier YAML décrivant les tâches à exécuter sur les cibles
• Rôle : ensemble structuré de tâches, variables, templates et handlers réutilisable
• Module : unité de travail (ex: apt, copy, service, user, template)
• Task : une action unitaire utilisant un module
• Handler : tâche déclenchée conditionnellement (ex: redémarrer un service après une modification)
• Facts : variables automatiquement collectées sur les hôtes (OS, IP, RAM...)

Fichier d'inventaire

# inventory.ini
[webservers]
srv-web ansible_host=192.168.56.10

[dbservers]
srv-db ansible_host=192.168.56.11

[monitoring]
srv-monitor ansible_host=192.168.56.12

[all:vars]
ansible_user=vagrant
ansible_ssh_private_key_file=.vagrant/machines/web/virtualbox/private_key

Premier playbook

# playbook.yml
---
- name: Installer et configurer Nginx
  hosts: webservers
  become: yes   # exécuter en root (sudo)

  tasks:
    - name: Mettre à jour le cache apt
      apt:
        update_cache: yes
        cache_valid_time: 3600

    - name: Installer Nginx
      apt:
        name: nginx
        state: present

    - name: Copier la page d'accueil
      copy:
        src: files/index.html
        dest: /var/www/html/index.html
        owner: www-data
        group: www-data
        mode: '0644'
      notify: Redémarrer Nginx

    - name: S'assurer que Nginx est démarré et activé
      service:
        name: nginx
        state: started
        enabled: yes

  handlers:
    - name: Redémarrer Nginx
      service:
        name: nginx
        state: restarted

Commandes Ansible

# Tester la connexion à tous les hôtes
ansible all -i inventory.ini -m ping

# Exécuter une commande ad-hoc sur les serveurs web
ansible webservers -i inventory.ini -m shell -a "df -h"

# Lancer un playbook
ansible-playbook -i inventory.ini playbook.yml

# Lancer un playbook en mode check (simulation, sans modification)
ansible-playbook -i inventory.ini playbook.yml --check

# Lancer un playbook avec verbosité
ansible-playbook -i inventory.ini playbook.yml -vvv

# Lister les facts d'un hôte
ansible srv-web -i inventory.ini -m setup

Modules Ansible les plus utilisés

Variables et templates Jinja2

Ansible utilise le moteur de templates Jinja2 pour générer dynamiquement des fichiers de configuration :

# vars/main.yml
---
server_name: "cours.iris.a3n.fr"
http_port: 80
max_connections: 1024

# templates/nginx.conf.j2
server {
    listen {{ http_port }};
    server_name {{ server_name }};

    worker_connections {{ max_connections }};

    location / {
        root /var/www/html;
        index index.html;
    }
}

Structure d'un rôle Ansible

roles/
└── webserver/
    ├── tasks/
    │   └── main.yml        # Tâches principales
    ├── handlers/
    │   └── main.yml        # Handlers (redémarrages...)
    ├── templates/
    │   └── nginx.conf.j2   # Templates Jinja2
    ├── files/
    │   └── index.html      # Fichiers statiques
    ├── vars/
    │   └── main.yml        # Variables du rôle
    ├── defaults/
    │   └── main.yml        # Variables par défaut (surchargeables)
    └── meta/
        └── main.yml        # Métadonnées et dépendances

Un playbook utilisant des rôles :

# site.yml
---
- name: Configurer les serveurs web
  hosts: webservers
  become: yes
  roles:
    - webserver

- name: Configurer les bases de données
  hosts: dbservers
  become: yes
  roles:
    - mysql

📖 Combiner Vagrant et Ansible

Le duo parfait

La combinaison Vagrant + Ansible est un workflow très puissant pour le BTS SIO SISR :

• Vagrant crée les VMs (l'infrastructure)
• Ansible configure les VMs (le provisioning)

On obtient ainsi une infrastructure complète reproductible en une seule commande : vagrant up crée les VMs puis lance automatiquement les playbooks Ansible.

Vagrantfile avec provisioning Ansible

Vagrant.configure("2") do |config|

  config.vm.define "web" do |web|
    web.vm.box = "ubuntu/jammy64"
    web.vm.hostname = "srv-web"
    web.vm.network "private_network", ip: "192.168.56.10"
    web.vm.provider "virtualbox" do |vb|
      vb.memory = 1024
    end
  end

  config.vm.define "db" do |db|
    db.vm.box = "ubuntu/jammy64"
    db.vm.hostname = "srv-db"
    db.vm.network "private_network", ip: "192.168.56.11"
    db.vm.provider "virtualbox" do |vb|
      vb.memory = 2048
    end
  end

  # Provisioning Ansible (lancé après la dernière VM)
  config.vm.define "db" do |db|
    db.vm.provision "ansible" do |ansible|
      ansible.playbook = "site.yml"
      ansible.inventory_path = "inventory.ini"
      ansible.limit = "all"
    end
  end

end

📖 Comparaison des outils de provisioning

📖 Infrastructure as Code (IaC)

Vagrant et Ansible s'inscrivent dans la philosophie Infrastructure as Code : l'infrastructure est décrite dans des fichiers texte versionnés, ce qui apporte :

• Reproductibilité : même résultat à chaque exécution
• Traçabilité : historique des modifications via Git
• Collaboration : les fichiers sont partagés et revus en équipe
• Automatisation : déploiement en une commande
• Documentation vivante : le code décrit l'infrastructure réelle

📝 QCM — Testez vos connaissances