Installer et Configurer Ansible sur Linux et macOS

Prérequis avant d'installer Ansible

Avant de vous lancer dans l'installation d'Ansible, il est important de comprendre les prérequis techniques nécessaires. Ansible repose sur deux technologies fondamentales : Python et SSH. Ces deux éléments constituent le socle sur lequel fonctionne toute l'architecture d'Ansible.

Python : le moteur d'Ansible

Ansible est entièrement écrit en Python. Il nécessite Python sur deux niveaux :

Architecture en un coup d'œil

Diagramme - Installer et Configurer Ansible sur Linux et macOS

Sur la machine de contrôle (le poste depuis lequel vous lancez Ansible) : Python 3.9 ou supérieur est requis pour les versions récentes d'Ansible
Sur les machines cibles (les serveurs que vous gérez) : Python 3.x doit être présent pour que la plupart des modules fonctionnent correctement

La bonne nouvelle, c'est que Python est installé par défaut sur la grande majorité des distributions Linux modernes. Vous pouvez vérifier sa présence avec la commande suivante :

# Vérifier la version de Python installée
python3 --version

# Si Python n'est pas installé sur Ubuntu/Debian
sudo apt update && sudo apt install -y python3 python3-pip

# Si Python n'est pas installé sur CentOS/RHEL
sudo dnf install -y python3 python3-pip

SSH : le canal de communication

Ansible utilise SSH (Secure Shell) pour se connecter aux machines cibles et exécuter les tâches. Le serveur SSH (sshd) doit être installé et actif sur chaque machine que vous souhaitez gérer. C'est généralement le cas par défaut sur les serveurs Linux, mais vérifiez tout de même :

# Vérifier que le service SSH est actif
sudo systemctl status sshd

# Installer et démarrer SSH si nécessaire (Ubuntu/Debian)
sudo apt install -y openssh-server
sudo systemctl enable --now ssh

# Installer et démarrer SSH si nécessaire (CentOS/RHEL)
sudo dnf install -y openssh-server
sudo systemctl enable --now sshd

Pour des raisons de sécurité et de praticité, nous recommandons fortement l'utilisation de clés SSH plutôt que des mots de passe. Nous verrons comment les configurer plus loin dans cet article.

Installation d'Ansible sur Ubuntu / Debian

Ubuntu et Debian sont parmi les distributions les plus utilisées pour les serveurs et les postes de travail. L'installation d'Ansible y est particulièrement simple grâce au gestionnaire de paquets APT.

Méthode 1 : via le PPA officiel (recommandé pour Ubuntu)

Le PPA (Personal Package Archive) officiel d'Ansible garantit que vous disposez toujours de la dernière version stable.

# Installer les dépendances nécessaires
sudo apt update
sudo apt install -y software-properties-common

# Ajouter le PPA officiel d'Ansible
sudo add-apt-repository --yes --update ppa:ansible/ansible

# Installer Ansible
sudo apt install -y ansible

Méthode 2 : via les dépôts système (Debian et Ubuntu)

Vous pouvez aussi installer Ansible directement depuis les dépôts officiels de votre distribution. Attention toutefois, la version disponible peut être plus ancienne que celle du PPA.

# Mettre à jour la liste des paquets
sudo apt update

# Installer Ansible depuis les dépôts officiels
sudo apt install -y ansible

Méthode 3 : via pip (toutes distributions)

L'installation via pip (le gestionnaire de paquets Python) est la méthode la plus universelle et garantit la version la plus récente d'Ansible.

# Installer pip si nécessaire
sudo apt install -y python3-pip python3-venv

# Créer un environnement virtuel dédié (bonne pratique)
python3 -m venv ~/ansible-venv
source ~/ansible-venv/bin/activate

# Installer Ansible via pip
pip install ansible

# Vérifier l'installation
ansible --version

L'utilisation d'un environnement virtuel Python (venv) est une bonne pratique qui permet d'isoler Ansible et ses dépendances du système. Cela évite les conflits de versions avec d'autres outils Python installés sur votre machine.

Installation d'Ansible sur CentOS / RHEL / Fedora

