Configurer un environnement Ansible
Quatre fichiers, un venv isolé, un playbook idempotent : la configuration Ansible qui survit six mois sans intervention.
Mon premier playbook a redémarré la prod un mardi à 14 h. Pas par malveillance : un state: restarted collé dans une boucle qui passait sur les 42 serveurs du parc. Depuis, chaque environnement Ansible que je monte commence par les mêmes quatre fichiers, et surtout par une règle bête : rien ne part en prod sans un --check --diff qui montre exactement ce qui va changer. Voici la configuration complète, testée sur ansible-core 2.22, celle que je déploie aujourd'hui sur un VPS Debian et un parc de conteneurs.
Ansible ne fait que trois choses, et c'est suffisant
Ansible se connecte en SSH, pousse des modules Python temporaires, puis les supprime. Aucun agent à installer, aucun port supplémentaire à ouvrir : si tu sais te connecter en SSH, Ansible sait gérer la machine. C'est ce qui le distingue d'un chef ou d'un puppet, et c'est aussi sa limite — pas de démon local pour rattraper un drift entre deux exécutions.
La deuxième chose qu'il fait, c'est l'idempotence. Un module apt avec state: present vérifie l'état avant d'agir et renvoie ok si le paquet est déjà là. Tu peux relancer le même playbook dix fois, seule la première exécution rapporte du changed.
La troisième, c'est l'orchestration dans l'ordre : serial, max_fail_percentage et les handlers te donnent un déploiement progressif sans écrire une ligne de bash. Si tu hésites encore entre Ansible et Terraform, la frontière est simple : Terraform crée l'infrastructure, Ansible configure ce qui tourne dessus. J'ai détaillé ce partage dans Ansible vs Terraform : la vraie différence.
Les quatre fichiers d'un environnement qui tient
Un dépôt Ansible lisible tient dans quatre emplacements. Le reste, c'est du confort.
| Fichier | Rôle | Sans lui |
|---|---|---|
ansible.cfg | défauts, vault, forks | option -i oubliée |
inventory/hosts.yml | hôtes et groupes | IP en dur |
group_vars/, host_vars/ | variables par groupe | un if par serveur |
site.yml | point d'entrée | tâches lancées à la main |
Mon ansible.cfg tient en huit lignes, et deux d'entre elles évitent 90 % des mauvaises surprises :
[defaults]
inventory = inventory/hosts.yml
host_key_checking = False
interpreter_python = auto_silent
forks = 10
stdout_callback = yaml
callbacks_enabled = profile_tasks
vault_password_file = ~/.ansible/vault-pass
interpreter_python = auto_silent évite le warning sur les distributions où Python n'est pas dans le PATH. profile_tasks affiche le temps par tâche : sur un run de 4 minutes, tu vois immédiatement que 3 minutes partent dans un apt mal placé dans une boucle.
Installer ansible-core sans polluer le Python système
Sur Debian 13 comme sur Ubuntu 24.04, pip install ansible en root casse le gestionnaire de paquets tôt ou tard. Je passe systématiquement par l'installation par paquet Python dans un environnement isolé, avec uv :
uv venv ~/.venvs/ansible
uv pip install --python ~/.venvs/ansible/bin/python ansible-core==2.22.0 ansible-lint
~/.venvs/ansible/bin/ansible --version
La sortie doit afficher la version du core, le chemin de config et le module Python utilisé. Si config file pointe ailleurs que ton dépôt, c'est que tu lances la commande depuis le mauvais dossier — Ansible lit le ansible.cfg du répertoire courant en priorité.
Pour le confort, un alias dans le ~/.bashrc suffit : alias ans='~/.venvs/ansible/bin/ansible'. Pas besoin de source activate, et ton shell reste propre.
Un inventaire YAML qui ne pourrit pas
Le format INI est encore partout dans les tutoriels, mais il ne sait pas porter de variables imbriquées. Le YAML, si. Voici l'inventaire que j'utilise pour un front, deux back et une base :
all:
children:
web:
hosts:
front-01:
ansible_host: 91.134.135.118
ansible_user: deploy
front-02:
ansible_host: 92.222.197.3
ansible_user: deploy
api:
hosts:
api-01:
ansible_host: 10.0.0.21
api-02:
ansible_host: 10.0.0.22
vars:
app_port: 9890
db:
hosts:
pg-01:
ansible_host: 10.0.0.31
vars:
ansible_python_interpreter: /usr/bin/python3
Deux détails qui comptent. D'abord, le groupe db ne contient qu'un hôte mais garde son nom : le jour où tu ajoutes un réplica, le playbook ne change pas. Ensuite, ansible_user est déclaré par hôte, pas globalement : mon utilisateur de déploiement n'existe pas sur la base, qui accepte une clé dédiée.
Pour l'authentification, jamais de mot de passe en clair. Une clé SSH par environnement, chargée par ssh-agent, et l'empreinte de l'hôte vérifiée au premier contact. Le host_key_checking = False du ansible.cfg sert uniquement en lab — en prod, je le retire et je préremplis known_hosts via ssh-keyscan dans le pipeline.
Le premier playbook vraiment idempotent
Objectif : un serveur web prêt, avec Nginx installé, une page d'accueil et un redémarrage uniquement si la config a changé.
---
- name: Base web
hosts: web
become: true
serial: 1
tasks:
- name: Mettre à jour le cache APT
ansible.builtin.apt:
update_cache: true
cache_valid_time: 3600
- name: Installer Nginx
ansible.builtin.apt:
name: nginx
state: present
- name: Déposer la page d'accueil
ansible.builtin.copy:
src: files/index.html
dest: /var/www/html/index.html
owner: www-data
group: www-data
mode: "0644"
notify: Reload nginx
handlers:
- name: Reload nginx
ansible.builtin.service:
name: nginx
state: reloaded
Le cache_valid_time: 3600 évite de refaire un apt update à chaque tâche dans la même heure. Le handler ne se déclenche que sur changed : si la page est identique, pas de reload. Et serial: 1 garantit qu'on ne coupe pas les deux fronts en même temps — c'est la version la plus simple d'un déploiement sans coupure, avant de passer à du blue-green.
Vérifie l'idempotence en relançant deux fois : le second run doit afficher changed=0. Si un changed persiste sur une tâche copy, c'est presque toujours un fichier source dont le contenu varie (timestamp dans un template), pas Ansible qui ment. La logique de déploiement progressive est détaillée dans Passer aux déploiements automatisés sans douleur.
Tester avant de toucher la prod
Trois commandes, dans cet ordre, et je n'en saute aucune :
ansible-playbook site.yml --syntax-check
ansible-playbook site.yml --check --diff --limit front-01
ansible-lint site.yml roles/
--check simule sans appliquer, --diff affiche le contenu qui changerait. Certains modules ne supportent pas le mode check (les command: bruts notamment) : ils sont marqués skipped, et c'est normal. --limit te permet de viser un seul hôte, ce qui reste la meilleure façon de découvrir qu'un rôle suppose un paquet absent.
ansible-lint attrape le reste : tâches sans name, command au lieu d'un module, shell inutile, permissions trop larges sur les fichiers. Sur un dépôt existant, attends-toi à une cinquantaine d'avertissements le premier jour — commence par la règle no-changed-when, celle qui casse l'idempotence sans que personne ne le voie.
Les secrets, une fois pour toutes
Un mot de passe de base en clair dans group_vars/all.yml finit toujours dans l'historique git. Le chiffrement natif règle ça sans dépendance externe :
ansible-vault create group_vars/db/vault.yml
ansible-vault edit group_vars/db/vault.yml
ansible-vault rekey group_vars/db/vault.yml
Je garde deux fichiers par groupe : vars.yml en clair avec le nom des variables, et vault.yml chiffré avec les valeurs. Le playbook référence {{ vault_db_password }} et personne n'a besoin de lire le secret pour comprendre le rôle.
Le mot de passe du vault, lui, ne va ni dans le dépôt ni dans ton shell history. Soit un fichier ~/.ansible/vault-pass en chmod 600 sur le poste qui exécute, soit un vault-id qui appelle un script de récupération depuis ton coffre de secrets. Sur mes VPS, le runner tire le secret de Bitwarden au démarrage du process, exactement comme pour les autres applications.
Ranger les rôles avant que le dépôt n'explose
La règle est mécanique : dès qu'une tâche sert deux playbooks, elle devient un rôle. La structure standard, et rien d'autre :
roles/
nginx/
tasks/main.yml
handlers/main.yml
templates/nginx.conf.j2
defaults/main.yml
group_vars/
inventory/
site.yml
requirements.yml
defaults/main.yml contient les valeurs surchargeables, vars/main.yml les constantes internes. Confondre les deux est l'erreur la plus fréquente : une variable dans vars/ ne peut pas être écrasée par l'inventaire, et tu passes une heure à te demander pourquoi ton app_port: 9890 est ignoré.
Pour les dépendances externes, fige les versions dans requirements.yml et installe via Ansible Galaxy :
collections:
- name: community.docker
version: ">=3.10.0,<4.0.0"
roles:
- name: geerlingguy.nginx
version: 3.1.4
Un rôle non versionné qui publie une nouvelle release casse ton run du lundi matin, sans qu'aucune de tes lignes n'ait bougé. Le pin de version coûte deux minutes et t'évite ce genre de réveil.
Questions fréquentes
Ansible ou ansible-core, lequel installer ?
ansible-core contient uniquement les modules de base. Le paquet ansible ajoute la collection community complète, soit plusieurs centaines de modules. Pour un environnement maîtrisé, je pars sur ansible-core et j'ajoute les collections au besoin via requirements.yml : image plus légère, surface d'attaque réduite, et tu sais exactement ce que tu utilises.
Faut-il un serveur Ansible dédié ?
Non, pas avant plusieurs dizaines d'hôtes. Un runner CI ou un poste avec une clé dédiée suffit. Ce qui compte, c'est que l'exécution soit reproductible : même version, même inventaire, mêmes collections. Un ansible --version différent entre deux machines produit des comportements différents sur les mêmes tâches.
Comment gérer un hôte injoignable sans bloquer tout le play ?
any_errors_fatal coupe tout au premier échec — utile pour une migration, terrible pour un run de flotte. À l'inverse, ignore_unreachable: true sur une tâche permet de continuer et de traiter les hôtes injoignables dans un play de reprise. Je préfère cette seconde option, avec un rapport final qui liste les hôtes en échec : un serveur absent ne doit pas empêcher les 41 autres de recevoir leur configuration.
Quelle différence entre serial et strategy: free ?
serial limite le nombre d'hôtes traités simultanément, dans l'ordre des batches — c'est ce qui sécurise un redémarrage progressif. strategy: free laisse chaque hôte avancer à son rythme, ce qui accélère les parcs hétérogènes mais rend l'ordre imprévisible. Pour de la configuration système, serial. Pour du déploiement applicatif où chaque hôte est indépendant, free peut diviser le temps de run par deux.
La config minimale qui survit six mois
Quatre fichiers, un venv isolé, un inventaire en YAML, un playbook idempotent, un lint dans la CI et des secrets chiffrés : c'est tout. Le reste — AWX, rôles maison, collections exotiques — s'ajoute quand le besoin est réel, pas avant.
Le vrai test de ton environnement n'est pas la première exécution, c'est la deuxième : changed=0, zéro warning, et un run qui prend moins de temps que la fois précédente. Si ce n'est pas le cas, le problème est dans ton playbook, jamais dans Ansible.