Ampliando un raid 1 en linux

   Resulta que el raid 1 que monté en mi servidor de backup estaba al 96% de sus escasos 60GB. De hecho, la última vez que lancé el backup se me llenó y tuve que estar borrando archivos y arreglando el estropicio a mano.

shian:~# df -h
S.ficheros          Tamaño Usado  Disp Uso% Montado en
/dev/md0               56G   50G  2,6G  96% /mnt/raid

   Así, me decidí por un par de discos de 320GB y el pasado fin de semana estuve haciendo el cambio. El proceso es muy sencillo y no tiene ningún truco ni paso especial que haya que realizar. Como ya he puesto varios tutoriales sobre el raid 1, lo único que voy a comentar son los pasos que seguí por si alguien necesita ampliar el suyo pero sin mucho detalle. Para información adicional os remito al artículo original del raid 1 en linux.

Conectar los discos y particionarlos.

shian:~# fdisk -l

Disk /dev/hdf: 320.0 GB, 320072933376 bytes
255 heads, 63 sectors/track, 38913 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Disk /dev/hdf doesn't contain a valid partition table

Disk /dev/hdh: 320.0 GB, 320072933376 bytes
255 heads, 63 sectors/track, 38913 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Disk /dev/hdh doesn't contain a valid partition table

Crear el nuevo dispositivo del raid. Como el raid anterior era /dev/md0, este nuevo será /dev/md1. Armarse de paciencia mientras dura la creación del raid. En mi caso fueron más de 2 horas.

shian:~# mdadm --create /dev/md1 --verbose --level=1 --raid-devices=2 /dev/hdf1 /dev/hdh1
mdadm: size set to 312568576K
mdadm: array /dev/md1 started.

shian:~# cat /proc/mdstat
Personalities : [raid1]
md1 : active raid1 hdh1[1] hdf1[0]
      312568576 blocks [2/2] [UU]
      [>....................]  resync =  0.0% (182272/312568576) finish=142.7min speed=36454K/sec

Formatear el raid y montarlo en un nuevo directorio. Fijaos en el tamaño disponible para datos. De los 294GB teóricos, sólo 279GB están disponibles, el resto están reservados para los metadatos e información necesaria del raid 1.

shian:~# mkfs.ext3 /dev/md1

shian:~# mkdir /mnt/raid_new
shian:~# mount /dev/md1 /mnt/raid_new/

shian:~# df -h
S.ficheros          Tamaño Usado  Disp Uso% Montado en
/dev/md0               56G   50G  2,6G  96% /mnt/raid
/dev/md1              294G  191M  279G   1% /mnt/raid_new

Copiar todos los datos del antiguo raid al nuevo. Es necesario asegurarse de que no hay ningún proceso en ejecución que pueda modificar los datos mientras los copiamos. En casa es sencillo, pero en entornos con más usuarios habría que denegar las conexiones entrantes o restringirlas de alguna forma.

shian:~# cp -a /mnt/raid /mnt/raid_new

shian:~# df -h
S.ficheros          Tamaño Usado  Disp Uso% Montado en
/dev/md0               56G   50G  2,6G  96% /mnt/raid
/dev/md1              294G   50G  230G  17% /mnt/raid_new

Como paso final, es necesario actualizar los archivos /etc/fstab y /etc/mdadm/mdadm.conf con la información del nuevo raid y eliminar las entradas correspondientes al antiguo.

   Una vez hecho lo anterior podemos apagar la máquina, desconectar los discos duros antiguos y arrancar de nuevo. Si todo ha ido bien, el sistema debería arrancar sin mostrar ningún error y en el mismo punto de montaje deberíamos tener disponible el nuevo raid. Ahora ya sólo nos queda empezar a llenar de nuevo el raid y dentro de dos o tres años repetir el tutorial pero esta vez con discos duros de un par de teras... ;-).

Convertir un raid 1 a un raid 5 sin formatear

   Hace un mes Javier Ros me contaba que se había montado un servidor Ubuntu en casa con un raid 1 para almacenar sus datos siguiendo mi artículo del Raid 1 en Linux. En ese mismo comentario me planteaba que se le estaba llenando el raid y que en lugar de hacer un nuevo raid 1 (puesto que necesitaba dos discos adicionales) había pensado en hacer un raid 5 añadiendo solamente un disco más. Así, me pasaba un enlace que había encontrado en el que se muestra cómo pasar de un raid 1 a un raid 5 sin necesidad de formatear y sin perder la información.

   Como sabéis, no me creo las cosas si no las pruebo. Además he estado buscando información sobre cómo funciona un raid 5 y cómo puede ser posible hacer el cambio sin perder los datos. Así, en este artículo vamos a ver un poco de teoría, posteriormente la conversión de un raid 1 a raid 5 siguiendo el tutorial inicial añadiendo mis propios comentarios, y finalmente mis impresiones sobre el raid 5.

Un poco de Teoría
   Un raid 5 es la evolución lógica de un raid 4. Divide los datos en bloques y distribuye la paridad entre el total de discos del raid. Así, se elimina el problema del raid 4 de tener la paridad en un único disco y que éste se convierta en un cuello de botella. Este tipo de raid tiene una tolerancia a los fallos de un disco. Si uno falla el raid puede seguir funcionando y cuando se reemplaza el disco que ha fallado, se puede reconstruir la información que falta partiendo de la existente en el resto de discos.

   El cálculo de la paridad se realiza con la función lógica XOR cuya característica es que devuelve 1 si los bits de entrada son diferentes y 0 si son iguales. Esta es una característica muy importante puesto hace que dicha función sea reversible. Veámoslo con un ejemplo para que quede más claro:

	Binario	Decimal
A	11000110	198
B	00100101	37
XOR	11100011	227

   Como hemos dicho, la función es reversible, por lo que si "le damos la vuelta":

	Binario	Decimal
A	11000110	198
B	11100011	227
XOR	00100101	37

   Es decir, que partiendo de A y teniendo la paridad podemos calcular B. Esta propiedad también se aplica a A XOR B XOR C XOR D ... XOR N = PARIDAD, de manera que si tenemos un raid de N discos y falla cualquiera, la información que falta se puede calcular sin problemas partiendo del resto de datos y de la paridad.

   El truco para realizar la conversión consiste en que si aplicamos dicho algoritmo a dos discos, lo que obtenemos es que los dos discos se quedan en espejo!. Esto es así porque la paridad de un único bloque es él mismo, debido a que el algorimo del raid 5 necesita al menos dos bloques. Así, la única diferencia entre un raid 1 de dos discos y un raid 5 de dos discos son los metadatos. Si reemplazamos estos metadatos convertiremos el raid 1 en un raid 5.

La parte práctica
   Ahora ya sí, con la teoría aprendida vamos a realizar la conversión. Partimos de un sistema Debian ya instalado con un raid 1 creado con 2 discos y al 99% de su capacidad.

shian:~# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/md3              496M  464M  6.3M  99% /mnt/md3

Desmontamos el raid y lo paramos.

shian:~# umount /dev/md3
shian:~# mdadm --stop /dev/md3
mdadm: stopped /dev/md3