Sur les distributions de la famille Red Hat, l'installation se fait principalement via dnf (ou yum pour les versions plus anciennes de CentOS).

Méthode 1 : via dnf (CentOS 8+, RHEL 8+, Fedora)

# Activer le dépôt EPEL (Extra Packages for Enterprise Linux)
sudo dnf install -y epel-release

# Installer Ansible
sudo dnf install -y ansible

# Vérifier l'installation
ansible --version

Méthode 2 : via yum (CentOS 7)

Pour les systèmes plus anciens utilisant encore yum :

# Activer le dépôt EPEL
sudo yum install -y epel-release

# Installer Ansible
sudo yum install -y ansible

# Vérifier l'installation
ansible --version

Méthode 3 : via pip (recommandé pour la dernière version)

# Installer pip
sudo dnf install -y python3-pip python3-virtualenv

# Créer un environnement virtuel
python3 -m venv ~/ansible-venv
source ~/ansible-venv/bin/activate

# Installer Ansible
pip install ansible

# Vérifier l'installation
ansible --version

Installation d'Ansible sur macOS

macOS est un excellent choix comme machine de contrôle Ansible, notamment pour les développeurs et les administrateurs qui travaillent sur Mac. Deux méthodes principales s'offrent à vous.

Méthode 1 : via Homebrew (recommandé)

Homebrew est le gestionnaire de paquets le plus populaire sur macOS. Si vous ne l'avez pas encore installé, commencez par là :

# Installer Homebrew (si pas encore installé)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Installer Ansible via Homebrew
brew install ansible

# Vérifier l'installation
ansible --version

Méthode 2 : via pip

# Créer un environnement virtuel
python3 -m venv ~/ansible-venv
source ~/ansible-venv/bin/activate

# Installer Ansible
pip install ansible

# Vérifier l'installation
ansible --version

Sur macOS, vous devrez peut-être configurer certaines variables d'environnement si vous rencontrez des problèmes avec les forks de processus :

# Ajouter dans votre ~/.zshrc ou ~/.bash_profile
export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES

Vérification de l'installation

Quelle que soit la méthode d'installation choisie, il est important de vérifier que tout fonctionne correctement. Voici les commandes de vérification essentielles :

# Vérifier la version d'Ansible et ses composants
ansible --version

# Exemple de sortie :
# ansible [core 2.16.3]
#   config file = /etc/ansible/ansible.cfg
#   configured module search path = ['/home/user/.ansible/plugins/modules']
#   ansible python module location = /usr/lib/python3/dist-packages/ansible
#   ansible collection location = /home/user/.ansible/collections
#   executable location = /usr/bin/ansible
#   python version = 3.12.3

# Vérifier que les composants principaux sont disponibles
ansible-playbook --version
ansible-galaxy --version
ansible-vault --version
ansible-doc --version

# Lister tous les modules disponibles
ansible-doc -l | head -20

# Obtenir de l'aide sur un module spécifique
ansible-doc apt
ansible-doc copy

Configuration d'Ansible : le fichier ansible.cfg

Le fichier ansible.cfg est le fichier de configuration principal d'Ansible. Il contrôle le comportement global de l'outil : connexion SSH, parallélisme, emplacement de l'inventaire, gestion des privilèges, et bien plus encore.

Ordre de priorité des fichiers de configuration

Ansible recherche son fichier de configuration dans l'ordre suivant (le premier trouvé est utilisé) :

ANSIBLE_CONFIG : variable d'environnement pointant vers un fichier de configuration
./ansible.cfg : fichier dans le répertoire courant du projet
~/.ansible.cfg : fichier dans le répertoire home de l'utilisateur
/etc/ansible/ansible.cfg : fichier de configuration globale du système

La bonne pratique consiste à créer un fichier ansible.cfg à la racine de chaque projet. Cela permet d'avoir des configurations spécifiques par projet et de les versionner dans Git.

Exemple complet de fichier ansible.cfg

# ansible.cfg - Configuration projet Ansible
[defaults]
# Emplacement de l'inventaire par défaut
inventory = ./inventaire/hosts.yml

