SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-11-08

VPS storage కోసం RAID 10 అంటే ఏమిటి?

RAID 1, 5, 6, 10 తట్టుకునే drive failures, rebuild ఖర్చు, NVMe VPSలో RAID 10 ఎంపిక కారణాలు తెలుసుకోండి. /proc/mdstat చదవడం, RAID backup కాదని గ్రహించండి.

RAID 10 అంటే ఏమిటి, VPS hostలు దీన్ని ఎందుకు ఉపయోగిస్తాయి

వర్చువలైజ్ చేసిన NVMe (non-volatile memory express) డ్రైవ్‌లపై చాలా VPS hostలు ఉపయోగించే storage layout RAID 10. సంప్రదాయ రెండు-copy layoutలో ప్రతి driveలోని డేటాను దాని భాగస్వామి driveపై mirror చేసి, ఆ mirrored pairల మధ్య dataను stripe చేస్తుంది. ఒక drive పనిచేయడం ఆపినా array ఆగదు. Repair సమయంలో setలోని మిగతా ప్రతి driveను చదివి మళ్లీ లెక్కించాల్సిన అవసరం ఉండదు; పనిచేస్తున్న భాగస్వామి drive నుంచి సాధారణ copy చేయడం సరిపోతుంది.

RAID అంటే redundant array of independent disks. దీని ఒకే పని: disk పనిచేయకపోయినా లేదా దాన్ని భర్తీ చేస్తున్నప్పటికీ machine సేవలను అందించడం కొనసాగించడం. ఆ పని availabilityకు సంబంధించినది. Availability అంటే safety కాదు.

RAID మీ writesను replicate చేస్తుంది. rm -rf /srv ఒక write. Mirrorలోని రెండు భాగాలు అదే millisecondలో ఆ directoryని తొలగిస్తాయి. అయినప్పటికీ array తరువాత కూడా తన స్థితిని cleanగా చూపిస్తుంది.

ఆ వాక్యాన్ని గుర్తుంచుకోండి. ఈ పేజీలోని మిగతా భాగాలు ప్రతి level ఏ వైఫల్యాలను తట్టుకుంటుందో, ప్రతి writeపై దానికి మీకు కలిగే ఖర్చు ఏమిటో వివరిస్తాయి. చివరి sectionsలో మీకు చెందిన machineలో array statusను చూడటానికి ఉపయోగించే commands, అలాగే RAID ఎప్పుడూ కవర్ చేయని failure వివరించబడ్డాయి.

హోస్టింగ్ కొనుగోలుదారుడు వాస్తవంగా ఎదుర్కొనే స్థాయిలు: 1, 5, 6 మరియు 10

ఒక ప్లాన్ పేజీ సంఖ్యను పేర్కొని అక్కడితో ఆగిపోతుంది. ఆ సంఖ్య రెండు ప్రశ్నలకు సమాధానం ఇస్తుంది: ఎన్ని drives విఫలమైనా తట్టుకోగలదు, మరియు ప్రతి write కు ఎంత ఖర్చవుతుంది.

RAID 1 ఒక mirror. రెండు drives లో ఒకే blocks ఉంటాయి. ప్రతి write రెండింటికీ వెళ్తుంది. ఏ drive అయినా read ను అందించగలదు. ఒక drive విఫలమైనా data loss ఉండదు, కానీ raw capacity లో సగం మాత్రమే ఉపయోగించగలం. Parity లెక్కించాల్సిన అవసరం లేదు కాబట్టి write path చిన్నదిగా ఉంటుంది.

RAID 5 ప్రతి stripe కు ఒక parity block తో కూడిన striping. n drives తో వాటిలో n-1 drives కు సమానమైన capacity లభిస్తుంది, మరియు array సరిగ్గా ఒక failure ను తట్టుకుంటుంది. Parity ఒక ప్రత్యేక drive లో ఉండదు. అది అన్ని drives మధ్య మారుతూ ఉంటుంది. అందువల్ల ప్రతి drive లో data మరియు parity రెండూ ఉంటాయి.

RAID 6 ప్రతి stripe కు రెండో, స్వతంత్ర parity block ను జోడిస్తుంది. వీటిని సాధారణంగా P మరియు Q అని రాస్తారు. ఒకేసారి ఏవైనా రెండు drives విఫలమైనా ఇది తట్టుకుంటుంది. ఇది వినిపించేదానికంటే ముఖ్యమైన విషయం, ఎందుకంటే మొదటి drive ను repair చేస్తున్న సమయంలోనే రెండో failure సాధారణంగా సంభవిస్తుంది.

