Archivi tag: raid

Nagios: script bash per monitorare lo stato dei volumi RAID

Partendo dalle considerazioni fatte in questo post, ho deciso di mettere a punto uno script bash da integrare a Nagios, in modo da monitorare lo status dei volumi RAID (e dei dischi fisici annessi) a prescindere dal metodo utilizzato per l’implementazione di tale tecnologia (hardware, fake oppure software).

nagiosDi seguito riporto il suddetto script nella sua interezza:

#!/bin/bash

type=$1

subtype=$2

element=$3

usage="check_raid <--software|--fake|--hardware> [--megaraid|--mpt] [--volume|--physical|--battery]"

if [[ ! -z "$type" && "$type" =~ "software" ]];then
        okswraid=0;
        koswraid=0;
        volumes=`cat /proc/mdstat | grep md | grep active | grep -v inactive | awk '{print $1}' | wc -l`
        if [[ ! -z $volumes ]];then
                for (( v=1; v<=$volumes; v++ ))
                do
                        volume=`cat /proc/mdstat | grep md | grep active | grep -v inactive | awk '{print $1}' | sed -n "$v p"`
                        raidtype=`cat /proc/mdstat | grep md | grep active | grep -v inactive | awk '{print $4}' | sed -n "$v p"`
                        diskno=`cat /proc/mdstat | grep '[[0-9]\/[0-9]]' | awk '{print $3}' | sed -n "$v p"`
                        disksok=`echo $diskno | sed 's/\[//g' | cut -d '/' -f1`
                        diskstotal=`echo $diskno | sed 's/\]//g' | cut -d '/' -f2`
                        if [[ "$disksok" -eq "$diskstotal" ]];then
                                echo "OK: Software RAID volume $volume configured in $raidtype is OK, with $diskno disks UP"
                                ((okswraid++))
                        elif [[ "$disksok" -lt "$diskstotal" ]];then
                                echo "CRITICAL: Software RAID volume $volume configured in $raidtype is CRITICAL, with $diskno disks UP"
                                ((koswraid++))
                        fi
                done

                if [[ $koswraid -eq 0 ]];then
                        exit 0;
                else
                        exit 2;
                fi
        else
                echo "UNKNOWN: No software RAID configured"
                exit 3;
        fi

elif [[ ! -z "$type" && "$type" =~ "fake" ]];then
        bin=`/usr/bin/which dmraid`
        if [[ ! -z $bin ]];then
                result=`$bin -s`
                disksno=`$bin -r | grep -v no | wc -l`
                disksok=`$bin -r | grep ok | wc -l`
                if [[ ! -z "$result" && "$result" =~ "ok" ]];then
                        echo "OK: RAID Status is OK, with $disksok/$disksno disks OK"
                        exit 0;
                elif [[ ! -z "$result" && "$result" =~ "no raid" ]];then
                        echo "UNKNOWN: no fake RAID configured"
                        exit 3;
                else
                        echo "CRITICAL: RAID Status is KO, with $disksok/$disksno disks OK"
                        exit 2;
                fi
        else
                echo "UNKNOWN: no dmraid binary found - please install dmraid"
                exit 3;
        fi

