Gestión de discos y particiones en Linux: guía completa desde cero

El almacenamiento es el cimiento invisible sobre el que descansa todo sistema operativo. Cada archivo de configuración, cada base de datos, cada log de servicio, cada línea de código reside, en última instancia, sobre un disco que ha sido particionado, formateado y montado por un administrador. En Linux, la gestión de discos y particiones es una de las competencias más críticas —y una de las que más respeto exigen—, porque un error en este nivel puede significar la pérdida irrecuperable de datos. Esta guía te llevará desde los fundamentos teóricos (cómo Linux nombra los dispositivos, qué diferencia hay entre MBR y GPT, cómo funcionan los sistemas de archivos) hasta las técnicas avanzadas (LVM, RAID por software, monitorización SMART), con ejemplos prácticos que puedes ejecutar en una máquina virtual sin riesgo. Al terminar, tendrás el conocimiento necesario para diseñar, implementar y mantener esquemas de almacenamiento profesionales.

💾 Fundamentos: cómo Linux ve los discos

En Linux, los dispositivos de almacenamiento se representan como archivos especiales en el directorio /dev/. Esta filosofía —«todo es un archivo»— es una de las decisiones de diseño más elegantes heredadas de Unix, y permite que las mismas herramientas que manipulan archivos ordinarios puedan interactuar con dispositivos físicos.

Los discos duros y SSDs conectados por SATA, SCSI o USB reciben nombres del tipo /dev/sda, /dev/sdb, /dev/sdc, donde la letra indica el orden de detección. Las unidades NVMe (conectadas directamente al bus PCIe) usan una convención diferente: /dev/nvme0n1, /dev/nvme1n1, etc. Las particiones se numeran secuencialmente: /dev/sda1 es la primera partición del primer disco SATA; /dev/nvme0n1p1 es la primera partición del primer disco NVMe.

Para ver todos los dispositivos de bloque disponibles en tu sistema, el comando más útil es lsblk (list block devices), que muestra la jerarquía disco→partición→punto de montaje en un formato de árbol:

$ lsblk
            NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
            sda           8:0    0 465.8G  0 disk
            ├─sda1        8:1    0   512M  0 part /boot/efi
            ├─sda2        8:2    0     1G  0 part /boot
            └─sda3        8:3    0 464.3G  0 part
            ├─vg0-root 253:0   0    50G  0 lvm  /
            ├─vg0-home 253:1   0   350G  0 lvm  /home
            └─vg0-swap 253:2   0     8G  0 lvm  [SWAP]
            nvme0n1     259:0    0 476.9G  0 disk
            └─nvme0n1p1 259:1    0 476.9G  0 part /data

Otros comandos complementarios son fdisk -l (lista particiones con detalles técnicos), blkid (muestra UUID y tipo de sistema de archivos), y df -h (espacio usado y disponible en sistemas montados). El UUID (Universally Unique Identifier) es especialmente importante porque, a diferencia de los nombres como /dev/sda, es inmutable: no cambia si añades o quitas otros discos al sistema. Por eso, en configuraciones profesionales siempre se usa el UUID para identificar particiones en /etc/fstab.

🔧 Tipos de disco: HDD, SSD y NVMe

Comprender las diferencias entre tipos de disco es fundamental para tomar decisiones de particionado y sistema de archivos adecuadas.

Los HDD (Hard Disk Drives) almacenan datos en platos magnéticos giratorios. Sus velocidades típicas son 5.400 o 7.200 RPM, con tiempos de acceso de 5-10 ms y tasas de transferencia secuencial de 100-200 MB/s. Su gran ventaja es el coste por gigabyte: son la opción más económica para almacenamiento masivo. En Linux, los HDD se benefician de sistemas de archivos como ext4 o XFS, y las estrategias de particionado deben tener en cuenta que la fragmentación afecta al rendimiento debido al movimiento mecánico del cabezal.

Los SSD (Solid State Drives) SATA utilizan memoria flash NAND sin partes móviles. Ofrecen tiempos de acceso de 0,1 ms (50 veces más rápido que un HDD) y tasas de transferencia de 500-550 MB/s, limitados por la interfaz SATA III a 6 Gbps. En Linux, es importante habilitar el comando TRIM (mediante fstrim o la opción discard en fstab) para mantener el rendimiento a largo plazo, ya que las celdas NAND necesitan ser «limpiadas» antes de reescribirse.

