SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-11-08

מהו RAID 10 ואיך הוא עובד בשרתי VPS?

המדריך המלא להבנת RAID 10 בשרתי VPS מבוססי NVMe. נסביר אילו כשלים המערך שורד, איך לקרוא את /proc/mdstat, ומדוע RAID אינו מהווה תחליף לגיבוי נתונים חיצוני ומאובטח.

מהו RAID 10 ומדוע מארחי VPS משתמשים בו

RAID 10 הוא מבנה האחסון הנפוץ ביותר אצל מארחי VPS המשתמשים בכונני NVMe (non-volatile memory express) וירטואליים. בתצורת שני העותקים הקלאסית שלו, המערכת משכפלת כל כונן לכונן תואם, ולאחר מכן מבצעת striping לנתונים על פני זוגות משוכפלים אלו. כונן אחד יכול להפסיק לעבוד מבלי שהמערך יושבת, והתיקון הוא העתקה פשוטה מהכונן התואם שנותר, במקום חישוב מחדש שקורא מכל שאר הכוננים בסט.

RAID הוא ראשי תיבות של Redundant Array of Independent Disks. תפקידו אחד: להבטיח שהמכונה תמשיך לשרת בקשות בזמן שכונן תקול או מוחלף. תפקיד זה הוא זמינות (availability), וזמינות אינה בטיחות (safety).

RAID משכפל את פעולות הכתיבה שלכם. rm -rf /srv הוא פעולת כתיבה. שני חלקי המראה מוחקים את הספרייה באותה מילי-שנייה, והמערך עדיין מדווח על עצמו כתקין לאחר מכן.

שמרו את המשפט הזה. שאר הדף הזה מכסה מה כל רמה שורדת ומה העלות שלה בכל פעולת כתיבה. הסעיפים האחרונים כוללים את הפקודות לקריאת מצב המערך במכונה שבבעלותכם, ואת הכשל ש־RAID מעולם לא כיסה.

הרמות שקונה אחסון פוגש בפועל: 1, 5, 6 ו-10

דף תוכנית מציין מספר ועוצר שם. המספר עונה על שתי שאלות: כמה כוננים יכולים להתקלקל, ומה העלות של כל פעולת כתיבה.

RAID 1 הוא שיקוף (mirror). שני כוננים מחזיקים בלוקים זהים. כל כתיבה מופנית לשניהם. כל אחד מהכוננים יכול לשרת קריאה. כונן אחד יכול להיכשל ללא אובדן נתונים, ומחצית מהקיבולת הגולמית זמינה לשימוש. אין צורך לחשב parity, לכן נתיב הכתיבה קצר.

RAID 5 הוא פריסה (striping) עם בלוק parity אחד לכל stripe. עם n כוננים מקבלים קיבולת של n-1 מהם, והמערך שורד כישלון של כונן אחד בדיוק. ה-parity אינו יושב על כונן ייעודי אחד. הוא מסתובב בין כולם, כך שכל כונן נושא גם נתונים וגם parity.

RAID 6 מוסיף בלוק parity שני ועצמאי לכל stripe, הנכתב בדרך כלל כ-P ו-Q. הוא שורד כישלון של כל שני כוננים בו-זמנית. זה משמעותי יותר ממה שזה נשמע, כיוון שהכישלון השני מגיע לרוב במהלך התיקון של הראשון.

RAID 10 הוא פריסה של שיקופים. כוננים משוקפים בזוגות, והנתונים מופצים על פני הזוגות. הקיבולת הזמינה היא מחצית מהסך הגולמי, בדומה ל-RAID 1, עם תוספת של מקביליות הפריסה.

ניתן לראות זאת כתוב גם כ-RAID 1+0, שזהו התיאור המדויק: שיקוף תחילה, ואז פריסה על פני השיקופים. RAID 0+1 הוא הסדר ההפוך: פריסה תחילה ואז שיקוף של שני ה-stripes. הוא פחות טוב, כיוון שכישלון של כונן אחד מוציא stripe שלם מהשירות והתיקון מחייב העתקה של כל הצד השני.