# Utilisateur SSH par défaut
remote_user = deploy

# Désactiver la vérification des clés SSH (utile en lab, déconseillé en production)
host_key_checking = False

# Nombre de machines gérées en parallèle
forks = 20

# Timeout de connexion SSH en secondes
timeout = 30

# Emplacement des rôles
roles_path = ./roles

# Emplacement des logs
log_path = ./ansible.log

# Format de sortie (yaml est plus lisible)
stdout_callback = yaml

# Collecte des facts
gathering = smart
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts_cache
fact_caching_timeout = 3600

# Réessayer les tâches échouées
retry_files_enabled = True
retry_files_save_path = ./retry

[privilege_escalation]
# Devenir root par défaut
become = False
become_method = sudo
become_user = root
become_ask_pass = False

[ssh_connection]
# Optimisation SSH avec pipelining
pipelining = True

# Nombre de tentatives de connexion SSH
retries = 3

# Arguments SSH supplémentaires
ssh_args = -o ControlMaster=auto -o ControlPersist=60s -o StrictHostKeyChecking=no

# Utiliser SCP au lieu de SFTP si nécessaire
# transfer_method = scp

[colors]
# Personnalisation des couleurs de sortie
changed = yellow
ok = green
error = red
warn = purple

Ce fichier de configuration est bien commenté et couvre les paramètres les plus importants. Le pipelining SSH est particulièrement recommandé car il réduit considérablement le nombre de connexions SSH nécessaires, améliorant ainsi les performances.

L'inventaire : définir vos machines

L'inventaire est un élément central d'Ansible. C'est lui qui définit quelles machines vous allez gérer et comment Ansible doit s'y connecter.

L'inventaire par défaut

Par défaut, Ansible recherche l'inventaire dans /etc/ansible/hosts. Ce fichier peut être au format INI ou YAML. Cependant, il est recommandé de définir un inventaire spécifique à chaque projet dans votre fichier ansible.cfg.

Inventaire au format INI

# /etc/ansible/hosts ou inventaire/hosts.ini

# Serveurs individuels
serveur1.codeclan.fr
192.168.1.100

# Groupe de serveurs web
[webservers]
web1.codeclan.fr ansible_host=192.168.1.10
web2.codeclan.fr ansible_host=192.168.1.11
web3.codeclan.fr ansible_host=192.168.1.12

# Groupe de bases de données
[databases]
db-master.codeclan.fr ansible_host=192.168.1.20
db-replica.codeclan.fr ansible_host=192.168.1.21

# Groupe de monitoring
[monitoring]
prometheus.codeclan.fr ansible_host=192.168.1.30
grafana.codeclan.fr ansible_host=192.168.1.31

# Variables pour le groupe webservers
[webservers:vars]
http_port=80
ansible_user=deploy

# Variables pour le groupe databases
[databases:vars]
db_port=5432
ansible_user=dbadmin

# Sous-groupe : tous les serveurs de production
[production:children]
webservers
databases
monitoring

# Variables globales pour la production
[production:vars]
env=production
ansible_ssh_private_key_file=~/.ssh/prod_key

Inventaire au format YAML (recommandé)

Le format YAML est plus lisible et plus flexible. Voici le même inventaire au format YAML :

# inventaire/hosts.yml
all:
  children:
    production:
      children:
        webservers:
          hosts:
            web1.codeclan.fr:
              ansible_host: 192.168.1.10
            web2.codeclan.fr:
              ansible_host: 192.168.1.11
            web3.codeclan.fr:
              ansible_host: 192.168.1.12
          vars:
            http_port: 80
            ansible_user: deploy

        databases:
          hosts:
            db-master.codeclan.fr:
              ansible_host: 192.168.1.20
              db_role: master
            db-replica.codeclan.fr:
              ansible_host: 192.168.1.21
              db_role: replica
          vars:
            db_port: 5432
            ansible_user: dbadmin

        monitoring:
          hosts:
            prometheus.codeclan.fr:
              ansible_host: 192.168.1.30
            grafana.codeclan.fr:
              ansible_host: 192.168.1.31
          vars:
            ansible_user: monitor

      vars:
        env: production
        ansible_ssh_private_key_file: ~/.ssh/prod_key

    staging:
      hosts:
        staging.codeclan.fr:
          ansible_host: 192.168.2.10
      vars:
        env: staging
        ansible_user: deploy

