SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-11-08

RAID 10 para sa VPS storage: paliwanag

Alamin kung ano ang nalalampasan ng RAID 1, 5, 6 at 10, magkano ang rebuild, paano basahin ang /proc/mdstat, at bakit hindi backup ang RAID.

Ano ang RAID 10, at bakit ito ginagamit ng mga VPS host

Ang RAID 10 ang storage layout na ginagamit ng karamihan ng VPS host sa ilalim ng mga virtualised na NVMe (non-volatile memory express) drive. Sa karaniwang two-copy layout nito, mina-mirror nito ang bawat drive sa isang partner, saka sini-stripe ang data sa mga pares na iyon. Maaaring masira ang isang drive nang hindi humihinto ang array. Ang repair ay simpleng pagkopya mula sa gumaganang partner, sa halip na muling kalkulahin ang data gamit ang pagbasa sa lahat ng iba pang drive sa set.

Ang RAID ay nangangahulugang redundant array of independent disks. Iisa ang layunin nito: panatilihing gumagana ang machine habang may sirang disk o pinapalitan ito. Ang layuning iyon ay availability, at hindi katumbas ng safety ang availability.

Nirereplicate ng RAID ang iyong mga write. rm -rf /srv ay isang write. Parehong nabubura ang directory sa magkabilang bahagi ng mirror sa iisang millisecond, at nagrereport pa rin ang array na malinis ito pagkatapos.

Panatilihin ang pangungusap na iyon. Sinasaklaw ng natitirang bahagi ng page na ito kung anong mga failure ang nalalampasan ng bawat level at kung magkano ang halaga nito sa bawat write. Ang mga huling seksyon ay naglalaman ng mga command para basahin ang status ng array sa machine na pagmamay-ari mo, pati na rin ang failure na hindi kailanman natatakpan ng RAID.

Mga antas na aktuwal na nakikita ng isang hosting buyer: 1, 5, 6 at 10

Sa isang plan page, karaniwang may nakalagay na numero at hanggang doon na lang. Sinasagot ng numerong iyon ang dalawang tanong: ilang drive ang maaaring masira, at magkano ang kapalit ng bawat write.

Ang RAID 1 ay mirror. Magkaparehong blocks ang hawak ng dalawang drive. Sa bawat write, parehong drive ang sinusulatan. Maaaring gamitin ang alinmang drive para sa read. Maaaring masira ang isang drive nang walang data loss, at kalahati ng raw capacity ang magagamit. Walang parity na kailangang i-compute, kaya maikli ang write path.

Ang RAID 5 ay striping na may isang parity block sa bawat stripe. Kung n ang bilang ng drive, makukuha mo ang capacity ng n-1 sa mga ito, at makaliligtas ang array sa eksaktong isang failure. Hindi nasa isang dedicated drive ang parity. Umiikot ito sa lahat ng drive, kaya bawat drive ay naglalaman ng data at parity.

Nagdagdag ang RAID 6 ng ikalawang hiwalay na parity block sa bawat stripe, na karaniwang tinatawag na P at Q. Nakaliligtas ito kapag sabay na nasira ang alinmang dalawang drive. Mas mahalaga ito kaysa sa tila, dahil kadalasang dumarating ang ikalawang failure habang nire-repair ang una.

Ang RAID 10 ay isang stripe ng mga mirror. Naka-mirror nang pares ang mga drive, at ipinapamahagi ang data sa mga pares. Kalahati ng raw total ang usable capacity, katulad ng RAID 1, pero may dagdag na parallelism mula sa striping.

Makikita mo rin itong isinusulat bilang RAID 1+0, na siyang tumpak na paglalarawan: mirror muna, pagkatapos ay mag-stripe sa mga mirror. Ang RAID 0+1 ay kabaligtaran: stripe muna, pagkatapos ay i-mirror ang dalawang stripe. Mas mahina ito dahil kapag may isang drive failure, mawawala sa serbisyo ang buong stripe at kailangang kopyahin sa repair ang buong kabilang panig.

May espesyal na kaso sa Linux na mahalagang malaman. Ang raid10 ng kernel ay isang personality lamang sa halip na dalawang magkapatong na layer, kaya gumagana ito sa odd number ng mga drive at mayroon itong mga layout (near, far, offset) na hindi kayang ipahayag ng nested setup. Kaya sinasabi ng status line sa Linux box na 2 near-copies sa halip na pangalanan ang dalawang array.