RAID 10 mirrors యొక్క stripe. Drives ను జంటలుగా mirror చేస్తారు, తరువాత data ను ఆ జంటల మధ్య పంపిణీ చేస్తారు. ఉపయోగించగల capacity raw total లో సగం ఉంటుంది. ఇది RAID 1 తో సమానం, కానీ దీనిపై striping యొక్క parallelism ఉంటుంది.

దీనిని RAID 1+0 అని కూడా రాస్తారు. అదే సరైన వివరణ: ముందుగా mirror చేసి, తరువాత mirrors మీద stripe చేయడం. RAID 0+1 లో క్రమం వేరుగా ఉంటుంది: ముందుగా stripe చేసి, తరువాత ఆ రెండు stripes ను mirror చేస్తారు. ఇది తక్కువ మెరుగైనది, ఎందుకంటే ఒక drive failure వల్ల మొత్తం stripe సేవకు దూరమవుతుంది. Repair సమయంలో మొత్తం ఇతర వైపు copy చేయాలి.

Linux ఒక ప్రత్యేక సందర్భం. Kernel లోని raid10 రెండు stacked layers గా కాకుండా ఒకే personality గా ఉంటుంది. అందువల్ల ఇది బేసి సంఖ్యలో drives పై నడుస్తుంది. Nested setup లో వ్యక్తీకరించలేని layouts (near, far, offset) కూడా దీనిలో ఉన్నాయి. అందుకే Linux box లోని status line రెండు arrays పేర్లు చెప్పకుండా 2 near-copies అని చూపిస్తుంది.

చార్ట్Eight 1 TB drives: usable capacity and drives lost before data loss
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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
  }
]

ఎనిమిది 1 TB drives తో RAID 5 కింద 7 TB ఉపయోగించగల space, RAID 10 కింద 4 TB లభిస్తాయి. ఆ తేడా వాస్తవమైన ఖర్చు తేడా. అందుకే parity ను మళ్లీ మళ్లీ ప్రతిపాదిస్తారు. ఎలాంటి pattern లోనైనా RAID 6 2 failures ను తట్టుకుంటుంది. RAID 10 మాత్రం 1 ను మాత్రమే హామీ ఇస్తుంది, ఎందుకంటే ఇప్పటికే విఫలమైన drive యొక్క partner పై పడే రెండో failure అత్యంత ప్రమాదకరం. ఏ రెండు failures ఒకే pair లో ఉండనప్పుడు ఇది 4 వరకు తట్టుకుంటుంది. అయితే అది design property కాదు; అదృష్టం మాత్రమే.

ప్రతి writeపై ప్రతి levelకు అయ్యే ఖర్చు

mirrorకు చేసే write రెండు writesగా మారుతుంది. అవి ఒకేసారి రెండు membersకు పంపబడతాయి. parity stripeకు చేసే write ఎక్కువ పని కలిగిస్తుంది. కారణం, ఆ stripeకు చెందిన parity block ఇక సరైనదిగా ఉండదు. దాన్ని మళ్లీ లెక్కించాలి.

read-modify-write సందర్భంలో controller ముందుగా పాత data మరియు పాత parityను చదువుతుంది. Cache లేని single-block overwrite RAID 5లో read, read, write, writeగా మారుతుంది. RAID 6 రెండు parity blocksను నిర్వహిస్తుంది. అందువల్ల read-modify-write read, read, read, write, write, writeగా మారుతుంది. Linux reconstruct-writeను కూడా ఉపయోగిస్తుంది. దీనిలో parity లెక్కించడానికి మారని dataను చదువుతుంది. మూడు drives కలిగిన RAID 5లో ఆ overwriteకు ఒక data read మరియు రెండు writes పట్టవచ్చు. నాలుగు drives కలిగిన RAID 6లో ఒక data read మరియు మూడు writes పట్టవచ్చు. Four మరియు six అనేవి read-modify-write counts మాత్రమే. ప్రతి చిన్న random writeకు ఇవి స్థిరమైన ఖర్చులు కావు.

చార్ట్Uncached single-block read-modify-write operations, and drives read during a full rebuild
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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
  }
]

