Hur man konfigurerar RAID i Linux steg för steg

Denna handledning förklarar hur man visar, listar, skapar, lägger till, tar bort, raderar, ändrar storlek, formaterar, monterar och konfigurerar RAID-nivåer (0, 1 och 5) i Linux steg för steg med praktiska exempel. Lär dig grundläggande koncept för mjukvaru-RAID (Chunk, Mirroring, Striping och Parity) och viktiga kommandon för RAID-enhetshantering i detalj.

RAID står för Redundant Array of Independent Disks. Det finns två typer av RAID; hårdvaru-RAID och mjukvaru-RAID.

Hårdvaru-RAID

Hårdvaru-RAID är en fysisk lagringsenhet som är uppbyggd av flera hårddiskar. Vid anslutning till systemet visas alla diskar som en enda SCSI-disk i systemet. Ur systemsynpunkt finns det ingen skillnad mellan en vanlig SCSI-disk och en hårdvaru-RAID-enhet. Systemet kan använda hårdvaru-RAID-enheten som en enda SCSI-disk.

Hårdvaru-RAID har sitt eget oberoende disksubsystem och sina egna resurser. Den använder inga resurser från systemet, t.ex. ström, RAM och CPU. Hårdvaru-RAID innebär ingen extra belastning för systemet. Eftersom den har egna dedikerade resurser ger den hög prestanda.

Mjukvaru-RAID

Mjukvaru-RAID är en logisk lagringsenhet som byggs upp av anslutna diskar i systemet. Den använder alla resurser från systemet. Den ger långsam prestanda men kostar ingenting. I den här handledningen kommer vi att lära oss hur man skapar och hanterar software RAID i detalj.

Denna handledning är den sista delen av vår artikel ”Linux Disk Management Explained in Easy Language with Examples”. Du kan läsa andra delar av artikeln här.

Grundläggande begrepp för RAID

En RAID-enhet kan konfigureras på flera olika sätt. Beroende på konfigurationen kan den kategoriseras i tio olika nivåer. Innan vi diskuterar RAID-nivåer mer i detalj ska vi ta en snabb titt på några viktiga termer som används vid RAID-konfiguration.

Chunk: – Detta är storleken på det datablock som används i RAID-konfigurationen. Om storleken på en bit är 64 KB finns det 16 bitar i en RAID-array på 1 MB (1024 KB/64 KB).

Hot Spare: – Detta är den extra disken i RAID-matrisen. Om någon disk går sönder flyttas data från den felaktiga disken automatiskt till denna reservdisk.

Mirroring: – Om denna funktion är aktiverad sparas en kopia av samma data även på den andra disken. Det är precis som att göra en extra kopia av data för säkerhetskopiering.

Striping: – Om den här funktionen är aktiverad kommer data att skrivas slumpmässigt på alla tillgängliga diskar. Det är precis som att dela data mellan alla diskar, så att alla diskar fylls lika mycket.

Paritet: – Detta är en metod för att återskapa förlorade data från sparad paritetsinformation.

Differenta RAID-nivåer definieras baserat på hur spegling och strippning krävs. Bland dessa nivåer är det bara nivå 0, nivå 1 och nivå 5 som används mest i Red Hat Linux.

RAID-nivå 0

Denna nivå ger strippning utan paritet. Eftersom den inte lagrar några paritetsdata och utför läs- och skrivoperationer samtidigt är hastigheten mycket högre än på andra nivåer. Denna nivå kräver minst två hårddiskar. Alla hårddiskar på denna nivå fylls lika mycket. Du bör använda denna nivå endast om läs- och skrivhastigheten är viktig. Om du bestämmer dig för att använda den här nivån ska du alltid använda en alternativ plan för säkerhetskopiering av data. Eftersom varje enskilt diskfel i matrisen leder till total dataförlust.

RAID Level 1

Denna nivå ger paritet utan striping. Alla data skrivs på två diskar. Om en disk går sönder eller tas bort har vi fortfarande alla data på den andra disken. Denna nivå kräver dubbla hårddiskar. Det innebär att om du vill använda två hårddiskar måste du installera fyra hårddiskar eller om du vill använda en hårddisk måste du installera två hårddiskar. Den första hårddisken lagrar originaldata medan den andra hårddisken lagrar en exakt kopia av den första hårddisken. Eftersom data skrivs två gånger kommer prestandan att minska. Du bör endast använda denna nivå om datasäkerheten är viktig till varje pris.

RAID-nivå 5

