Abbiamo visto in un precedente articolo (questo, per l’esattezza) le differenze tra i vari livelli RAID con particolare attenzione al RAID10.

Vediamo adesso come “costruire” e gestire un RAID10 via software, cominciando dallo spiegare quando utilizzarlo.

Iniziamo col dire che, sebbene un RAID10 abbia il pregio di una elevata fault-tollerance, non significa che sia un sistema di backup! Ti invito quindi a leggere il relativo articolo riguardante l’importanza di avere un sistema di backup.

Quando serve un RAID10

Detto questo, avremo necessità di un sistema RAID10 se:

  • abbiamo bisogno di alta affidabilità, alta tolleranza ai guasti e prestazioni elevate sia in scrittura che in lettura
  • useremo il disco “logico” per una condivisione Samba o Nfs o simili
  • useremo il disco per archiviare database o siti web

Riguardo al primo punto abbiamo già visto come e perchè nell’articolo precedente.
Per ciò che riguarda il secondo punto e/o il terzo, diciamo che la velocità di lettura e scrittura del sistema, molto migliore di qualsiasi altra configurazione RAID, è però adatta per file relativamente piccoli che, tecnicamente, possono occupare qualche chunk. Il chunk è la suddivisione dello spazio sui dischi RAID. Tipicamente è di 64k, 128k, 256k o 512k ed essendo un parametro configurabile ecco che capiamo bene l’uso adatto a file “piccoli” come pagine web, immagini, database ecc.
Nulla toglie ovviamente di usare RAID10 anche come configurazione sui NAS di backup, dove più che la velocità di lettura o scrittura conta molto di più l’affidabilità.

Passiamo ora allo studio e alla comprensione di come creare e gestire un RAID10 software.

Come creare un array RAID

Sui sistemi Linux (server) è installato ormai ovunque il comando mdadm che è quello che ci serve per effettuare ogni operazione su un RAID.

Iniziamo dalle basi, cioè “costruiamo” un RAID10. Resta inteso che da ora in avanti tutti i comandi devono essere eseguiti come “root”.

…evitiamo casini…

Per evitare casini e fare pratica, vi consiglio di usare dei dischi loop…cioè, veri finti dischi…o finti dischi veri…
Allora, creiamo 6 “dischi”

dd if=/dev/zero of=/tmp/test0 bs=1M count=200
dd if=/dev/zero of=/tmp/test1 bs=1M count=200
dd if=/dev/zero of=/tmp/test2 bs=1M count=200
dd if=/dev/zero of=/tmp/test3 bs=1M count=200
dd if=/dev/zero of=/tmp/test4 bs=1M count=200
dd if=/dev/zero of=/tmp/test5 bs=1M count=200

Ora creiamo i device veri e propri

losetup /dev/loop10 /tmp/test0
losetup /dev/loop11 /tmp/test1
losetup /dev/loop12 /tmp/test2
losetup /dev/loop13 /tmp/test3
losetup /dev/loop14 /tmp/test4
losetup /dev/loop15 /tmp/test5

E ora useremo questi device “veri ma finti” così da non danneggiare i dischi reali in casi di problemi durante i test e soprattutto non dover attendere eoni per le sincronizzazioni dei dischi! :-)

Sintassi base

Fatto questo, passiamo alla sintassi base per creare un RAID, che è la seguente:

mdadm –create device –chunk=X –level=Y –raid-devices=Z devices

Facile, praticamente non necessita spiegazioni ma, nel dubbio, meglio non avere dubbi.
device sarà il nome del nostro device (cioè “come” sarà chiamato e accessibile all’interno di /dev/, quindi per esempio mdadm –create /dev/mdTest)
–chunk indica la dimensione del chunk, come detto sopra, espresso in Kb (quindi 64, 128 ecc)
–level indica il livello RAID da creare (0, 1, 5, 6, 10 ecc)
–raid-devices indica il NUMERO di dischi ATTIVI (es per RAID5 da 4 dischi di cui uno spare, indicheremo 3, ovvero –raid-devices=3 e lo spare lo indicheremo con un aggiuntiva opzione –spare-devices=1. Se invece il RAID5 avrà esattamente 4 dischi e nessuno spare, allora useremo solo l’opzione –raid-devices=4)
devices invece indica materialmente gli hard disk (fisici o logici) da usare indicati sia come “interi” sia come singole partizioni, a patto che siano o tutte partizioni o tutti dischi interi.
OK: /dev/sda /dev/sdb /dev/dsc
OK: /dev/sda2 /dev/sdc2
NON OK: /dev/sda1 /dev/sdb /dev/sdc

Una volta creato l’array, prima che sia assemblato, i dischi verranno controllati per verificare se facevano già parte di un array (e quindi saremo avvisati di questo per evitare danni non voluti) e sarà verificato che la differenza di “spazio” tra i membri dell’array sia inferiore al 1%.

Se volete maggiori informazioni sull’uso del comando vi basterà il classico comando “programma –opzione –help”:

