Creare array RAID1, aggiornare fstab e preparare GRUB

4 Creazione dei nostri array RAID

Ora creiamo i nostri array RAID: /dev/md0, /dev/md1 e /dev/md2. Aggiungeremo /dev/hdb1 a /dev/md0, /dev/hdb5 a /dev/md1 e /dev/hdb6 a /dev/md2. Le partizioni /dev/hda1, /dev/hda5 e /dev/hda6 non possono essere aggiunte subito (perché il sistema è in esecuzione su di esse), quindi utilizziamo il placeholder missing nei tre comandi seguenti:

mdadm --create /dev/md0 --level=1 --raid-disks=2 missing /dev/hdb1  
mdadm --create /dev/md1 --level=1 --raid-disks=2 missing /dev/hdb5  
mdadm --create /dev/md2 --level=1 --raid-disks=2 missing /dev/hdb6

Il comando

cat /proc/mdstat

di norma mostrerà che i tre array RAID sono in stato degraded ([U] o [U] indica array degradato, [UU] indica array ok):

[root@server1 ~]# cat /proc/mdstat  
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]  
md2 : active raid1 hdb6[1]  
      4642688 blocks [2/1] [_U]  
  
md1 : active raid1 hdb5[1]  
      417536 blocks [2/1] [_U]  
  
md0 : active raid1 hdb1[1]  
      176576 blocks [2/1] [_U]  
  
unused devices:   
[root@server1 ~]#

Adesso creiamo i filesystem sugli array RAID (ext3 su /dev/md0 e /dev/md2, e swap su /dev/md1):

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

Il file /etc/mdadm.conf non contiene ancora informazioni sui nuovi array; salviamo l’originale e rileviamo gli array per aggiungerli al file:

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

Mostriamo poi il contenuto del file:

cat /etc/mdadm.conf

Nel file dovreste ora trovare i dettagli sui tre array RAID (anche se degradati):

| # mdadm configuration file # # mdadm will function properly without the use of a configuration file, # but this file is useful for keeping track of arrays and member disks. # In general, a mdadm.conf file is created, and updated, after arrays # are created. This is the opposite behavior of /etc/raidtab which is # created prior to array construction. # # # the config file takes two types of lines: # # DEVICE lines specify a list of devices of where to look for # potential member disks # # ARRAY lines specify information about how to identify arrays so # so that they can be activated # # You can have more than one device line and use wild cards. The first # example includes SCSI the first partition of SCSI disks /dev/sdb, # /dev/sdc, /dev/sdd, /dev/sdj, /dev/sdk, and /dev/sdl. The second # line looks for array slices on IDE disks. # #DEVICE /dev/sd[bcdjkl]1 #DEVICE /dev/hda1 /dev/hdb1 # # If you mount devfs on /dev, then a suitable way to list all devices is: #DEVICE /dev/discs/*/* # # # # ARRAY lines specify an array to assemble and a method of identification. # Arrays can currently be identified by using a UUID, superblock minor number, # or a listing of devices. # # super-minor is usually the minor number of the metadevice # UUID is the Universally Unique Identifier for the array # Each can be obtained using # # mdadm -D # #ARRAY /dev/md0 UUID=3aaa0122:29827cfa:5331ad66:ca767371 #ARRAY /dev/md1 super-minor=1 #ARRAY /dev/md2 devices=/dev/hda1,/dev/hdb1 # # ARRAY lines can also specify a "spare-group" for each array. mdadm --monitor # will then move a spare between arrays in a spare-group if one array has a failed # drive but no spare #ARRAY /dev/md4 uuid=b23f3c6d:aec43a9f:fd65db85:369432df spare-group=group1 #ARRAY /dev/md5 uuid=19464854:03f71b1b:e0df2edd:246cc977 spare-group=group1 # # When used in --follow (aka --monitor) mode, mdadm needs a # mail address and/or a program. This can be given with "mailaddr" # and "program" lines to that monitoring can be started using # mdadm --follow --scan & echo $! > /var/run/mdadm # If the lines are not found, mdadm will exit quietly #MAILADDR [email protected] #PROGRAM /usr/sbin/handle-mdadm-events ARRAY /dev/md0 level=raid1 num-devices=2 UUID=6b4f013f:6fe18719:5904a9bd:70e9cee6 ARRAY /dev/md1 level=raid1 num-devices=2 UUID=63194e2e:c656857a:3237a906:0616f49e ARRAY /dev/md2 level=raid1 num-devices=2 UUID=edec7105:62700dc0:643e9917:176563a7 |