Denna nivå ger både paritet och striping. Den kräver minst tre diskar. Den skriver paritetsdata lika mycket på alla diskar. Om en disk går sönder kan data rekonstrueras från paritetsdata som finns på resterande diskar. Detta ger en kombination av integritet och prestanda. Om möjligt bör du alltid använda denna nivå.

Om RAID-enheten är korrekt konfigurerad kommer det inte att finnas någon skillnad mellan mjukvaru-RAID och hårdvaru-RAID ur operativsystems synvinkel. Operativsystemet kommer att få tillgång till RAID-enheten som en vanlig hårddisk, oavsett om det är en mjukvaru-RAID eller hårdvaru-RAID.

Linux tillhandahåller md-kärnmodulen för konfigurering av mjukvaru-RAID. För att använda mjukvaru-RAID måste vi konfigurera RAID md-enheten som är en sammansättning av två eller flera lagringsenheter.

Hur man konfigurerar mjukvaru-RAID steg för steg

För den här handledningen utgår jag från att du har opartionerat diskutrymme eller ytterligare hårddiskar för övning. Om du följer den här handledningen på virtuell programvara som VMware Workstation lägger du till tre extra hårddiskar i systemet. Om du vill veta hur du lägger till ytterligare hårddiskar i ett virtuellt system, se den första delen av denna handledning. Om du följer den här handledningen på en fysisk maskin, anslut en extra hårddisk. Du kan använda ett USB-minne eller en penna för att öva. I demonstrationssyfte har jag anslutit tre extra hårddiskar i mitt labbsystem.

Varje disk är 2 GB stor. Vi kan lista alla anslutna hårddiskar med kommandot fdisk -l.

Vi kan också använda kommandot lsblk för att få en strukturerad översikt över alla anslutna lagringsenheter.

Som vi kan se i ovanstående utdata finns det tre opartitionerade diskar tillgängliga med en storlek på 2G vardera.

Paketet mdadm används för att skapa och hantera mjukvaru-RAID. Se till att det är installerat innan vi börjar arbeta med mjukvaru-RAID.För att lära dig hur man installerar och hanterar paket i Linux se följande tutorials

Hur man konfigurerar YUM Repository i RHEL
RPM Command Explained with Example

För den här handledningen förutsätter jag att mdadm-paketet är installerat.

Skapa RAID 0-array

Vi kan skapa RAID 0-array med diskar eller partitioner. För att förstå båda alternativen kommer vi att skapa två separata RAID 0-matriser, en med diskar och en med partitioner. RAID 0-array kräver minst två diskar eller partitioner. Vi kommer att använda diskarna /dev/sdc och /dev/sdd för att skapa RAID 0 Array från diskar. Vi kommer att skapa två partitioner i /dev/sdb och senare använda dem för att skapa en annan RAID 0-array från partitioner.

För att skapa RAID 0 Array med diskar använder du följande kommando

#mdadm --create --verbose /dev/ --level= --raid-devices= 

Låt oss förstå detta kommando i detalj

mdadm:- Det här är huvudkommandot

–create:- Det här alternativet används för att skapa en ny md-enhet (RAID).

–verbose:- Det här alternativet används för att visa processens uppdatering i realtid.

/dev/:- Det här argumentet används för att ange namn och plats för RAID-matrisen. Md-enheten ska skapas under katalogen /dev/.

–level=:- Det här alternativet och argumentet används för att definiera den RAID-nivå som ska skapas.

–raid-devices=:- Det här alternativet och argumentet används för att ange antalet lagringsenheter eller partitioner som vi vill använda i den här enheten.

:- Det här alternativet används för att ange lagringsenhetens namn och plats.

Följande kommando kommer att användas för att skapa en RAID 0-array från diskarna /dev/sdc och /dev/sdd med namnet md0.

För att verifiera matrisen kan vi använda följande kommando

Ovanstående utdata bekräftar att RAID-matrisen md0 framgångsrikt har skapats från två diskar (sdd och sdc) med RAID-nivå 0-konfigurationer.

Skapa RAID 0-array med partitioner

Skapa en 1GiB-partition med kommandot fdisk

Som standard skapas alla partitioner enligt Linuxstandard. Ändra partitionstyp till RAID och spara partitionen. Avsluta från fdisk-verktyget och kör kommandot partprobe för att uppdatera kärnans partitionstabell vid körning.

Om du vill lära dig fdisk-kommandot och dess underkommandon i detalj, se den andra delen av den här handledningen som förklarar hur du skapar och hanterar partitioner med fdisk-kommandot steg för steg.

Låt oss skapa ytterligare en partition men den här gången använder vi kommandot parted.

