LVM — Gestion de volumes logiques

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np
import seaborn as sns
import pandas as pd

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

Pourquoi LVM

Le partitionnement classique souffre d’une limitation fondamentale : les tailles sont figées à la création. Redimensionner une partition sous Linux implique de la démonter, de la supprimer, de la recréer avec la bonne taille, puis de recréer et de restaurer le système de fichiers — une opération risquée et souvent impossible sans reboot.

Cas d’usage réels qui nécessitent LVM :

• Volume /var qui sature sur un serveur de logs — ajout d’un disque sans arrêt

• Redimensionnement de /home au profit de / après changement d’usage d’une machine

• Clonage cohérent d’une base de données via snapshot sans arrêt de service

• Migration de données d’un disque vieillissant vers un nouveau sans interruption (pvmove)

• Consolidation de plusieurs disques en un seul espace de nommage unifié

LVM (Logical Volume Manager) résout ces problèmes en introduisant une couche d’abstraction entre les disques physiques et les systèmes de fichiers.

---

Architecture LVM

LVM s’organise en trois niveaux hiérarchiques :

Physical Volume (PV)

Un PV est un disque ou une partition initialisé pour LVM. Il contient une PV label dans les premiers secteurs qui stocke : UUID, taille totale, liste des Volume Groups auxquels il appartient, et la metadata area — une copie circulaire des métadonnées LVM.

Volume Group (VG)

Un VG est un pool d’espace formé par un ou plusieurs PV. Il est découpé en Physical Extents (PE) de taille fixe (4 Mio par défaut, configurable de 1 Kio à 1 Gio). L’ensemble des PEs du VG forme un espace adressable unifié.

Logical Volume (LV)

Un LV est une allocation d’un nombre donné de PEs, présentée au système d’exploitation comme un périphérique bloc (/dev/vgname/lvname). Les PEs alloués peuvent être dispersés sur plusieurs PV.

Physical Extent (PE)

Unité minimale d’allocation LVM. La taille par défaut est 4 Mio. Un LV de 100 Gio avec des PEs de 4 Mio consomme 25 600 PEs.

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

fig, ax = plt.subplots(figsize=(13, 7))
ax.set_xlim(0, 13)
ax.set_ylim(0, 8)
ax.axis("off")
ax.set_title("Architecture LVM : PV → VG → LV", fontweight="bold", pad=14, fontsize=13)

# --- Disques physiques / PV ---
pv_configs = [
    (0.3, 5.5, "sda1\n200 Go", "#7f8c8d"),
    (3.3, 5.5, "sdb\n500 Go",  "#7f8c8d"),
    (6.3, 5.5, "sdc\n300 Go",  "#7f8c8d"),
]
for x, y, label, color in pv_configs:
    rect = mpatches.FancyBboxPatch((x, y), 2.5, 1.8,
        boxstyle="round,pad=0.12", fc=color, ec="white", lw=2)
    ax.add_patch(rect)
    ax.text(x + 1.25, y + 0.9, label, ha="center", va="center",
            fontsize=9, color="white", fontweight="bold")

ax.text(0.1, 7.65, "Physical Volumes (PV)", fontsize=10, color="#7f8c8d", fontweight="bold")

# --- Flèches PV → VG ---
for x in [1.55, 4.55, 7.55]:
    ax.annotate("", xy=(x, 4.95), xytext=(x, 5.45),
                arrowprops=dict(arrowstyle="->", color="#555", lw=2))

# --- Volume Group ---
vg_rect = mpatches.FancyBboxPatch((0.2, 2.8), 9.1, 2.0,
    boxstyle="round,pad=0.15", fc="#2c3e50", ec="#1a252f", lw=2.5)
ax.add_patch(vg_rect)
ax.text(4.75, 4.95, "Volume Group : vg_data  (1 000 Go total)", ha="center",
        fontsize=10, color="white", fontweight="bold")

