{"canonical_url":"https://engineer.company/sv/glossary/raid/","content_markdown":"# RAID\n\n## Vad det är\n\nRAID kör flera diskar som en enda blockenhet, så att gruppen blir snabbare, större eller svårare att\nslå ut än någon av diskarna den består av. Namnet kommer från en teknisk rapport från University of\nCalifornia, Berkeley, år 1987, skriven av David Patterson, Garth Gibson och Randy Katz: _A Case for\nRedundant Arrays of Inexpensive Disks (RAID)_. Linux skriver nivåerna med små bokstäver och utan\nmellanslag, raid1 eller raid5, vilket är hur dess md-drivrutin rapporterar dem.\n\nRapporten utgår från ett missförhållande. Processorer och minne blev allt snabbare, och\nsammanfattningen varnar för att vinsten går förlorad om in- och utmatningen inte hänger med. Den\nställer Single Large Expensive Disk, SLED, vars kapacitet hade vuxit snabbt medan prestandan bara\nförbättrats måttligt, mot arrayer byggda av de billiga diskar som tillverkades för persondatorer,\noch väntar sig att sådana arrayer ska slå den stora disken ungefär tio gånger om i fråga om\nhastighet, tillförlitlighet, strömförbrukning och utrymme för tillväxt. Jämförelsen är konkret: en\nIBM 3380 för stordatorer, en Fujitsu Super Eagle för minidatorer och den 100 MB stora Conner CP 3100\nför persondatorer.\n\nSedan kommer haken, i ett avsnitt som författarna själva betecknar som dåliga nyheter. Om diskar går\nsönder oberoende av varandra och i konstant takt, vilket rapporten påpekar att disktillverkarna\nförutsätter när de anger en medeltid till fel (MTTF), är arrayens MTTF lika med en disks MTTF delat\nmed antalet diskar. Hundra CP 3100, var och en angiven till 30 000 timmar, ger 300 timmar, under två\nveckor; tusen ger 30 timmar. Rapporten drar en rak slutsats: utan feltolerans är stora arrayer av\nbilliga diskar för opålitliga för att vara till någon nytta.\n\nSvaret är redundans. Diskarna delas in i tillförlitlighetsgrupper, var och en med extra\nkontrolldiskar som rymmer redundant information. När en disk går sönder byts den ut, och innehållet\nbyggs upp på den nya disken ur den informationen; tiden det tar är medeltiden till reparation\n(MTTR), och varma reservdiskar (hot standby spares), som kopplas in elektroniskt i samma stund som\nen disk dör, kortar den. Därefter lägger rapporten fram fem sätt att organisera diskarna och kallar\nvart och ett för en nivå. Nivå 1 speglar varje disk. Nivå 2 rättar fel med en Hammingkod, som\nminnessystem gjorde. Nivå 3 klarar sig med en enda kontrolldisk per grupp. Nivå 4 låter små\nläsningar och skrivningar gå till olika diskar samtidigt. Nivå 5 sprider data och\nkontrollinformation över alla diskar, så att ingen enskild kontrolldisk håller tillbaka\nskrivningarna.\n\nPraktiken har byggt på listan. mdadm, verktyget som hanterar mjukvaru-RAID i Linux, godtar bland\nannat linear, raid0 (eller stripe), raid1, raid4, raid5, raid6 och raid10. Striping utan redundans,\nsom numera kallas nivå 0, finns inte i indelningen från 1987, som börjar med speglade diskar.\nRapporten lämnade öppet om en array byggs i hårdvara eller i mjukvara och kallade det enbart en\nfråga om kostnad och nytta. Linux md är mjukvaruvarianten; ett kontrollerkort som visar\noperativsystemet en enda stor disk är hårdvaruvarianten.\n\n## Varför det spelar roll\n\nEn disk slits ut, och på en server med en enda disk stoppar haveriet maskinen och lämnar data åt den\nsäkerhetskopia som råkar finnas. Rapporten inleder sitt avsnitt om tillförlitlighet med just detta:\ndiskar är så opålitliga att systemansvariga säkerhetskopierar allt varje natt. Med redundans blir en\ntrasig disk ett reparationsjobb i stället för ett avbrott. Arrayen fortsätter på de diskar som finns\nkvar, i ett tillstånd som Linux kallar degraded (degraderad), och återgår till full styrka när en\nersättare har lagts till och byggts upp.\n\nDet skyddet varar bara så länge de återstående diskarna gör det. Rapportens kalkyler räknar data som\nförlorade när ytterligare en disk i samma grupp går sönder innan den första har reparerats, så\nlängden på reparationsfönstret väger lika tungt som antalet kontrolldiskar. Med varma reservdiskar\noch korta reparationer blir siffrorna imponerande: rapporten räknar ut att en nivå 5-array med 1 000\ndiskar, i grupper om tio och med 5 procent reservdiskar, fortfarande skulle ha en MTTF på 90 år. På\nett annat ställe varnar den för att en jordbävning eller en spänningstopp kan få diskarna i en array\natt gå sönder samtidigt, och dess formler förutsätter att det inte händer.\n\nValet av nivå är en avvägning mellan kapacitet, hastighet och kostnad. Rapportens egen slutsats är\natt speglade diskar passar transaktionsbehandling som använder högst hälften av lagringen, medan\nnivå 5 ser bäst ut när mer av kapaciteten behövs, för arbete på superdatorer eller för en blandning\nav sådant arbete och transaktionsbehandling.\n\nNär redundansen tar slut återstår räddning. Portföljposten om\n[räddning av data på SD-kort, hårddiskar, SSD:er och RAID](/sv/portfolio/recovered-data-from-sd-cards-hdds-ssds-and-raid/)\nbehandlar en trasig RAID-array som ett problem för sig, skilt från en död SSD eller en havererad\ndisk med skivor, där tillvägagångssättet beror på mediet.\n\n## Så ser det ut i praktiken\n\nTa en server med en partition på var och en av två diskar, `/dev/sda1` och `/dev/sdb1`, som ska\nspeglas till en datavolym. Med Linux md bygger tre kommandon arrayen, lägger ett filsystem på den\noch för in den i konfigurationen:\n\n```sh\nmdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1\nmke2fs -t ext4 -L data /dev/md0\nmdadm --detail --scan \u003e\u003e /etc/mdadm/mdadm.conf\n```\n\nDet första skapar `/dev/md0`, en RAID1-array av de två partitionerna, och kärnan startar en\nomsynkronisering (resync) som räknar om redundansen, precis som efter varje nyskapande. Det andra\nformaterar arrayen exakt som det skulle formatera en enskild disk; filsystemet ser en enda enhet.\nDet tredje lägger till en rad som beskriver arrayen i mdadm:s konfigurationsfil, som ligger i\n`/etc/mdadm.conf` eller `/etc/mdadm/mdadm.conf`, och manualen ber att utdata granskas före\nanvändning, eftersom de kan innehålla detaljer som ingen vill ha där.\n\nTre filer visar hur arrayen mår:\n\n```sh\ncat /proc/mdstat\ncat /sys/block/md0/md/degraded\ncat /sys/block/md0/md/sync_action\n```\n\n`/proc/mdstat` listar alla aktiva md-enheter med deras tillstånd, och mdadm läser den för att hitta\narrayer och följa återuppbyggnaden. Varje array har också en katalog under `/sys/block/`, och där\ninnehåller `degraded` antalet medlemmar som saknas: 0 för en hel array, 1 när en disk är borta.\n`sync_action` visar `idle` när ingenting pågår, `resync` efter nyskapande eller en okontrollerad\navstängning, `recover` medan en varm reservdisk tar över innehållet från en förlorad medlem, och\n`check` eller `repair` under en fullständig kontroll. Att skriva `check` till den startar den\nkontrollen, som läser varje block i arrayen:\n\n```sh\necho check \u003e /sys/block/md0/md/sync_action\ncat /sys/block/md0/md/mismatch_cnt\n```\n\nEfteråt anger `mismatch_cnt` antalet sektorer som skrevs om, eller som skulle ha skrivits om.\nKärndokumentationen påpekar att de flesta nivåer arbetar med sidor snarare än sektorer, så siffran\nkan bli större än antalet verkliga fel.\n\nNågon måste också få höra om ett haveri. `mdadm --monitor` frågar arrayerna med jämna mellanrum och\ngör om det den märker till händelser, som den kan skicka med e-post till en adress eller lämna till\nett program. På ett system som styrs av systemd pekar manualen ut `mdmonitor.service` som huvudvägen\noch `MAILADDR` i `mdadm.conf` som inställningen att fylla i för e-post. Bara fem händelser skickar\ne-post: `Fail`, `FailSpare`, `DegradedArray`, `SparesMissing` och `TestMessage`. Den sista finns för\natt bevisa att vägen fungerar:\n\n```text\nMAILADDR ops@example.com\n```\n\n```sh\nmdadm --monitor --scan --oneshot --test\nmdadm --detail --test /dev/md0\n```\n\nDet första kommandot skickar ett testmeddelande för varje array det hittar och avslutar sedan. Det\nandra passar i ett skript: med `--test` är slutstatusen 0 för en frisk array, 1 när minst en enhet\nhar gått sönder, 2 när så många har gått sönder att arrayen är oanvändbar, och 4 när mdadm stötte på\nett fel under insamlingen av uppgifter om arrayen.\n\nArrayen täcker en enda händelse, att en disk dör, och ingenting annat.\nPortföljposten om [automatiserad säkerhetskopiering och\nåterställningstest](/sv/portfolio/backups-that-have-actually-been-restored/)\nbeskriver en separat återställningsdesign: krypterade, deduplicerade\nrestic-ögonblicksbilder via SFTP till lagring hos en annan leverantör,\nsystemd-timerenheter och ett månatligt arbetsflöde som återställer en känd fil\ntill ett tillfälligt arbetsutrymme och jämför dess byte. Det är ett test av\nåterställning i designen, inte belägg för att det har körts.\nImplementeringsbeskrivningen daterad 2026-10-27 anger att timerenheterna var\ninaktiverade utan ett konfigurerat repo och redovisar ingen genomförd\nåterställning i drift.\n\n## Var det går fel\n\nEn array byggs för en enda händelse, att en av dess diskar dör, och de flesta sätt den förlorar data\npå ligger alldeles bredvid den händelsen.\n\n**Arrayen tas för en säkerhetskopia.** En spegel skriver varje ändring till båda diskarna samtidigt,\noch det gäller också en fil som raderats av misstag, en tabell som en misslyckad migrering tagit\nbort eller en volym som utpressningsprogram har krypterat. Då bär varje medlem på samma skada.\nLösningen är att ha en separat säkerhetskopia utanför värden, med återställningar som testas enligt\nett schema, så att arrayen skyddar mot hårdvarufel och säkerhetskopian mot allt annat.\n\n**En degraderad array går obemärkt förbi.** En degraderad array fortsätter att leverera data, och\ningenting i den ser annorlunda ut förrän nästa disk går sönder. mdadm skickar ingen e-post om det\ninte har en adress eller ett program: med `--scan` och ingetdera inställt övervakar det ingenting,\nenligt manualen. `DegradedArray` gäller dessutom bara arrayer som redan är degraderade när mdadm ser\ndem första gången; en disk som dör senare ger en `Fail`-händelse. Lösningen är att sätta `MAILADDR`,\nse till att `mdmonitor.service` körs och skicka ett meddelande med `--test` för att bevisa att\ne-posten kommer fram.\n\n**Den andra disken går sönder under återuppbyggnaden.** En återuppbyggnad rekonstruerar den saknade\ndisken ur alla de andra, och rapportens modell förlorar data precis när ytterligare en disk i\ngruppen går sönder inom reparationstiden. En död disk som får sitta kvar i en vecka sträcker ut\nfönstret till en vecka. Lösningen är att korta fönstret: med en varm reservdisk i arrayen, som mdadm\nkan lägga till redan när arrayen skapas med `--spare-devices`, med snabba byten av döda diskar och\nmed en `check` som körs enligt ett schema, så att en disk med problem hittas medan arrayen\nfortfarande kan rätta dem.\n\n**Diskarna är inte oberoende.** MTTF-kalkylen förutsätter att diskar går sönder var för sig, och\nrapporten nämner själv jordbävning och spänningstopp som fall där de inte gör det. Två diskar i\nsamma chassi delar nätaggregat, kontroller, rum och byggnad. Lösningen är att behandla den beräknade\nsiffran som en övre gräns och att täcka gemensamma orsaker med något utanför chassit, till exempel\nen kopia på en annan plats.\n\n**En RAID 5- eller 6-array är både smutsig och degraderad.** Om maskinen stannar okontrollerat medan\nen medlem saknas går det inte att lita på pariteten, och vissa block kan inte byggas upp igen, så\nkärndokumentationen varnar för korruption som inte går att upptäcka, och md vägrar starta arrayen.\nAtt tvinga igång den med `mdadm --assemble --force`, eller för ett rotfilsystem med modulparametern\n`start_dirty_degraded`, är att godta den risken. Lösningen är att välja en konsistenspolicy i\nförväg: md kan låta skrivningar gå via en separat journalenhet för nivå 4, 5 och 6, och för nivå 5\nerbjuder den en partial parity log, som enligt dokumentationen täpper till det så kallade write\nhole. När tvång är den enda vägen in bör data betraktas som tvivelaktiga och kontrolleras mot en\nsäkerhetskopia.\n\n**RAID 0 räknas som skydd.** md räknar raid0- och linear-arrayer till dem som saknar redundant\ninformation, och övervakningen i mdadm rapporterar dem med `Wrong-Level`, eftersom de inte stöder\nnågon av de operationer för haveri, reservdisk och omsynkronisering som den håller koll på. Det\nfinns ingenting att bygga upp en saknad medlem ur. Lösningen är att använda nivå 0 bara för data som\nkan kastas eller återskapas, och att aldrig räkna den som RAID i den mening som rapporten från 1987\ngav ordet.\n\n**En hårdvarukontroller döljer diskarna.** Bakom ett kontrollerkort ser operativsystemet en enda\nlogisk enhet, och en fråga om diskhälsa som riktas mot den enheten når kontrollern, inte diskarna.\nsmartctl behöver till exempel `-d megaraid,N` för att nå disk N bakom en MegaRAID-kontroller, och\nenligt manualen täcker det också Dell PERC-kort. Lösningen är att övervaka varje fysisk disk via\nkontrollerns eget gränssnitt, så att en medlem som börjar fallera upptäcks medan arrayen fortfarande\när hel.\n\n## Läs mer\n\n- [A Case for Redundant Arrays of Inexpensive Disks (RAID)](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1987/5853.html)\n  — sidan för den tekniska rapporten från Berkeley, med sammanfattning och PDF.\n- [UCB/CSD-87-391, hela rapporten (PDF)](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1987/CSD-87-391.pdf)\n  — MTTF-kalkylen, tillförlitlighetsgrupperna och de fem nivåerna.\n- [RAID arrays, Linuxkärnans dokumentation](https://docs.kernel.org/admin-guide/md.html)\n  — md:s filer under `/sys`, smutsiga degraderade arrayer och\n  konsistenspolicyer.\n- [mdadm(8)](https://man7.org/linux/man-pages/man8/mdadm.8.html) — att skapa\n  arrayer, övervakningshändelser, e-post och slutstatus för `--detail --test`.\n- [smartctl(8), smartmontools](https://github.com/smartmontools/smartmontools/blob/main/src/smartctl.8.in)\n  — att nå diskar bakom RAID-kontroller med flaggan `-d`.\n\n\u003chttps://engineer.company/sv/glossary/raid/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"Vad RAID är, var de fem nivåerna i Berkeleyrapporten från 1987 kom ifrån, hur Linux bygger och övervakar en md-array och var data går förlorade.","formats":{"gemtext":"https://engineer.company/sv/glossary/raid/index.gmi","gopher":"https://engineer.company/sv/glossary/raid/gophermap","html":"https://engineer.company/sv/glossary/raid/","json":"https://engineer.company/sv/glossary/raid/index.json","markdown":"https://engineer.company/sv/glossary/raid/index.md","pdf":"https://engineer.company/sv/glossary/raid/index.pdf"},"kind":"page","language":"sv","title":"Vad är RAID?","url":"https://engineer.company/sv/glossary/raid/","version":1}