Ansible est un outil open-source d'automatisation informatique.
Il permet de :
Déployer des applications
Installer des logiciels
Configurer des systèmes
Exécuter des tâches sur des centaines de serveurs en même temps
Particularité :
Pas besoin d'installer un agent sur les machines distantes
Utilise SSH pour se connecter aux serveurs
sudo apt update
sudo apt install ansible -y
ansible --version
Exemple de sortie :
ansible [core 2.14.2]
config file = /etc/ansible/ansible.cfg
python version = 3.11
Fichier inventory.ini :
[web]
192.168.1.20 ansible_user=debian
[all:vars]
ansible_python_interpreter=/usr/bin/python3
Ou au format YAML (plus moderne) :
all:
hosts:
web1:
ansible_host: 192.168.1.20
ansible_user: debian
Définir ton fichier ansible.cfg à la racine de ton projet :
[defaults]
inventory = ./inventory.ini
remote_user = debian
host_key_checking = False
retry_files_enabled = False
timeout = 30
forks = 10
✅ Conseil :
Tu peux aussi définir un chemin vers un répertoire d'inventaire dynamique si besoin !
Créer un fichier apache.yml :
---
- name: Installer Apache sur les serveurs
hosts: web
become: true # devient root
tasks:
- name: Installer le paquet Apache2
apt:
name: apache2
state: present
ansible-playbook apache.yml
Exemple simple pour installer plusieurs paquets :
---
- name: Installer plusieurs paquets
hosts: web
become: true
tasks:
- name: Installer les paquets utiles
apt:
name: "{{ item }}"
state: present
loop:
- apache2
- curl
- git
Explication :
loop parcourt chaque élément de la liste.
item représente l'élément actuel.
Exécuter une tâche seulement si une condition est remplie :
---
- name: Installer Apache uniquement sur Debian
hosts: web
become: true
tasks:
- name: Installer apache2
apt:
name: apache2
state: present
when: ansible_distribution == "Debian"
Autres utilisations de when :
Vérifier si une variable est définie :
when: my_variable is defined
Plusieurs conditions avec and ou or :
when: ansible_distribution == "Debian" and ansible_distribution_major_version|int >= 11
Les filtres permettent de transformer des données.
Exemple :
{{ my_list | length }}
Retourne la longueur d'une liste.
Exemple avec filtre dans une condition :
when: "'web' in group_names"
Ici on teste si le serveur appartient au groupe web.
Créer un rôle avec ansible-galaxy :
ansible-galaxy init mon_role_web
Arborescence d'un rôle :
mon_role_web/
├── defaults/ # Variables par défaut
│ └── main.yml
├── files/ # Fichiers statiques
├── handlers/ # Gestion des services (restart, reload)
│ └── main.yml
├── meta/ # Dépendances
├── tasks/ # Les actions principales
│ └── main.yml
├── templates/ # Fichiers dynamiques (avec Jinja2)
├── tests/ # Tests
└── vars/ # Variables avec priorité forte
└── main.yml
Fichier templates/index.html.j2 :
<h1>Bienvenue sur {{ inventory_hostname }} !</h1>
<p>Ton IP est : {{ ansible_default_ipv4.address }}</p>
{% if ansible_hostname == 'web1' %}
Bienvenue sur le serveur principal !
{% else %}
Bienvenue sur un autre serveur.
{% endif %}
<ul>
{% for package in packages %}
<li>{{ package }}</li>
{% endfor %}
</ul>
Ansible Vault sert à chiffrer des fichiers sensibles comme :
Les mots de passe
Les clés API
Les variables confidentielles
Cela permet de stocker les fichiers en toute sécurité, même sur GitHub.
ansible-vault encrypt secrets.yml
ansible-vault decrypt secrets.yml
ansible-vault edit secrets.yml
ansible-vault view secrets.yml
Chiffrer une seule variable :
ansible-vault encrypt_string 'super_secret_password' --name 'db_password'
Dans le playbook :
vars:
db_password: !vault |
$ANSIBLE_VAULT;1.1;AES256...
---
- hosts: web
become: true
vars_files:
- secrets.yml
tasks:
- name: Utiliser le mot de passe chiffré
debug:
msg: "Le mot de passe est {{ db_password }}"
⚠️ Important :
Ne jamais publier les mots de passe Vault ni le fichier .vault_pass.txt si tu utilises une passphrase automatique !
project-ansible/
├── ansible.cfg
├── inventory/
│ └── hosts.ini
├── group_vars/
│ ├── all.yml
│ └── secrets.yml # Vaulté
├── roles/
│ ├── apache/
│ ├── nginx/
│ └── haproxy/
├── playbooks/
│ ├── apache.yml
│ ├── nginx.yml
│ └── haproxy.yml
└── site.yml # Playbook principal
ansible.cfg : configuration de base
inventory/ : tous les serveurs cibles
group_vars/ : variables communes ou sensibles
roles/ : rôles organisés
playbooks/ : scripts Ansible pour chaque application
site.yml : point d'entrée général (include les autres playbooks)
[defaults]
inventory = ./inventory/hosts.ini
remote_user = debian
private_key_file = ~/.ssh/id_rsa
host_key_checking = False
retry_files_enabled = False
roles_path = ./roles
vault_password_file = ~/.vault_pass.txt
git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin git@github.com:monuser/mon-projet-ansible.git
git push -u origin main
plaintext
*.retry
*.log
vault_pass.txt
__pycache__/
secrets.yml
✋ N’envoie jamais les fichiers non sécurisés (comme des mots de passe en clair) !
Site pour télécharger et partager des rôles :
https://galaxy.ansible.com/
Installer un rôle :
ansible-galaxy install geerlingguy.apache
Version commerciale (payante) d'Ansible
Interface Web pour lancer des playbooks, planifier, auditer
Gère les accès utilisateurs, logs, permissions, etc.
Version open-source de Tower
Permet :
Exécuter des playbooks via un tableau de bord Web
Voir les logs d'exécution
Gérer des équipes / rôles
Toujours utiliser ansible-lint pour vérifier tes playbooks
Lancer en mode simulation :
ansible-playbook site.yml --check --diff
Organiser clairement les rôles pour faciliter la maintenance
Séparer les données sensibles dans Vault
Utiliser tags pour exécuter seulement certaines tâches :
tasks:
- name: Installer Apache
apt:
name: apache2
state: present
tags:
- apache
Exécution ciblée :
ansible-playbook site.yml --tags apache
Tu sais maintenant :
✅ Installer Ansible
✅ Utiliser les playbooks, rôles, templates
✅ Sécuriser avec Vault
✅ Organiser ton projet
✅ Déployer automatiquement !
Bravo ! 🎉 Tu peux prétendre à un niveau "DevOps Junior" solide avec ça !
Arborescence projet :
css
infra-web-ansible/
├── ansible.cfg
├── inventory/
│ └── hosts.ini
├── group_vars/
│ └── all.yml
├── roles/
│ ├── nginx/
│ ├── apache/
│ └── haproxy/
├── playbooks/
│ ├── install_nginx.yml
│ ├── install_apache.yml
│ └── install_haproxy.yml
└── site.yml
[defaults]
inventory = ./inventory/hosts.ini
remote_user = debian
private_key_file = ~/.ssh/id_rsa
host_key_checking = False
retry_files_enabled = False
roles_path = ./roles
vault_password_file = ~/.vault_pass.txt
[nginx]
192.168.1.21
[apache]
192.168.1.22
[haproxy]
192.168.1.23
[all:vars]
ansible_user=debian
ansible_python_interpreter=/usr/bin/python3
---
# Variables communes à tous les serveurs
web_server_port: 80
haproxy_port: 80
---
# Installation de NGINX
- name: Installer nginx
apt:
name: nginx
state: present
update_cache: yes
# Démarrer nginx
- name: Démarrer nginx
service:
name: nginx
state: started
enabled: yes
# Déployer une page d'accueil
- name: Copier la page d'accueil NGINX
template:
src: index_nginx.html.j2
dest: /var/www/html/index.html
owner: www-data
group: www-data
mode: '0644'
html
<h1>Bienvenue sur le serveur NGINX - {{ inventory_hostname }}</h1>
---
# Installation d'Apache
- name: Installer apache2
apt:
name: apache2
state: present
update_cache: yes
# Démarrer Apache
- name: Démarrer apache2
service:
name: apache2
state: started
enabled: yes
# Déployer une page d'accueil
- name: Copier la page d'accueil Apache
template:
src: index_apache.html.j2
dest: /var/www/html/index.html
owner: www-data
group: www-data
mode: '0644'
html
<h1>Bienvenue sur le serveur Apache - {{ inventory_hostname }}</h1>
---
# Installation de HAProxy
- name: Installer haproxy
apt:
name: haproxy
state: present
update_cache: yes
# Configurer HAProxy
- name: Déployer la configuration HAProxy
template:
src: haproxy.cfg.j2
dest: /etc/haproxy/haproxy.cfg
owner: root
group: root
mode: '0644'
notify:
- Restart haproxy
# S'assurer que HAProxy est démarré
- name: Démarrer haproxy
service:
name: haproxy
state: started
enabled: yes
---
# Handler pour redémarrer HAProxy si la config change
- name: Restart haproxy
service:
name: haproxy
state: restarted
global
log /dev/log local0
log /dev/log local1 notice
chroot /var/lib/haproxy
stats socket /run/haproxy/admin.sock mode 660 level admin
stats timeout 30s
user haproxy
group haproxy
daemon
defaults
log global
mode http
option httplog
option dontlognull
timeout connect 5000
timeout client 50000
timeout server 50000
frontend http_in
bind *:{{ haproxy_port }}
default_backend servers
backend servers
balance roundrobin
server nginx 192.168.1.21:80 check
server apache 192.168.1.22:80 check
---
- name: Installer et configurer nginx
hosts: nginx
become: true
roles:
- nginx
---
- name: Installer et configurer apache
hosts: apache
become: true
roles:
- apache
---
- name: Installer et configurer haproxy
hosts: haproxy
become: true
roles:
- haproxy
---
- import_playbook: playbooks/install_nginx.yml
- import_playbook: playbooks/install_apache.yml
- import_playbook: playbooks/install_haproxy.yml
ansible-playbook site.yml
Et ton infrastructure sera automatiquement montée :
Serveur NGINX en 192.168.1.21
Serveur Apache en 192.168.1.22
Load balancer HAProxy en 192.168.1.23
Je vais créer un nouveau rôle tests/ dans ton projet Ansible :
css
infra-web-ansible/
├── roles/
│ ├── tests/
│ │ ├── tasks/
│ │ │ └── main.yml
---
# Test de la disponibilité du service nginx
- name: Vérifier que NGINX est en écoute sur le port 80
wait_for:
host: 192.168.1.21
port: 80
timeout: 10
delegate_to: localhost
# Test de la disponibilité du service apache
- name: Vérifier que Apache est en écoute sur le port 80
wait_for:
host: 192.168.1.22
port: 80
timeout: 10
delegate_to: localhost
# Test de la disponibilité du service haproxy
- name: Vérifier que HAProxy est en écoute sur le port 80
wait_for:
host: 192.168.1.23
port: 80
timeout: 10
delegate_to: localhost
# Tester que la page NGINX est bien accessible
- name: Vérifier l'accès à la page NGINX
uri:
url: http://192.168.1.21
return_content: yes
status_code: 200
register: nginx_response
delegate_to: localhost
- name: Afficher la réponse de NGINX
debug:
var: nginx_response.content
# Tester que la page Apache est bien accessible
- name: Vérifier l'accès à la page Apache
uri:
url: http://192.168.1.22
return_content: yes
status_code: 200
register: apache_response
delegate_to: localhost
- name: Afficher la réponse de Apache
debug:
var: apache_response.content
# Test de la page HAProxy
- name: Vérifier l'accès au load balancer HAProxy
uri:
url: http://192.168.1.23
return_content: yes
status_code: 200
register: haproxy_response
delegate_to: localhost
- name: Afficher la réponse de HAProxy
debug:
var: haproxy_response.content
👉 Ajoute ce fichier dans ton projet, puis lance uniquement le rôle de test avec :
ansible-playbook -i inventory/hosts.ini -l localhost -e "ansible_connection=local" tests.yml
(Je vais aussi créer un petit tests.yml spécial pour lancer tout ça.)
J'intègre le rôle tests
Je mets à jour ton site.yml pour inclure une option de tests à la fin
Je prépare l'archive ZIP complète
Je prépare le PDF final tout bien organisé avec toutes les explications détaillées (y compris les tests automatiques)
Voici ce que le script deploy.sh va contenir. Tu peux le placer à la racine de ton projet Ansible :
#!/bin/bash
# Variables pour l'inventaire
INVENTORY="./inventory/hosts.ini"
# Vérification si Ansible est installé
if ! command -v ansible &> /dev/null
then
echo "Ansible n'est pas installé. Installation..."
sudo apt update
sudo apt install ansible -y
else
echo "Ansible est déjà installé."
fi
# Vérifier la version d'Ansible
ansible --version
# Lancer les playbooks de déploiement
echo "Lancement des playbooks pour déployer NGINX, Apache, et HAProxy..."
ansible-playbook -i "$INVENTORY" site.yml
# Lancer les tests de vérification
echo "Lancement des tests de disponibilité des services..."
ansible-playbook -i "$INVENTORY" tests.yml
# Fin
echo "Déploiement et tests terminés avec succès !"
Vérification de l'installation d'Ansible :
Si Ansible n'est pas installé, le script l'installe automatiquement.
Si Ansible est déjà installé, il passe directement à la suite.
Exécution des playbooks :
Le script exécute le playbook principal site.yml pour déployer NGINX, Apache, et HAProxy.
Exécution des tests :
Une fois le déploiement effectué, il exécute les tests pour vérifier que les services sont bien accessibles.
Message de fin :
Le script informe que le déploiement et les tests sont terminés.
Place le fichier deploy.sh à la racine de ton projet Ansible.
Rendre le script exécutable :
chmod +x deploy.sh
Exécute le script :
./deploy.sh
Ce script va tout gérer, du déploiement au test, en passant par l'installation d'Ansible si nécessaire. C'est une manière simple et rapide d'exécuter tout ton projet. 🚀