# PEs simulées dans le VG
pe_colors = {
    "lv_root":  "#e74c3c",
    "lv_home":  "#3498db",
    "lv_data":  "#27ae60",
    "libre":    "#636e72",
}
pe_map = (
    ["lv_root"] * 5 + ["lv_home"] * 8 + ["lv_data"] * 12 + ["libre"] * 5
)
cols = 10
for i, pe in enumerate(pe_map[:30]):
    col = i % cols
    row = i // cols
    xp = 0.4 + col * 0.88
    yp = 2.95 + row * 0.85
    rect2 = mpatches.FancyBboxPatch((xp, yp), 0.76, 0.72,
        boxstyle="round,pad=0.03", fc=pe_colors[pe], ec="white", lw=1)
    ax.add_patch(rect2)

ax.text(0.2, 2.6, "Volume Group (VG)", fontsize=10, color="#2c3e50", fontweight="bold")

# --- Logical Volumes ---
lv_configs = [
    (0.2,  0.3, 2.0, "#e74c3c", "lv_root\n50 Go  ext4  /"),
    (2.5,  0.3, 3.5, "#3498db", "lv_home\n100 Go  xfs  /home"),
    (6.3,  0.3, 3.1, "#27ae60", "lv_data\n150 Go  ext4  /data"),
]
for x, y, w, color, label in lv_configs:
    rect = mpatches.FancyBboxPatch((x, y), w, 1.5,
        boxstyle="round,pad=0.12", fc=color, ec="white", lw=2)
    ax.add_patch(rect)
    ax.text(x + w / 2, y + 0.75, label, ha="center", va="center",
            fontsize=8.5, color="white", fontweight="bold")
    ax.annotate("", xy=(x + w / 2, 1.8), xytext=(x + w / 2, 2.75),
                arrowprops=dict(arrowstyle="->", color="#555", lw=1.8))

ax.text(0.2, 2.1, "Logical Volumes (LV)", fontsize=10, color="#555", fontweight="bold")

plt.tight_layout()
plt.show()

---

Création d’une infrastructure LVM

Étape 1 — Initialiser les Physical Volumes

# Initialiser trois disques/partitions comme PV
sudo pvcreate /dev/sda1 /dev/sdb /dev/sdc
#   Physical volume "/dev/sda1" successfully created.
#   Physical volume "/dev/sdb" successfully created.
#   Physical volume "/dev/sdc" successfully created.

Étape 2 — Créer le Volume Group

# Créer le VG "vg_data" avec les trois PV, PE de 4 Mio (défaut)
sudo vgcreate vg_data /dev/sda1 /dev/sdb /dev/sdc
#   Volume group "vg_data" successfully created

# Avec une PE size personnalisée (utile pour les grands volumes)
sudo vgcreate -s 16M vg_large /dev/sdd

Étape 3 — Créer les Logical Volumes

# LV de taille fixe
sudo lvcreate -L 50G -n lv_root vg_data
#   Logical volume "lv_root" created.

# LV utilisant un pourcentage du VG libre
sudo lvcreate -l 100%FREE -n lv_data vg_data

# LV de type linéaire strippé sur 2 PV (performances)
sudo lvcreate -L 100G -n lv_fast -i2 -I64 vg_data

# Formater et monter
sudo mkfs.ext4 /dev/vg_data/lv_root
sudo mkfs.xfs  /dev/vg_data/lv_data
sudo mount /dev/vg_data/lv_root /

Chemins des LV

Un LV est accessible via deux chemins équivalents : /dev/vgname/lvname (lien symbolique créé par udev) et /dev/mapper/vgname-lvname (device-mapper). Dans /etc/fstab, préférer le lien symbolique qui est plus lisible.

---

Inspection de l’infrastructure LVM

Vue synthétique

pvs
# PV          VG       Fmt  Attr PSize    PFree
# /dev/sda1   vg_data  lvm2 a--  200.00g  50.00g
# /dev/sdb    vg_data  lvm2 a--  500.00g 400.00g
# /dev/sdc    vg_data  lvm2 a--  300.00g 150.00g

vgs
# VG       #PV #LV #SN Attr   VSize    VFree
# vg_data    3   3   0 wz--n-  996.00g 600.00g