Creamos el raid 5 con los dos dispositivos del raid 1 (sdf1 y sdg1).

shian:~# mdadm --create /dev/md3 --level=5 --raid-devices=2 /dev/sdf1 /dev/sdg1
mdadm: /dev/sdf1 appears to contain an ext2fs file system
    size=524160K  mtime=Wed Mar 26 16:43:27 2008
mdadm: /dev/sdf1 appears to be part of a raid array:
    level=raid1 devices=2 ctime=Wed Mar 26 15:09:37 2008
mdadm: /dev/sdg1 appears to contain an ext2fs file system
    size=524160K  mtime=Wed Mar 26 16:43:27 2008
mdadm: /dev/sdg1 appears to be part of a raid array:
    level=raid1 devices=2 ctime=Wed Mar 26 15:09:37 2008
Continue creating array? y
mdadm: array /dev/md3 started.

Podemos observar cómo se reconstruye el raid y en la información detallada vemos que ya es un raid 5.

shian:~# cat /proc/mdstat
Personalities : [raid1] [raid6] [raid5] [raid4]
md3 : active raid5 sdg1[2] sdf1[0]
      524160 blocks level 5, 64k chunk, algorithm 2 [2/1] [U_]
      [=====>...............]  recovery = 27.1% (143104/524160) finish=0.5min speed=11008K/sec