elif [[ ! -z "$type" && "$type" =~ "hardware" ]];then
        okraid=0;
        oksmart=0;
        koraid=0;
        kosmart=0;
        if [[ ! -z "$subtype" && "$subtype" =~ "--megaraid" ]];then
                bin=`/usr/bin/which MegaCli64`
                if [[ ! -z $bin ]];then
                        if [[ ! -z "$element" && "$element" =~ "--volume" ]];then
                                result=`$bin -LDinfo -Lall -aALL | grep State | awk '{print $3}'`
                                if [[ ! -z "$result" && $result =~ "Optimal" ]];then
                                        echo "OK: RAID Volume state is $result"
                                        exit 0;
                                else
                                        echo "CRITICAL: RAID Volume state is $result"
                                        exit 2;
                                fi
                        elif [[ ! -z "$element" && "$element" =~ "--physical" ]];then
                                diskno=`$bin -PDList -aALL | grep "S.M.A.R.T alert" | wc -l`
                                for (( d=1; d<=$diskno; d++ ))
                                do
                                        result=`$bin -PDList -aALL | grep "Firmware state" | sed -n "$d p" | awk '{print $3}' | sed 's/,//g'`
                                        if [[ ! -z "$result" && $result =~ "Online" ]];then
                                                echo "RAID Status for Physical Disk number $d is OK"
                                                ((okraid++));
                                        else
                                                echo "RAID Status for Physical Disks number $d is KO"
                                                ((koraid++));
                                        fi
                                done
                                for (( d=1; d<=$diskno; d++ ))
                                do
                                        result=`$bin -PDList -aALL | grep "S.M.A.R.T alert" | sed -n "$d p" | awk '{print $8}'`
                                        if [[ ! -z "$result" && $result =~ "No" ]];then
                                                echo "S.M.A.R.T Status for Physical Disk number $d is OK"
                                                ((oksmart++));
                                        else
                                                echo "S.M.A.R.T. Status for Physical Disks number $d is KO"
                                                ((kosmart++));
                                        fi
                                done
                                if [[ $koraid -eq 0 && $kosmart -eq 0 ]];then
                                        echo "OK: RAID and S.M.A.R.T Status for all Physical Disks is OK"
                                        exit 0;
                                elif [[ $koraid -eq 0 && $kosmart -ne 0 ]];then
                                        echo "CRITICAL: S.M.A.R.T Status for some Physical Disks is KO"
                                        exit 2;
                                elif [[ $koraid -ne 0 && "$kosmart" -eq 0 ]];then
                                        echo "CRITICAL: RAID Status for some Physical Disks is KO"
                                        exit 2;
                                elif [[ $koraid -ne 0 && $kosmart -ne 0 ]];then
                                        echo "CRITICAL: RAID and S.M.A.R.T Status for some Physical Disks is KO"
                                        exit 2;
                                fi
                        elif [[ ! -z "$element" && "$element" =~ "--battery" ]];then
                                result=`$bin -AdpBbuCmd -aAll | grep "Battery State" | awk '{print $3}'`
                                if [[ ! -z "$result" && $result =~ "OK" ]];then
                                        echo "OK: RAID Controller Battery state is OK"
                                        exit 0;
                                else
                                        echo "CRITICAL: RAID Controller Battery state is $result"
                                        exit 2;
                                fi
                        else
                                echo "UNKNOWN: please specify the element to check"
                                echo $usage;
                                exit 3;
                        fi
                else
                        echo "UNKNOWN: No MegaCli64 binary found - please install MegaCli64"
                        exit 3;
                fi

        elif [[ ! -z "$subtype" && "$subtype" =~ "mpt" ]];then
                modprobe mptctl
                bin=`/usr/bin/which mpt-status`
                bin2=`/usr/bin/which lspci`
                bin3=`/usr/bin/which daemonize`
                if [[ ! -z $bin ]];then
                        if [[ ! -z $bin2 ]];then
                                controller_status=`lspci | grep MPT`
                                if [[ ! -z $controller_status ]];then
                                        if [[ ! -z $bin3 ]];then
                                                controller=`$bin -p | grep id | awk '{print $3}' | sed 's/id=//g' | sed 's/,//g'`
                                                if [[ ! -z $controller ]];then
                                                        result=`$bin -i $controller | grep OPTIMAL`
                                                        if [[ ! -z "$result" ]];then
                                                                echo "OK: RAID Status is OPTIMAL"
                                                                exit 0;
                                                        else
                                                                echo "CRITICAL: RAID Status is DEGRADED"
                                                                exit 2;
                                                        fi
                                                else
                                                        echo "UNKNOWN: MPT Controller found but no RAID configured";
                                                        exit 3;
                                                fi
                                        else
                                                echo "UNKNOWN: No daemonize binary found - please install daemonize";
                                                exit 3;
                                        fi
                                else
                                        echo "UNKNOWN: Unable to find RAID Controller";
                                        exit 3;
                                fi
                        else
                                echo "UNKNOWN: No lspci binary found - please install lspci";
                                exit 3;
                        fi
                else
                        echo "UNKNOWN: No mpt-status binary found - please install mpt-status"
                        exit 3;
                fi

        else
                echo "UNKNOWN: please specify the RAID Controller type"
                echo $usage
                exit 3;
        fi
