DevOps Bootcamp · Leçon

Automatiser les disques, systèmes de fichiers et montages

Inspectez les périphériques blocs, gérez les entrées fstab et automatisez sans risque les opérations LVM et de montage.

Automatiser les disques, systèmes de fichiers et montages est une leçon DevOps Bootcamp gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage DevOps Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours DevOps Bootcamp comprend 4 leçons au total.

Comprendre les périphériques en mode bloc avec lsblk et fdisk

Avant d’automatiser les opérations sur les disques, vous devez savoir examiner les périphériques en mode bloc présents sur le système. Deux outils essentiels sont lsblk et fdisk -l.

lsblk — répertorie les périphériques en mode bloc sous forme d’arborescence, avec les noms des périphériques, les tailles, les points de montage et les types (disk, part, lvm)
fdisk -l — affiche les tables de partitions et les détails des secteurs (les privilèges root sont requis)
blkid — affiche les UUID et les types de systèmes de fichiers de chaque périphérique en mode bloc

Dans les scripts, vous devrez souvent analyser cette sortie pour détecter les disques disponibles, vérifier si une partition est formatée ou déterminer son UUID avant de la monter.

#!/usr/bin/env bash
# Inspect all block devices and their UUIDs
set -euo pipefail

echo '=== Block Device Tree ==='
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,UUID

echo ''
echo '=== Partition Table Details ==='
sudo fdisk -l 2>/dev/null | grep -E '^Disk |^/dev/'

echo ''
echo '=== UUID Lookup via blkid ==='
sudo blkid | awk -F: '{print $1}' | while read -r dev; do
  uuid=$(sudo blkid -s UUID -o value "$dev" 2>/dev/null || echo 'N/A')
  fstype=$(sudo blkid -s TYPE -o value "$dev" 2>/dev/null || echo 'unknown')
  printf '%-20s UUID=%-38s TYPE=%s\n' "$dev" "$uuid" "$fstype"
done

Vérifier l’espace disque avec df et du

df et du sont les outils de référence pour indiquer l’utilisation des systèmes de fichiers et des répertoires. Dans les scripts d’administration système, vous les utilisez pour déclencher des alertes, appliquer des quotas ou décider quand fournir davantage d’espace.

df -h — utilisation des systèmes de fichiers dans un format lisible, pour tous les systèmes de fichiers montés
df -BG — sortie en gigaoctets pour permettre une analyse numérique cohérente
du -sh /path — taille récapitulative d’un répertoire donné
du -d 1 /var — répartition sur un seul niveau (utile pour trouver le sous-répertoire volumineux)

La colonne pourcentage utilisé de df est couramment analysée pour déclencher des alertes de disque plein dans les scripts de supervision.

#!/usr/bin/env bash
# Alert if any mounted filesystem exceeds a usage threshold
set -euo pipefail

THRESHOLD=80   # percent

echo 'Checking filesystem usage...'
df -h --output=source,pcent,target | tail -n +2 | while IFS= read -r line; do
  device=$(awk '{print $1}' <<< "$line")
  pct=$(awk '{print $2}' <<< "$line" | tr -d '%')
  mount=$(awk '{print $3}' <<< "$line")

  # Skip pseudo filesystems
  [[ "$device" == tmpfs* || "$device" == devtmpfs* ]] && continue

  if (( pct >= THRESHOLD )); then
    echo "WARNING: $device mounted at $mount is ${pct}% full" >&2
  else
    echo "OK: $device at $mount is ${pct}% used"
  fi
done

Lire et analyser /etc/fstab

/etc/fstab est la table statique des systèmes de fichiers : elle définit quels périphériques sont montés au démarrage, à quel emplacement et avec quelles options. Chaque ligne comporte six champs :

Périphérique — UUID=..., LABEL=... ou /dev/sdX
Point de montage — chemin du répertoire
Type de système de fichiers — ext4, xfs, nfs, tmpfs, etc.
Options — defaults, ro, noexec, nofail, etc.
Dump — 0 ou 1 (indicateur de sauvegarde)
Pass — 0, 1 ou 2 (ordre de fsck)

