LVM avec Ansible : pipeline pv → vg → lv → filesystem → mount

LVM (Logical Volume Manager) abstrait les disques physiques en volumes logiques redimensionnables. Sur RHEL 2026, c’est l’outil standard pour gérer le stockage des serveurs. Pipeline classique :

PV (Physical Volume) — disque ou partition initialisée pour LVM.
VG (Volume Group) — pool de PVs combinés.
LV (Logical Volume) — volume découpé dans le VG (le “disque virtuel” utilisable).

4 modules Ansible forment le pipeline storage complet :

community.general.lvg: — gérer les Volume Groups (PVs inclus).
community.general.lvol: — gérer les Logical Volumes.
community.general.filesystem: — formater un LV ou un disque.
ansible.posix.mount: — monter et persister dans fstab.

# 1. Créer le VG (initialise le PV en même temps)
- community.general.lvg:
    vg: vg_data
    pvs: /dev/vdb           # le disque entier — PAS une partition (LVM gère)
    state: present
  become: true

# 2. Créer le LV (taille fixe ou pourcentage du VG)
- community.general.lvol:
    vg: vg_data
    lv: lv_app
    size: 50%VG             # ou "10G", "100M"
    state: present
  become: true

# 3. Formater (idempotent : ne réécrit pas si déjà formaté)
- community.general.filesystem:
    fstype: xfs
    dev: /dev/vg_data/lv_app
    # force: false           # JAMAIS true sauf debug — détruit les données
  become: true

# 4. Monter avec UUID (et durcissement)
- ansible.posix.mount:
    path: /srv/app
    src: /dev/vg_data/lv_app
    fstype: xfs
    opts: defaults,noatime,nodev,nosuid
    state: mounted
  become: true

# 5. Étendre un LV à chaud (resizefs étend aussi le filesystem)
- community.general.lvol:
    vg: vg_data
    lv: lv_app
    size: +20G             # +20G ajoute, =80G fixe la taille absolue
    resizefs: true         # étend xfs/ext4 en même temps
  become: true

Sécurité non négociable :

filesystem: avec force: false (défaut) — force: true détruit toutes les données du device sans avertissement. À ne jamais mettre dans un playbook qui peut tourner par erreur en prod.
Ordre du teardown = inverse de la création : démonter → supprimer LV → supprimer VG. Sauter une étape laisse des structures orphelines visibles dans pvs/vgs/lvs.
PV sur disque entier (/dev/vdb) plutôt que sur partition (/dev/vdb1) — plus simple, pas de table de partitions à gérer. La partition n’apporte rien quand LVM est seul propriétaire du disque.
size: 50%VG plutôt qu’une valeur absolue quand le code est partagé entre hôtes de tailles différentes — sinon le playbook échoue sur les VG plus petits.
resizefs: true est le pattern d’extension à chaud — sans ça, le LV grossit mais le FS ne voit pas la nouvelle place. Tester en check mode avant un agrandissement de prod : --check --diff.

Ce que vous allez apprendre

Construire un PV → VG → LV en chaîne avec les modules dédiés.
Formater un LV en xfs ou ext4 avec idempotence.
Monter le LV via /dev/<vg>/<lv> dans fstab.
Étendre un LV à chaud avec lvol: resizefs: true.
Comprendre l’ordre du teardown (inverse de la création).

Prérequis

community.general et ansible.posix installés.
Sur le managed node : lvm2, parted, xfsprogs (généralement installés par défaut sur RHEL).

Pipeline complet

- name: Pipeline LVM complet
  hosts: db1.lab
  become: true
  tasks:
    - name: 1. Creer le VG sur un disque (ou loop device)
      community.general.lvg:
        vg: lab_vg
        pvs: /dev/loop10
        state: present

    - name: 2. Creer le LV (300M)
      community.general.lvol:
        vg: lab_vg
        lv: lab_lv
        size: 300M
        state: present

    - name: 3. Formater en xfs
      community.general.filesystem:
        fstype: xfs
        dev: /dev/lab_vg/lab_lv

    - name: 4. Creer le point de montage
      ansible.builtin.file:
        path: /mnt/lvm-data
        state: directory
        mode: "0755"

    - name: 5. Monter le LV (fstab + maintenant)
      ansible.posix.mount:
        path: /mnt/lvm-data
        src: /dev/lab_vg/lab_lv
        fstype: xfs
        opts: defaults,noatime
        state: mounted

5 tâches dans l’ordre strict. Chaque module est idempotent — 2e run → changed=0.

`lvg:` — Volume Group (PV + VG en une étape)

- community.general.lvg:
    vg: lab_vg
    pvs: /dev/loop10
    state: present

Le module fait 2 choses :

pvcreate /dev/loop10 — initialise le PV.
vgcreate lab_vg /dev/loop10 — crée le VG sur ce PV.

Étendre le VG ultérieurement avec un nouveau disque :

- community.general.lvg:
    vg: lab_vg
    pvs: /dev/loop10,/dev/loop11   # Ajout du 2e disque
    state: present