TsartEight 1 TB drives: usable capacity and drives lost before data loss
Ang datos sa likod ng tsart na ito
[
  {
    "label": "RAID 1 (eight copies)",
    "usable_tb": 1,
    "worst_case_drives_lost": 7,
    "best_case_drives_lost": 7
  },
  {
    "label": "RAID 5",
    "usable_tb": 7,
    "worst_case_drives_lost": 1,
    "best_case_drives_lost": 1
  },
  {
    "label": "RAID 6",
    "usable_tb": 6,
    "worst_case_drives_lost": 2,
    "best_case_drives_lost": 2
  },
  {
    "label": "RAID 10",
    "usable_tb": 4,
    "worst_case_drives_lost": 1,
    "best_case_drives_lost": 4
  }
]

Ang walong 1 TB drive ay nagbibigay ng 7 TB na usable space sa ilalim ng RAID 5 at 4 TB sa ilalim ng RAID 10. Totoong halaga ang agwat na iyon, kaya patuloy na ipinapanukala ang parity. Nakaliligtas ang RAID 6 sa 2 failure, anuman ang pattern. Ang RAID 10 ay garantisado lamang ang 1, dahil ang mapanganib na ikalawang failure ay ang tumama sa partner ng drive na nasira na. Maaari itong makaligtas sa hanggang 4 kapag walang dalawang failure na tumama sa iisang pares, pero nakabatay ito sa suwerte at hindi sa katangian ng disenyo.

Magkano ang gastos ng bawat level sa bawat write

Ang write sa isang mirror ay dalawang write na sabay ipinapadala sa parehong member. Mas maraming trabaho ang write sa isang parity stripe, dahil mali na ang parity block para sa stripe na iyon at kailangan itong muling kalkulahin.

Sa read-modify-write, unang binabasa ng controller ang lumang data at lumang parity. Kaya ang uncached na single-block overwrite sa RAID 5 ay nagiging read, read, write, write. May dalawang parity block ang RAID 6, kaya ang read-modify-write ay nagiging read, read, read, write, write, write. Gumagamit din ang Linux ng reconstruct-write, kung saan binabasa ang hindi nagbago na data para makalkula ang parity. Sa three-drive RAID 5, maaaring mangailangan ang overwrite na iyon ng isang data read at dalawang write; sa four-drive RAID 6, isang data read at tatlong write. Ang apat at anim ay bilang ng read-modify-write operations, hindi nakapirming gastos para sa bawat maliit na random write.

TsartUncached single-block read-modify-write operations, and drives read during a full rebuild
Ang datos sa likod ng tsart na ito
[
  {
    "label": "RAID 1 (2 drives)",
    "write_ops_per_host_write": 2,
    "drives_read_to_rebuild": 1
  },
  {
    "label": "RAID 5 (8 drives)",
    "write_ops_per_host_write": 4,
    "drives_read_to_rebuild": 7
  },
  {
    "label": "RAID 6 (8 drives)",
    "write_ops_per_host_write": 6,
    "drives_read_to_rebuild": 7
  },
  {
    "label": "RAID 10 (8 drives, fixed mirror pairs)",
    "write_ops_per_host_write": 2,
    "drives_read_to_rebuild": 1
  }
]

Ang uncached na single-block read-modify-write ay nagkakahalaga ng 6 device operations sa RAID 6, kumpara sa 2 para sa parehong overwrite sa two-copy RAID 10. Hindi lubos na ipinapakita ng mga bilang ang pagkakaiba sa latency. Sabay ipinapadala ang dalawang mirror write, kaya hinihintay ng guest ang mas mabagal sa dalawa. Sa read-modify-write path, may read na kailangang matapos bago makalkula ang bagong parity. Kaya hinihintay ng guest ang read at pagkatapos ay ang write, nang magkakasunod. Sa isang busy na host, nakapila ang read na iyon sa likod ng I/O ng iba pang workload.

May mahalagang exception. Ang write na sapat ang laki para punan ang buong stripe ay hindi nangangailangan ng lumang data, dahil pinapalitan ang bawat block sa stripe. Kinakalkula ang parity mula sa data na nasa memorya na, at bumababa ang overhead sa isang parity write bawat stripe para sa RAID 5 o dalawa para sa RAID 6, nang walang preread. Ito ang dahilan kung bakit maayos ang performance ng RAID 5 sa sequential benchmark pero hindi maganda sa mixed load ng maliliit na write mula sa maraming tenant. I-test ang pattern na aktuwal mong pinapatakbo: ang tamang pag-benchmark ng VPS disk ay nangangahulugan ng random I/O sa realistic na queue depth, hindi isang malaking dd.