Los NVMe (Non-Volatile Memory Express) conectan la memoria flash directamente al bus PCIe, eliminando el cuello de botella SATA. Un SSD NVMe PCIe Gen 4 alcanza 7.000 MB/s de lectura secuencial, más de 10 veces la velocidad de un SSD SATA. En Linux aparecen como /dev/nvme* en vez de /dev/sd*. Los sistemas de archivos modernos como Btrfs y XFS aprovechan mejor sus capacidades de escritura paralela.

📋 Esquemas de partición: MBR vs GPT

El MBR (Master Boot Record) es el esquema de partición original de los PCs, introducido en 1983 con el IBM PC XT. Almacena la tabla de particiones en los primeros 512 bytes del disco (el sector 0). Su limitación más crítica es que solo admite discos de hasta 2 TB y un máximo de 4 particiones primarias. Para superar el límite de 4 particiones, se inventó el concepto de «partición extendida» que actúa como contenedor de particiones lógicas, pero esta es una solución heredada cada vez menos relevante.

El GPT (GUID Partition Table) es el estándar moderno, parte de la especificación UEFI. Admite discos de hasta 9,4 ZB (zettabytes), hasta 128 particiones sin necesidad de extendidas, y cada partición se identifica con un GUID único. Además, GPT guarda una copia de seguridad de la tabla de particiones al final del disco e incluye checksums CRC32 para detectar corrupción. En sistemas UEFI, GPT requiere una partición ESP (EFI System Partition) de tipo FAT32, típicamente de 512 MB, que contiene los cargadores de arranque.

📂 Sistemas de archivos: ext4, XFS, Btrfs y más

El sistema de archivos es la capa de software que organiza cómo se almacenan, nombran y recuperan los datos dentro de una partición. Elegir el sistema de archivos correcto es una decisión arquitectónica que afecta al rendimiento, la fiabilidad y las capacidades de administración.

ext4 (Fourth Extended Filesystem) es el sistema de archivos por defecto en la mayoría de distribuciones Linux (Ubuntu, Debian, Linux Mint). Es maduro, estable y extremadamente probado en producción. Soporta volúmenes de hasta 1 EiB (exbibyte), archivos de hasta 16 TiB, y utiliza journaling para proteger la integridad de los datos ante apagones. Su combinación de fiabilidad y rendimiento lo convierte en la opción más segura para la mayoría de casos de uso.

XFS es el sistema de archivos por defecto en Red Hat Enterprise Linux y sus derivados (CentOS, AlmaLinux, Rocky Linux). Fue desarrollado originalmente por Silicon Graphics en 1993 y destaca por su excelente rendimiento en archivos grandes y operaciones de I/O paralelo. Es ideal para servidores de bases de datos, almacenamiento multimedia y cargas de trabajo que manejan archivos de gran tamaño. Una limitación histórica es que no se puede reducir de tamaño (solo ampliar), aunque esto rara vez es un problema en la práctica.

Btrfs (B-tree File System) es el sistema de archivos de nueva generación de Linux, con características avanzadas inspiradas en ZFS: snapshots nativos (copias instantáneas del sistema), compresión transparente, checksums en datos y metadatos, subvolúmenes, y RAID integrado. Es el sistema por defecto en openSUSE y Fedora (para la partición raíz). Aunque ha mejorado enormemente en estabilidad, algunos administradores conservadores todavía prefieren ext4 o XFS para bases de datos de producción críticas.

Otros sistemas de archivos relevantes incluyen FAT32/VFAT (obligatorio para la partición ESP de UEFI y para USB compatibles con Windows), exFAT (para USBs de más de 4 GB compartidos con Windows/macOS), swap (no es un sistema de archivos propiamente dicho, sino espacio de intercambio utilizado por el kernel para memoria virtual), y ZFS (disponible en Ubuntu como opción, con capacidades empresariales excepcionales pero con licencia CDDL incompatible con GPL, lo que impide su inclusión directa en el kernel).

🛠️ Herramientas esenciales: lsblk, fdisk, parted, mkfs

