SAN en NAS vergeleken

Een van de grootste verwarringen die ik de afgelopen jaren heb gezien, is die tussen NAS en SAN. Begrijpen wat elk van beide is, draagt sterk bij aan het begrijpen waar ze nuttig en passend zijn.

Onze eerste taak is om de marketingtermen weg te strippen en over te gaan op technische termen. NAS staat voor Network Attached Storage maar betekent niet precies dat, en SAN staat voor Storage Area Network maar wordt over het algemeen gebruikt om te verwijzen naar een SAN-apparaat, niet naar het netwerk zelf. In zijn meest correcte vorm is een SAN elk netwerk dat aan opslagverkeer is gewijd, maar in de echte wereld wordt het zo niet normaal gebruikt. In dit geval zijn we hier om over NAS- en SAN-apparaten te praten en hoe ze zich verhouden, dus we zullen niet de definitie hanteren die het netwerk in plaats van het apparaat omvat. In werkelijkheid zijn zowel NAS als SAN marketingtermen en zijn ze daardoor wat vaag aan de randen. Ze zijn nauwkeurig genoeg om in een normaal technisch gesprek te gebruiken, zolang alle partijen weten wat ze betekenen, maar bij het bespreken van hun betekenis moeten we de stoer klinkende namen wegstrippen en ons houden aan de meest technische beschrijvingen. Beide termen worden, wanneer ze via marketing worden gebruikt, ingezet om te impliceren dat het om een bepaalde technologie gaat die is “geappliancized”, wat het gebruik van de termen onnodig ingewikkeld maakt maar niet nuttiger.

Onze eerste taak is dus om te definiëren wat deze twee namen betekenen in de context van een apparaat. Beide apparaten zijn opslagservers, simpel en eenvoudig, slechts twee verschillende manieren om die opslag aan de buitenwereld bloot te stellen.

De eenvoudigste van de twee is de SAN, die eigenlijk een blockstorage-apparaat is. Elk apparaat dat zijn opslag extern als een block-apparaat blootstelt, valt in deze categorie en kan uitwisselbaar worden gebruikt op basis van hoe het wordt ingezet. De blockstorage-apparaten zijn externe harde schijven, DAS (Direct Attach Storage) en SAN. Dit zijn eigenlijk allemaal hetzelfde. We noemen het een externe harde schijf wanneer we het aan een desktop koppelen. We noemen het een DAS wanneer we het aan een server koppelen. We noemen het een SAN wanneer we een vorm van netwerk toevoegen, doorgaans een switch, tussen het apparaat en het uiteindelijke apparaat dat de opslag verbruikt. Er is geen technologisch verschil tussen deze apparaten. Een traditionele SAN kan rechtstreeks aan een desktop worden gekoppeld en als een externe harde schijf worden gebruikt. Een externe harde schijf kan aan een switch worden gehangen en door meerdere apparaten op een netwerk worden gebruikt. De interface tussen het opslagapparaat en het systeem dat het gebruikt, is het block. Veelgebruikte protocollen voor blockstorage zijn onder andere iSCSI, Fibre Channel, SAS, eSATA, USB, Thunderbolt, IEEE1394 (ook bekend als Firewire), Fibre Channel over Ethernet (FCoE) en ATA over Ethernet (AoE). Een apparaat dat zich aan een blockstorage-apparaat koppelt, zal de opslag altijd zien gepresenteerd als een schijfstation, niets meer.

Een NAS, ook bekend als een “filer”, is een filestorage-apparaat. Dit betekent dat het zijn opslag blootstelt als een netwerkbestandssysteem. Dus elk apparaat dat zich aan deze opslag koppelt, ziet geen schijfstation maar in plaats daarvan een aankoppelbaar bestandssysteem. Wanneer een NAS niet als appliance verpakt is, noemen we het gewoon een bestandsserver en vrijwel alle computerapparaten, van desktops tot servers, hebben deze functionaliteit in zekere mate ingebouwd. Veelgebruikte protocollen voor filestorage-apparaten zijn onder andere NFS, SMB / CIFS en AFP. Er zijn er echter veel meer, en technisch gezien zijn er bijzondere filestorage-protocollen zoals FTP en HTTP die zich daar ook voor kwalificeren. Als extreem voorbeeld: een traditionele webserver is een zeer gespecialiseerde vorm van filestorage-apparaat.

