Configurer un environnement Ansible

Quatre fichiers, un venv isolé, un playbook idempotent : la configuration Ansible qui survit six mois sans intervention.

Configurer un environnement Ansible

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.

FichierRôleSans lui
ansible.cfgdéfauts, vault, forksoption -i oubliée
inventory/hosts.ymlhôtes et groupesIP en dur
group_vars/, host_vars/variables par groupeun if par serveur
site.ymlpoint d'entréetâ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.