DevOps Bootcamp · Lección

Automatización de discos, sistemas de archivos y montajes

Inspeccione dispositivos de bloques, gestione entradas de fstab y automatice de forma segura operaciones de LVM y montaje.

Automatización de discos, sistemas de archivos y montajes es una lección gratuita de DevOps Bootcamp en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de DevOps Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de DevOps Bootcamp incluye 4 lecciones en total.

Comprensión de los dispositivos de bloques con lsblk y fdisk

Antes de automatizar operaciones de disco, debe poder inspeccionar qué dispositivos de bloques existen en el sistema. Dos herramientas esenciales son lsblk y fdisk -l.

lsblk — lista los dispositivos de bloques en formato de árbol y muestra nombres de dispositivo, tamaños, puntos de montaje y tipos (disk, part, lvm)
fdisk -l — muestra las tablas de particiones y los detalles de los sectores (requiere root)
blkid — muestra los UUID y los tipos de sistema de archivos de cada dispositivo de bloques

En los scripts, a menudo tendrá que analizar esta salida para detectar discos disponibles, comprobar si una partición está formateada o determinar su UUID antes de montarla.

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

Comprobación del espacio en disco con df y du

df y du son las herramientas fundamentales para informar sobre el uso de sistemas de archivos y directorios. En los scripts de administración de sistemas, se utilizan para activar alertas, aplicar cuotas o decidir cuándo asignar más espacio.

df -h — uso de los sistemas de archivos en un formato legible para las personas en todos los sistemas montados
df -BG — salida en gigabytes para facilitar un análisis numérico coherente
du -sh /path — tamaño resumido de un directorio concreto
du -d 1 /var — desglose con un nivel de profundidad (útil para encontrar qué subdirectorio ocupa más espacio)

La columna de porcentaje utilizado de df se analiza habitualmente para activar alertas de disco lleno en scripts de monitorización.

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

Lectura y análisis de /etc/fstab

/etc/fstab es la tabla estática de sistemas de archivos: define qué dispositivos se montan durante el arranque, en qué ruta y con qué opciones. Cada línea contiene seis campos:

Device — UUID=..., LABEL=... o /dev/sdX
Mount point — ruta del directorio
Filesystem type — ext4, xfs, nfs, tmpfs, etc.
Options — defaults, ro, noexec, nofail, etc.
Dump — 0 o 1 (indicador de copia de seguridad)
Pass — 0, 1 o 2 (orden de fsck)