mdadm –create –help
mdadm –assemble –help
…

Ora…in base a ciò che abbiamo detto nell’articolo riguardante gli array RAID, se abbiamo 4 dischi per creare il nostro array RAID10 sarà sufficiente un comando come questo

mdadm –create /dev/md/TestVolumeRaid10_finale –chunk=128 –level=10 –raid-devices=4 /dev/loop10 /dev/loop11 /dev/loop12 /dev/loop13

Passare alla sezione Passaggi finali se siete a posto così….

“Vero” RAID1+0

MA …. se vogliamo avere una maggiore tolleranza ai guasti E abbiamo i famosi 6 dischi E non ci interessa sfruttare tutto lo spazio disco sfruttabile ALLORA dovremo fare diversamente.

Prima creiamo i due RAID1, poi li assembliamo come RAID0.
L’unico “inconveniente” di questa formula è che per vedere lo stato dell’Array “globale” dovremo vedere lo stato dei due singoli Array1.

mdadm –create /dev/md/TestVolumeRaid11 –level=1 –raid-devices=3 /dev/loop10 /dev/loop11 /dev/loop12

mdadm –create /dev/md/TestVolumeRaid12 –level=1 –raid-devices=3 /dev/loop13 /dev/loop14 /dev/loop15

mdadm –create /dev/md/TestVolumeRaid10_finale –level=0 –raid-devices=2 /dev/md/TestVolumeRaid11 /dev/md/TestVolumeRaid12

Passaggi finali

A questo punto dobbiamo creare i filesystem sul nuovo volume

mkfs.ext4 -F /dev/md/TestVolumeRaid10_finale

e poi montiamo il filesystem per cominciare a usarlo

mount /dev/md/TestVolumeRaid10_finale /mnt/testmd/

Questo però ovviamente non basta, dobbiamo “salvare” la configurazione affinchè al prossimo riavvio l’Array sia riconosciuto e parta normalmente e sia montato sul fs.

mdadm –detail –scan | tee -a /etc/mdadm/mdadm.conf
update-initramfs -u
echo ‘/dev/md/TestVolumeRaid10_finale /mnt/testmd ext4 defaults,nofail,discard 0 0’ | tee -a /etc/fstab

Conclusioni

Bene. Ora sappiamo come creare un RAID10 che usi 3 dischi in RAID1 per ognuno dei 2 rami del RAID0.
Tutto questo ha come detto due svantaggi rispetto a un normale RAID10 “nativo” da 2 dischi in RAID1 per ognuno dei 3 rami del RAID0 (ipotesi 20Gb ciascuno):

  1. lo spazio totale disponibile non è 60 Gb (20 Gb * 3 rami RAID1) ma solo 40 Gb (20 Gb * 2 rami RAID1)
  2. per verificare lo stato generale dell’array non mi basta eseguire “mdadm -D /dev/md/TestVolumeRaid10_finale” perchè non mi darà lo stato dei due rami RAID1 nel dettaglio, quindi dovrò eseguire anche il detail per i due volumi TestVolumeRaid11 e TestVolumeRaid12, tipo:
  1. mdadm -D /dev/md/TestVolumeRaid11 &&
  2. mdadm -D /dev/md/TestVolumeRaid12 &&
  3. mdadm -D /dev/md/TestVolumeRaid10_finale

In compenso, come detto, ho il vantaggio che si possano rompere DUE dischi sul primo ramo RAID1 (TestVolumeRaid11) e ANCHE ALTRI DUE sul secondo ramo (TestVolumeRaid12) che comunque il nostro RAID10 funzionerà ugualmente!

Su un “normale” RAID10 con 6 dischi invece, al massimo si può rompere UN disco per ogni ramo RAID1, quindi al massimo 3 dischi.

(calcolo probabilità…RAID10 normale si rompe 1 disco nel ramo 1. Le probabilità che si rompa il disco 2 del ramo 1, dando per certo che succederà subito dopo, è 1 su 5 e se succede l’array è perso per sempre.
RAID10 costruito, si rompe 1 disco nel ramo 1. Probabilità che si rompa ecc ecc è ancora 1 su 5 ma NON perdo tutto l’array. Se si rompe anche un 3 disco sul ramo1 è 1 su 4)

Su un RAID10 a due rami ma con 4 dischi per ramo, si possono guastare fino a 6 dischi (3 per ramo) senza problemi, mentre su un RAID10 normale con 8 dischi e 4 rami, al massimo si possono rompere 4 dischi.

10 dischi e 2 rami = 8 rotti
10 dischi e 5 rami = 5 rotti
12 dischi e 2 rami = 10 rotti
12 dischi e 6 rami = 6 rotti

Fate pratica con questo Array RAID formato da dischi finti, così anche in caso di problemi non rischiate di rovinare dati reali e mi raccomando, in caso di dubbi “man” e “–help” !!

Link a questo articolo!