Enhetsframträdande

Ett av de mer vanliga, men ändå mer knepiga grundläggande begreppen inom databehandling idag är begreppet enhetsframträdande eller, med andra ord, något som framstår som en hårddisk. Detta kan låta enkelt, och mestadels är det det, men det kan vara knepigt.

Först, vad är en hårddisk. Detta borde vara enkelt. Vi menar normalt en traditionell Winchester-enhet med roterande skiva av det slag som tillverkats i decennier i standardformaten tre och en halv tum samt två och en halv tum. De innehåller plattor som roterar, ett läshuvud som rör sig framåt och bakåt, och de ansluts med något i stil med ATA- eller SCSI-kontakter. De flesta av oss kan plocka upp en hårddisk med händerna och vara säkra på att vi har en hårddisk. Detta är vad vi kallar enhetens fysiska manifestation.

För datorn ser den dock varken enhetens hölje eller kontakterna. Datorn måste se genom sin elektronik och “se” enheten digitalt. Detta skiljer sig mycket, mycket från hur människor betraktar den fysiska enheten. För datorn framstår en hårddisk som en ATA-, SCSI- eller Fibre Channel-enhet på den mest grundläggande fysiska nivån och abstraheras i allmänhet på en högre nivå som en blockenhet. Detta är vad vi skulle kalla ett logiskt framträdande, snarare än ett fysiskt. För våra syften här kommer vi att betrakta alla dessa enhetsgränssnitt som blockenheter. De skiljer sig åt, men endast något och inte på ett sätt som har betydelse för diskussionen. Det som är viktigt är att det finns ett standardgränssnitt eller en uppsättning nära besläktade gränssnitt som datorn ser som en hårddisk.

Ett annat sätt att tänka på det logiska enhetsframträdandet här är att allt som ser ut som en hårddisk för datorn är något som datorn kan formatera med ett filsystem. Filsystem är inte enheter i sig själva, utan kräver en enhet att placeras på.

Begreppet gränssnitt är det viktigaste här. För datorn är det “allt som implementerar ett hårddiskgränssnitt” som verkligen ses som en hårddisk. Detta är ett både enkelt och kraftfullt begrepp.

Det är tack vare användningen av ett standardgränssnitt som vi kunde ta flashminne, ansluta det till en diskstyrenhet som presenterar det över ett standardprotokoll (både SATA- och SAS-implementationer av ATA och SCSI är vanliga för detta idag) och skapa SSD:er som ser ut och beter sig exakt som traditionella Winchester-enheter för datorn, men ändå inte har något fysiskt gemensamt med dem. De kan komma i en bekant fysisk formfaktor eller inte, men de saknar definitivt plattor och ett läshuvud. Om vi betraktade hur en traditionell hårddisk och en modern SSD fungerar skulle vi inte gissa att de delar ett syfte.

Detta begrepp gäller många enheter. Uppenbarligen fungerar SD-kort och USB-minnen på samma sätt. Men viktigt nog är det så här partitioner ovanpå hårddiskar fungerar. Partitioneringssystemet använder begreppet enhetsframträdandegränssnitt på ena sidan för att kunna appliceras på en enhet, och på den andra sidan presenterar det ett enhetsframträdandegränssnitt mot vad som än vill använda det; normalt ett filsystem. Denna idé om något som använder enhetsframträdandegränssnittet på båda sidor är mycket viktig. Genom att göra detta får vi ett enhetligt och universellt byggblockssystem för att skapa komplexa lagringssystem!

Vi ser detta begrepp om “enhet in; enhet ut” i många fall. Förmodligen det mest kända är RAID. Ett RAID-system tar en array av hårddiskar, applicerar en av ett antal algoritmer för att få enheterna att agera som ett lag, och presenterar dem sedan som ett enda enhetsframträdande mot nästa system uppåt i “stacken.” Denna inkapsling är vad som ger RAID sin kraft: system längre upp i stacken som tittar på en RAID-array ser bokstavligen en hårddisk. De ser inte arrayen av enheter, de vet inte vad som finns under RAID:en. De ser bara den eller de resulterande enheter som RAID-systemet presenterar.