Linux ofrece un arsenal completo de herramientas de línea de comandos para gestionar discos. Las más importantes son:

# Ver todos los discos y particiones en formato árbol
            lsblk -f            # Añade sistema de archivos, UUID y puntos de montaje

            # Ver información detallada de un disco
            sudo fdisk -l /dev/sda

            # Obtener UUID de todas las particiones
            sudo blkid

            # Ver espacio usado/disponible en sistemas montados
            df -hT              # -T muestra el tipo de sistema de archivos

            # Ver uso de inodos (importante: un disco puede quedarse sin inodos antes que sin espacio)
            df -i

fdisk es la herramienta clásica de particionado interactivo. Funciona tanto con MBR como con GPT (desde util-linux 2.26). Su interfaz es basada en menú: escribes un comando de una letra (n para nueva partición, d para eliminar, t para cambiar tipo, p para imprimir la tabla, w para escribir cambios). Los cambios no se aplican hasta que ejecutas w, lo que permite experimentar sin riesgo.

parted (y su interfaz gráfica GParted) es más moderno que fdisk y trabaja directamente con GPT. A diferencia de fdisk, parted aplica los cambios inmediatamente — no hay un paso de confirmación. Esto lo hace más peligroso pero también más eficiente para scripts de automatización. Su sintaxis permite operaciones no interactivas ideales para provisioning automatizado.

mkfs (make filesystem) es la familia de comandos que formatea particiones. El comando genérico mkfs -t ext4 /dev/sda1 equivale a mkfs.ext4 /dev/sda1. Cada sistema de archivos tiene sus propias opciones: mkfs.ext4 -L "datos" -m 1 crea un ext4 con etiqueta «datos» y reserva solo el 1% del espacio para root (por defecto se reserva el 5%, lo cual en un disco de 4 TB supone 200 GB desperdiciados).

🔨 Particionado práctico paso a paso

Veamos un ejemplo completo de particionado de un disco nuevo de 500 GB con GPT usando fdisk:

# 1. Crear tabla de particiones GPT en el disco
            sudo fdisk /dev/sdb
            # Dentro de fdisk:
            #   g       → crear tabla GPT nueva
            #   n       → nueva partición
            #   1       → número de partición
            #   [Enter] → primer sector por defecto
            #   +200G   → tamaño de 200 GB
            #   n → 2 → [Enter] → +200G   (segunda partición)
            #   n → 3 → [Enter] → [Enter] (tercera: resto del disco)
            #   p       → ver tabla de particiones
            #   w       → escribir y salir

            # 2. Formatear cada partición
            sudo mkfs.ext4 -L "proyectos" /dev/sdb1
            sudo mkfs.xfs -L "multimedia" /dev/sdb2
            sudo mkfs.ext4 -L "backups" -m 1 /dev/sdb3

            # 3. Crear puntos de montaje
            sudo mkdir -p /mnt/{proyectos,multimedia,backups}

            # 4. Montar
            sudo mount /dev/sdb1 /mnt/proyectos
            sudo mount /dev/sdb2 /mnt/multimedia
            sudo mount /dev/sdb3 /mnt/backups

            # 5. Verificar
            lsblk /dev/sdb
            df -hT /mnt/proyectos /mnt/multimedia /mnt/backups

Para un particionado no interactivo (ideal para scripts de automatización), puedes usar parted o sfdisk:

# Particionado automatizado con parted
            sudo parted /dev/sdb --script -- \
            mklabel gpt \
            mkpart proyectos ext4 1MiB 200GiB \
            mkpart multimedia xfs 200GiB 400GiB \
            mkpart backups ext4 400GiB 100%

📌 Montaje y /etc/fstab

Montar una partición significa asociar un sistema de archivos a un directorio del árbol de directorios de Linux. El comando mount realiza esta operación en tiempo real, pero los montajes desaparecen al reiniciar. Para que sean permanentes, se configuran en /etc/fstab.

# Montaje temporal
            sudo mount /dev/sdb1 /mnt/datos

            # Montaje con opciones específicas
            sudo mount -o noatime,compress=zstd /dev/sdb1 /mnt/datos   # Para Btrfs

            # Ver todos los montajes activos
            mount | column -t
            # O más limpio:
            findmnt --real