Bakit mapanganib ang rebuild

Kailangang buuing muli ng buong RAID 5 rebuild ang nawawalang drive mula sa lahat ng natitirang drive. Kaya binabasa nito ang 7 surviving drive mula sa unang block hanggang sa huli sa halimbawang may walong drive. Sa fixed two-copy mirror pairs, 1 ang binabasa ng RAID 10 rebuild: ang mirror partner ng namatay na drive, at wala nang iba. Iba ang pagkakahati ng mga kopya sa ibang Linux RAID10 layout. Sa pag-rebuild ng isang member ng three-device near layout, binabasa ang dalawang surviving member.

Dalawang gastos ang dulot nito. Una ang oras, dahil nakadepende ang rebuild sa bilis ng mga surviving drive, sa reconstruction work, at sa recovery speed targets. Ikalawa ang load. Ipinapamahagi ng parity rebuild ang I/O sa mga surviving drive. Sa fixed mirror pairs, nakatuon ang I/O ng RAID 10 rebuild sa isang pair. Gayunman, nakaaapekto pa rin ang shared controller at host resources sa ibang pair.

May panganib din sa correctness sa parehong panahong ito. Kapag may isang namatay na drive ang RAID 5 array, wala na itong natitirang redundancy. Kaya hindi na mare-recover ang unreadable sector saanman sa isang surviving drive. Ang rebuild ang operasyong nagbabasa sa bawat sector, pati sa mga sector na hindi nagalaw sa loob ng isang taon. Ayon sa mga inilathalang datasheet figure, ang isang consumer hard drive ay maaaring magkaroon ng humigit-kumulang isang unrecoverable read error sa bawat 10^14 bits read, habang ang isang enterprise NVMe drive ay may isa sa bawat 10^17 o mas mabuti pa. Mga vendor specification ang mga ito, hindi mga aktuwal na sukat, ngunit ipinapaliwanag ng ratio kung bakit ang dating babala na mabibigo ang RAID 5 rebuild ay tumutukoy sa malalaking spinning disk, at kung bakit mas mahina ito sa NVMe. Nalalapat ang argumento tungkol sa load sa anumang medium.

Hanapin ang mga latent error bago pa ito gawin ng rebuild, sa pamamagitan ng scrubbing. May periodic scrub para sa md arrays ang Debian at Ubuntu. Nagkakaiba ang mekanismo depende sa release, kaya tingnan kung alin ang ginagamit mo at saka manu-manong mag-trigger ng pass.

systemctl list-timers --all | grep -i mdcheck
ls -l /etc/cron.d/mdadm
echo check | sudo tee /sys/block/md0/md/sync_action
cat /sys/block/md0/md/mismatch_cnt

sync_action bumabalik sa idle kapag natapos ang pass, at dapat basahin ng mismatch_cnt ang 0. Sa mirror, nangangahulugan ang value na higit sa zero na hindi nagtutugma ang dalawang kalahati. Hindi matukoy ng kernel kung alin ang tama dahil walang checksum ang alinmang kopya. Hindi nakapipinsala ang ilang mismatch. Karaniwang pinagmumulan nito ang swap partitions, dahil maaaring magsulat ang kernel ng page na nagbabago habang ginagamit ito. Kung tumataas ang count sa isang data array, kailangan itong siyasatin. Hindi tinutukoy ng count lamang kung aling drive ang dapat palitan.

Bakit RAID 10 ang karaniwang pinipili ng mga VPS provider para sa NVMe

Hindi iisang workload ang pinapatakbo ng isang hypervisor node. Pinapatakbo nito ang dose-dosenang guest na magkakaiba, at dumarating ang kanilang I/O nang magkakahalo bilang stream ng maliliit na write na walang locality sa isa’t isa. Ito mismo ang pattern kung saan pinakamalaki ang gastos ng parity read-modify-write cycle. Ito rin ang pattern na nararanasan ng isang shared node sa buong araw.