Eftersom ett RAID-system tar ett godtyckligt antal enheter och presenterar dem som en standardenhet har vi den teoretiska möjligheten att lagra RAID så många gånger vi vill. Naturligtvis skulle detta vara extremt opraktiskt att göra i någon större utsträckning. Men det är genom detta begrepp som nästlade RAID-arrayer är möjliga. Till exempel, om vi hade många fysiska hårddiskar uppdelade i par och varje par i en RAID 1-array. Var och en av de resulterande arrayerna presenteras som en enda enhet. Var och en av de resulterande logiska enheterna kan kombineras till ytterligare en RAID-array, såsom RAID 0. Att göra detta är hur RAID 10 byggs. Går vi vidare skulle vi kunna ta ett antal RAID 10-arrayer, presentera dem alla för ytterligare ett RAID-system som placerar dem i RAID 0 igen och få RAID 100 och så vidare i oändlighet.

På liknande sätt använder det logiska volymlagret samma slags inkapsling som RAID för att utföra sin magi. Logiska volymhanterare, såsom LVM på Linux och Dynamic Disks på Windows, placeras ovanpå logiska diskar och tillhandahåller ett lager där du kan utföra kraftfull hantering, såsom att flexibelt utöka enheter eller aktivera ögonblicksbilder, och presenterar sedan logiska diskar (alias enhetsframträdandegränssnitt) mot nästa lager i stacken.

På grund av enhetsframträdandens enhetliga natur kan stacken ske i vilken ordning som helst. En logisk volymhanterare kan placeras ovanpå RAID, eller RAID kan placeras ovanpå en logisk volymhanterare, och naturligtvis kan du hoppa över det ena eller det andra eller båda!

Begreppet enhetsframträdanden eller logiska hårddiskar är kraftfullt i sin enkelhet och ger oss stor potential att anpassa lagringssystem hur vi än behöver utforma dem.

Naturligtvis finns det även andra användningar av begreppet logisk enhet. En av de mest populära och minst förstådda är SAN. Ett SAN är inget annat än en enhet som tar en eller flera fysiska diskar och presenterar dem som logiska enheter (denna presentation av en logisk enhet från ett SAN kallas en LUN) över nätverket. Detta är, helt bokstavligen, allt som ett SAN är. De flesta SAN:er kommer att inkludera ett RAID-lager och troligen ett logiskt volymhanterarlager innan de presenterar de slutliga LUN:erna, eller enhetsframträdandena, mot nätverket, men det krävs inte för att vara ett SAN.

Detta innebär naturligtvis att flera SAN-LUN:er kan kombineras i en enda RAID eller styras via ett logiskt volymlager. Och naturligtvis innebär det att en SAN-LUN, en fysisk hårddisk, en RAID-array, en logisk volym, en partition…. alla kan formateras med ett filsystem eftersom de alla är olika sätt att uppnå samma resultat. De beter sig alla identiskt. De delar alla enhetsframträdandegränssnittet.

För att ge ett verkligt exempel på hur du ofta skulle se alla dessa delar komma samman ska vi granska en av de vanligaste “lagringsstackarna” som du hittar i företagsmiljöer. Naturligtvis finns det många sätt att bygga en lagringsstack, så bli inte förvånad om din är annorlunda. Längst ner i stacken finns nästan alltid fysiska hårddiskar, vilket skulle kunna inkludera SSD-enheter. Dessa är fysiskt placerade inuti ett SAN. Innan stacken lämnar SAN:et kommer den troligen att inkludera enheternas faktiska lagringslager, sedan ett RAID-lager som kombinerar dessa enheter till en enda entitet. Sedan ett logiskt volymlager för att möjliggöra funktioner som tillväxt och ögonblicksbilder. Sedan finns den fysiska gränsdragningen mellan SAN:et och servern som presenteras som LUN:en. LUN:en får sedan en logisk volymhanterare applicerad på sig på server-/operativsystemsidan av gränsdragningspunkten. Sedan ovanpå den LUN:en finns ett filsystem, vilket är vårt sista steg eftersom filsystemet inte fortsätter att presentera ett enhetsframträdandegränssnitt utan istället ett filgränssnitt.

Att förstå enhetsframträdande, eller logiska enheter, och hur dessa låter komponenter samverka med varandra för att bygga komplexa lagringsundersystem är ett kritiskt byggblock för IT-förståelse och är brett tillämpligt på ett stort antal IT-aktiviteter.