Linux היא מקרה מיוחד שכדאי להכיר. ה-raid10 של ה-kernel הוא אישיות אחת במקום שתי שכבות מוערמות, לכן הוא רץ על מספר אי-זוגי של כוננים ויש לו פריסות (near, far, offset) שהגדרה מקוננת אינה יכולה לבטא. זו הסיבה ששורת הסטטוס בשרת Linux מציגה 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 נותנים 7 TB של שטח זמין תחת RAID 5 ו-4 TB תחת RAID 10. הפער הזה הוא כסף אמיתי, וזו הסיבה ש-parity ממשיך לעלות כהצעה. RAID 6 שורד 2 כישלונות בכל תבנית שהיא. RAID 10 מבטיח רק 1, כיוון שהכישלון השני המסוכן הוא זה שנופל על השותף של הכונן שכבר מת. הוא שורד עד 4 כאשר אף שני כישלונות אינם חולקים זוג, מה שמהווה מזל ולא תכונה תכנונית.

העלות של כל רמה בכל פעולת כתיבה

כתיבה ל-mirror מורכבת משתי פעולות כתיבה, המבוצעות בו-זמנית לשני החברים במערך. כתיבה ל-stripe עם parity דורשת עבודה רבה יותר, כיוון שבלוק ה-parity עבור אותו stripe הופך ללא מעודכן ויש לחשב אותו מחדש.

בתהליך read-modify-write, הבקר קורא תחילה את הנתונים הישנים ואת ה-parity הישן. כתיבה מחדש (overwrite) של בלוק בודד שאינו ב-cache ב-RAID 5 הופכת ל-read, read, write, write. מערך RAID 6 מחזיק שני בלוקים של parity, לכן ה-read-modify-write הופך ל-read, read, read, write, write, write. לינוקס משתמשת גם ב-reconstruct-write, שבו נקראים נתונים שלא השתנו כדי לחשב את ה-parity. ב-RAID 5 עם שלושה כוננים, כתיבה כזו יכולה לדרוש קריאת נתונים אחת ושתי כתיבות; ב-RAID 6 עם ארבעה כוננים, קריאת נתונים אחת ושלוש כתיבות. המספרים ארבע ושש מייצגים את ספירת ה-read-modify-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
  }
]

פעולת read-modify-write של בלוק בודד שאינו ב-cache עולה 6 פעולות התקן ב-RAID 6, לעומת 2 עבור אותה כתיבה מחדש ב-RAID 10 עם שני עותקים. ספירות אלו ממעיטות בהערכת ההבדל ב-latency. שתי כתיבות ה-mirror יוצאות במקביל, לכן ה-guest ממתין לאיטי מבין השניים. נתיב ה-read-modify-write כולל קריאה שחייבת להסתיים לפני שניתן לחשב את ה-parity החדש, לכן ה-guest ממתין לקריאה ולאחריה לכתיבה, בזו אחר זו. במארח עמוס, קריאה זו נכנסת לתור מאחורי ה-I/O של כל השאר.

ישנו חריג חשוב. כתיבה גדולה מספיק כדי למלא stripe שלם אינה זקוקה לנתונים ישנים, כיוון שכל בלוק ב-stripe מוחלף. ה-parity מחושב ממה שכבר נמצא בזיכרון, והתקורה יורדת לכתיבת parity אחת לכל stripe ב-RAID 5 או שתיים ב-RAID 6, ללא קריאות מוקדמות (prereads). זו הסיבה ש-RAID 5 נראה תקין ב-benchmark סדרתי ומתנהג רע תחת עומס מעורב של כתיבות קטנות מצד דיירים רבים. בדקו את התבנית שאתם מריצים בפועל: ביצוע benchmark תקין לדיסק של VPS משמעו I/O אקראי בעומק תור ריאלי, לא dd אחד גדול.

מדוע תהליך ה-rebuild הוא החלק המסוכן

תהליך rebuild מלא ב-RAID 5 מחייב שחזור של הכונן החסר מכל שאר הכוננים, ולכן הוא קורא מ-7 כוננים ששרדו, מהבלוק הראשון ועד האחרון בדוגמה של שמונה כוננים. בזוגות מראה (mirror) קבועים, תהליך rebuild ב-RAID 10 קורא מ-1: השותף למראה של הכונן התקול, ולא שום דבר אחר. פריסות RAID10 אחרות בלינוקס מפזרות את העותקים בצורה שונה: שחזור של חבר בפריסת near של שלושה התקנים קורא משני החברים ששרדו.