Idagdag pa ang behavior habang nagre-rebuild, at nagiging malinaw ang pagpili. Kapag pumalya ang isang drive sa parity node, nagdaragdag ito ng reconstruction work sa mga natitirang drive. Sa mga fixed mirror pair, ang pumalyang drive sa RAID 10 node ay nagdaragdag lamang ng rebuild I/O sa isang pair, at pinapabagal ng Linux MD ang recovery kapag may iba pang aktibidad. Nagbebenta ang mga provider ng latency na hindi biglang tumataas, kaya capacity ang kapalit nito: kalahati ng raw NVMe ang ginagamit para sa mirror.

Itinutulak din ng laki ng mga drive ang parehong desisyon. Habang lumalaki ang mga drive, humahaba ang rebuild window. Sa RAID 5, ito ang panahong nagdaragdag ng load ang reconstruction at wala nang natitirang redundancy. Nananatili sa RAID 6 ang proteksiyon laban sa pagkabigo ng isa pang drive. Ito rin ang dahilan kung bakit ang mga ZFS deployment para sa virtualisation ay gumagamit ng mga pool ng mirrored vdev sa halip na malalawak na raidz: mga block na aktuwal na ginagamit lamang ang kino-copy ng mirror resilver, at sa isang pair lamang.

Hindi ibig sabihin nito na tama ang RAID 10 sa lahat ng sitwasyon. Ang backup target ay sinusulatan sa mahahabang sequential run at bihirang basahin, kaya mas sulit doon ang RAID 6. Nakaliligtas ito sa dalawang failure at naibabalik ang malaking bahagi ng capacity. Ang workload ang nagpapasya, hindi ang bilang. Para sa planong pinipili mo ngayon, karaniwang mas mahalaga ang medium kaysa sa layout na nasa ibabaw nito, at mas malaki ang paglukso mula SATA SSD patungong NVMe kaysa sa anumang pagkakaiba ng RAID sa alinman sa mga ito.

Paano basahin ang /proc/mdstat

Patakbuhin ang mga ito sa machine kung saan ikaw ang may-ari ng array: isang dedicated server, isang box sa bahay, o isang VPS na may dalawang volume na ikaw mismo ang nag-assemble. Basahin ang sarili mong output. Mga halimbawa ang mga block sa ibaba. Isinulat ang mga ito para maikumpara mo ang anyo ng makukuha mong output.

cat /proc/mdstat
sudo mdadm --detail /dev/md0
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS

Ganito o halos ganito ang output ng isang malusog na four-drive RAID 10.

Personalities : [raid1] [raid10]
md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2] nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/4] [UUUU]
      bitmap: 0/30 pages [0KB], 65536KB chunk

unused devices: <none>

May impormasyong dala ang bawat bahagi nito.

  • Inililista ng Personalities ang mga md module na na-load ng running kernel. Ang paglitaw ng raid10 roon ay nangangahulugang available ang code, at wala nang iba.
  • Ang md0 : active raid10 ang array device, ang state nito, at ang level nito.
  • Ang mga pangalan pagkatapos nito ang mga member. Ang numerong nasa square brackets ay index ng device sa array metadata. Hindi ito ang posisyon nito sa linya at hindi rin palaging ang slot nito.
  • Pagkatapos palitan ang isang drive, karaniwang mas mataas ang index ng bagong member kaysa sa slot na pinunan nito. Kaya maaaring nasa slot 2 ang nvme4n1p3[4]. Inililimbag ng mdadm --detail ang aktuwal na slot sa column nitong RaidDevice. Gamitin iyon kapag mahalaga ang pagkakaiba.
  • Ang (F) pagkatapos ng member ay nangangahulugang faulty. Ang (S) ay nangangahulugang spare: present, idle, at naghihintay na may pumalya.
  • Ang 3906764800 blocks super 1.2 ang usable size sa 1 KiB blocks, na sinusundan ng metadata format.
  • Ang 512K chunks 2 near-copies ang stripe chunk size at ang RAID 10 layout. Sa halimbawang ito, pinananatili nito ang dalawang kopya ng bawat block na magkatabi.
  • Ang [4/4] ang bilang ng mga member na inaasahan ng array, na sinusundan ng bilang ng kasalukuyang naka-sync.
  • Ang [UUUU] ay isang character para sa bawat slot, ayon sa pagkakasunod ng mga slot. Ang U ay slot na aktibo at naka-sync. Ang _ ay slot na walang gumaganang device.
  • Ang bitmap: ang write intent bitmap. Itinatala nito kung aling mga region ang sinusulatan. Kapag nawala at bumalik ang isang member, ang mga region na iyon lamang ang nire-resync nito sa halip na ang buong drive.

