RAID 10 คืออะไร ทำไมผู้ให้บริการ VPS ถึงเลือกใช้
ทำความเข้าใจการทำงานของ RAID 10 บน NVMe พร้อมเปรียบเทียบระดับ RAID 1, 5, 6 ในด้านความทนทานและประสิทธิภาพ รวมถึงวิธีตรวจสอบสถานะผ่าน /proc/mdstat และเหตุผลที่ RAID ไม่ใช่การสำรองข้อมูล
RAID 10 คืออะไร และเหตุใดผู้ให้บริการ VPS จึงเลือกใช้งาน
RAID 10 คือรูปแบบการจัดเก็บข้อมูลที่ผู้ให้บริการ VPS ส่วนใหญ่เลือกใช้สำหรับไดรฟ์ NVMe (non-volatile memory express) แบบเสมือน ในรูปแบบการสำเนาข้อมูลสองชุดตามมาตรฐาน ระบบจะทำการมิเรอร์ (mirror) ข้อมูลจากไดรฟ์หนึ่งไปยังอีกไดรฟ์ที่เป็นคู่กัน จากนั้นจึงทำการสตริป (stripe) ข้อมูลกระจายไปยังคู่มิเรอร์เหล่านั้น หากไดรฟ์หนึ่งตัวเกิดความเสียหาย ระบบจะยังคงทำงานต่อไปได้โดยไม่หยุดชะงัก และการกู้คืนข้อมูลจะเป็นเพียงการคัดลอกข้อมูลจากไดรฟ์คู่ที่ยังทำงานอยู่ แทนที่จะต้องคำนวณใหม่โดยการอ่านข้อมูลจากไดรฟ์ทุกตัวในชุด
RAID ย่อมาจาก redundant array of independent disks มีหน้าที่เพียงอย่างเดียวคือการทำให้เครื่องเซิร์ฟเวอร์ยังคงให้บริการได้ในขณะที่ดิสก์ตัวหนึ่งเสียหรือกำลังถูกเปลี่ยน หน้าที่นี้คือความพร้อมใช้งาน (availability) ซึ่งความพร้อมใช้งานไม่ใช่ความปลอดภัยของข้อมูล
RAID ทำการจำลองข้อมูลที่คุณเขียนลงไป rm -rf /srv คือการเขียนข้อมูล ทั้งสองฝั่งของมิเรอร์จะลบไดเรกทอรีทิ้งในเสี้ยววินาทีเดียวกัน และหลังจากนั้นอาร์เรย์จะยังคงรายงานสถานะว่าปกติ
จงจำประโยคนี้ไว้ เนื้อหาที่เหลือของหน้านี้จะครอบคลุมว่าแต่ละระดับของ RAID สามารถรับมือกับความเสียหายแบบใดได้บ้าง และมีต้นทุนในการเขียนข้อมูลอย่างไร ส่วนสุดท้ายจะเป็นคำสั่งสำหรับตรวจสอบสถานะของอาร์เรย์บนเครื่องที่คุณเป็นเจ้าของ รวมถึงความล้มเหลวที่ RAID ไม่เคยครอบคลุมถึง
ระดับของ RAID ที่ผู้ซื้อบริการโฮสติ้งมักพบเจอ: 1, 5, 6 และ 10
หน้าแผนบริการมักระบุตัวเลขไว้เพียงอย่างเดียว ตัวเลขนี้ตอบคำถามสำคัญสองประการ: จำนวนไดรฟ์ที่เสียหายได้ และต้นทุนต่อการเขียนข้อมูลหนึ่งครั้ง
RAID 1 คือการทำมิเรอร์ (mirror) ไดรฟ์สองตัวจะเก็บข้อมูลบล็อกที่เหมือนกันทุกประการ การเขียนข้อมูลทุกครั้งจะถูกส่งไปยังไดรฟ์ทั้งสองตัว การอ่านข้อมูลสามารถทำได้จากไดรฟ์ตัวใดก็ได้ หากไดรฟ์ตัวหนึ่งเสียหาย ข้อมูลจะไม่สูญหาย และความจุที่ใช้งานได้จริงจะเหลือเพียงครึ่งหนึ่งของความจุรวมทั้งหมด เนื่องจากไม่มีการคำนวณ parity ทำให้เส้นทางการเขียนข้อมูลสั้นและรวดเร็ว
RAID 5 คือการทำ striping ร่วมกับ parity block หนึ่งชุดต่อหนึ่ง stripe หากคุณมีไดรฟ์ n ตัว คุณจะได้ความจุเท่ากับ n-1 ตัว และอาร์เรย์จะรองรับความเสียหายของไดรฟ์ได้เพียงหนึ่งตัวเท่านั้น Parity จะไม่ถูกเก็บไว้ที่ไดรฟ์ตัวใดตัวหนึ่งโดยเฉพาะ แต่จะหมุนเวียนไปทั่วทุกไดรฟ์ ทำให้ไดรฟ์ทุกตัวเก็บทั้งข้อมูลและ parity
RAID 6 เพิ่ม parity block ชุดที่สองที่เป็นอิสระต่อกัน เข้าไปในแต่ละ stripe ซึ่งมักเรียกว่า P และ Q ทำให้ระบบรองรับความเสียหายของไดรฟ์ได้พร้อมกันสูงสุดสองตัว ซึ่งมีความสำคัญมากกว่าที่คิด เพราะความเสียหายครั้งที่สองมักเกิดขึ้นระหว่างช่วงเวลาที่ระบบกำลังซ่อมแซมความเสียหายครั้งแรก
RAID 10 คือการทำ stripe บนมิเรอร์ ไดรฟ์จะถูกจับคู่ทำมิเรอร์กัน และข้อมูลจะถูกกระจายไปทั่วคู่เหล่านั้น ความจุที่ใช้งานได้จริงคือครึ่งหนึ่งของความจุรวมทั้งหมด เช่นเดียวกับ RAID 1 แต่ได้ประสิทธิภาพจากการทำ striping เพิ่มเข้ามาด้วย
คุณอาจพบการเขียนว่า RAID 1+0 ซึ่งเป็นคำอธิบายที่ตรงไปตรงมาที่สุด คือการทำมิเรอร์ก่อน แล้วจึงทำ stripe ข้ามคู่มิเรอร์เหล่านั้น ส่วน RAID 0+1 คือการทำในลำดับกลับกัน คือทำ stripe ก่อนแล้วจึงทำมิเรอร์ stripe ทั้งสองชุด ซึ่งแย่กว่าเนื่องจากหากไดรฟ์ตัวหนึ่งเสียหาย จะทำให้ stripe ทั้งชุดหยุดทำงาน และการซ่อมแซมต้องคัดลอกข้อมูลจากอีกฝั่งทั้งหมด
Linux มีกรณีพิเศษที่ควรทราบ ตัว kernel ของมันเองมี raid10 ซึ่งเป็นรูปแบบการทำงานเดี่ยวแทนที่จะเป็นการซ้อนเลเยอร์กันสองชั้น ทำให้มันสามารถทำงานบนจำนวนไดรฟ์ที่เป็นเลขคี่ได้ และมีเลย์เอาต์ (near, far, offset) ที่การตั้งค่าแบบซ้อนเลเยอร์ไม่สามารถทำได้ นี่คือเหตุผลที่บรรทัดสถานะบนเครื่อง Linux แสดงค่าเป็น 2 near-copies แทนที่จะระบุชื่ออาร์เรย์สองชุด
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"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 จำนวนแปดตัว จะให้พื้นที่ใช้งานได้จริง 7 TB ภายใต้ RAID 5 และ 4 TB ภายใต้ RAID 10 ช่องว่างของความจุนี้คือต้นทุนที่แตกต่างกันอย่างชัดเจน และเป็นเหตุผลว่าทำไมการใช้ parity จึงยังคงถูกนำเสนออยู่เสมอ RAID 6 รองรับความเสียหายได้ 2 ตัวในรูปแบบใดก็ได้ ส่วน RAID 10 รับประกันความปลอดภัยเพียง 1 ตัวเท่านั้น เนื่องจากความเสียหายครั้งที่สองที่อันตรายที่สุดคือความเสียหายที่เกิดขึ้นกับไดรฟ์คู่ของตัวที่เสียไปก่อนหน้า อย่างไรก็ตาม มันสามารถรองรับความเสียหายได้สูงสุดถึง 4 ตัว หากไม่มีความเสียหายสองตัวใดที่อยู่ในคู่เดียวกัน ซึ่งถือเป็นเรื่องของโชคมากกว่าคุณสมบัติในการออกแบบ
ต้นทุนของแต่ละระดับในการเขียนข้อมูลแต่ละครั้ง
การเขียนข้อมูลลงใน mirror คือการเขียน 2 ครั้ง โดยส่งคำสั่งไปยังสมาชิกทั้งสองพร้อมกัน การเขียนลงใน parity stripe จะใช้การทำงานมากกว่า เนื่องจากบล็อก parity ของ stripe นั้นไม่ถูกต้องและจำเป็นต้องคำนวณใหม่
สำหรับกระบวนการ read-modify-write ตัวควบคุมจะอ่านข้อมูลเก่าและ parity เก่าออกมาก่อน ดังนั้นการเขียนทับบล็อกเดียวใน RAID 5 ที่ไม่มีการแคชไว้จะกลายเป็นการอ่าน, การอ่าน, การเขียน, การเขียน RAID 6 จะรักษาบล็อก parity ไว้สองชุด ดังนั้น read-modify-write จึงกลายเป็นการอ่าน, การอ่าน, การอ่าน, การเขียน, การเขียน, การเขียน Linux ยังใช้วิธี reconstruct-write โดยการอ่านข้อมูลที่ไม่มีการเปลี่ยนแปลงเพื่อคำนวณ parity ใน RAID 5 ที่มีไดรฟ์ 3 ตัว การเขียนทับนั้นอาจใช้การอ่านข้อมูล 1 ครั้งและการเขียน 2 ครั้ง ส่วนใน RAID 6 ที่มีไดรฟ์ 4 ตัว จะใช้การอ่านข้อมูล 1 ครั้งและการเขียน 3 ครั้ง จำนวน 4 และ 6 ครั้งนั้นคือจำนวนของ read-modify-write ไม่ใช่ต้นทุนคงที่สำหรับการเขียนแบบสุ่มขนาดเล็กทุกครั้ง
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"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
}
]การทำ read-modify-write สำหรับบล็อกเดียวที่ไม่มีการแคชไว้จะมีต้นทุนเท่ากับ 6 การดำเนินการของอุปกรณ์บน RAID 6 เมื่อเทียบกับ 2 สำหรับการเขียนทับแบบเดียวกันบน RAID 10 แบบสองสำเนา จำนวนเหล่านี้ยังต่ำกว่าความเป็นจริงเมื่อพิจารณาถึงความแตกต่างของ latency การเขียน mirror สองครั้งจะเกิดขึ้นแบบขนาน ดังนั้น guest จะต้องรอการเขียนที่ช้ากว่าระหว่างสองตัวนั้น ในขณะที่เส้นทางของ read-modify-write จะมีการอ่านที่ต้องเสร็จสิ้นก่อนจึงจะคำนวณ parity ใหม่ได้ ดังนั้น guest จึงต้องรอการอ่านแล้วตามด้วยการเขียนทีละขั้นตอน บนโฮสต์ที่มีภาระงานสูง การอ่านนั้นจะต้องเข้าคิวต่อจาก I/O ของผู้อื่นทั้งหมด
มีข้อยกเว้นที่สำคัญประการหนึ่ง การเขียนที่มีขนาดใหญ่พอที่จะเติมเต็มทั้ง stripe จะไม่จำเป็นต้องใช้ข้อมูลเก่า เนื่องจากทุกบล็อกใน stripe กำลังถูกแทนที่ Parity จะถูกคำนวณจากสิ่งที่อยู่ในหน่วยความจำอยู่แล้ว และ overhead จะลดลงเหลือการเขียน parity 1 ครั้งต่อ stripe สำหรับ RAID 5 หรือ 2 ครั้งสำหรับ RAID 6 โดยไม่มีการอ่านล่วงหน้า นี่คือเหตุผลที่ RAID 5 ดูเหมือนทำงานได้ดีในการทดสอบแบบ sequential แต่กลับทำงานได้แย่ภายใต้ภาระงานแบบผสมที่มีการเขียนขนาดเล็กจากหลายผู้ใช้งาน ให้ทดสอบรูปแบบที่คุณใช้งานจริง: การทำ benchmarking ดิสก์ VPS อย่างถูกต้อง หมายถึงการทำ random I/O ที่ความลึกของคิว (queue depth) ที่สมจริง ไม่ใช่การใช้ dd ขนาดใหญ่เพียงรายการเดียว
เหตุใดการสร้าง RAID ใหม่ (rebuild) จึงเป็นส่วนที่อันตราย
การสร้าง RAID 5 ใหม่ทั้งหมดจำเป็นต้องกู้คืนข้อมูลจากไดรฟ์ที่เหลืออยู่ทั้งหมด ดังนั้นระบบจึงต้องอ่านข้อมูลจากไดรฟ์ที่ยังทำงานอยู่จำนวน 7 ลูก ตั้งแต่บล็อกแรกจนถึงบล็อกสุดท้ายในตัวอย่างที่มีไดรฟ์ 8 ลูก สำหรับ RAID 10 ที่ใช้การทำ mirror แบบคู่ที่ตายตัว การสร้างใหม่จะอ่านข้อมูลเพียง 1 ลูกเท่านั้น คืออ่านจากคู่ mirror ของไดรฟ์ที่เสียไปเพียงลูกเดียวและไม่ต้องอ่านจากที่อื่น สำหรับ RAID 10 รูปแบบอื่นบน Linux ที่กระจายสำเนาข้อมูลต่างออกไป การสร้างสมาชิกใหม่ในรูปแบบ near layout ที่มีอุปกรณ์ 3 ชิ้น จะต้องอ่านข้อมูลจากสมาชิกที่เหลืออยู่ทั้งสองชิ้น
ผลกระทบที่ตามมามี 2 ประการ ประการแรกคือเรื่องเวลา เนื่องจากกระบวนการสร้างใหม่ถูกจำกัดด้วยความเร็วของไดรฟ์ที่เหลืออยู่ ปริมาณงานในการกู้คืน และเป้าหมายความเร็วในการกู้คืน ประการที่สองคือเรื่องภาระงาน การสร้าง RAID แบบ parity จะกระจาย I/O ไปยังไดรฟ์ที่เหลืออยู่ทั้งหมด ในขณะที่ RAID 10 แบบ mirror คู่จะรวมภาระ I/O ไว้ที่คู่ใดคู่หนึ่งเท่านั้น แม้ว่าทรัพยากรของ controller และ host ที่ใช้ร่วมกันจะยังคงส่งผลกระทบต่อคู่ mirror อื่นๆ อยู่ก็ตาม
มีความเสี่ยงต่อความถูกต้องของข้อมูลในช่วงเวลาเดียวกันนี้ อาร์เรย์ RAID 5 ที่มีไดรฟ์เสีย 1 ลูกจะไม่มีความซ้ำซ้อนเหลืออยู่ ดังนั้นหากพบเซกเตอร์ที่อ่านไม่ได้บนไดรฟ์ที่เหลืออยู่ ข้อมูลนั้นจะไม่สามารถกู้คืนได้ กระบวนการสร้างใหม่คือการดำเนินการเพียงอย่างเดียวที่ต้องอ่านทุกเซกเตอร์ รวมถึงเซกเตอร์ที่ไม่มีใครเข้าถึงมานานเป็นปี ข้อมูลจากเอกสารทางเทคนิคระบุว่าฮาร์ดดิสก์สำหรับผู้บริโภคทั่วไปมีโอกาสเกิดข้อผิดพลาดในการอ่านที่กู้คืนไม่ได้ประมาณ 1 ครั้งต่อทุกๆ 10^14 บิตที่อ่าน ในขณะที่ไดรฟ์ NVMe ระดับองค์กรมีโอกาสเกิด 1 ครั้งต่อ 10^17 บิตหรือดีกว่านั้น แม้ตัวเลขเหล่านี้จะเป็นสเปกจากผู้ผลิตมากกว่าการวัดผลจริง แต่สัดส่วนดังกล่าวอธิบายได้ว่าเหตุใดคำเตือนเก่าที่ว่าการสร้าง RAID 5 ใหม่จะล้มเหลวถึงถูกเขียนขึ้นสำหรับฮาร์ดดิสก์แบบจานหมุนขนาดใหญ่ และเหตุใดคำเตือนนี้จึงมีความสำคัญน้อยลงมากเมื่อใช้ NVMe อย่างไรก็ตาม ข้อโต้แย้งเรื่องภาระงานยังคงเป็นจริงสำหรับสื่อบันทึกข้อมูลทุกประเภท
ค้นหาข้อผิดพลาดที่แฝงอยู่ก่อนที่กระบวนการสร้างใหม่จะตรวจพบ โดยการทำ scrubbing สำหรับ Debian และ Ubuntu จะมีการตั้งค่าการ scrub อาร์เรย์ md ไว้เป็นระยะ ซึ่งกลไกจะแตกต่างกันไปตามรุ่นของระบบปฏิบัติการ ดังนั้นควรตรวจสอบว่าคุณใช้รุ่นใดและสั่งรันการตรวจสอบด้วยตนเอง
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_cntsync_action จะกลับไปที่ idle เมื่อการตรวจสอบเสร็จสิ้น และ mismatch_cnt ควรแสดงค่าเป็น 0 หากตัวเลขสูงกว่าศูนย์ในอาร์เรย์แบบ mirror หมายความว่าข้อมูลทั้งสองฝั่งไม่ตรงกันและ kernel ไม่สามารถระบุได้ว่าฝั่งใดถูกต้อง เนื่องจากไม่มีสำเนาใดที่มีการตรวจสอบ checksum ข้อผิดพลาดบางอย่างอาจไม่เป็นอันตราย ซึ่งมักเกิดจากพาร์ทิชัน swap เนื่องจาก kernel อาจเขียนหน้าข้อมูลที่เปลี่ยนแปลงอยู่ตลอดเวลา หากจำนวนข้อผิดพลาดในอาร์เรย์ข้อมูลเพิ่มสูงขึ้น จำเป็นต้องมีการตรวจสอบเพิ่มเติม เพราะตัวเลขเพียงอย่างเดียวไม่สามารถระบุได้ว่าต้องเปลี่ยนไดรฟ์ลูกใด
เหตุผลที่ผู้ให้บริการ VPS เลือกใช้ RAID 10 เป็นมาตรฐานสำหรับ NVMe
โหนด Hypervisor ไม่ได้รันเพียงแค่ภาระงานเดียว แต่รัน Guest หลายสิบรายการที่ไม่เกี่ยวข้องกัน โดย I/O จะเข้ามาแบบสลับกันเป็นกระแสของการเขียนขนาดเล็กที่ไม่มีความต่อเนื่องกัน (locality) ซึ่งเป็นรูปแบบที่วงจรการอ่าน-แก้ไข-เขียน (read-modify-write) ของ parity มีต้นทุนสูงที่สุด และเป็นรูปแบบที่โหนดที่ใช้งานร่วมกันต้องเผชิญตลอดเวลา
เมื่อพิจารณาถึงพฤติกรรมการกู้คืนข้อมูล (rebuild) การตัดสินใจเลือกจึงชัดเจนขึ้น ไดรฟ์ที่ล้มเหลวในโหนดที่ใช้ parity จะเพิ่มภาระงานในการสร้างข้อมูลใหม่ให้กับไดรฟ์ที่เหลืออยู่ทั้งหมด ในขณะที่การใช้คู่ Mirror แบบคงที่ หากไดรฟ์ใน RAID 10 ล้มเหลว จะเพิ่ม I/O ในการกู้คืนเฉพาะคู่ที่เกี่ยวข้องเท่านั้น และ Linux MD จะชะลอการกู้คืนหากมีการใช้งานอื่นเกิดขึ้นพร้อมกัน ผู้ให้บริการต้องการขายค่า Latency ที่ไม่พุ่งสูงขึ้น จึงยอมแลกด้วยความจุ โดยเสียพื้นที่ NVMe ดิบไปครึ่งหนึ่งเพื่อทำ Mirror
ขนาดของไดรฟ์ก็เป็นปัจจัยสำคัญเช่นกัน ยิ่งไดรฟ์มีขนาดใหญ่ขึ้น ระยะเวลาในการกู้คืน (rebuild window) ก็ยิ่งนานขึ้น สำหรับ RAID 5 ช่วงเวลานี้คือช่วงที่การสร้างข้อมูลใหม่เพิ่มภาระงานและไม่มีความซ้ำซ้อนเหลืออยู่ ส่วน RAID 6 ยังคงป้องกันความล้มเหลวของไดรฟ์ได้อีกหนึ่งตัว นี่เป็นเหตุผลเดียวกันกับที่การปรับใช้ ZFS สำหรับระบบเสมือนเลือกใช้ Pool ของ vdev แบบ Mirror แทนการใช้ raidz แบบกว้าง เพราะการทำ resilver ของ Mirror จะคัดลอกเฉพาะบล็อกที่มีการใช้งานจริงบนคู่ไดรฟ์นั้นเท่านั้น
ไม่มีสิ่งใดที่ทำให้ RAID 10 เป็นตัวเลือกที่ถูกต้องในทุกสถานการณ์ เป้าหมายสำหรับการสำรองข้อมูล (backup target) มักถูกเขียนแบบลำดับยาวและอ่านน้อยครั้ง ดังนั้น RAID 6 จึงเป็นตัวเลือกที่คุ้มค่ากว่า เพราะสามารถรองรับความล้มเหลวได้สองจุดและคืนพื้นที่ความจุส่วนใหญ่กลับมาได้ ภาระงานเป็นตัวกำหนดการตัดสินใจ ไม่ใช่จำนวนไดรฟ์ สำหรับแผนที่คุณกำลังเลือกในปัจจุบัน สื่อบันทึกข้อมูลมักมีความสำคัญมากกว่ารูปแบบการจัดเก็บข้อมูลที่อยู่ด้านบน และ การเปลี่ยนจาก SATA SSD ไปเป็น NVMe นั้นสร้างความแตกต่างได้มากกว่าความแตกต่างของ RAID ใดๆ บนสื่อทั้งสองประเภท
วิธีอ่านค่า /proc/mdstat
ให้รันคำสั่งเหล่านี้บนเครื่องที่คุณเป็นเจ้าของอาร์เรย์ ไม่ว่าจะเป็นเซิร์ฟเวอร์เฉพาะ, เครื่องที่บ้าน หรือ VPS ที่มีโวลุ่มสองตัวที่คุณประกอบขึ้นเอง ให้อ่านค่าจากผลลัพธ์ของคุณ บล็อกด้านล่างนี้เป็นตัวอย่างที่เขียนไว้เพื่อให้คุณเทียบเคียงกับสิ่งที่ได้รับ
cat /proc/mdstat
sudo mdadm --detail /dev/md0
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTSRAID 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>ทุกส่วนของข้อมูลนั้นมีความหมาย
Personalitiesแสดงรายการ md modules ที่เคอร์เนลที่กำลังทำงานโหลดไว้ การที่raid10ปรากฏขึ้นหมายความว่าโค้ดนั้นพร้อมใช้งานแล้ว ไม่มีอะไรมากไปกว่านั้นmd0 : active raid10คืออุปกรณ์อาร์เรย์ สถานะ และระดับของอาร์เรย์- ชื่อที่ตามหลังมาคือสมาชิก ตัวเลขในวงเล็บเหลี่ยมคือดัชนีของอุปกรณ์ในเมทาดาตาของอาร์เรย์ ไม่ใช่ตำแหน่งบนบรรทัดและไม่ใช่สล็อตเสมอไป
- หลังจากเปลี่ยนไดรฟ์ สมาชิกใหม่มักจะมีดัชนีสูงกว่าสล็อตที่มันเข้าไปแทนที่ ดังนั้น
nvme4n1p3[4]อาจไปอยู่ในสล็อต 2 ได้mdadm --detailจะพิมพ์สล็อตจริงในคอลัมน์RaidDeviceดังนั้นให้ใช้ค่านี้เมื่อความแตกต่างมีความสำคัญ (F)หลังชื่อสมาชิกหมายถึงเกิดข้อผิดพลาด(S)หมายถึงสแปร์ (spare): มีอยู่, ว่างงาน, รอให้บางอย่างล้มเหลว3906764800 blocks super 1.2คือขนาดที่ใช้งานได้ในหน่วย 1 KiB blocks ตามด้วยรูปแบบเมทาดาตา512K chunks 2 near-copiesคือขนาด stripe chunk และเลย์เอาต์ของ RAID 10 ซึ่งในกรณีนี้จะเก็บสำเนาของแต่ละบล็อกไว้สองชุดติดกัน[4/4]คือจำนวนสมาชิกที่อาร์เรย์คาดหวัง ตามด้วยจำนวนที่กำลังซิงค์อยู่ในปัจจุบัน[UUUU]คือตัวอักษรหนึ่งตัวต่อหนึ่งสล็อต ตามลำดับสล็อตUคือสล็อตที่ทำงานปกติและซิงค์อยู่_คือสล็อตที่ไม่มีอุปกรณ์ทำงานอยู่bitmap:คือ write intent bitmap มันบันทึกว่าพื้นที่ใดที่กำลังถูกเขียน เพื่อที่ว่าหากสมาชิกหลุดไปและกลับเข้ามาใหม่ มันจะซิงค์เฉพาะพื้นที่เหล่านั้นแทนที่จะซิงค์ทั้งไดรฟ์
ความหมายของ [4/3] และ [UU_U] เมื่อมีบางอย่างผิดปกติ
อาร์เรย์ที่อยู่ในสถานะ degraded จะมีลักษณะดังนี้
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]ให้อ่านวงเล็บทั้งสองชุดประกอบกัน [4/3] บอกว่าหนึ่งในสี่สล็อตไม่ได้ทำงาน [UU_U] บอกว่าสล็อตไหนที่เสีย เพราะขีดล่างคือตัวอักษรตัวที่สามและสล็อตเริ่มนับจากศูนย์ ดังนั้นสล็อต 2 จึงใช้งานไม่ได้ แฟล็ก (F) จะระบุชื่ออุปกรณ์เฉพาะในขณะที่ไดรฟ์ที่เสียยังคงเชื่อมต่ออยู่ หากคุณถอดมันออกจากเครื่อง ชื่อนั้นจะหายไปจากบรรทัด แต่ขีดล่างจะยังคงอยู่
อาร์เรย์ยังคงให้บริการต่อไปได้ในระหว่างนี้ และบน RAID 10 มักจะให้บริการได้ที่ความเร็วเกือบเต็มที่ ซึ่งเป็นเหตุผลว่าทำไมไม่มีใครสังเกตเห็นด้วยความรู้สึก คุณต้องมีบางอย่างแจ้งเตือนคุณ
grep -i mailaddr /etc/mdadm/mdadm.conf
sudo mdadm --monitor --scan --oneshot --test
systemctl list-units --all | grep -i mdแพ็กเกจ mdadm จะติดตั้งมอนิเตอร์ดีมอนที่อ่านค่า MAILADDR จาก /etc/mdadm/mdadm.conf และชื่อยูนิตมีการเปลี่ยนแปลงระหว่างรุ่น ดังนั้นให้ค้นหาด้วยคำสั่งล่าสุดแทนการเดา การรัน --test จะส่งข้อความหนึ่งฉบับต่อหนึ่งอาร์เรย์ทันที หากกล่องจดหมายว่างเปล่าหลังจากนั้น แสดงว่าเส้นทางการส่งอีเมลมีปัญหา ดังนั้นข้อความที่คุณต้องการทราบจริงๆ ก็จะสูญหายไปในลักษณะเดียวกัน
เมื่อมีการสร้างข้อมูลใหม่ (rebuild) หลังจากเปลี่ยนไดรฟ์ บรรทัดความคืบหน้าจะปรากฏขึ้นใต้อาร์เรย์
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/secrecovery คือการ rebuild ลงบนไดรฟ์ที่เปลี่ยนใหม่ resync คือการตรวจสอบความสอดคล้อง (consistency pass) รวมถึงการตรวจสอบรอบแรกและการกู้คืนจากการปิดเครื่องที่ไม่สมบูรณ์ check คือการ scrub ที่คุณสั่งการไว้ด้านบน คู่ในวงเล็บคือความคืบหน้าในหน่วย 1 KiB blocks เทียบกับยอดรวมต่ออุปกรณ์ และ finish คือการประมาณการของเคอร์เนลที่ความเร็วปัจจุบัน Linux MD ใช้ /proc/sys/dev/raid/speed_limit_min และ speed_limit_max เป็นเป้าหมายความเร็วในการกู้คืน โดยมีการตั้งค่าแทนที่ต่ออาร์เรย์ใน sync_speed_min และ sync_speed_max ค่าสูงสุดเริ่มต้นคือ 200,000 KiB/s ต่ออุปกรณ์ เป้าหมายเหล่านี้ช่วยให้การกู้คืนยอมหลีกทางให้กับ I/O ของระบบงานจริงและไม่ใช่การจำกัดความเร็วที่ตายตัว
mdadm --detail เต็มรูปแบบระหว่างการ 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คอลัมน์ Number คือดัชนีเมทาดาตาที่พิมพ์อยู่ในวงเล็บใน /proc/mdstat คอลัมน์ RaidDevice คือสล็อต ซึ่งเป็นตำแหน่งในสตริง [UU_U] ค่าเหล่านี้แตกต่างกันในที่นี้เพราะอุปกรณ์ 4 เข้ามาแทนที่ไดรฟ์ที่เคยอยู่ในสล็อต 2 set-A และ set-B คือชื่อของสองส่วนในแต่ละมิเรอร์ ดังนั้นสมาชิกของ set-A และสมาชิกของ set-B ในคู่เดียวกันที่เก็บข้อมูลชุดเดียวกันคือสิ่งที่คุณต้องไม่ทำหายไปพร้อมกัน
การเปลี่ยนไดรฟ์บนอาร์เรย์ที่คุณเป็นเจ้าของมี 4 คำสั่ง และคำสั่งสุดท้ายคือการตรวจสอบ
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บรรทัดการกู้คืนควรปรากฏขึ้นภายในหนึ่งหรือสองวินาที พาร์ทิชันที่นำมาเปลี่ยนต้องมีขนาดอย่างน้อยเท่ากับ Used Dev Size จาก mdadm --detail และพาร์ทิชันที่เล็กกว่าแม้เพียงเล็กน้อยจะถูกปฏิเสธด้วยข้อความในรูปแบบ not large enough to join array ให้แบ่งพาร์ทิชันไดรฟ์ใหม่ให้ตรงกับไดรฟ์เดิมก่อนที่คุณจะเพิ่มเข้าไปในอาร์เรย์
สิ่งที่คุณสามารถและไม่สามารถมองเห็นได้จากภายใน VPS
โดยส่วนใหญ่แล้ว Guest จะไม่สามารถมองเห็น RAID ของ Host ได้ ซึ่งเป็นไปตามการออกแบบ Hypervisor จะจัดสรร Virtual disk ให้คุณหนึ่งชุด ไม่ว่าดิสก์นั้นจะถูกแบ่งมาจาก RAID 10 pool ของ NVMe drive หรือวางอยู่บนไดรฟ์เพียงตัวเดียวก็ตาม สิ่งเหล่านี้ถือเป็นคุณสมบัติของ Host และจะไม่ปรากฏให้เห็นภายใน Guest ของคุณ
systemd-detect-virt
lsblk -d -o NAME,SIZE,ROTA,MODEL
cat /proc/mdstatsystemd-detect-virt จะแสดง kvm บน KVM guest, แสดงประเภท container เช่น lxc บน container และแสดง none บน bare metal สำหรับ KVM guest โดยปกติคุณจะเห็นเพียง vda หรือ sda เพียงชุดเดียวใน lsblk และไม่พบ array ใดๆ ใน /proc/mdstat เนื่องจากไม่มี array เหล่านั้นอยู่ภายใน Guest
สำหรับ VPS ที่ใช้เทคโนโลยี container ข้อมูลที่อ่านได้จะไม่น่าเชื่อถือ เนื่องจาก container ใช้ kernel ร่วมกับ Host และบางส่วนของ /proc ไม่ได้ถูกทำ namespaced ดังนั้นสิ่งที่คุณอ่านได้จากจุดนั้นอาจเป็นการอธิบายถึงตัว Host แทนที่จะเป็นส่วนแบ่งของคุณ อย่าถือว่าข้อมูลใดๆ เป็นข้อเท็จจริงเกี่ยวกับพื้นที่จัดเก็บข้อมูลของคุณเอง ให้สอบถามผู้ให้บริการเกี่ยวกับโครงสร้างการจัดเก็บข้อมูล และขอคำตอบเป็นลายลักษณ์อักษรหากข้อมูลนั้นมีความสำคัญต่อคุณ
สิ่งที่คุณสามารถตรวจสอบได้จากภายในคือพฤติกรรมของดิสก์ที่ได้รับมา การตรวจสอบว่าดิสก์ VPS ของคุณเป็น NVMe จริงหรือไม่ จะครอบคลุมคำสั่งที่รายงานข้อมูลที่เป็นจริง และ สิ่งที่ VPS แบบ SSD มีอยู่จริง จะครอบคลุมถึงสิ่งที่ระบุไว้ในหน้าแผนบริการ
คุณควรทำ RAID ภายใน VPS ของคุณหรือไม่?
โดยปกติแล้วไม่ควรทำ และเหตุผลคือเรื่องขอบเขตความล้มเหลว (failure domains) หากคุณเชื่อมต่อ volume สองชุดเข้ากับ VPS หนึ่งเครื่องแล้วทำ mirror ด้วย mdadm ทั้งสอง volume อาจอยู่บน physical array เดียวกัน บนโหนดเดียวกัน และใช้แหล่งจ่ายไฟเดียวกัน คุณจะเสียค่าใช้จ่ายในการเขียนข้อมูลเพิ่มขึ้นเป็นสองเท่าเพื่อแลกกับความซ้ำซ้อนที่คุณมีอยู่แล้ว และคุณยังคงสูญเสียข้อมูลทั้งสองชุดหากเกิดความล้มเหลวเพียงจุดเดียวที่ส่งผลกระทบต่อระบบทั้งหมด
การทำ RAID เป็นสิ่งที่คุ้มค่าเมื่อผู้ให้บริการระบุไว้ในเอกสารว่า volume เหล่านั้นตั้งอยู่ในขอบเขตความล้มเหลวที่แยกจากกัน หรือเมื่อคุณใช้งาน dedicated server ที่คุณสามารถระบุตำแหน่งของไดรฟ์ได้โดยตรง มิฉะนั้นแล้ว การนำความพยายามไปทำสำเนาข้อมูลที่เก็บไว้นอกเครื่องจะให้ผลลัพธ์ที่ดีกว่า
สิ่งที่ RAID ไม่สามารถปกป้องคุณได้
RAID ครอบคลุมเหตุการณ์เดียวเท่านั้น คือการที่ไดรฟ์หยุดทำงานอย่างถูกต้อง ทุกสิ่งที่เขียนลงไปถือเป็นการเขียนที่ถูกต้อง ดังนั้นอาร์เรย์จะนำไปใช้กับทุกสำเนาและรายงานสถานะว่าปกติ
- การลบข้อมูล.
rm -rfในไดเรกทอรีที่ผิด หรือสคริปต์ deploy ที่มีตัวแปรไม่ได้กำหนดค่าใน path อาร์เรย์จะมองว่าเป็นการเขียนที่ถูกต้องและดำเนินการซ้ำสองครั้ง - Ransomware. การเข้ารหัสคือการเขียนข้อมูล อาร์เรย์ที่ปกติจะจัดเก็บเวอร์ชันที่ถูกเข้ารหัสไว้ในทั้งสองฝั่งของ mirror
- แอปพลิเคชันที่ทำงานผิดพลาด. บั๊กที่เขียนข้อมูลขยะลงในฐานข้อมูลของคุณ จะเขียนข้อมูลขยะชุดเดียวกันลงในไดรฟ์สำรองด้วย
- โหนดทั้งหมด. โฮสต์ที่ล้มเหลว หรือบัญชีที่ถูกระงับโดยไม่ได้ตั้งใจ อาร์เรย์อาจอยู่ในสถานะสมบูรณ์แบบแต่ไม่สามารถเข้าถึงได้ในเวลาเดียวกัน
- ตัวคุณเองในอีกหนึ่งสัปดาห์ถัดมา. ไฟล์ที่คุณลบไปเมื่อวันจันทร์จะหายไปจากทุกไดรฟ์ตั้งแต่วันจันทร์นั้น มีเพียงสำเนาที่ทำไว้ก่อนหน้านั้นเท่านั้นที่จะนำข้อมูลกลับมาได้
Snapshot บนพื้นที่จัดเก็บเดียวกันก็ไม่ใช่ทางแก้เช่นกัน มันช่วยป้องกันการลบข้อมูลได้ แต่จะสูญหายไปพร้อมกับอาร์เรย์ที่มันอาศัยอยู่ คุณสมบัติที่ทำให้การสำรองข้อมูลเป็นการสำรองข้อมูลที่แท้จริงคือการที่มันต้องอยู่ที่อื่น การสำรองข้อมูลแบบเข้ารหัสนอกเซิร์ฟเวอร์ด้วย restic คืออีกครึ่งหนึ่งของหน้านี้ อาร์เรย์ช่วยให้คุณให้บริการต่อไปได้แม้ไดรฟ์จะเสีย และ restic จะกู้คืนข้อมูลของคุณเมื่อเกิดความเสียหายจากการเขียนข้อมูลที่อาร์เรย์ยินยอมให้ทำ
FAQ
RAID 10 หมายความว่าฉันไม่จำเป็นต้องสำรองข้อมูลใช่หรือไม่?
ไม่จำเป็น RAID 10 ช่วยป้องกันกรณีไดรฟ์หยุดทำงาน ระบบจะเขียนข้อมูลที่ถูกต้องลงในทั้งสองฝั่งของมิเรอร์พร้อมกัน ดังนั้นการลบไฟล์หรือการโจมตีด้วย ransomware จะส่งผลไปยังไดรฟ์สำรองในทันทีเช่นกัน อาร์เรย์จะรายงานสถานะว่าปกติหลังจากนั้น เพราะในมุมมองของอาร์เรย์ไม่มีส่วนใดล้มเหลว คุณยังคงจำเป็นต้องมีสำเนาข้อมูลที่เก็บไว้นอกเครื่อง และต้องทดสอบการกู้คืนข้อมูลเป็นระยะเพื่อยืนยันว่าสำเนาเหล่านั้นใช้งานได้จริง
ทำไมผู้ให้บริการ VPS ถึงเลือกใช้ RAID 10 แทน RAID 5 หรือ RAID 6?
มีสองเหตุผล ซึ่งทั้งคู่เกี่ยวข้องกับการเขียนข้อมูลแบบสุ่มขนาดเล็ก การอ่าน-แก้ไข-เขียน (read-modify-write) แบบ single-block ที่ไม่มีแคช จะต้องอ่านข้อมูลเก่าและ parity ก่อนที่จะคำนวณ parity ใหม่ ซึ่งใช้การทำงาน 4 ครั้งบน RAID 5 และ 6 ครั้งบน RAID 6 ในขณะที่การทำมิเรอร์สองชุดใช้เพียง 2 ครั้งเท่านั้น การเขียนแบบ reconstruct-write จะใช้ข้อมูลที่ไม่เปลี่ยนแปลงแทน และการเขียนแบบ full-stripe ไม่จำเป็นต้องอ่านข้อมูลเก่าหรือ parity เก่าล่วงหน้า การสร้าง RAID 5 ใหม่ (rebuild) จะต้องอ่านไดรฟ์ที่เหลืออยู่ทั้งหมดตั้งแต่ต้นจนจบ ในขณะที่ RAID 10 แบบดั้งเดิมที่มีคู่มิเรอร์คงที่จะคัดลอกข้อมูลจากไดรฟ์คู่ที่เหลืออยู่ ส่วนเลย์เอาต์ RAID10 อื่นๆ ของ Linux จะใช้สมาชิกต้นทางหลายตัว Linux MD จะจำกัดความเร็วในการกู้คืนเมื่อมีการใช้งานอื่นเกิดขึ้น ผู้ให้บริการต้องแลกสิ่งนี้ด้วยความจุที่หายไปครึ่งหนึ่งของ NVMe ดิบ
[U_] หรือ [UU_U] ใน /proc/mdstat หมายความว่าอย่างไร?
แต่ละตัวอักษรแทนหนึ่งช่องในอาร์เรย์ เรียงตามลำดับช่อง โดยหนึ่งตัวอักษรต่อหนึ่งช่อง U หมายความว่าช่องนั้นมีสมาชิกที่ทำงานปกติและซิงค์ข้อมูลอยู่ _ หมายความว่าช่องนั้นไม่มีส่วนประกอบที่ทำงานได้ [U_] บนมิเรอร์สองไดรฟ์หมายความว่าช่องที่สองหยุดทำงานและไม่มีความซ้ำซ้อนเหลืออยู่ ให้ดูควบคู่ไปกับคู่ที่อยู่ด้านหน้า โดย [4/3] ระบุว่าอาร์เรย์คาดหวังสมาชิกสี่ตัวแต่มีอยู่สามตัว ลำดับของช่องจะตรงกับคอลัมน์ RaidDevice ของ mdadm --detail ไม่ใช่ลำดับที่ชื่ออุปกรณ์ปรากฏบนบรรทัด
อาร์เรย์ RAID 10 สามารถสูญเสียไดรฟ์ได้กี่ตัว?
สำหรับ RAID 10 แบบสองสำเนาทั่วไปที่มีคู่มิเรอร์คงที่ จะสูญเสียได้หนึ่งตัวในรูปแบบใดก็ได้ หลังจากนั้นจะขึ้นอยู่กับว่าความล้มเหลวเกิดขึ้นที่จุดใด คู่มิเรอร์แต่ละคู่สามารถสูญเสียสมาชิกได้หนึ่งตัว ดังนั้นอาร์เรย์แปดไดรฟ์จะรอดพ้นจากความล้มเหลวได้สูงสุดสี่ตัวหากไม่มีคู่ใดที่เสียพร้อมกันทั้งคู่ แต่จะล้มเหลวทันทีหากความล้มเหลวเกิดขึ้นในคู่เดียวกันทั้งสองตัว ให้วางแผนโดยยึดจำนวนที่รับประกันได้คือหนึ่งตัว และถือว่าจำนวนที่มากกว่านั้นเป็นเรื่องของโชคมากกว่าการป้องกัน
ฉันควรทำมิเรอร์สองโวลุ่มภายใน VPS ด้วย mdadm หรือไม่?
โดยปกติแล้วไม่ควร สองโวลุ่มที่เชื่อมต่อกับ VPS เดียวกันมักจะอยู่บนอาร์เรย์ทางกายภาพเดียวกันบนโฮสต์เดียวกัน ดังนั้นการทำมิเรอร์โวลุ่มเหล่านั้นจะเพิ่มต้นทุนการเขียนเป็นสองเท่าและไม่ได้ช่วยป้องกันอะไรที่ RAID ของโฮสต์ไม่ได้ครอบคลุมอยู่แล้ว การทำเช่นนี้จะคุ้มค่าก็ต่อเมื่อผู้ให้บริการระบุชัดเจนว่าโวลุ่มเหล่านั้นอยู่ในโดเมนความล้มเหลว (failure domain) ที่แยกจากกัน มิฉะนั้นควรนำความพยายามนั้นไปใช้กับการสำรองข้อมูลที่เก็บไว้นอกเครื่องจะดีกว่า