מכאן נובעות שתי עלויות. הראשונה היא זמן, כיוון שתהליך ה-rebuild מוגבל על ידי הכוננים ששרדו, עבודת השחזור ויעדי מהירות ההתאוששות. השנייה היא עומס. שחזור מבוסס parity מפזר את ה-I/O על פני כל הכוננים ששרדו. בזוגות מראה קבועים, rebuild של RAID 10 מרכז את ה-I/O על זוג אחד; משאבי בקר ומארח משותפים עדיין משפיעים על שאר הזוגות.

קיים סיכון לשלמות הנתונים באותו חלון זמן. מערך RAID 5 עם כונן אחד תקול נותר ללא יתירות, ולכן סקטור בלתי קריא בכל מקום בכונן ששרד הופך כעת לבלתי ניתן לשחזור. תהליך ה-rebuild הוא הפעולה היחידה שקוראת כל סקטור, כולל אלו שאף אחד לא נגע בהם במשך שנה. נתוני יצרן מפרסמים כונן קשיח צרכני עם שגיאת קריאה בלתי ניתנת לשחזור אחת לכל 10^14 ביטים שנקראו, וכונן NVMe ארגוני עם אחת לכל 10^17 או טוב מכך. אלו מפרטי יצרן ולא מדידות בפועל, אך היחס מסביר מדוע האזהרה הישנה ש-rebuild של RAID 5 ייכשל נכתבה על כוננים מסתובבים גדולים, ומדוע היא חלשה הרבה יותר ב-NVMe. הטיעון לגבי העומס תקף בכל סוג מדיה.

מצאו שגיאות חבויות לפני שה-rebuild עושה זאת, באמצעות ביצוע scrub. הפצות 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_cnt

sync_action חוזר ל-idle בסיום הסריקה, ו-mismatch_cnt אמור להציג 0. מספר הגבוה מאפס במערך מראה (mirror) אומר ששני החצאים אינם מסכימים ביניהם וה-kernel אינו יכול לקבוע מי מהם צודק, כיוון שאף עותק אינו נושא checksum. חלק מהאי-התאמות אינן מזיקות, ומחיצות swap הן המקור הנפוץ לכך: ה-kernel עשוי לכתוב דף שמשתנה מתחתיו. מספר עולה במערך נתונים מחייב בדיקה; המספר כשלעצמו אינו מזהה איזה כונן יש להחליף.

מדוע ספקי VPS מתקננים על RAID 10 עבור NVMe

צומת hypervisor אינו מריץ עומס עבודה יחיד. הוא מריץ עשרות אורחים שאינם קשורים זה לזה, וה־I/O שלהם מגיע משולב כזרם של כתיבות קטנות ללא לוקאליות ביניהן. זהו בדיוק הדפוס שבו מחזור ה-parity read-modify-write עולה הכי הרבה, וזהו הדפוס שקיים בצומת משותף לאורך כל היום.

הוסיפו לכך את התנהגות השחזור (rebuild) והבחירה הופכת למובנת מאליה. כונן כושל בצומת מבוסס parity מוסיף עבודת שחזור לכל הכוננים ששרדו. עם זוגות מראה (mirror) קבועים, כונן כושל בצומת RAID 10 מוסיף I/O של שחזור לזוג אחד בלבד, ו־Linux MD מאט את ההתאוששות כאשר מתקיימת פעילות אחרת. ספקים מוכרים שיהוי (latency) שאינו מזנק, לכן הם קונים זאת באמצעות קיבולת: מחצית מנפח ה־NVMe הגולמי מוקצה למראה.

גדלי הכוננים דוחפים לאותו כיוון. ככל שהכוננים גדלים, חלון השחזור מתארך, וב־RAID 5 זהו החלון שבו השחזור מוסיף עומס ולא נותרת יתירות; RAID 6 שומר על הגנה מפני כשל של כונן נוסף. זו אותה סיבה שפריסות ZFS עבור וירטואליזציה משתמשות במאגרים (pools) של vdevs במבנה מראה במקום ב־raidz רחב: פעולת resilver של מראה מעתיקה רק את הבלוקים שנמצאים בשימוש בפועל, על זוג אחד.