Groupes et sous-groupes

L'organisation de vos hôtes en groupes et sous-groupes est une pratique essentielle pour cibler efficacement vos playbooks. Ansible crée automatiquement deux groupes spéciaux :

all : contient tous les hôtes de l'inventaire
ungrouped : contient les hôtes qui ne sont dans aucun groupe explicite

Vous pouvez ensuite cibler vos playbooks sur un groupe spécifique, combiner des groupes ou exclure certains hôtes :

# Cibler tous les serveurs
ansible all -m ping

# Cibler un groupe spécifique
ansible webservers -m ping

# Cibler plusieurs groupes
ansible 'webservers:databases' -m ping

# Exclure un groupe
ansible 'production:!monitoring' -m ping

# Intersection de groupes
ansible 'production:&webservers' -m ping

Variables d'hôte et de groupe

Pour une meilleure organisation, vous pouvez séparer les variables dans des fichiers dédiés grâce aux répertoires host_vars et group_vars :

# Structure de répertoires recommandée
inventaire/
├── hosts.yml
├── group_vars/
│   ├── all.yml           # Variables pour tous les hôtes
│   ├── webservers.yml    # Variables pour les serveurs web
│   ├── databases.yml     # Variables pour les bases de données
│   └── production.yml    # Variables pour la production
└── host_vars/
    ├── web1.codeclan.fr.yml    # Variables spécifiques à web1
    └── db-master.codeclan.fr.yml  # Variables spécifiques au master DB

Exemple de fichier group_vars/webservers.yml :

# group_vars/webservers.yml
---
http_port: 80
https_port: 443
document_root: /var/www/html
nginx_worker_processes: auto
nginx_worker_connections: 1024

ssl_certificate: /etc/ssl/certs/codeclan.pem
ssl_certificate_key: /etc/ssl/private/codeclan.key

firewall_allowed_ports:
  - 80
  - 443
  - 22

Configuration des clés SSH

L'authentification par clé SSH est indispensable pour utiliser Ansible efficacement. Voici comment la configurer de A à Z.

Générer une paire de clés SSH

# Générer une clé SSH Ed25519 (recommandé, plus sécurisé)
ssh-keygen -t ed25519 -C "ansible@codeclan.fr" -f ~/.ssh/ansible_key

# Ou générer une clé RSA 4096 bits (alternative)
ssh-keygen -t rsa -b 4096 -C "ansible@codeclan.fr" -f ~/.ssh/ansible_key

# Vérifier que les clés ont été créées
ls -la ~/.ssh/ansible_key*
# ansible_key      (clé privée - NE JAMAIS PARTAGER)
# ansible_key.pub  (clé publique - à copier sur les serveurs)

Copier la clé publique sur les serveurs

# Copier la clé publique sur un serveur
ssh-copy-id -i ~/.ssh/ansible_key.pub deploy@web1.codeclan.fr

# Si ssh-copy-id n'est pas disponible, méthode manuelle
cat ~/.ssh/ansible_key.pub | ssh deploy@web1.codeclan.fr "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

# Copier sur plusieurs serveurs avec une boucle
for server in web1 web2 web3 db1 db2; do
    ssh-copy-id -i ~/.ssh/ansible_key.pub deploy@${server}.codeclan.fr
done

# Tester la connexion SSH sans mot de passe
ssh -i ~/.ssh/ansible_key deploy@web1.codeclan.fr "hostname"

Configurer SSH pour Ansible

Créez ou modifiez votre fichier ~/.ssh/config pour simplifier les connexions :