El archivo /etc/fstab define los montajes permanentes. Cada línea tiene 6 campos: dispositivo (UUID recomendado), punto de montaje, tipo de sistema de archivos, opciones, dump (backup) y pass (orden de fsck). Un ejemplo profesional:

# /etc/fstab - Montajes permanentes
            # <dispositivo>                          <mount>       <tipo>  <opciones>        <dump> <pass>
            UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890  /             ext4    errors=remount-ro  0      1
            UUID=b2c3d4e5-f6a7-8901-bcde-f12345678901  /home         ext4    defaults,noatime   0      2
            UUID=c3d4e5f6-a7b8-9012-cdef-123456789012  /boot/efi     vfat    umask=0077         0      1
            UUID=d4e5f6a7-b8c9-0123-defa-234567890123  none          swap    sw                 0      0
            UUID=e5f6a7b8-c9d0-1234-efab-345678901234  /mnt/datos    xfs     defaults,noatime   0      2

🧱 LVM: gestión de volúmenes lógicos

LVM (Logical Volume Manager) es una capa de abstracción que se sitúa entre los discos físicos y los sistemas de archivos, proporcionando una flexibilidad que el particionado tradicional no puede ofrecer. La arquitectura de LVM tiene tres niveles: Physical Volumes (PV) — particiones o discos físicos preparados para LVM; Volume Groups (VG) — pools de almacenamiento que agrupan uno o más PVs; y Logical Volumes (LV) — las «particiones virtuales» que se crean dentro de un VG y sobre las cuales se formatean sistemas de archivos.

La ventaja revolucionaria de LVM es que puedes redimensionar volúmenes en caliente: ampliar un LV que se está quedando pequeño, reducir otro que tiene espacio sobrante, o añadir un disco nuevo al pool y redistribuir el espacio, todo ello sin desmontar ni reiniciar. Esto es absolutamente crítico en servidores de producción donde el tiempo de inactividad tiene un coste económico directo.

# Crear PVs, VG y LVs desde cero
            sudo pvcreate /dev/sdb1 /dev/sdc1           # Preparar particiones como PVs
            sudo vgcreate vg_datos /dev/sdb1 /dev/sdc1  # Crear VG combinando ambos PVs
            sudo lvcreate -L 100G -n lv_web vg_datos    # Crear LV de 100 GB
            sudo lvcreate -l 100%FREE -n lv_backup vg_datos  # LV con todo el espacio restante

            # Formatear y montar
            sudo mkfs.ext4 /dev/vg_datos/lv_web
            sudo mount /dev/vg_datos/lv_web /var/www

            # Ampliar un LV en caliente (+50 GB)
            sudo lvextend -L +50G /dev/vg_datos/lv_web
            sudo resize2fs /dev/vg_datos/lv_web          # Ampliar ext4 (online)

            # Añadir un disco nuevo al pool
            sudo pvcreate /dev/sdd1
            sudo vgextend vg_datos /dev/sdd1             # Ahora el VG tiene más espacio

            # Ver estado de LVM
            sudo pvs     # Physical Volumes
            sudo vgs     # Volume Groups
            sudo lvs     # Logical Volumes

🔄 RAID por software con mdadm

RAID (Redundant Array of Independent Disks) combina múltiples discos para obtener redundancia, rendimiento, o ambos. En Linux, mdadm gestiona RAID por software sin necesidad de controladores hardware dedicados.

Los niveles RAID más utilizados son: RAID 0 (striping) que distribuye datos entre discos para máximo rendimiento pero sin redundancia (si un disco falla, se pierde todo); RAID 1 (mirroring) que duplica los datos en dos o más discos, ofreciendo redundancia total pero usando solo la mitad del espacio disponible; RAID 5 que distribuye datos y paridad entre 3+ discos, ofreciendo un balance entre rendimiento, capacidad y redundancia (tolera el fallo de 1 disco); y RAID 10 (1+0) que combina mirroring y striping para obtener tanto redundancia como rendimiento, requiriendo un mínimo de 4 discos.