Les scripts qui ajoutent ou valident des entrées fstab doivent gérer correctement les commentaires (lignes commençant par #) et les lignes vides. Préférez toujours les UUID aux noms de périphériques afin de résister aux redémarrages susceptibles de modifier l’ordre des périphériques.

#!/usr/bin/env bash
# Parse /etc/fstab and display non-comment entries in a readable table
set -euo pipefail

FSTAB=/etc/fstab

printf '%-40s %-20s %-10s %s\n' 'DEVICE' 'MOUNTPOINT' 'FSTYPE' 'OPTIONS'
printf '%s\n' '-------------------------------------------------------------------------------------'

while IFS= read -r line; do
  # Skip blank lines and comments
  [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue

  read -r device mountpt fstype options _dump _pass <<< "$line"
  printf '%-40s %-20s %-10s %s\n' "$device" "$mountpt" "$fstype" "$options"
done < "$FSTAB"

Ajouter une entrée fstab en toute sécurité

Modifier manuellement /etc/fstab est source d’erreurs. Une entrée incorrecte peut empêcher le système de démarrer. Un script d’automatisation sûr doit :

Vérifier que l’entrée n’existe pas déjà avant de l’ajouter (idempotence)
Sauvegarder le fichier d’origine avant toute modification
Utiliser l’UUID plutôt que le chemin du périphérique
Ajouter nofail aux options de montage afin que l’absence d’un disque n’interrompe pas le démarrage
Exécuter mount -a en mode simulation ou effectuer un montage de test pour valider la configuration avant de redémarrer

Après avoir écrit l’entrée, vérifiez toujours avec findmnt --verify (disponible sur les distributions modernes utilisant systemd) afin de détecter immédiatement les erreurs de syntaxe.

#!/usr/bin/env bash
# Safely append a new entry to /etc/fstab (idempotent)
set -euo pipefail

DEVICE_PATH='/dev/sdb1'
MOUNTPOINT='/mnt/data'
FSTYPE='ext4'
OPTIONS='defaults,nofail'
FSTAB='/etc/fstab'

# Resolve UUID for stable identification
UUID=$(sudo blkid -s UUID -o value "$DEVICE_PATH")
if [[ -z "$UUID" ]]; then
  echo "ERROR: Could not resolve UUID for $DEVICE_PATH" >&2
  exit 1
fi

ENTRY="UUID=$UUID  $MOUNTPOINT  $FSTYPE  $OPTIONS  0  2"

# Idempotency: skip if UUID already referenced in fstab
if grep -qsF "UUID=$UUID" "$FSTAB"; then
  echo "INFO: fstab already contains UUID=$UUID — skipping."
  exit 0
fi

# Backup
cp -p "$FSTAB" "${FSTAB}.bak.$(date +%Y%m%d%H%M%S)"

# Create mountpoint if needed
sudo mkdir -p "$MOUNTPOINT"

# Append entry
echo "$ENTRY" | sudo tee -a "$FSTAB" > /dev/null
echo "INFO: Added: $ENTRY"

# Validate
sudo findmnt --verify --verbose || echo 'WARNING: findmnt verify reported issues'

Monter et démonter des systèmes de fichiers dans des scripts

Les commandes mount et umount sont simples à utiliser, mais les scripts doivent gérer certains cas particuliers :

Un périphérique peut être déjà monté — un nouveau montage échoue ; vérifiez avec findmnt ou mountpoint
Un point de montage peut être occupé (fichiers ouverts) — umount échoue ; utilisez lsof +D /mnt/target pour trouver les processus concernés
Utilisez mount -o remount,ro /mnt/data pour passer en lecture seule sans démonter
Utilisez umount -l /mnt/data (démontage différé) en dernier recours : cela détache l’espace de noms, mais attend la fermeture des références

Dans une automatisation, vérifiez toujours le code de sortie de mount et consignez les échecs dans syslog avec logger.

#!/usr/bin/env bash
# Mount a device only if not already mounted; log outcome
set -euo pipefail

DEVICE='/dev/sdb1'
MOUNTPOINT='/mnt/data'

log() { logger -t disk-mount "$*"; echo "[$(date '+%F %T')] $*"; }

# Check if already mounted
if mountpoint -q "$MOUNTPOINT"; then
  log "INFO: $MOUNTPOINT is already mounted — nothing to do."
  exit 0
fi

# Ensure mountpoint directory exists
sudo mkdir -p "$MOUNTPOINT"

# Attempt mount
if sudo mount "$DEVICE" "$MOUNTPOINT"; then
  log "OK: Mounted $DEVICE at $MOUNTPOINT"
else
  log "ERROR: Failed to mount $DEVICE at $MOUNTPOINT"
  exit 1
fi

# Show what is now mounted there
df -h "$MOUNTPOINT"

Introduction à LVM : volumes physiques, groupes de volumes et volumes logiques

LVM (Logical Volume Manager) ajoute une couche d’abstraction flexible entre les périphériques bloc bruts et les systèmes de fichiers. La hiérarchie à trois niveaux est la suivante :

Physical Volume (PV) — un disque brut ou une partition initialisé avec pvcreate
Volume Group (VG) — un ou plusieurs PV regroupés avec vgcreate
Logical Volume (LV) — une partition virtuelle créée à partir d’un VG avec lvcreate ; c’est cet élément que vous formatez et montez

L’avantage principal est de pouvoir étendre un LV en ligne sans le démonter et d’ajouter de nouveaux disques à un VG sans le reformater. LVM est ainsi essentiel pour automatiser le stockage en production.

Commandes d’inspection : pvs, vgs, lvs, ainsi que leurs équivalents détaillés pvdisplay, vgdisplay et lvdisplay.

Créer des volumes LVM avec des scripts

L’automatisation de la configuration de LVM suit une séquence stricte : pvcreate → vgcreate → lvcreate → mkfs → mount. Chaque étape doit réussir avant l’exécution de la suivante — utilisez set -euo pipefail et validez la sortie de chaque commande.

Vérifiez toujours que le disque cible ne contient aucune table de partitions avant d’appeler pvcreate
Utilisez l’option -y pour supprimer les invites interactives dans les scripts non interactifs
Indiquez -L (taille fixe) ou -l 100%FREE pour utiliser tout l’espace restant
Après mkfs, utilisez le chemin du périphérique du LV : /dev/<vgname>/<lvname>

#!/usr/bin/env bash
# Automate LVM setup: PV -> VG -> LV -> mkfs -> mount
set -euo pipefail

DISK='/dev/sdc'          # raw disk, no existing partitions
VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
LV_SIZE='10G'
MOUNTPOINT='/mnt/appdata'
FSTYPE='xfs'

echo "[1/6] Initializing Physical Volume on $DISK"
sudo pvcreate -y "$DISK"

echo "[2/6] Creating Volume Group: $VG_NAME"
sudo vgcreate "$VG_NAME" "$DISK"

echo "[3/6] Creating Logical Volume: $LV_NAME (${LV_SIZE})"
sudo lvcreate -y -L "$LV_SIZE" -n "$LV_NAME" "$VG_NAME"

echo "[4/6] Formatting as $FSTYPE"
sudo mkfs."$FSTYPE" "/dev/$VG_NAME/$LV_NAME"

echo "[5/6] Mounting at $MOUNTPOINT"
sudo mkdir -p "$MOUNTPOINT"
sudo mount "/dev/$VG_NAME/$LV_NAME" "$MOUNTPOINT"

echo "[6/6] Done. Disk usage:"
df -h "$MOUNTPOINT"

# Show LVM summary
vgs && lvs

Étendre un volume logique en ligne

L’une des fonctionnalités les plus puissantes de LVM est le redimensionnement en ligne : vous pouvez étendre un volume logique et son système de fichiers alors qu’il est monté et utilisé. La procédure est la suivante :

Étendez le LV avec lvextend (l’option -r redimensionne le système de fichiers au cours de la même étape)
Si vous n’utilisez pas -r, redimensionnez séparément le système de fichiers : resize2fs pour ext4 et xfs_growfs pour xfs

Contraintes importantes :

xfs peut uniquement être agrandi, jamais réduit — planifiez soigneusement la capacité
ext4 peut être réduit, mais uniquement lorsqu’il est démonté
Vérifiez toujours que le VG dispose d’espace libre avec vgdisplay -s avant de l’étendre

#!/usr/bin/env bash
# Extend an LV and its xfs filesystem online
set -euo pipefail

VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
EXTEND_BY='5G'
LV_DEV="/dev/$VG_NAME/$LV_NAME"

# Confirm VG has enough free space
FREE_GB=$(vgs --noheadings --units g -o vg_free "$VG_NAME" | tr -d ' g')
echo "VG free space: ${FREE_GB}G"
if (( $(echo "$FREE_GB < 5" | bc -l) )); then
  echo 'ERROR: Not enough free space in VG' >&2
  exit 1
fi

echo "Extending LV by $EXTEND_BY..."
sudo lvextend -L "+${EXTEND_BY}" "$LV_DEV"

echo 'Growing xfs filesystem online...'
sudo xfs_growfs "$LV_DEV"

echo 'New size:'
df -h "$LV_DEV"
lvs "$LV_DEV"

Créer et formater des systèmes de fichiers

Après le partitionnement ou la configuration de LVM, vous devez formater le périphérique bloc avec un système de fichiers. Voici les choix courants dans l’administration Linux :

ext4 — mature, journalisé, prend en charge la réduction ; système par défaut de nombreuses distributions (mkfs.ext4)
xfs — hautes performances, privilégié pour les fichiers volumineux et les entrées-sorties parallèles ; système par défaut de RHEL/CentOS (mkfs.xfs)
btrfs — copie sur écriture, instantanés intégrés (mkfs.btrfs)
tmpfs — fondé sur la RAM, indiqué dans fstab sans mkfs

Définissez toujours un label de système de fichiers pertinent (option -L) afin de pouvoir référencer le périphérique avec LABEL= dans fstab comme solution de repli à l’UUID.

#!/usr/bin/env bash
# Format a partition and assign a label; print resulting UUID
set -euo pipefail

PARTITION='/dev/sdb1'
FSTYPE='ext4'
LABEL='appdata'

# Safety check: refuse to format a currently mounted device
if findmnt --source "$PARTITION" > /dev/null 2>&1; then
  echo "ERROR: $PARTITION is currently mounted. Unmount first." >&2
  exit 1
fi

echo "Formatting $PARTITION as $FSTYPE with label '$LABEL'..."
sudo mkfs."$FSTYPE" -L "$LABEL" -F "$PARTITION"

# Retrieve and display the new UUID
NEW_UUID=$(sudo blkid -s UUID -o value "$PARTITION")
echo "Formatted successfully."
echo "Label : $LABEL"
echo "UUID  : $NEW_UUID"
echo "Use this in fstab: UUID=$NEW_UUID  /mnt/$LABEL  $FSTYPE  defaults,nofail  0  2"

Automatiser les montages NFS avec autofs

Pour les systèmes de fichiers réseau, effectuer le montage au démarrage avec fstab peut provoquer des délais ou des échecs si le serveur NFS est temporairement inaccessible. autofs résout ce problème en montant les ressources à la demande et en les démontant après un délai d’attente.

Carte maîtresse : /etc/auto.master — définit le répertoire des points de montage et son fichier de carte
Carte directe : /etc/auto.nfs — indique les options et le chemin du serveur NFS pour chaque sous-répertoire
Rechargez avec systemctl reload autofs après toute modification
Les montages apparaissent automatiquement dans le répertoire configuré lorsqu’ils sont utilisés

Dans les scripts, vous pouvez générer dynamiquement le fichier de carte à partir d’une liste de partages NFS, puis recharger autofs — ce qui est utile pour provisionner un stockage partagé sur de nombreux hôtes.

#!/usr/bin/env bash
# Generate an autofs NFS map file from a share list and reload autofs
set -euo pipefail

NFS_SERVER='192.168.1.50'
AUTO_MAP='/etc/auto.nfs'
AUTO_MASTER='/etc/auto.master'
MOUNT_BASE='/nfs'

# Define shares: localname:remote_path
declare -A SHARES=(
  [homes]='/export/homes'
  [media]='/export/media'
  [backups]='/export/backups'
)

# Write map file
{
  echo '# Generated by disk-automation script'
  for localname in "${!SHARES[@]}"; do
    remote="${SHARES[$localname]}"
    echo "$localname  -rw,soft,timeo=30  ${NFS_SERVER}:${remote}"
  done
} | sudo tee "$AUTO_MAP" > /dev/null

echo "Wrote $AUTO_MAP"

# Ensure master map references this file
if ! grep -qF "$AUTO_MAP" "$AUTO_MASTER"; then
  echo "$MOUNT_BASE  $AUTO_MAP" | sudo tee -a "$AUTO_MASTER" > /dev/null
  echo "Updated $AUTO_MASTER"
fi

sudo systemctl reload autofs && echo 'autofs reloaded'

Instantané LVM pour des sauvegardes sûres

Les instantanés LVM fournissent une copie à un instant donné d’un volume logique, ce qui permet d’effectuer des sauvegardes cohérentes de systèmes de fichiers actifs sans les démonter. L’instantané capture l’état du volume au moment de sa création grâce à la copie sur écriture.

Créer : lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Monter l’instantané en lecture seule pour le sauvegarder : mount -o ro /dev/vg_data/lv_snap /mnt/snap
Exécuter rsync ou tar sur le point de montage de l’instantané
Supprimer l’instantané après la sauvegarde : umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Réservez à l’instantané une taille correspondant à 10 à 20 % du LV d’origine. S’il est entièrement rempli, il devient invalide — surveillez-le avec lvs -o lv_name,snap_percent.

#!/usr/bin/env bash
# Create an LVM snapshot, back up via tar, then remove snapshot
set -euo pipefail

VG='vg_appdata'
ORIGIN_LV='lv_appdata'
SNAP_LV='lv_appdata_snap'
SNAP_SIZE='2G'
SNAP_MOUNT='/mnt/snap_backup'
BACKUP_DEST='/var/backups/appdata'
DATESTAMP=$(date +%Y%m%d_%H%M%S)

trap 'sudo umount "$SNAP_MOUNT" 2>/dev/null; sudo lvremove -f "/dev/$VG/$SNAP_LV" 2>/dev/null' ERR EXIT

echo '[1] Creating snapshot...'
sudo lvcreate -s -n "$SNAP_LV" -L "$SNAP_SIZE" "/dev/$VG/$ORIGIN_LV"

echo '[2] Mounting snapshot read-only...'
sudo mkdir -p "$SNAP_MOUNT"
sudo mount -o ro "/dev/$VG/$SNAP_LV" "$SNAP_MOUNT"

echo '[3] Archiving to backup destination...'
sudo mkdir -p "$BACKUP_DEST"
sudo tar -czf "$BACKUP_DEST/appdata_${DATESTAMP}.tar.gz" -C "$SNAP_MOUNT" .

echo '[4] Cleaning up snapshot...'
sudo umount "$SNAP_MOUNT"
sudo lvremove -f "/dev/$VG/$SNAP_LV"

echo "Backup complete: $BACKUP_DEST/appdata_${DATESTAMP}.tar.gz"

Vérification des connaissances : automatiser fstab et les montages en toute sécurité

Vérifiez votre compréhension des pratiques sûres d’automatisation des disques, des systèmes de fichiers et des montages présentées dans cette leçon.

Récapitulatif de la leçon : automatiser les disques, les systèmes de fichiers et les montages

Dans cette leçon, vous avez constitué une boîte à outils complète pour gérer de façon sûre et scriptable les disques et le stockage sur les systèmes Linux. Points essentiels :

Inspecter d’abord : lsblk, blkid, df et du fournissent les informations nécessaires avant toute modification.
Rigueur avec fstab : utilisez toujours l’UUID, incluez toujours nofail, sauvegardez toujours le fichier avant de le modifier et validez avec findmnt --verify.
Sécurité des montages : vérifiez mountpoint -q avant de monter, consignez les opérations avec logger et gérez les erreurs liées aux périphériques occupés avec lsof.
Puissance de LVM : la chaîne PV → VG → LV permet l’extension en ligne et les sauvegardes fondées sur des instantanés, sans interruption de service.
Le choix du système de fichiers est important : xfs pour les performances (uniquement extensible), ext4 pour la flexibilité (réductible hors ligne), btrfs pour les charges de travail natives avec instantanés.
NFS à la demande : autofs évite les délais au démarrage en ne montant les partages réseau que lorsqu’ils sont utilisés.
Sauvegardes par instantanés : les instantanés LVM fournissent des sauvegardes cohérentes de systèmes actifs — mais surveillez toujours snap_percent et supprimez rapidement les instantanés après la sauvegarde.

En combinant ces méthodes, vous pouvez automatiser de manière fiable tout le cycle de vie du stockage : découverte, provisionnement, montage, redimensionnement et sauvegarde.

Questions Fréquemment Posées

La leçon « Automatiser les disques, systèmes de fichiers et montages » est-elle gratuite ?

Oui — le texte complet de « Automatiser les disques, systèmes de fichiers et montages » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours DevOps Bootcamp, passe à CoddyKit PRO. Le cours DevOps Bootcamp comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Automatiser les disques, systèmes de fichiers et montages » ?

Inspectez les périphériques blocs, gérez les entrées fstab et automatisez sans risque les opérations LVM et de montage. Tu pratiques DevOps Bootcamp avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer DevOps Bootcamp ?

Aucune expérience préalable n'est requise. DevOps Bootcamp sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Automatiser les disques, systèmes de fichiers et montages » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon DevOps Bootcamp ?

Oui. Chaque leçon DevOps Bootcamp inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Automatiser la création d’utilisateurs et de groupes
Contrôler les services systemd et écrire des fichiers d’unité
Automatiser les disques, systèmes de fichiers et montages
Créer des scripts de contrôle d’état et d’alerte du système

← Retour à DevOps Bootcamp