Ansible s’est imposé comme l’outil d’automatisation de référence pour l’administration système et le déploiement d’infrastructure. Sans agent à installer sur les machines cibles, avec une syntaxe YAML lisible et une courbe d’apprentissage accessible, il permet d’automatiser en quelques lignes ce qui prendrait des heures manuellement. Pour un étudiant en BTS SIO ou un administrateur junior, maîtriser Ansible représente un atout considérable sur le marché de l’emploi.

Ce guide vous accompagne de l’installation à l’écriture de votre premier playbook complet, en passant par les concepts fondamentaux et les cas d’usage concrets adaptés au contexte d’un étudiant en informatique.

Pourquoi apprendre Ansible en 2026

L’automatisation IT n’est plus un luxe réservé aux grandes entreprises. Avec la multiplication des serveurs (physiques, virtuels, conteneurs), la gestion manuelle machine par machine est devenue impraticable. Ansible répond à ce besoin avec une philosophie simple : décrire l’état souhaité de l’infrastructure, et laisser l’outil s’assurer que cet état est atteint.

Ansible dans l’écosystème DevOps

Ansible occupe une place centrale dans la chaîne d’outils DevOps. Il se positionne entre Terraform (qui provisionne l’infrastructure cloud) et les outils de CI/CD (qui déploient les applications). Concrètement, Terraform crée les serveurs, Ansible les configure, et Jenkins ou GitLab CI déploie le code applicatif. Cette complémentarité expliqué pourquoi les offres d’emploi DevOps mentionnent presque systématiquement Ansible.

Ansible vs les alternatives

Trois outils dominent le marché de la gestion de configuration : Ansible, Puppet et Chef. Ansible se distingue par deux caractéristiques décisives pour un débutant : l’absence d’agent (il utilisé SSH, déjà présent sur tout serveur Linux) et l’utilisation de YAML (un format lisible, contrairement au Ruby de Puppet/Chef).

Selon la documentation officielle d’Ansible, l’outil gère aujourd’hui des millions de nœuds à travers le monde, du petit réseau local au datacenter de milliers de serveurs.

Installer Ansible sur votre poste

Ansible s’installe uniquement sur la machine de contrôle (votre poste de travail ou un serveur dédié). Les machines cibles n’ont besoin que d’un serveur SSH et de Python, généralement déjà présents sur toute distribution Linux.

Installation sur Debian/Ubuntu

sudo apt update
sudo apt install -y ansible

Cette commande installé Ansible et ses dépendances via les dépôts officiels. Pour obtenir la dernière version, ajoutez le PPA Ansible :

sudo apt install -y software-properties-common
sudo add-apt-repository --yes ppa:ansible/ansible
sudo apt update
sudo apt install -y ansible

Installation via pip (méthode recommandée)

L’installation via pip permet d’obtenir la version la plus récente, indépendamment de votre distribution :

python3 -m pip install --user ansible

Vérifiez l’installation avec ansible --version. En mars 2026, la version stable est Ansible 10.x (ansible-core 2.17).

Installation sur macOS et Windows

Sur macOS, utilisez Homebrew : brew install ansible. Sur Windows, Ansible ne s’installe pas nativement ; utilisez WSL2 (Windows Subsystem for Linux) pour disposer d’un environnement Linux complet. Notre guide Linux pour débutants détaille l’installation de WSL2.

Les concepts fondamentaux d’Ansible

Avant d’écrire votre premier playbook, quatre concepts doivent être compris. Ils constituent le vocabulaire de base que vous retrouverez dans toute la documentation.

L’inventaire : déclarer ses machines

L’inventaire (inventory) liste les machines que vous souhaitez gérer. Dans sa forme la plus simple, c’est un fichier texte listant des adresses IP ou des noms d’hôtes, organisés en groupes :

[webservers]
192.168.1.10
192.168.1.11

[databases]
192.168.1.20

[bts_sio:children]
webservers
databases

Ce fichier déclare deux groupes (webservers et databases) et un méta-groupe (bts_sio) qui englobe les deux. Vous pouvez cibler un groupe spécifique ou l’ensemble de votre parc.

Les modules : les briques d’action