# ~/.ssh/config
Host *.codeclan.fr
    User deploy
    IdentityFile ~/.ssh/ansible_key
    StrictHostKeyChecking no
    UserKnownHostsFile /dev/null
    ServerAliveInterval 60
    ServerAliveCountMax 3
    ControlMaster auto
    ControlPath ~/.ssh/sockets/%r@%h-%p
    ControlPersist 600

# Créer le répertoire pour les sockets SSH
mkdir -p ~/.ssh/sockets
chmod 700 ~/.ssh/sockets

Test de connexion avec Ansible

Une fois l'installation terminée, l'inventaire configuré et les clés SSH en place, il est temps de vérifier que tout fonctionne correctement avec le module ping.

# Tester la connexion à tous les hôtes
ansible all -m ping -i inventaire/hosts.yml

# Sortie attendue :
# web1.codeclan.fr | SUCCESS => {
#     "changed": false,
#     "ping": "pong"
# }
# web2.codeclan.fr | SUCCESS => {
#     "changed": false,
#     "ping": "pong"
# }

# Tester un groupe spécifique
ansible webservers -m ping -i inventaire/hosts.yml

# Tester un hôte spécifique
ansible web1.codeclan.fr -m ping -i inventaire/hosts.yml

# En cas de problème, activer le mode verbose
ansible all -m ping -i inventaire/hosts.yml -vvv

Le module ping d'Ansible ne fait pas un simple ping ICMP. Il se connecte en SSH à la machine cible, vérifie que Python est disponible et retourne pong. C'est un véritable test de bout en bout de la chaîne de communication Ansible.

Premières commandes ad-hoc

Les commandes ad-hoc sont des commandes Ansible exécutées directement depuis le terminal, sans avoir besoin d'écrire un playbook. Elles sont idéales pour les tâches ponctuelles et rapides.

Syntaxe générale

# Syntaxe d'une commande ad-hoc
ansible [pattern] -m [module] -a "[arguments]" -i [inventaire]

Exemples pratiques de commandes ad-hoc

# Récupérer des informations système (facts)
ansible all -m setup -i inventaire/hosts.yml

# Filtrer les facts pour n'obtenir que la mémoire
ansible all -m setup -a "filter=ansible_memtotal_mb" -i inventaire/hosts.yml

# Exécuter une commande shell
ansible webservers -m shell -a "uptime" -i inventaire/hosts.yml

# Vérifier l'espace disque
ansible all -m shell -a "df -h /" -i inventaire/hosts.yml

# Installer un paquet sur tous les serveurs web (nécessite become)
ansible webservers -m apt -a "name=htop state=present" -b -i inventaire/hosts.yml

# Copier un fichier vers tous les serveurs
ansible all -m copy -a "src=/local/fichier.conf dest=/etc/app/fichier.conf" -b -i inventaire/hosts.yml

# Redémarrer un service
ansible webservers -m service -a "name=nginx state=restarted" -b -i inventaire/hosts.yml

# Créer un utilisateur
ansible all -m user -a "name=moniteur state=present shell=/bin/bash" -b -i inventaire/hosts.yml

# Vérifier la connectivité réseau vers un port
ansible all -m wait_for -a "host=google.com port=443 timeout=5" -i inventaire/hosts.yml

# Récupérer un fichier depuis les serveurs
ansible webservers -m fetch -a "src=/var/log/nginx/error.log dest=./logs/ flat=no" -i inventaire/hosts.yml

# Exécuter en parallèle sur 10 machines à la fois
ansible all -m shell -a "hostname" -f 10 -i inventaire/hosts.yml

Options utiles pour les commandes ad-hoc

-b ou --become : exécuter avec élévation de privilèges (sudo)
-K ou --ask-become-pass : demander le mot de passe sudo
-u [user] : spécifier l'utilisateur SSH
-f [nombre] : nombre de forks (parallélisme)
-v, -vv, -vvv : niveaux de verbosité croissants
--check : mode dry-run (simuler sans appliquer)
--diff : afficher les différences pour les fichiers modifiés

Structure de répertoires recommandée pour un projet Ansible

Maintenant que vous avez Ansible installé et configuré, voici la structure de répertoires recommandée pour organiser votre projet de manière professionnelle :