lvs
# LV       VG       Attr       LSize   Pool Origin Data%
# lv_data  vg_data  -wi-ao---- 396.00g
# lv_home  vg_data  -wi-ao---- 100.00g
# lv_root  vg_data  -wi-ao----  50.00g

Vue détaillée

pvdisplay /dev/sdb
# --- Physical volume ---
# PV Name               /dev/sdb
# VG Name               vg_data
# PV Size               500.00 GiB / not usable 4.00 MiB
# Allocatable           yes
# PE Size               4.00 MiB
# Total PE              127999
# Free PE               102399
# Allocated PE          25600

lvdisplay /dev/vg_data/lv_root
# --- Logical volume ---
# LV Path                /dev/vg_data/lv_root
# LV Name                lv_root
# VG Name                vg_data
# LV UUID                AbCd12-...
# LV Write Access        read/write
# LV Status              available
# # open                 1
# LV Size                50.00 GiB
# Current LE             12800
# Segments               1
# Allocation             inherit
# Read ahead sectors     auto
# Block device           253:0

---

Redimensionnement à chaud

Extension d’un LV

# Étendre lv_home de 50 Go supplémentaires
sudo lvextend -L +50G /dev/vg_data/lv_home
#   Size of logical volume vg_data/lv_home changed from 100.00 GiB to 150.00 GiB.
#   Logical volume vg_data/lv_home successfully resized.

# Étendre le système de fichiers ext4 (en ligne, volume monté)
sudo resize2fs /dev/vg_data/lv_home
# resize2fs ... (150.0 GiB)
# The filesystem on /dev/vg_data/lv_home is now 39321600 (4k) blocks long.

# Étendre le système de fichiers XFS (en ligne)
sudo xfs_growfs /home

# Raccourci : extension LV + resize2fs en une commande
sudo lvextend -L +50G -r /dev/vg_data/lv_home

Réduction d’un LV (ext4 uniquement)

# ATTENTION : la réduction est irréversible si mal effectuée
# 1. Démonter obligatoirement
sudo umount /home

# 2. Vérifier le système de fichiers
sudo e2fsck -f /dev/vg_data/lv_home

# 3. Réduire le FS d'abord (AVANT de réduire le LV)
sudo resize2fs /dev/vg_data/lv_home 80G

# 4. Réduire le LV (même taille ou légèrement supérieure)
sudo lvreduce -L 80G /dev/vg_data/lv_home
#   WARNING: Reducing active logical volume to 80.00 GiB.
#   THIS MAY DESTROY YOUR DATA (filesystem etc.)
# Do you really want to reduce vg_data/lv_home? [y/n]: y

# 5. Remonter
sudo mount /dev/vg_data/lv_home /home

Extension du VG (ajout d’un disque)

# Ajouter un nouveau disque au VG existant
sudo pvcreate /dev/sdd
sudo vgextend vg_data /dev/sdd
#   Physical volume "/dev/sdd" successfully created.
#   Volume group "vg_data" successfully extended

Comparaison avant/après redimensionnement

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

volumes  = ["lv_root", "lv_home", "lv_data"]
avant    = [50, 100, 200]
apres    = [50, 150, 350]

x  = np.arange(len(volumes))
w  = 0.35

fig, ax = plt.subplots(figsize=(9, 5))
b1 = ax.bar(x - w/2, avant, w, label="Avant", color="#95a5a6", edgecolor="white", linewidth=1.5)
b2 = ax.bar(x + w/2, apres, w, label="Après",  color="#27ae60", edgecolor="white", linewidth=1.5)

for bar in b1:
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 3,
            f"{int(bar.get_height())} Go", ha="center", fontsize=8.5, color="#555")
for bar in b2:
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 3,
            f"{int(bar.get_height())} Go", ha="center", fontsize=8.5, color="#27ae60",
            fontweight="bold")

ax.set_xticks(x)
ax.set_xticklabels(volumes, fontsize=10)
ax.set_ylabel("Taille (Go)")
ax.set_title("Redimensionnement LVM à chaud", fontweight="bold")
ax.legend()
plt.tight_layout()
plt.show()

---

Snapshots LVM