5 Adattare il sistema a RAID1

Montiamo /dev/md0 e /dev/md2 (non è necessario montare l’array swap /dev/md1):

mkdir /mnt/md0  
mkdir /mnt/md2

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

Verificate che gli array siano montati con:

mount

Output d’esempio:

[root@server1 ~]# mount  
/dev/hda6 on / type ext3 (rw,relatime)  
none on /proc type proc (rw)  
/dev/hda1 on /boot type ext3 (rw,relatime)  
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)  
/dev/md0 on /mnt/md0 type ext3 (rw)  
/dev/md2 on /mnt/md2 type ext3 (rw)  
[root@server1 ~]#

Modificate /etc/fstab: sostituite /dev/hda1 con /dev/md0, /dev/hda5 con /dev/md1 e /dev/hda6 con /dev/md2 in modo che il file appaia così:

vi /etc/fstab

| /dev/md2 / ext3 relatime 1 1 /dev/md0 /boot ext3 relatime 1 2 /dev/cdrom /media/cdrom auto umask=0022,users,iocharset=utf8,noauto,ro,exec 0 0 /dev/fd0 /media/floppy auto umask=0022,users,iocharset=utf8,noauto,exec,flush 0 0 none /proc proc defaults 0 0 /dev/md1 swap swap defaults 0 0 |

Aggiornate anche /etc/mtab sostituendo /dev/hda1 con /dev/md0 e /dev/hda6 con /dev/md2 (potete ignorare le righe /dev/md già presenti alla fine):

vi /etc/mtab

| /dev/md2 / ext3 rw,relatime 0 0 none /proc proc rw 0 0 /dev/md0 /boot ext3 rw,relatime 0 0 none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0 /dev/md0 /mnt/md0 ext3 rw 0 0 /dev/md2 /mnt/md2 ext3 rw 0 0 |

Ora modifichiamo il boot loader GRUB. Aprite /boot/grub/menu.lst e aggiungete fallback 1 subito dopo default 0:

vi /boot/grub/menu.lst

| [...] default 0 fallback 1 [...] |

Questo imposta un kernel di fallback (se il primo kernel non parte, verrà avviato il secondo nella lista, il conteggio inizia da 0).

Nel medesimo file, andate in fondo dove sono elencati i blocchi kernel. Copiate il primo blocco e incollatelo prima del primo esistente; sostituite root=/dev/hda6 con root=/dev/md2 e (hd0,0) con (hd1,0). Se avete resume=/dev/hda5 nel kernel stanza, sostituitelo con resume=/dev/md1:

| [...] title linux kernel (hd1,0)/vmlinuz BOOT_IMAGE=linux root=/dev/md2 resume=/dev/md1 initrd (hd1,0)/initrd.img title linux kernel (hd0,0)/vmlinuz BOOT_IMAGE=linux root=/dev/hda6 resume=/dev/hda5 initrd (hd0,0)/initrd.img |

Il file completo dovrebbe assomigliare a questo:

| timeout 10 color black/cyan yellow/cyan default 0 fallback 1 title linux kernel (hd1,0)/vmlinuz BOOT_IMAGE=linux root=/dev/md2 resume=/dev/md1 initrd (hd1,0)/initrd.img title linux kernel (hd0,0)/vmlinuz BOOT_IMAGE=linux root=/dev/hda6 resume=/dev/hda5 initrd (hd0,0)/initrd.img title failsafe kernel (hd0,0)/vmlinuz BOOT_IMAGE=failsafe root=/dev/hda6 failsafe initrd (hd0,0)/initrd.img |

Nota: (hd1,0) si riferisce a /dev/hdb, già parte degli array RAID in questo esempio. Riavvieremo il sistema a breve per provare l’avvio da questi array (ancora degradati); in caso di fallimento GRUB userà il fallback verso /dev/hda.

Aggiorniamo l’initrd al nuovo stato:

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

Copiamo il contenuto di / (root) montato su /dev/hda6 nella nuova root su /mnt/md2, e il contenuto di /boot su /mnt/md0:

cp -dpRx / /mnt/md2

