RAID 10 en RAID 01 vergeleken

Deze twee RAID-niveaus zorgen vaak voor enorm veel verwarring, deels omdat ze ten onrechte door elkaar worden gebruikt en vaak simpelweg omdat ze slecht worden begrepen.

Allereerst moet worden opgemerkt dat beide met of zonder het plusteken kunnen worden geschreven: RAID 10 is RAID 1+0 en RAID 01 is RAID 0+1. Vreemd genoeg wordt RAID 10 vrijwel nooit met het plusteken geschreven en RAID 01 vrijwel nooit zonder. Opslagengineers zijn het er over het algemeen over eens dat het plusteken nooit wordt gebruikt, omdat het overbodig is.

Beide RAID-niveaus zijn “samengestelde” niveaus die zijn opgebouwd uit de combinatie van twee verschillende, eenvoudige RAID-typen. Beide zijn op spiegeling gebaseerde, niet-pariteit samengestelde of geneste RAID. Beide hebben in wezen identieke prestatiekenmerken – verwaarloosbare overhead en latentie met NX-leessnelheid en (NX)/2-schrijfsnelheid, waarbij N het aantal schijven in de array is en X de prestatie van een individuele schijf in de array.

Wat de twee RAID-niveaus van elkaar onderscheidt, is hoe zij omgaan met schijfuitval. Het korte overzicht is dat RAID 10 in vrijwel alle redelijke scenario's uitermate veilig is. RAID 01 wordt echter snel behoorlijk riskant naarmate de array groter wordt.

In een RAID 10 leidt het verlies van een willekeurige enkele schijf tot de degradatie van één enkele RAID 1-set binnen de RAID 0-stripe. De stripe-laag ondervindt geen degradatie, alleen die ene specifieke RAID 1-spiegel wel. Alle andere spiegels blijven onaangetast. Dit betekent dat ons enige verhoogde risico is dat die ene schijf nu zonder redundantie draait en geen bescherming heeft. Alle andere gespiegelde sets behouden hun volledige bescherming. Onze blootstelling is dus één enkele, onbeschermde schijf – ongeveer zoals je in een desktopmachine zou verwachten.

Het herstel van een array in een gedegradeerde RAID 10 is het snelst mogelijke herstelscenario. Na het vervangen van een uitgevallen schijf gebeurt er niets meer dan dat die ene spiegel opnieuw wordt opgebouwd – wat een eenvoudige kopieerbewerking is die plaatsvindt op het RAID 1-niveau, onder de RAID 0-stripe. Dit betekent dat als de array als geheel inactief is, het spiegelproces op volle snelheid kan verlopen en de array als geheel geen enkel besef heeft dat dit zelfs maar gebeurt. Een schijf-naar-schijf-spiegeling is uitermate snel, efficiënt en betrouwbaar. Dit is een ideaal herstelscenario. Zelfs als meerdere spiegels tegelijkertijd gedegradeerd zijn en gelijktijdig herstellen, is er geen extra impact, aangezien het opnieuw opbouwen van de ene de andere niet beïnvloedt. Zowel het risico van RAID 10 als de impact van het herstel schalen uitstekend.

RAID 01 daarentegen verliest, wanneer het een enkele schijf verliest, onmiddellijk een volledige RAID 0-stripe. In een typische RAID 01-spiegel zijn er twee RAID 0-stripes. Dit betekent dat de helft van de gehele array is uitgevallen. Als we het hebben over een RAID 01-array met acht schijven, maakt de uitval van een enkele schijf vier schijven onmiddellijk onbruikbaar en feitelijk uitgevallen (de hardware hoeft niet te worden vervangen, maar de gegevens op de schijven zijn verouderd en moeten opnieuw worden opgebouwd om bruikbaar te zijn). Vanuit een risicoperspectief kunnen we dit dus beschouwen als de uitval van de gehele stripe.

Wat overblijft nadat een enkele schijf is uitgevallen, is niets meer dan één enkele, onbeschermde RAID 0-stripe. Dit is veel gevaarlijker dan de equivalente RAID 10-uitval, omdat er in plaats van slechts één enkele, geïsoleerde harde schijf die risico loopt, nu minimaal twee schijven en mogelijk veel meer risico lopen, en elke schijf die aan dit risico wordt blootgesteld vergroot het risico aanzienlijk.

Als voorbeeld: in de kleinst mogelijke RAID 10- of 01-array hebben we vier schijven. In RAID 10 is, als één schijf uitvalt, ons risico dat de bijbehorende partner ook uitvalt voordat we de array opnieuw opbouwen. We maken ons alleen zorgen over die ene schijf; alle andere schijven in de RAID 10-set zijn nog steeds beschermd en veilig. Alleen deze ene is van belang. In een RAID 01 is, wanneer de eerste schijf uitvalt, zijn partner in zijn RAID 0-set onmiddellijk nutteloos en feitelijk uitgevallen, aangezien deze niet langer in de array kan functioneren. Wat overblijft zijn twee schijven zonder bescherming die niets anders dan RAID 0 draaien, en zo hebben we hetzelfde risico dat RAID 10 had, twee keer. Elke schijf heeft hetzelfde risico dat de ene schijf eerder had. Dit maakt ons risico, in het beste geval, veel hoger.

Maar laten we voor een dramatischer voorbeeld kijken naar een grote RAID 10- en RAID 01-array met vierentwintig schijven. Wederom met RAID 10: als één schijf uitvalt, zijn alle andere, behalve die ene partner, nog steeds beschermd. De extra omvang van de array voegde vrijwel geen extra risico toe. We vrezen nog steeds alleen voor de uitval van die ene op zichzelf staande schijf. Vergelijk dat met RAID 01, waarbij een van zijn RAID 0-arrays zou zijn uitgevallen, waardoor twaalf schijven in één keer uitvallen door de uitval van één, en de andere twaalf schijven in een RAID 0 zonder enige vorm van bescherming achterblijven. De kans dat een van twaalf schijven uitvalt is uiteraard aanzienlijk hoger dan de kans dat een enkele schijf uitvalt.