# Crear RAID 1 (espejo) con 2 discos
            sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1

            # Ver estado del RAID
            cat /proc/mdstat
            sudo mdadm --detail /dev/md0

            # Formatear y usar como disco normal
            sudo mkfs.ext4 /dev/md0
            sudo mount /dev/md0 /mnt/raid

            # Guardar configuración para que sobreviva a reinicios
            sudo mdadm --detail --scan >> /etc/mdadm/mdadm.conf
            sudo update-initramfs -u

            # Simular fallo de un disco
            sudo mdadm --manage /dev/md0 --fail /dev/sdc1
            sudo mdadm --manage /dev/md0 --remove /dev/sdc1

            # Añadir disco de reemplazo
            sudo mdadm --manage /dev/md0 --add /dev/sdd1  # Reconstrucción automática

📊 Monitorización y salud del disco

Los discos duros no fallan de forma instantánea: dan señales de advertencia durante semanas o meses antes del fallo total. El sistema SMART (Self-Monitoring, Analysis and Reporting Technology) está integrado en todos los discos modernos y registra métricas de salud que puedes consultar con smartctl:

# Instalar smartmontools
            sudo apt install smartmontools     # Debian/Ubuntu
            sudo dnf install smartmontools     # Fedora/RHEL

            # Ver estado general SMART
            sudo smartctl -H /dev/sda          # PASSED o FAILED

            # Ver todos los atributos SMART
            sudo smartctl -A /dev/sda

            # Atributos críticos a vigilar:
            # - Reallocated_Sector_Ct: sectores reasignados (>0 es señal de alerta)
            # - Current_Pending_Sector: sectores pendientes de reasignación
            # - Offline_Uncorrectable: sectores que no pudieron ser corregidos
            # - Temperature_Celsius: temperatura del disco (>55°C es preocupante)

            # Ejecutar test corto
            sudo smartctl -t short /dev/sda    # ~2 minutos

            # Ver resultado del test
            sudo smartctl -l selftest /dev/sda

            # Monitorización continua con servicio smartd
            sudo systemctl enable --now smartd

Otras herramientas de monitorización importantes incluyen iostat (del paquete sysstat) para ver estadísticas de I/O en tiempo real, iotop para identificar qué procesos están generando más actividad de disco, y dstat como herramienta integrada que combina información de CPU, disco, red y memoria en una sola vista.

🔐 Cifrado de disco con LUKS

En entornos profesionales donde la seguridad de los datos es crítica — servidores con información sensible, portátiles de empleados, equipos que pueden ser robados o reciclados — el cifrado de disco es una capa de protección imprescindible. Linux integra LUKS (Linux Unified Key Setup) como estándar de cifrado de disco, proporcionando cifrado AES-256 transparente que protege los datos incluso si un atacante tiene acceso físico al disco.

LUKS funciona creando una capa de cifrado entre el dispositivo físico (o partición) y el sistema de archivos. Cuando abres un volumen LUKS con la contraseña correcta, el kernel crea un dispositivo mapeado en /dev/mapper/ que se comporta como un disco normal: puedes formatearlo, montarlo y usar cualquier sistema de archivos sobre él. La penalización de rendimiento del cifrado AES es mínima en CPUs modernas (que tienen instrucciones AES-NI dedicadas), típicamente inferior al 5%.

# Instalar herramientas de cifrado
            sudo apt install cryptsetup              # Debian/Ubuntu
            sudo dnf install cryptsetup              # Fedora/RHEL

            # Cifrar una partición (¡DESTRUYE todos los datos existentes!)
            sudo cryptsetup luksFormat /dev/sdb1     # Pide confirmación y contraseña

            # Abrir el volumen cifrado
            sudo cryptsetup luksOpen /dev/sdb1 datos_cifrados   # Crea /dev/mapper/datos_cifrados

            # Formatear y montar el volumen descifrado
            sudo mkfs.ext4 /dev/mapper/datos_cifrados
            sudo mount /dev/mapper/datos_cifrados /mnt/seguro

            # Para montaje automático, añadir a /etc/crypttab:
            # datos_cifrados  UUID=xxx  none  luks
            # Y luego en /etc/fstab:
            # /dev/mapper/datos_cifrados  /mnt/seguro  ext4  defaults  0  2

            # Ver información del volumen LUKS
            sudo cryptsetup luksDump /dev/sdb1

            # Añadir una contraseña adicional (LUKS soporta hasta 8 slots)
            sudo cryptsetup luksAddKey /dev/sdb1

