¿Cómo ensamblar particiones como dispositivos RAID?

RAID (Redundant Array of Independent Disks) combina varios discos o particiones en una única unidad lógica para mejorar el rendimiento, la tolerancia a fallos o ambos.

6.1. Introducción al RAID

En Linux, el RAID puede implementarse por hardware (controladora dedicada) o por software (el kernel y mdadm). Para LFCS nos centraremos en el RAID por software, que ofrece gran flexibilidad y no requiere hardware especial.

Los niveles de RAID más importantes son:

En el examen LFCS es probable que te pidan crear arrays RAID 0, 1 y 5 con mdadm, ver su estado, montarlos y configurarlos para que se reensamblen al arranque.

6.2. Conceptos previos

• md: múltiple device, el subsistema del kernel que gestiona el RAID por software.
• mdadm: herramienta de administración para crear, ensamblar y monitorizar arrays md.
• Componentes: cada disco o partición que forma parte del array.
• Metadatos: información que mdadm escribe en los componentes (superblock) para identificar el array. Formatos: 0.90, 1.0, 1.1, 1.2, etc.
• Dispositivo resultante: /dev/mdX (ej. /dev/md0, /dev/md1).
• Particiones: se recomienda usar particiones completas (tipo fd – Linux raid autodetect) en lugar de discos completos, aunque ambos son válidos.

6.3. Creación de particiones para RAID

Antes de crear el array, debemos preparar los discos con particiones del tipo adecuado. Usaremos fdisk o parted.

Ejemplo con dos discos de 2 GB cada uno (/dev/sdb y /dev/sdc):

1. Crear tabla MBR/GPT.
2. Crear una partición que ocupe todo el disco.
3. Cambiar el tipo a fd (MBR) o 29 (GPT, Linux RAID).

Con fdisk:

sudo fdisk /dev/sdb
# o -> nueva tabla DOS (MBR)
# n -> p -> 1 -> Enter (por defecto) -> Enter
# t -> fd (Linux raid autodetect)
# w

Repetir para /dev/sdc. Verificar: lsblk debe mostrar sdb1 y sdc1.

En GPT con gdisk, usar código fd00.

6.4. Creación de arrays con mdadm

La sintaxis básica para crear un array:

mdadm --create /dev/md0 --level=<nivel> --raid-devices=<cantidad> <componentes>

Ejemplos:

RAID 0 (striping, 2 discos):

sudo mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/sdb1 /dev/sdc1

RAID 1 (mirroring, 2 discos):

sudo mdadm --create /dev/md1 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1

RAID 5 (paridad, 3 discos):

sudo mdadm --create /dev/md2 --level=5 --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1

RAID 10 (4 discos):

sudo mdadm --create /dev/md3 --level=10 --raid-devices=4 /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1

Opciones adicionales:

• --spare-devices=1: añade un disco de repuesto (spare) que se activará automáticamente si uno falla (para RAID 1, 5, 6, 10).
• --chunk=64K: tamaño de chunk (stripe) en KiB. Por defecto 512K para RAID 1, 64K para otros. Ajusta el rendimiento según la carga.
• --metadata=1.2: formato de metadatos; 1.2 es el predeterminado actual.

Ejemplo de RAID 1 con spare:

sudo mdadm --create /dev/md1 --level=1 --raid-devices=2 --spare-devices=1 /dev/sdb1 /dev/sdc1 /dev/sdd1

Tras la creación, se puede monitorizar el progreso de la sincronización inicial (sync) con:

cat /proc/mdstat
watch cat /proc/mdstat

6.5. Formateo y montaje del array

Una vez creado /dev/mdX, se comporta como un disco normal. Hay que formatearlo y montarlo.

sudo mkfs.ext4 -L RAID1_DATOS /dev/md1
sudo mkdir -p /mnt/raid1
sudo mount /dev/md1 /mnt/raid1

Para que se monte automáticamente, añadimos a /etc/fstab usando UUID:

sudo blkid /dev/md1   # obtener UUID

Línea en fstab:

UUID=xxxxx /mnt/raid1 ext4 defaults 0 2

6.6. Configuración persistente del RAID: /etc/mdadm/mdadm.conf

Los arrays se ensamblan automáticamente durante el arranque si el initramfs incluye mdadm y existe el archivo de configuración. Para generarlo:

sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf

O más específico, actualizarlo completamente:

sudo mdadm --detail --scan | sudo tee /etc/mdadm/mdadm.conf

Luego, actualizar el initramfs para que el kernel pueda activar el RAID al arrancar:

sudo update-initramfs -u   # Debian/Ubuntu
sudo dracut --force        # RHEL/CentOS/Fedora

6.7. Comandos de gestión y monitorización