Un module Ansible réalise une action précise : installer un paquet, copier un fichier, démarrer un service, créer un utilisateur. Ansible fournit plus de 3 000 modules couvrant la quasi-totalité des besoins d’administration. Les plus utilisés :

• apt / yum / dnf : gestion de paquets
• copy / template : transfert et génération de fichiers
• service / systemd : gestion des services
• user / group : gestion des utilisateurs
• file : création de répertoires, liens symboliques, permissions
• command / shell : exécution de commandes (à utiliser en dernier recours)
• firewalld / ufw : configuration du pare-feu

Les playbooks : orchestrer les actions

Un playbook est un fichier YAML qui décrit une séquence de tâches à exécuter sur un ensemble de machines. C’est le cœur d’Ansible : vous y décrivez l’état souhaité de votre infrastructure de manière déclarative.

L’idempotence : le principe clé

L’idempotence signifie qu’exécuter un playbook une fois ou dix fois produit le même résultat. Si un paquet est déjà installé, Ansible ne le réinstalle pas. Si un fichier de configuration est déjà à jour, il n’est pas modifié. Ce principe garantit que vos playbooks sont sûrs à exécuter à tout moment, sans risque de casser une configuration fonctionnelle.

Votre premier playbook Ansible pas à pas

Passons à la pratique avec un playbook complet qui configure un serveur web Nginx. Ce cas d’usage est représentatif des tâches d’un administrateur junior et correspond à des situations de TP en BTS SIO SISR.

Structure du projet

mon-projet-ansible/
├── inventory.ini
├── playbook.yml
├── files/
│   └── index.html
└── templates/
    └── nginx.conf.j2

Le fichier d’inventaire

# inventory.ini
[webservers]
serveur1 ansible_host=192.168.1.10 ansible_user=admin
serveur2 ansible_host=192.168.1.11 ansible_user=admin

[webservers:vars]
ansible_python_interpreter=/usr/bin/python3

Le playbook complet

# playbook.yml
---
- name: Configurer un serveur web Nginx
  hosts: webservers
  become: yes

  vars:
    domain_name: "mon-site.local"
    document_root: "/var/www/{{ domain_name }}"

  tasks:
    - name: Mettre a jour le cache APT
      apt:
        update_cache: yes
        cache_valid_time: 3600

    - name: Installer Nginx
      apt:
        name: nginx
        state: présent

    - name: Créer le répertoire du site
      file:
        path: "{{ document_root }}"
        state: directory
        owner: www-data
        group: www-data
        mode: '0755'

    - name: Deployer la page d'accueil
      copy:
        src: files/index.html
        dest: "{{ document_root }}/index.html"
        owner: www-data
        group: www-data
      notify: Recharger Nginx

    - name: Deployer la configuration Nginx
      template:
        src: templates/nginx.conf.j2
        dest: "/etc/nginx/sites-available/{{ domain_name }}"
      notify: Recharger Nginx

    - name: Activer le site
      file:
        src: "/etc/nginx/sites-available/{{ domain_name }}"
        dest: "/etc/nginx/sites-enabled/{{ domain_name }}"
        state: link
      notify: Recharger Nginx

    - name: Desactiver le site par défaut
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
      notify: Recharger Nginx

    - name: S'assurer que Nginx est demarre
      service:
        name: nginx
        state: started
        enabled: yes

  handlers:
    - name: Recharger Nginx
      service:
        name: nginx
        state: reloaded

Exécution et résultat

Lancez le playbook avec la commande :

ansible-playbook -i inventory.ini playbook.yml

Ansible affiche le résultat de chaque tâche avec un code couleur : vert (ok, aucun changement), jaune (changed, modification effectuée), rouge (failed, erreur). L’option --check permet un « dry run » qui simule l’exécution sans modifier les machines.

Les templates Jinja2 : générer des configurations dynamiques

Les templates Jinja2 constituent l’une des fonctionnalités les plus puissantes d’Ansible. Ils permettent de générer des fichiers de configuration personnalisés pour chaque machine, en utilisant des variables.

Exemple de template Nginx