LUKS también se integra perfectamente con LVM: puedes cifrar un Physical Volume completo y luego crear Logical Volumes sobre él, obteniendo tanto la flexibilidad de LVM como la seguridad del cifrado. Esta configuración (conocida como LUKS sobre LVM o LVM sobre LUKS) es la que utilizan por defecto los instaladores de Ubuntu y Fedora cuando seleccionas la opción de cifrado completo durante la instalación.

✏️ Ejercicios resueltos

Ejercicio 1: Tienes un disco nuevo de 1 TB (/dev/sdb). Crea una tabla GPT, una partición de 500 GB formateada como ext4 con etiqueta «datos», y monta permanentemente en /srv/datos usando UUID.

# Particionar
            sudo parted /dev/sdb --script -- mklabel gpt mkpart datos ext4 1MiB 500GiB
            # Formatear
            sudo mkfs.ext4 -L "datos" /dev/sdb1
            # Obtener UUID
            UUID=$(sudo blkid -s UUID -o value /dev/sdb1)
            # Crear punto de montaje
            sudo mkdir -p /srv/datos
            # Añadir a fstab
            echo "UUID=$UUID  /srv/datos  ext4  defaults,noatime  0  2" | sudo tee -a /etc/fstab
            # Montar y verificar
            sudo mount -a
            df -hT /srv/datos

Ejercicio 2: Crea un volumen LVM combinando dos particiones de 100 GB (/dev/sdb1 y /dev/sdc1). Dentro del VG, crea un LV de 150 GB formateado como XFS.

sudo pvcreate /dev/sdb1 /dev/sdc1
            sudo vgcreate vg_app /dev/sdb1 /dev/sdc1
            sudo lvcreate -L 150G -n lv_app vg_app
            sudo mkfs.xfs /dev/vg_app/lv_app
            sudo mkdir -p /opt/app
            sudo mount /dev/vg_app/lv_app /opt/app
            # Verificar con: sudo lvs && df -hT /opt/app

Ejercicio 3: Comprueba la salud SMART de tu disco principal y determina si hay sectores reasignados.

sudo smartctl -H /dev/sda
            sudo smartctl -A /dev/sda | grep -i "reallocated\|pending\|uncorrect"
            # Si Reallocated_Sector_Ct > 0, el disco está empezando a fallar
            # Planifica un reemplazo y asegura que tienes backups

⚠️ Errores frecuentes y buenas prácticas

No hacer backup antes de particionar. Cualquier operación de particionado puede destruir datos irrecuperablemente. Antes de tocar una tabla de particiones, haz una copia de seguridad de la tabla con sfdisk -d /dev/sda > particiones_backup.txt y asegúrate de que los datos importantes están respaldados en otro dispositivo.

Usar /dev/sda en fstab en vez de UUID. Los nombres de dispositivo pueden cambiar entre reinicios. Si /dev/sdb se convierte en /dev/sdc porque conectaste un USB, tu sistema montará la partición equivocada. Usa siempre UUID= o LABEL= en /etc/fstab.

No habilitar TRIM en SSDs. Sin TRIM, los SSDs degradan su rendimiento progresivamente. Verifica que fstrim.timer está activo (systemctl status fstrim.timer) o añade la opción discard en fstab.

Llenar un disco al 100%. Cuando un disco se llena completamente, ext4 reserva un porcentaje para root (por defecto 5%), pero si incluso ese espacio se agota, el sistema puede volverse inestable. Configura alertas de monitorización al 80% y al 90% de ocupación. El comando ncdu (NCurses Disk Usage) es extraordinariamente útil para encontrar qué directorios están consumiendo más espacio.

No tener un plan de recuperación ante fallo de disco. Los discos son dispositivos mecánicos (o electrónicos) que fallan eventualmente. La pregunta no es «si» fallarán, sino «cuándo». Implementa RAID para redundancia, backups regulares para recuperación, y monitorización SMART para anticipar fallos. La regla 3-2-1 establece: 3 copias de los datos, en 2 medios diferentes, con 1 copia fuera del sitio.