Configurare RAID1 e preparare il sistema per il boot

4 Creare i nostri array RAID

Ora creiamo gli array RAID /dev/md0, /dev/md1 e /dev/md2. Aggiungeremo /dev/sdb1 a /dev/md0, /dev/sdb2 a /dev/md1 e /dev/sdb3 a /dev/md2. Le partizioni /dev/sda1, /dev/sda2 e /dev/sda3 non possono essere aggiunte al momento perché il sistema è avviato su di esse. Per questo useremo il placeholder missing nei tre comandi seguenti.

Esegui i comandi:

mdadm --create /dev/md0 --level=1 --raid-disks=2 missing /dev/sdb1
mdadm --create /dev/md1 --level=1 --raid-disks=2 missing /dev/sdb2
mdadm --create /dev/md2 --level=1 --raid-disks=2 missing /dev/sdb3

Dopo aver creato gli array, controlla lo stato con:

cat /proc/mdstat

L’output dovrebbe indicare tre array RAID degradati. Nel formato di /proc/mdstat, [U] o [U] indica un array degradato, mentre [UU] indica che l’array è sano:

[root@server1 ~]# cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md2 : active raid1 sdb3[1]
9759360 blocks [2/1] [_U]

md1 : active raid1 sdb2[1]
522048 blocks [2/1] [_U]

md0 : active raid1 sdb1[1]
200704 blocks [2/1] [_U]

unused devices: 
[root@server1 ~]#

Nota: l’array è degradato perché manca una delle due partizioni; questo è previsto finché non si aggiunge la controparte (/dev/sdaX) dopo il reboot o la sostituzione disco.

Importante: prima di procedere, assicurati di avere backup validi dei dati critici. La procedura manipola partizioni di avvio e root; un errore può rendere il sistema non avviabile.

Creare file system sugli array

Creiamo i file system su /dev/md0 e /dev/md2 (ext3) e configuriamo /dev/md1 come swap:

mkfs.ext3 /dev/md0
mkswap /dev/md1
mkfs.ext3 /dev/md2

Questi comandi sono distruttivi per i contenuti attuali sulle partizioni mirate. Assicurati ancora una volta del backup.

Salvare la configurazione mdadm

Genera /etc/mdadm.conf con gli UUID attuali degli array:

mdadm --examine --scan > /etc/mdadm.conf

Visualizza il file:

cat /etc/mdadm.conf

Nel file dovresti vedere le righe che descrivono i tre array (UUID e proprietà):

ARRAY /dev/md0 level=raid1 num-devices=2 UUID=78d582f0:940fabb5:f1c1092a:04a55452
ARRAY /dev/md1 level=raid1 num-devices=2 UUID=8db8f7e1:f2a64674:d22afece:4a539aa7
ARRAY /dev/md2 level=raid1 num-devices=2 UUID=1baf282d:17c58efd:a8de6947:b0af9792

Questa configurazione permette a mdadm di ricostruire gli array automaticamente al boot.

5 Adattare il sistema a RAID1

Adesso montiamo /dev/md0 e /dev/md2 (non serve montare l’array di swap /dev/md1):

mkdir /mnt/md0
mkdir /mnt/md2

mount /dev/md0 /mnt/md0
mount /dev/md2 /mnt/md2

Verifica con:

mount

Esempio di output:

[root@server1 ~]# mount
/dev/sda3 on / type ext3 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
/dev/sda1 on /boot type ext3 (rw)
tmpfs on /dev/shm type tmpfs (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
/dev/md0 on /mnt/md0 type ext3 (rw)
/dev/md2 on /mnt/md2 type ext3 (rw)
[root@server1 ~]#

Ora modifichiamo /etc/fstab per montare gli array RAID al boot. Sostituisci LABEL=/boot con /dev/md0, LABEL=SWAP-sda2 con /dev/md1 e LABEL=/ con /dev/md2. Il file aggiornato dovrebbe apparire così:

/dev/md2                 /                       ext3    defaults        1 1
/dev/md0                 /boot                   ext3    defaults        1 2
tmpfs                   /dev/shm                tmpfs   defaults        0 0
devpts                  /dev/pts                devpts  gid=5,mode=620  0 0
sysfs                   /sys                    sysfs   defaults        0 0
proc                    /proc                   proc    defaults        0 0
/dev/md1                swap                    swap    defaults        0 0

Salva /etc/fstab e poi aggiorna /etc/mtab (riflette lo stato corrente dei mount). Sostituisci /dev/sda1 con /dev/md0 e /dev/sda3 con /dev/md2 in /etc/mtab:

/dev/md2 / ext3 rw 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
devpts /dev/pts devpts rw,gid=5,mode=620 0 0
/dev/md0 /boot ext3 rw 0 0
tmpfs /dev/shm tmpfs rw 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0

Aggiornare GRUB per il fallback e per il root su RAID

Apri /boot/grub/menu.lst e aggiungi fallback=1 subito dopo default=0:

default=0
fallback=1

Questa impostazione fa sì che, se il kernel principale (indice 0) non si avvia, venga tentato il kernel indicato dal fallback (indice 1).

Scorri fino alle voci kernel in fondo al file. Copia la prima voce kernel e inseriscila prima della prima stanza esistente. Modifica root=LABEL=/ in root=/dev/md2 e modifica root (hd0,0) in root (hd1,0). Esempio:

title CentOS (2.6.18-128.el5)
        root (hd1,0)
        kernel /vmlinuz-2.6.18-128.el5 ro root=/dev/md2
        initrd /initrd-2.6.18-128.el5.img

title CentOS (2.6.18-128.el5)
        root (hd0,0)
        kernel /vmlinuz-2.6.18-128.el5 ro root=LABEL=/
        initrd /initrd-2.6.18-128.el5.img

Nel file completo si vedrà che la voce con root (hd1,0) punta a /dev/sdb, che è già parte degli array RAID. Se il boot da RAID fallisce, il fallback consentirà il boot da /dev/sda.

Rigenerare il ramdisk

Aggiorna l’initrd per il kernel corrente, spostando l’originale e creando una nuova immagine:

mv /boot/initrd-`uname -r`.img /boot/initrd-`uname -r`.img_orig
mkinitrd /boot/initrd-`uname -r`.img `uname -r`

Questo garantisce che il nuovo initrd includa i moduli necessari per montare gli array RAID al boot.

Copiare dati su array RAID

Copiamo i contenuti di / su /mnt/md2 e il contenuto di /boot su /mnt/md0:

cp -dpRx / /mnt/md2

Poi:

cd /boot
cp -dpRx . /mnt/md0

Questi comandi preservano permessi, timestamp e collegamenti simbolici (opzioni -dpRx). Il tempo di copia dipende dalla quantità di dati.

6 Preparare GRUB (Parte 1)

Dobbiamo installare il bootloader GRUB anche sul secondo disco (/dev/sdb) per assicurare che il sistema possa avviarsi se /dev/sda fallisce. Avvia la shell di grub:

grub

Nel prompt di GRUB inserisci i comandi seguenti per installare il bootloader su entrambe le unità. Prima imposta la root a (hd0,0):

root (hd0,0)

Esempio di output:

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

grub>

Poi esegui:

setup (hd0)

Output di esempio (controlli di stage, embed e install):

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/grub.conf"... succeeded
Done.

grub>

Ripeti per il secondo disco, impostando root a (hd1,0) e chiamando setup (hd1):

root (hd1,0)
setup (hd1)

Esempio di output:

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

grub>

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/grub.conf"... succeeded
Done.

grub>

Infine esci dalla shell di GRUB:

quit

Torna alla shell normale e riavvia il sistema:

reboot

Al riavvio il sistema tenterà di avviarsi dai nuovi array RAID (ancora degradati). Se l’avvio da RAID fallisce, la voce fallback nel menu GRUB permetterà il boot dalla vecchia configurazione su /dev/sda.

Importante: dopo il reboot e la verifica che il sistema sia avviato correttamente da RAID, aggiungi le partizioni mancanti agli array (ad esempio /dev/sda1 a /dev/md0) usando mdadm –add per ricostruire gli array in modalità RAID1 completa.

Box informativo: numeri chiave dall’esempio

• md0: 200704 blocks, stato [2/1] [_U]
• md1: 522048 blocks, stato [2/1] [_U]
• md2: 9759360 blocks, stato [2/1] [_U]
• Tipo di RAID usato: raid1 (mirroring)

Questi valori sono presi dall’output d’esempio e servono a illustrare lo stato di array degradati.

Checklist operativa (ruoli)

Admin (chi pianifica):

• Verifica backup recenti e testati.
• Pianifica finestra di manutenzione e comunicazione downtime.
• Determina ordini di boot e fallback per GRUB.

Operatore (chi esegue):

• Esegui i comandi mdadm –create con placeholder missing.
• Crea i filesystem e abilita swap come descritto.
• Aggiorna /etc/mdadm.conf, /etc/fstab e /etc/mtab.
• Aggiorna initrd e installa GRUB su entrambi i dischi.
• Copia dati su /dev/md2 e /dev/md0.
• Riavvia e verifica il boot da RAID.

Playbook rapido (SOP)

1. Backup dati.
2. Creare array RAID degradati su /dev/sdbX usando missing.
3. mkfs/mkswap sugli array.
4. mdadm –examine –scan > /etc/mdadm.conf.
5. Montare array su /mnt/md0 e /mnt/md2.
6. Aggiornare /etc/fstab e /etc/mtab.
7. Modificare /boot/grub/menu.lst per fallback e root su /dev/md2.
8. Rigenerare initrd.
9. Copiare filesystem e /boot sugli array.
10. Installare GRUB su /dev/sda e /dev/sdb.
11. Reboot e verifica.
12. Dopo boot corretto, aggiungere le partizioni mancanti agli array e lasciare la resilvering completare.

Problemi comuni e risoluzioni rapide

• Problema: il sistema non si avvia dal RAID dopo il reboot.

  • Controlla che GRUB punti al device corretto (root=/dev/md2) e che fallback sia impostato.
  • verifica /etc/mtab e /etc/fstab.
  • Avvia da live/rescue e monta gli array per controllare i log (/var/log/messages, dmesg).

• Problema: resilvering lento o non avviato.

  • Verifica /proc/mdstat per lo stato di ricostruzione.
  • Controlla I/O e carico sulla macchina; rallentamenti I/O impattano la velocità di resilvering.

• Problema: GRUB non si installa su un disco.

  • Controlla il tipo di partizione (MBR vs GPT) e se il disco richiede una partizione bios-grub.
  • Assicurati che i device siano accessibili e che la partizione /boot sia montata prima del setup.

Decisione: avviare da RAID o fallback (diagramma)

flowchart TD
  A[Start: Dopo la configurazione RAID] --> B{Il sistema si avvia da /dev/md2?}
  B -- Sì --> C[Procedi: Aggiungi /dev/sdaX agli array e attendi resilvering]
  B -- No --> D[Avvia da fallback '/dev/sda']
  D --> E[Controlla /boot/grub/menu.lst e initrd]
  E --> F[Correggi le voci e reinstalla GRUB se necessario]
  F --> G[Reboot e ripeti controllo]

Matrice di rischio e mitigazioni (qualitativa)

• Rischio: perdita di dati per errore umano. Mitigazione: backup verificato e checkpoint prima di operazioni distruttive.
• Rischio: sistema non avviabile dopo modifica GRUB. Mitigazione: installare GRUB su entrambi i dischi e mantenere fallback configurato.
• Rischio: resilvering fallito o lento. Mitigazione: monitorare /proc/mdstat e assicurare risorse I/O adeguate.

Note finali

Dopo il completamento e la verifica del boot da RAID, ricorda di eseguire mdadm –detail /dev/mdX per confermare lo stato e usare mdadm –add /dev/mdX /dev/sdaY per aggiungere le partizioni rimosse inizialmente. Monitora il processo di ricostruzione fino a quando lo stato torna a [UU] per ogni array.

Summary:

• Hai creato array RAID1 degradati con placeholder missing.
• Hai aggiornato fstab, mtab e configurazione GRUB.
• Hai installato GRUB su entrambi i dischi e rigenerato initrd.
• Dopo il reboot, aggiungi le partizioni mancanti agli array per completare il mirroring.