Los scripts que añaden o validan entradas de fstab deben gestionar correctamente los comentarios (líneas que empiezan por #) y las líneas en blanco. Prefiera siempre los UUID a los nombres de dispositivo para evitar problemas tras reinicios en los que el orden de los dispositivos pueda cambiar.

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

Cómo añadir de forma segura una entrada en fstab

Editar manualmente /etc/fstab puede provocar errores. Una entrada incorrecta puede impedir que el sistema arranque. Un script de automatización seguro debe:

Comprobar si la entrada ya existe antes de añadirla (idempotencia)
Hacer una copia de seguridad del archivo original antes de cualquier modificación
Usar el UUID en lugar de la ruta del dispositivo
Añadir nofail a las opciones de montaje para que la ausencia de un disco no detenga el arranque
Ejecutar mount -a en modo de prueba o realizar un montaje de prueba para validar la configuración antes de reiniciar

Después de escribir la entrada, verifíquela siempre con findmnt --verify (disponible en las distribuciones modernas basadas en systemd) para detectar inmediatamente los errores de sintaxis.

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

Montar y desmontar sistemas de archivos en scripts

Los comandos mount y umount son sencillos, pero los scripts deben gestionar varios casos límite:

Es posible que un dispositivo ya esté montado; volver a montarlo provoca un error. Compruébelo con findmnt o mountpoint
Un punto de montaje puede estar ocupado (por archivos abiertos); umount fallará. Use lsof +D /mnt/target para encontrar los procesos responsables
Use mount -o remount,ro /mnt/data para cambiar a solo lectura sin desmontar
Use umount -l /mnt/data (lazy) como último recurso: separa el espacio de nombres, pero espera a que se cierren las referencias

En la automatización, compruebe siempre el código de salida de mount y registre los errores en 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"

Introducción a LVM: volúmenes físicos, grupos de volúmenes y volúmenes lógicos

LVM (Logical Volume Manager) añade una capa de abstracción flexible entre los dispositivos de bloques sin procesar y los sistemas de archivos. La jerarquía de tres niveles es:

Physical Volume (PV): un disco o una partición sin procesar inicializado con pvcreate
Volume Group (VG): uno o más PV agrupados con vgcreate
Logical Volume (LV): una partición virtual creada a partir de un VG con lvcreate; es lo que se formatea y se monta

La principal ventaja es que puede ampliar un LV en línea sin desmontarlo y añadir discos nuevos a un VG sin volver a formatearlo. Por eso LVM es fundamental para automatizar el almacenamiento en entornos de producción.

Comandos de inspección: pvs, vgs, lvs y sus equivalentes detallados pvdisplay, vgdisplay, lvdisplay.

Crear volúmenes LVM mediante scripts

La configuración automatizada de LVM sigue una secuencia estricta: pvcreate → vgcreate → lvcreate → mkfs → mount. Cada paso debe completarse correctamente antes de ejecutar el siguiente; use set -euo pipefail y valide la salida de cada comando.

Compruebe siempre que el disco de destino no tenga una tabla de particiones existente antes de ejecutar pvcreate
Use la opción -y para suprimir las confirmaciones interactivas en scripts no interactivos
Especifique -L (tamaño fijo) o -l 100%FREE para usar todo el espacio restante
Después de mkfs, use la ruta del dispositivo del 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

Ampliar un volumen lógico en línea

Una de las funciones más potentes de LVM es el redimensionamiento en línea: ampliar un volumen lógico y su sistema de archivos mientras está montado y en uso. El procedimiento es:

Amplíe el LV con lvextend (la opción -r redimensiona el sistema de archivos en el mismo paso)
Si no usa -r, redimensione el sistema de archivos por separado: resize2fs para ext4 y xfs_growfs para xfs

Restricciones importantes:

xfs solo puede crecer, nunca reducirse; planifique cuidadosamente la capacidad
ext4 puede reducirse, pero solo mientras está desmontado
Verifique siempre que el VG tenga espacio libre con vgdisplay -s antes de ampliarlo

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

Crear y formatear sistemas de archivos

Después de particionar o configurar LVM, debe formatear el dispositivo de bloques con un sistema de archivos. Opciones habituales en la administración de Linux:

ext4: maduro, con journaling y compatible con la reducción de tamaño; es el predeterminado en muchas distribuciones (mkfs.ext4)
xfs: alto rendimiento, preferido para archivos grandes y E/S en paralelo; es el predeterminado en RHEL/CentOS (mkfs.xfs)
btrfs: copy-on-write, con instantáneas integradas (mkfs.btrfs)
tmpfs: respaldado por RAM, se especifica en fstab sin mkfs

Establezca siempre una etiqueta significativa para el sistema de archivos (opción -L) para poder referenciar el dispositivo mediante LABEL= en fstab como alternativa al 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"

Automatizar montajes NFS con autofs

En el caso de los sistemas de archivos de red, montar durante el arranque mediante fstab puede causar retrasos o errores si el servidor NFS no está disponible temporalmente. autofs resuelve este problema montando bajo demanda y desmontando después de un tiempo de espera.

Mapa principal: /etc/auto.master: define el directorio del punto de montaje y su archivo de mapa
Mapa directo: /etc/auto.nfs: especifica las opciones y la ruta del servidor NFS para cada subdirectorio
Recargue con systemctl reload autofs después de realizar cambios
Los montajes aparecen automáticamente bajo el directorio configurado cuando se accede a ellos

En los scripts, puede generar dinámicamente el archivo de mapa a partir de una lista de recursos compartidos NFS y recargar autofs, lo que resulta útil para aprovisionar almacenamiento compartido en muchos hosts.

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

Instantáneas de LVM para copias de seguridad seguras

Las instantáneas de LVM proporcionan una copia de un volumen lógico en un momento determinado, lo que permite realizar copias de seguridad coherentes de sistemas de archivos activos sin desmontarlos. La instantánea captura el estado en el momento de su creación mediante copy-on-write.

Crear: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Montar la instantánea como de solo lectura para realizar la copia de seguridad: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Ejecute rsync o tar sobre el punto de montaje de la instantánea
Eliminar la instantánea después de la copia de seguridad: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Mantenga el tamaño de la instantánea en un 10-20% del LV de origen. Si la instantánea se llena, deja de ser válida; supervise su estado 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"

Comprobación de conocimientos: automatización segura de fstab y montajes

Compruebe sus conocimientos sobre las prácticas seguras de automatización de discos, sistemas de archivos y montajes tratadas en esta lección.

Resumen de la lección: automatización de discos, sistemas de archivos y montajes

En esta lección ha creado un conjunto completo de herramientas para la gestión segura y mediante scripts de discos y almacenamiento en sistemas Linux. Ideas clave:

Inspeccionar primero: lsblk, blkid, df y du proporcionan la información necesaria antes de realizar cualquier cambio.
Disciplina con fstab: use siempre el UUID, incluya siempre nofail, haga siempre una copia de seguridad antes de editar y valide con findmnt --verify.
Seguridad al montar: compruebe mountpoint -q antes de montar, registre los eventos con logger y gestione los errores de dispositivos ocupados con lsof.
Potencia de LVM: el flujo PV → VG → LV permite ampliar en línea y realizar copias de seguridad basadas en instantáneas sin tiempo de inactividad.
La elección del sistema de archivos es importante: xfs para obtener rendimiento (solo puede crecer), ext4 para mayor flexibilidad (puede reducirse sin conexión) y btrfs para cargas de trabajo nativas de instantáneas.
NFS bajo demanda: autofs evita retrasos durante el arranque al montar los recursos compartidos de red solo cuando se accede a ellos.
Copias de seguridad mediante instantáneas: las instantáneas de LVM proporcionan copias coherentes de sistemas activos, pero debe supervisar siempre snap_percent y eliminar las instantáneas rápidamente después de la copia de seguridad.

Combine estos patrones y podrá automatizar de forma fiable todo el ciclo de vida del almacenamiento: detección, aprovisionamiento, montaje, redimensionamiento y copia de seguridad.

Preguntas frecuentes

¿La lección «Automatización de discos, sistemas de archivos y montajes» es gratis?

Sí — el texto completo de «Automatización de discos, sistemas de archivos y montajes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de DevOps Bootcamp, actualiza a CoddyKit PRO. El curso de DevOps Bootcamp incluye 4 lecciones en total.

¿Qué aprenderé en «Automatización de discos, sistemas de archivos y montajes»?

Inspeccione dispositivos de bloques, gestione entradas de fstab y automatice de forma segura operaciones de LVM y montaje. Practicas DevOps Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar DevOps Bootcamp?

No se requiere experiencia previa. DevOps Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Automatización de discos, sistemas de archivos y montajes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de DevOps Bootcamp?

Sí. Cada lección de DevOps Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Automatización del aprovisionamiento de usuarios y grupos
Control de servicios systemd y escritura de archivos unit
Automatización de discos, sistemas de archivos y montajes
Creación de scripts de comprobación y alerta del estado del sistema

← Volver a DevOps Bootcamp