semanage (SELinux Policy Management tool) es un comando que permite configurar políticas de SELinux en RHEL, CentOS, etc. Lo más probable es que en un sistema Red Hat 6 instalado por defecto (base) el comando no se encuentre disponible:

# semanage login -l
semanage: command not found

Si visteis el artículo que hice hace un tiempo sobre trucos de yum recordaréis que con “whatprovides” podemos encontrar rápidamente el paquete que contiene un determinado binario/fichero:

# yum whatprovides */semanage
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: sunsite.rediris.es
 * extras: sunsite.rediris.es
 * updates: sunsite.rediris.es
libsemanage-devel-2.0.43-4.el6.i686 : Header files and libraries used to build
                                    : policy manipulation tools
Repo        : base
Matched from:
Filename    : /usr/include/semanage

policycoreutils-python-2.0.83-19.1.el6.i686 : SELinux policy core python
                                            : utilities
Repo        : base
Matched from:
Filename    : /usr/sbin/semanage

policycoreutils-python-2.0.83-19.8.el6_0.i686 : SELinux policy core python
                                              : utilities
Repo        : updates
Matched from:
Filename    : /usr/sbin/semanage

Así que instalamos el paquete (y sus dependencias) y listo:

# yum install policycoreutils-python-2.0.83-19.1.el6.i686

# semanage login -l

Login Name         SELinux User           MLS/MCS Range            

__default__               unconfined_u              s0-s0:c0.c1023
root                      unconfined_u              s0-s0:c0.c1023
system_u                  system_u                  s0-s0:c0.c1023

Existe la posibilidad de que llegue un día, arranquemos uno de nuestros sistemas GNU/Linux y en el momento en el que deberíamos visualizar el menú de Grub con los sistemas y Kernel disponibles para arrancar nos encontremos con esto:

grub>

Antes de entrar en modo pánico debemos tener unas nociones básicas que nos permiten arrancar un sistema manualmente desde Grub cuando su fichero de configuración ha sido borrado o está vacío/incorrecto. Básicamente se trata de construir y ejecutar manualmente las líneas que componen cada entrada en el fichero grub.conf o menu.lst. El siguiente ejemplo práctico ha sido realizado sobre un sistema CentOS (RHEL, Fedora, etc) con el fichero /etc/grub.conf | /boot/grub/grub.conf eliminado.

Bien, para arrancar el sistema de forma correcta tenemos que establecer una secuencia de tres comandos en la que especifiquemos lo siguiente:

Partición que contiene el kernel

