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

מהו CPU steal time ואיך לזהות שכן רועש ב-VPS

מדד ה-steal time ב-vmstat חושף מתי השרת שלכם ממתין למשאבי מעבד מהמארח. למדו להבדיל בין עומס פנימי לבין השפעת שכנים בשרת ה-VPS שלכם ולפענח את עמודת ה-st בדו"ח המערכת.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 7, 2026.

מהו מדד ה-CPU steal time בפועל

מדד ה-CPU steal time מייצג את פרק הזמן שבו ה-vCPU שלכם היה מוכן לביצוע, ללא כל המתנה מצדו, בעוד ה-hypervisor הקצה את הליבה הפיזית לאורח (guest) אחר. העבודה המתינה בתור, והליבה הייתה בשימוש במקום אחר. מערכת Linux סופרת מחזורי מעבד אלו בנפרד ומדווחת עליהם כ-st; זהו האופן שבו ניתן להבחין בין מצב שבו "השרת שלי עמוס" לבין מצב שבו "השרת שלי ממתין לתורו".

הבחנה זו היא הסיבה המרכזית לקיומו של המונה. זמן שבו התהליכים שלכם משתמשים ב-CPU מדווח כ-us (user) או כ-sy (system). זמן שבו משימה חסומה בהמתנה לאחסון מדווח כ-wa (I/O wait). כאשר vCPU נמצא במצב מוכן לביצוע (runnable), ממתין בתור הריצה, ללא פעולות I/O תלויות ועומדות, ועדיין אינו מבצע פקודות, המערכת מדווחת על st. שום גורם בתוך השרת שלכם אינו יכול לשנות מצב זה, כיוון שהחלטות התזמון מתקבלות בשכבה שמתחת לכם, בשרת המארח (host).

נתון זה נובע ישירות מ-אופן השיתוף של מכונה פיזית אחת בין אורחים רבים ב-VPS. הגורם השכיח לכך הוא "שכן": אורח אחר על אותו ה-node נמצא בעומס גבוה, ולכן ה-host מחלק את הליבות ביניכם. קיימת סיבה שנייה שלעיתים קרובות מתפספסת. ספקי שירות רבים מגבילים vCPU משותף לשבריר מליבה פיזית, ובמספר סוגי hypervisor, הגבלה נאכפת זו נספרת כ-steal בתוך האורח. לפיכך, קריאת st גבוהה מעידה על כך שהליבה לא הוקצתה לכם, אך היא לא תמיד מצביעה על הגורם שלקח אותה.

מקור הנתונים של זמן ה-steal

ה-kernel שלכם אינו יכול למדוד steal בעצמו, כיוון שאין לו נראות אל ה-host. ה-hypervisor הוא זה שמדווח לו על כך. ב-KVM, ה-host כותב מונה לכל vCPU לתוך דף זיכרון המשותף עם ה-guest, וה-guest מסכם אותו כאשר ה-kernel נבנה עם CONFIG_PARAVIRT_TIME_ACCOUNTING, הגדרה שקיימת בכל kernel של הפצות לינוקס. Xen מדווח על אותו נתון דרך אזור ה-runstate שלו. הסכום הכולל מגיע ל-userspace במיקום אחד בלבד:

head -1 /proc/stat

השורה cpu מכילה עשרה מונים, ביחידות של USER_HZ מאז ה-boot, לפי הסדר הבא: user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice. ה-steal הוא הערך השמיני אחרי התווית. כל כלי המפורט מטה, כגון vmstat, top, mpstat וכל Prometheus exporter, קורא את אותו שדה וממיר שתי דגימות לאחוזים.