För att lära dig kommandot parted i detalj, se den fjärde delen av den här handledningen som förklarar hur man hanterar diskar med kommandot parted steg för steg.

Vi har skapat två partitioner. Låt oss bygga en annan RAID-array (nivå 0) men den här gången använder vi partitioner istället för diskar.

Samma kommando kommer att användas för att skapa en RAID-array från partitioner.

När vi använder mdadm-kommandot för att skapa en ny RAID-array, så sätter det sin signatur på den tillhandahållna enheten eller partitionen.Det betyder att vi kan skapa en RAID-array från vilken typ av partition som helst eller till och med från en disk som inte innehåller någon partition alls. Så vilken partitionstyp vi använder här är inte viktigt, den viktiga punkt som vi alltid bör tänka på är att partitionen inte får innehålla några värdefulla data. Under denna process kommer alla data från partitionen att raderas.

Skapa filsystem i RAID-array

Vi kan inte använda RAID-array för datalagring förrän den innehåller ett giltigt filsystem. Följande kommando används för att skapa ett filsystem i matrisen.

#mkfs –t 

Låt oss formatera md0 med ext4-filsystemet och md1 med xfs-filsystemet.

RAID 0-matriserna är redo att användas. För att kunna använda dem måste vi montera dem någonstans i Linux filsystem.Linux filsystem (primär katalogstruktur) börjar med katalogen root (/) och allt går under den eller dess underkataloger.Vi måste montera partitioner någonstans under detta katalogträd. Vi kan montera partitioner temporärt eller permanent.

Temporär montering av RAID 0-array

Följande kommando används för att montera arrayen temporärt.

#mount 

Mount-kommandot accepterar flera alternativ och argument som jag kommer att förklara separat i en annan tutorial. För den här handledningen räcker den här grundläggande syntaxen.

What to mount :- Det här är arrayen.

where to mount :- Det här är katalogen som kommer att användas för att få tillgång till den monterade resursen.

När den väl är monterad kommer alla åtgärder som vi utför i den monterade katalogen att utföras i de monterade resurserna. Låt oss förstå det praktiskt.

• Skapa en monterad katalog i /-katalogen
• Mount /dev/md0 array
• Lista innehållet
• Skapa en testkatalog och fil
• Lista innehållet igen
• Un-montera /dev/md0-matrisen och lista innehållet igen
• montera nu /dev/md1-matrisen och lista innehållet
• skapa återigen en testkatalog och -fil. Använd olika namn för filen och katalogen
• Lista upp innehållet
• Montera av arrayen /dev/md1 och lista upp innehållet igen

Följande figur illustrerar denna övning steg för steg

Som figuren ovan visar så utfördes den åtgärd som utfördes i mount-katalogen faktiskt i respektive array.

Temporary mount-alternativet är bra för matriser som vi har tillgång till ibland. Varje gång vi startar om systemet så avmonteras alla temporärt monterade resurser automatiskt när vi startar om systemet. Så om vi har en matris som kommer att användas regelbundet bör vi montera den permanent.

Montera RAID-matris permanent

Varje resurs i filsystemet har ett unikt ID som kallas UUID. När vi monterar en matris permanent bör vi använda UUID i stället för dess namn. Från och med version 7 använder RHEL också UUID istället för enhetsnamn.

UUUID står för Universally Unique Identifier. Det är ett 128-bitars nummer, uttryckt i hexadecimalt format (bas 16).

Om du har en statisk miljö kan du använda enhetsnamn. Men om du har en dynamisk miljö bör du alltid använda UUID. I en dynamisk miljö kan enhetsnamnet ändras varje gång när systemet startas. Om vi till exempel anslutit ytterligare en SCSI-disk i systemet kommer den att heta /dev/sdb. Vi monterade den här disken permanent med dess enhetsnamn. Anta att någon annan tar bort denna disk och ansluter en ny SCSI-disk till samma plats. Den nya disken kommer också att heta /dev/sdb. Eftersom namnet på den gamla disken och den nya disken är detsamma kommer den nya disken att monteras på samma plats som den gamla disken. På detta sätt kan enhetsnamnet skapa allvarliga problem i en dynamisk miljö. Men detta problem kan lösas med UUID. Oavsett hur vi kopplar resursen till systemet kommer dess UUID alltid att vara fast.

Om du har en statisk miljö kan du överväga enhetsnamn för att montera resursen. Men om du har en dynamisk miljö bör du alltid använda UUID.

För att få reda på UUID för alla partitioner kan vi använda kommandot blkid. För att få reda på UUID för en viss partition måste vi använda dess namn som argument i det här kommandot.