Ano ang ibig sabihin ng [4/3] at [UU_U] kapag may problema

Ganito ang hitsura ng degraded array.

md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2](F) nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]

Basahin nang magkasama ang dalawang bracket. Sinasabi ng [4/3] na hindi nag-aambag ang isa sa apat na slot. Sinasabi naman ng [UU_U] kung alin iyon. Pangatlong character ang underscore, at mula zero ang pagbilang ng mga slot, kaya down ang slot 2. Tinutukoy ng (F) flag ang device habang nakakabit pa ang failed drive. Kapag inalis mo ito sa machine, mawawala ang pangalan sa linya, pero mananatili ang underscore.

Patuloy na naghahatid ng serbisyo ang array sa ganitong kalagayan. Sa RAID 10, madalas ay halos full speed pa rin ito. Kaya maaaring walang mapansing pagbabago sa performance. Kailangan may mag-monitor nito.

grep -i mailaddr /etc/mdadm/mdadm.conf
sudo mdadm --monitor --scan --oneshot --test
systemctl list-units --all | grep -i md

Nag-i-install ang mdadm package ng monitor daemon na nagbabasa ng MAILADDR mula sa /etc/mdadm/mdadm.conf. Nagbago ang unit name sa pagitan ng mga release, kaya hanapin ito gamit ang huling command sa halip na manghula. Agad na nagpapadala ang --test run ng isang message para sa bawat array. Kapag walang laman ang inbox pagkatapos nito, may problema sa mail path. Ibig sabihin, maaaring mawala sa parehong paraan ang message na talagang kailangan mong matanggap.

Kapag nagre-rebuild ang isang replacement, may lalabas na progress line sa ilalim ng array.

md0 : active raid10 nvme4n1p3[4] nvme3n1p3[3] nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]
      [==>..................]  recovery = 12.4% (242012928/1953382400) finish=63.1min speed=452000K/sec

Ang recovery ay rebuild papunta sa replacement drive. Ang resync ay consistency pass, kabilang ang initial pass at recovery mula sa unclean shutdown. Ang check ang scrub na na-trigger mo sa itaas. Ang pair sa parentheses ay ang progress sa 1 KiB blocks kumpara sa per-device total. Ang finish ang estimate ng kernel sa kasalukuyang speed. Ginagamit ng Linux MD ang /proc/sys/dev/raid/speed_limit_min at speed_limit_max bilang recovery speed target. May per-array override ang mga ito sa sync_speed_min at sync_speed_max. Ang default maximum target ay 200,000 KiB/s bawat device. Tinutulungan ng mga target na ito na bigyang-prayoridad ang production I/O kaysa recovery. Hindi sila hard speed cap.

Isang buong mdadm --detail habang nagre-rebuild
/dev/md0:
           Version : 1.2
     Creation Time : Tue Mar 10 09:14:22 2026
        Raid Level : raid10
        Array Size : 3906764800 (3.64 TiB 4.00 TB)
     Used Dev Size : 1953382400 (1.82 TiB 2.00 TB)
      Raid Devices : 4
     Total Devices : 4
       Persistence : Superblock is persistent

       Update Time : Wed Aug  5 11:02:41 2026
             State : clean, degraded, recovering
    Active Devices : 3
   Working Devices : 4
    Failed Devices : 0
     Spare Devices : 1

            Layout : near=2
        Chunk Size : 512K

    Rebuild Status : 12% complete

              Name : storage:0
            Events : 4184

    Number   Major   Minor   RaidDevice State
       0     259        3        0      active sync set-A   /dev/nvme0n1p3
       1     259        7        1      active sync set-B   /dev/nvme1n1p3
       4     259       11        2      spare rebuilding    /dev/nvme4n1p3
       3     259       15        3      active sync set-B   /dev/nvme3n1p3

Ang Number column ang metadata index na inililimbag sa brackets sa /proc/mdstat. Ang RaidDevice column ang slot, na siyang posisyon sa [UU_U] string. Magkaiba ang mga ito rito dahil pinalitan ng device 4 ang drive na may hawak sa slot 2. Tinutukoy ng set-A at set-B ang dalawang kalahati ng bawat mirror. Kaya ang hindi dapat sabay mawala ay ang isang member ng set-A at isang member ng set-B sa parehong pair na may hawak ng parehong data.

Ang pagpapalit ng drive sa array na pagmamay-ari mo ay binubuo ng apat na command. Ang huli ang verification.