`lvol:` — Logical Volume

- community.general.lvol:
    vg: lab_vg
    lv: lab_lv
    size: 100%FREE
    state: present

Format de size: :

100M — taille fixe (en MB).
50%FREE — 50% de l’espace libre du VG.
+10G — extension de 10Go (relatif).
100%VG — tout l’espace du VG.

Le LV est créé à /dev/lab_vg/lab_lv (ou /dev/mapper/lab_vg-lab_lv).

Note RHCE : LVM arrondit à des multiples du PE size (4Mo par défaut). Demander 100M peut donner 100M ou 104M selon les cas.

`filesystem:` — formater le LV

- community.general.filesystem:
    fstype: xfs
    dev: /dev/lab_vg/lab_lv

Idempotent : si le filesystem est déjà du bon type, changed=0. force: true force le reformatage si un autre filesystem existe (DANGER — perte de données).

Filesystems supportés : ext2, ext3, ext4, xfs, btrfs, f2fs, etc.

Convention RHCE 2026 :

xfs est le défaut RHEL 7+ (performant, snapshots, quotas).
ext4 reste utilisé pour /boot ou besoin de réduction (xfs ne sait pas réduire).

Limitation xfs : taille minimale ~300Mo. En dessous, mkfs.xfs échoue.

`mount:` — monter le LV

- ansible.posix.mount:
    path: /mnt/lvm-data
    src: /dev/lab_vg/lab_lv
    fstype: xfs
    opts: defaults,noatime
    state: mounted

Le LV monté via /dev/<vg>/<lv> est plus stable que /dev/sdaX — LVM gère l’alias logique même si le disque change de position physique.

Pattern préféré pour fstab : utiliser UUID=... plutôt que /dev/... :

ssh ansible@db1.lab 'sudo blkid /dev/lab_vg/lab_lv'
# /dev/lab_vg/lab_lv: UUID="abc-123" TYPE="xfs"

Étendre un LV à chaud

Cas réel : votre /var/log/ est plein. Vous étendez le LV sans démonter :

- community.general.lvol:
    vg: lab_vg
    lv: lab_lv
    size: +500M
    resizefs: true   # Etend le filesystem aussi
    state: present

lvextend étend le LV de 500Mo.
resizefs: true lance xfs_growfs (ou resize2fs pour ext4) pour étendre le filesystem sans démonter.

Limitation XFS : xfs_growfs peut étendre mais pas réduire. Pour réduire, il faut ext4 ou démonter + reformater.

Le piège : ordre de teardown

# ❌ DANGER : vgremove echoue si des LVs existent encore
- community.general.lvg:
    vg: lab_vg
    state: absent

Ordre correct pour le teardown (inverse de la création) :

- name: 1. Demonter et retirer fstab
  ansible.posix.mount:
    path: /mnt/lvm-data
    state: absent

- name: 2. Supprimer le LV
  community.general.lvol:
    vg: lab_vg
    lv: lab_lv
    state: absent

- name: 3. Supprimer le VG
  community.general.lvg:
    vg: lab_vg
    state: absent

Sauter une étape = échec ou orphelins LVM qui hantent ensuite vos déploiements.

Pièges courants

Symptôme	Cause	Fix
`mkfs.xfs` failed sur LV 100M	xfs minimum ~300M	Augmenter le LV ou utiliser ext4
LV taille différente du `size:` demandé	Arrondi PE size	Vérifier avec `lvs --units M`
Teardown VG bloque	LVs encore présents	Supprimer LVs d’abord
`xfs_growfs` réduit failed	xfs ne sait pas réduire	Backup + reformater + restore

À retenir

Pipeline LVM : lvg: (PV+VG) → lvol: (LV) → filesystem: (FS) → mount:.
size: accepte : 100M, 50%FREE, +10G, 100%VG.
xfs est le défaut RHEL 7+ (limitation : ne réduit pas, minimum ~300M).
resizefs: true étend filesystem à chaud.
Teardown = inverse de la création (mount → lvol → lvg).
PE size (4Mo défaut) cause des arrondis légers sur la taille du LV.

Pratiquer dans le lab

Cette page a un lab d’accompagnement : labs/modules-rhel/lvm-storage/ dans stephrobert/ansible-training.

Challenge — sur db1.lab :

Loop device 500M sur /dev/loop10.
VG lab_vg, LV lab_lv (300M).
xfs + mount sur /mnt/lvm-data.

Validation pytest+testinfra :

ansible-playbook solution.yml
pytest -v labs/modules-rhel/lvm-storage/challenge/tests/

7 tests vérifient le pipeline complet : image, loop, VG, LV taille (~300M), xfs, mount actif avec noatime, fstab.

Prochaines étapes

Module mount Le module compagnon pour monter le LV final

Module file Créer le point de montage avant de monter

Module SELinux Gérer les contextes SELinux des données stockées sur le LV

Pivot Modules Vue d'ensemble des modules RHEL système