Ansible Roles et Galaxy : structurer vos déploiements pour l'échelle

Quand vous gérez quelques serveurs, des playbooks Ansible linéaires suffisent. Mais à l'échelle — dix datacenters, des centaines de machines — vous avez besoin de structure, de réutilisabilité et de testabilité. C'est là qu'interviennent les rôles Ansible.

Un rôle est une unité d'automatisation autonome : des tâches, des variables, des handlers et des templates, tout rangé dans une structure définie. Galaxy, c'est le hub communautaire où se partagent ces rôles — et depuis 2.9+, les Collections.

1. Anatomie d'un rôle Ansible
2. Créer un rôle from scratch
3. Variables : precedence et bonnes pratiques
4. Galaxy et Collections
5. Tester avec Molecule
6. Perspectives (pour votre infra)
7. Conclusion

Un rôle Ansible suit une structure figée, reconnue partout :

my_role/
├── defaults/          # Variables avec faible précédence (override facile)
│   └── main.yml
├── vars/              # Variables avec haute précédence (fixes)
│   └── main.yml
├── tasks/             # Tâches exécutées (cœur du rôle)
│   └── main.yml
├── handlers/          # Handlers (redémarrage services, etc.)
│   └── main.yml
├── templates/         # Templates Jinja2 (fichiers à générer)
│   └── config.j2
├── files/             # Fichiers statiques à déployer
│   └── app.conf
├── meta/              # Metadata + dépendances du rôle
│   └── main.yml
└── README.md          # Documentation

defaults/ — Valeurs par défaut, faible précédence. C'est ici qu'on expose les variables que l'appelant peut surcharger.

vars/ — Variables fixes du rôle, haute précédence. Jamais changées par l'utilisateur.

tasks/main.yml — Les actions : installer packages, copier fichiers, démarrer services. Chaque tâche est numérotée et peut avoir des tags.

handlers/ — Actions déclenchées (notifiées) : redémarrage nginx, rechargement config. Exécutées une seule fois à la fin du play.

templates/ — Fichiers Jinja2 : configurations dynamiques basées sur des variables.

files/ — Fichiers statiques, servis tels quels.

meta/main.yml — Dépendances, informations du rôle, tags Galaxy.

Utilisez ansible-galaxy init :

ansible-galaxy init my_nginx_role

Cela génère la structure complète. Remplissons-la pour un rôle Nginx simple :

defaults/main.yml — Variables surchargeables :

nginx_user: www-data
nginx_port: 80
nginx_worker_processes: auto
nginx_worker_connections: 1024
enable_ssl: false
ssl_cert_path: /etc/ssl/certs/nginx.crt
ssl_key_path: /etc/ssl/private/nginx.key

tasks/main.yml — Tâches :

---
- name: Update apt cache
  ansible.builtin.apt:
    update_cache: yes
    cache_valid_time: 3600
  when: ansible_os_family == "Debian"
  tags: packages

- name: Install nginx
  ansible.builtin.apt:
    name: nginx
    state: present
  tags: packages

- name: Create nginx config
  ansible.builtin.template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
    owner: root
    group: root
    mode: '0644'
  notify: restart nginx
  tags: config

- name: Enable nginx service
  ansible.builtin.systemd:
    name: nginx
    enabled: yes
    state: started
  tags: service

handlers/main.yml :

---
- name: restart nginx
  ansible.builtin.systemd:
    name: nginx
    state: restarted

- name: reload nginx
  ansible.builtin.systemd:
    name: nginx
    state: reloaded

templates/nginx.conf.j2 :

user {{ nginx_user }};
worker_processes {{ nginx_worker_processes }};

events {
    worker_connections {{ nginx_worker_connections }};
}