sudo mdadm --manage /dev/md0 --fail /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --remove /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --add /dev/nvme4n1p3
cat /proc/mdstat

Dapat lumitaw ang recovery line sa loob ng isa o dalawang segundo. Dapat kasinglaki man lang ng Used Dev Size mula sa mdadm --detail ang replacement partition. Tatanggihan ang partition na kahit bahagyang mas maliit, na may message na tulad ng not large enough to join array. I-partition ang bagong drive para tumugma sa luma bago mo ito idagdag.

Ano ang makikita at hindi makikita mula sa loob ng VPS

Hindi nakikita ng karamihan sa mga guest ang RAID ng host, at sinadya iyon. Isang virtual disk ang ibinibigay sa iyo ng hypervisor. Katangian ng host kung ang disk na iyon ay mula sa RAID 10 pool ng mga NVMe drive o nasa isang drive lamang. Hindi ito lumalabas sa loob ng guest.

systemd-detect-virt
lsblk -d -o NAME,SIZE,ROTA,MODEL
cat /proc/mdstat

systemd-detect-virt ay nagpi-print ng kvm sa KVM guest, ng uri ng container gaya ng lxc sa container, at ng none sa bare metal. Sa KVM guest, karaniwan mong makikita ang isang vda o sda sa lsblk, at walang array sa /proc/mdstat, dahil walang array sa loob ng guest.

Sa container-based VPS, hindi mapagkakatiwalaan ang resulta. Ibinabahagi ng mga container ang kernel ng host, at hindi naka-namespace ang ilang bahagi ng /proc. Kaya maaaring ilarawan ng makikita mo roon ang host, hindi ang slice na inilaan sa iyo. Huwag ituring na katotohanan tungkol sa sarili mong storage ang alinman dito. Tanungin ang provider kung ano ang layout, at hingin ang sagot nang nakasulat kung mahalaga ito sa iyo.

Ang maaari mong suriin mula sa loob ay ang aktuwal na behavior ng disk na ibinigay sa iyo. Saklaw ng Pagsuri kung talagang NVMe ang disk ng iyong VPS ang mga command na nag-uulat ng aktuwal na impormasyon, at saklaw ng kung ano talaga ang kasama sa SSD VPS kung ano ang ipinapangako ng label sa plan page.

Magpatakbo ka ba ng RAID sa loob ng iyong VPS?

Karaniwang hindi, at ang dahilan ay ang failure domains. Kung mag-attach ka ng dalawang volume sa isang VPS at i-mirror ang mga ito gamit ang mdadm, maaaring nasa iisang physical array, iisang node, at iisang power supply ang dalawang volume. Dodoble ang cost ng bawat write para sa redundancy na mayroon ka na, pero mawawala pa rin ang dalawang kopya kapag nangyari ang failure na mahalaga.

Makatuwiran ito kapag nakadokumento ang provider na nasa magkahiwalay na failure domain ang mga volume, o kapag dedicated server ang gamit mo at ikaw ang pumipili ng mga drive. Kung hindi, mas kapaki-pakinabang ang effort sa paggawa ng mga kopyang nasa labas ng machine.

Hindi pinoprotektahan ng RAID

Isang event lang ang tinutugunan ng RAID: ang drive na hindi na gumagana nang tama. Valid na write ang lahat ng nasa ibaba, kaya inilalapat ito ng array sa bawat copy at itinuturing nitong healthy ang sarili nito.

  • Deletion. rm -rf sa maling directory, o isang deploy script na may unset variable sa path. Nakikita ng array na legal na write ito at ginagawa ito nang dalawang beses.
  • Ransomware. Ang encryption ay isang writing operation. Iniimbak ng healthy array ang encrypted na bersyon sa magkabilang bahagi ng mirror.
  • Sirang application. Kapag may bug na nagsusulat ng maling data sa database mo, isinusulat din ang parehong maling data sa redundant drive.
  • Buong node. Isang host na nag-fail, o isang account na nasuspinde dahil sa pagkakamali. Maaaring perfect ang array pero hindi pa rin ito ma-access.
  • Ikaw, makalipas ang isang linggo. Ang file na dinelete mo noong Monday ay wala na sa bawat drive noong araw ding iyon. Copy lang na ginawa bago iyon ang makapagbabalik nito.