Wat blockstorage- en filestorage-apparaten onderscheidt, is het type interface dat ze aan de buitenwereld presenteren, of, anders gedacht, waar de scheiding tussen serverapparaat en clientapparaat plaatsvindt binnen de opslagstack.

Het is tegenwoordig uiterst gebruikelijk geworden dat opslagapparaten zowel blockstorage als filestorage vanuit hetzelfde apparaat bieden. Systemen die dit doen, worden unified storage genoemd. Bij unified storage is of je kunt zeggen dat het zich gedraagt als een blockstorage- of een filestorage-apparaat (SAN of NAS in de gangbare spreektaal) of beide, gebaseerd op het gedrag dat je voor het apparaat configureert en niet op wat je aanschaft. Dit is belangrijk omdat het het punt benadrukt dat dit puur een protocol- of interface-onderscheid is, niet een van omvang, capaciteit, betrouwbaarheid, prestaties, functies, enzovoort.

Beide soorten apparaten hebben de optie, maar niet de verplichting, om uitgebreide functies te bieden onder het “demarcatiepunt” waarop ze de opslag aan de buitenkant overdragen. Beide kunnen al dan niet RAID, logical volume management, monitoring, enzovoort bieden. Filestorage (NAS) kan ook bestandssysteemfuncties bieden zoals Windows NTFS-ACL’s.

Het belangrijkste voordeel van blockstorage is dat de systemen die zich eraan koppelen de gelegenheid krijgen om het opslagsysteem te manipuleren alsof het een traditioneel schijfstation is. Dit betekent dat RAID en logical volume management, die mogelijk al in de “black box” van het opslagapparaat zijn uitgevoerd, nu desgewenst opnieuw kunnen worden gedaan op een hoger niveau. De clientapparaten zijn zich er niet van bewust wat voor soort apparaat ze zien, alleen dat het zich voordoet als een schijfstation. Je kunt er dus voor kiezen om het te vertrouwen (er bijvoorbeeld van uitgaan dat het RAID van een toereikend niveau heeft) of je kunt meerdere blockstorage-apparaten samenvoegen tot RAID, net alsof het gewone lokale schijven waren. Dit is uiterst ongebruikelijk maar het is een interessante optie en er zijn producten die zo zijn ontworpen om op deze manier te worden gebruikt.

Vaker wordt logical volume management zoals Linux LVM, Solaris ZFS of Windows Dynamic Disks toegepast bovenop de blootgestelde blockstorage van het apparaat en vervolgens wordt daar bovenop een bestandssysteem ingezet. Dit is belangrijk om te onthouden: bij blockstorage-apparaten wordt het bestandssysteem aangemaakt en beheerd door het clientapparaat, niet door het opslagapparaat. Het opslagapparaat is zich er volkomen onbewust van hoe de blockstorage die het presenteert wordt gebruikt en laat de eindgebruiker het naar eigen inzicht gebruiken met volledige controle. Dit gaat zelfs zo ver dat je blockstorage-apparaten aan elkaar kunt koppelen, waarbij het ene de opslag levert aan het volgende, mogelijk gecombineerd in RAID-groepen – blockstorage-apparaten kunnen min of meer eindeloos worden gestapeld.

Een filestorage-apparaat bevat daarentegen het volledige block-gedeelte van de opslag, dus elke mogelijkheid voor RAID, logical volume management en monitoring moet door het filestorage-apparaat worden afgehandeld. Vervolgens wordt bovenop de blockstorage een bestandssysteem toegepast. Doorgaans zou dit Linux’ EXT4, FreeBSD en Solaris’ ZFS, of Windows NTFS zijn, maar andere bestandssystemen zoals WAFL, XFS, JFS, BtrFS, UFS en meer behoren zeker tot de mogelijkheden. Op dit bestandssysteem worden gegevens opgeslagen. Om die gegevens vervolgens met de buitenwereld te delen, wordt een netwerkbestandssysteem (ook bekend als een gedistribueerd bestandssysteem) gebruikt dat een bestandssysteeminterface biedt die netwerkgeschikt is – NFS, SMB en AFP zijn daarbij het meest gangbaar, maar zoals bij elke protocolfamilie zijn er talloze bijzondere en exotische mogelijkheden.