När vi väl känner till UUID kan vi använda det i stället för enhetens namn. Vi kan också använda alternativet kopiera och klistra in för att skriva in UUID.

• Använd kommandot blkid för att skriva ut UUID för arrayen.
• Kopiera UUID för arrayen.
• Använd kommandot mount för att montera arrayen. Använd alternativet paste istället för att skriva UUID.

Följande figur illustrerar ovanstående steg

När systemet startas tittar det i filen /etc/fstab för att ta reda på vilka enheter (partitioner, LV:s, swap eller array) som måste monteras i filsystemet automatiskt. Som standard har denna fil en post för de partitioner, logiska volymer och växlingsutrymme som skapades under installationen. För att montera ytterligare enheter (matriser) automatiskt måste vi skapa en post för den enheten i denna fil. Varje post i den här filen har sex fält:

Låt oss göra några kataloger för att montera de matriser som vi har skapat nyligen

Ta en säkerhetskopia av fstab-filen och öppna den för redigering

Gör poster för matriser och spara filen.

För demonstrationsändamål använde jag både enhetsnamn och UUID för att montera partitionerna. efter att ha sparat kontrollerar du alltid posterna med kommandot mount -a. Detta kommando kommer att montera allt som anges i filen /etc/fstab. Så om vi har gjort något misstag när vi uppdaterade denna fil kommer vi att få ett fel som resultat av detta kommando.

Om du får något fel som resultat av kommandot mount -a, korrigera det innan du startar om systemet.Om det inte finns något fel, starta om systemet.

Kommandot df -h används för att kontrollera det tillgängliga utrymmet i alla monterade partitioner. Vi kan använda det här kommandot för att kontrollera att alla partitioner är monterade korrekt.

Ovanstående utdata bekräftar att alla partitioner är monterade korrekt. Låt oss lista de båda RAID-enheterna.

Hur man tar bort RAID-array

Vi kan inte ta bort en monterad array. Avmontera alla matriser som vi skapade i den här övningen

Använd följande kommando för att stoppa RAID-matrisen

#mdadm --stop /dev/

Ta bort monteringskatalogen och kopiera tillbaka den ursprungliga fstab-filen.

Om du inte har tagit en säkerhetskopia av den ursprungliga fstab-filen ska du ta bort alla poster från den här filen som du har gjort.

Finnligen återställer du alla diskar som används i den här övningen.

Kommandot dd är det enklaste sättet att återställa disken. Diskverktyg lagrar sina konfigurationsparametrar i superblocket. Vanligtvis definieras superblockstorleken i KB så vi skrev bara över det första 10 MB stora utrymmet med nollbytes på varje disk. Om du vill lära dig dd-kommandot i detalj, se den femte delen av den här handledningen som förklarar det här kommandot i detalj.

Nu startar du om systemet och använder kommandot df -h igen för att verifiera att alla RIAD-enheter som vi skapade i den här övningen är borta.

Hur man skapar en RAID 1- och RAID 5-array

Vi kan skapa en RAID 1- eller RAID 5-array genom att följa samma procedur. Alla steg och kommandon kommer att vara desamma utom kommandot mdadm –create. I det här kommandot måste du ändra RAID-nivå, antal diskar och placering av tillhörande diskar.

För att skapa en RAID 1-matris från diskarna /dev/sdd och /dev/sdb använd följande kommando

För att skapa en RAID 1-matris från partitionerna /dev/sdb1 och /dev/sdb2 använd följande kommando Kommando

För att skapa en RAID 5-matris från /dev/sdb-, /dev/sdc- och /dev/sdd-diskarna använder du följande kommando.

RAID 5-konfigurationen kräver minst tre diskar eller partitioner. Därför har vi använt tre diskar här.

För att skapa en RAID 5-matris från partitionerna /dev/sdb1, /dev/sdb2 och /dev/sdb3 använder du följande kommando

För att undvika onödiga fel ska du alltid vila diskarna innan du använder dem i en ny övning.

Så här långt i den här handledningen har vi lärt oss att skapa, montera och ta bort RAID-matris. I följande avsnitt kommer vi att lära oss hur man hanterar och felsöker en RAID-array. För det här avsnittet antar jag att du har minst en array konfigurerad. I demonstrationssyfte kommer jag att använda det senast konfigurerade exemplet (RAID 5 med 3 partitioner). Låt oss skapa ett filsystem i den här matrisen och montera det.

Låt oss lägga in lite dummy data i den här katalogen.