# templates/nginx.conf.j2
server {
    listen 80;
    server_name {{ domain_name }};
    root {{ document_root }};
    index index.html;

    access_log /var/log/nginx/{{ domain_name }}_access.log;
    error_log /var/log/nginx/{{ domain_name }}_error.log;

    location / {
        try_files $uri $uri/ =404;
    }
}

Les doubles accolades {{ }} marquent les variables qui seront remplacées par leurs valeurs au moment du déploiement. Jinja2 supporte aussi les conditions ({% if %}), les boucles ({% for %}) et les filtres de transformation.

Variables et priorités

Les variables peuvent être définies à plusieurs niveaux : dans le playbook (vars:), dans l’inventaire, dans des fichiers séparés (group_vars/, host_vars/), ou passées en ligne de commande (-e). Ansible applique un ordre de priorité précis, documenté sur redhat.com, qui détermine quelle valeur l’emporte en cas de conflit.

Les rôles Ansible : structurer ses playbooks

Quand vos playbooks grandissent, les rôles permettent de les organiser en composants réutilisables. Un rôle regroupe les tâches, handlers, templates, fichiers et variables liés à une fonctionnalité.

Structure d’un rôle

rôles/
└── nginx/
    ├── tasks/
    │   └── main.yml
    ├── handlers/
    │   └── main.yml
    ├── templates/
    │   └── nginx.conf.j2
    ├── files/
    │   └── index.html
    ├── vars/
    │   └── main.yml
    └── defaults/
        └── main.yml

Chaque sous-répertoire à un rôle précis. Le fichier defaults/main.yml contient les valeurs par défaut des variables (priorité basse), tandis que vars/main.yml contient les valeurs forcées (priorité haute). Les tâches sont identiques à celles d’un playbook classique.

Ansible Galaxy : la communauté

Ansible Galaxy est le dépôt communautaire de rôles préfabriqués. Avant d’écrire un rôle de zéro, vérifiez si un rôle maintenu existe déjà. La commande ansible-galaxy install geerlingguy.nginx télécharge un rôle Nginx complet et testé. Jeff Geerling, auteur de référence dans la communauté Ansible, maintient des dizaines de rôles de qualité professionnelle.

Cas d’usage BTS SIO : déployer une configuration sur N machines

Voici un scénario réaliste d’examen ou de TP : vous devez configurer un parc de 10 postes de salle informatique avec les mêmes logiciels, utilisateurs et paramètres réseau. Sans Ansible, comptez 30 minutes par poste, soit 5 heures de travail répétitif. Avec Ansible, 5 minutes de rédaction et 10 minutes d’exécution suffisent.

Playbook de configuration de parc

Ce playbook installé les logiciels nécessaires, crée les comptes utilisateurs, configure le pare-feu et déploie un fond d’écran personnalisé :

---
- name: Configurer les postes de la salle TP
  hosts: salle_tp
  become: yes

  vars:
    packages:
      - firefox-esr
      - libreoffice
      - gimp
      - filezilla
      - wireshark
      - code
    students:
      - { name: "etudiant01", uid: 2001 }
      - { name: "etudiant02", uid: 2002 }

  tasks:
    - name: Installer les logiciels
      apt:
        name: "{{ packages }}"
        state: présent
        update_cache: yes

    - name: Créer les comptes etudiants
      user:
        name: "{{ item.name }}"
        uid: "{{ item.uid }}"
        shell: /bin/bash
        create_home: yes
        password: "{{ 'bts2026' | password_hash('sha512') }}"
      loop: "{{ students }}"

    - name: Configurer UFW
      ufw:
        rule: allow
        port: "{{ item }}"
        proto: tcp
      loop:
        - "22"
        - "80"
        - "443"

    - name: Activer UFW
      ufw:
        state: enabled
        policy: deny

Ce type de projet se valorise parfaitement lors de l’épreuve E5 du BTS SIO. Il démontre votre capacité à automatiser des tâches d’administration, une compétence du bloc B2 du référentiel.

Modules essentiels à connaître

Parmi les 3 000+ modules Ansible, une vingtaine couvrent 80 % des besoins quotidiens. Voici les incontournables pour un administrateur débutant.

Gestion des paquets