http {
    server {
        listen {{ nginx_port }};
        server_name _;

        {% if enable_ssl %}
        ssl_certificate {{ ssl_cert_path }};
        ssl_certificate_key {{ ssl_key_path }};
        {% endif %}

        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

meta/main.yml :

---
galaxy_info:
  author: 'Your Name'
  description: 'Nginx deployment and configuration'
  company: 'SHPV'
  license: 'MIT'
  min_ansible_version: 2.10
  platforms:
    - name: Ubuntu
      versions: ['20.04', '22.04', '24.04']
  galaxy_tags: ['nginx', 'webserver', 'http']

dependencies: []

La précédence est clé. Ordre (du moins au plus spécifique) :

1. defaults/ — Valeurs par défaut, faible précédence
2. vars/ — Variables du rôle, haute précédence
3. Variables passées à include_role ou import_role
4. Hostvars, groupvars, variables de ligne de commande

Règle SHPV : Mettez dans defaults/ tout ce qui est configurable (ports, tailles, chemins). Laissez vars/ pour les constantes métier ou les calculs internes.

Exemple pour une infra multi-datacenter :

# defaults/main.yml
datacenter: toulouse
region: fr-sw
environment: production
monitoring_enabled: true

# vars/main.yml (ne pas surcharger)
monitoring_agent_name: datadog
infrastructure_owner: SHPV

Ansible Galaxy (galaxy.ansible.com) est le hub. Vous pouvez :

• Installer des rôles/collections communautaires
• Publier les vôtres
• Gérer des dépendances via requirements.yml

Collections (depuis 2.9+) sont l'évolution des rôles. Format : namespace.collection.module.

Exemples :

• community.general — Modules génériques
• ansible.posix — Modules POSIX
• community.mysql — Support MySQL
• ansible.windows — Support Windows

Installez via requirements.yml :

---
collections:
  - name: community.general
    version: '>=7.0.0'
  - name: ansible.posix
    version: '7.0.0'

roles:
  - name: geerlingguy.nginx
    version: 3.9.0
  - name: geerlingguy.docker
    src: https://github.com/geerlingguy/ansible-role-docker.git
    version: main

Installez :

ansible-galaxy install -r requirements.yml

Pour publier votre rôle :

ansible-galaxy role publish /path/to/my_role --api-key YOUR_API_KEY

Molecule est le framework de test pour rôles Ansible. Il automatise :

• Lancement de containers/VMs
• Convergence du rôle
• Vérification (idempotence, assertions)
• Cleanup

Installez :

pip install molecule molecule-docker

Initialisez dans votre rôle :

molecule init scenario -d docker

Cela crée molecule/default/ :

molecule/default/molecule.yml :

---
driver:
  name: docker

platforms:
  - name: ubuntu-22.04
    image: ubuntu:22.04
    pre_build_commands:
      - apt-get update && apt-get install -y python3 python3-apt
  - name: debian-12
    image: debian:12
    pre_build_commands:
      - apt-get update && apt-get install -y python3 python3-apt

provisioner:
  name: ansible
  playbooks:
    converge: converge.yml

verifier:
  name: ansible
  playbooks:
    verify: verify.yml

molecule/default/converge.yml :

---
- hosts: all
  gather_facts: yes
  roles:
    - role: my_nginx_role
      nginx_port: 8080

molecule/default/verify.yml :

---
- hosts: all
  gather_facts: no
  tasks:
    - name: Check nginx is running
      ansible.builtin.systemd:
        name: nginx
        state: started
      register: result
      failed_when: result.failed

    - name: Check nginx listens on 8080
      ansible.builtin.uri:
        url: http://localhost:8080
        status_code: 200
      register: result
      failed_when: result.failed

Lancez les tests :

molecule converge  # Déployer
molecule verify    # Vérifier
molecule test      # Tout (converge + verify + cleanup)

Pour SHPV, structurer vos déploiements autour des rôles Ansible :

1. Rôles par domaine : role_network_backbone, role_dataplane, role_monitoring
2. Collections maison : shpv.infrastructure avec vos modules custom
3. Molecule en CI/CD : Tester chaque changement dans Docker avant prod
4. Vault Ansible : Secrets chiffrés (ansible-vault)
5. Versioning : Taguez vos rôles en Git, publiez sur Galaxy interne

Lisez aussi :

• Automatiser configuration Ansible
• Terraform + Ansible pour le Cloud
• AWX : orchestration à l'échelle

• Ansible Playbook Guide: Roles
• Ansible Galaxy Documentation
• Molecule Testing Framework
• Ansible Collections

Les rôles Ansible transforment vos playbooks en modules réutilisables, testables et partageables. Combinés à Galaxy et Molecule, ils deviennent la fondation de vos déploiements à l'échelle.

Chez SHPV, où l'automatisation de l'infrastructure est critiquement importante, structurer vos rôles dès le départ vous économise des jours de débogage futur. Pensez structure, defaults plutôt que vars, tests Molecule systématiques.

Bonne automatisation !