שום דבר מזה לא הופך את RAID 10 לנכון בכל מקום. יעד גיבוי נכתב ברצפים ארוכים ונקרא לעיתים רחוקות, לכן RAID 6 הוא העסקה הטובה יותר שם. הוא שורד שני כשלים ומחזיר את רוב הקיבולת. עומס העבודה הוא הקובע, לא המספר. עבור תוכנית שאתם בוחרים היום, המדיום בדרך כלל חשוב יותר מהמבנה שמעליו, ו-הקפיצה מ-SATA SSD ל-NVMe גדולה יותר מכל הבדל של RAID על גבי כל אחד מהם.

כיצד לקרוא את /proc/mdstat

הריצו פקודות אלו על מכונה שבה אתם מחזיקים במערך: שרת ייעודי, מחשב ביתי, או VPS עם שני כוננים מחוברים שהרכבתם בעצמכם. קראו את הפלט שלכם. הבלוקים להלן הם דוגמאות, הכתובים כך שתוכלו להשוות את המבנה למה שאתם מקבלים.

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

מערך 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>

כל חלק בפלט נושא מידע.

  • Personalities מפרט את מודולי ה-md שנטענו ב-kernel הפעיל. הופעת raid10 שם מציינת שהקוד זמין, ולא מעבר לכך.
  • md0 : active raid10 הוא התקן המערך, מצבו, וה-level שלו.
  • השמות שאחריו הם החברים במערך. המספר בסוגריים מרובעים הוא האינדקס של ההתקן ב-metadata של המערך, לא המיקום שלו בשורה ולא תמיד ה-slot שלו.
  • לאחר החלפת כונן, החבר החדש בדרך כלל שומר על אינדקס גבוה יותר מה-slot שהוא ממלא, לכן nvme4n1p3[4] יכול לשבת ב-slot 2. mdadm --detail מדפיס את ה-slot האמיתי בעמודה RaidDevice, לכן השתמשו בזה כאשר ההבדל משמעותי.
  • (F) אחרי חבר במערך מציין תקלה. (S) מציין כונן spare: נוכח, לא פעיל, וממתין לכשל כלשהו.
  • 3906764800 blocks super 1.2 הוא הגודל הזמין בבלוקים של 1 KiB, ולאחריו פורמט ה-metadata.
  • 512K chunks 2 near-copies הוא גודל ה-chunk של ה-stripe וה-layout של ה-RAID 10, אשר במקרה זה שומר שני עותקים של כל בלוק זה לצד זה.
  • [4/4] הוא מספר החברים שהמערך מצפה לו, ולאחריו המספר שמסונכרן כרגע.
  • [UUUU] הוא תו אחד לכל slot, לפי סדר ה-slots. U הוא slot תקין ומסונכרן. _ הוא slot שאין בו רכיב עובד.
  • 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] מציין שאחד מתוך ארבעה slots אינו תורם למערך. [UU_U] מציין איזה מהם, כיוון שהקו התחתי הוא התו השלישי וה-slots ממוספרים מאפס, לכן slot 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 מתקינה daemon לניטור שקורא את MAILADDR מתוך /etc/mdadm/mdadm.conf, ושם ה-unit השתנה בין גרסאות, לכן מצאו אותו בעזרת הפקודה האחרונה במקום לנחש. הרצה של --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/sec

recovery הוא rebuild לכונן חלופי. resync הוא מעבר עקביות, כולל המעבר הראשוני ושחזור מכיבוי לא תקין. check הוא ה-scrub שהפעלתם למעלה. הצמד בסוגריים הוא ההתקדמות בבלוקים של 1 KiB ביחס לסך הכל של ההתקן, ו-finish הוא הערכת ה-kernel לפי המהירות הנוכחית. Linux MD משתמש ב-/proc/sys/dev/raid/speed_limit_min וב-speed_limit_max כיעדי מהירות שחזור, עם דריסות (overrides) לכל מערך ב-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 היא אינדקס ה-metadata המודפס בסוגריים ב-/proc/mdstat. העמודה RaidDevice היא ה-slot, שהוא המיקום במחרוזת [UU_U]. הם שונים כאן כיוון שהתקן 4 החליף את הכונן שהחזיק את slot 2. set-A ו-set-B מציינים את שני החצאים של כל mirror, לכן חבר מ-set-A וחבר מ-set-B באותו זוג שמחזיקים את אותו מידע הם הדבר שאסור לכם לאבד יחד.