Een extern apparaat dat opslag op het filestorage-apparaat wil gebruiken, zou het over het netwerk op dezelfde manier zien als een lokaal bestandssysteem en kan het op identieke wijze aankoppelen. Dit maakt filestorage bijzonder eenvoudig en vanzelfsprekend in gebruik voor de eindgebruiker, omdat het in elk opzicht zeer natuurlijk aanvoelt. We gebruiken elke dag netwerkbestandssystemen voor normaal desktopgebruik. Wanneer we bijvoorbeeld in Windows een “netwerkschijf toewijzen”, gebruiken we een netwerkbestandssysteem.

Een cruciaal onderscheid tussen blockstorage en filestorage dat moet worden gemaakt, is dat, hoewel beide potentieel op een netwerk kunnen staan en meerdere clientmachines zich eraan kunnen laten koppelen, alleen filestorage-apparaten de mogelijkheid hebben om die toegang te arbitreren. Dit is zeer belangrijk en mag niet worden weggewuifd.

Blockstorage verschijnt als een schijfstation. Als je simpelweg een schijfstation aan twee of meer computers tegelijk koppelt, kun je je voorstellen wat er gebeurt – elk weet niets van het andere en zal zich niet bewust zijn van nieuwe bestanden die worden aangemaakt of andere die veranderen, en de systemen zullen elkaar snel beginnen te overschrijven. Als je bestandssysteem op alle nodes alleen-lezen is, is dit geen probleem. Maar als enig systeem de gegevens schrijft of wijzigt, krijgen de andere problemen. Dit resulteert over het algemeen zeer snel in gegevensbeschadiging, doorgaans in de orde van minuten. Om dit in extreme actie te zien: stel je voor dat twee of drie clientsystemen allemaal geloven dat ze exclusieve toegang tot een schijfstation hebben en ze het allemaal tegelijkertijd laten defragmenteren. Alle gegevens op de schijf zullen in seconden door elkaar worden gehusseld.

Een filestorage-apparaat heeft daarentegen natuurlijke arbitrage, aangezien het netwerkbestandssysteem de communicatie voor toegang tot het werkelijke bestandssysteem afhandelt en bestandssystemen van nature multi-user zijn. Dus als één systeem dat aan een filestorage-apparaat is gekoppeld een wijziging aanbrengt, zijn alle systemen daar onmiddellijk van op de hoogte en zullen ze elkaar niet “voor de voeten lopen”. Zelfs als ze dat proberen, arbitreert het bestandssysteem van het filestorage-apparaat de toegang en heeft het het laatste woord en laat dit niet gebeuren. Dit maakt het delen van gegevens gemakkelijk en transparant voor eindgebruikers. (Ik gebruik de term “eindgebruikers” hier inclusief systeembeheerders.)