לכך יש השלכה אחת שחשובה יותר מכל השאר. אם ה-hypervisor אינו מייצא את המונה, השדה יישאר על אפס לנצח, וכל כלי המבוסס עליו ידווח על 0.0 תקין גם כאשר ה-host עמוס מדי. KVM ו-Xen מייצאים את הנתון הזה. בפלטפורמות אחרות, ביניהן VMware ו-Hyper-V, השאלה אם תראו steal תלויה במה שה-host חושף ובמה שה-guest kernel תומך בו; לכן, ערך אפס כשלעצמו אינו מוכיח דבר. בדקו את הפלטפורמה לפני שאתם מסתמכים על ערך אפס:

systemd-detect-virt

הפקודה מדפיסה את שם הפלטפורמה, כגון kvm, xen, vmware או microsoft, ו-none על גבי bare metal. בתוך container, הפקודה תדווח על ה-runtime במקום זאת, כגון lxc, docker או podman, מה שמעיד על ה-container ולא על המכונה שמתחתיו. ב-kvm, ערך אפס הוא עדות ממשית לכך שה-host מתנהל כראוי. בפלטפורמה שאינה מאכלסת את השדה הזה, ערך אפס אינו מהווה עדות כלל, ויש להעריך את העומס על ידי תזמון ביצוע של עבודה ממשית.

כיצד בודקים זמן steal של מעבד ב-VPS?

vmstat מגיע מחבילת procps. הוא קיים כמעט בכל תמונת VPS של Ubuntu או Debian, אך חסר בחלק מתמונות מכולות (container) מינימליות, לכן יש להתקין אותו לפני השימוש.

sudo apt-get update
sudo apt-get install -y procps
vmstat --version
vmstat 1 5

vmstat --version מדפיס שורה כגון vmstat from procps-ng 4.0.4. אם הפקודה מדפיסה זאת, הכלי מותקן ואתה קורא מוני ליבה אמיתיים. vmstat 1 5 מדפיס לאחר מכן חמישה דוחות: הראשון הוא הממוצע מאז האתחול, וארבעת הבאים הם דגימות של שנייה אחת כל אחת.

procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 1  0      0 3216484  98304 1284360    0    0     4    18   62  110  3  1 96  0  0  0
 2  0      0 3216232  98304 1284360    0    0     0     0  248  431  6  2 84  0  8  0

מצא את עמודת st בבלוק cpu מימין. גרסאות עדכניות של procps-ng מדפיסות עמודת gu אחריה עבור זמן אורח KVM, לכן st נמצאת כעת שנייה מימין ולא אחרונה. קרא את העמודה לפי שם הכותרת שלה, כיוון שמיקומה השתנה בין גרסאות.

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

top מדווח על אותו מספר בשורת הסיכום %Cpu(s) שלו, בשדה המסומן st:

%Cpu(s):  6.2 us,  2.1 sy,  0.0 ni, 83.9 id,  0.0 wa,  0.0 hi,  0.3 si,  7.5 st

עבור פירוט לפי ליבה, הוסף את sysstat:

sudo apt-get install -y sysstat
mpstat -P ALL 1 5

mpstat מדפיס שורה אחת לכל מעבד עם עמודת %steal, המראה האם כל vCPU מושפע או רק אחד. עבור ההיסטוריה שכרטיס תמיכה דורש, שמור את הדגימות במקום לקרוא אותן מהמסך:

date -u | tee -a ~/steal.log
mpstat -P ALL 1 5 | tee -a ~/steal.log

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

מה משמעות מספרי ה-steal?

  • ערך 0.0 יציב. המערכת תקינה, או שהפלטפורמה אינה מדווחת על steal כלל. ודאו זאת באמצעות systemd-detect-virt לפני שתסיקו מסקנות.
  • קפיצות של אחוזים בודדים הנמשכות שניות. תקין בכל שרת משותף (shared node). ייתכן ששכן לשרת התחיל תהליך build או שהמארח מריץ גיבויים.
  • 1 עד 5 אחוזים באופן קבוע בתוכנית משותפת. צפוי. המחיר משקף שימוש ב-CPU משותף.
  • 5 עד 10 אחוזים באופן קבוע. האטה שניתן למדוד. התחילו לתעד נתונים והשוו את אותן השעות לאורך כמה ימים.
  • מעל 10 אחוזים למשך שעות ברצף. השרת עמוס מדי עבור עומס העבודה שלכם, או שהגבלת ה-CPU בתוכנית שלכם נאכפת, וספקי שירות מסוימים מדווחים על הגבלה זו כ-steal. זהו השלב המצדיק פתיחת קריאת תמיכה או מעבר לספק אחר.