Hindi rin solusyon ang snapshots sa parehong storage. Nakakatulong ang mga ito laban sa deletion, pero nawawala rin ang mga ito kapag nawala ang array na pinaglalagyan nila. Ang katangiang nagpapaging backup sa isang backup ay nasa ibang lokasyon ito. Ang Encrypted off-server backups gamit ang restic ang kabilang bahagi ng page na ito: pinananatili kang nagsi-serve ng array kapag namatay ang isang drive, at ibinabalik ng restic ang data mo kapag ang pinsala ay isang write na maayos namang tinanggap ng array.

FAQ

Ibig bang sabihin ba ng RAID 10 na hindi ko na kailangan ng backups?

Hindi. Pinoprotektahan ng RAID 10 laban sa drive na tumitigil sa paggana. Inilalapat nito ang bawat valid na write sa dalawang bahagi ng mirror, kaya umaabot sa redundant drive sa parehong sandali ang deletion o ransomware run. Pagkatapos, itinuturing ng array na malinis ang sarili nito dahil, mula sa pananaw nito, walang nag-fail. Kailangan mo pa rin ng mga kopyang nasa labas ng machine, at kailangan mo pa ring mag-restore ng isa paminsan-minsan upang mapatunayan na gumagana ang mga ito.

Bakit RAID 10 ang pinipili ng mga VPS provider kaysa RAID 5 o RAID 6?

Dalawang dahilan, at kapwa nauugnay sa maliliit na random write. Sa isang uncached single-block read-modify-write, binabasa muna ang lumang data at parity bago kalkulahin ang bagong parity. Nagkakahalaga ito ng 4 operations sa RAID 5 at 6 sa RAID 6, kumpara sa 2 sa mirror na may dalawang kopya. Sa reconstruct-write, ginagamit ang hindi nagbagong data. Sa full-stripe write naman, hindi kailangan ang preread ng lumang data o lumang parity. Sa full RAID 5 rebuild, binabasa ang bawat surviving drive mula simula hanggang dulo. Samantala, sa conventional RAID 10 na may fixed mirror pairs, kumokopya ito mula sa surviving partner. Gumagamit ang ibang Linux RAID10 layout ng maraming source member. Nililimitahan ng Linux MD ang recovery kapag may iba pang aktibidad. Ang kapalit nito para sa mga provider ay kapasidad: kalahati ng raw NVMe.

Ano ang ibig sabihin ng [U_] o [UU_U] sa /proc/mdstat?

Ang bawat character ay isang slot sa array, ayon sa pagkakasunod ng mga slot, at tig-isang character bawat slot. Ibig sabihin ng U na ang slot ay may member na up at in sync. Ibig sabihin ng _ na walang gumaganang laman ang slot. Sa mirror na may dalawang drive, ibig sabihin ng [U_] na down ang ikalawang slot at wala nang natitirang redundancy. Basahin ito kasama ng pair na nasa unahan nito. Ipinapahiwatig ng [4/3] na umaasa ang array sa apat na member at tatlo lamang ang mayroon ito. Ang pagkakasunod ng mga slot ay tumutugma sa column na RaidDevice ng mdadm --detail, hindi sa pagkakasunod ng mga device name sa linya.

Ilang drive ang maaaring mawala sa isang RAID 10 array?

Para sa conventional two-copy RAID 10 na may fixed mirror pairs, isa, anuman ang pattern. Kapag higit sa isa ang nawala, nakadepende ito sa lokasyon ng mga failure. Maaaring mawala ang isang member sa bawat mirror pair, kaya makakaligtas ang isang array na may walong drive sa hanggang apat na failure kung walang dalawang failure na nasa parehong pair. Magfa-fail naman ito kapag dalawang failure ang parehong tumama sa iisang pair. Magplano batay sa garantisadong bilang, na isa, at ituring ang anumang lampas dito na suwerte lamang, hindi proteksiyon.

Dapat ko bang i-mirror ang dalawang volume sa loob ng VPS ko gamit ang mdadm?

Karaniwan, hindi. Ang dalawang volume na nakakabit sa isang VPS ay madalas nasa parehong physical array sa parehong host. Dahil dito, nadodoble ang gastos sa bawat write at wala itong napoprotektahan na hindi na saklaw ng sariling RAID ng host. Makatuwiran lamang ito kapag dokumentado ng provider na nasa magkahiwalay na failure domain ang mga volume. Kung hindi, ilaan ang effort na iyon sa backups na lumalabas sa machine.

Nakatulong ba ang artikulong ito?