Dit betekent niet dat er geen manier is om opslag vanaf een block-apparaat te delen, maar de arbitrage daarvan kan niet door het blockstorage-apparaat zelf worden afgehandeld. Blockstorage-apparaten worden “deelbaar” gemaakt door gebruik te maken van wat bekendstaat als een clustered filesystem. Dit soort bestandssystemen is ontstaan in de tijd dat serverclusters opslagbronnen deelden door twee servers te koppelen met een SCSI-controller aan beide uiteinden van één SCSI-kabel en de gedeelde schijven in het midden van de kabel aan te sluiten. De enige manier waarop de servers konden communiceren was via het bestandssysteem zelf, en daarom werden er speciale clustered filesystems ontwikkeld die communicatie tussen de apparaten mogelijk maakten, waarbij elk werd gewaarschuwd voor wijzigingen die het andere had aangebracht, via het bestandssysteem zelf. Dit werkt eigenlijk verrassend goed, maar clustered filesystems zijn relatief ongebruikelijk, waarbij Red Hat’s GFS en Oracle’s OCFS enkele van de bekendste zijn in de traditionele serverwereld en VMWare’s veel nieuwere VMFS uiterst bekend is geworden door het gebruik ervan voor virtualisatieopslag. Normale gebruikers, waaronder systeembeheerders, hebben mogelijk geen toegang tot clustered filesystems of hebben behoeften die het gebruik ervan niet toestaan. Van belang is ook dat de arbitrage wordt afgehandeld via vertrouwen, niet via afdwinging, zoals bij een filestorage-apparaat. Bij een filestorage-apparaat handelt het apparaat zelf de toegangsarbitrage af en is daar geen weg omheen. Bij blockstorage-apparaten die een clustered filesystem gebruiken, kan elk apparaat dat zich aan de opslag koppelt het clustered filesystem negeren en simpelweg de passieve arbitrage omzeilen – dit is zo eenvoudig dat het normaal gesproken per ongeluk zou gebeuren. Het kan gebeuren bij het aankoppelen van het bestandssysteem en het opgeven van het verkeerde bestandssysteemtype, of doordat een schijf zich misdraagt of door enige kwaadwillige actie. Toegangsbeveiliging op netwerkniveau is dus cruciaal om blockstorage te beschermen.

Het onderliggende concept dat hier wordt blootgelegd, is dat blockstorage-apparaten domme apparaten zijn (denk aan een opgewaardeerd schijfstation) en filestorage-apparaten slimme apparaten zijn (denk aan een traditionele server). Filestorage-apparaten moeten een volledig werkende “computer” bevatten met CPU, geheugen, opslag, bestandssysteem en netwerk. Blockstorage-apparaten kunnen deze zaken bevatten maar hoeven dat niet. In hun eenvoudigste vorm kunnen blockstorage-apparaten niets meer zijn dan een schijfstation met een USB- of Ethernet-adapter eraan gekoppeld. Het is eigenlijk niet ongebruikelijk dat ze niets meer zijn dan een RAID-controller plus Ethernet- of Fibre Channel-adapters.

In beide gevallen, blockstorage-apparaat en filestorage-apparaat, kunnen we afschalen naar triviaal eenvoudige apparaten of opschalen naar enorme “mainframe-class” systemen met ultrahoge beschikbaarheid. Beide kunnen snel of langzaam zijn. Het ene is niet beter of slechter, het ene is niet hoger of lager, het ene is niet meer of minder enterprise – ze zijn verschillend en dienen over het algemeen verschillende doelen. En er zijn geavanceerde functies die elk al dan niet kan bevatten. De uitdaging schuilt in het weten welk apparaat juist is voor welke taak.

Ik denk graag aan blockstorage-protocollen als een “standard out”-stroom, vergelijkbaar met die op een commandline. Het basisniveau van elke opslag-“pipeline” is dus altijd een block-apparaat en er kunnen talloze block-apparaten of transformaties bestaan die elk van het ene naar het andere worden gepiped, zolang de uitvoer een blockstorage-protocol blijft. We beëindigen de keten pas wanneer we een bestandssysteem toepassen. Op deze manier kunnen hardware-RAID, netwerk-RAID, logical volume management, enzovoort, in meerdere combinaties naar behoefte worden toegepast. Blockstorage bestaat werkelijk niet alleen uit blokken gegevens, maar uit bouwblokken van opslagsystemen.

Een punt dat zeer interessant is, is dat aangezien blockstorage-apparaten aan elkaar kunnen worden gekoppeld en aangezien netwerkopslagapparaten blockstorage als hun “invoer” moeten accepteren, het eigenlijk vrij gebruikelijk is dat een blockstorage-apparaat (SAN) wordt gebruikt als de onderliggende opslag voor een filestorage-apparaat (NAS), vooral in highend-systemen. Ze kunnen samen in één behuizing bestaan of ze kunnen op het netwerk samenwerken.