Schijfverschijning

Een van de meer gangbare, maar ook lastigere fundamentele concepten in de hedendaagse informatica is het concept van schijfverschijning of, met andere woorden, iets dat zich voordoet als een harde schijf. Dit klinkt misschien eenvoudig, en dat is het meestal ook, maar het kan lastig zijn.

Ten eerste: wat is een harde schijf. Dit zou eenvoudig moeten zijn. We bedoelen hier normaal gesproken een traditioneel Winchester-apparaat met een draaiende schijf, zoals die al decennialang worden gemaakt in de standaard formaten van drieënhalve inch en tweeënhalve inch. Ze bevatten platters die draaien, een leeskop die naar voren en naar achteren beweegt en ze worden aangesloten met iets als ATA- of SCSI-connectoren. De meesten van ons kunnen een harde schijf met onze handen oppakken en er zeker van zijn dat we een harde schijf hebben. Dit is wat we de fysieke verschijningsvorm van de schijf noemen.

Voor de computer geldt echter dat deze niet de behuizing van de schijf of de connectoren ziet. De computer moet door zijn elektronica heen kijken en de schijf digitaal “zien”. Dit is heel, heel anders dan hoe mensen de fysieke schijf zien. Voor de computer verschijnt een harde schijf op het meest elementaire fysieke niveau als een ATA-, SCSI- of Fibre Channel-apparaat en wordt deze op een hoger niveau over het algemeen geabstraheerd als een blokapparaat. Dit is wat we een logische verschijning zouden noemen, in plaats van een fysieke. Voor ons doel hier zullen we al deze schijfinterfaces beschouwen als blokapparaten. Ze verschillen wel, maar slechts in geringe mate en niet op een voor deze discussie relevante manier. Wat van belang is, is dat er een standaardinterface of een reeks nauw verwante interfaces bestaat die door de computer worden gezien als een harde schijf.

Een andere manier om de logische schijfverschijning hier te beschouwen, is dat alles wat er voor de computer uitziet als een harde schijf, iets is waarop de computer kan formatteren met een bestandssysteem. Bestandssystemen zijn zelf geen schijven, maar vereisen een schijf waarop ze geplaatst kunnen worden.

Het concept van de interface is hier het belangrijkste. Voor de computer is het “alles wat een harde-schijfinterface implementeert” dat daadwerkelijk wordt gezien als een harde schijf. Dit is een zowel eenvoudig als krachtig concept.

Het is dankzij het gebruik van een standaardinterface dat we flashgeheugen konden nemen, dit konden koppelen aan een schijfcontroller die het via een standaardprotocol zou presenteren (zowel SATA- als SAS-implementaties van ATA en SCSI zijn hiervoor tegenwoordig gangbaar) en SSD's konden creëren die er voor de computer precies zo uitzien en zich precies zo gedragen als traditionele Winchester-schijven, terwijl ze er fysiek niets mee gemeen hebben. Ze komen mogelijk wel of niet in een vertrouwde fysieke vorm, maar ze missen zeker platters en een leeskop. Wanneer we naar de werking van een traditionele harde schijf en een moderne SSD kijken, zouden we niet vermoeden dat ze een gemeenschappelijk doel delen.

Dit concept is van toepassing op veel apparaten. Uiteraard werken SD-kaarten en USB-geheugensticks op dezelfde manier. Maar wat belangrijk is: zo werken partities bovenop harde schijven. Het partitioneringssysteem gebruikt aan de ene kant het concept van de schijfverschijningsinterface om op een apparaat te kunnen worden toegepast, en aan de andere kant presenteert het een schijfverschijningsinterface aan datgene wat het wil gebruiken; normaal gesproken een bestandssysteem. Dit idee van iets dat aan beide kanten de schijfverschijningsinterface gebruikt, is zeer belangrijk. Door dit te doen krijgen we een uniform en universeel bouwsteensysteem voor het maken van complexe opslagsystemen!

We zien dit concept van “schijf erin; schijf eruit” in veel gevallen. Het bekendste is waarschijnlijk RAID. Een RAID-systeem neemt een array van harde schijven, past een van een aantal algoritmen toe om de schijven als een team te laten werken, en presenteert ze vervolgens als één enkele schijfverschijning aan het volgende systeem hoger in de “stack”. Deze inkapseling is wat RAID zijn kracht geeft: systemen hoger in de stack die naar een RAID-array kijken, zien letterlijk een harde schijf. Ze zien niet de array van schijven, ze weten niet wat zich onder de RAID bevindt. Ze zien alleen de resulterende schijf of schijven die het RAID-systeem presenteert.

