Installer Molecule 26 : configuration d'un scénario par défaut

Cette page vous fait installer Molecule 26.x avec le plugin Podman, créer le premier scénario default, et configurer molecule.yml, converge.yml, verify.yml. Stack 2026 strict : ansible-native, drivers delegated + collections, Podman rootless.

Ce que vous allez apprendre

Installer Molecule 26.x + molecule-plugins[podman] via pip/pipx.
Initialiser un scénario avec molecule init scenario.
Configurer molecule.yml : driver, platforms, provisioner, verifier.
Écrire converge.yml (le playbook qui appelle le rôle).
Écrire verify.yml (les assertions Ansible-native).

Prérequis

Python 3.10+ sur le control node.
Podman 4+ installé (podman --version).
Ansible 2.16+ (ansible --version).

Installation

Méthode recommandée — pipx

pipx install molecule
pipx inject molecule molecule-plugins[podman]
pipx inject molecule ansible-lint

Avantage pipx : installation isolée, pas de conflit avec d’autres outils Python.

Vérification

molecule --version

Sortie attendue :

molecule 26.4.0 using python 3.12
    ansible:2.20.1
    containers:25.8.12 from molecule_plugins requiring collections: containers.podman>=1.8.1

Confirmer que containers plugin est bien chargé (driver Podman).

Structure générée par `molecule init scenario`

À la racine d’un rôle :

cd roles/webserver/
molecule init scenario

Crée :

Répertoiremolecule/
- Répertoiredefault/
  - molecule.yml
  - converge.yml

Le scénario s’appelle default par convention. Vous pouvez créer d’autres scénarios (molecule init scenario --scenario-name multi-distro) pour tester différents cas.

Le fichier `molecule.yml`

---
# molecule/default/molecule.yml — config 2026 minimale
dependency:
  name: galaxy

driver:
  name: default                 # ← v6+ : driver delegated par défaut

platforms:
  - name: instance
    image: docker.io/rockylinux/rockylinux:9
    pre_build_image: true       # utilise une image existante (pas de build)
    privileged: true            # nécessaire pour systemd dans le container
    command: /sbin/init         # PID 1 = systemd

provisioner:
  name: ansible
  config_options:
    defaults:
      stdout_callback: yaml
      callback_enabled: profile_tasks

verifier:
  name: ansible                 # ← verifier 2026 par défaut (verify.yml)

Décortication :

dependency: galaxy : Molecule installe les rôles/collections via ansible-galaxy install avant le test.
driver: default : delegated, supporte n’importe quelle infra (containers, VMs).
platforms: : liste des cibles de test. Une entrée = un container.
pre_build_image: true : utilise l’image telle quelle (pas de Dockerfile custom).
privileged: true + command: /sbin/init : permet à systemd de tourner dans le container (sinon systemctl ne marche pas).
provisioner: ansible : Ansible est l’orchestrateur (logique).
verifier: ansible : les assertions sont en YAML (verify.yml), pas en Python (testinfra).

Le fichier `converge.yml`

---
- name: Converge
  hosts: all
  become: true

  roles:
    - role: webserver

Le playbook qui joue le rôle sur l’instance Molecule. Mêmes variables que vos playbooks de production — c’est le test du rôle dans des conditions réelles.

Vous pouvez passer des vars :

- name: Converge
  hosts: all
  become: true
  roles:
    - role: webserver
      vars:
        webserver_listen_port: 8080
        webserver_index_content: "Test from Molecule"

Le fichier `verify.yml`

---
- name: Verify
  hosts: all
  gather_facts: false
  become: true

  tasks:
    - name: Vérifier que nginx est installé
      ansible.builtin.command: rpm -q nginx
      register: nginx_pkg
      changed_when: false

    - name: Assertion paquet présent
      ansible.builtin.assert:
        that:
          - nginx_pkg.rc == 0
        fail_msg: "nginx n'est pas installé"

    - name: Vérifier que le fichier nginx.conf existe
      ansible.builtin.stat:
        path: /etc/nginx/nginx.conf
      register: conf

    - name: Assertion config présente
      ansible.builtin.assert:
        that:
          - conf.stat.exists
          - conf.stat.isreg

Pattern : pour chaque feature attendue, un check + un assert: avec fail_msg: clair.

Les commandes Molecule

# Cycle complet : create → prepare → converge → idempotence → verify → destroy
molecule test

# Étapes individuelles (utiles en dev)
molecule create        # crée le container
molecule converge      # joue le rôle (sans destroy)
molecule verify        # joue verify.yml
molecule destroy       # supprime le container

# Loguer dedans pour debug
molecule login         # ssh dans le container converged

# Voir la matrice de test
molecule matrix test

Workflow de dev typique :

molecule converge       # 1ère fois — construit l'instance, joue le rôle
molecule verify         # vérifie
# ... vous modifiez le rôle ...
molecule converge       # rejoue le rôle (instance préservée — RAPIDE)
molecule verify
# ... cycle TDD ...
molecule destroy        # quand fini

Pratiquer dans le lab

Cette page a un lab d’accompagnement : labs/molecule/installation-config/ dans stephrobert/ansible-training.

Le lab pose une config Molecule enrichie avec prepare.yml, requirements.yml, host_vars, test_sequence personnalisée. 6 tests structure validés.

cd ~/Projets/ansible-training/labs/molecule/installation-config/

cat molecule/default/molecule.yml      # config enrichie
cat molecule/default/prepare.yml       # prérequis pré-converge
pytest -v challenge/tests/             # 6 tests structure

Pour lancer Molecule réellement :

molecule test                          # nécessite Podman opérationnel

Pièges courants

Symptôme	Cause	Fix
`Driver 'docker' was not found`	Plugin manquant	`pipx inject molecule molecule-plugins[podman]`
`systemctl is not allowed` dans le container	Pas de `privileged: true`	Ajouter `privileged: true` + `command: /sbin/init`
`connection refused` sur podman	Service podman pas démarré	`systemctl --user enable --now podman.socket`
Test idempotence rate	Tâche non idempotente (`command:` sans `creates`)	Refactorer en module dédié (`copy:`, `template:`, etc.)
`molecule converge` lent à chaque dev	Container détruit à chaque test	`molecule converge` (sans `test`) préserve l’instance

À retenir

pipx install molecule + inject molecule-plugins[podman] = stack 2026.
driver: default + Podman rootless = config recommandée.
privileged: true + command: /sbin/init mandatory pour systemd dans le container.
verifier: ansible par défaut — verify.yml en YAML, pas Python.
molecule converge rapide en dev (instance préservée). molecule test = cycle complet.

Prochaines étapes

Cycle TDD complet Développer un rôle users en TDD : test rouge → code → test vert

Scenarios multi-distro Étendre la matrice de test à Rocky + AlmaLinux + Debian

Tests avec testinfra Quand verify.yml ne suffit pas — bascule vers Python

Tests multi-versions tox Lancer molecule test sur ansible-core 2.16, 2.17, 2.18 d'un seul tox