Cache లేని single-block read-modify-writeకు RAID 6లో 6 device operations ఖర్చవుతాయి. అదే overwriteకు two-copy RAID 10లో 2 device operations ఖర్చవుతాయి. అయితే ఈ counts latencyలోని తేడాను పూర్తిగా చూపించవు. రెండు mirror writes parallelగా పంపబడతాయి. అందువల్ల guest, ఈ రెండింటిలో ఆలస్యమైనదాని కోసం వేచి ఉంటుంది. read-modify-write pathలో కొత్త parityను లెక్కించడానికి ముందుగా ఒక read పూర్తవ్వాలి. అందువల్ల guest ముందుగా read కోసం, తరువాత write కోసం వరుసగా వేచి ఉంటుంది. busy hostలో ఆ read అందరి I/O వెనుక queueలో నిలబడుతుంది.

దీనికి ఒక ముఖ్యమైన మినహాయింపు ఉంది. ఒక write మొత్తం stripeను నింపేంత పెద్దదైతే పాత data అవసరం ఉండదు. కారణం, ఆ stripeలోని ప్రతి block భర్తీ అవుతోంది. ఇప్పటికే memoryలో ఉన్న dataతో parity లెక్కించబడుతుంది. అప్పుడు overhead RAID 5లో ప్రతి stripeకు ఒక parity writeకు, RAID 6లో రెండు parity writesకు తగ్గుతుంది. prereads అవసరం ఉండదు. అందుకే sequential benchmarkలో RAID 5 బాగానే కనిపిస్తుంది. కానీ అనేక tenants నుంచి వచ్చే చిన్న writes కలిగిన mixed loadలో దాని పనితీరు దెబ్బతింటుంది. మీరు వాస్తవంగా నడిపే patternనే పరీక్షించండి: VPS diskను సరిగ్గా benchmark చేయడం అంటే వాస్తవిక queue depthతో random I/O చేయడం, ఒక పెద్ద dd చేయడం కాదు.

పునర్నిర్మాణమే ఎందుకు ప్రమాదకరమైన దశ

పూర్తి RAID 5 rebuild కోసం మిగిలిన అన్ని drives లోని డేటాను ఉపయోగించి కనబడని drive ను పునర్నిర్మించాలి. అందువల్ల ఎనిమిది-drive ఉదాహరణలో మొదటి block నుంచి చివరి block వరకు 7 మిగిలిన drives ను చదవాలి. స్థిరమైన రెండు-copy mirror pairs తో ఉన్న RAID 10 rebuild మాత్రం 1 ను మాత్రమే చదువుతుంది: పనిచేయని drive యొక్క mirror partner ను, అంతే. ఇతర Linux RAID10 layouts copies ను వేరే విధంగా పంపిణీ చేస్తాయి. మూడు-device near layout లోని ఒక member ను rebuild చేయాలంటే మిగిలిన రెండు members ను చదవాలి.

దీనివల్ల రెండు ఖర్చులు వస్తాయి. మొదటిది సమయం. ఎందుకంటే rebuild వేగం మిగిలిన drives, reconstruction పని మరియు recovery speed targets పై ఆధారపడి ఉంటుంది. రెండవది load. Parity rebuild సమయంలో I/O మిగిలిన drives అంతటా విస్తరిస్తుంది. స్థిరమైన mirror pairs ఉన్న RAID 10 rebuild లో ఆ I/O ఒక pair పై కేంద్రీకృతమవుతుంది. Shared controller మరియు host resources మాత్రం మిగిలిన pairs పై కూడా ప్రభావం చూపుతాయి.

అదే సమయంలో correctness risk కూడా ఉంటుంది. ఒక drive పనిచేయని RAID 5 array లో ఇక redundancy ఉండదు. అందువల్ల మిగిలిన drive లో ఎక్కడైనా చదవలేని sector ఉంటే దాన్ని ఇక recover చేయలేరు. Rebuild అనేది ప్రతి sector ను చదివే ఒకే operation. ఏడాది పాటు ఎవరూ తాకని sectors కూడా అందులో ఉంటాయి. Published datasheet figures ప్రకారం consumer hard drive లో చదివిన ప్రతి 10^14 bits కు సుమారు ఒక unrecoverable read error రావచ్చు. Enterprise NVMe drive లో అది ప్రతి 10^17 bits కు ఒకటి లేదా అంతకంటే మెరుగ్గా ఉంటుంది. ఇవి measurements కాకుండా vendor specifications. అయినప్పటికీ, ఈ నిష్పత్తి పాత spinning disks పెద్దవిగా ఉన్నప్పుడు RAID 5 rebuild విఫలమవుతుందనే హెచ్చరిక ఎందుకు వచ్చింది, అలాగే NVMe పై ఆ హెచ్చరిక ఎందుకు చాలా తక్కువగా వర్తిస్తుందో వివరిస్తుంది. Load కు సంబంధించిన వాదన ఏ medium పైనైనా వర్తిస్తుంది.