else
        echo "UNKNOWN: please specify the RAID type"
        echo $usage
        exit 3;
fi
exit 0

Lo usage parla chiaro: il primo argomento identifica, per l’appunto, la tecnologia RAID utilizzata sul sistema target. Il secondo ed il terzo argomento, invece, dovranno essere specificati solo nel caso in cui si abbia a che fare con un RAID di tipo hardware. Nella fattispecie, essi rappresentano, rispettivamente, la tipologia di chipset utilizzata dal controller e l’oggetto di interesse della nostra query, ovvero il volume, i dischi fisici oppure la batteria (tale parametro ha senso solo se il chipset è di tipo LSI MegaRAID).

Configurazione di Nagios

Come al solito, il primo step consiste nel definire un comando che utilizzi lo script (in gergo plugin) riportato in precedenza:

# 'check_local_raid' command definition
define command{
        command_name    check_local_raid
        command_line    $USER1$/check_raid $ARG1$ $ARG2$ $ARG3$
        }

tali direttive andranno opportunamente inserite all’interno del file /etc/nagios/objects/commands.cfg.

Successivamente si potrà procedere con la definizione del servizio che si occuperà del monitoraggio vero e proprio, da aggiungere alla configurazione dell’host target, in questo caso /etc/nagios/object/locahost.cfg:

define service{
        use                             local-service         ; Name of service template to use
        host_name                       localhost
        service_description             RAID Status
        check_command                   check_local_raid!--software
        }

A questo punto non ci rimane che ricaricare la configurazione di Nagios per rendere effettive le suddette modifiche:

[root@linuxbox ~]# service nagios reload

ed abbiamo finito.

Alla prossima.

Sistemi RAID implementabili su Linux

Premessa

L’obiettivo di questo post non è quello di spiegare le diverse modalità di funzionamento del RAID (già discusse qui), ma di illustrare come sia possibile implementare tale tecnologia sulle macchine Linux.

RAID

Tipologie di sistemi RAID

Per farla breve, esistono 3 modi per realizzare quanto detto sopra:

1) Utilizzando un controller dedicato (in questo caso parliadmo di RAID hardware). Ovviamente ne esiste una vasta gamma ma ciò che li contraddistingue è il chipset di cui sono dotati (ad esempio LSI MPT, LSI MegaRAID, ecc)., dato che è proprio tramite di essi che il sistema operativo sarà in grado di interfacciarsi con i dischi (siano essi fisici o virtuali). A mio avviso, questo è il metodo più sicuro di implementazione del RAID (a patto che si tenga sotto controllo lo stato di salute dei vari elementi coinvolti, compresa la batteria di backup in dotazione al controller).

2) Avvalendosi del chipset integrato alla scheda madre (sempre che tale funzionalità sia effettivamente supportata). In tal caso parliamo di RAID ATA o fake RAID. E’ sicuramente uno dei metodi più comodi di implementazione (la creazione e gestione dei volumi avviene mediante il BIOS), ma è comunque poco affidabile (non sono rari i casi in cui tale tecnologia si è rivelata essere insufficiente, portando spesso alla perdita di tutte le informazioni presenti sugli hard drive).

3) Demandando al sistema operativo (Linux) la creazione e la gestione dei dischi logici. In questo caso parliamo di RAID software. Anche questo metodo, come quello del punto 1, è molto sicuro ed è ampiamente preferibile al fake RAID.

Tool per la gestione dei sistemi RAID hardware

A seconda della tecnologia scelta, Linux è in grado di interrogare lo stato dei dischi configurati in RAID avvalendosi di alcuni tool. Ad esempio, se si utilizza un controller dedicato e ci si vuole interagire, occorrerà prima di tutto individuare il chipset di cui è dotato e successivamente scegliere un tool in grado di interfacciarsi con esso.

Nella fattispecie, per l’indentificazione dei chipset, si può utilizzare il tool lspci:

[root@linuxbox ~]# lspci | grep LSI

oppure, in alternativa, il comando dmesg:

[root@linuxbox ~]# dmesg | grep LSI