Le module apt (Debian/Ubuntu) ou dnf (RHEL/Rocky) gère l’installation, la mise à jour et la suppression de paquets. L’option state: latest force la mise à jour vers la dernière version disponible, tandis que state: présent installé sans mettre à jour si le paquet existe déjà.

Gestion des fichiers

Le module copy transfère un fichier depuis la machine de contrôle vers la ciblé. Le module template fait de même avec un template Jinja2. Le module file crée des répertoires, des liens symboliques, et gère les permissions. Le module lineinfile modifie une ligne spécifique dans un fichier existant, utile pour ajuster des fichiers de configuration sans les remplacer entièrement.

Gestion des services

Le module service (ou systemd) démarre, arrête, redémarre et active les services au démarrage. Combiné avec les handlers, il permet de ne redémarrer un service que lorsqu’une modification de configuration l’exige.

Commandes et scripts

Les modules command et shell exécutent des commandes arbitraires. Utilisez-les en dernier recours, car ils ne sont pas idempotents par défaut. Préférez toujours un module spécialisé quand il existe. Si vous devez utiliser command, ajoutez une condition creates: ou when: pour garantir l’idempotence.

La maîtrise de ces modules suppose une bonne connaissance de l’administration Linux et des réseaux informatiques.

Bonnes pratiques et erreurs à éviter

L’expérience de la communauté Ansible a codifié un ensemble de bonnes pratiques qui vous feront gagner du temps et éviter des problèmes.

Organisation des fichiers

• Utilisez une structure de répertoires cohérente (inventaire, playbooks, rôles, group_vars, host_vars)
• Versionnez tout avec Git ; un dépôt Ansible est du code d’infrastructure
• Séparez les variables sensibles (mots de passé) dans des fichiers chiffrés avec Ansible Vault

Rédaction des playbooks

• Donnez un name: explicite à chaque tâche (pas de tâche anonyme)
• Utilisez des variables plutôt que des valeurs en dur
• Préférez les modules spécialisés aux commandes shell
• Testez avec --check --diff avant d’exécuter en production

Erreurs fréquentes des débutants

• Indentation YAML incorrecte : YAML est sensible à l’indentation (espaces, jamais de tabulations). Utilisez un éditeur avec validation YAML intégrée comme VS Code avec l’extension Ansible
• Oublier become: yes : la plupart des tâches d’administration nécessitent les droits root
• Ne pas utiliser les handlers : redémarrer un service dans chaque tâche ralentit l’exécution et peut causer des interruptions inutiles
• Ignorer les erreurs : ne mettez jamais ignore_errors: yes sauf pour un cas très spécifique documenté

Aller plus loin : Ansible dans un pipeline CI/CD

Ansible s’intègre naturellement dans un pipeline CI/CD. Le principe : à chaque modification du code d’infrastructure (poussée sur un dépôt Git), un pipeline automatisé exécute les playbooks pour mettre à jour les serveurs concernés.

GitLab CI, GitHub Actions ou Jenkins peuvent déclencher l’exécution d’un playbook Ansible. Cette approche, appelée GitOps pour l’infrastructure, garantit que l’état réel de vos serveurs correspond toujours à ce qui est décrit dans votre dépôt Git.

Pour les étudiants qui s’intéressent au DevOps, cette compétence est directement valorisable. Les débouchés du BTS SIO incluent de plus en plus de postes orientés automatisation et infrastructure as code.

La certification Red Hat Certified Engineer (RHCE) valide officiellement les compétences Ansible. C’est un investissement pertinent après le BTS SIO pour ceux qui souhaitent se spécialiser. Consultez notre guide des certifications IT pour planifier votre parcours.

Ansible transforme l’administration système d’un travail répétitif en une pratique de code. Chaque playbook est documenté, versionné, testable et reproductible. Pour un étudiant en informatique, c’est l’outil idéal pour franchir le cap entre la théorie et la pratique professionnelle. Commencez avec un cas simple (configurer un serveur web), puis élargissez progressivement à l’ensemble de votre infrastructure.

Pour poursuivre votre montée en compétences, explorez notre guide Docker pour débutants (souvent combiné avec Ansible dans les workflows DevOps), ainsi que notre article sur le salaire développeur junior et les perspectives de carrière liées à ces compétences.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.