החלפת כונן במערך שבבעלותכם מורכבת מארבע פקודות, והאחרונה שבהן היא הבדיקה.

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

רוב המערכות האורחות אינן יכולות לראות את ה-RAID של המארח, וזהו תכנון מכוון. ה-hypervisor מספק לך דיסק וירטואלי אחד. השאלה אם הדיסק הזה נגזר מתוך pool של RAID 10 על כונני NVMe או שהוא יושב על כונן בודד היא מאפיין של המארח, והיא אינה מופיעה בתוך המערכת האורחת שלך.

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

systemd-detect-virt מדפיס kvm במערכת אורחת מסוג KVM, סוג מכולה כמו lxc במכולה, ו-none על חומרה חשופה (bare metal). במערכת אורחת מסוג KVM תראה בדרך כלל vda או sda בודד ב-lsblk, ולא תראה מערכי דיסקים ב-/proc/mdstat, כיוון שאין כאלה בתוך המערכת האורחת.

ב-VPS מבוסס מכולות, הקריאה אינה מהימנה. מכולות חולקות את ה-kernel של המארח וחלקים מ-/proc אינם מבודדים ב-namespaces, לכן מה שאתה קורא שם עשוי לתאר את המארח ולא את החלק שלך בו. אל תתייחס לשום דבר מזה כאל עובדה לגבי האחסון שלך. שאל את הספק מהו המבנה, וקבל את התשובה בכתב אם הדבר חשוב לך.

מה שאתה יכול לבדוק מבפנים הוא את ההתנהגות של הדיסק שקיבלת. בדיקה האם דיסק ה-VPS שלך הוא באמת NVMe מכסה את הפקודות שמדווחות על נתונים ממשיים, ו-מה באמת כולל VPS מבוסס SSD מכסה את מה שהתווית בדף התוכנית טוענת.

האם כדאי להריץ RAID בתוך ה-VPS שלכם?

בדרך כלל לא, והסיבה לכך היא תחומי כשל (failure domains). אם תחברו שני כוננים (volumes) ל-VPS אחד ותבצעו ביניהם שיקוף (mirroring) באמצעות mdadm, ייתכן ששני הכוננים יאוחסנו על אותו מערך פיזי, באותו צומת, ומאחורי אותו ספק כוח. אתם תכפילו את עלות כל פעולת כתיבה עבור יתירות שכבר הייתה קיימת, ועדיין תאבדו את שני העותקים במקרה של כשל בודד ומשמעותי.

פעולה זו כדאית רק כאשר ספק השירות מתעד שהכוננים נמצאים בתחומי כשל נפרדים, או כאשר אתם עובדים על שרת ייעודי עם כוננים שניתן להצביע עליהם ישירות. אחרת, המאמץ מושקע טוב יותר בביצוע גיבויים שיוצאים אל מחוץ למכונה.

ממה RAID אינו מגן עליכם

RAID מכסה תרחיש אחד בלבד: כונן שמפסיק לעבוד כראוי. כל פעולה להלן נחשבת לכתיבה תקינה, ולכן המערך מבצע אותה על כל העותקים ומדווח על תקינותו.

  • מחיקה. rm -rf בספרייה הלא נכונה, או סקריפט פריסה עם משתנה לא מוגדר בנתיב. המערך רואה פעולת כתיבה חוקית ומבצע אותה פעמיים.
  • תוכנות כופר. הצפנה היא פעולת כתיבה. מערך תקין יאחסן את הגרסה המוצפנת בשני חלקי ה-mirror.
  • יישום תקול. באג שכותב נתונים פגומים למסד הנתונים שלכם יכתוב את אותם נתונים פגומים גם לכונן היתיר.
  • הצומת כולו. מארח שקורס, או חשבון שהושעה בטעות. מערך יכול להיות מושלם ובלתי נגיש בעת ובעונה אחת.
  • אתם עצמכם, שבוע לאחר מכן. הקובץ שמחקתם ביום שני נעלם מכל הכוננים ביום שני. רק עותק שנלקח לפני כן יחזיר אותו.