Rebuild ప్రారంభమయ్యే ముందు latent errors ను scrubbing ద్వారా కనుగొనండి. Debian మరియు Ubuntu md arrays కోసం periodic scrub ను ship చేస్తాయి. Releases మధ్య mechanism మారుతుంది. కాబట్టి మీ సిస్టమ్‌లో ఏది ఉందో తనిఖీ చేసి, తరువాత pass ను చేతితో trigger చేయండి.

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

Pass పూర్తయినప్పుడు sync_action తిరిగి idle వద్దకు వెళ్తుంది. అలాగే mismatch_cnt విలువ 0 గా ఉండాలి. Mirror పై zero కంటే ఎక్కువ mismatch ఉంటే రెండు halves ఒకదానితో ఒకటి సరిపోలడం లేదని అర్థం. ఏది సరైనదో kernel చెప్పలేడు, ఎందుకంటే ఏ copy లోనూ checksum ఉండదు. కొన్ని mismatches హానికరం కావు. సాధారణంగా swap partitions ఇందుకు కారణమవుతాయి. Kernel ఒక page ను రాస్తున్న సమయంలో అది మారిపోవచ్చు. Data array పై mismatch count పెరుగుతుంటే దర్యాప్తు చేయాలి. అయితే count ఒక్కటితో ఏ drive ను replace చేయాలో గుర్తించలేరు.

NVMe కోసం VPS providerలు RAID 10 ను ఎందుకు ప్రామాణీకరిస్తాయి

ఒక hypervisor node ఒకే workload ను నడపదు. అది పరస్పరం సంబంధం లేని dozens of guests ను నడుపుతుంది. వాటి I/O locality లేకుండా చిన్న writes stream గా interleaved రూపంలో వస్తుంది. parity read-modify-write cycle కు అత్యధిక ఖర్చు అయ్యే pattern ఇదే. shared node లో ఈ pattern రోజంతా ఉంటుంది.

Rebuild ప్రవర్తనను కూడా పరిగణలోకి తీసుకుంటే ఎంపిక స్పష్టమవుతుంది. parity node లో ఒక drive విఫలమైతే, మిగిలిన drives అన్నింటిపై reconstruction పని పెరుగుతుంది. స్థిరమైన mirror pairs ఉన్న RAID 10 node లో ఒక drive విఫలమైతే, rebuild I/O ఒక pair కు మాత్రమే పరిమితమవుతుంది. ఇతర activity జరుగుతున్నప్పుడు Linux MD recovery వేగాన్ని తగ్గిస్తుంది. Providers అధికంగా పెరగని latency ను అందిస్తున్నారు. అందుకే వారు capacity తో దానికి చెల్లిస్తారు: raw NVMe లో సగం mirror కోసం ఉపయోగించబడుతుంది.

Drive sizes కూడా ఇదే దిశను సూచిస్తాయి. Drives పెద్దవుతున్నకొద్దీ rebuild window పొడవవుతుంది. RAID 5 లో reconstruction load పెరగడం, అదనంగా redundancy లేకపోవడం రెండూ ఈ window లోనే జరుగుతాయి. RAID 6 మరో ఒక drive failure ను తట్టుకునే రక్షణను కొనసాగిస్తుంది. Virtualisation కోసం ZFS deployments wide raidz కు బదులుగా mirrored vdevs pools ను ఉపయోగించడానికి ఇదే కారణం: mirror resilver ఒక pair లో ప్రస్తుతం ఉపయోగంలో ఉన్న blocks ను మాత్రమే copy చేస్తుంది.

ఇవేవీ RAID 10 ను ప్రతి సందర్భంలో సరైనదిగా చేయవు. Backup target కు దీర్ఘమైన sequential runs గా writes వస్తాయి, reads అరుదుగా జరుగుతాయి. అందువల్ల అక్కడ RAID 6 మెరుగైన ఎంపిక. ఇది రెండు failures ను తట్టుకుంటుంది మరియు capacity లో ఎక్కువ భాగాన్ని తిరిగి అందిస్తుంది. నిర్ణయించేది workload, సంఖ్య కాదు. ఈరోజు మీరు ఎంచుకుంటున్న plan కోసం, దానిపై అమర్చిన layout కంటే medium సాధారణంగా ముఖ్యమైనది. రెండింటిపైనా RAID తేడా కంటే SATA SSD నుంచి NVMe కు మార్పు ఎక్కువ ప్రభావం చూపుతుంది.

/proc/mdstat ను ఎలా చదవాలి

