DevOps Bootcamp · Lezione

Automatizzare dischi, filesystem e mount

Ispezioni i dispositivi a blocchi, gestisca le voci di fstab e automatizzi in sicurezza le operazioni LVM e di mount.

Automatizzare dischi, filesystem e mount è una lezione DevOps Bootcamp gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento DevOps Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso DevOps Bootcamp include 4 lezioni in totale.

Comprendere i dispositivi a blocchi con lsblk e fdisk

Prima di automatizzare le operazioni sui dischi, deve saper ispezionare quali dispositivi a blocchi sono presenti nel sistema. Due strumenti essenziali sono lsblk e fdisk -l.

lsblk — elenca i dispositivi a blocchi in formato ad albero, mostrando nomi dei dispositivi, dimensioni, punti di montaggio e tipi (disk, part, lvm)
fdisk -l — mostra le tabelle delle partizioni e i dettagli dei settori (richiede root)
blkid — visualizza gli UUID e i tipi di file system di ogni dispositivo a blocchi

Negli script, spesso sarà necessario analizzare questo output per rilevare i dischi disponibili, verificare se una partizione è formattata o determinare il relativo UUID prima del montaggio.

#!/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

Verifica dello spazio su disco con df e du

df e du sono gli strumenti principali per rilevare l'utilizzo dei file system e delle directory. Negli script di amministrazione dei sistemi, vengono utilizzati per attivare avvisi, applicare quote o decidere quando predisporre ulteriore spazio.

df -h — utilizzo dei file system in formato leggibile, per tutti i file system montati
df -BG — output in gigabyte, per un'analisi numerica uniforme
du -sh /path — dimensione riepilogativa di una directory specifica
du -d 1 /var — suddivisione con un livello di profondità (utile per individuare la sottodirectory di grandi dimensioni)

La colonna percentuale utilizzata di df viene comunemente analizzata per attivare gli avvisi di disco pieno negli script di monitoraggio.

#!/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

Lettura e analisi di /etc/fstab

/etc/fstab è la tabella statica dei file system: definisce quali dispositivi vengono montati all'avvio, in quale percorso e con quali opzioni. Ogni riga contiene sei campi:

Device — UUID=..., LABEL=... o /dev/sdX
Mount point — percorso della directory
Filesystem type — ext4, xfs, nfs, tmpfs, ecc.
Options — defaults, ro, noexec, nofail, ecc.
Dump — 0 o 1 (flag di backup)
Pass — 0, 1 o 2 (ordine di fsck)

Gli script che aggiungono o convalidano voci in fstab devono gestire correttamente i commenti (righe che iniziano con #) e le righe vuote. È sempre preferibile utilizzare gli UUID invece dei nomi dei dispositivi, per garantire il funzionamento dopo i riavvii, quando l'ordine dei dispositivi potrebbe cambiare.

#!/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"

Aggiunta sicura di una voce in fstab

Modificare manualmente /etc/fstab è soggetto a errori. Una voce errata può impedire l'avvio del sistema. Uno script di automazione sicuro dovrebbe:

Verificare se la voce esiste già prima di aggiungerla (idempotenza)
Creare una copia di backup del file originale prima di qualsiasi modifica
Usare l'UUID invece del percorso del dispositivo
Aggiungere nofail alle opzioni di mount, in modo che l'assenza di un disco non interrompa l'avvio
Eseguire mount -a in modalità dry-run o effettuare un mount di prova per eseguire la convalida prima del riavvio

Dopo aver scritto la voce, verifichi sempre con findmnt --verify (disponibile nelle moderne distribuzioni basate su systemd) per rilevare immediatamente gli errori di sintassi.

#!/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'

Montaggio e smontaggio dei filesystem negli script

I comandi mount e umount sono semplici da usare, ma gli script devono gestire alcuni casi particolari:

Un dispositivo potrebbe essere già montato: un ulteriore mount non va a buon fine; verifichi con findmnt o mountpoint
Un punto di mount potrebbe essere occupato (file aperti): umount non va a buon fine; usi lsof +D /mnt/target per individuare i processi responsabili
Usi mount -o remount,ro /mnt/data per passare alla modalità di sola lettura senza smontare
Usi umount -l /mnt/data (lazy) solo come ultima risorsa: scollega il namespace, ma attende la chiusura dei riferimenti

In automazione, verifichi sempre il codice di uscita di mount e registri gli errori in syslog con 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"

Introduzione a LVM: volumi fisici, gruppi di volumi e volumi logici

LVM (Logical Volume Manager) aggiunge un livello di astrazione flessibile tra i dispositivi a blocchi grezzi e i filesystem. La gerarchia a tre livelli è:

Physical Volume (PV) — un disco o una partizione grezzi inizializzati con pvcreate
Volume Group (VG) — uno o più PV raggruppati con vgcreate
Logical Volume (LV) — una partizione virtuale ricavata da un VG con lvcreate; è questa che viene formattata e montata

Il vantaggio principale è che può estendere un LV online senza smontarlo e aggiungere nuovi dischi a un VG senza riformattare. Per questo LVM è essenziale nell'automazione dello storage in produzione.

Comandi di ispezione: pvs, vgs, lvs e le rispettive versioni dettagliate pvdisplay, vgdisplay, lvdisplay.

Creazione di volumi LVM tramite script

L'automazione della configurazione di LVM segue una sequenza rigorosa: pvcreate → vgcreate → lvcreate → mkfs → mount. Ogni passaggio deve essere completato correttamente prima di eseguire il successivo: usi set -euo pipefail e convalidi l'output di ogni comando.

Verifichi sempre che il disco di destinazione non contenga una tabella delle partizioni esistente prima di chiamare pvcreate
Usi l'opzione -y per sopprimere le richieste interattive negli script non interattivi
Specifichi -L (dimensione fissa) oppure -l 100%FREE per usare tutto lo spazio rimanente
Dopo mkfs, usi il percorso del dispositivo dell'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

Estensione online di un volume logico

Una delle funzionalità più potenti di LVM è il ridimensionamento online: estendere un volume logico e il relativo filesystem mentre è montato e in uso. La procedura è:

Estenda l'LV con lvextend (l'opzione -r ridimensiona il filesystem nello stesso passaggio)
Se non usa -r, ridimensioni separatamente il filesystem: resize2fs per ext4, xfs_growfs per xfs