shian:~# mdadm --detail /dev/md3
/dev/md3:
        Version : 00.90.03
  Creation Time : Wed Mar 26 17:19:26 2008
     Raid Level : raid5
     Array Size : 524160 (511.96 MiB 536.74 MB)
    Device Size : 524160 (511.96 MiB 536.74 MB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 3
    Persistence : Superblock is persistent

    Update Time : Wed Mar 26 17:20:16 2008
          State : clean
 Active Devices : 2
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 0

         Layout : left-symmetric
     Chunk Size : 64K

           UUID : df77ed88:83aa5bac:daa25bcf:b5b2c6e7
         Events : 0.2

    Number   Major   Minor   RaidDevice State
       0       8       81        0      active sync   /dev/sdf1
       1       8       97        1      active sync   /dev/sdg1

Ahora añadimos el nuevo disco para tener los 3 que queremos en el raid 5 y ampliamos el dispositivo. Podemos comprobar que se ha añadido el nuevo disco que se está redimensionando el raid.

shian:~# mdadm --add /dev/md3 /dev/sdh1
mdadm: added /dev/sdh1

shian:~# mdadm --grow /dev/md3 --raid-disks=3 --backup-file=/tmp/raid1-5.backup
mdadm: Need to backup 128K of critical section..
mdadm: ... critical section passed.

shian:~# cat /proc/mdstat
Personalities : [raid1] [raid6] [raid5] [raid4]
md3 : active raid5 sdh1[2] sdg1[1] sdf1[0]
      524160 blocks super 0.91 level 5, 64k chunk, algorithm 2 [3/3] [UUU]
      [=>...................]  reshape =  8.3% (44544/524160) finish=2.6min speed=2969K/sec

Forzamos la comprobación del filesystem y lo redimensionamos.

shian:~# e2fsck -f /dev/md3
e2fsck 1.40-WIP (14-Nov-2006)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
/dev/md3: 20680/131072 files (0.6% non-contiguous), 491521/524160 blocks

shian:~# resize2fs -p /dev/md3
resize2fs 1.40-WIP (14-Nov-2006)
Resizing the filesystem on /dev/md3 to 1048320 (1k) blocks.
Begin pass 1 (max = 64)
Extending the inode table     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The filesystem on /dev/md3 is now 1048320 blocks long.

Después de montar de nuevo el raid, comprobamos el nuevo tamaño (los 500MB del nuevo disco):

shian:~# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/md3              992M  465M  476M  50% /mnt/md3

No se nos puede olvidar finalmente modificar el archivo /etc/mdadm.conf para que se actualicen los datos de nuestro nuevo raid 5.

shian:~# cd /etc/mdadm
shian:/etc/mdadm# cp mdadm.conf mdadm.conf.`date +%y%m%d`
shian:/etc/mdadm# echo "DEVICE partitions" > mdadm.conf
shian:/etc/mdadm# mdadm --detail --scan >> mdadm.conf

Conclusiones
   Hemos visto que es posible realizar la conversión de un raid 1 a un raid 5 sin perder los datos y sin necesidad de recrear el raid desde cero. Aún así, la pregunta es ¿merece la pena pasar a un raid 5?.
   Depende. Para un entorno doméstico sin mucha carga y sin un uso muy intensivo yo diría que sí. La alternativa a tener un raid 5 pasa por un raid 10, pero en este caso ya necesitaríamos 4 discos en lugar de tres. La capacidad del volumen total sería la misma en ambos casos, pero para el raid 10 utilizaríamos un disco más!. En el lado positivo tendríamos dos discos de redundancia a fallos (uno de cada mirror), recuperaciones mucho más rápidas y mayor rendimiento.
   Por contra, el principal problema del raid 5 es el tiempo de recuperación en caso de fallo de un disco y el pobre rendimiento que obtenemos cuando se está realizando dicha recuperación. De nuevo, en un entorno doméstico esto no debería representar mayor problema, pero aún así es un hecho a tener en cuenta antes de tomar la decisión final.

Raid 1 en un sistema ya instalado

   En el artículo del Raid 1 en linux veíamos cómo montar un raid 1 con Debian para tener fiablidad en nuestros datos y en el caso de que fallase un disco no perderlos. De esta forma aseguramos nuestros datos, pero en caso de fallo del disco de sistema irremediablemente tendríamos que instalar de nuevo todo.

   Lo que vamos a ver en este artículo es cómo montar un raid 1 completo de todo el sistema Debian, con éste ya instalado y funcionando. De esta forma contesto a varias personas que me han pedido este artículo tanto en los comentarios del primero como por email. Para no hacer muy pesado el artículo obviaré algunas partes que están detalladas en el artículo anterior del raid 1, por lo que si algún paso no lo comprendes, por favor lee el artículo anterior para aclarar las dudas.

   Debo aclarar que este tutorial está pensado para Debian y similares por lo que en otras distribuciones no funcionará correctamente al no existir el comando update-initramfs.

Partimos de un sistema ya instalado con tres particiones distintas: /dev/sda1 para /boot, /dev/sda5 para el swap y /dev/sda6 para /.

Filesystem            Size  Used Avail Use% Mounted on
/dev/sda6             7.4G  509M  6.5G   8% /
tmpfs                  63M     0   63M   0% /lib/init/rw
udev                   10M   84K   10M   1% /dev
tmpfs                  63M     0   63M   0% /dev/shm
/dev/sda1             177M   11M  157M   7% /boot

Después de añadir el disco a la máquina utilizamos el truco que ya usamos en el artículo original para copiar la tabla de particiones de un disco a otro:

shian:~# sfdisk -d /dev/sda | sfdisk /dev/sdb
Checking that no-one is using this disk right now ...
OK

Disk /dev/sdb: 1044 cylinders, 255 heads, 63 sectors/track

sfdisk: ERROR: sector 0 does not have an msdos signature
 /dev/sdb: unrecognized partition table type
Old situation:
No partitions found
New situation:
Units = sectors of 512 bytes, counting from 0

   Device Boot    Start       End   #sectors  Id  System
/dev/sdb1            63    385559     385497  83  Linux
/dev/sdb2        385560  16771859   16386300   5  Extended
/dev/sdb3             0         -          0   0  Empty
/dev/sdb4             0         -          0   0  Empty
/dev/sdb5        385623   1172744     787122  82  Linux swap / Solaris
/dev/sdb6       1172808  16771859   15599052  83  Linux

Editamos con fdisk las particiones de /dev/sdb y cambiamos del tipo a fd de las número 1, 5 y 6. El resultado final es:

...
Command (m for help): p

Disk /dev/sdb: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1          24      192748+  fd  Linux raid autodetect
/dev/sdb2              25        1044     8193150    5  Extended
/dev/sdb5              25          73      393561   fd  Linux raid autodetect
/dev/sdb6              74        1044     7799526   fd  Linux raid autodetect

Ahora creamos los dispositivos raid para las particiones.

shian:~# mdadm --create /dev/md0 --level=1 --raid-disks=2 missing /dev/sdb1
mdadm: array /dev/md0 started.
shian:~# mdadm --create /dev/md1 --level=1 --raid-disks=2 missing /dev/sdb5
mdadm: array /dev/md1 started.
shian:~# mdadm --create /dev/md2 --level=1 --raid-disks=2 missing /dev/sdb6
mdadm: array /dev/md2 started.

Formateamos las nuevas particiones.

shian:~# mkfs.ext2 /dev/md0
shian:~# mkswap /dev/md1
shian:~# mkfs.ext3 /dev/md2

Actualizamos el archivo mdadm.conf con los nuevos dispositivos raid.

shian:~# cd /etc/mdadm
shian:/etc/mdadm# cp mdadm.conf mdadm.conf.`date +%y%m%d`
shian:/etc/mdadm# echo "DEVICE partitions" > mdadm.conf
shian:/etc/mdadm# mdadm --detail --scan >> mdadm.conf

Montamos las particiones del raid.

shian:~# mkdir /mnt/md0
shian:~# mkdir /mnt/md2

shian:~# mount /dev/md0 /mnt/md0
shian:~# mount /dev/md2 /mnt/md2

Editamos el archivo /etc/fstab y cambiamos sda1, sda5 y sda6 por los nuevos dispositivos del raid (md0, md1 y md2 respectivamente).

# /etc/fstab: static file system information.
#
#                
proc            /proc           proc    defaults        0       0
/dev/md2        /               ext3    defaults,errors=remount-ro 0       1
/dev/md0        /boot           ext2    defaults        0       2
/dev/md1        none            swap    sw              0       0
/dev/hdc        /media/cdrom0   udf,iso9660 user,noauto     0       0
/dev/fd0        /media/floppy0  auto    rw,user,noauto  0       0

Editamos el archivo /boot/grub/menu.lst de configuración del grub para añadir las entradas a ambos discos duros. Duplicamos la línea que tenemos del arranque, cambiamos sda6 por md2 y cambiamos el disco duro del que arranca.

# Línea original
#title           Debian GNU/Linux, kernel 2.6.18-4-686
#root            (hd0,0)
#kernel          /vmlinuz-2.6.18-4-686 root=/dev/sda6 ro
#initrd          /initrd.img-2.6.18-4-686
#savedefault

# Nuevas líneas
title           Debian GNU/Linux, kernel 2.6.18-4-686 (HD1)
root            (hd1,0)
kernel          /vmlinuz-2.6.18-4-686 root=/dev/md2 ro
initrd          /initrd.img-2.6.18-4-686
savedefault

title           Debian GNU/Linux, kernel 2.6.18-4-686 (HD0)
root            (hd0,0)
kernel          /vmlinuz-2.6.18-4-686 root=/dev/md2 ro
initrd          /initrd.img-2.6.18-4-686
savedefault

Ahora actualizamos el ramdisk para que se reflejen los cambios que hemos hecho.

shian:~# update-initramfs -u
update-initramfs: Generating /boot/initrd.img-2.6.18-4-686

Copiamos los datos de las particiones antiguas a las nuevas del raid. La opción 'x' es muy importante porque sino al copiar desde / copiaríamos todo de manera recursiva.

shian:~# cp -ax / /mnt/md2

shian:~# cd /boot/
shian:/boot# cp -ax . /mnt/md0

Instalamos y reconfiguramos grub en los dos discos.

shian:~# grub

grub> root (hd0,0)
 Filesystem type is ext2fs, partition type 0x83

grub> setup (hd0)
 Checking if "/boot/grub/stage1" exists... no
 Checking if "/grub/stage1" exists... yes
 Checking if "/grub/stage2" exists... yes
 Checking if "/grub/e2fs_stage1_5" exists... yes
 Running "embed /grub/e2fs_stage1_5 (hd0)"...  15 sectors are embedded.
succeeded
 Running "install /grub/stage1 (hd0) (hd0)1+15 p (hd0,0)/grub/stage2 /grub/menu.lst"... succeeded
Done.

grub> root (hd1,0)
 Filesystem type is ext2fs, partition type 0xfd

grub> setup (hd1)
 Checking if "/boot/grub/stage1" exists... no
 Checking if "/grub/stage1" exists... yes
 Checking if "/grub/stage2" exists... yes
 Checking if "/grub/e2fs_stage1_5" exists... yes
 Running "embed /grub/e2fs_stage1_5 (hd1)"...  15 sectors are embedded.
succeeded
 Running "install /grub/stage1 (hd1) (hd1)1+15 p (hd1,0)/grub/stage2 /grub/menu.lst"... succeeded
Done.

Y ya podemos reinicar la máquina. Hay que tenemos en cuenta que la máquina sólo arrancará del segundo disco porque el primero todavía no forma parte del raid. Si todo va bien, una vez que arranque veremos algo como esto:

shian:~# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/md2              7.4G  509M  6.5G   8% /
tmpfs                  63M     0   63M   0% /lib/init/rw
udev                   10M  100K   10M   1% /dev
tmpfs                  63M     0   63M   0% /dev/shm
/dev/md0              183M   13M  161M   8% /boot

shian:~# mount
/dev/md2 on / type ext3 (rw,errors=remount-ro)
tmpfs on /lib/init/rw type tmpfs (rw,nosuid,mode=0755)
proc on /proc type proc (rw,noexec,nosuid,nodev)
sysfs on /sys type sysfs (rw,noexec,nosuid,nodev)
udev on /dev type tmpfs (rw,mode=0755)
tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev)
devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=620)
/dev/md0 on /boot type ext2 (rw)

Lo más difícil ya está hecho. Tenemos el raid funcionando en modo degradado porque sólo está disponible el disco sdb. Ahora repetimos casi el mismo proceso para el disco antiguo. Cambiamos el tipo de particiones a fd y las añadimos particiones al raid.

shian:~# fdisk /dev/sda
...
Command (m for help): p