మీకు చెందిన array ఉన్న machine పై మాత్రమే వీటిని అమలు చేయండి: dedicated server, ఇంట్లోని box లేదా మీరు స్వయంగా జత చేసిన రెండు volumes కలిగిన VPS. మీ స్వంత output ను చదవండి. మీరు పొందే output ఆకారంతో సరిపోల్చుకోవడానికి కింది blocks ఉదాహరణలుగా ఇవ్వబడ్డాయి.

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

సరిగ్గా పనిచేస్తున్న నాలుగు-drive RAID 10 సాధారణంగా ఇలాంటి output ఇస్తుంది.

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>

ఇందులోని ప్రతి భాగం సమాచారాన్ని అందిస్తుంది.

  • Personalities ప్రస్తుతం నడుస్తున్న kernel load చేసిన md modules ను చూపిస్తుంది. అక్కడ raid10 కనిపించడం వల్ల code అందుబాటులో ఉందని మాత్రమే తెలుస్తుంది.
  • md0 : active raid10 array device, దాని state, level ను చూపిస్తుంది.
  • దాని తరువాత ఉన్న పేర్లు members. Square brackets లోని సంఖ్య array metadata లో device index; అది line లోని స్థానం కాదు, ఎల్లప్పుడూ దాని slot కూడా కాదు.
  • Drive replacement తర్వాత కొత్త member సాధారణంగా అది భర్తీ చేసిన slot కంటే ఎక్కువ index ను ఉంచుకుంటుంది. అందువల్ల nvme4n1p3[4] slot 2లో ఉండవచ్చు. mdadm --detail తన RaidDevice column లో నిజమైన slot ను చూపిస్తుంది. తేడా ముఖ్యమైనప్పుడు దానినే ఉపయోగించండి.
  • Member తర్వాత ఉన్న (F) అంటే అది faulty అని అర్థం. (S) అంటే spare: అది ఉంది, idleగా ఉంది, ఏదైనా విఫలమయ్యే వరకు వేచి ఉంది.
  • 3906764800 blocks super 1.2 usable size ను 1 KiB blocks లో చూపిస్తుంది. తరువాత metadata format ఉంటుంది.
  • 512K chunks 2 near-copies stripe chunk size మరియు RAID 10 layout ను చూపిస్తుంది. ఇక్కడ ప్రతి block కు చెందిన రెండు copies ను పక్కపక్కనే ఉంచుతుంది.
  • [4/4] array ఆశించే members సంఖ్యను, తరువాత ప్రస్తుతం syncలో ఉన్న members సంఖ్యను చూపిస్తుంది.
  • [UUUU] ప్రతి slot కు ఒక character చొప్పున, slot క్రమంలో ఉంటుంది. U అంటే ఆ slot పనిచేస్తూ syncలో ఉంది. _ అంటే ఆ slotలో ఏదీ పనిచేయడం లేదు.
  • bitmap: write intent bitmap. ఏ regions కు write జరుగుతున్నదో ఇది నమోదు చేస్తుంది. అందువల్ల బయటకు వెళ్లి తిరిగి వచ్చిన member మొత్తం driveకు బదులుగా ఆ regions ను మాత్రమే resync చేస్తుంది.

ఏదైనా సమస్య ఉన్నప్పుడు [4/3] మరియు [UU_U] అర్థం

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]

రెండు brackets ను కలిసి చదవండి. [4/3] నాలుగు slotsలో ఒకటి సహకరించడం లేదని చెబుతుంది. [UU_U] ఏది అని చూపిస్తుంది. Underscore మూడవ character, slots zero నుంచి లెక్కించబడతాయి. అందువల్ల slot 2 down అయింది. Failed drive ఇంకా జతచేయబడి ఉన్నప్పుడు మాత్రమే (F) flag ఆ device పేరును చూపిస్తుంది. దాన్ని machine నుంచి తీసివేస్తే lineలో ఆ పేరు కనిపించదు, కానీ underscore అలాగే ఉంటుంది.

ఇవన్నీ జరిగినా array సేవలను కొనసాగిస్తుంది. RAID 10లో ఇది తరచుగా దాదాపు పూర్తి వేగంతోనే సేవలు అందిస్తుంది. అందువల్ల సాధారణంగా ఉపయోగిస్తున్నప్పుడు ఎవరూ సమస్యను గుర్తించరు. మీకు తెలియజేసే monitoring అవసరం.

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