Vincoli importanti:

xfs può solo crescere, mai ridursi: pianifichi attentamente la capacità
ext4 può ridursi, ma solo quando è smontato
Verifichi sempre che il VG disponga di spazio libero con vgdisplay -s prima dell'estensione

#!/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"

Creazione e formattazione dei filesystem

Dopo il partizionamento o la configurazione di LVM, è necessario formattare il dispositivo a blocchi con un filesystem. Scelte comuni nell'amministrazione Linux:

ext4 — maturo, con journaling e supporto alla riduzione; predefinito in molte distribuzioni (mkfs.ext4)
xfs — alte prestazioni, preferito per file di grandi dimensioni e I/O parallelo; predefinito in RHEL/CentOS (mkfs.xfs)
btrfs — copy-on-write, con snapshot integrati (mkfs.btrfs)
tmpfs — basato sulla RAM, specificato in fstab senza mkfs

Imposti sempre un filesystem label significativo (opzione -L), in modo da poter fare riferimento al dispositivo tramite LABEL= in fstab come alternativa all'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"

Automazione dei mount NFS con autofs

Per i filesystem di rete, eseguire il mount all'avvio tramite fstab può causare ritardi o errori se il server NFS è temporaneamente irraggiungibile. autofs risolve il problema eseguendo il mount su richiesta e lo smontaggio dopo un timeout.

Master map: /etc/auto.master — definisce la directory del punto di mount e il relativo file di map
Direct map: /etc/auto.nfs — specifica le opzioni e il percorso del server NFS per ogni sottodirectory
Ricarichi la configurazione con systemctl reload autofs dopo le modifiche
I mount vengono visualizzati automaticamente nella directory configurata quando vi si accede

Negli script, può generare dinamicamente il file di map a partire da un elenco di condivisioni NFS e ricaricare autofs: è utile per predisporre lo storage condiviso su molti host.

#!/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'

Snapshot LVM per backup sicuri

Gli snapshot LVM forniscono una copia point-in-time di un volume logico, consentendo di eseguire backup coerenti di filesystem attivi senza smontarli. Lo snapshot acquisisce lo stato al momento della creazione usando il meccanismo copy-on-write.

Creazione: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Monti lo snapshot in sola lettura per eseguirne il backup: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Esegua rsync o tar sul punto di mount dello snapshot
Rimuova lo snapshot dopo il backup: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Mantenga le dimensioni dello snapshot al 10-20% dell'LV di origine. Se lo snapshot si riempie, diventa non valido: lo monitori con 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"

Verifica delle conoscenze: automazione sicura di fstab e dei mount

Verifichi la propria comprensione delle pratiche sicure di automazione di dischi, filesystem e mount illustrate in questa lezione.

Riepilogo della lezione: automazione di dischi, filesystem e mount

In questa lezione ha creato un kit completo per la gestione sicura e programmabile di dischi e storage nei sistemi Linux. Concetti chiave:

Prima l'ispezione: lsblk, blkid, df e du forniscono le informazioni necessarie prima di qualsiasi modifica.
Disciplina con fstab: usi sempre l'UUID, includa sempre nofail, crei sempre un backup prima delle modifiche e convalidi con findmnt --verify.
Sicurezza dei mount: verifichi mountpoint -q prima del mount, registri gli eventi con logger e gestisca gli errori dei dispositivi occupati con lsof.
Potenza di LVM: la sequenza PV → VG → LV consente estensioni online e backup basati su snapshot senza downtime.
La scelta del filesystem è importante: xfs per le prestazioni (solo crescita), ext4 per la flessibilità (può ridursi offline), btrfs per i carichi di lavoro nativamente basati su snapshot.
NFS su richiesta: autofs evita i ritardi all'avvio montando le condivisioni di rete solo quando vi si accede.
Backup tramite snapshot: gli snapshot LVM forniscono backup coerenti anche a sistema attivo, ma monitori sempre snap_percent e rimuova tempestivamente gli snapshot dopo il backup.

Combinando questi schemi, può automatizzare in modo affidabile l'intero ciclo di vita dello storage: rilevamento, predisposizione, mount, ridimensionamento e backup.

Domande Frequenti

La lezione «Automatizzare dischi, filesystem e mount» è gratuita?

Sì — il testo completo di «Automatizzare dischi, filesystem e mount» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso DevOps Bootcamp, passa a CoddyKit PRO. Il corso DevOps Bootcamp include 4 lezioni in totale.

Cosa imparerò in «Automatizzare dischi, filesystem e mount»?

Ispezioni i dispositivi a blocchi, gestisca le voci di fstab e automatizzi in sicurezza le operazioni LVM e di mount. Eserciti DevOps Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare DevOps Bootcamp?

Non è richiesta alcuna esperienza precedente. DevOps Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Automatizzare dischi, filesystem e mount»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione DevOps Bootcamp?

Sì. Ogni lezione DevOps Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Automatizzare la gestione di utenti e gruppi
Controllare i servizi systemd e scrivere file unit
Automatizzare dischi, filesystem e mount
Creare script per controlli e avvisi sullo stato del sistema

← Torna a DevOps Bootcamp