Disk /dev/sda: 8589 MB, 8589934592 bytes
255 heads, 63 sectors/track, 1044 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1          24      192748+  fd  Linux raid autodetect
/dev/sda2              25        1044     8193150    5  Extended
/dev/sda5              25          73      393561   fd  Linux raid autodetect
/dev/sda6              74        1044     7799526   fd  Linux raid autodetect
...


shian:~# mdadm --add /dev/md0 /dev/sda1
mdadm: added /dev/sda1
shian:~# mdadm --add /dev/md1 /dev/sda5
mdadm: added /dev/sda5
shian:~# mdadm --add /dev/md2 /dev/sda6
mdadm: added /dev/sda6

Empezará entonces la reconstrucción de los raid.

shian:~# cat /proc/mdstat
Personalities : [raid1] [raid6] [raid5] [raid4]
md2 : active raid1 sda6[2] sdb6[1]
      7799424 blocks [2/1] [_U]
      [=====>...............]  recovery = 25.2% (1967936/7799424) finish=1.1min speed=81997K/sec

md1 : active raid1 sda5[0] sdb5[1]
      393472 blocks [2/2] [UU]

md0 : active raid1 sda1[0] sdb1[1]
      192640 blocks [2/2] [UU]

unused devices: 

   Un vez terminada la reconstrucción tendremos listo el sistema. Ahora, si queremos probar que todo funciona correctamente podemos reinicar de nuevo la máquina y comprobar que es capaz de arrancar desde cualquiera de los dos discos.

   Con este tipo de configuración estamos seguros de que aunque falle un disco nuestro servidor estará disponible y no tendremos que reinstalar ni reconfigurar nada. Sólo será necesario cambiar el disco defectuoso, reconstruir el raid y reconfigurar el grub.

Crear un raid 1 a partir de un disco con datos sin formatear

   Hace unos días recibí un email de un lector de este blog, Renato, diciéndome que tiene un NSLU2 con Debian, qué envidía :-P, y con un disco duro muy lleno. Me preguntaba si podía añadir un nuevo disco y crear un raid sin tener que reformatear.

   Me picó la curiosidad y el resultado es este tutorial. No voy a extenderme demasiado en las explicaciones puesto que en el tutorial del raid 1 que hice hace tiempo se puede encontrar la información más detallada. Manos a la obra!.

Como preparación he creado una partición /dev/sda1, la he montado en /mnt/datos y he copiado algo de información en ella. Esta sería la partición que ya tenemos casi llena y no queremos tener que formatearla.

Vamos a crear un raid 1 con el otro disco (el disco nuevo que todavía no tiene información). Particionamos como tipo fd:

shian:~# fdisk /dev/sdb
...
Disk /dev/sdb: 1073 MB, 1073741824 bytes
255 heads, 63 sectors/track, 130 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1         130     1044193+  fd  Linux raid autodetect
...

Y ahora viene el paso más importante en la creación del raid. Creamos el raid 1 pero con un único disco/partición. La clave es utilizar sólo la partición del nuevo disco /dev/sdb1 y en el otro poner missing, de tal forma que el raid 1 se crea degradado porque sólo existe un disco.

shian:~# mdadm --create --verbose /dev/md1 --level=1 --raid-devices=2 /dev/sdb1 missing
mdadm: size set to 1044096K
mdadm: array /dev/md1 started.

Si aparece el error mdadm: error opening /dev/md1: No such file or directory deberemos crear el dispositivo mdX primero, según el que necesitemos:

shian:~# mknod /dev/md0 b 9 0
shian:~# mknod /dev/md1 b 9 1
shian:~# mknod /dev/md2 b 9 2
...

Si miramos el fichero /proc/mdstat nos fijamos en el que raid está disponible pero sólo con un disco.

shian:~# cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md1 : active raid1 sdb1[0]
      1044096 blocks [2/1] [U_]

Lo mismo ocurre si mostramos la información del raid:

shian:~# mdadm --detail /dev/md1
/dev/md1:
        Version : 00.90.03
  Creation Time : Fri Sep 28 08:09:16 2007
     Raid Level : raid1
     Array Size : 1044096 (1019.80 MiB 1069.15 MB)
    Device Size : 1044096 (1019.80 MiB 1069.15 MB)
   Raid Devices : 2
  Total Devices : 1
Preferred Minor : 1
    Persistence : Superblock is persistent

    Update Time : Fri Sep 28 08:09:16 2007
          State : clean, degraded
 Active Devices : 1
Working Devices : 1
 Failed Devices : 0
  Spare Devices : 0

           UUID : b0e5f96e:12266294:54e4f551:119b56e7
         Events : 0.1

    Number   Major   Minor   RaidDevice State
       0       8       17        0      active sync   /dev/sdb1
       1       0        0        1      removed

Formateamos el raid y lo montamos en /mnt/datos_raid. Así, estaría disponible para ser utilizado, pero con un único disco. Además, copiamos la información del disco antiguo (recordemos que está montado en /mnt/datos) al raid.

shian:~# mkfs.ext3 /dev/md1
shian:~#
shian:~# mkdir /mnt/datos_raid 
shian:~# mount /dev/md1 /mnt/datos_raid
shian:~#
shian:~# cp -a /mnt/datos/* /mnt/datos_raid

En este punto ya tenemos toda la información en el raid. Ahora desmontamos la partición de nuestros datos /dev/sda1, particionamos el disco y creamos la partición de tipo raid (fd).

shian:~# umount /dev/sda1
shian:~# fdisk /dev/sda
...
Disk /dev/sda: 1073 MB, 1073741824 bytes
255 heads, 63 sectors/track, 130 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1         130     1044193+  fd  Linux raid autodetect
...

Y ahora añadimos al raid /dev/md1 la partición que acabamos de crear:

shian:~# mdadm --manage /dev/md1 --add /dev/sda1
mdadm: added /dev/sda1

Después de un tiempo el raid estará reconstruido con toda nuestra información a salvo en ambos discos:

shian:~# cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md1 : active raid1 sda1[1] sdb1[0]
      1044096 blocks [2/2] [UU]

El paso final es actualizar el archivo de configuración /etc/mdadm/mdadm.conf con el nuevo raid.

shian:~# cd /etc/mdadm
shian:/etc/mdadm# cp mdadm.conf mdadm.conf.`date +%y%m%d`
shian:/etc/mdadm# echo "DEVICE partitions" > mdadm.conf
shian:/etc/mdadm# mdadm --detail --scan >> mdadm.conf

Y añadir al archivo /etc/fstab el montaje automático del raid en el arranque.

shian:~# echo "/dev/md1        /mnt/datos       ext3    defaults        0       2" >> /etc/fstab

   Hemos visto cómo pasar de una configuración con un único disco a otra basada en un raid 1 sin tener que salvar toda nuestra información en otro medio independiente y reformatear todo a la vez.

   Lamentablemente, lo que quería hacer nuestro compañero Renato era crear un raid JBOD (o lineal), cosa que no entendí yo en un primer momento y me lancé a probarlo con un raid 1. Si intentamos crear el raid lineal con un único disco vemos que no es posible. Aunque el mensaje de mdadm no es muy claro, con dmesg vemos realmente la causa:

shian:~# mdadm --create --verbose /dev/md2 --level=linear --raid-devices=2 /dev/sdb1 missing
mdadm: chunk size defaults to 64K
mdadm: RUN_ARRAY failed: Invalid argument
mdadm: stopped /dev/md2

shian:~# dmesg
...
linear: not enough drives present. Aborting!
md: pers->run() failed ...
md: md3 stopped.
md: unbind
md: export_rdev(sdb1)

   La solución a cómo poder hacer esto sin tener que reformatear en el próximo post :-).

Monitorizando un Raid en Linux: Estado y Ocupación

   Enlazando con el artículo anterior del envío de alarmas al móvil utilizando el API de Google Calendar, le he dado utilidad al programa. Desde hace unos días lo utilizo para monitorizar el estado del raid 1 del servidor de backup y enterarme de manera instantánea de cualquier problema con algún disco.

   Utilizando mdadm en modo monitor lo configuré para que ejecutara un script cuando detectara algún evento del raid. De todos los eventos posibles, los que a mi me interesan son:

Fail: Cuando se produce un fallo en algún disco del raid.

DegradedArray: Si se ha producido un fallo en algún disco y se ejecuta de nuevo el mdadm, se genera este evento. El caso más típico para un raid 1 es que ha fallado un disco y hemos reiniciado la máquina y estamos trabajando sólo con el otro disco. Sirve a modo de recordatorio de que hay que cambiar el disco defectuoso y reconstruir el raid.

RebuildStarted: Este evento se genera cuando comienza la reconstrucción del raid.

RebuldFinished: Cuando se ha terminado de reconstruir el raid se lanza este evento.

   El resto de eventos no me afectan demasiado, así que simplemente los guardaré en un log. Para ejecutar un script cuando se produce un evento en el raid en lugar de la notificación por email, es necesario hacer un pequeño cambio en el archivo /etc/init.d/mdadm.

Definimos la ruta del script:

PROGRAM=/root/scripts/monitorRaid.sh

En "start" cambiamos la instrucción que viene por:

start-stop-daemon -S -p $PIDFILE -x $MDADM -- -F -i $PIDFILE -p $PROGRAM -f --scan

   El script monitorRaid.sh que he creado es el siguiente:

shian:~# cat scripts/monitorRaid.sh
#!/bin/sh
# Script de generación de alarmas según el estado del raid
#
# Iván López Martín
# http://lopezivan.blogspot.com
#####

RAID_EVENT=$1
LOG_DIR=/var/local/raid
LOG_FILE=monitor_raid.log
SMS_PROGRAM=/root/scripts/enviaSMS.sh
GMAIL_USER=usuario@gmail.com
GMAIL_PASS=mipassword

if [ $RAID_EVENT == "Fail" ]; then
  date >> $LOG_DIR/$LOG_FILE
  echo Fail >> $LOG_DIR/$LOG_FILE
  echo >> $LOG_DIR/$LOG_FILE
  
  # Envío del SMS
  $SMS_PROGRAM $GMAIL_USER $GMAIL_PASS "ERROR CRITICO: Ha fallado un disco del raid."

elif [ $RAID_EVENT == "DegradedArray" ]; then
  date >> $LOG_DIR/LOG_FILE
  echo DegradedArray >> $LOG_DIR/$LOG_FILE
  echo >> $LOG_DIR/$LOG_FILE
  
  # Envío del SMS
  $SMS_PROGRAM $GMAIL_USER $GMAIL_PASS "RECORDATORIO: El raid está funcionando con un solo disco."

elif [ $RAID_EVENT == "RebuildStarted" ]; then
  date >> $LOG_DIR/$LOG_FILE
  echo RebuildStarted >> $LOG_DIR/$LOG_FILE
  echo >> $LOG_DIR/$LOG_FILE

elif [ $RAID_EVENT == "RebuildFinished" ]; then
  date >> $LOG_DIR/$LOG_FILE
  echo RebuldFinished >> $LOG_DIR/$LOG_FILE
  echo >> $LOG_DIR/$LOG_FILE

  # Envío del SMS
  $SMS_PROGRAM $GMAIL_USER $GMAIL_PASS "INFO: Ha terminado la reconstrucción del raid."

else
  date >> $LOG_DIR/$LOG_FILE
  echo $RAID_EVENT >> $LOG_DIR/$LOG_FILE
  echo >> $LOG_DIR/$LOG_FILE
fi

   Para probar que está todo bien configurado, podemos ejecutar el monitor del raid en modo Test:

shian:~# mdadm -F -p /root/scripts/monitorRaid.sh --scan -t -1

shian:~# tail -3 /var/local/raid/monitor_raid.log
Mon May 21 18:15:17 CEST 2007
TestMessage

   Si vemos el mensaje de prueba significa que la monitorización es correcta, ahora sólo queda esperar a que falle algún disco (ojalá no ocurra) para que el programa de alarmas por sms cumpla su función.

   Adicionalmente he creado otro script que ejecuto por medio de crontab cada 10 minutos que monitoriza la ocupación de los filesystems (en este caso sólo el del raid) y cuando se supera un umbral se envía una notificación por SMS.

shian:~# cat monitorFS.sh
#!/bin/sh
# Script de monitorización del tamaño de un filesystem y envío de alarmas por SMS
#
# Iván López Martín
# http://lopezivan.blogspot.com
######

FILESYSTEM=$1
TMP_DIR=/root/scripts
SMS_PROGRAM=/root/scripts/enviaSMS.sh
GMAIL_USER=usuario@gmail.com
GMAIL_PASS=mipassword

SPACE_USED=`df | grep $FILESYSTEM | awk '{print $5}' | sed 's/%//g'`

if [ "$SPACE_USED" -gt 90 ] ; then
  if ! [ -f $TMP_DIR/.fs_90 ] ;then
    SEND_SMS=YES
    THRESHOLD=90
    touch $TMP_DIR/.fs_90
  fi
elif [ "$SPACE_USED" -gt 80 ] ; then
  if ! [ -f $TMP_DIR/.fs_80 ] ;then
    SEND_SMS=YES
    THRESHOLD=80
    touch $TMP_DIR/.fs_80
  fi
elif [ "$SPACE_USED" -gt 70 ] ; then
  if ! [ -f $TMP_DIR/.fs_70 ] ;then
    SEND_SMS=YES
    THRESHOLD=70
    touch $TMP_DIR/.fs_70
  fi
elif [ "$SPACE_USED" -gt 60 ] ; then
  if ! [ -f $TMP_DIR/.fs_60 ] ;then
    SEND_SMS=YES
    THRESHOLD=60
    touch $TMP_DIR/.fs_60
  fi
fi

if [ "$SEND_SMS" == "YES" ] ; then
  # Envio del SMS
  $SMS_PROGRAM $GMAIL_USER $GMAIL_PASS "El filesystem" $FILESYSTEM "supera el "$THRESHOLD"%."
fi

