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

איך להגביל זיכרון ומעבד לתהליך באמצעות systemd

תהליך מוגבל עדיין עלול לתקוע VPS. הגדירו MemoryHigh, MemoryMax, CPUQuota ו־TasksMax ביחידת systemd, ובדקו את הודעת OOM kill לאחר מכן.

הגבלת זיכרון ומעבד של תהליך באמצעות קובץ drop-in של systemd

מגבילים את הזיכרון והמעבד של תהליך ב־Linux VPS על ידי הוספת כמה שורות ליחידה שמפעילה את התהליך. MemoryMax= הוא תקרת הזיכרון הקשיחה. CPUQuota= הוא תקרת זמן המעבד. שתי ההגבלות נאכפות באמצעות cgroup v2 (קבוצות בקרה, גרסה 2), תכונת ליבה ש־systemd כבר משתמש בה כדי לעקוב אחר כל שירות בשרת.

sudo systemctl edit myapp.service

פעולה זו פותחת קובץ drop-in ובו הוראות בהערות. הוסיפו את השורות הבאות מעליהן:

[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128
sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMax

systemctl show חייב להציג שוב את המספרים שלכם ביחידות שבהן משתמשת הליבה: MemoryMax=805306368 ו־CPUQuotaPerSecUSec=800ms. אם הפלט הוא MemoryMax=infinity, קובץ ה־drop-in לא נטען. בדקו שהקובץ נשמר ב־/etc/systemd/system/myapp.service.d/override.conf, ושהוא מתחיל בכותרת [Service], משום ששורת הגדרה ללא מקטע שקודם לה גורמת ל־systemd לרשום את Assignment outside of section. Ignoring. ולהפעיל את השירות ללא הגבלות כלל.

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

מדוע תהליך שיצא משליטה מקפיא VPS בלי למלא את כולו

תהליך שמגיע לתקרת זיכרון קשיחה מסתיים בתוך כשנייה, והשירות מופעל מחדש. זה המצב הטוב. המצב הרע הוא מצב שבו שום דבר אינו מסתיים: השרת עונה ל־ping, ‏SSH מקבל את החיבור, אך שורת הפקודה אינה מופיעה. המכונה פעילה ועסוקה, אך אף אחת מהפעולות האלה אינה מועילה.

כך המנגנון פועל, והוא אינו מובן מאליו. כאשר הזיכרון הפנוי הולך ואוזל, ה־kernel מפנה עמודים במקום להקצות עמודים חדשים. העמודים הזולים ביותר לפינוי הם עמודים שמגובים בקבצים, ו־page cache מחזיק את קוד ההרצה של כל מה שפועל. לכן ה־kernel מפנה את עמודי הקוד של sshd, וההוראה הבאה ש־sshd מריץ היא page fault, שצריכה לקרוא את הבתים האלה בחזרה מהאחסון. בסופו של דבר, כל תהליך ממתין לדיסק במקום לפעול. אותם עמודים יוצאים וחוזרים בלולאה, ותופעה זו נקראת thrashing.

שני דברים מחמירים את המצב ב־VPS יותר מאשר במחשב נייד. האחסון מחובר לעיתים קרובות דרך הרשת או משותף, ולכן כל תקלה כזו עולה יותר אלפיות שנייה מאשר בהתקן NVMe מקומי. בנוסף, ה־kernel אינו מודד זמן אלא כשל: כל עוד תהליך הפינוי ממשיך להחזיר עמוד, גם אם באיטיות, ה־kernel סבור שהוא מתקדם ואינו מפעיל את מחסל התהליכים בעת מחסור בזיכרון (OOM). שרת יכול להישאר במצב הזה דקות רבות לפני שתהליך כלשהו יופסק.

אפשר לעקוב אחר התופעה בזמן שהיא מתרחשת. ה־kernel מייצא pressure stall information (PSI) ב־Linux 4.20 ואילך:

cat /proc/pressure/memory
cat /proc/pressure/io
some avg10=63.72 avg60=41.02 avg300=12.33 total=13729481
full avg10=48.15 avg60=30.44 avg300=8.90 total=9114233

השורה full היא החשובה. full avg10=48.15 פירושו שב־48% מעשר השניות האחרונות, כל המשימות שאינן במצב idle בשרת היו תקועות בגלל זיכרון באותו זמן, ולכן אף אחת מהפעולות שלכם לא התקדמה. בשרת תקין הערך של full קרוב לאפס. מעל 10 המערכת מרגישה איטית למשתמש, ו־40 ומעלה הוא המצב שאנשים מתארים כקפוא.

זו גם הסיבה שמגבלה בפני עצמה אינה הבטחה. יחידה שמוחזקת תחת MemoryHigh= מואטת במקום להסתיים, ולכן היא נשארת פעילה ואיטית; שום דבר אינו מפעיל אותה מחדש, משום שמנקודת המבט של systemd היא מעולם לא נכשלה. יחידה מוגבלת שעדיין מורשית להשתמש ב־swap יוצרת קריאות וכתיבות שנזקפות ליחידה, אך מטופלות באמצעות התקן משותף אחד. לכן היא עלולה להעלות את /proc/pressure/io עבור כל שירות אחר בשרת. מגבלות קובעות מי יישא בעלות המחסור, אך אינן מסוגלות ליצור קיבולת.

וודאו שה-VPS שלכם מריץ cgroup v2

stat -fc %T /sys/fs/cgroup

cgroup2fs הוא ההיררכיה המאוחדת, אשר הגדרות הזיכרון להלן דורשות. tmpfs מציין שהשרת עלה עם מבנה ה-v1 הישן, שבו MemoryHigh= ו-MemorySwapMax= אינם נתמכים והתנהגות ה-OOM ברמת היחידה שונה, אם כי CPUQuota= עדיין עובד שם דרך קובץ ה-cpu.cfs_quota_us המיושן. הפצות Ubuntu 22.04 ומעלה, ו-Debian 11 ומעלה, משתמשות ב-v2 כברירת מחדל. תמונת מערכת ישנה לא תעשה זאת, ובגרסאות systemd 255 ומטה גם לא קרנל שעלה עם systemd.unified_cgroup_hierarchy=0. גרסאות systemd 256 ו-257 מסרבות לעלות תחת v1 אלא אם כן SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 מופיע גם הוא בשורת הפקודה של הקרנל. גרסה systemd 258 הסירה את התמיכה ב-cgroup v1 ומעגנת תמיד את ההיררכיה המאוחדת בעת העלייה, כך שבהפצות הכוללות אותה, אף אחד מהארגומנטים לא יחזיר את v1.

ב-cgroup v2, ה-systemd מפעיל חשבונאות זיכרון (memory accounting) עבור כל יחידה כברירת מחדל, לכן הנתונים כבר קיימים:

systemd-cgtop -m

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

MemoryHigh מבצע ויסות. MemoryMax מסיים תהליכים.

ההבדל בין שתי הגדרות הזיכרון קובע כיצד ייראה כשל.

  • MemoryHigh= היא תקרת שימוש רכה. מעליה ה־kernel מפנה זיכרון באגרסיביות מאותו cgroup ומאט בכוונה את הקצאות הזיכרון שלו. השימוש עדיין יכול לעבור את הערך, ושום תהליך אינו מסיים.
  • MemoryMax= היא תקרת שימוש קשיחה. כאשר אי־אפשר לספק הקצאה במסגרת התקרה, מנגנון OOM killer מופעל בתוך אותו cgroup ומסיים אחד מהתהליכים של אותה יחידה.

החלק השני הוא הסיבה העיקרית להגדיר MemoryMax= לכל דבר שאינכם נותנים בו אמון מלא. ללא תקרה, מחסור בזיכרון הופך לבעיה של השרת כולו, ומנגנון ה־OOM הגלובלי בוחר את הקורבן לפי oom_score, כלומר בדרך כלל את התהליך הגדול ביותר. התהליך הגדול ביותר הוא בדרך כלל מסד הנתונים, ולא הסקריפט שגרם לדליפה. עם תקרה, הסיום מתרחש בתוך היחידה שגרמה לבעיה.

הגדירו את שתיהן, כאשר MemoryHigh= נמוכה בכ־20 עד 30 אחוזים מ־MemoryMax=. הפער הוא אזור אזהרה: דליפה איטית חוצה את High ומתבטאת בשירות שהפך לאיטי, ואילו קפיצה פתאומית חוצה ישירות את Max ומביאה לסיום התהליך.

ערכי אחוזים מחושבים לפי הזיכרון הפיזי המותקן. לכן MemoryMax=25% בתוכנית של 4 GB הם 1 GB, והם יישארו רבע מהשרת גם לאחר שינוי גודל התוכנית. MemorySwapMax=0 מונעת לחלוטין מאותה יחידה להשתמש ב־swap, ולכן כשהיא מגיעה ל־MemoryMax=, הסיום מתרחש במהירות ולא לאחר הידרדרות ממושכת בגלל שימוש ב־swap. מתחת לנקודה זו MemoryHigh= עדיין יכולה לבצע ויסות, וחריגה מהגבול העליון לעולם אינה מפעילה את OOM killer. לכן יחידה שנשארת בין שני הגבולות תישאר איטית במקום להסתיים.

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

לצד תקרת שימוש יש להגדיר מדיניות אתחול מחדש. אחרת הסיום רק ישאיר את השירות במצב stopped.

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Restart=on-failure
RestartSec=5s

StartLimit* שייך ל־[Unit], ו־Restart= שייך ל־[Service]. אם תציבו אחד מהם בסעיף הלא נכון, systemd יתעלם ממנו. חמישה אתחולים מחדש בתוך חמש דקות מעידים על דליפה ולא על תקלה רגעית. לאחר מכן systemd מוותר ומשאיר את היחידה במצב failed. זהו המצב שתרצו למצוא בהמשך, במקום לולאת קריסות שמסתירה את הבעיה.

הגבלת CPU באמצעות CPUQuota, או חלוקת זמן באמצעות CPUWeight

CPUQuota= מקצה לתהליך אחוז מזמן המעבד הזמין ב־CPU אחד. CPUQuota=50% שווה למחצית מליבה אחת. CPUQuota=200% שקול לשתי ליבות, והיחידה יכולה לפזר את העומס ביניהן על פני מספר threads כרצונה. בתוכנית עם 2 vCPU, CPUQuota=200% מייצג את מלוא משאבי המכונה.

CPUWeight= הוא ברירת המחדל המתאימה יותר לרוב השירותים. זהו חלק יחסי בטווח שבין 1 ל־10000, וברירת המחדל של ה־kernel היא 100. ההגדרה משפיעה רק כאשר יש תחרות על המשאב: עבודת גיבוי עם CPUWeight=20 תפנה מקום ל־web server עם 100 תחת עומס, ועדיין תשתמש במלוא המכונה כאשר היא אינה עסוקה. מכסה קשיחה מבזבזת את הקיבולת הפנויה הזאת.

חשוב להגדיר ציפיות נכונות לגבי התועלת מהגבלת CPU. תהליך שתלוי ב־CPU כמעט לעולם אינו מקפיא את Linux, משום שה־scheduler ממשיך להקצות זמן לכל התהליכים. הזיכרון הוא הגורם שבדרך כלל משבית מכונה. השתמשו ב־CPUQuota= כאשר נדרשת תקרה צפויה, למשל ב־build או ב־agent שאחרת היה פועל בעומס מלא במשך שעה. התאמת המשאבים לעומס עבודה כזה היא שאלה נפרדת, והיא מוסברת ב־כמה RAM ו־CPU דרושים ל־VPS שמריץ coding agent.

אם ה־CPU נראה עסוק אף שאף אחד מהתהליכים שלכם אינו עושה עבודה רבה, ייתכן שהגורם נמצא בצד השני של ה־hypervisor. זהו זמן גניבת CPU משכן רועש, ושום quota שתגדירו לא ישנה זאת.

TasksMax מונע לולאת fork

TasksMax= הוא מספר התהליכים וה־threads שיחידה יכולה להחזיק. גם threads נספרים, לכן שירות Java או Go זקוק למרווח גדול יותר מכפי שרשימת התהליכים מרמזת. זו ההגנה הזולה ביותר מפני סקריפט שמבצע fork בלולאה, משום שה־fork נכשל בתוך היחידה במקום שהשרת יאזל ממזהי תהליכים.

TasksMax=128

כאשר יחידה מגיעה למגבלה, ה־kernel רושם שורה שמציינת את ה־cgroup:

cgroup: fork rejected by pids controller in /system.slice/myapp.service

התוכנית עצמה מדווחת בדרך כלל על fork: retry: Resource temporarily unavailable. בדקו מה מנהל השירותים מחיל כברירת מחדל באמצעות systemctl show -p DefaultTasksMax.

הגבלת משימה חד־פעמית באמצעות systemd-run

אין צורך בקובץ יחידה כדי להשתמש באפשרויות האלה. systemd-run יוצר יחידה זמנית עבור פקודה יחידה.

sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh

--scope מריץ את הפקודה במסוף שלכם, לאחר הצגת Running scope as unit: run-r7c1a....scope. הפלט נשאר על המסך, והמגבלות נעלמות כשהפקודה מסתיימת. כל מאפיין מתוך systemd.resource-control פועל לאחר -p.

עבור משימה ממושכת, השמיטו את --scope והקצו לה שם. לאחר מכן היא פועלת ברקע כשירות זמני, והרישומים שלה נכתבים ל־journal:

sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -f

אותן אפשרויות פועלות עם --user גם כאשר אינכם root, אך למנהל המשתמש שלכם יש רק את הבקרים שהוקצו לו, ולכן ייתכן שמאפיין יידחה. במקרה כזה, הפעילו אותו באמצעות sudo. כאשר משימה מקבלת מקום קבוע, ההגדרות מועברות ללא שינוי ליחידה אמיתית: ראו הרצת סקריפט כשירות וכתזמון של systemd.

שאלת ה־swap, בתשובה כנה

Swap משנה את אופן הכשל במקום למנוע אותו.

ללא swap, דליפת זיכרון מגיעה לתקרה ותהליך כלשהו קורס בתוך שניות. ההשבתה רועשת, קצרה וקל להבין אותה ב־journal לאחר מכן. עם swap, ה־kernel כותב לדיסק דפים אנונימיים שלא היו בשימוש לאחרונה, וכך קונה זמן. אם התהליך עמד להתייצב, swap מציל את המצב. אם מדובר בתהליך שצורך משאבים ללא הפסקה, swap הופך השבתה של חמש שניות לקיפאון של עשרים דקות. הקיפאון גרוע יותר, משום שתהליך שקרס עדיין משאיר לכם shell עובד, ואילו מערכת שנמצאת ב־thrashing אינה עושה זאת.

swapon --show
free -h

פתרון מעשי ל־VPS קטן: השאירו קובץ swap בגודל מתון עבור דפים שמוקצים פעם אחת ולא נגישים שוב, והגדירו את MemorySwapMax=0 ביחידות שאתם מוכנים לאבד. השירותים החשובים שומרים על ה־swap שלהם. השירותים הבלתי צפויים נתקלים במהירות במגבלה, ומדיניות האתחול מחדש שלצד המגבלה מחזירה אותם לפעולה.

הפחתת vm.swappiness היא מנוף חלש, וכדאי להבין מדוע. היא רק משנה את האיזון בין פינוי מטמון דפים לבין העברת דפים אנונימיים ל־swap, ושתי הפעולות יחייבו קריאת דיסק מאוחר יותר. היא משנה אילו דפים יגרמו ל־thrashing, אך לא אם המערכת תיכנס ל־thrashing.

דמון OOM מוקדם מסיים תהליכים לפני ההיתקעות

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

earlyoom בודק זיכרון זמין ו־swap פנוי עד עשר פעמים בשנייה, ומסיים את התהליך עם הערך הגבוה ביותר של oom_score רק כאשר שניהם יורדים מתחת לספים שלהם. במכונה ללא swap, סף הזיכרון לבדו קובע.

sudo apt install earlyoom
systemctl status earlyoom

החבילה של Debian ושל Ubuntu מפעילה את השירות במהלך ההתקנה. האפשרויות שלו נמצאות ב־/etc/default/earlyoom:

EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"

-m PERCENT מגדיר את המינימום של הזיכרון הזמין, ו־-s PERCENT את המינימום של ה־swap הפנוי; ברירת המחדל של שניהם היא 10 אחוזים. המספר השני בכל זוג הוא נקודת ההפעלה של SIGKILL: ‏earlyoom שולח SIGTERM כאשר גם הזיכרון וגם ה־swap יורדים מתחת לערכים הראשונים שלהם, ולאחר מכן שולח SIGKILL כאשר שניהם יורדים מתחת לערכים השניים. ברירת המחדל של הערכים השניים היא מחצית מהערכים הראשונים. היחידה מעבירה את המשתנה הזה ל־earlyoom באמצעות $EARLYOOM_ARGS, ולכן systemd מפצל אותו לארגומנטים לפי רווחים. מותר להקיף במרכאות את התבניות --avoid ו־--prefer: ‏systemd מסיר את המרכאות הכפולות החיצוניות בעת קריאת הקובץ, ולאחר מכן מכבד ומסיר את המרכאות היחידות הפנימיות כשהוא מפצל את הערך, ולכן --avoid '^(sshd|systemd)$' פועל באותו אופן כמו הצורה ללא מרכאות שלמעלה. תבנית שמכילה רווח זקוקה למרכאות יחידות אלה; אחרת היא מתפצלת לשני ארגומנטים. החילו שינוי באמצעות sudo systemctl restart earlyoom, וקראו את journalctl -u earlyoom כדי לראות איזה תהליך הוא סיים וכמה זיכרון התהליך החזיק.

systemd-oomd היא האפשרות האחרת. דף ה־manual שלה מתאר אותה כ"שירות מערכת שמשתמש ב־cgroups-v2 ובמידע PSI על השהיית מערכת כדי לנטר ולנקוט פעולה מתקנת לפני שמתרחש OOM במרחב הליבה". היא פועלת על קבוצות cgroup שלמות ולא על תהליכים יחידים, ולכן היא מסיימת יחידה ולא תהליך-בן מיותר. יחידות מצטרפות באופן מפורש באמצעות ManagedOOMMemoryPressure=kill או ManagedOOMSwap=kill, והספים נמצאים ב־/etc/systemd/oomd.conf.

systemctl status systemd-oomd
oomctl

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

איזו יחידה הייתה אחראית?

התחילו ב־kernel, משום שהוא מתעד כל תהליך שהוא מסיים.

journalctl -k --grep "Killed process" --since "2 hours ago"

הריגה של תהליך על ידי מנגנון OOM הגלובלי נראית כך:

Out of memory: Killed process 4127 (node) total-vm:2731084kB, anon-rss:1874232kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:4212kB oom_score_adj:0

anon-rss הוא הזיכרון האנונימי, כגון heap, שהתהליך החזיק ב־RAM כשמת, וכאן מדובר בכ־1.8 GB. מיפויי קבצים תושביים וזיכרון משותף נספרים בנפרד, כ־file-rss וכ־shmem-rss. קראו את השם שבסוגריים בזהירות. זהו התהליך שה־kernel בחר לסיים, וה־kernel בוחר בתהליך הגדול ביותר. זה לא תמיד התהליך שגרם למחסור.

הריגה עקב מגבלת cgroup מקבלת קידומת אחרת, והדוח שמודפס לפניה מציין את ה־cgroup שהגיע לתקרה שלו:

Memory cgroup out of memory: Killed process 8811 (python3) total-vm:1044320kB, anon-rss:769112kB, file-rss:0kB, shmem-rss:0kB, UID:998 pgtables:1720kB oom_score_adj:0

הקידומת הזו מספקת את רוב האבחון. Memory cgroup out of memory פירושו שיחידה אחת הגיעה ל־MemoryMax= שהקציתם לה, ושאר המערכת הייתה תקינה. Out of memory ללא תוספת פירושו שלמכונה כולה אזל הזיכרון, ולכן המגבלות שלכם חסרות או נדיבות מדי במצטבר.

לאחר מכן שאלו את systemd מה הוא ראה:

systemctl status myapp.service
journalctl -u myapp.service -n 50
myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Main process exited, code=killed, status=9/KILL
myapp.service: Failed with result 'oom-kill'.

systemctl status מציין את אותו הדבר בשורה אחת, בתור Active: failed (Result: oom-kill).

מוני ה־cgroup הם המקור השלישי, והיחיד שמתעד throttling, שאינו יוצר שורת log כלל:

cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peak
low 0
high 4213
max 118
oom 12
oom_kill 12

high סופר כמה פעמים היחידה חרגה מ־MemoryHigh= והופעלה עליה הגבלת קצב. max סופר כמה פעמים היא הגיעה לתקרה הקשיחה, ו־oom_kill סופר תהליכים שבפועל הסתיימו. ערך high גדול יחד עם oom_kill 0 הוא המקרה השקט שתואר קודם: מאז יצירת ה־cgroup שלו היחידה הוגבלה שוב ושוב, בלי אפילו הריגה אחת, ולכן systemd לא תיעד כשל. המונה רק גדל, לכן קראו אותו פעמיים בהפרש של דקה: high שעדיין עולה פירושו שהגבלת הקצב מתרחשת עכשיו. memory.peak (ב־Linux 5.19 ומעלה) מכיל את השימוש המרבי שאליו הגיע ה־cgroup, וזהו המספר שלפיו יש לקבוע את גודל MemoryMax=. שני הקבצים מתאפסים כשהיחידה מופעלת מחדש, משום ש־systemd יוצר את ה־cgroup מחדש.

יש תנאי מוקדם אחד לכל זה. אם /var/log/journal אינו קיים, ה־journal נשמר ב־RAM, וכל השורות נעלמות לאחר האתחול שהיה דרוש כדי לשחזר את המערכת.

sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-boots

journalctl --list-boots שמציג יותר מה־boot הנוכחי פירושו שההיסטוריה נשמרת כעת, ולכן journalctl -k -b -1 יכול להציג את הודעות ה־kernel מה־boot שהסתיים בכשל.

נקודת פתיחה עבור VPS קטן

בתוכנית עם 2 GB, השאירו 300 עד 400 MB עבור הליבה ו־page cache, ואל תאפשרו לסכומי המגבלות להגיע ל־2 GB המלאים, משום שכל יחידה עלולה להגיע לשיא באותו רגע. הקצו לשירות החשוב ביותר את החלק הגדול ביותר, ולאחר מכן הגבילו את כל השירותים המשניים שסביבו.

[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5s

כדאי להוסיף הגדרה נוספת כדי לשמור על דרך גישה לשרת. OOMScoreAdjust=-500 בקובץ drop-in עבור ssh.service מפחית משמעותית את הסבירות ש־OOM killer הגלובלי יבחר ב־SSH daemon כקורבן שלו. זה ההבדל בין תיקון השרת לבין אתחול שלו מלוח הבקרה. ההגדרה משנה רק את בחירת הקורבן של הליבה. היא אינה מקצרת את זמן התקיעה.

מכולות פועלות ב־cgroups משלהן, שנוצרו על ידי runtime של המכולות ולא על ידי קובצי היחידות שלכם. לכן, מגבלה על docker.service אינה הופכת למגבלה על מכולה אחת. המקבילות לכל מכולה של MemoryMax= ושל CPUQuota= מוסברות ב־הגדרת מגבלות זיכרון ומעבד ב־Docker Compose.

FAQ

מדוע ה־VPS שלי קפא במקום להפסיק את התהליך שיצא משליטה?

משום שה־kernel קובע אם יש התקדמות לפי השאלה אם פעולת reclaim מחזירה דפים, ולא לפי משך הזמן שהיא נמשכת. כאשר הזיכרון חסר, הוא מפנה את מטמון הדפים, כולל את דפי קובצי ההרצה של תוכניות פעילות, ולאחר מכן קורא אותם מחדש בעת ביצוע ההוראה הבאה. הכול ממתין לאחסון, ושום הקצאה לא נכשלה מבחינה טכנית, ולכן ה־OOM killer אינו מופעל. בדקו את /proc/pressure/memory בזמן שהמצב מתרחש: ערך full avg10 מעל 40 פירושו שבמשך יותר מ־40% מ־10 השניות האחרונות, כל המשימות שאינן במצב idle היו תקועות בו־זמנית בהמתנה לזיכרון. דמון userspace כגון earlyoom מפסיק תהליכים לפני שהשרת מגיע למצב הזה.

מה ההבדל בין MemoryHigh לבין MemoryMax?

MemoryHigh= הוא סף רך שמגביל את קצב הפעולה. ה־kernel מפנה זיכרון מהיחידה באופן אגרסיבי ומאט את ההקצאות שלה, אך השימוש יכול לחרוג מהערך ושום תהליך אינו מופסק. MemoryMax= הוא סף קשיח: הקצאה שאי־אפשר לספק במסגרת הסף מפעילה את ה־OOM killer בתוך ה־cgroup של אותה יחידה, ולכן התהליך שגרם לבעיה הוא זה שמופסק, במקום התהליך הגדול ביותר בשרת. הגדירו את MemoryHigh= מתחת ל־MemoryMax=, והתייחסו לפער ביניהם כאזור אזהרה.

כיצד אפשר למצוא איזה שירות נפגע על־ידי ה־OOM killer?

הריצו journalctl -k --grep "Killed process" --since "2 hours ago". שורה שמתחילה ב־Memory cgroup out of memory פירושה שיחידה אחת חרגה מה־MemoryMax= שלה, ואילו Out of memory ללא תוספת פירושו שלמכונה כולה אזל הזיכרון. לאחר מכן הריצו journalctl -u <unit> -n 50 וחפשו את Failed with result 'oom-kill'. אם /var/log/journal אינו קיים בשרת שלכם, ה־journal נשמר בזיכרון והראיות אבדו בעת האתחול מחדש, לכן צרו את התיקייה לפני האירוע הבא.

האם כדאי להוסיף swap ל־VPS קטן?

קובץ swap קטן מסייע לדפים קרים שמוקצים פעם אחת ואינם נגישים שוב. הוא אינו מסייע לתהליך שיצא משליטה: הוא מעכב את הפסקת התהליך ומחליף השבתה קצרה בתקיעה ממושכת, שבמהלכה אי־אפשר להתחבר כדי לתקן את הבעיה. השאירו את ה־swap בגודל מתון, והגדירו MemorySwapMax=0 ביחידות שאתם מוכנים לאבד, כדי שיגיעו במהירות לתקרה שלהם ובעזרת Restart=on-failure יחזרו לפעול בעצמם, בעוד שהשירותים החשובים ימשיכו להשתמש ב־swap שלהם.

האם אפשר להגביל פקודה בלי לכתוב קובץ unit?

כן. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh מריץ את הפקודה במסוף שלכם בתוך scope זמני עם המגבלות האלה, והמגבלות נעלמות כשהפקודה מסתיימת. כל מאפיין מתוך systemd.resource-control זמין לאחר -p, ולכן גם MemorySwapMax=, TasksMax= ו־CPUWeight= פועלים שם. הסירו את --scope והוסיפו את --unit=name כדי להריץ את המשימה ברקע ולשמור את הפלט שלה ב־journal.

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