# Structure de projet Ansible recommandée
mon-projet-ansible/
├── ansible.cfg              # Configuration Ansible du projet
├── inventaire/
│   ├── production/
│   │   ├── hosts.yml        # Inventaire de production
│   │   ├── group_vars/
│   │   │   ├── all.yml
│   │   │   ├── webservers.yml
│   │   │   └── databases.yml
│   │   └── host_vars/
│   │       └── web1.codeclan.fr.yml
│   └── staging/
│       ├── hosts.yml        # Inventaire de staging
│       ├── group_vars/
│       │   └── all.yml
│       └── host_vars/
├── playbooks/
│   ├── site.yml             # Playbook principal
│   ├── webservers.yml       # Playbook pour les serveurs web
│   ├── databases.yml        # Playbook pour les BDD
│   └── deploy.yml           # Playbook de déploiement
├── roles/
│   ├── common/              # Rôle commun à tous les serveurs
│   ├── nginx/               # Rôle Nginx
│   ├── postgresql/          # Rôle PostgreSQL
│   └── firewall/            # Rôle pare-feu
├── templates/               # Templates Jinja2 globaux
├── files/                   # Fichiers statiques globaux
├── vars/                    # Variables globales
│   ├── main.yml
│   └── secrets.yml          # Chiffré avec ansible-vault
├── requirements.yml         # Rôles Galaxy requis
└── .gitignore               # Fichiers à ignorer par Git

Dépannage des problèmes courants

Voici les problèmes les plus fréquemment rencontrés lors de l'installation et de la configuration d'Ansible, avec leurs solutions.

Problème : "Permission denied (publickey)"

# Vérifier les permissions des fichiers SSH
chmod 700 ~/.ssh
chmod 600 ~/.ssh/ansible_key
chmod 644 ~/.ssh/ansible_key.pub

# Vérifier que la clé est bien copiée sur le serveur
ssh -i ~/.ssh/ansible_key -v deploy@serveur.codeclan.fr

# Vérifier les permissions côté serveur
# Sur le serveur cible :
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Problème : "No module named ansible"

# Vérifier que vous êtes dans le bon environnement virtuel
which ansible
which python3

# Réactiver l'environnement virtuel si nécessaire
source ~/ansible-venv/bin/activate

# Réinstaller Ansible
pip install --force-reinstall ansible

Problème : "Host key verification failed"

# Solution 1 : Accepter la clé manuellement
ssh deploy@serveur.codeclan.fr

# Solution 2 : Désactiver la vérification dans ansible.cfg
# [defaults]
# host_key_checking = False

# Solution 3 : Variable d'environnement
export ANSIBLE_HOST_KEY_CHECKING=False

Problème : Python non trouvé sur la machine cible

# Dans votre inventaire, spécifiez l'interpréteur Python
all:
  vars:
    ansible_python_interpreter: /usr/bin/python3

Conclusion et prochaines étapes

Vous disposez maintenant d'une installation d'Ansible fonctionnelle, correctement configurée et prête à l'emploi. Récapitulons les étapes clés que nous avons couvertes :

Les prérequis : Python et SSH sont les fondations d'Ansible
L'installation : via le gestionnaire de paquets système ou pip, sur Linux comme sur macOS
La configuration : le fichier ansible.cfg adapté à votre projet
L'inventaire : la définition structurée de vos machines avec groupes et variables
Les clés SSH : l'authentification sécurisée sans mot de passe
Les commandes ad-hoc : vos premières interactions avec les machines cibles

Dans le prochain article de cette série, nous plongerons dans le sujet le plus important d'Ansible : les Playbooks. Vous apprendrez à écrire des playbooks complets pour automatiser la configuration de vos serveurs, en utilisant les variables, les conditionnels, les boucles, les handlers et bien plus encore. C'est là que la véritable puissance d'Ansible se révèle.

En attendant, nous vous encourageons à pratiquer avec les commandes ad-hoc sur vos machines de test. Plus vous vous familiariserez avec les modules Ansible et la syntaxe des commandes, plus l'écriture de playbooks sera naturelle et intuitive.