Una volta identificato il chipset, occorrerà sincerarsi che esso sia supportato dal kernel della nostra macchina (ovvero che esiste un driver in grado di parlarci), ed in caso affermativo verificare, in seconda battuta, che tale driver (sottoforma di modulo) sia stato opportunamente caricato.

Nella fattispecie, se parliamo di un chipset LSI MPT, sarà necessario caricare il modulo mptctl mediante il seguente comando:

[root@linuxbox ~]# modprobe mptctl

In seguito si dovranno scaricare ed installare i tool daemonize ed mpt-status, il primo mandatorio per il funzionamento del secondo (se utilizzate una macchina CentOS/RHEL potete scaricarli da qui).

Una volta fatto ciò sarà possibile interrogare il controller utilizzando il seguente comando:

[root@linuxbox ~]# mpt-status -p

che ci restituirà l’ID del controller stesso e successivamente:

[root@linuxbox ~]# mpt-status -i <ID controller>

per individuare lo stato dei volumi e dei dischi fisici.

Nel caso in cui, invece, si avesse a che fare con un controller LSI MegaRAID, sarà necessario utilizzare un tool a scelta tra dmraid o MegaCli64 (anche se esistono diverse alternative, quali storcli). Sinceramente preferisco il secondo, anche se la sintassi che utilizza non è propriamente esplicativa. Solo a titolo di esempio, ecco alcune “query” (lasciatemi passare il termine) dirette al controller ed effettuate mediante MegaCli64:

[root@linuxbox ~]# MegaCli64 -AdpAllInfo -aAll

per ottenere tutte le info relative al controller stesso (stato dei volumi, dei dischi fisici, della batteria, ecc.);

[root@linuxbox ~]# MegaCli64 -AdpBbuCmd -aAll | grep "Battery State"

per individuare lo stato della batteria del controller (detta di backup), grazie alla quale è possibile preservare la configurazione del RAID anche in caso di failure della CMOS;

[root@linuxbox ~]# MegaCli64 -LDinfo -Lall -aALL | grep "State"

per avere informazioni relative ai dischi logici (volumi);

[root@linuxbox ~]# MegaCli64 -PDList -aALL

per individuare lo stato dei dischi fisici;

[root@linuxbox ~]# MegaCli64 -PDList -aALL | grep "S.M.A.R.T alert

per appurare la presenza di eventuali errori di tipo S.M.A.R.T (vedi qui per ulteriori dettagli);

[root@linuxbox ~]# MegaCli64 -PDList -aALL | grep "Firmware state"

per individuare lo stato delle repliche RAID sui dischi fisici.

Tool per la gestione dei sistemi RAID ATA

Per quanto riguarda il fake RAID, uno dei tool più diffusi per la sua gestione è sicuramente dmraid. E’ necessario precisare, inoltre, che tale tool supporta anche diversi controller hardware e per ottenere una lista esaustiva di quelli compatibili basta utilizzare il comando:

[root@linuxbox ~]# dmraid -l

il cui output sarà simile al seguente:

asr     : Adaptec HostRAID ASR (0,1,10)
ddf1    : SNIA DDF1 (0,1,4,5,linear)
hpt37x  : Highpoint HPT37X (S,0,1,10,01)
hpt45x  : Highpoint HPT45X (S,0,1,10)
isw     : Intel Software RAID (0,1,5,01)
jmicron : JMicron ATARAID (S,0,1)
lsi     : LSI Logic MegaRAID (0,1,10)
nvidia  : NVidia RAID (S,0,1,10,5)
pdc     : Promise FastTrack (S,0,1,10)
sil     : Silicon Image(tm) Medley(tm) (0,1,10)
via     : VIA Software RAID (S,0,1,10)
dos     : DOS partitions on SW RAIDs

Per ottenere lo stato del volume RAID è sufficiente lanciare il comando:

[root@linuxbox ~]# dmraid -s

il cui output sarà qualcosa del tipo:

*** Group superset isw_bigeeiijaj
--> Active Subset
name   : isw_bigeeiijaj_Volume0
size   : 312576256
stride : 128
type   : mirror
status : ok
subsets: 0
devs   : 2
spares : 0

Per lo stato dei dischi fisici, invece, occorre utilizzare la flag -r:

[root@linuxbox ~]# dmraid -r

/dev/sdc: isw, "isw_bigeeiijaj", GROUP, ok, 312581806 sectors, data@ 0
/dev/sda: isw, "isw_bigeeiijaj", GROUP, ok, 312581806 sectors, data@

Tool per la gestione dei sistemi RAID Software

Per gestire i RAID software si può utilizzare il tool mdadm o, in alternativa, nel caso in cui fosse sufficiente individuare lo stato dei dischi fisici e dei volumi, si può lanciare il comando:

[root@linuxbox ~]# cat /proc/mdstat

il cui output avrà il seguente formato:

[root@linuxbox ~]# cat /proc/mdstat
Personalities : [raid1]
md3 : active raid1 sda3[0] sdb3[1]
      511998912 blocks [2/2] [UU]
      bitmap: 0/4 pages [0KB], 65536KB chunk

md2 : active raid1 sda2[0] sdb2[1]
      1433598912 blocks [2/2] [UU]
      bitmap: 4/11 pages [16KB], 65536KB chunk

dove la stringa Personalities: indica il tipo di RAID supportato dal kernel, mentre md3 ed md2 sono i 2 volumi configurati in RAID 1 (mirroring).

Per ora è tutto. Alla prossima.

RAID

Premessa

In questo post ho descritto a grandi linee le diverse politiche di backup ed il motivo per il quale esse sono estramemente importanti. Però, per ciò che concerne la tolleranza ai guasti, soprattutto se si parla di memorie di massa, la prima cosa da fare riguarda la scelta del tipo di RAID da implementare.

Bhè, chiunque abbia mai avuto a che fare con dei server sa sicuramente di cosa sto parlando. Per fare una brevissima introduzione, l’acronimo RAID sta per Redundant Array of Indipendent Disks oppure Redundant Array of Inexpensive Disks, poichè tale sistema è stato pensato per avere ridondanza e per ottenere dischi logici di grandi dimensioni a partire da unità di piccole/medie dimensioni (quindi meno costose).

Inoltre, sono previste diverse tipologie di RAID, ciascuna delle quali presenta delle caratteristiche peculiari, da cui è possibile dedurne i vantaggi e soprattutto gli svantaggi.

RAID a livello hardware oppure a livello software?

Sia ben chiaro che per quanto riguarda i primissimi sistemi RAID, ne era possibile l’implementazione solo a livello hardware, utilizzando opportuni controller. Con l’evolversi della tecnologia sono nati anche dei sistemi software in grado di emulare il comportamento dei suddetti controller. Va detto, però, che essi sono meno performanti dal punto di vista prestazionale. Ergo, se dovete scegliere e non avete budget molto ristretti, il mio consiglio è quello di optare sempre per il RAID hardware.

Livelli RAID

La caratteristica peculiare del RAID è la possibilità di salvare i dati su più unita di archiviazione di massa, facendo diminuire i tempi di accesso (I/O). Tale operazione si chiama, in gergo, data striping.

Altra caratteristica fondamentale dei sistemi RAID è la ridondanza e la tolleranza ai guasti (tranne per il RAID 0).

Detto ciò, vediamo nel dettaglio quali sono i tratti somatici di ciascun livello RAID.

RAID 0

Esso non è proprio un livello RAID a tutti gli effetti. Mi spiego: poichè i sistemi RAID sono nati per offire ridondanza e dato che il RAID 0 non offre tale possibilità, parlare di RAID sembra quasi una forzatura.

Infatti, il RAID 0 consente solo ed esclusivamente di creare un’unità logica di dimensione C a partire da N unità di dimensione D (con N maggiore o uguale a 2). La capacità C sarà data (molto banalmente) dalla formula:

C=N*D

 

raid0.jpg

Vantaggi: economico.

Svantaggi: non offre tolleranza ai guasti.

RAID 1

Tale sistema viene anche detto mirroring o shadowing. Esso non fa altro che creare una copia speculare del contenuto di un disco rigido su un altro hard disk. Da ciò si deduce che il numero di dischi da configurare in RAID 1 deve essere pari. Inoltre, la capacità totale sarà pari a quella di un singolo disco (l’altro viene usato solo per la tolleranza ai guasti).

 