Omdat een RAID-systeem een willekeurig aantal schijven neemt en deze presenteert als een standaardschijf, hebben we de theoretische mogelijkheid om RAID zo vaak te stapelen als we willen. Uiteraard zou dit in hoge mate buitengewoon onpraktisch zijn. Maar het is dankzij dit concept dat geneste RAID-arrays mogelijk zijn. Stel bijvoorbeeld dat we veel fysieke harde schijven hadden, opgesplitst in paren en elk paar in een RAID 1-array. Elk van die resulterende arrays wordt gepresenteerd als één enkele schijf. Elk van die resulterende logische schijven kan worden gecombineerd tot een andere RAID-array, zoals RAID 0. Op deze manier wordt RAID 10 opgebouwd. Als we nog verder gaan, zouden we een aantal RAID 10-arrays kunnen nemen, ze allemaal kunnen presenteren aan een ander RAID-systeem dat ze opnieuw in RAID 0 plaatst, en RAID 100 verkrijgen, enzovoort tot in het oneindige.

Op vergelijkbare wijze gebruikt de logische-volumelaag dezelfde soort inkapseling als RAID om zijn magie te verrichten. Logical Volume Managers, zoals LVM op Linux en Dynamic Disks op Windows, zitten bovenop logische schijven en bieden een laag waarin je krachtig beheer kunt uitvoeren, zoals het flexibel uitbreiden van apparaten of het inschakelen van snapshots, en presenteren vervolgens logische schijven (oftewel de schijfverschijningsinterface) aan de volgende laag van de stack.

Vanwege het uniforme karakter van schijfverschijningen kan de stack in elke willekeurige volgorde plaatsvinden. Een logical volume manager kan bovenop RAID zitten, of RAID kan bovenop een logical volume manager zitten en uiteraard kun je de een of de ander of beide overslaan!

Het concept van schijfverschijningen of logische harde schijven is krachtig in zijn eenvoud en biedt ons grote mogelijkheden om opslagsystemen aan te passen, op welke manier we ze ook nodig hebben.

Uiteraard zijn er ook andere toepassingen van het concept van de logische schijf. Een van de populairste en minst begrepen is die van een SAN. Een SAN is niets meer dan een apparaat dat een of meer fysieke schijven neemt en deze over het netwerk presenteert als logische schijven (deze presentatie van een logische schijf vanuit een SAN wordt een LUN genoemd). Dit is, heel letterlijk, alles wat een SAN is. De meeste SAN's zullen een RAID-laag en waarschijnlijk een logical-volume-managerlaag bevatten voordat ze de uiteindelijke LUN's, oftewel schijfverschijningen, aan het netwerk presenteren, maar dat is niet vereist om een SAN te zijn.

Dit betekent uiteraard dat meerdere SAN-LUN's kunnen worden gecombineerd in één enkele RAID of kunnen worden beheerd via een logische-volumelaag. En het betekent uiteraard dat een SAN-LUN, een fysieke harde schijf, een RAID-array, een logisch volume, een partitie… allemaal kunnen worden geformatteerd met een bestandssysteem, aangezien het allemaal verschillende manieren zijn om hetzelfde resultaat te bereiken. Ze gedragen zich allemaal identiek. Ze delen allemaal de schijfverschijningsinterface.

Om een praktijkvoorbeeld te geven van hoe je al deze onderdelen vaak zou zien samenkomen, bekijken we een van de meest voorkomende “opslagstacks” die je in de enterprise-omgeving zult tegenkomen. Uiteraard zijn er veel manieren om een opslagstack op te bouwen, dus wees niet verbaasd als die van jou anders is. Aan de basis van de stack bevinden zich vrijwel altijd fysieke harde schijven, waaronder mogelijk solid-state schijven. Deze bevinden zich fysiek binnen een SAN. Voordat de stack de SAN verlaat, omvat deze waarschijnlijk de feitelijke opslaglaag van de schijven, en vervolgens een RAID-laag die die schijven combineert tot één entiteit. Daarna een logische-volumelaag om functies zoals groei en snapshots mogelijk te maken. Dan is er de fysieke demarcatie tussen de SAN en de server, die wordt gepresenteerd als de LUN. Op de LUN wordt vervolgens een logical volume manager toegepast aan de server- / besturingssysteemzijde van het demarcatiepunt. En bovenop die LUN bevindt zich een bestandssysteem, wat onze laatste stap is, aangezien het bestandssysteem niet langer een schijfverschijningsinterface presenteert, maar in plaats daarvan een bestandsinterface.

Het begrijpen van schijfverschijning, oftewel logische schijven, en hoe deze componenten in staat stellen om met elkaar te koppelen om complexe opslagsubsystemen op te bouwen, is een cruciale bouwsteen voor IT-begrip en is breed toepasbaar op een groot aantal IT-activiteiten.