mdadm package ఒక monitor daemon ను install చేస్తుంది. అది /etc/mdadm/mdadm.conf నుంచి MAILADDR ను చదువుతుంది. Unit name releases మధ్య మారి ఉండవచ్చు. అందువల్ల ఊహించకుండా last command తో దాన్ని కనుగొనండి. --test run ప్రతి array కు వెంటనే ఒక్క message పంపుతుంది. దాని తరువాత inbox ఖాళీగా ఉంటే mail pathలో సమస్య ఉంది. మీరు నిజంగా చూడాల్సిన message కూడా అదే విధంగా పోయి ఉండేది.

Replacement rebuild అవుతున్నప్పుడు array కింద progress line కనిపిస్తుంది.

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

recovery replacement drive పై జరిగే rebuild. resync consistency pass; ఇందులో initial pass మరియు unclean shutdown నుంచి recovery కూడా ఉంటాయి. check పై trigger చేసిన scrub. Parenthesesలోని జంట సంఖ్య per-device totalకు సంబంధించి 1 KiB blocksలో progress. finish ప్రస్తుత వేగం ఆధారంగా kernel estimate. Linux MD recovery speed targetsగా /proc/sys/dev/raid/speed_limit_min మరియు speed_limit_max ను ఉపయోగిస్తుంది. ప్రతి array కోసం overrides sync_speed_min మరియు sync_speed_max లో ఉంటాయి. Default maximum target ప్రతి deviceకు 200,000 KiB/s. ఈ targets recoveryకు production I/Oకు ప్రాధాన్యం ఇవ్వడానికి వీలు కల్పిస్తాయి; ఇవి hard speed caps కావు.

Rebuild సమయంలో పూర్తి mdadm --detail
/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

Number column /proc/mdstat లో bracketsలో చూపించే metadata index. RaidDevice column slotను చూపిస్తుంది. ఇది [UU_U] stringలోని position. ఇక్కడ రెండూ వేర్వేరుగా ఉన్నాయి, ఎందుకంటే slot 2ను కలిగి ఉన్న drive స్థానంలో device 4 వచ్చింది. ప్రతి mirrorలోని రెండు halvesను set-A మరియు set-B చూపిస్తాయి. అదే pairలో ఒకే dataను కలిగి ఉన్న set-A member మరియు set-B member రెండూ ఒకేసారి కోల్పోకుండా చూడాలి.

మీకు చెందిన arrayలో driveను replace చేయడానికి నాలుగు commands అవసరం. చివరిది check command.

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

Recovery line ఒకటి లేదా రెండు secondsలో కనిపించాలి. Replacement partition పరిమాణం mdadm --detail నుంచి వచ్చిన Used Dev Size కంటే కనీసం అంత పెద్దగా ఉండాలి. కొద్దిగా చిన్న partitionను కూడా not large enough to join array తరహా messageతో reject చేస్తుంది. కొత్త driveను add చేయడానికి ముందు పాత driveకు సరిపోయేలా partition చేయండి.

VPS లోపల నుంచి మీరు ఏమి చూడగలరు, ఏమి చూడలేరు

చాలా guest వ్యవస్థలు host యొక్క RAID ను చూడలేవు. ఇది ఉద్దేశపూర్వకంగానే ఉంటుంది. Hypervisor మీకు ఒక virtual disk ను అందిస్తుంది. ఆ disk NVMe driveలతో రూపొందించిన RAID 10 pool నుంచి కేటాయించబడిందా లేదా ఒకే drive పై ఉందా అనేది host కు సంబంధించిన లక్షణం. అది మీ guest లో కనిపించదు.

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

systemd-detect-virt ఒక KVM guest లో kvm ను, container లో lxc వంటి container type ను, bare metal పై none ను ప్రదర్శిస్తుంది. KVM guest లో సాధారణంగా lsblk లో ఒకే vda లేదా sda కనిపిస్తుంది. /proc/mdstat లో arrays కనిపించవు, ఎందుకంటే guest లో అవి ఉండవు.

Container ఆధారిత VPS లో ఈ సమాచారం నమ్మదగినది కాదు. Containers host kernel ను పంచుకుంటాయి. /proc లోని కొన్ని భాగాలు namespace చేయబడవు. అందువల్ల అక్కడ మీరు చదివేది మీకు కేటాయించిన భాగం కంటే host ను వివరిస్తుండవచ్చు. ఈ సమాచారాన్ని మీ స్వంత storage గురించి వాస్తవంగా పరిగణించవద్దు. Layout ఏమిటో provider ను అడగండి. అది మీకు ముఖ్యమైతే సమాధానాన్ని లిఖితపూర్వకంగా పొందండి.