Un snapshot LVM crée une vue cohérente d’un LV à un instant donné. Il utilise le mécanisme CoW (Copy-on-Write) : les blocs originaux ne sont copiés dans le snapshot qu’au moment où ils sont modifiés dans le LV source.

Création et utilisation

# Créer un snapshot de 5 Go de lv_data
# (5 Go doit suffire pour stocker les blocs modifiés pendant la sauvegarde)
sudo lvcreate -L 5G -s -n lv_data_snap /dev/vg_data/lv_data
#   Logical volume "lv_data_snap" created.

# Monter le snapshot en lecture seule pour sauvegarder
sudo mount -o ro /dev/vg_data/lv_data_snap /mnt/snap

# Sauvegarder depuis le snapshot (cohérence garantie)
sudo rsync -a /mnt/snap/ /backup/data_$(date +%Y%m%d)/

# Démonter et supprimer le snapshot
sudo umount /mnt/snap
sudo lvremove /dev/vg_data/lv_data_snap

Surveiller l’utilisation du snapshot

lvs -o name,size,data_percent,snap_percent
# LV            LSize  Data%  Snap%
# lv_data       200.00g
# lv_data_snap    5.00g  23.45  23.45

Si le snapshot se remplit à 100%, il est automatiquement invalidé. Toujours allouer suffisamment d’espace ou surveiller via lvs.

Schéma CoW

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

fig, axes = plt.subplots(1, 3, figsize=(13, 5))

def draw_blocks(ax, title, data_blocks, snap_blocks, cow_blocks=None, subtitle=""):
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 5)
    ax.axis("off")
    ax.set_title(title, fontweight="bold", fontsize=9, pad=8)
    cols = 4

    for i, (val, color) in enumerate(data_blocks):
        c, r = i % cols, i // cols
        rect = mpatches.FancyBboxPatch((0.3 + c * 1.05, 2.8 - r * 1.05), 0.85, 0.85,
            boxstyle="round,pad=0.04", fc=color, ec="white", lw=1.5)
        ax.add_patch(rect)
        ax.text(0.3 + c * 1.05 + 0.425, 2.8 - r * 1.05 + 0.425, val,
                ha="center", va="center", fontsize=8, color="white", fontweight="bold")

    ax.text(2.5, 3.82, "LV original", ha="center", fontsize=8, color="#2c3e50", fontweight="bold")

    if snap_blocks:
        for i, (val, color) in enumerate(snap_blocks):
            c = i % cols
            rect = mpatches.FancyBboxPatch((0.3 + c * 1.05, 0.4), 0.85, 0.85,
                boxstyle="round,pad=0.04", fc=color, ec="white", lw=1.5)
            ax.add_patch(rect)
            ax.text(0.3 + c * 1.05 + 0.425, 0.4 + 0.425, val,
                    ha="center", va="center", fontsize=8, color="white", fontweight="bold")
        ax.text(2.5, 1.42, "Snapshot", ha="center", fontsize=8, color="#8e44ad", fontweight="bold")

    if cow_blocks is not None:
        for idx in cow_blocks:
            c = idx % cols
            ax.annotate("", xy=(0.3 + c * 1.05 + 0.425, 1.25),
                        xytext=(0.3 + c * 1.05 + 0.425, 2.8),
                        arrowprops=dict(arrowstyle="->", color="#e74c3c", lw=1.5))
    ax.text(2.5, 0.1, subtitle, ha="center", fontsize=7.5, color="#555", style="italic")

# T=0 : snapshot créé, aucun bloc copié
data0 = [("A", "#3498db"), ("B", "#3498db"), ("C", "#3498db"), ("D", "#3498db")]
snap0 = [("→A", "#8e44ad"), ("→B", "#8e44ad"), ("→C", "#8e44ad"), ("→D", "#8e44ad")]
draw_blocks(axes[0], "T₀ — Création snapshot", data0, snap0,
            subtitle="Snapshot pointe vers les blocs originaux")