Dit is niet het volledige beeld. Het herstel van de ene RAID 10-schijf is snel, het is een rechtstreekse kopieerbewerking van de ene schijf naar de andere. Het gebruikt minimale middelen en duurt slechts zo lang als nodig is voor een enkele schijf om zichzelf volledig te lezen en te schrijven. RAID 01 heeft niet zoveel geluk. In tegenstelling tot RAID 10, dat slechts een kleine deelverzameling van de gehele array opnieuw opbouwt – en een deelverzameling die niet groeit naarmate de array groeit; de tijd om een RAID 10 met vier schijven of een RAID 10 met veertig schijven na uitval te herstellen is identiek – moet RAID 01 een volledige helft van de gehele bovenliggende array opnieuw opbouwen. In het geval van de array met vier schijven is dit het dubbele van het herstelwerk van de RAID 10, maar in het geval van de array met vierentwintig schijven is het twaalf keer zoveel herstelwerk dat moet worden uitgevoerd. RAID 01-herstel duurt dus langer om uit te voeren, terwijl het gedurende die tijd aanzienlijk meer risico loopt.

Er bestaat een nogal hardnekkige mythe dat RAID 01 en RAID 10 verschillende prestatiekenmerken hebben, maar dat is niet zo. Beide gebruiken eenvoudige striping en spiegeling, die in feite bewerkingen met nul overhead zijn die vrijwel geen verwerkingsoverhead vereisen. Beide halen volledige leesprestaties uit elk aangesloten schijfapparaat en beide verliezen de helft van hun schrijfprestaties aan hun spiegelbewerking (uitgaande van tweevoudige spiegels, wat het enige gebruikelijke gebruik van beide arraytypen is). Er is simpelweg niets dat RAID 01 of RAID 10 sneller of langzamer maakt dan de ander. Beide zijn uitermate snel.

Vanwege de kenmerken van de twee arraytypen is het duidelijk dat RAID 10 van de twee het enige type is dat ooit binnen één enkele arraycontroller zou mogen bestaan. RAID 01 is onnodig gevaarlijk en biedt geen enkel voordeel. Ze gebruiken dezelfde capaciteitsoverhead, ze hebben dezelfde prestaties, ze kosten hetzelfde om te implementeren, maar RAID 10 is aanzienlijk betrouwbaarder.

Waarom bestaat RAID 01 dan überhaupt? Deels bestaat het uit onwetendheid of verwarring. Veel mensen die hun eigen samengestelde RAID-arrays implementeren, kiezen voor RAID 01 omdat ze de mythe hebben gehoord dat het sneller is en, zoals over het algemeen het geval is met RAID, niet onderzoeken waarom het sneller zou zijn en vergeten te kijken naar de betrouwbaarheid en andere factoren. RAID 01 wordt op lokale arrays werkelijk alleen per ongeluk geïmplementeerd.

Wanneer we RAID echter naar de netwerklaag brengen, zijn er nieuwe factoren om rekening mee te houden en kan RAID 01 belangrijk worden, evenals zijn zeldzame neef RAID 61. We geven, via Network RAID Notation, aan waar de lokale en waar de netwerklagen van de RAID zich bevinden. In dit geval bedoelen we dus RAID 0(1) OF RAID 6(1). De haakjes geven aan dat de RAID 1-spiegel, het “hoogste” deel van de RAID-stack, zich over een netwerkverbinding bevindt en niet op de lokale RAID-controller.

Hoe zou dit eruitzien in RAID 0(1)? Als je twee servers hebt, elk met een standaard RAID 0-array, en je wilt dat ze met elkaar worden gesynchroniseerd om als één enkele, betrouwbare array te fungeren, dan zou je een technologie zoals DRBD (op Linux) of HAST (op FreeBSD) kunnen gebruiken om een netwerk-RAID 1-array te maken van de lokale opslag op elke server. Uiteraard brengt dit veel prestatieoverhead met zich mee, aangezien de RAID 1-array gesynchroniseerd moet worden gehouden over de LAN-verbinding met hoge latentie en lage bandbreedte. RAID 0(1) is de notatie voor deze opzet. Als elke lokale RAID 0-array werd vervangen door een betrouwbaardere RAID 6, zouden we de hele opzet schrijven als RAID 6(1).

Waarom accepteren we het risico van RAID 01 wanneer het over een netwerk loopt en niet wanneer het lokaal is? Dit komt door de aard van de netwerkverbinding. In het geval van RAID 10 vertrouwen we op het laaggelegen RAID 1-deel van de RAID-stack voor bescherming, met de RAID 0 daarbovenop. Als we dit op netwerkniveau repliceren, zoals RAID 1(0), dan eindigen we ermee dat elke host één enkele spiegel heeft die slechts een deel van de gegevens van de array vertegenwoordigt. Als er iets zou gebeuren met een knooppunt in de array of als de netwerkverbinding zou uitvallen, zou de array onmiddellijk worden vernietigd en zou elk knooppunt achterblijven met nutteloze, onvolledige gegevens. Het is de aard van het hoge risico van knooppuntuitval en het risico op het niveau van de netwerkverbinding dat RAID-beslissingen in een netwerkomgeving uitermate anders maakt. Dit wordt op zichzelf een complex onderwerp.

Het volstaat te zeggen dat je, bij het werken met normale RAID-arraycontrollers of met lokale opslag en software-RAID, uitsluitend RAID 10 moet gebruiken en nooit RAID 01.