Table des matières

Ansible en partant de zéro

Après une formation de 3 jours, voici un mémo post formation qui me sert de révision. Donc Ansible comme Salt, Puppet est une solution d'automatisation des taches. Il n'utilise pas d'agent et se base uniquement sur une connexion SSH sur les cibles (SSH ou WinRM pour les cibles Windows) et python. Pour que cela foncionne sans prise de tete il faut donc que les cibles aient un compte avec un acces par clé. IL EST FORTEMENT D'ECONSEILLE D'UTILISER LE COMPTE ROOT !!! Mais comme la plupart des commandes nécessitent une élévation de droit il faut alors que le compte soit OBLIGATOIREMENT dans le groupe sudo. On ne parlera pas des solutions de coffre vault, de chiffrement ou autre car c'est un usage avancé. On ne parle pas de serveur ansible mais plutot de “pilote” ou “master” car n'importe quelle machine peut être pilote. Du coup si on travaille en équipe il est donc fortement conseillé d'utiliser le meme répertoire “projet” qui contiendra toutes les configurations, fichiers, répertoires, etc.. Le plus simple est alors soit un partage réseau soit un dépot Git (GitHub ou GitLab). On ne traitera pas ce point.

Mise en place du Lab

Par défaut, ansible exécutera les commandes sur les cibles avec le meme compte qui est utilisé sur la machine pilote. Si on travaille en équipe, chacun a son login. Ce n'est pas impossible mais cela va être fastidieux de gérer tous les comptes en sudo sur toutes les cibles. Donc il est préférable d'avoir un seul compte sur les cibles en sudo qui sera utilisé pour ansible. Dans ce cas il faudra le fixer dans la configuration de chaque playbook, la recette d'une automatisation.

Pour un usage plus détaillé: https://docs.ansible.com/projects/ansible/latest/inventory_guide/connection_details.html

Installer la machine pilote

Avec votre compte, pas du root et ni en SUDO, on installe ansible avec la méthode conseillé: PIPX. Le pakage de votre distribution risque de ne pas suivre les versions ou diverger sur des fonctionnalités. On installe d'abord les outils avant d'installer ansible . (en root ou sudo)

sudo apt install pipx yamllint tree jq git

Installation de pip avec son compte normal (pas en root ou sudo )

pipx install ansible --include-deps

Voilà, pour vérifier l'instllation:

ansible --version

retours attendu:

ansible [core 2.21.4]
  config file =
  configured module search path = ['/home/beemoon/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /home/beemoon/.local/share/pipx/venvs/ansible/lib/python3.13/site-packages/ansible
  ansible collection location = /home/beemoon/.ansible/collections:/usr/share/ansible/collections
  executable location = /home/beemoon/.local/bin/ansible
  python version = 3.13.5 (main, Aug 10 2026, 12:06:59) [GCC 14.2.0] (/home/beemoon/.local/share/pipx/venvs/ansible/bin/python)
  jinja version = 3.1.6
  pyyaml version = 6.0.3 (with libyaml v0.2.5)

Création d'un répertoire projet

On peut avoir plusieurs projets ansible sur la machine pilote. Ce répertoire contiendra l'ensemble de la configuration et de la structure des dossiers du projet. Il regroupe toutes les taches d'automatisation organisées dans un fichier playbook au format yaml. On regroupe un ensemble d'action pour une tache dans un playbook. Il est donc possible d'avoir plusieurs playbooks. Un dossier projet DOIT avoir au minimum un fichier de configuration nommé OBLIGATOIREMENT ansible.cfg

Dans la commande ansible –version plus haut, on voit dans le retours de la commande qu'il n'y a pas encore de “config file”. Il faut juste créer ansible.cfg meme vide et se déplacer dans le répertoire projet

mkdir ansible
cd ansible
touch ansible.cfg

Lister les cibles (target)

L'objectif est d'automatiser les taches sur un ensemble de cible. Généralement ces cibles sont des serveurs. Pour une prise en main de ansible on va lister manuellemennt ces machines. Mais il est tout àfait possible d'avoir une liste automatique fournie par un serveur vCenter, Proxmox, solution de monitoring, etc…

La liste de ces cibles est dans un fichier qui sera à déclarer dans ansible.cfg. Anfin de structurer le projet on mettra par exemple ce fichier dans le répertoire ansible/mesCibles sous le nom de serveurs.txt

vi ansible.cfg

Contenu

[defaults]
inventory = mesCibles/serveurs.txt

Le fichier serveurs.txt contient le hostname des machines soit sous forme FQDN soit sous un nom cours si la résolution DNS fonctionne et un hostname par ligne. Il est possible de créer des groupes. Une machine peut etre dans plusieurs groupes.

vi mesCibles/serveurs.txt

Contenu

machineA
machineB
machineC

[www]
machineB
machineD

[proxy]
machineE
machineA

Ici nous avons 3 groupes: 2 explicites www et proxy et 1 implicite “all”

Le compte d'automatisation sur les cibles et clé SSH.

On suppose que vous pouvez vous connecter sur les cibles en SSH depuis la machine pilote avec votre compte en cours actuellement. Vous vous connectez avec un mot de passe sur la cible. On va donc maintenant utiliser une clé à la place du mot de passe. Cette clé sera utilisée par ansible. L'endroit où sera stockée la clé privée doit être définit dans le fichier ansible.cfg

le fichier ansible.cfg doit contenir maintenant

[defaults]
inventory          = mesCibles/serveurs.txt
private_key_file   = cleSSH/ansible

Il faut donc:

mkdir cleSSH
ssh-keygen -t ed25519 -f cleSSH/ansible
ssh-copy-id -i cleSSH/ansible maCible

Voilà on a le strict minimum pour commencé à utiliser ansible. Viendra par la suite plus d'élément pour une utilisation avancéé en ajoutant d'autre répertoires et fichiers dans l'arborescence du dossier projet et d'autres paramètres dans ansible.cfg.

Premier pas avec ansible.

Les commandes "ad-hoc"

Les commandes ad-hoc sont des lignes de commandes dans un terminal pour exécuter une tache ansible à la demande. C'est comme quand vous exécuter une command shell.

Par exemple pour lancer un ping sur une machine:

ping machineA
ping machineB
ping machineX

on peut faire la meme chose avec ansible… mais le faire sur une seule machine, il n'y a pas d'interet d'utiliser ansible. Par contre pour toutes les machines ou groupe déclarées dans notre fichier cible c'est plus interessant.

IMPORTANT: il faut etre dans le dossier projet qu'on veut utiliser avant de lance une quelconque commande ansible

cd ansible
ansible all -m ping

une commande ad-hoc est composée au minimum:

ansible all -m ping -a "data=ok"

pour connaitre les paramètres possible du module utilisé, ansible intègre par défaut une documentation liée au module installé.

ansible-doc ping

Il existe des centaines de module ! Il est possible qu'il y ait des modules avec le même nom mais provenant obligatoirement de diffrent fournisseur appelé aussi “espace de nom”. Il ne peut pas y avoir 2 modules avec le meme nom pour un meme espace de nom. Donc pour ne pas avoir de problème lors de l'appel il est TRES FORTEMENT conseillé d'utiliser leur nom complet.

Ici ping : ansible.builtin.ping

ansible all -m ansible.builtin.ping -a "data=ok"

Enfin pour connaitre la liste des modules installés sur votre machine pilote

ansible-doc -l

La liste de tous les modules: https://docs.ansible.com/projects/ansible/latest/collections/index_module.html

TOUS les modules ont besoin de python présent sur les cibles pour s'exécuter SAUF un et un seul, le module RAW

Ansible a un retours des résulats explicite en couleur selon le résultat de l'exécution du module.


🟢 Le Vert (SUCCESS / OK): La tâche s'est exécutée avec succès, mais aucun changement n'a été effectué sur la machine cible.

🟡 Le Jaune (CHANGED): La tâche s'est exécutée avec succès et un ou plusieurs changements ont été appliqués sur la machine cible.

🔴 Le Rouge (FAILED) : La tâche a échoué. L'exécution du playbook s'arrête généralement ici pour l'hôte concerné (sauf si vous utilisez ignore_errors: true).

🔵 Le Bleu ou Cyan (SKIPPED) : La tâche a été ignorée.

🟣 Le Violet / Magenta (DEPRECATION / WARNING) : Un avertissement concernant votre code.

Le fichier "playbook"

Les commandes ad-hoc sont utiles que pour tester manuellement un module ou faire un controle rapide. Dans l'objectif d'automatisation on utilisera des playbooks. C'est un fichier de recette au format yaml. Il décrit les taches successives à éxécuter dans l'ordre de leur déclaration.

Les taches dans un playbook décrivent des actions et un état final de chaque action que doit atteindre la cible. La tache est toujours exécuter pour éxécuter l'action décrite. Mais si l'état final de l'action est déjà satisfait alors elle n'est pas rejouée et passe à la tache suivante. C'est l'idempotencce . Un retours couleur (voir plus haut) est toujours retourné pour chaque tache éxécuté du playbook.

Pour démarrer un playbook on lance la commande: ansible-playbook cible playbook

ansible-playbook all ping

Le format yaml du playbook est strict ! S'il y a une erreur d'indentation ou d'espace en fin de ligne, il y aura un échec d'exécution.

Structure du playbook

---
- name: Un nom de la tâche 1
  hosts: lesCibles

  tasks: liste les actions pour la tache 1
  - name: Nom d'une action 1
    ansible.builtin.pin: module à utiliser
      name: paramètre 1 du module
      state: paramètre 2 du module

  - name: Nom d'une action 2
    ansible.builtin.package: module à utiliser
      name: paramètre 1 du module
      state: paramètre 2 du module

- name: Un nom de la tâche 2
  hosts: lesCibles

  tasks: liste les actions pour la tache 2
  - name: Nom d'une action 1
    ansible.builtin.pin: module à utiliser
      name: paramètre 1 du module
      state: paramètre 2 du module

  - name: Nom d'une action 2
    ansible.builtin.package: module à utiliser
      name: paramètre 1 du module
      state: paramètre 2 du module

state est l'état que doit atteindre la cible.

Rappel: les paramètres sont listés avec “ansible-doc moonModule”

Pour une playbook ping

---
- name: Verifier si les machines sont allumées
  hosts: all

  tasks:
  - name: Execute un ping
    ansible.builtin.ping:
      data: ok

La commande ping ne modifie rien sur la cible. Il n'y a pas d'état à atteindre, donc pas de paramètre “state”. L'action de la tache sera donc toujours exécutée.

Equilibrage de performance

Lorsque votre infastructure est conséquente en nombre de cible à gérer, il faut savoir que ansible traite par lot de 5 cibles par défaut. On peut modifier ce lot par un parametre de “fork”

ansible-playbook playbook-ping.yml --forks 10
[defaults]
forks = 50

Bonus VIM

Si vous utilisez VIM comme editeur de code voici une configuration adaptée pour éditer du yaml.

Lors de la péparation du Lab on a installé un outils (indépendant de ansible) qui permet de controler la syntaxe d'un fichier yaml, yamllint. Il vous indiquera s'il y a une erreur avant de lancer votre playbook.

yamllint playbook.yml

De plus voici une configuration de VIM pour une sythaxe et coloration pour yaml

installez d'abord un plugin

git clone https://github.com/Yggdroot/indentLine.git ~/.vim/pack/vendor/start/indentLine

puis ajoutez dans votre ~/.vimrc

syntax on
set number
autocmd FileType yaml setlocal ts=2 sts=2 sw=2 expandtab
let g:indentLine_char = '⦙'

Après avoir validé la syntaxe yamllint, il est fortement recommandé de valider les tâches et actions du playbook AVANT de l'appliquer. Pour cela il faut passer 2 paramètres: –check –diff

ansible-playbook playbook-ping.yml --check --diff

https://blog.stephane-robert.info/docs/infra-as-code/gestion-de-configuration/ansible/ecrire-code/playbooks/checkmode-diff/

Maintenant qu'on a les bases passons aux choses sérieuses !