# T=1 : bloc B modifié dans LV → ancien B copié dans snapshot
data1 = [("A", "#3498db"), ("B'", "#e74c3c"), ("C", "#3498db"), ("D", "#3498db")]
snap1 = [("→A", "#8e44ad"), ("B", "#27ae60"), ("→C", "#8e44ad"), ("→D", "#8e44ad")]
draw_blocks(axes[1], "T₁ — Bloc B modifié dans LV", data1, snap1, cow_blocks=[1],
            subtitle="B original copié dans le snapshot (CoW)")

# T=2 : snapshot contient l'état cohérent de T=0
data2 = [("A", "#3498db"), ("B'", "#e74c3c"), ("C", "#3498db"), ("D", "#3498db")]
snap2 = [("→A", "#8e44ad"), ("B", "#27ae60"), ("→C", "#8e44ad"), ("→D", "#8e44ad")]
draw_blocks(axes[2], "T₂ — Vue snapshot = état T₀", data2, snap2,
            subtitle="LV courant modifié, snapshot intact")

plt.suptitle("Mécanisme Copy-on-Write du snapshot LVM", fontweight="bold", fontsize=11)
plt.tight_layout()
plt.show()

---

LVM Thin Provisioning

Le thin provisioning permet de créer des LV dont la taille logique déclarée dépasse l’espace physique réellement alloué (sur-allocation). L’espace réel est consommé à la demande.

# Créer un thin pool de 200 Go dans vg_data
sudo lvcreate -L 200G -T vg_data/tp_pool
#   Logical volume "tp_pool" created.

# Créer des thin volumes dont la somme dépasse 200 Go
sudo lvcreate -V 100G -T vg_data/tp_pool -n tv_vm1
sudo lvcreate -V 100G -T vg_data/tp_pool -n tv_vm2
sudo lvcreate -V 100G -T vg_data/tp_pool -n tv_vm3
# Allocation logique totale : 300 Go pour 200 Go physiques

# Surveiller l'utilisation réelle du pool
lvs -o name,lv_size,data_percent,pool_lv
# LV       LSize   Data%  Pool
# tp_pool  200.00g  45.20
# tv_vm1   100.00g   30.10  tp_pool
# tv_vm2   100.00g   55.00  tp_pool
# tv_vm3   100.00g   60.30  tp_pool

Danger de sur-allocation

Si le thin pool se remplit à 100%, tous les thin volumes associés deviennent inaccessibles (erreur I/O). Mettre en place une supervision avec alerte à 80% d’utilisation du pool. Étendre le pool en urgence : lvextend -L +50G vg_data/tp_pool.

---

Migration de données avec pvmove

pvmove déplace les PEs d’un PV vers d’autres PV du même VG, à chaud, sans interruption de service.

# Voir la répartition des PEs par PV
pvs -o pv_name,lv_name,seg_start_pe,seg_size_pe

# Déplacer tous les LEs de /dev/sda1 vers les autres PV du VG
sudo pvmove /dev/sda1
#   /dev/sda1: Moved: 12.50%
#   /dev/sda1: Moved: 25.00%
#   ...
#   /dev/sda1: Moved: 100.00%

# Après pvmove, supprimer le PV du VG
sudo vgreduce vg_data /dev/sda1
#   Removed "/dev/sda1" from volume group "vg_data"

# Supprimer le label LVM du PV (pour réutiliser le disque)
sudo pvremove /dev/sda1
#   Labels on physical volume "/dev/sda1" successfully wiped.

Pendant pvmove, les données restent accessibles. En cas d’interruption (reboot), pvmove reprend automatiquement au prochain démarrage via les métadonnées du VG.

Simulation d’allocation de PEs

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

np.random.seed(42)

# Simulation de la carte des PEs sur un VG avec 3 PV
# sda1 : 50 PEs, sdb : 125 PEs, sdc : 75 PEs
pv_sizes  = {"sda1": 50, "sdb": 125, "sdc": 75}
lv_colors = {
    "lv_root": "#e74c3c",
    "lv_home": "#3498db",
    "lv_data": "#27ae60",
    "libre":   "#dfe6e9",
}