6.7.1. Ver información detallada

sudo mdadm --detail /dev/md0

Muestra el nivel, estado, UUID, discos activos, fallidos, tamaño de chunk, etc.

6.7.2. Estado rápido

cat /proc/mdstat

6.7.3. Simular fallo de un disco (para pruebas)

Marcar un disco como fallido:

sudo mdadm --manage /dev/md1 --fail /dev/sdc1

Quitar el disco fallido del array:

sudo mdadm --manage /dev/md1 --remove /dev/sdc1

Añadir un disco nuevo (o el mismo reparado):

sudo mdadm --manage /dev/md1 --add /dev/sde1

6.7.4. Reactivar un array que no se monta automáticamente

Si por alguna razón el array no arranca, se puede ensamblar manualmente:

sudo mdadm --assemble --scan
sudo mdadm --assemble /dev/md1 /dev/sdb1 /dev/sdc1

6.7.5. Detener un array

Antes de eliminarlo o hacer cambios mayores, se debe desmontar y detener:

sudo umount /mnt/raid1
sudo mdadm --stop /dev/md1

6.7.6. Borrar un array y limpiar superbloques

Si queremos reutilizar los discos, limpiamos los metadatos RAID:

sudo mdadm --zero-superblock /dev/sdb1 /dev/sdc1

Luego se puede eliminar la entrada en mdadm.conf.

6.8. Reemplazo de discos y recuperación

En un sistema real, si un disco falla:

1. Marcar el disco como fallido y removerlo (si no lo hizo automáticamente el kernel).
2. Sustituir físicamente el disco.
3. Particionar el nuevo disco igual que los demás (tipo fd).
4. Añadirlo al array: mdadm --add /dev/md1 /dev/sdd1.
5. El sistema empezará a reconstruir los datos (resync). Monitorizar con cat /proc/mdstat.

6.9. RAID de arranque y consideraciones

RAID 1 se puede utilizar para /boot o incluso la raíz, siempre que el gestor de arranque (GRUB) soporte metadatos RAID y los módulos estén en initramfs. Para RAID 0, 5, 6, es necesario que initramfs incluya mdadm y módulos.

En particiones EFI, el firmware no entiende RAID; cada disco debe tener su propia partición EFI y se debe sincronizar manualmente (o usar RAID 1 para /boot/efi con metadatos 1.0 que permiten leer la partición como FAT sin RAID).

6.10. Ejercicios prácticos

1. Creación de RAID 0: Con dos particiones de 1 GB cada una, crea un array RAID 0 con chunk de 128K. Formatéalo como XFS y móntalo en /mnt/raid0. Crea un archivo de 1.5 GB y verifica que ocupa espacio en ambos discos con lsblk.

2. RAID 1 con spare: Crea un RAID 1 usando tres particiones: dos activas y una de repuesto. Simula un fallo (--fail) en una de las activas, observa cómo el spare se sincroniza automáticamente. Retira el disco fallido y añádelo de nuevo como spare.

3. RAID 5: Con tres particiones, crea un RAID 5. Genera un fichero con dd de 200 MB. Luego simula un fallo en un disco, verifica que el array sigue funcionando (en estado degraded). Añade un cuarto disco y observa la reconstrucción.

4. Persistencia: Configura mdadm.conf y actualiza initramfs. Reinicia el sistema y verifica que los arrays se ensamblan automáticamente.

5. Migración de niveles: (Tarea avanzada) Convierte un RAID 1 de dos discos a RAID 5 añadiendo un tercer disco con mdadm --grow. Antes de ejecutar, investiga la sintaxis y haz una copia de seguridad (en entorno de pruebas).

6. Limpieza completa: Detén todos los arrays, pon a cero los superbloques y restaura los discos a uso normal.

6.11. Resumen y consejos para LFCS

• mdadm --create, --detail, --fail, --remove, --add son comandos que debes manejar con fluidez.
• No olvides cambiar el tipo de partición a fd (Linux raid autodetect) antes de crear el array.
• /proc/mdstat es el panel de control rápido para ver el estado y progreso.
• La configuración en /etc/mdadm/mdadm.conf y la actualización del initramfs son necesarias para el montaje automático al arranque.
• En el examen, te pueden pedir que crees un array, lo formatees y lo montes de forma permanente. Practica el flujo completo varias veces hasta hacerlo en minutos.
• Recuerda que RAID no es una copia de seguridad. Protege contra fallos de hardware, no contra borrados accidentales o corrupción de datos.

Con esto vas a dominar el ensamblaje de RAID por software. En el próximo capítulo, abordaremos la gestión de servicios del sistema con SysVinit, Systemd y Upstart, para controlar qué se ejecuta y cuándo se ejecuta.