התייחסו לטווחים אלו כאל מדריך קריאה ולא כמפרט טכני, שכן אף ספק אינו מתחייב על רמת steal בתוכנית משותפת. שקללו את הנתונים מול מה שאתם מריצים. משימת batch לילית יכולה לספוג 15 אחוז steal מבלי שאיש יבחין בכך. שירות הרגיש לזמן תגובה יציג זאת ב-p99 הרבה לפני שהממוצע ייראה מדאיג, וזו הסיבה ש-עומסי עבודה הרגישים לזמן תגובה, כגון בוטים למסחר צריכים לרוץ על ליבות ייעודיות.

כמה עולה לכם זמן גניבה (steal time)?

החשבון פשוט. אם חלק יחסי s מזמן ה-CPU שלכם נלקח, משימה הדורשת כמות קבועה של זמן CPU תיקח פי 1 / (1 - s) יותר זמן שעון. עבור משימה הדורשת 60 שניות של CPU:

תרשיםWall clock time for a job needing 60 seconds of CPU
הנתונים שמאחורי התרשים
[
  {
    "steal_percent": 0,
    "wall_clock_seconds": "60.0"
  },
  {
    "steal_percent": 3,
    "wall_clock_seconds": "61.9"
  },
  {
    "steal_percent": 8,
    "wall_clock_seconds": "65.2"
  },
  {
    "steal_percent": 15,
    "wall_clock_seconds": "70.6"
  },
  {
    "steal_percent": 25,
    "wall_clock_seconds": "80.0"
  },
  {
    "steal_percent": 40,
    "wall_clock_seconds": "100.0"
  }
]

בשיעור של 3 אחוזים, קריאה רגילה בתוכנית שיתופית, אותה משימה תיקח 61.9 שניות במקום 60.0. איש אינו פותח כרטיס תמיכה בגלל זה. בשיעור של 8 אחוזים מדובר ב-65.2 שניות. בשיעור של 40 אחוזים, אותה משימה דורשת 100.0 שניות, ותור שהיה מתרוקן בעבר מתחיל במקום זאת לגדול.

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

האם מדובר ב-steal, או במשהו אחר?

קל לבלבל בין steal לבין תסמינים אחרים. יש לקרוא את המונים יחד, באותה שורה של vmstat.

  • st גבוה בעוד r ו-us נשארים נמוכים: המארח (host) אינו מקצה לכם את הליבה. זהו steal.
  • r גבוה משמעותית ממספר ה-vCPU שלכם, עם us גבוה ו-st קרוב לאפס: אתם מריצים עומס עבודה גדול יותר ממה שהמעבדים שלכם מסוגלים לעבד. השוו את r לפלט של nproc. זוהי מנוי-יתר (oversubscription) שלכם, ולא שכן בשרת.
  • wa גבוה עם st קרוב לאפס: משימות חסומות בהמתנה לאחסון, וזו בעיה שונה הדורשת פתרון אחר.
  • Load average גבוה בעוד st ו-us שניהם נמוכים: מדד העומס סופר גם משימות במצב uninterruptible, לכן מצב זה מעיד בדרך כלל על התקן תקוע או על mount רשת שנתלה, ולא על בעיית CPU.

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

מדוע מכולה מדווחת על זמן steal אפס

