Les Inventaires Statiques Ansible

Au cœur d’Ansible réside un concept fondamental : les inventaires (inventories en anglais). Les inventaires Ansible sont essentiels pour cataloguer et gérer les serveurs, les ordinateurs et d’autres équipements informatiques ciblés par les scripts automatisations.

Les inventaires Ansible peuvent être statiques ou dynamiques, s’adaptant automatiquement aux environnements changeants en interrogeant des sources de données externes.

Dans ce guide, nous allons explorer en profondeur les inventaires statiques Ansible.

Qu’est-ce qu’un Inventaire Statique Ansible ?

Un inventaire statique dans Ansible est un fichier où les hôtes (serveurs, conteneurs, équipements réseau…) sont définis manuellement et ne changent pas automatiquement. Il s’agit de la méthode la plus simple pour commencer avec Ansible, car elle ne nécessite aucun script ou plugin externe.

Où sont déclarés les hôtes ?

Dans un fichier texte au format INI ou YAML, généralement nommé hosts, inventory.ini, inventory.yml, etc. Ce fichier est ensuite référencé dans le fichier ansible.cfg ou via l’option -i des commandes Ansible.

Exemple simple au format INI :

[web]
192.168.1.10
192.168.1.11

[db]
192.168.1.20

Ici, deux groupes sont définis : web et db. Chaque groupe contient des adresses IP des machines.

Pourquoi dit-on “statique” ?

Car les hôtes sont inscrits manuellement dans le fichier et ne sont pas mis à jour dynamiquement par Ansible. Si une nouvelle machine est ajoutée à votre infrastructure, vous devez éditer le fichier à la main pour l’y inclure.

Quand utiliser un inventaire statique ?

C’est le bon choix si :

• Vous gérez une infrastructure fixe ou peu changeante.
• Vous réalisez des tests en local, par exemple avec le plugin local.
• Vous souhaitez maîtriser complètement la composition de votre parc sans dépendre d’un service externe.

Localisation du fichier d’inventaire

Vous pouvez le placer où vous voulez, mais il est conseillé de l’intégrer dans la structure de votre projet Ansible, par exemple :

[webservers]
webserver1 ansible_host=192.168.1.10
webserver2 ansible_host=192.168.1.11

[dbservers]
dbserver1 ansible_host=192.168.1.20
dbserver2 ansible_host=192.168.1.21

Et dans le fichier ansible.cfg :

[defaults]
inventory = inventory/hosts.ini

Le fichier devient alors la source de vérité de votre infrastructure Ansible.

Structure d’un inventaire statique INI

Le format INI est le format historique utilisé par Ansible pour les fichiers d’inventaire. Il est simple à écrire et à lire, ce qui en fait une bonne option pour les environnements simples ou pour débuter.

Définition des groupes et des hôtes

Les hôtes sont organisés par groupes dans le fichier INI. Chaque groupe est défini entre crochets [], suivi de la liste des hôtes appartenant à ce groupe.

Exemple basique :

[web]
server1
server2

[db]
db1

Dans cet exemple :

• Le groupe web contient deux hôtes : server1 et server2.
• Le groupe db contient l’hôte db1.

Ces noms peuvent être :

• des adresses IP (192.168.1.100),
• des noms DNS (web.example.com),
• ou des noms d’hôtes logiques (avec variables associées).

Ajout de variables d’hôtes

Il est possible d’associer des variables à chaque hôte directement dans l’inventaire :

[web]
web1 ansible_user=admin ansible_port=2222
web2 ansible_user=admin ansible_ssh_private_key_file=~/.ssh/id_rsa

Ces variables contrôlent le comportement d’Ansible :

• ansible_user : utilisateur SSH à utiliser.
• ansible_port : port SSH.
• ansible_ssh_private_key_file : chemin vers la clé privée.

Définir des variables de groupe

On peut également déclarer des variables communes à tous les hôtes d’un groupe avec une section :vars :

[web]
web1
web2

[web:vars]
nginx_version=1.18.0

Tous les hôtes du groupe web hériteront de la variable nginx_version.

Groupes enfants

Ansible permet de créer une hiérarchie entre groupes avec la syntaxe :children :

[frontend]
web1
web2

[backend]
db1
db2

[app:children]
frontend
backend

Le groupe app contient alors tous les hôtes des groupes frontend et backend.

Exemple complet

[frontend]
web1 ansible_host=192.168.1.10 ansible_user=deploy
web2 ansible_host=192.168.1.11 ansible_user=deploy

[backend]
db1 ansible_host=192.168.1.20 ansible_user=dbadmin

[frontend:vars]
nginx_version=1.18.0
ansible_ssh_common_args='-o StrictHostKeyChecking=no'

[app:children]
frontend
backend

Ce fichier est prêt à être utilisé dans un projet Ansible pour gérer plusieurs groupes avec des variables dédiées.

Rappel : pour utiliser ce fichier en ligne de commande, il suffit de lancer :

ansible-inventory -i hosts.ini --list
ansible-playbook -i hosts.ini playbook.yml

Ce format est simple, lisible et rapide à écrire. Mais pour des projets plus complexes ou structurés, on peut préférer le format YAML — abordé au chapitre suivant.

