האם כדאי לבחור אחסון NVMe עבור שרת VPS?
האם NVMe באמת משפר ביצועים ב-VPS? גלו מתי המעבר מ-SATA SSD מוצדק ומתי ה-hypervisor והשכנים בשרת יגבילו אתכם. למדו כיצד למדוד את מהירות הדיסק האמיתית בעזרת כלי fio.
האם ל-NVMe יש חשיבות ב-VPS?
ל-NVMe יש חשיבות ב-VPS כאשר התוכנה שלכם מבצעת פעולות קריאה וכתיבה קטנות רבות וממתינה לסיום כל אחת מהן. ההשפעה זניחה עבור אתר שמגיש דפים מה-cache, או עבור תוכנית שמבלה את רוב זמנה בהמתנה לתעבורת רשת. אמצעי האחסון הוא רק גורם אחד. ה-hypervisor שחוצץ מול הדיסק, והלקוחות האחרים שחולקים את אותו השרת הפיזי, הם אלו שקובעים את תקרת הביצועים שתקבלו בפועל.
מה משתנה ב-NVMe ומה נשאר ללא שינוי
NVMe (non-volatile memory express) אינו סוג של זיכרון פלאש. זהו הפרוטוקול ושיטת החיבור המשמשים לגישה לזיכרון הפלאש. התקן NVMe יושב על נתיבי PCIe (peripheral component interconnect express) ומתקשר באמצעות NVMe. כונן SSD בתקן SATA (serial ATA) יושב על ערוץ SATA ומתקשר באמצעות AHCI (advanced host controller interface). שבבי הזיכרון המאחסנים את הנתונים שלכם יכולים להיות זהים בשני המקרים.
שני דברים משתנים, ושניהם נוגעים לנתיב הפקודות ולא לאחסון עצמו.
תורים (Queues). תקן AHCI מקצה לכל פורט SATA רשימת פקודות אחת עם לכל היותר 32 חריצי פקודות, כך שכונן SATA לעולם לא מחזיק יותר מ-32 פקודות בו-זמנית. NVMe מאפשר אלפי תורים, בפועל תור אחד לכל ליבת CPU, כאשר כל תור עמוק בהרבה מ-32. תהליך שקורא בלוק אחד בכל פעם לא יבחין בהבדל הזה. מסד נתונים עם 64 קריאות ממתינות יבחין בהבדל: ב-SATA, הבקשה ה-33 תמתין לחריץ פנוי לפני שההתקן בכלל יראה אותה, בעוד שהתקן NVMe מקבל את כולן ומעבד אותן במקביל.
רוחב ערוץ (Link width). ערוץ SATA III פועל במהירות של 6 Gbit/s, שהם כ-550 MB/s של נתונים בפועל לאחר חישוב ה-overhead של הפרוטוקול. זהו תקרה קבועה, ללא קשר לסוג הפלאש שמאחוריו. ארבעה נתיבי PCIe מעבירים מספר גיגה-בייטים בשנייה, מה שנותן מרחב גדול בהרבה מ-SATA, אך הערוץ עדיין יכול להוות מגבלה: חברת Micron מתארת כונני PCIe Gen5 SSD המסוגלים להגיע לרוויה של ערוץ PCIe Gen5 בעומסי עבודה אקראיים.
בנושא השיהוי (Latency), הציפיות בדרך כלל שגויות. בעומק תור (queue depth) של 1, כלומר בקשה אחת בלבד בתהליך, כונן SATA SSD משיב לקריאת 4k בתוך כ-100 עד 150 מיקרו-שניות. NVMe משיב בתוך כ-80 עד 100. שניהם מהירים, ושום דבר שתריצו לא יבחין בהבדל בבקשה בודדת. הפער נפתח תחת עבודה במקביל (concurrency). עומק תור, מספר הבקשות שנמצאות בתהליך בו-זמנית, הוא ההגדרה שקובעת האם שני המדיות ייראו דומות או שונות מאוד.
אחסון בלוקים ברשת (Network block storage) הוא סוג שלישי עם פיזיקה שונה. כתיבה חוצה רשת אל אשכול אחסון ומקבלת אישור רק לאחר שהאשכול מחזיק את המידע, לכן השיהוי שלו נמדד במילי-שניות במקום במיקרו-שניות. מה שאתם קונים תמורת השיהוי הזה הוא שרידות: הנפח (volume) שורד גם לאחר שהמארח שאליו הוא מחובר מפסיק לפעול, וניתן לבצע לו snapshot ולשנות את גודלו.
נתונים אופייניים לביצועים: NVMe, SATA SSD ואחסון רשת
הנתונים שמאחורי התרשים
[
{
"disk": "Local NVMe SSD",
"iops_4k_read": "184,000",
"p99_latency_ms": 0.4,
"seq_read_mbps": "3,400"
},
{
"disk": "Local SATA SSD",
"iops_4k_read": "90,000",
"p99_latency_ms": 1.2,
"seq_read_mbps": "550"
},
{
"disk": "Network block storage",
"iops_4k_read": "12,500",
"p99_latency_ms": 6.5,
"seq_read_mbps": "250"
}
]התקן NVMe מקומי מציג בדרך כלל נתון של 184,000 פעולות קריאה אקראיות של 4k בשנייה (IOPS) בעומק תור (queue depth) של 32. אותו מבחן על כונן SATA SSD מציג נתון הקרוב ל-90,000, המוגבל על ידי 32 חריצי הפקודות של פרוטוקול AHCI לכל פורט ועל ידי רוחב הפס של 6 Gbit/s. אחסון בלוקים ברשת מוגבל לרוב על ידי ספק השירות ולא על ידי החומרה, ו-12,500 הוא תקרה מתועדת נפוצה.
השהיה (latency) משקפת את אותה המציאות ביחידות זמן שהמשתמשים חווים. השהיית קריאה מסוג p99 – הזמן שבו 99 אחוז מהבקשות מסתיימות, כך שרק האחוז האיטי ביותר לוקח זמן רב יותר – עומדת על כ-0.4 ms בכונן NVMe מקומי ועל 1.2 ms ב-SATA. הוספת רשת בנתיב הנתונים מעלה את הנתון ל-6.5 ms, פי עשרה ויותר מהנתון של NVMe.
קריאה סדרתית (sequential) מציגה את הפער הגדול ביותר, אך היא גם הפחות רלוונטית: 3,400 MB/s לעומת 550 MB/s. כמעט אף שירות בשרת אינו קורא קובץ גדול מתחילתו ועד סופו במהירות המקסימלית. העמודות של קריאה אקראית והשהיה מתארות את מה שמתרחש בפועל במסד נתונים, בתור דואר או במנהל חבילות.
מאין מגיעים הנתונים הללו, ומדוע התוצאות שלכם יהיו שונות
השורות ב-3 מבוססות על נתוני יצרן עבור התקנים מקומיים ועל מגבלות מתועדות לכל נפח אחסון עבור אחסון רשת, נכון ליולי 2026 ומעוגלות. הן מניחות גודל בלוק של 4k, קריאות אקראיות ועומק תור של 32. היצרנים אינם משתמשים כולם באותו מספר תהליכונים (workers) בבדיקות שלהם: דף הנתונים של Samsung 990 PRO, למשל, מציין את נתוני הקריאה האקראית שלו תחת "QD 32 Thread 16", כך שביצוע בדיקת fio בודדת בעומק תור של 32 הוא מבחן קל יותר מזה שמופיע בדף הנתונים. ה-VPS שלכם הוא אורח על שרת מארח משותף, לכן אותה בדיקה על השרת שלכם תניב בדרך כלל תוצאות נמוכות יותר, והן ישתנו בין הרצה להרצה. התייחסו לשורות אלו כאל הצגת הפערים בין שלוש הקטגוריות, ולא כיעד שיש להגיע אליו.
אילו עומסי עבודה מבחינים בדיסק
כלל אחד מסביר את כולם: עומס עבודה מבחין בדיסק רק כאשר הוא ממתין לו. לינוקס שומרת נתוני קבצים שנעשה בהם שימוש לאחרונה ב-RAM, בתוך ה-page cache, כך שהקריאה השנייה של קובץ לעולם אינה מגיעה לאחסון. אם סט העבודה, כלומר הנתונים שנמצאים בשימוש בפועל, נכנס לתוך ה-RAM, קריאות הופכות לקריאות זיכרון לאחר המעבר הראשון. כתיבות הן עניין שונה. כל כתיבה שהיישום מבצע לה פלאש (flush) באמצעות fsync() חייבת להימצא באחסון יציב לפני שהיישום רשאי להמשיך.
עבודה שמבצעת commit. מסדי הנתונים PostgreSQL, MySQL ו-SQLite קוראים ל-fsync() או ל-fdatasync() בעת ביצוע commit, וכל commit ממתין לתגובת ההתקן. לכן, קצב ה-commit של חיבור בודד נקבע על ידי השהיית כתיבה (write latency), ולא על ידי רוחב פס. התקן שמבצע פלאש ב-0.2 ms מאפשר הרבה יותר commits בשנייה מאשר התקן שלוקח לו 5 ms, ושום כמות של תפוקה (throughput) לא תשנה זאת. MySQL מציינת זאת ביומן השגיאות כאשר ה-flush אינו עומד בקצב:
[Note] InnoDB: page_cleaner: 1000ms intended loop took 4589ms. The settings might not be optimal.PostgreSQL מדווחת על כך בשורות ה-checkpoint שלה, שבהן ערך sync= גבוה מעיד על כך שה-flush עצמו היה איטי:
LOG: checkpoint complete: wrote 8192 buffers (25.0%); write=27.694 s, sync=11.207 s, total=39.001 sעבודה שנוגעת בהרבה קבצים קטנים. כל קובץ גורר פעולות מטא-דאטה שקריאה רציפה אחת גדולה אינה גוררת. npm install, git clone של מאגר גדול, פריסת מכולות (container images), אחסון דואר מסוג Maildir וגיבוי שסורק עץ קבצים גדול, כולם מבלים את זמנם בגישה אקראית לקבצים קטנים. משימת גיבוי restic ב-VPS קוראת ומבצעת hashing לכל קובץ שטרם ראתה, ולכן זמן הביצוע הכולל של גיבוי הכולל מיליון קבצים עוקב מקרוב אחר השהיית הקריאה האקראית. כך גם לגבי du -sh, שקוראת מטא-דאטה בלבד.
מסדי נתונים שחורגים מגודל ה-RAM שייכים גם הם לקטגוריה זו. ברגע שהאינדקס אינו נכנס יותר ל-page cache, כל חיפוש הופך לקריאה אקראית, והדיסק חוזר להיות צוואר הבקבוק הקריטי.
אילו עומסי עבודה אינם מושפעים מהדיסק
בלוג או אתר של חברה קטנה. הדפים קטנים, ה-page cache מחזיק את כולם לאחר הבקשה הראשונה, והמגבלה היא ה-CPU עבור רינדור או רוחב הפס עבור נכסים. מחסנית LAMP על Ubuntu 24.04 המשרתת אתר עם תעבורה נמוכה כמעט אינה מבצעת IO לדיסק לאחר שהיא חמה.
הזרמת מדיה. זרם 4K אחד ב-40 Mbit/s קורא 5 MB/s. עשרה זרמים כאלה קוראים 50 MB/s, מה שגם אחסון בלוקים ברשת משרת ללא מאמץ. שרת מדיה Jellyfin על גבי VPS מוגבל על ידי מכסת התעבורה היוצאת מהרשת שלך, ועל ידי ה-CPU בעת קידוד מחדש (transcoding), ולא על ידי אמצעי האחסון.
הסקה מקומית של מודלים. הרצת Ollama על גבי VPS לאירוח עצמי של LLM קוראת את קובץ המודל פעם אחת, ולאחר מכן עובדת ב-RAM. כונן NVMe מקצר את זמן הטעינה של מודל בגודל 20 GB מדקות לשניות. הוא אינו משנה את קצב ה-tokens לשנייה, המוגבל על ידי רוחב פס של זיכרון ו-CPU.
כל תהליך הממתין לשירות חיצוני. Worker שמבלה 800 ms לכל משימה על בקשת HTTP לא יפעל מהר יותר על דיסק טוב יותר.
מדוע ה-hypervisor חשוב לא פחות מהמדיה הפיזית
אתם לעולם לא מתקשרים ישירות להתקן. אתם מתקשרים לדיסק וירטואלי שה-hypervisor מציג, בדרך כלל באמצעות virtio, ומספר החלטות בשכבה זו משפיעות יותר מאשר ההבדל בין NVMe ל-SATA.
לא ניתן לראות את המדיה מתוך ה-guest. הפקודה lsblk -d -o NAME,ROTA,SIZE,MODEL מציגה vda עם דגם ריק, מכיוון ש-virtio אינו מעביר את זהות הכונן. הפקודה cat /sys/block/vda/queue/rotational מדווחת על מה שה-hypervisor מפרסם, לכן ערך 0 שם אינו הוכחה לשימוש ב-flash. הפקודה nvme list, מחבילת nvme-cli, לא תציג דבר ברוב ה-VPS גם אם המארח מלא בכונני NVMe, מכיוון שהדיסק שלכם הוא התקן virtio ולא התקן NVMe. תוכנית המציינת NVMe מתארת בדרך כלל את מה שקיים במארח. ייתכן שהנפח שלכם עדיין מחובר דרך הרשת.
מצב ה-cache של המארח משפיע על התוצאות יותר מהמדיה עצמה. עם caching מסוג writeback במארח, כתיבה של ה-guest יכולה להסתיים ברגע שהנתונים נמצאים ב-RAM של המארח, מה שמשפר תוצאות של כל benchmark שאינו מבצע flush. אם המארח מוגדר גם להתעלם מפקודות flush, מצב ש-QEMU מכנה unsafe, אפילו פקודת fsync() של ה-guest תחזיר תשובה מה-RAM של המארח. זה מפיק תוצאת benchmark שאף התקן פיזי לא יכול לספק. המשמעות היא גם שקריסת מארח עלולה לגרום לאובדן כתיבות שמסד הנתונים שלכם מחשיב כבטוחות. עם מצב cache מסוג none, ה-page cache של המארח נעקף והתוצאות נמוכות ואמינות יותר.
מכסות וקרדיטים ל-burst. ספקים רבים מגבילים IOPS לכל נפח או לכל תוכנית, ונפחי רשת רבים משתמשים במכסת burst. מכסת burst היא מאגר של קרדיטים: הנפח פועל במהירות כל עוד נותרו קרדיטים, ואז יורד לרמת בסיס נמוכה בהרבה. קל לזהות את התופעה. פעולת ייבוא או שחזור רצה במהירות במשך כמה דקות, ואז מואטת בחדות ונשארת איטית, מבלי ששונה דבר בתצורה שלכם. ניצלתם את הקרדיטים.
שכנים. במארח משותף, השהיית הדיסק שלכם משתנה בהתאם לפעילות של guest אחרים. זו הסיבה למדוד יותר מפעם אחת. הריצו את אותו מבחן בבוקר ושוב בערב, והשוו את הפערים. במארח עמוס, ההבדל בין שתי הרצות על אותו נפח גדול לעיתים קרובות מההבדל המוצהר בין שתי מדיות שונות.
כיצד למדוד את הדיסק שמותקן בפועל ב-VPS שלכם
התקינו את fio, כלי הסטנדרט למדידת ביצועי IO, ובצעו מדידה. שלוש אזהרות לפני שמתחילים: הבדיקה יוצרת קובץ, לכן היא צורכת שטח דיסק ונחשבת במכסת ה-IOPS שעליה אתם משלמים. שמרו על הרצות קצרות. אל תריצו את הבדיקה בעומק תור (queue depth) מלא מול כרך שמשרת תעבורה חיה, שכן תיווצר תחרות מול היישום שלכם.
sudo apt update && sudo apt install -y fio ioping sysstat
cd /var/tmpקריאה אקראית בעומק תור של 32, העומק שספקים מציינים (רבים מריצים גם כמה תהליכונים במקביל, לכן עבודה בודדת בדרך כלל תניב תוצאה נמוכה מהמפרט הטכני):
fio --name=randread --filename=fio.test --size=1G --bs=4k --rw=randread \
--ioengine=libaio --direct=1 --iodepth=32 --numjobs=1 \
--runtime=30 --time_based --group_reportingהשורה שחשובה מתחילה ב-read:
read: IOPS=184k, BW=719MiB/s (754MB/s)(21.1GiB/30001msec)הדגל --direct=1 עוקף את ה-page cache של האורח, לכן התוצאה מתארת את הדיסק הווירטואלי ולא את ה-RAM של האורח. הוא אינו עוקף מטמון כלשהו בשרת המארח (host). השאלה האם ה-page cache של המארח נמצא בנתיב תלויה במצב המטמון של המארח (QEMU מדלג עליו רק עם cache.direct=on), ולא ניתן לראות הגדרה זו מתוך האורח. השאירו את --direct=1 בחוץ ותמדדו זיכרון, מה שיחזיר מספר שאף דיסק לא יכול להגיע אליו. השתמשו ב---size=4G או גדול יותר אם יש לכם מקום, כיוון שקובץ של 1G יכול לשבת במלואו בתוך המטמון של המארח ולנפח את התוצאה.
עומק תור של 1 שומר על בקשה אחת בתהליך בכל פעם, לכן הוא מציג את ה-latency הגולמי, שזה מה שתהליך שמבצע קריאות סינכרוניות בזו אחר זו מרגיש. תהליכון בודד שמשתמש ב-IO אסינכרוני יכול להחזיק בקשות רבות בתהליך, לכן הוא אינו מוגבל למספר זה:
fio --name=lat --filename=fio.test --size=1G --bs=4k --rw=randread \
--ioengine=libaio --direct=1 --iodepth=1 --runtime=30 --time_basedבדיקת ה-commit חוזה את התנהגות מסד הנתונים. היא כותבת 4k וקוראת ל-fdatasync() אחרי כל כתיבה, לכן הקצב המדווח כולל את ה-flush:
fio --name=commit --filename=fio.test --size=1G --bs=4k --rw=randwrite \
--ioengine=psync --fdatasync=1 --runtime=30 --time_based
rm -f fio.testנתון ה-IOPS מהרצה זו קרוב למספר הגבוה ביותר של טרנזקציות קטנות בשנייה שחיבור מסד נתונים בודד יכול לבצע commit, כיוון ש-commit ממתין לאותו flush.
לדגימה מהירה ללא fio:
ioping -c 20 .--- . (ext4 /dev/vda1) ioping statistics ---
19 requests completed in 4.13 ms, 76 KiB read, 4.60 k iops, 17.9 MiB/s
min/avg/max/mdev = 174.2 us / 217.6 us / 386.1 us / 51.3 usהערך mdev, סטיית התקן הממוצעת, חשוב בדיוק כמו הממוצע. סטייה גדולה במכונה לא פעילה מעידה על כך ש-backend האחסון משותף ועמוס.
כיצד לקרוא את התוצאות
נכון ליולי 2026, אלו הם ערכים סבירים עבור VPS קטן. עשרות אלפי IOPS של קריאה אקראית בנפח 4k בעומק תור (queue depth) של 32, עם שיהוי (latency) של פחות מ-0.3 ms בעומק תור 1, תואמים לביצועי זיכרון פלאש מקומי, אם כי מערך אחסון עם מטמון DRAM גדול יכול להגיב גם ב-0.2 ms. שיהוי של כמה מילי-שניות בעומק תור 1 מצביע על נתיב רשת או על מגבלת IOPS מצד המארח (host), ללא קשר לשם התוכנית: מגבלה של ה-hypervisor ל-250 IOPS בלבד מעכבת כל בקשה בודדת בכ-4 ms. קריאות סדרתיות שנעצרות סביב 550 MB/s מתאימות לחיבור SATA, אך מגבלת רוחב פס המוגדרת במארח תייצר את אותו קו ישר, לכן יש להתייחס לכך כרמז ולא כהוכחה. מספר גבוה בהרבה ממה שכל התקן בודד מסוגל לבצע מעיד על קיומו של caching בנתיב, כמעט תמיד ברמת המארח.
כדי לראות כיצד עומס העבודה הנוכחי שלכם משפיע על הדיסק:
iostat -x 1 3
vmstat 1 5
cat /proc/pressure/ioבפלט של iostat -x, קראו את r_await ואת w_await, המייצגים את ממוצע המילי-שניות שבקשה המתינה, ואת aqu-sz, המייצג את אורך התור הממוצע. התעלמו מ-%util בדיסק וירטואלי. הוא מדווח על חלק הזמן שבו לפחות בקשה אחת הייתה בהמתנה, נתון שאינו מעיד דבר על רוויה בהתקן המשרת בקשות רבות בו-זמנית; לכן, %util של 100 לצד r_await של 0.2 ms מעידים על דיסק עמוס ותקין. ב-vmstat, העמודה wa מציגה את אחוז זמן המעבד שהושקע בהמתנה ל-IO. אם /proc/pressure/io קיים ב-kernel שלכם, הערך some avg10= שלו הוא ממוצע דועך, עם קבוע זמן של 10 שניות, של חלק הזמן שבו לפחות משימה אחת הייתה תקועה בהמתנה ל-IO. זוהי התשובה הישירה ביותר לשאלה האם האחסון הוא צוואר הבקבוק שלכם.
איך נראה VPS שמוגבל על ידי הדיסק
עומס מערכת גבוה (load average) בזמן שה-CPU אינו בשימוש, יחד עם ערך גבוה ב-wa בתוך vmstat, מעידים על כך שתהליכים ממתינים בתור לדיסק. הסימן הברור ביותר מה-kernel הוא ההודעה הבאה ב-dmesg -T:
INFO: task jbd2/vda1-8:194 blocked for more than 120 seconds.שורה זו מופיעה מכיוון ש-kernel thread המתין מעל שתי דקות לתגובה מהאחסון, ולכן ה-hung task watchdog תיעד זאת. jbd2 הוא ה-journal thread של ext4, כלומר העיכוב התרחש בנתיב ה-commit של מערכת הקבצים ולא בגלל תוכנית ספציפית שמתנהגת בצורה לא תקינה. כל פעולה שזקוקה לסיום ה-journal commit הזה, כמו למשל fsync(), תמתין מאחוריו. ב-VPS, הדבר מצביע בדרך כלל על ה-storage backend או על מיצוי מכסת ה-IOPS.
התסמינים ביישום עוקבים אחר אותו דפוס. זמן התגובה החציוני נשאר תקין, בעוד שהבקשות האיטיות ביותר יוצרות "זנב" ארוך, כיוון שרק הבקשות שניגשות לדיסק משלמות את המחיר. apt upgrade נתקע במצב Unpacking למשך דקות, כיוון ש-dpkg מבצע flush בזמן הכתיבה. git status במאגר נתונים גדול לוקח שניות ארוכות. אלו עלויות של מטא-דאטה ו-flush, ולכן תוספת רוחב פס לא תועיל.
מה לעשות כשמגבלת הדיסק היא צוואר הבקבוק
רכשו זיכרון RAM לפני שאתם משדרגים IOPS. אם סט הנתונים הפעיל נכנס לתוך ה-page cache, פעולות קריאה לא יגיעו לדיסק כלל. הכפלת הזיכרון לרוב יעילה יותר ממעבר לסוג אחסון מהיר יותר, ובדרך כלל גם זולה יותר.
צמצמו את מספר פעולות ה-flush, במקומות שבהם הנתונים מאפשרים זאת. ב-PostgreSQL, ההגדרה synchronous_commit = off מאפשרת ל-commit לחזור לפני שהכתיבה הושלמה בדיסק. אתם עלולים לאבד שבריר שנייה אחרון של טרנזקציות אם השרת קורס. מסד הנתונים לא יושחת, כיוון שה-write-ahead log עדיין נכתב לפי הסדר. פשרה זו מתאימה לעותק של מערכת אנליטיקה, אך אינה מתאימה למערכות תשלומים. ההגדרה innodb_flush_log_at_trx_commit = 2 ב-MySQL מייצגת פשרה זהה.
אחדו קבצים קטנים. העברה או גיבוי של מיליון קבצים קטנים מושפעים בעיקר מהעלות לכל קובץ. לכן, יצירת ארכיון לפני ההעברה ושינוע זרם נתונים אחד מהירים יותר באחסון בעל שיהוי (latency) גבוה, בהשוואה להעתקת עץ קבצים קובץ אחר קובץ.
וודאו שפעולת ה-discard עובדת בכרכים מסוג thin provisioned. באחסון מסוג thin provisioned, מערכת ה-backend אינה יודעת שבלוק התפנה עד שמערכת הקבצים מדווחת על כך. כרך שלעולם לא עובר תהליך trim יאבד בהדרגה את ביצועי הכתיבה שלו. ב-Ubuntu קיים טיימר שבועי המטפל בכך:
systemctl status fstrim.timer
sudo fstrim -avהפקודה fstrim -av מציגה את מספר הבייטים שעברו trim עבור כל נקודת עיגון (mount point). הודעה המציינת שפעולת ה-discard אינה נתמכת משמעותה שהדיסק הווירטואלי אינו מעביר את הפקודה למארח, ולכן אין באפשרותכם לתקן זאת.
דלגו על כוונון ה-IO scheduler. בדיסק מסוג virtio, הפקודה cat /sys/block/vda/queue/scheduler בדרך כלל תציג כבר none, והתזמון האמיתי מתבצע במארח, שאין לכם גישה אליו. דלגו גם על noatime: ב-Ubuntu נקודות העיגון מוגדרות כברירת מחדל עם relatime, מה שמונע כמעט את כל פעולות הכתיבה של atime.
בחירת תוכנית
שלמו עבור NVMe כאשר השרת מריץ מסד נתונים, שרת דואר, CI runner או תהליך בנייה עתיר חבילות. אל תשלמו מחיר פרימיום עבור אתר מבוסס מטמון או עבור יישום שזמן העיבוד שלו מושקע בקריאות חיצוניות. אם אינכם בטוחים, סביר להניח שהדיסק אינו צוואר הבקבוק שלכם, כיוון שרוב עומסי העבודה ב־VPS קטנים מנצלים תחילה את ה־RAM או את רוחב הפס.
בצעו מדידות ביום הראשון, בזמן שאתם עוברים על עשר הדקות הראשונות ב־VPS חדש, ושמרו את הפלט בקובץ. קו בסיס (baseline) הוא הדרך שלכם להוכיח בהמשך שהשרת הוא זה שהפך לאיטי ולא הקוד שלכם. העדיפו ספקיות שמציינות בכתב את סוג האחסון ואת מגבלת ה־IOPS. אם תוכנית מוגדרת כ־NVMe וקריאה ב־queue depth 1 אורכת 4 ms, אתם לא מקבלים שיהוי (latency) של NVMe מקומי: או שהנפח הוא אחסון רשת על שרת מצויד ב־NVMe, או שהשרת מגביל את ה־IOPS שלכם לרמה נמוכה מספיק כדי לעכב כל בקשה ל־4 ms. שאלו את הספקית מה המצב. שני המקרים הם מוצרים לגיטימיים למכירה, אך הם דברים שונים לחלוטין לרכישה.
FAQ
האם NVMe תמיד מהיר יותר מ-SATA SSD בשרת VPS?
לא. בעומק תור (queue depth) של 1, הביצועים של שניהם דומים, בערך 80 עד 150 מיקרו-שניות לקריאת 4k, ותוכנית שמוציאה בקשה אחת בכל פעם לא תבחין בהבדל. NVMe מוביל כאשר ישנן בקשות רבות בתהליך, כיוון ש-AHCI מציע לכל היותר 32 חריצי פקודות לכל פורט, בעוד NVMe מציע אלפי תורים עמוקים יותר. בשרת מארח משותף, עומס מצד לקוחות אחרים עשוי להשפיע על ה-latency שלכם יותר מאשר סוג המדיה, לכן מדדו את הנפח שלכם באמצעות fio במקום להסתמך על שם התוכנית.
איך אוכל לבדוק אם ה-VPS שלי באמת משתמש ב-NVMe?
לא ניתן לבדוק זאת ישירות, כיוון ש-virtio מסתיר את ההתקן הפיזי. lsblk מציג vda ללא מחרוזת דגם, nvme list לא מחזיר דבר, ו-/sys/block/vda/queue/rotational מדווח רק על מה שה-hypervisor מפרסם. מדדו את ההתנהגות במקום זאת, והתייחסו לתוצאה כאל אינדיקציה ולא כאל הוכחה. קריאת 4k אקראית בעומק תור 1 של פחות מ-0.3 ms תואמת לזיכרון פלאש מקומי, אם כי מערך אחסון עם מטמון DRAM יכול להגיב במהירות כזו גם כן. מספר מילי-שניות מצביעים על דילוג רשת או על מגבלת IOPS בשרת המארח. קריאות רציפות שנעצרות סביב 550 MB/s מרמזות על חיבור SATA או על מגבלת רוחב פס.
האם NVMe גורם לאתר שלי להיטען מהר יותר?
בדרך כלל לא. לאחר הבקשה הראשונה, Linux מגיש את הקבצים מתוך ה-page cache ב-RAM, כך שהדיסק נותר במצב המתנה. מהירות דף ב-VPS קטן מוגבלת בדרך כלל על ידי זמן מעבד של היישום ועל ידי רוחב פס. הדיסק חוזר למסלול הקריטי אם האתר מבצע כתיבה בכל בקשה, למשל עגלת קניות מבוססת מסד נתונים שמבצעת commit לעיתים קרובות, כיוון שכל commit ממתין להשלמת ה-flush.
מהי תוצאת fio טובה עבור VPS?
נכון ליולי 2026, VPS קטן על פלאש מקומי מחזיר בדרך כלל עשרות אלפי IOPS של קריאה אקראית 4k בעומק תור 32, עם latency של פחות מ-0.3 ms בעומק תור 1. אחסון בלוקים מבוסס רשת מחזיר בדרך כלל כמה אלפי IOPS ב-latency של כמה מילי-שניות. בצעו את הבדיקה שלוש פעמים בשעות שונות. טווח רחב בין התוצאות מלמד יותר מהממוצע, כיוון שהוא מראה עד כמה הלקוחות האחרים בשרת המארח משפיעים עליכם.
האם כדאי לי להציב את מסד הנתונים שלי על אחסון בלוקים ברשת?
ניתן לעשות זאת, ושירותים מנוהלים רבים אכן עושים זאת, אך מסלול ה-commit משלם על כך מחיר. כל פעולת flush עוברת ברשת, לכן חיבור בודד יבצע פחות טרנזקציות קטנות בשנייה בהשוואה לפלאש מקומי. בתמורה, אתם מקבלים עמידות (durability) ששורדת את השרת המארח. אם בחרתם באחסון רשת עבור מסד נתונים עתיר כתיבות, קבצו את הפעולות לטרנזקציות גדולות יותר כך שפחות פעולות flush יישאו יותר שורות.