ערך ה-steal הוא מאפיין של מכונה וירטואלית, לא של מכולה הרצה בתוכה. מכולת Docker על ה-VPS שלכם חולקת את ה-/proc של המארח, לכן ערך ה-st שנקרא מתוכה הוא ה-steal של ה-VPS עצמו, וזהו המידע הרצוי. וירטואליזציה מבוססת מכולות שנמכרת כ-VPS מתנהגת אחרת. כאשר lxcfs פעיל, ה-/proc/stat בתוך המכולה מחושב מתוך רישומי ה-cgroup, וערך ה-steal הוא אפס מעצם ההגדרה. מערכת ניטור שדוגמת נתונים רק מתוך המכולה עלולה להציג ערך אפס שטוח ורגוע, בזמן שהמכונה הפיזית שמתחתיה סובלת ממחסור במשאבים.

בתוך מכולה, המונה שנושא משמעות דומה הוא ה-CPU quota throttling. ב-cgroup v2:

cat /sys/fs/cgroup/cpu.stat

הקובץ nr_throttled סופר את תקופות האכיפה שבהן הקבוצה הגיעה למכסת ה-CPU שלה, והקובץ throttled_usec מסכם את הזמן שבו היא הייתה מוקפאת. ערך עולה ב-nr_throttled מעיד על כך שהתהליך שלכם היה מוכן להרצה אך לא רץ בפועל – אותה חוויה כמו steal, אך כזו שנגרמה ממגבלה שהגדרתם בעצמכם. בדקו את המגבלות שלכם לפני שאתם מאשימים את המארח, במיוחד אם אתם מריצים שירותים ב-Docker על גבי VPS עם מגבלות CPU בקובץ ה-compose. וירטואליזציה מדורגת מוסיפה מקום נוסף שבו זמן יכול להיעלם, כיוון שמכונה וירטואלית בתוך ה-VPS שלכם משלמת גם את ה-steal שלכם וגם את השיהוי של התזמון שלה. קחו זאת בחשבון אם אתם מריצים וירטואליזציה מקוננת על גבי VPS.

מה לעשות במקרה של steal מתמשך

שום הגדרה בתוך ה-guest לא תתקן steal, כיוון שה-scheduler שמקבל את ההחלטות רץ מחוץ ל-guest. גם שדרוג ה-kernel לא ישנה זאת: ה-cache aware scheduling שנוסף ב-Linux kernel 7.2 מארגן מחדש את המשימות שלכם על פני ה-cores שקיבלתם בפועל, אך אינו יכול להחזיר מחזורי מעבד ששכן כבר ניצל. ישנם ארבעה צעדים מעשיים.

אספו ראיות תחילה. תעדו חותמות זמן ב-UTC, את משך כל אירוע, את תדירות החזרה שלו, והאם mpstat מציג vCPU אחד שנפגע או את כולם. שבוע של דגימות מתועדות שווה יותר מצילום מסך.

פתחו כרטיס תמיכה עם הנתונים הללו. שאלו שתי שאלות ישירות: האם ה-node עמוס מדי (oversubscribed) במהלך חלונות זמן אלו, והאם ניתן להעביר את ה-instance שלי. הדביקו את הפלט של vmstat ואת הזמנים המדויקים. ספקי שירות פועלים על סמך חלון זמן שניתן לשחזור, וכרטיס שרק מציין שהשרת איטי יקבל תשובה שמבקשת אחד כזה. כמות העבודה שניתן להעביר לספק היא אחד ההבדלים המעשיים בין VPS מנוהל לבין VPS לא מנוהל.

בקשו הגירה (migration). העברת guest ל-node פחות עמוס היא עבודה שגרתית עבור ספק, ובדרך כלל מדובר ב-reboot קצר. זהו הפתרון שאינו עולה דבר, והוא פותר את המקרה הנפוץ שבו במקרה נמצאים על אותו node כמה שכנים כבדים בו-זמנית.