Una vez que estemos en la shell de Grub, si ejecutamos el comando root a secas nos dirá la partición en la cual se encuentra el/los kernel (podéis usar [TAB] para ver los comandos disponibles:

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

Ya sabemos que la partición que contiene el kernel, imágenes initrd y demás es la (hd0,0), podemos navegar por ella usando el comando find y haciendo uso de la tabulación para el auto-completado de nombres, lo verificamos:

grub> find (hd0,0)/ <- presionad [TAB]
 Possible files are: lost+found grub efi initramfs-2.6... vmlinux-2.6.....

Una vez verificado ejecutamos el siguiente comando (normalmente no es necesario ya que como vemos anteriormente lo detecta automáticamente):

grub> root (hd0,0)

Especificar el kernel y ruta al filesystem

grub> kernel /vmlinuz-2.6.32-71.el6.i686  ro root=/dev/sda1

Ya sabemos que el kernel está en /vml* así que lo especificamos como veis en la línea superior, usad el auto completado con [TAB] para no tener que escribir todo el nombre. Especificamos que en primera instancia se tiene que arrancar en modo lectura (ro) y finalmente la ruta a la partición root de nuestro sistema (dev/sda1). La partición root es la que contiene /sbin/init, también se puede especificar mediante el UUID. Si no sabemos cual es podemos localizarla con el siguiente comando:

grub> find /sbin/init
 (hd0,1)

(hd0,1)=/dev/sda2

Otra forma sería consultando el fichero fstab:

grub> cat (hd0,1)/etc/fstab

Ubicación del Initial RAM disk

El RAM disk se encuentra en la misma ruta/partición que el kernel:

grub> initrd /initramfs-2.6.32-71.el6.i686.img

Secuencia completa para arrancar el sistema

Haciendo un resumen y añadiendo el último comando para arrancar el sistema (boot) quedaría así:

grub> root (hd0,0)
grub> kernel /vmlinuz-2.6.32-71.el6.i686  ro root=/dev/sda1
grub> initrd /initramfs-2.6.32-71.el6.i686.img
grub> boot

Si todo va bien, debería arrancar sin problemas el sistema. Una vez dentro podréis restaurar el Grub con tranquilidad.

Uno de los cambios importantes que hemos encontrado con la salida de Red Hat Enterprise Linux 6 y por consiguiente CentOS 6 es el cambio del sistema de arranque de los servicios. El nuevo sistema tiene por nombre Upstart y reemplaza al que nos acompañó durante muchos años, System V.

Una de las principales diferencias entre System V y Upstart es que el primero trabaja de forma sincrona mientras que Upstart lo hace de forma asíncrona, es decir, no arranca/para un servicio después de otro sino que puede hacerlo en paralelo. Esto implica un aumento considerable de la velocidad de arranque y evita que un servicio tenga esperar a que otro termine para poder arrancar. Otra característica interesante de Upstart es que tiene la capacidad de supervisar los servicios mientras el sistema está funcionando. Upstart también es compatible con los scripts de arranque del sistema System V por lo cual la migración de un sistema a otro es más sencilla.

Los scripts de arranque basados en System V seguirán emplazados en /etc/init.d, mientras que los basados en Upstart debemos añadirlos en /etc/init/*.conf. Podemos ver un ejemplo de la sintaxis utilizada revisando cualquiera de los que ahí se encuentran. De momento podréis ver que únicamente hay scripts propios de sistema, los servicios siguen teniendo sus scripts de arranque en init.d. Vamos a crear un script sencillo para que veáis su funcionamiento. Básicamente queremos que un script propio de prueba esté siempre corriendo, que arranque en el runlevel 3 y que si cae se levante de forma automática:

vim /etc/init/test.conf

#
# Este servicio arranca y monitoriza nuestro script test.sh.
start on runlevel 3

respawn
respawn limit 15 5
exec sh /root/test.sh

Mediante “respawn” especificamos que en caso de que el servicio termine de forma inesperada, Upstart intente levantarlo. Después, con “respawn limit” especificamos el número de intentos y durante cuanto tiempo. En caso de pasar ese tiempo/número de intentos dejaría de intentarlo y el servicio quedaría detenido.

Arrancamos el servicio con el comando initctl:

# initctl start test
test start/running, process 1581

Si matamos el script, veremos en el log /var/log/messages como automáticamente lo levanta. En caso de tener 10 intentos fallidos durante 5 segundos (especificado en el script) dejaría de intentarlo y el script quedaría parado:

# kill 1581
# tail -2 /var/log/messages
Oct 30 19:18:45 server1 init: test main process (1581) killed by TERM signal
Oct 30 19:18:45 server1 init: test main process ended, respawning

Podéis encontrar más información sobre initctl en la salida de ayuda del propio comando, páginas man, etc. También de init:

# initctl help
Job commands:
  start                       Start job.
  stop                        Stop job.
  restart                     Restart job.
  reload                      Send HUP signal to job.
  status                      Query status of job.
  list                        List known jobs.

Event commands:
  emit                        Emit an event.

Other commands:
  reload-configuration        Reload the configuration of the init daemon.
  version                     Request the version of the init daemon.
  log-priority                Change the minimum priority of log messages from the init daemon
  help                        display list of commands

For more information on a command, try `initctl COMMAND --help'.

# man init
# man initctl

El otro día tuvimos que instalar software de 32 bits en una máquina virtual de Debian de 64 bits. Tras la instalación encontramos problemas con dependencias incumplidas que hacían referencia a librerías de 32 bits que no se encontraban instaladas en el sistema. A partir de ahí, gracias a getlibs (¡y a Ángel!) pudimos instalar de forma sencilla todas las librerías necesarias. Todo ello debido a que dicho software no disponía de versión para Debian en 64 bits.

Lo primero que hicimos fue descargar e instalar getlibs:

$ wget http://frozenfox.freehostia.com/cappy/getlibs-all.deb
$ sudo dpkg -i getlibs-all.deb

Después sólo queda ejecutar getlibs seguido de la ruta al binario que da problemas para que automáticamente podamos resolver todas las dependencias:

$ getlibs
Usage: getlibs /path/to/binary
       getlibs -l i386librarytoinstall.so
       getlibs -p i386packagename
       getlibs -w www.website.com/i386package.deb
       getlibs -i /home/alex/i386package.deb
       See 'man getlibs' for more commands

Existen una serie de runlevels que nos permiten arrancar un sistema Linux con distintas características según nuestras necesidades. En el anterior enlace los tenéis detallados. En anteriores versiones de RHEL, CentOS y derivados cuando necesitábamos acceder al sistema en modo emergencia (sin necesidad de especificar la clave de root y sin los sistemas de ficheros montados en modo RW) añadíamos a la línea de arranque que se le pasa al kernel en el grub el parámetro emergency. Este parámetro ya no se usa y se ha pasado a utilizar dos variantes.

En primer lugar, hay que decir que para acceder cambiando el runlevel hay que añadir a la línea de comando que se pasa al kernel el número del runlevel. Para ello, en el grub presionamos la letra a y añadimos el número del runlevel:

Presionamos ‘a’ para añadir un parámetro nuevo a la línea y ya podemos añadir el runlevel deseado.

Para RHEL 6, CentOS6 y derivados, en lugar de emergency tenemos dos opciones para entrar en modo emergencia:

• single: Modo single user, el arranque será como el runlevel 1 pero sin ejecutar los scripts de arranque en /etc/rc1.d
• init=/bin/sh: Este sería el equivalente al modo emergencia, no ejecuta ningún script de arranque e únicamente monta la partición raíz (/) en modo lectura.

Si queremos ver el proceso de arranque, podemos quitar de la línea las palabras rhgb quiet (arranque gráfico). Para entrar en modo emergencia quedaría una línea como la de la siguiente imagen. Presionamos ENTER y arrancará el sistema:

Para un usuario medio de GNU/Linux e incluso para la mayoría de usuarios avanzados, las posibilidades que nos ofrecen el sistema de permisos y propietario estándar es más que suficiente. No obstante, conviene conocer el sistema de listas de control de acceso, conocido comúnmente como ACL (Access Control List) que nos permite extender estos permisos a nivel de ficheros y directorios.

Estas ACL permiten definir permisos concretos para un determinado usuario o grupo en ficheros y directorios, además, se asignan igual que los permisos estándar, con formato octal o simbólico (rwx). Básicamente, en caso de tener un fichero o directorio con unos permisos concretos determinados para su propietario y grupo, nos permite añadir usuarios o grupos extra con unos permisos completamente independientes a los definidos con los permisos estándar.

Activar ACL en el sistema de ficheros

Verificamos con el comando tune2fs si el sistema de ficheros sobre el que queremos tener ACL tiene activado ACL:

# tune2fs -l /dev/mapper/VolGroup00-LogVol00 | grep acl
Default mount options:    user_xattr acl

En caso de no aparecer la opción, tendríamos que remontar el filesystem añadiendo la flag, para hacerlo persistente habría que añadirla en el /etc/fstab.

[root@cluster01 ~]# mount -o remount,acl /
# mount
/dev/mapper/VolGroup00-LogVol00 on / type ext3 (rw,acl)

Ver y cambiar las ACL en ficheros/directorios

Para listar los permisos genéricos de un fichero o directorio y las ACL utilizamos el comando getfacl

# getfacl prueba.tmp
# file: prueba.tmp
# owner: root
# group: root
user::rw-
group::r--
other::r--

El fichero prueba.tmp no tiene ACL establecidas, sólo vemos los permisos estándar. Para comenzar a añadir permisos de ACL utilizamos el comando setfacl. En la página man encontramos información relativa a la sintaxis y formato para el cambio de permisos en usuarios y grupos, máscara y otros:

      [d[efault]:] [u[ser]:]uid [:perms]
              Permissions of a named user. Permissions of the file owner if uid is empty.

       [d[efault]:] g[roup]:gid [:perms]
              Permissions of a named group. Permissions of the owning group if gid is empty.

       [d[efault]:] m[ask][:] [:perms]
              Effective rights mask

       [d[efault]:] o[ther][:] [:perms]
              Permissions of others.

Vamos a ver algún ejemplo. En este primer caso vamos a asignar permiso total (777) al usuario foo contra el fichero anterior, del cual es propietario root.

# setfacl -m u:foo:7 prueba.tmp

Y ahí lo tenemos, con sus permisos especiales asignados con ACL:

# getfacl prueba.tmp 
# file: prueba.tmp
# owner: root
# group: root
user::rw-
user:foo:rwx
group::r--
mask::rwx
other::r--

También los podemos asignar con notación simbólica en lugar de octal, vamos a cambiarlo a únicamente lectura para foo:

# setfacl -m u:foo:r prueba.tmp
# getfacl prueba.tmp 
# file: prueba.tmp
# owner: root
# group: root
user::rw-
user:foo:r--
group::r--
mask::r--
other::r--

Si nos fijamos, al listar el fichero con un ls vemos que ha aparecido un ‘+’ indicando que hay ACLs asignadas:

# ll prueba.tmp
-rw-r--r--+ 1 root root 0 Sep 28 17:32 prueba.tmp

Si con el parámetro ‘-m’ cambiabamos las ACL, con ‘-x’ las borramos para un usuario concreto, y con ‘-b’ para todas las asignadas al fichero:

# setfacl -x u:foo prueba.tmp
# setfacl -b prueba.tmp

A la hora de asignar ACL para directorios, resulta interesante poder asignar unas ACL por defecto para todas aquellos subdirectorios que se vayan creando, así como los ficheros que contenga y se vayan metiendo. Vamos a asignar permiso total al usuario foo para el directorio prueba, es prácticamente igual que con ficheros pero añadiendo la ‘d’ de default:

# setfacl -m d:u:foo:rwx testdir

Nota: Sólo a los directorios se les puede añadir ACLs por defecto, si lo hacéis en ficheros:

# setfacl -m d:u:foo:rwx test
setfacl: /root/test: Only directories can have default ACLs

Si revisamos las ACL del directorio vemos asignados todos los default, podríamos también cambiarlo para el propietario, el grupo y ‘otros’ además de para los nuevos usuarios que añadamos vía ACL:

# getfacl testdir/
# file: testdir
# owner: root
# group: root
user::rwx
group::r-x
other::r-x
default:user::rwx
default:user:foo:rwx
default:group::r-x
default:mask::rwx
default:other::r-x

Espero que esta introducción a las ACL en GNU/Linux os haya sido de utilidad, es un mundo poco explorado pero lleno de posibilidades.

Cuando en nuestro sistema conviven una buena cantidad de usuarios y grupos, y queremos ‘mantener el orden’ en lo referente a el espacio usado por cada uno de ellos, tenemos la opción de activar el sistema de cuotas/quotas a nivel de sistema de ficheros de modo que podamos personalizar por usuario y grupo el espacio máximo o número de inodos que pueden utilizar.

Activación e inicialización de quotas

Lo primero que debemos averiguar es si nuestro sistema es compatible con las quotas, para ello, por un lado deberíamos tener instalado el paquete quota, en RHEL, CentOS y derivados lo podemos verificar así:

# rpm -qa | grep quota
quota-3.13-4.el5

Si está instalado, el próximo paso es saber si la partición o sistema de ficheros sobre el que queremos activar quotas tiene los flags correspondientes que lo activan (usrquota,grpquota):

# mount
/dev/mapper/VolGroup00-LogVol00 on / type ext3 (rw,acl)

Si no lo tiene, como es el caso anterior, lo activamos remontando el sistema de ficheros así:

# mount -o remount,usrquota,grpquota /
# mount
/dev/mapper/VolGroup00-LogVol00 on / type ext3 (rw,acl,usrquota,grpquota)

Para que esto tenga efecto tras el reinicio tendréis que añadir las flags al fichero /etc/fstab:

/dev/VolGroup00/LogVol00 /                       ext3    defaults,usrquota,grpquota       1 1

Ahora podemos usar quotas en /, únicamente nos falta inicializarlas, para ello utilizamos el comando quotacheck, que hace un escaneo de las quotas asignadas a grupos y usuarios, y en caso de que sea la primera vez, crea los ficheros de quota para usuarios y grupos. Veréis aparecen errores, es normal al ser la primera vez ya que no existen:

# quotacheck -cgumv /
quotacheck: Scanning /dev/mapper/VolGroup00-LogVol00 [/] quotacheck: Cannot stat old user quota file: No such file or directory
quotacheck: Cannot stat old group quota file: No such file or directory
quotacheck: Cannot stat old user quota file: No such file or directory
quotacheck: Cannot stat old group quota file: No such file or directory
done
quotacheck: Checked 4266 directories and 31262 files
quotacheck: Old file not found.
quotacheck: Old file not found.

Los parámetros son:

• -c: Escaneo del sistema de ficheros en busca de quotas
• -g: Busca quotas de grupos
• -u: Busca quotas de usuarios
• -m: No intenta hacer un remount en sistemas read-only
• -v: Verbose

Tras el escaneo, podemos activar las quotas en el sistema de ficheros elegido (-u de usuario, -g de grupo y -v de verbose):

# quotaon -ugv /
/dev/mapper/VolGroup00-LogVol00 [/]: group quotas turned on
/dev/mapper/VolGroup00-LogVol00 [/]: user quotas turned on

Asignación de quota a usuarios o grupos

A la hora de editar las quotas podemos hacerlo de dos formas, directamente desde la línea de comandos con setquota o editando el fichero correspondiente con edquota, vamos a ver las dos formas.

Asignamos una quota de 250M de soft limit, 300 de hard limit y sin límite de inodos al usuario foo en /:

# setquota -u foo 256000 307200 0 0 /

O lo hacemos con edquota:

# edquota foo
Disk quotas for user foo (uid 10000):
  Filesystem                   blocks       soft       hard     inodes     soft     hard
  /dev/mapper/VolGroup00-LogVol00    1068920     256000     307200      35408        0        0

Para visualizar el estado de las quotas de un usuario o grupo, utilizamos quota -v:

# quota -v foo
Disk quotas for user foo (uid 10000):
     Filesystem  blocks   quota   limit   grace   files   quota   limit   grace
/dev/mapper/VolGroup00-LogVol00
                1068920* 256000  307200   6days   35407       0       0

Para los grupos es igual, pero utilizando el parámetro -g:

# edquota -g grupo
# setquota -g grupo 256000 307200 0 0 /

También podéis ver distintos reportes con el comando repquota. Reportes de todos los usuarios, todos los grupos, todo un sistema de ficheros, etc:

# repquota -v /
*** Report for user quotas on device /dev/mapper/VolGroup00-LogVol00
Block grace time: 7days; Inode grace time: 7days
Block limits                File limits
User            used    soft    hard  grace    used  soft  hard  grace
----------------------------------------------------------------------
root      +- 1068920  256000  307200  6days   35407     0     0
daemon    --      20       0       0              3     0     0
nobody    --       4       0       0              1     0     0

# repquota -vg /
*** Report for group quotas on device /dev/mapper/VolGroup00-LogVol00
Block grace time: 7days; Inode grace time: 7days
                        Block limits                File limits
Group           used    soft    hard  grace    used  soft  hard  grace
----------------------------------------------------------------------
root      -- 1066300       0       0          35348     0     0
daemon    --      28       0       0              4     0     0
tty       --      28       0       0              2     0     0
disk      --       4       0       0              1     0     0
mail      --     220       0       0              7     0     0
man       --     256       0       0             32     0     0

Algo a tener en cuenta son los ‘periodos de gracia’ o dicho de otro modo, el tiempo que dejamos al usuario o al grupo pasar el soft-limit sin que suceda nada. Lo podemos modificar utilizando el parámetro -t. Podemos ver la configuración y/o modificarla así para todos los usuarios y grupos:

# edquota -t
Grace period before enforcing soft limits for users:
Time units may be: days, hours, minutes, or seconds
  Filesystem             Block grace period     Inode grace period
  /dev/mapper/VolGroup00-LogVol00                  7days                  7days

Por defecto son 7 días, tanto para inodos como para bloques. Si quisieramos modificarlo de forma individual sería con la T mayúscula, y añadiendo la g si es para grupos:

# edquota -t foo
# edquota -tg grupo

Si lo hacemos con setquota, tendremos que especificar el tiempo en segundos:

Para un usuario:

# setquota -uT foo 20000 20000 /

Para un grupo:

# setquota -ug grupo 20000 20000 /

Y para todos los usuarios:

# setquota -ut 20000 20000 /

Deshabilitar quotas

Podemos deshabilitar las quotas del sistema de ficheros o en general con el comando quotaoff:

Para todos los filesystems:

# quotaoff -av
/dev/mapper/VolGroup00-LogVol00 [/]: group quotas turned off
/dev/mapper/VolGroup00-LogVol00 [/]: user quotas turned off

O para uno en concreto:

# quotaoff -av /
/dev/mapper/VolGroup00-LogVol00 [/]: group quotas turned off
/dev/mapper/VolGroup00-LogVol00 [/]: user quotas turned off

Vamos a ver como crear un RAID 1 (espejo) por software entre dos discos extra añadidos a un sistema CentOS o RHEL. Este sistema nos ofrece total redundancia de datos a expensas de utilizar el doble de espacio en disco. En caso de disponer una controladora para hacer el RAID por hardware lógicamente es más recomendable que esta opción, ya que el rendimiento es mucho mejor.

Vamos a partir de la base de que además del disco que engloba el sistema, tenemos dos discos más disponibles para trabajar:

# fdisk -l | egrep -e "hdb|hdd"
Disk /dev/hdb doesn't contain a valid partition table
Disk /dev/hdd doesn't contain a valid partition table
Disk /dev/hdb: 1073 MB, 1073741824 bytes
Disk /dev/hdd: 1073 MB, 1073741824 bytes

Creación del RAID 1

Lo primero que tenemos que hacer es configurar dos particiones, una en cada disco y del tipo RAID AUTODETECT (fd). Aquellos que tengáis dudas con este paso, revisad este artículo: crear y eliminar particiones con fdisk en Linux

Haríamos este paso en ambos discos:

# fdisk /dev/hdd
Device contains neither a valid DOS partition table, nor Sun, SGI or OSF disklabel
Building a new DOS disklabel. Changes will remain in memory only,
until you decide to write them. After that, of course, the previous
content won't be recoverable.

The number of cylinders for this disk is set to 2080.
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)
Warning: invalid flag 0x0000 of partition table 4 will be corrected by w(rite)

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):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-2080, default 2080):
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): w
The partition table has been altered!

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

El resultado hasta el momento sería esto (omitiendo el disco de sistema):

# fdisk -l

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

Disk /dev/hdd: 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/hdd1               1        2080     1048288+  fd  Linux raid autodetect

Ahora ya podemos hacer uso del comando mdadm para crear el RAID 1 entre las particiones configuradas en ambos discos. Especificamos con -v la opción verbose, -C significa la creación del raid seguido del nombre asignado al array /dev/md0 y le indicamos que los dos discos serán activos (-n 2), podríamos asignar discos spare con -x. Finalmente especificamos los dispositivos a configurar en el array (las dos particiones creadas antes) y especificamos que es un RAID 1 con -l 1:

# mdadm -v -C /dev/md0 -n 2 /dev/hdb1 /dev/hdd1 -l 1
mdadm: size set to 1048192K
mdadm: array /dev/md0 started.

Monitorizar y gestionar el RAID

Podemos ver el estado del RAID en cualquier comento con mdadm –detail seguido del RAID a revisar:

# mdadm --detail /dev/md0
/dev/md0:
        Version : 0.90
  Creation Time : Tue Sep 27 18:02:46 2011
     Raid Level : raid1
     Array Size : 1048192 (1023.80 MiB 1073.35 MB)
  Used Dev Size : 1048192 (1023.80 MiB 1073.35 MB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Tue Sep 27 18:03:33 2011
          State : clean
 Active Devices : 2
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 0

           UUID : 9a7817d8:038050a4:82a2f37d:414f679e
         Events : 0.2

    Number   Major   Minor   RaidDevice State
       0       3       65        0      active sync   /dev/hdb1
       1      22       65        1      active sync   /dev/hdd1

En caso de que uno de los discos fallase, habría que sacar del raid el disco fallido y reemplazarlo por otro, con el cual habría que seguir todos los pasos anteriores para prepararlo.

Forzamos el disco como fallido para hacer la prueba:

# mdadm /dev/md0 -f /dev/hdd1
mdadm: set /dev/hdd1 faulty in /dev/md0

Si ahora hicieramos un mdadm -D /dev/md0 veríamos el fallo del disco y el estado degraded:

# mdadm --detail /dev/md0
/dev/md0:
        Version : 0.90
  Creation Time : Tue Sep 27 18:02:46 2011
     Raid Level : raid1
...
...
...
          State : clean, degraded
 Number   Major   Minor   RaidDevice State
       0       3       65        0      active sync   /dev/hdb1
       1       0        0        1      removed

       2      22       65        -      faulty spare   /dev/hdd1

Sacamos el disco fallido del raid:

# mdadm /dev/md0 -r /dev/hdd1
mdadm: hot removed /dev/hdd1

Ahora el estado seguiría siendo degraded pero sin el disco fallido, así que sólo quedaría añadir un nuevo disco para que el RAID se reconstruyera:

# mdadm /dev/md0 -a /dev/hdd1
mdadm: re-added /dev/hdd1

Y automáticamente debería activarse el rebuild/recover y sincronizar la información entre ambos discos:

# mdadm -D /dev/md0
/dev/md0:
        Version : 0.90
  Creation Time : Tue Sep 27 18:02:46 2011
     Raid Level : raid1
     Array Size : 1048192 (1023.80 MiB 1073.35 MB)
  Used Dev Size : 1048192 (1023.80 MiB 1073.35 MB)
   Raid Devices : 2
  Total Devices : 2
Preferred Minor : 0
    Persistence : Superblock is persistent

    Update Time : Tue Sep 27 18:12:32 2011
          State : clean, degraded, recovering
 Active Devices : 1
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 1

 Rebuild Status : 44% complete

           UUID : 9a7817d8:038050a4:82a2f37d:414f679e
         Events : 0.6

    Number   Major   Minor   RaidDevice State
       0       3       65        0      active sync   /dev/hdb1
       1      22       65        1      spare rebuilding   /dev/hdd1

Eliminar un RAID

Para eliminar un RAID antes hay que pararlo, y posteriormente destruirlo:

# mdadm -vS /dev/md0
mdadm: stopped /dev/md0
# mdadm -vr /dev/md0

A partir de aquí, pues únicamente quedaría dar formato a /dev/md0 con el sistema de ficheros que necesitéis y gestionarlo como un sistema de ficheros normal.

Esquema raid: dis.um.es