# Répartition simulée des PEs par PV et LV
allocation = {
    "sda1": ["lv_root"] * 12 + ["lv_home"] * 20 + ["libre"] * 18,
    "sdb":  ["lv_root"] * 0  + ["lv_home"] * 30 + ["lv_data"] * 60 + ["libre"] * 35,
    "sdc":  ["lv_data"] * 50 + ["libre"] * 25,
}

fig, axes = plt.subplots(1, 3, figsize=(13, 5))
for ax, (pv, pes) in zip(axes, allocation.items()):
    n = len(pes)
    cols = 10
    rows = (n + cols - 1) // cols
    ax.set_xlim(-0.5, cols)
    ax.set_ylim(-1, rows + 0.5)
    ax.axis("off")
    ax.set_title(f"/dev/{pv}\n({n} PEs × 4 Mio = {n*4} Gio)", fontweight="bold", fontsize=9)

    for i, lv in enumerate(pes):
        c = i % cols
        r = rows - 1 - i // cols
        color = lv_colors[lv]
        rect = plt.Rectangle((c, r), 0.85, 0.75, fc=color, ec="white", lw=1)
        ax.add_patch(rect)

# Légende commune
legend_patches = [mpatches.Patch(fc=c, label=n, ec="white")
                  for n, c in lv_colors.items()]
fig.legend(handles=legend_patches, loc="lower center", ncol=4, fontsize=9,
           bbox_to_anchor=(0.5, -0.02))
plt.suptitle("Carte d'allocation des Physical Extents dans vg_data", fontweight="bold", fontsize=11)
plt.tight_layout()
plt.show()

---

LVM et systemd

Activation automatique au démarrage

Sur les systèmes avec systemd, l’activation des VG et LV est gérée par :

• lvm2-monitor.service : surveille l’état des LV (dmeventd)

• lvm2-pvscan@.service : scanné par udev à la détection de chaque disque

# Vérifier l'état
systemctl status lvm2-monitor.service
systemctl status lvm2-pvscan@8:0.service  # major:minor du disque

# Forcer un scan manuel
sudo vgscan --cache
sudo vgchange -ay   # activer tous les VG

Persistance de la configuration LVM

La configuration globale se trouve dans /etc/lvm/lvm.conf. Elle contrôle notamment :

• filter : liste des périphériques à inclure ou exclure du scan

• auto_activation_volume_list : VGs à activer automatiquement

• backup : sauvegarde automatique des métadonnées VG dans /etc/lvm/backup/

# Activer la sauvegarde automatique des métadonnées (défaut : on)
grep -A2 "backup {" /etc/lvm/lvm.conf
# backup {
#     backup = 1
#     backup_dir = "/etc/lvm/backup"

# Sauvegarder manuellement
sudo vgcfgbackup vg_data
# Volume group configuration for vg_data successfully backed up.
# Backed up volume group data to /etc/lvm/backup/vg_data (seqno 15).

# Restaurer depuis une sauvegarde
sudo vgcfgrestore vg_data

---

Résumé

LVM transforme la gestion de l’espace disque d’une opération risquée et statique en une activité dynamique et réversible.

Points essentiels :

• PV → VG → LV est la hiérarchie immuable. Un LV ne peut pas exister sans VG, un VG sans PV.

• pvs, vgs, lvs donnent une vue synthétique ; pvdisplay, vgdisplay, lvdisplay donnent les détails.

• L’extension d’un LV est toujours sûre (avec -r pour redimensionner le FS simultanément). La réduction est risquée et interdite pour XFS.

• Les snapshots LVM permettent des sauvegardes cohérentes sans arrêt de service, mais leur espace doit être surveillé.

• pvmove permet de migrer des données à chaud pour décommissionner un disque.

• Le thin provisioning est puissant mais exige une surveillance stricte de l’utilisation du pool.

• systemd gère l’activation automatique des VG via lvm2-monitor.service et vgchange -ay.

Pour aller plus loin

Le chapitre 8 présente RAID (mdadm et lvmraid) qui peut se combiner avec LVM pour ajouter la redondance à la flexibilité. Les snapshots LVM y sont réutilisés comme base de stratégie de sauvegarde.