Servidor raid 1 en "Preproducción"

   El otro día estuve un tanto ocioso y quise hacer una pequeña prueba del raid 1 pero esta vez sin utilizar máquinas virtuales, sino con hardware real. Así podía hacer una prueba en "preproducción" antes de la implementación definitiva cuando tenga mi nuevo ordenador y reutilice el antiguo.

   Abrí una caja con diverso hardware (memorias, discos duros, cables ide, alguna placa base, procesadores,...) que tengo pendiente de subir al trastero y monté lo siguiente:

   El equipo es ya algo antiguo y fue lo mejor que pude hacer con el hardware que tenía:

Pentium II 300Mhz

384 MB de Ram

Tarjeta Gráfica ATI Mach32 PCI

Tarjeta de red 3Com PCI 100 Mbps

Disco duro principal 1,6 GB

2 discos duros adicionales para el raid

   El disco duro principal ya tenía una Debian Sarge recien instalada que utilicé hace algún tiempo en un pc de características similares, así que todo arrancó sin problemas. Para logarme como root y empezar a configurar el raid y hacer las pruebas utilicé el método que comenté el otro día para recuperar el password de root puesto que no me acordaba del password.

   Después de tener tanto el raid como samba configurados hice una pequeña prueba copiando un archivo de unos 700 MB de mi actual sobremesa a una carpeta compartida del raid y tomé tiempos. La copia de los 700 MB tardó algo menos de 2 minutos, por lo que me sale una transferencia de aproximadamente unos 6,5 MBytes por segundo. Aunque creo que para casa es más que suficiente he hecho una prueba similar en el trabajo (aunque con dos máquinas windows) para comparar y el tiempo ha sido prácticamente el mismo.

Raid 1 en Linux

   Siguiendo el artículo anterior del servidor NAS para casa, aquí cuento todo lo que hice para configurar y probar el raid 1 en debian y las conclusiones finales a las que llegué. Este pequeño tutorial lo he hecho en una máquina virtual VMware por lo cómodo que es probar e instalar todo. El disco de sistema es hda con una única partición y los discos con los que se creará el raid 1 serán hdb y hdc. Muestro en rojo lo que he introducido en los diferentes menús.

Particionar los dos discos duros. El sistema de archivos debe ser Linux raid auto.

shian:~# fdisk /dev/hdb
Command (m for help): p

Disk /dev/hdb: 1073 MB, 1073741824 bytes
16 heads, 63 sectors/track, 2080 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

   Device Boot      Start         End      Blocks   Id  System

Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-2080, default 1):INTRO
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-2080, default 2080):INTRO
Using default value 2080

Command (m for help): t
Selected partition 1
Hex code (type L to list codes): fd
Changed system type of partition 1 to fd (Linux raid autodetect)

Command (m for help): p

Disk /dev/hdb: 1073 MB, 1073741824 bytes
16 heads, 63 sectors/track, 2080 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/hdb1               1        2080     1048288+  fd  Linux raid autodetect

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

Repetimos los pasos para /dev/hdc.

Creamos el raid 1 con las dos particiones que acabamos de crear. En las opciones indicamos que el tipo de raid será 1 (mirror), que deseamos utilizar dos discos y que el nuevo dispositivo raid será /dev/md0.

shian:~# mdadm --create /dev/md0 --verbose --level=1 --raid-devices=2 /dev/hdb1 /dev/hdc1
mdadm: size set to 1048192K
mdadm: array /dev/md0 started.

NOTA: Si ya hemos usado el disco anteriormente para otro raid, es necesario reiniciar el superbloque para que se borre la información existente, puesto que sino, la creación puede fallar:

shian:~# mdadm --zero-superblock /dev/sdXX

El raid 1 se está creando en segundo plano. En función del tamaño de los discos tardará más o menos. Se puede ver el estado en el archivo /proc/mdstat:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1] ide/host0/bus0/target1/lun0/part1[0]
      1048192 blocks [2/2] [UU]
      [===========>.........]  resync = 58.2% (611196/1048192) finish=0.0min speed=101866K/sec
unused devices: <none>

El porcentaje va subiendo hasta que finalmente el dispositivo está listo:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1] ide/host0/bus0/target1/lun0/part1[0]
      1048192 blocks [2/2] [UU]

unused devices: <none>

A partir de este momento para cualquier manipulación que deseemos hacer del raid debemos utilizar /dev/md0 y no /dev/hdb1 ni /dev/hdc1.

Formateamos el raid

shian:~# mkfs.ext3 /dev/md0
mke2fs 1.37 (21-Mar-2005)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
131072 inodes, 262048 blocks
13102 blocks (5.00%) reserved for the super user
First data block=0
8 block groups
32768 blocks per group, 32768 fragments per group
16384 inodes per group
Superblock backups stored on blocks:
        32768, 98304, 163840, 229376