raid1.gif

Vantaggi: alta tolleranza ai guasti.

Svantaggi: costo elevato.

RAID 2

Il RAID 2 prevede il data striping a livello di bit. Dunque, da più unità fisiche se ne ricava una logica. Offre, inoltre, una politica di correzione degli errori relativi al singolo bit (grazie al codice di Hamming) e di individuazione (ma non correzione) di errori doppi.

 

raid2.jpg

Vataggi: alte performance in sistemi in cui si verificano molti errori durante la fase di I/O.

Svantaggi: performance ridotte in tutti gli altri casi.

RAID 3

Tale sistema (come il RAID 4) è poco utilizzato. Prevede il data striping a livello di byte, dunque tempi di accesso elevati (il byte viene “spalmato” sui dischi, ergo il tempo di accesso per ogni singolo disco va moltiplicato per il numero di unità coinvolte ed in questo modo si ottiene il tempo di accesso reale).

Prevede un meccanismo di tolleranza ai guasti, grazie ad un disco dedicato su cui vengono salvate le informazioni relative al controllo di parità.

 

raid3.jpg

Vantaggi: tolleranza ai guasti.

Svantaggi: tempi di accesso elevati, può sopperire al guasto di un solo disco affinchè i dati possano essere ripristinati. Quindi, se si guastano due dischi contemporaneamente, tutti i dati verranno persi.

RAID 4

Poco utilizzato. Differisce dal RAID 3 solo perchè il data striping avviene a livello di blocco e non di byte. In questo modo vengono risolti i problemi relativi ai lunghi tempi di accesso tipici del RAID 3.

 

raid4.jpg

Vantaggi: tempi di accesso ragionevoli, tolleranza ai guasti.

Svantaggi: se si guastano due dischi contemporaneamente i dati verranno persi.

RAID 5

Una vera e propria rivoluzione. Infatti, esso non prevede dei dischi dedicati per il controllo di parità, ma tali informazioni vengono salvate assieme ai dati veri e propri. Purtroppo, però, come già visto per il RAID 3 e per il RAID 4, non è in grado di ripristinare i dati nel caso in cui si guastassero due o più dischi contemporaneamente.

 

raid5.gif

Vantaggi: eliminazione del bottleneck rappresentato dal disco dedicato al controllo di parità.

Svantaggi: operazioni di scrittura lente a causa del calcolo della parità.

RAID 6

Può essere definito “RAID 5 più qualcosa” e quel qualcosa è rappresentato dalla ridondanza del controllo di parità. Infatti, i dati relativi al controllo di parità per uno specifico blocco vengono salvati su due dischi differenti, seguendo direzioni opposte. A titolo di esempio, se l’array è formato dai dischi A B C D e la scrittura avviene sul disco B, il controllo di parità sarà memorizzato su A e su C.

 

RAID6.jpg

Vantaggi: alta tolleranza ai guasti.

Svantaggi: costoso poichè implica l’uso di un controller ad hoc che lo supporti.

RAID annidati

L’ultima frontiera del RAID è rappresentata dalla possibilità di utilizzare diverse tipologie in modo annidato.

Ad esempio, per ciò che concerne il RAID 0+1 (la seguente figura si legge dal basso verso l’alto), è possibile prevedere il mirroring direttamente sulle unità logiche create attraverso il RAID di tipo 0.

                               RAID 1
┌——————┴————————┐
RAID 0                             RAID 0
┌—————┼—————┐     ┌—————┼—————┐
120GB   120GB  120GB      120GB   120GB  120GB

Due parole sugli spare

Quasi tutti i sistemi RAID che vi ho illustrato (per la precisione tutti tranne il RAID 0) supportano l’hot spare. Questo significa che può essere allocato su uno slot un disco vuoto aggiuntivo, il quale verrà utilizzato automaticamente nel caso in cui una delle memorie di massa che costituiscono l’array si guasti. La differenza tra l’hot spare ed il cold spare sta semplicemente nel fatto che, nell’ultimo caso, il povero sistemista di turno dovrà sostituire il disco guasto con uno vuoto (spegnendo il sistema durante la fase di manutenzione).

Il post termina qui.

Bye.