మీకు ఇచ్చిన disk యొక్క ప్రవర్తనను మాత్రం VPS లోపల నుంచి పరిశీలించవచ్చు. మీ VPS disk నిజంగా NVMe కాదో పరిశీలించడం వాస్తవ సమాచారాన్ని అందించే commands ను వివరిస్తుంది. SSD VPS లో వాస్తవంగా ఏమి ఉంటుంది plan page పై ఉన్న label ఏం సూచిస్తుందో వివరిస్తుంది.

మీ VPS లో RAID నడపాలా?

సాధారణంగా వద్దు. దీనికి కారణం failure domains. ఒకే VPS కు రెండు volumes జతచేసి, వాటిని mdadm తో mirror చేస్తే, రెండు volumes ఒకే physical array లో, ఒకే node పై, ఒకే power supply వెనుక ఉండవచ్చు. Redundancy ఇప్పటికే ఉన్నప్పటికీ, ప్రతి write కు ఖర్చు రెట్టింపు అవుతుంది. అయినా ముఖ్యమైన ఒకే failure వల్ల రెండు copies ను కోల్పోతారు.

ఆ volumes వేర్వేరు failure domains లో ఉన్నాయని provider documentation స్పష్టంగా చెబితే RAID ఉపయోగకరంగా ఉంటుంది. మీరు drives పై నేరుగా నియంత్రణ కలిగిన dedicated server ఉపయోగిస్తున్నప్పుడు కూడా ఇది సముచితం. ఇతర సందర్భాల్లో, machine వెలుపలికి వెళ్లే copies పై కృషి చేయడం మరింత ప్రయోజనకరం.

RAID మీకు రక్షణ ఇవ్వనివి

RAID ఒక సంఘటనను మాత్రమే ఎదుర్కొంటుంది: సరిగ్గా పనిచేయడం ఆపిన drive. కిందివన్నీ చెల్లుబాటు అయ్యే writeలు. అందువల్ల array వాటిని ప్రతి copyకు వర్తింపజేసి, తన స్థితి healthyగా ఉందని చూపిస్తుంది.

  • తొలగింపు. తప్పు directoryలోని rm -rf, లేదా pathలో unset variable ఉన్న deploy script. array దీనిని చెల్లుబాటు అయ్యే writeగా గుర్తించి రెండుసార్లు అమలు చేస్తుంది.
  • Ransomware. Encryption కూడా writing ప్రక్రియే. healthy array encrypted versionను mirrorలోని రెండు భాగాల్లోనూ నిల్వ చేస్తుంది.
  • పనిచేయని application. మీ databaseలో చెత్త data రాసే bug, అదే చెత్త dataను redundant driveలోనూ రాస్తుంది.
  • మొత్తం node. విఫలమైన host, లేదా పొరపాటున suspend చేసిన account. array పూర్తిగా సక్రమంగా ఉండి, అదే సమయంలో అందుబాటులో లేకపోవచ్చు.
  • ఒక వారం తరువాత మీరే. Mondayన తొలగించిన file, Mondayనే ప్రతి drive నుంచి తొలగిపోతుంది. అప్పటికి ముందు తీసిన copy మాత్రమే దాన్ని తిరిగి తీసుకురాగలదు.

అదే storageపై ఉన్న snapshots కూడా పరిష్కారం కావు. అవి deletionకు సహాయపడతాయి, కానీ అవి ఉన్న arrayతో పాటే నశిస్తాయి. backupను backupగా చేసే లక్షణం అది వేరే చోట ఉండటమే. resticతో encrypted off-server backups ఈ పేజీలోని మరో భాగం: dead drive ఉన్నప్పటికీ array మీ సేవలను కొనసాగిస్తుంది, కానీ array సంతోషంగా అమలు చేసిన write వల్ల నష్టం జరిగినప్పుడు restic మీ dataను తిరిగి పొందుతుంది.

FAQ

RAID 10 ఉంటే backups అవసరం ఉండవా?

లేదు. పనిచేయడం ఆగిపోయిన drive నుంచి RAID 10 రక్షణ కల్పిస్తుంది. ప్రతి చెల్లుబాటు అయ్యే write ను mirror లోని రెండు భాగాలకు వర్తింపజేస్తుంది. అందువల్ల deletion లేదా ransomware run జరిగినప్పుడు redundant drive లోనూ అదే సమయంలో మార్పు జరుగుతుంది. ఆ తర్వాత array తనను తాను clean గా చూపిస్తుంది, ఎందుకంటే దాని దృష్టిలో ఏదీ విఫలం కాలేదు. Machine వెలుపల ఉండే copies మీకు ఇంకా అవసరం. అవి పనిచేస్తున్నాయని నిర్ధారించడానికి అప్పుడప్పుడు ఒక copy ను restore చేయాలి.