Writing inode tables: done
Creating journal (4096 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 22 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.

Creamos el punto de montaje, añadimos la entrada correspondiente para que el raid se monte cuando se arranca la máquina y lo montamos:

shian:~# mkdir /mnt/raid

shian:~# echo "/dev/md0        /mnt/raid       ext3    defaults        0       1" >> /etc/fstab

shian:~# mount /mnt/raid

shian:~# df -h /dev/md0
Filesystem            Size  Used Avail Use% Mounted on
/dev/md0             1008M   17M  941M   2% /mnt/raid

Aquí ya habríamos terminado la instalación del raid y podríamos utilizarlo, aunque tal y como está configurado y montado sólo tendría permisos el usuario root.

   A partir de aquí, lo que yo hice inicialmente fue simular que un disco duro se estropeaba y al arrancar la máquina quería montar el raid sólo con el otro disco y utilizarlo normalmente. Además, después de simular con la máquina virtual que añadía un nuevo disco duro, quería añadirlo al raid para volver a tener de nuevo la redundancia. Después de leer muchos tutoriales y foros no había manera de que funcionase. Si reiniciaba la máquina sin un disco del raid, éste no se montaba y no podía acceder a los datos. Además, el dispositivo /dev/md0 no era reconocido, por lo que era como si el raid no existiese!. Finalmente, encontré en un pequeño tutorial la solución a mis problemas.

Es necesario indicarle al sistema operativo cómo acceder a ese dispositivo raid para que sea capaz de utilizarlo. Esto que puede parecer tan obvio no venía en ningún tutorial ni en ninguna ayuda de las que consulté.

shian:/# cd /etc/mdadm
shian:/etc/mdadm# cp mdadm.conf mdadm.conf.`date +%y%m%d`
shian:/etc/mdadm# echo "DEVICE partitions" > mdadm.conf
shian:/etc/mdadm# mdadm --detail --scan >> mdadm.conf
shian:/etc/mdadm#
shian:/etc/mdadm# cat mdadm.conf
DEVICE partitions
ARRAY /dev/md0 level=raid1 num-devices=2 UUID=a48e6816:ea6e7f37:6cc50cdb:6fead399
   devices=/dev/hdb1,/dev/hdc1

Ahora ya podemos reiniciar la máquina y el raid arrancará y se montará automáticamente en el arranque.

Podemos probar a parar el dispositivo y a levantarlo de nuevo:

shian:/etc/mdadm# umount /mnt/raid
shian:/etc/mdadm# mdadm --stop /dev/md0
shian:/etc/mdadm# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
unused devices: <none>

shian:/etc/mdadm# mdadm --assemble /dev/md0 /dev/hdb1 /dev/hdc1
mdadm: /dev/md0 has been started with 2 drives.
shian:/etc/mdadm# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[0] ide/host0/bus1/target0/lun0/part1[1]
      1048192 blocks [2/2] [UU]

unused devices: <none>

   Ahora sí, vamos a probar si realmente el podemos recuperar la información y el sistema funciona correctamente en caso de caída de un dispositivo. Además, veremos cómo reemplazar el disco defectuoso y recuperar de nuevo el raid 1 con los dos discos.

Creamos un archivo aleatorio de 25MB en el raid montando previamente de nuevo el raid:

shian:/# mount /dev/md0 /mnt/raid
shian:/# dd if=/dev/urandom of=/mnt/raid/random1 count=51200
51200+0 records in
51200+0 records out
26214400 bytes transferred in 7.829523 seconds (3348148 bytes/sec)

Calculamos su CRC y lo apuntamos. Posteriormente nos servirá para comprobar que todo es correcto:

shian:/# cksum /mnt/raid/random1
1652310020 26214400 /mnt/raid/random1

Vamos a simular un fallo en uno de los dispositivos. Para ello apagamos el sistema, desconectamos uno de los discos duros (en este caso /dev/hdb) y arrancamos de nuevo.

Una vez arrancado de nuevo el sistema, si examinamos con detalle los mensajes de arranque encontraremos algo como lo siguiente. Como se puede ver el sistema ha detectado un disco falla y al no haber un disco de repuesto (spare) levanta el raid en modo degradado con un sólo disco. Podremos seguir utilizando el raid con total normalidad pero si este disco también fallase, perderíamos irremediablemente todos los datos.

md: bind
md: ide/host0/bus1/target0/lun0/part1's event counter: 00000006
md0: former device hdb1 is unavailable, removing from array!
md: raid1 personality registered as nr 3
md0: max total readahead window set to 124k
md0: 1 data-disks, max readahead per data-disk: 124k
raid1: device ide/host0/bus1/target0/lun0/part1 operational as mirror 1
raid1: md0, not all disks are operational -- trying to recover array
raid1: raid set md0 active with 1 out of 2 mirrors
md: updating md0 RAID superblock on device
md: ide/host0/bus1/target0/lun0/part1 [events: 00000007]<6>(write) ide/host0/bus1/target0/lun0/part1's sb offset: 1048192
md: recovery thread got woken up ...
md0: no spare disk to reconstruct array! -- continuing in degraded mode
md: recovery thread finished ...

En el archivo /proc/mdstat podemos ver el estado del raid. Ahora mismo se encuentra funcionando sólo con un dispositivo de dos posibles y nos indica que el que ha fallado es el primero de ellos:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1]
      1048192 blocks [2/1] [_U]

unused devices: <none>

No obstante el raid está montado y el filesystem es accesible:

shian:~# df -h /dev/md0
Filesystem            Size  Used Avail Use% Mounted on
/dev/md0             1008M   42M  916M   5% /mnt/raid

Ahora marcamos el disco /dev/hdb1 como fallo para proceder a cambiarlo:

shian:~# mdadm --manage /dev/md0 --fail /dev/hdb1
mdadm: set /dev/hdb1 faulty in /dev/md0

   Apagamos la máquina y cambiamos el disco duro defectuoso por uno nuevo. En el caso de VMware basta con crear un nuevo dispositivo de tipo disco duro. Además, este disco duro nuevo que añadimos va a ser de mayor tamaño que el anterior. Idealmente en un raid 1 los dos discos duros deben tener el mismo tamaño, pero linux nos proporciona la suficiente flexibilidad para que esto no sea así.

En el arranque de la máquina vemos que el raid sigue arrancando pero en modo degradado. Lo que vamos a hacer es crear la tabla de particiones del nuevo disco duro exáctamente igual que la del disco duro que aún funciona y que forma parte del raid:

shian:~# sfdisk -d /dev/hdc | sfdisk /dev/hdb
Checking that no-one is using this disk right now ...
OK

Disk /dev/hdb: 4161 cylinders, 16 heads, 63 sectors/track

sfdisk: ERROR: sector 0 does not have an msdos signature
 /dev/hdb: unrecognized partition table type
Old situation:
No partitions found
New situation:
Units = sectors of 512 bytes, counting from 0

   Device Boot    Start       End   #sectors  Id  System
/dev/hdb1            63   2096639    2096577  fd  Linux raid autodetect
/dev/hdb2             0         -          0   0  Empty
/dev/hdb3             0         -          0   0  Empty
/dev/hdb4             0         -          0   0  Empty
Warning: no primary partition is marked bootable (active)
This does not matter for LILO, but the DOS MBR will not boot this disk.
Successfully wrote the new partition table

Re-reading the partition table ...

If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)
to zero the first 512 bytes:  dd if=/dev/zero of=/dev/foo7 bs=512 count=1
(See fdisk(8).)

Como este nuevo disco duro es mayor que el anterior, podemos crear una partición /dev/hdb2 y formatearla para utilizarla sin problemas.

shian:~# fdisk /dev/hdb

The number of cylinders for this disk is set to 4161.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs
   (e.g., DOS FDISK, OS/2 FDISK)

Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (2081-4161, default 2081):INTRO
Using default value 2081
Last cylinder or +size or +sizeM or +sizeK (2081-4161, default 4161):INTRO
Using default value 4161

Command (m for help): p

Disk /dev/hdb: 2147 MB, 2147483648 bytes
16 heads, 63 sectors/track, 4161 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/hdb1               1        2080     1048288+  fd  Linux raid autodetect
/dev/hdb2            2081        4161     1048824   83  Linux

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

shian:~# mkfs.ext3 /dev/hdb2
mke2fs 1.37 (21-Mar-2005)
warning: 62 blocks unused.

Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
131328 inodes, 262144 blocks
13110 blocks (5.00%) reserved for the super user
First data block=0
8 block groups
32768 blocks per group, 32768 fragments per group
16416 inodes per group
Superblock backups stored on blocks:
        32768, 98304, 163840, 229376

Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 30 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.

shian:~# mkdir /mnt/tmp

shian:~# mount /dev/hdb2 /mnt/tmp

Ahora vamos a reconstruir el raid:

shian:~# mdadm --manage /dev/md0 --add /dev/hdb1
mdadm: hot added /dev/hdb1

En este instante el raid 1 se está reconstruyendo. Toda la información del disco existente (/dev/hdc1) se está escribiendo en el nuevo disco (/dev/hdb1) para reconstruir el mirror y tener de nuevo la redundancia. Podemos comprobar el estado en el archivo /proc/mdstat:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[2] ide/host0/bus1/target0/lun0/part1[1]
      1048192 blocks [2/1] [_U]
      [=======>.............]  recovery = 39.5% (415488/1048192) finish=0.1min speed=69248K/sec
unused devices: <none>

Finalmente, después de un tiempo tenemos el raid recuperado:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[0] ide/host0/bus1/target0/lun0/part1[1]
      1048192 blocks [2/2] [UU]