Structure d’un inventaire statique YAML

Le format YAML est une alternative plus moderne au format INI pour les inventaires Ansible. Il est plus expressif, plus structuré, et mieux adapté à des environnements complexes. Ansible le prend en charge nativement via le plugin YAML d’inventaire.

Syntaxe de base

Un fichier d’inventaire YAML commence par la racine all, puis utilise les clés children, hosts, et vars pour organiser les groupes, les hôtes et leurs variables.

Exemple minimal :

all:
  hosts:
    localhost:
      ansible_connection: local

Cet inventaire déclare un seul hôte local, avec une connexion locale (utile pour des tests ou des TPs sur votre machine).

Organisation par groupes

Les hôtes peuvent être organisés en groupes imbriqués avec children, et chaque hôte peut recevoir des variables spécifiques.

Exemple avec plusieurs groupes :

all:
  children:
    web:
      hosts:
        web1:
          ansible_host: 192.168.1.10
          ansible_user: admin
        web2:
          ansible_host: 192.168.1.11
          ansible_user: admin
      vars:
        nginx_version: "1.18.0"

    db:
      hosts:
        db1:
          ansible_host: 192.168.1.20
          ansible_user: dbadmin

• Le groupe web contient web1 et web2, avec des variables de groupe.
• Le groupe db contient db1, avec ses propres variables d’hôte.

Groupes de groupes

On peut combiner des groupes en créant des groupes de groupes, exactement comme dans le format INI.

all:
  children:
    frontend:
      hosts:
        web1:
        web2:
    backend:
      hosts:
        db1:
        db2:
    app:
      children:
        frontend:
        backend:

Le groupe app englobe frontend et backend. C’est utile pour appliquer un playbook à toute l’application.

Déclaration de variables

Les variables peuvent être déclarées :

• au niveau d’un groupe (vars sous children)
• au niveau d’un hôte (hosts → nom → variable)

Cela permet une définition claire et centralisée des paramètres d’exécution.

Exemple complet d’inventaire YAML

all:
  children:
    frontend:
      hosts:
        web1:
          ansible_host: 10.0.0.11
          ansible_user: deploy
        web2:
          ansible_host: 10.0.0.12
          ansible_user: deploy
      vars:
        nginx_version: "1.18.0"
    backend:
      hosts:
        db1:
          ansible_host: 10.0.0.21
          ansible_user: dbuser
    app:
      children:
        frontend:
        backend

Utilisation avec Ansible

Pour exécuter un playbook avec un inventaire YAML :

ansible-playbook -i inventory.yml playbook.yml

Pour visualiser sa structure :

ansible-inventory -i inventory.yml --list -y

Le format YAML est plus rigide que INI (syntaxe à respecter scrupuleusement) mais il apporte une lisibilité supérieure et une extensibilité idéale pour les projets structurés.

Variables d’inventaire

Il est possible de structurer les variables Ansible hors des fichiers d’inventaire, en utilisant les dossiers group_vars/ et host_vars/. Ces répertoires permettent de gérer les paramètres de manière plus claire et modulaire, particulièrement dans les projets Ansible organisés.

Structure recommandée

Ansible recherche automatiquement ces répertoires à côté du fichier d’inventaire.

Exemple de structure de projet :

inventaire/
  hosts.ini
group_vars/
  web.yml
  all.yml
host_vars/
  web1.yml
  db1.yml

Définir des variables de groupe

Pour appliquer des variables à un groupe entier, créez un fichier YAML dans group_vars/ portant le nom exact du groupe.

Exemple group_vars/web.yml :

nginx_version: "1.18.0"
ansible_user: admin

Définir des variables d’hôte

Pour des variables spécifiques à un seul hôte, utilisez host_vars/ :

Exemple host_vars/web1.yml :

ansible_host: 192.168.1.10
ansible_user: deploy

Priorité des variables

Ansible applique une hiérarchie stricte entre les sources de variables. Voici les principales (du plus faible au plus fort) :

• role/defaults
• group_vars/ puis host_vars/
• Variables définies dans le playbook (vars)
• Variables enregistrées via set_fact
• Variables passées en ligne de commande (-e)

Exemple de surcharge : une variable ansible_user définie dans host_vars/web1.yml prendra le dessus sur celle de group_vars/web.yml.

Bonnes pratiques

• Utiliser group_vars/all.yml pour les variables globales à tous les hôtes.
• Centraliser les paramètres de connexion (ansible_user, ansible_port, etc.).
• Chiffrer les variables sensibles avec Ansible Vault :

ansible-vault encrypt host_vars/web1.yml

• Préférer les fichiers séparés à l’injection inline pour plus de lisibilité et de réutilisabilité.

Avec cette méthode, vos inventaires restent propres, faciles à maintenir et vos playbooks deviennent véritablement adaptables à tout environnement.

Utilisation de la commande ansible-inventory

La commande ansible-inventory permet de visualiser et diagnostiquer la structure complète de vos inventaires, sans exécuter de playbook. Elle est particulièrement utile pour confirmer la présence des hôtes, des groupes, et des variables associées.