קנו את הפתרון לבעיית ה-contention. תוכנית vCPU ייעודית משריינת קיבולת CPU עבור ה-instance שלכם, core מלא או hardware thread מלא בהתאם לספק, כך שהשכנים מפסיקים לקחת את המחזורים שלכם והמונה נשאר על אפס או קרוב מאוד אליו. פעולות התחזוקה של ה-hypervisor עצמו עדיין עשויות להשאיר שארית קטנה. זה עולה יותר בכל חודש, וזו התשובה הכנה עבור עומס עבודה שאינו יכול לספוג את התנודתיות. אם זה עדיין לא מספיק, או שאתם רוצים גם את רוחב הפס של ה-memory לעצמכם, הצעד הבא הוא שרת ייעודי במקום VPS.

בזמן שאתם ממתינים לכל אחד מאלו, צמצמו את הנזק שנגרם מה-steal. הריצו פחות worker threads ממספר ה-vCPUs שיש לכם, כיוון ש-threads שלא מצליחים לקבל core רק מוסיפים context switches. העבירו עבודות batch לשעות שבהן ה-node שקט, דבר שהלוגים שלכם כעת מראים לכם. לאחר מכן מדדו שוב עם אותה פקודה באותן שעות, כדי שתוכלו לומר האם השינוי עבד במקום לנחש.

FAQ

מהו זמן steal תקין ב־CPU בשרת VPS?

בתוכנית שיתופית, קפיצות קצרות וערך מתמשך של פחות מ־5 אחוזים הם תקינים, כיוון ש־CPU שיתופי משמעו שהמארח מחלק ליבות פיזיות בין האורחים. ערכים דו-ספרתיים מתמשכים לאורך שעות אינם תקינים ומצדיקים פתיחת כרטיס תמיכה. בתוכנית עם vCPU ייעודי, הערך הצפוי הוא 0 או קרוב מאוד ל־0.0, שכן תחזוקת ה־hypervisor עדיין עשויה לצרוך נתח קטן; לכן, זמן steal מתמשך מעבר לכך הוא תקלה שיש לדווח עליה. יש להעריך את הנתון בהתאם לעומס העבודה שלכם: משימת batch לילית יכולה לספוג זמן steal ש־API הרגיש לזמן תגובה (latency) לא יכול להרשות לעצמו.

האם שדרוג לתוכנית גדולה יותר יפתור זמן steal גבוה?

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

מדוע ה־VPS שלי מציג 0 זמן steal כשהוא בבירור איטי?

יש לכך שתי סיבות נפוצות. ייתכן שה־hypervisor כלל לא מייצא את המונה, דבר שקורה בפלטפורמות מסוימות בהתאם למארח ולגרעין (kernel) של האורח, ולכן השדה נשאר על אפס ללא קשר לפעילות המארח. הריצו את systemd-detect-virt כדי לראות באיזו פלטפורמה אתם נמצאים. לחלופין, צוואר הבקבוק נמצא במקום אחר: בדקו את wa עבור המתנה לאחסון, השוו את r ל-nproc כדי לבדוק עומס עצמי, וקראו את /sys/fs/cgroup/cpu.stat בתוך מכולות (containers) כדי לבדוק הגבלות מכסה (quota throttling).

האם אני יכול להפחית זמן steal מתוך השרת שלי?

אינכם יכולים לשנות את ניהול התזמון של המארח מתוך האורח. אתם יכולים רק להפחית את הנזק שזה גורם. הריצו פחות תהליכי עבודה (worker threads) ממספר ה־vCPUs שיש לכם, כך שפחות עבודה תמתין בתור לליבה שאינה מתפנה. העבירו משימות batch לשעות שבהן הצומת שקט יותר. בצעו caching לתוצאות כדי שפחות בקשות ידרשו CPU מלכתחילה. השינויים שמבטלים בפועל את ה־steal, כמו הגירה לצומת אחר או ליבות ייעודיות, נמצאים בצד של ספק השירות.

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