unused devices: <none>

Si no nos fiamos de que todo esté correcto (yo tengo que verlo para creerlo), podemos hacer lo siguiente para comprobar que la recuperación se ha realizado satisfactoriamente. Lo que vamos a hacer es desmontar el raid, montar únicamente el nuevo dispositivo /dev/hdb1 y comprobar el CRC del archivo que generamos anteriormente para comprobar que la recuperación ha sido correcta.

shian:~# umount /mnt/raid
shian:~# mount /dev/hdb1 /mnt/raid
shian:~# cksum /mnt/raid/random1
1652310020 26214400 /mnt/raid/random1

Y listo!. El raid se ha recuperado correctamente y toda nuestra información está a salvo. Es importante dejarlo todo como estaba antes de utilizarlo puesto que ahora mismo en /mnt/raid se encuentra montado de manera temporal sólo un dispositivo del raid y no éste completo. Si ahora hiciéramos algún cambio, creásemos archivos,... perderíamos todos esos datos en cuanto montásemos de nuevo el raid. Mejor lo dejamos todo como estaba:

shian:~# umount /mnt/raid/
shian:~# mount /mnt/raid/
shian:~# df -h /mnt/raid/
Filesystem            Size  Used Avail Use% Mounted on
/dev/md0             1008M   42M  916M   5% /mnt/raid

Si ahora reiniciamos la máquina vemos que el raid arranca correctamente con los dos discos de nuevo:

md: ide/host0/bus0/target1/lun0/part1's event counter: 0000000c
md: ide/host0/bus1/target0/lun0/part1's event counter: 0000000c
md: raid1 personality registered as nr 3
md0: max total readahead window set to 124k
md0: 1 data-disks, max readahead per data-disk: 124k
raid1: device ide/host0/bus0/target1/lun0/part1 operational as mirror 0
raid1: device ide/host0/bus1/target0/lun0/part1 operational as mirror 1
raid1: raid set md0 active with 2 out of 2 mirrors
md: updating md0 RAID superblock on device
md: ide/host0/bus0/target1/lun0/part1 [events: 0000000d]<6>(write) ide/host0/bus0/target1/lun0/part1's sb offset: 1048192
md: ide/host0/bus1/target0/lun0/part1 [events: 0000000d]<6>(write) ide/host0/bus1/target0/lun0/part1's sb offset: 1048192

   Hemos visto una manera bastante sencilla y fiable de tener nuestros datos importantes a buen recaudo. No obstante este sistema raid no sirve de nada sin una buena política de backups, puesto que no protege del borrado accidental de archivos.

   Después de haber probado FreeNAS y el Raid en Debian puedo sacar en claro lo siguiente:

FreeNAS es mucho más sencillo y fácil de configurar, pero no ofrece toda la flexibilidad que linux. Por ejemplo, con FreeNAS no es posible crear un raid con dos discos de distinto tamaño y aprovechar el espacio restante. En linux eso no supone ningún problema. Simplemente hay que tener claro que los datos de esa nueva partición no tendrán respaldo, por lo que no se debe utilizar para almacenar información importante.

FreeNAS todavía es una versión beta y aunque parece muy robusta y hay mucha gente que la está utilizando (sólo hay que echar un vistazo a sus foros), los desarrolladores indican que no se debería utilizar en entornos de producción. Por contra, el raid por software en linux se lleva utilizando desde hace bastante tiempo.

Si tengo algún problema con FreeNAS será más complicado encontrar soporte. Sólo tendría el foro para preguntar. Si tengo un problema con linux tengo a mano a Alex que seguro está encantado de echarme una mano ;-)

Al utilizar un sistema linux "estandar" podemos montar un apache, scripts de monitorización del raid, avisos por correo electrónico,... cualquier cosa que se nos ocurra. Con FreeNAS esto sería muy complicado de hacer.

   Ahora ya sólo me queda cambiar mi actual Duron 1200Mhz (algo que voy a hacer en las próximas semanas) puesto que ya está algo viejo y cada vez lo noto más lento y utilizarlo como servidor NAS-Debian en casa.

   El siguiente capítulo será la configuración de Samba para compartir los nuevos dispositivos creados con una máquina windows así como la gestión de los distintos permisos de usuario.

   

Servidor NAS para casa

   Hace un mes descubrí el proyecto FreeNAS. Es un proyecto para crer un servidor NAS basado en una distribución de FreeBSD y con una interfaz gráfica php. La instalación es muy sencilla he incluso en la web de sourceforge podemos descargar una máquina virtual de VMware ya preparada para probar.

   Me ha picado el gusanillo y he estado algún tiempo realizando bastantes pruebas (gracias a la máquina virtual) creando servidores con discos en raid 1, raid 5, (por software claro)... compartiendo los datos con máquinas windows,... y aunque todavía se trata de una versión beta (actualmente 0.68b3) el producto está muy logrado y me ha sorprendido gratamente. Me he planteado crear un pequeño servidor NAS en casa con raid 1 para poder tener todos los datos importantes centralizados y poder gestionar mejor las copias de seguridad. Actualmente es bastante complicado porque mi mujer trabaja con su portatil pero parte de su información está en mi sobremesa, luego otra copia está en mi disco duro externo,... y nunca tiene tiempo de sincronizar la información!! en fin, un caos!.

   Un aspecto muy importante cuando se configura un servidor NAS es la recuperación en caso de fallo. En mi caso, con la máquina virtual es muy fácil de simular y probar. Sólo hay que desconectar un disco duro y arrancar de nuevo el sistema para ver qué ocurre. En las pruebas no se perdió nada de información aunque se trabajase sólo con un único disco. Posteriormente conecté un nuevo disco a la máquina virtual y lo quise añadir al raid 1. Al principio me volví loco puesto que desde la interfaz gráfica no encontraba la forma de hacerlo. Finalmente, después de leer el foro descubrí que a los desarrolladores se les había olvidado la opción de añadir un disco al raid 1. Como FreeNAS utiliza la herramienta gmirror de FreeBSD, googleando un poco encontré los comandos necesarios para reconstruir el raid sin problemas desde la línea de comandos.

   Unos días después le conté este proyecto a Alex y aunque me dijo que tenía buena pinta me sugirió que hiciera lo mismo con linux, exactamente con Debian. La ventaja de utilizar FreeNAS es que ya está todo configurado y orientado al servidor NAS. Así, es muy sencillo compartir la información con clientes windows, utilizar un servidor ftp,... Pero esto también es un inconveniente. El sistema está tan pensado para hacer sólo esto que es muy dificil añadir alguna mejora o modificarlo para adaptarlo a nuestros gustos. Además, aunque no tengo los conocimientos de Alex en linux, me defiendo. Sin embargo, esto no lo puedo decir de FreeBSD que es el sistema operativo en el que se basa FreeNAS.

   Así, descargué la última versión de Debian Sarge que encontré (la 3.1r5) y lo instalé en VMware para poder hacer todas las pruebas. En breve publicaré el siguiente artículo con todo lo que tuve que hacer y cómo solucioné los problemas (que hubo bastantes) hasta que logré que todo funcionase correctamente.