Snapshot על אותו התקן אחסון אינם הפתרון. הם עוזרים נגד מחיקה, אך הם נעלמים יחד עם המערך שעליו הם נמצאים. התכונה שהופכת גיבוי לגיבוי היא היותו במקום אחר. גיבויים מוצפנים מחוץ לשרת באמצעות restic הם החצי השני של דף זה: המערך מאפשר לכם להמשיך לספק שירות גם כשכונן מת, ו-restic מחזיר את הנתונים שלכם כאשר הנזק נגרם כתוצאה מכתיבה שהמערך ביצע בשמחה.

FAQ

האם RAID 10 אומר שאין לי צורך בגיבויים?

לא. RAID 10 מגן מפני כשל של כונן בודד. המערך מבצע כל פעולת כתיבה תקינה על שני חלקי ה-mirror, לכן מחיקה או פעילות של תוכנת כופר מגיעות לכונן היתיר באותו הרגע. לאחר מכן המערך מדווח על תקינות, כיוון שמבחינתו לא התרחש שום כשל. עדיין נדרשים עותקים שנשמרים מחוץ למכונה, ועדיין יש לבצע שחזור מדי פעם כדי לוודא שהם תקינים.

מדוע ספקי VPS מעדיפים RAID 10 על פני RAID 5 או RAID 6?

שתי סיבות, שתיהן נוגעות לכתיבות אקראיות קטנות. פעולת read-modify-write של בלוק בודד ללא cache קוראת נתונים ישנים ו-parity לפני חישוב ה-parity החדש, מה שצורך 4 פעולות ב-RAID 5 ו-6 ב-RAID 6, לעומת 2 ב-mirror של שני עותקים. פעולת reconstruct-write משתמשת בנתונים ללא שינוי, וכתיבות full-stripe אינן דורשות קריאה מוקדמת של נתונים או parity ישנים. בנייה מחדש (rebuild) של RAID 5 קוראת את כל הכוננים ששרדו מתחילתם ועד סופם, בעוד ש-RAID 10 קונבנציונלי עם זוגות mirror קבועים מעתיק מהשותף ששרד; פריסות RAID10 אחרות ב-Linux משתמשות במספר חברים כמקור. מנגנון ה-MD ב-Linux ממתן את מהירות השחזור כאשר יש פעילות אחרת. ספקים משלמים על כך בקיבולת: מחצית מנפח ה-NVMe הגולמי.

מה המשמעות של [U_] או [UU_U] בתוך /proc/mdstat?

כל תו מייצג חריץ (slot) במערך, לפי סדר החריצים, תו אחד לכל חריץ. U מציין שהחריץ מכיל חבר פעיל ומסונכרן. _ מציין שהחריץ אינו מכיל רכיב תקין. [U_] ב-mirror של שני כוננים אומר שהחריץ השני מושבת ואין יותר יתירות. יש לקרוא זאת יחד עם הזוג שלפניו, כאשר [4/3] אומר שהמערך מצפה לארבעה חברים ויש לו שלושה. סדר החריצים תואם לעמודת RaidDevice של mdadm --detail, ולא לסדר שבו שמות ההתקנים מופיעים בשורה.

כמה כוננים יכול מערך RAID 10 לאבד?

עבור RAID 10 קונבנציונלי של שני עותקים עם זוגות mirror קבועים, כונן אחד, בכל תצורה. מעבר לכך, הדבר תלוי במיקום הכשלים. כל זוג mirror יכול לאבד אחד משני חבריו, לכן מערך של שמונה כוננים ישרוד עד ארבעה כשלים אם אף שניים מהם לא חולקים את אותו זוג, אך הוא יקרוס בשני כשלים אם שניהם פוגעים באותו זוג. תכננו לפי המספר המובטח, שהוא אחד, והתייחסו לכל מה שמעבר לכך כאל מזל ולא כאל הגנה.

האם עליי לבצע mirror לשני כוננים בתוך ה-VPS שלי בעזרת mdadm?

בדרך כלל לא. שני כוננים המחוברים ל-VPS אחד נמצאים לרוב על אותו מערך פיזי באותו מארח, לכן ביצוע mirror ביניהם מכפיל את העלות של כל כתיבה ואינו מגן מפני שום דבר שה-RAID של המארח לא כיסה ממילא. כדאי לעשות זאת רק כאשר הספק מציין שהכוננים נמצאים ב-failure domains נפרדים. אחרת, השקיעו את המאמץ בגיבויים שיוצאים מהמכונה.

האם המאמר הזה היה מועיל?