--list : voir la structure complète

Cette option affiche tout l’inventaire sous forme de JSON ou YAML.

ansible-inventory --list -y

Vous verrez :

• la liste des groupes,
• les hôtes par groupe,
• les variables (via _meta.hostvars).

--graph : visualiser la hiérarchie des groupes

Elle montre l’arborescence entre groupes et sous-groupes, avec les hôtes associés.

ansible-inventory --graph

Exemple de sortie :

@all:
  |--@web:
  |  |--web1

--vars : afficher les variables

À utiliser avec --list ou --graph, cette option ajoute les variables associées à chaque hôte.

ansible-inventory --list -y --vars

Utile pour vérifier la prise en compte de fichiers group_vars/ et host_vars/.

Résumé des options clés

Option	Utilité
--list	Vue complète de l’inventaire (JSON par défaut)
--list -y	Idem au format YAML
--graph	Affiche la hiérarchie des groupes
--vars	Affiche les variables des hôtes

Ces commandes permettent de valider votre inventaire avant exécution, de déboguer les erreurs de portée de variables, et de documenter la structure de votre infrastructure.

Plugin local et exécution sur hôte local

Ansible est conçu pour exécuter des tâches à distance via SSH. Cependant, dans certains cas, on souhaite lancer des playbooks sur la machine locale (celle où Ansible est installé). C’est notamment utile pour :

• les tests,
• les environnements de développement,
• les formations,
• l’automatisation de tâches système locales.

Le plugin local est un plugin de connexion intégré à Ansible. Il permet de lancer des commandes sans SSH, directement sur la machine de contrôle.

Pour exécuter Ansible localement, il suffit de déclarer un hôte avec la variable ansible_connection=local.

Exemple au format INI :

[local]
localhost ansible_connection=local

Exemple YAML équivalent :

all:
  hosts:
    localhost:
      ansible_connection: local

Vous pouvez alors exécuter un playbook comme suit :

ansible-playbook -i inventory.ini playbook.yml

ou même, sans fichier d’inventaire, en ligne directe :

ansible-playbook -i localhost, -c local playbook.yml

(Remarquez la virgule après localhost, nécessaire pour éviter que le nom soit interprété comme un fichier.)

Exercices pratiques : Utiliser un inventaire statique avec Ansible

Vous avez maintenant une bonne compréhension des inventaires statiques dans Ansible : leur format, leur structure, l’ajout de variables, ainsi que l’usage du plugin local. Passons à l’étape suivante : pratiquer en situation réelle.

Dans ce TP, vous allez créer un inventaire statique simple, configurer un projet Ansible minimal, exécuter des tâches localement, et observer comment Ansible utilise cet inventaire pour cibler la machine hôte.

👉 Travaux pratiques : TP 1 : Inventaires statiques Ansible en local ↗

Ces exercices couvrent notamment

• La création d’un inventaire statique au format INI avec un seul hôte localhost
• La déclaration du plugin de connexion : ansible_connection=local
• La mise en place d’un fichier ansible.cfg minimal
• L’écriture d’un playbook simple : ping, debug, création de fichier
• L’utilisation de ansible-inventory pour visualiser la structure de l’inventaire
• Le test en ligne de commande avec ansible et l’option -i pour cibler l’inventaire

Pourquoi pratiquer ?

Apprendre à utiliser un inventaire statique vous permettra de :

• Déployer rapidement des automatisations locales
• Acquérir les bons réflexes de structuration de projet Ansible
• Comprendre la chaîne d’exécution entre l’inventaire, les variables et le playbook
• Préparer vos futurs projets de manière robuste, même dans des environnements plus complexes

Clonez le dépôt ou suivez les consignes directement en ligne. Grâce à ces exercices ciblés, vous allez maîtriser les fondamentaux des inventaires statiques et poser une base solide pour automatiser vos premiers déploiements avec Ansible.

Contrôle de connaissances : Inventaires statiques Ansible

Pourquoi ce contrôle ?

Cet contrôle va vous permettre de valider vos connaissances sur le sujet abordé dans le guide. Il comporte des QCM, des questions vrai/faux et des réponses ouvertes à un mot.

🕒 Le chronomètre commence dès que vous cliquez sur Démarrer le test. Vous devrez terminer l’examen avant la fin du temps imparti.

🎯 Pour réussir, vous devez obtenir au moins 80% de bonnes réponses.

💡 Je ne fournis pas directement les réponses aux questions. Cependant, si certaines sont complexes, des pistes d’explication pourront être proposées dans le guide ou après l’examen.

Bonne chance ! 🚀

Démarrer le test

Temps restant :

Conclusion

Vous maîtrisez désormais les fondementaux des inventaires statiques Ansible : leur structure, les formats INI et YAML, la gestion des variables, ainsi que leur utilisation en local. Ces compétences sont essentielles pour organiser vos projets et cibler efficacement vos hôtes.

🎯 Prochaine étape : passez à l’écriture de playbooks, cœur de l’automatisation avec Ansible. Vous y apprendrez à décrire des tâches, et déployer vos configurations de manière répétable et fiable.