cd /boot  
cp -dpRx . /mnt/md0

6 Preparare GRUB (Parte 1)

Ora installiamo il bootloader GRUB sul secondo disco /dev/hdb in modo che sia possibile avviare da entrambe le unità.

Avviate il prompt di GRUB:

grub

All’interno della shell di GRUB digitate i comandi indicati:

root (hd0,0)

Esempio di risposta:

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

Poi eseguite l’installazione su (hd0):

setup (hd0)

Output di esempio:

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>

Ripetete per (hd1,0) e impostate anche su (hd1):

root (hd1,0)

setup (hd1)

quit

Dopo essere tornati alla shell normale, riavviate il sistema per testare l’avvio dagli array RAID:

reboot

Cosa fare se qualcosa va storto — controlli rapidi

Important: prima di procedere create un backup completo del sistema o uno snapshot delle partizioni critiche. Se il sistema non si avvia dopo il cambio, usare una live CD/USB per montare gli array e ripristinare /boot o ripristinare i file /etc/fstab e /etc/mtab dall’originale (/etc/mdadm.conf_orig, /etc/fstab_orig se li avete salvati).

Piccola metodologia (passi essenziali)

1. Identificare partizioni sorgente e destinazione.
2. Creare array RAID con placeholder “missing” per i dischi attivi.
3. Creare filesystem e swap sugli array.
4. Aggiornare /etc/mdadm.conf usando mdadm –examine –scan.
5. Montare gli array e copiare i dati (root e /boot).
6. Aggiornare /etc/fstab e /etc/mtab.
7. Rigenerare initrd e aggiornare GRUB (installare su entrambi i dischi).
8. Testare il boot; verificare cat /proc/mdstat e mount.

Checklist per il ruolo Sysadmin

• Backup completo del sistema e /boot
• Verificare spazio libero su disco target
• Verificare versione di kernel e package mdadm
• Creare gli array con mdadm (comandi di cui sopra)
• Aggiungere righe array in /etc/mdadm.conf
• Aggiornare /etc/fstab e /etc/mtab
• Rigenerare initrd con mkinitrd
• Installare GRUB su entrambi i dischi
• Riavviare e testare; controllare /proc/mdstat

Criteri di accettazione

• Il sistema si avvia correttamente dal nuovo array /dev/md2 (root) senza interventi manuali.
• /dev/md0 è montato su /boot; /dev/md1 è attivo come swap.
• cat /proc/mdstat non mostra errori permanenti; gli array sono in stato [UU] dopo il raddoppio dei dispositivi.
• GRUB è installato su entrambi i dischi e il fallback funziona.

Rischi principali e mitigazioni

• Rischio: perdita di /boot o fs root durante la copia. Mitigazione: backup e test di ripristino su live environment.
• Rischio: GRUB non installato correttamente su entrambe le unità -> non boot. Mitigazione: installare GRUB sequentialmente su entrambi i dischi e verificare con una live.
• Rischio: UUID cambiate/duplicati in /etc/fstab o mdadm.conf. Mitigazione: verificare UUID con blkid e correggere i riferimenti.

Compatibilità e migrazione: note pratiche

• Questa procedura presume un sistema con GRUB legacy (menu.lst). Su sistemi con GRUB2 adattare i comandi (update-grub, grub-install, /boot/grub/grub.cfg).
• Se il sistema usa systemd-boot o altri bootloader, mappare i passaggi equivalenti per installare il bootloader sul secondo disco.

Piccolo glossario (1 riga ciascuno)

• mdadm: strumento da riga di comando per gestire array software RAID su Linux.
• RAID1: mirroring dei dati su due (o più) dischi per tolleranza ai guasti.
• initrd / initramfs: immagine iniziale caricata dal bootloader per avviare il kernel con driver necessari.
• GRUB: bootloader usato per avviare il kernel Linux.

Sintesi

Questa guida fornisce i comandi e le modifiche di configurazione necessarie per creare array RAID1 degradati, copiarvi root e /boot, aggiornare fstab/mtab, rigenerare l’initrd e installare GRUB su più dischi. Seguite la checklist e testate il ripristino prima del deployment in produzione.

Note importanti

• Testate sempre su un ambiente non produttivo prima di applicare in produzione.
• Conservate una copia di /etc/mdadm.conf_orig e /boot/initrd-uname -r.img_orig per rollback.