Jag omdirigerade den manuella sidan för ls kommandot i filen /testingdata/manual-of-ls-command. För att verifiera att filen innehåller faktiska data använde jag senare kommandot wc som räknar rad, ord och tecken i filen.

Hur man visar detaljerna för RAID-enheten

Följande kommando används för att visa detaljerad information om RAID-enheten.

#mdadm --detail /dev/

Denna information omfattar RAID-nivå, storlek på matrisen, använd storlek av den totala tillgängliga storleken, enheter som används vid skapandet av matrisen, enheter som används för närvarande, extra enheter, felande enheter, storlek på bitarna, UUID för matrisen och mycket mer.

Hur man lägger till ytterligare disk eller partition i RIAD

Det finns flera situationer där vi måste öka storleken på en RAID-enhet, t.ex. när en RAID-enhet är fylld med data eller när en disk i en matris är trasig. För att öka utrymmet för RAID-enheten måste vi lägga till ytterligare disk eller partition i befintlig Array.

I det löpande exemplet använde vi /dev/sdb-disken för att skapa tre partitioner. /dev/sdc och /dev/sdd är fortfarande tillgängliga för användning. Innan vi lägger till dem i den här matrisen ska vi se till att de är rensade. Förra gången använde vi kommandot dd för att rensa diskarna. Vi kan använda det kommandot igen eller använda följande kommando

#mdadm --zero-superblock /dev/

För att kontrollera en disk om den innehåller superblock eller inte kan vi använda följande kommando

#mdadm --examine /dev/

Följande figur illustrerar användningen av båda kommandona på båda diskarna

Nu är båda diskarna redo för RAID Array. Följande kommando används för att lägga till ytterligare en disk i den befintliga matrisen.

#mdadm --manage /dev/ --add /dev/

Låt oss lägga till /dev/sdc-disken i den här matrisen och bekräfta samma sak.

Redan nu har den här disken lagts till som en reservdisk. Den här disken kommer inte att användas förrän någon disk går sönder i den befintliga matrisen eller om vi manuellt tvingar RAID att använda den här disken.

För säkerhetskopiering kommer vi att lägga till ytterligare en disk i matrisen, låt oss använda denna disk för att öka matrisens storlek. Följande kommando används för att öka storleken på RAID-enheten.

#mdadm --grow --raid-devices= /dev/

RAID arrangerar alla enheter i en sekvens. Denna sekvens byggs upp av den ordning i vilken diskarna läggs till i matrisen. När vi använder det här kommandot kommer RAID att lägga till nästa fungerande enhet i aktiva enheter.

Följande figur illustrerar det här kommandot

Som vi kan se i utmatningen ovan har diskar lagts till i matrisen och storleken på matrisen har ökat med framgång.

Föra bort felaktig enhet

Om det finns en reservenhet tillgänglig, kommer RAID automatiskt att ersätta den felaktiga enheten med reservenheten. Slutanvändaren kommer inte att se någon förändring. Han kommer att kunna få tillgång till data som vanligt. Låt oss förstå det praktiskt.

Rätt nu finns det ingen reservdisk tillgänglig i matrisen. Låt oss lägga till en reservdisk.

När en disk går sönder markerar RAID den disken som en misslyckad enhet. När den väl är markerad kan den tas bort på ett säkert sätt. Om vi vill ta bort en fungerande enhet från matrisen för underhåll eller felsökning bör vi alltid markera den som en misslyckad enhet innan vi tar bort den. När en enhet markeras som en misslyckad enhet rekonstrueras all data från den misslyckade enheten i de fungerande enheterna.

För att markera en disk som en misslyckad enhet används följande kommando.

#mdadm --manage --set-faulty /dev/ /dev/

Vi har nyligen ökat storleken på den här matrisen. Så innan vi gör det här ska vi kontrollera en gång till att arrayen fortfarande innehåller giltiga data.

Som ovanstående utdata bekräftar att arrayen fortfarande innehåller giltiga data. Låt oss nu markera en enhet /dev/sdc som en felaktig enhet från matrisen och bekräfta operationen.

Som ovanstående utdata bekräftar att enheten sdc, som är nummer fyra i matrissekvensen, har markerats som en misslyckad enhet.

Som vi vet om det finns en reservdisk tillgänglig, kommer den att användas som ersättning för den felaktiga enheten automatiskt. Ingen manuell åtgärd krävs i denna process. Låt oss bekräfta att reservdisken har använts som ersättning för den felaktiga disken.

Finnligt kan vi kontrollera att data fortfarande finns i matrisen.

Ovanstående utdata bekräftar att matrisen fortfarande innehåller giltiga data.

Det är allt för den här handledningen.