VPS providers RAID 5 లేదా RAID 6 కంటే RAID 10 ను ఎందుకు ఎంచుకుంటారు?

దీనికి రెండు కారణాలు ఉన్నాయి. రెండూ small random writes కు సంబంధించినవే. Cached కాని single-block read-modify-write సమయంలో కొత్త parity లెక్కించడానికి పాత data మరియు parity ను చదవాలి. అందువల్ల RAID 5లో 4 operations, RAID 6లో 6 operations ఖర్చవుతాయి. రెండు-copy mirror లో ఈ సంఖ్య 2 operations మాత్రమే. Reconstruct-write లో మారని data ను ఉపయోగిస్తుంది. Full-stripe writes కు పాత data లేదా పాత parity prereads అవసరం ఉండదు. Full RAID 5 rebuild సమయంలో మిగిలిన ప్రతి drive ను ఒక చివర నుంచి మరొక చివర వరకు చదవాలి. Conventional RAID 10లో fixed mirror pairs ఉన్నందున surviving partner నుంచి copy చేస్తుంది. ఇతర Linux RAID10 layouts లో multiple source members ను ఉపయోగిస్తాయి. ఇతర activity జరుగుతున్నప్పుడు Linux MD recovery వేగాన్ని తగ్గిస్తుంది. ఇందుకు providers capacity తో చెల్లిస్తారు: raw NVMeలో సగం.

/proc/mdstat లో [U_] లేదా [UU_U] అంటే ఏమిటి?

ప్రతి character array లోని ఒక slot ను సూచిస్తుంది. ఇవి slot order లో ఉంటాయి; ప్రతి slot కు ఒక character ఉంటుంది. U అంటే ఆ slot లో up అయి sync లో ఉన్న member ఉందని అర్థం. _ అంటే ఆ slot లో పనిచేస్తున్నది ఏదీ లేదని అర్థం. రెండు-drive mirror లో [U_] అంటే రెండవ slot down అయిందని, redundancy ఇక మిగలలేదని అర్థం. దీన్ని ముందు ఉన్న pair తో కలిపి చదవాలి. అక్కడ [4/3] array నాలుగు members ను ఆశిస్తోందని, వాటిలో మూడు ఉన్నాయని చెబుతుంది. Slot order, mdadm --detail లోని RaidDevice column కు సరిపోతుంది. ఇది line లో device names కనిపించే order కు సరిపోవాల్సిన అవసరం లేదు.

RAID 10 array ఎన్ని drives కోల్పోయినా పనిచేస్తుంది?

Fixed mirror pairs కలిగిన conventional two-copy RAID 10లో ఏ pattern అయినా ఒక drive కోల్పోయినా పనిచేస్తుంది. అంతకంటే ఎక్కువ failures ఎక్కడ సంభవించాయనే దానిపై ఫలితం ఆధారపడి ఉంటుంది. ప్రతి mirror pair తన రెండు members లో ఒకదాన్ని కోల్పోవచ్చు. అందువల్ల ఎనిమిది-drive arrayలో ఒకే pair కు చెందిన రెండు drives విఫలం కాకపోతే నాలుగు failures వరకు తట్టుకుంటుంది. రెండు failures ఒకే pair లో ఉంటే array రెండు failuresకే ఆగిపోతుంది. హామీగా లభించే సంఖ్య ఒకటే కాబట్టి దాని ఆధారంగా ప్రణాళిక చేయండి. దానికంటే ఎక్కువను protection గా కాకుండా అదృష్టంగా పరిగణించండి.

నా VPS లోని రెండు volumes ను mdadmతో mirror చేయాలా?

సాధారణంగా అవసరం లేదు. ఒకే VPS కు జతచేసిన రెండు volumes తరచుగా ఒకే host లోని ఒకే physical array పై ఉంటాయి. అందువల్ల ప్రతి write ఖర్చు రెట్టింపు అవుతుంది, కానీ host యొక్క స్వంత RAID ఇప్పటికే అందించని అదనపు రక్షణ ఏదీ లభించదు. Provider ఆ volumes వేర్వేరు failure domains లో ఉన్నాయని documentationలో పేర్కొన్నప్పుడు మాత్రమే ఇది ఉపయోగకరం. లేకపోతే ఆ కృషిని machine వెలుపల ఉండే backups కోసం ఉపయోగించండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?