SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-28

systemd service की CPU और memory limit कैसे सेट करें

systemd unit में MemoryMax और CPUQuota का उपयोग करके process को सीमित करें। यह गाइड बताती है कि कैसे cgroup v2 के जरिए VPS पर संसाधनों को नियंत्रित करें और OOM kill को समझें।

systemd drop-in के साथ process memory और CPU को सीमित करना

आप Linux VPS पर process की memory और CPU को उस unit में कुछ lines जोड़कर सीमित कर सकते हैं जो process को चलाती है। MemoryMax= memory पर एक hard ceiling है। CPUQuota= processor time पर एक ceiling है। दोनों को cgroup v2 (control groups, version 2) द्वारा लागू किया जाता है, जो कि kernel का वह feature है जिसे systemd पहले से ही box पर मौजूद हर service का हिसाब रखने के लिए उपयोग करता है।

sudo systemctl edit myapp.service

यह comments में निर्देशों के साथ एक drop-in file खोलता है। उनके ऊपर यह जोड़ें:

[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 को आपके numbers को kernel की अपनी units में वापस दोहराना चाहिए: MemoryMax=805306368 और CPUQuotaPerSecUSec=800ms। यदि यह MemoryMax=infinity print करता है, तो drop-in कभी load नहीं हुआ। जाँचें कि file /etc/systemd/system/myapp.service.d/override.conf पर स्थित है, और यह कि यह [Service] header के साथ शुरू होती है, क्योंकि बिना किसी section वाली settings line systemd को Assignment outside of section. Ignoring. log करने के लिए मजबूर करती है और service बिना किसी limit के start हो जाती है।

इस guide का बाकी हिस्सा यह है कि उन numbers को कैसे चुनें, और set होने के बाद भी क्या गलत हो सकता है।

रनवे प्रोसेस VPS को फ्रीज क्यों कर देती है, जबकि वह उसे भरती नहीं है

जब कोई प्रोसेस अपनी हार्ड मेमोरी लिमिट तक पहुँचती है, तो वह लगभग एक सेकंड में बंद हो जाती है और सर्विस रीस्टार्ट हो जाती है। यह एक अच्छा परिदृश्य है। बुरा परिदृश्य वह है जहाँ कुछ भी बंद नहीं होता: मशीन ping का जवाब देती है, SSH कनेक्शन स्वीकार करता है, लेकिन शेल प्रॉम्प्ट कभी नहीं आता। मशीन चालू और व्यस्त है, लेकिन वह कोई उपयोगी काम नहीं कर रही है।

इसका कारण यह है, क्योंकि यह स्पष्ट नहीं है। जब फ्री मेमोरी कम हो जाती है, तो कर्नेल नई पेज देने के बजाय पेजों को रिक्लेम (reclaim) करने लगता है। रिक्लेम करने के लिए सबसे सस्ते पेज फाइल-बैक्ड होते हैं, और पेज कैश में चल रही हर चीज का एक्जीक्यूटेबल कोड होता है। इसलिए कर्नेल sshd के टेक्स्ट पेजों को हटा देता है, और अगला इंस्ट्रक्शन जिसे sshd रन करता है, वह एक पेज फॉल्ट है जिसे उन बाइट्स को स्टोरेज से वापस पढ़ना पड़ता है। हर प्रोसेस चलने के बजाय डिस्क पर प्रतीक्षा करती रह जाती है। वही पेज एक लूप में बाहर जाते हैं और वापस आते हैं, जिसे थ्रैशिंग (thrashing) कहा जाता है।

दो चीजें इसे लैपटॉप की तुलना में VPS पर और खराब बना देती हैं। स्टोरेज अक्सर नेटवर्क अटैच्ड या शेयर्ड होता है, इसलिए प्रत्येक फॉल्ट में लोकल NVMe डिवाइस की तुलना में अधिक मिलीसेकंड लगते हैं। और कर्नेल समय नहीं मापता, वह विफलता मापता है: जब तक रिक्लेम एक पेज वापस देता रहता है, चाहे वह कितना भी धीमा क्यों न हो, कर्नेल को लगता है कि वह प्रगति कर रहा है और वह आउट ऑफ मेमोरी (OOM) किलर को कॉल नहीं करता है। कोई भी चीज मारे जाने से पहले एक मशीन कई मिनटों तक उस स्थिति में रह सकती है।

आप इसे होते हुए देख सकते हैं। कर्नेल Linux 4.20 और उसके बाद के वर्ज़न पर प्रेशर स्टॉल इंफॉर्मेशन (PSI) एक्सपोर्ट करता है:

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% समय के लिए, बॉक्स पर सभी नॉन-आइडल टास्क एक ही समय में मेमोरी पर स्टॉल थे, इसलिए आपका कोई भी काम प्रगति नहीं कर रहा था। एक स्वस्थ सर्वर full पर शून्य के करीब रहता है। 10 से ऊपर यह इंसान को धीमा महसूस होता है, और 40 या उससे अधिक वह स्थिति है जिसे लोग फ्रीज होना कहते हैं।

यही कारण है कि केवल एक लिमिट होना कोई वादा नहीं है। MemoryHigh= के तहत रखी गई यूनिट को मारने के बजाय थ्रॉटल (throttle) किया जाता है, इसलिए वह जीवित रहती है और धीमी बनी रहती है, और कोई भी उसे रीस्टार्ट नहीं करता क्योंकि systemd के नजरिए से वह कभी फेल नहीं हुई। एक कैप्ड यूनिट जिसे स्वैप करने की अनुमति है, वह ऐसे रीड और राइट उत्पन्न करती है जो उस यूनिट के खाते में जाते हैं लेकिन एक शेयर्ड डिवाइस द्वारा सर्व किए जाते हैं, इसलिए यह बॉक्स पर मौजूद हर दूसरी सर्विस के लिए /proc/pressure/io को बढ़ा सकती है। लिमिट यह तय करती है कि कमी की कीमत कौन चुकाएगा, और वे क्षमता पैदा नहीं कर सकतीं।

जांचें कि आपका VPS cgroup v2 चला रहा है या नहीं

stat -fc %T /sys/fs/cgroup

cgroup2fs एकीकृत पदानुक्रम (unified hierarchy) है, जिसकी आवश्यकता नीचे दी गई memory settings को होती है। 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 को memory उपयोग के आधार पर क्रमबद्ध करता है, जो यह जानने का सबसे तेज़ तरीका है कि "इस बॉक्स की मेमोरी कौन खा रहा है", जबकि यह अभी भी प्रतिक्रिया देने में सक्षम है। यदि सर्वर नया है, तो नए VPS पर पहले दस मिनट में किए जाने वाले अकाउंट और फ़ायरवॉल के कार्य इससे पहले आते हैं।

MemoryHigh थ्रॉटलिंग करता है। MemoryMax प्रोसेस को समाप्त (kill) कर देता है।

इन दो मेमोरी सेटिंग्स के बीच का अंतर यह तय करता है कि विफलता (failure) किस तरह की होगी।

  • MemoryHigh= एक सॉफ्ट कैप (soft cap) है। इससे ऊपर जाने पर कर्नल उस cgroup से आक्रामक रूप से मेमोरी वापस लेता है और जानबूझकर उसके एलोकेशन को धीमा कर देता है। उपयोग इस संख्या से आगे जा सकता है और कोई भी प्रोसेस समाप्त नहीं होती है।
  • MemoryMax= एक हार्ड कैप (hard cap) है। जब इसके अंतर्गत कोई एलोकेशन पूरा नहीं किया जा सकता, तो OOM killer उस cgroup के भीतर चलता है और उस यूनिट की अपनी किसी एक प्रोसेस को समाप्त कर देता है।

यह दूसरा भाग ही वह मुख्य कारण है कि आपको किसी भी ऐसी चीज़ पर MemoryMax= सेट करना चाहिए जिस पर आप पूरी तरह भरोसा नहीं करते। बिना कैप के, मेमोरी की कमी पूरी मशीन की समस्या बन जाती है, और ग्लोबल OOM killer अपने शिकार को oom_score के आधार पर चुनता है, जिसका अर्थ आमतौर पर सबसे बड़ी प्रोसेस होता है। सबसे बड़ी प्रोसेस अक्सर आपका डेटाबेस होती है, न कि वह स्क्रिप्ट जिसमें मेमोरी लीक हुई है। कैप के साथ, किल (kill) उसी यूनिट के भीतर होता है जिसने समस्या पैदा की है।

दोनों को सेट करें, जिसमें MemoryHigh= को MemoryMax= से लगभग 20 से 30 प्रतिशत नीचे रखें। यह अंतर एक चेतावनी क्षेत्र (warning zone) है: एक धीमा लीक High को पार करता है और एक ऐसी सर्विस के रूप में दिखाई देता है जो धीमी हो गई है, जबकि अचानक आया स्पाइक सीधे Max को पार कर जाता है और सर्विस समाप्त हो जाती है।

प्रतिशत मानों को इंस्टॉल की गई फिजिकल मेमोरी के आधार पर पढ़ा जाता है, इसलिए 4 GB प्लान पर MemoryMax=25% का मतलब 1 GB है और प्लान का आकार बदलने के बाद भी यह मशीन का एक चौथाई हिस्सा ही रहता है। MemorySwapMax=0 उस यूनिट को पूरी तरह से स्वैप (swap) से बाहर रखता है, इसलिए जब यह MemoryMax= तक पहुँचती है, तो स्वैप में लंबे समय तक चलने के बजाय किल जल्दी हो जाता है। उस बिंदु से नीचे MemoryHigh= अभी भी इसे थ्रॉटल कर सकता है, और हाई लिमिट से ऊपर जाने पर कभी भी OOM killer सक्रिय नहीं होता है, इसलिए जो यूनिट इन दोनों के बीच रहती है, वह मरने के बजाय धीमी बनी रहती है।

कुछ सर्विसेज आपको मापने के बजाय पहले ही अपनी मेमोरी की आवश्यकता तय करने देती हैं: एक Ollama यूनिट आपके द्वारा दिए गए कॉन्टेक्स्ट विंडो से अपना KV कैश आकार निर्धारित करती है, इसलिए RAM में num_ctx बढ़ाने की लागत क्या है इसे पढ़ें, इससे पहले कि आप किसी के लिए अधिकतम सीमा चुनें।

कैप के साथ एक रीस्टार्ट पॉलिसी की आवश्यकता होती है, अन्यथा किल होने के बाद आपके पास केवल एक बंद सर्विस रह जाएगी।

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

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

StartLimit* को [Unit] में और Restart= को [Service] में होना चाहिए। यदि आप किसी को गलत सेक्शन में रखते हैं, तो systemd उसे अनदेखा कर देता है। पाँच मिनट में पाँच बार रीस्टार्ट होना एक मामूली समस्या के बजाय एक लीक है, इसलिए उसके बाद systemd प्रयास करना छोड़ देता है और यूनिट को failed स्थिति में छोड़ देता है। यह वही स्थिति है जिसे आप बाद में देखना चाहेंगे, बजाय इसके कि एक क्रैश लूप समस्या को छिपाए रखे।

CPUQuota के साथ CPU को सीमित करें, या CPUWeight के साथ उसे साझा करें

CPUQuota= एक CPU पर उपलब्ध समय का प्रतिशत लेता है। CPUQuota=50% एक कोर का आधा हिस्सा है। CPUQuota=200% दो कोर के बराबर है, जिसे यूनिट अपनी इच्छा अनुसार कई थ्रेड्स में फैला सकती है। 2 vCPU वाले प्लान पर, CPUQuota=200% पूरी मशीन के बराबर है।

CPUWeight= अधिकांश सेवाओं के लिए बेहतर डिफ़ॉल्ट है। यह 1 से 10000 तक का एक सापेक्ष हिस्सा (relative share) है, और कर्नल का डिफ़ॉल्ट मान 100 है। यह केवल तब प्रभावी होता है जब संसाधन के लिए प्रतिस्पर्धा हो: लोड होने पर CPUWeight=20 पर चल रहा बैकअप जॉब 100 पर चल रहे वेब सर्वर को प्राथमिकता देता है, और जब सर्वर खाली (idle) होता है तो यह पूरे बॉक्स का उपयोग कर सकता है। एक हार्ड कोटा उस खाली क्षमता को व्यर्थ कर देता है।

ईमानदार रहें कि CPU लिमिट आपको क्या देती है। एक CPU-बाउंड प्रोसेस शायद ही कभी Linux को फ्रीज करती है, क्योंकि शेड्यूलर सभी को समय देता रहता है। मेमोरी वह चीज है जो बॉक्स को डाउन कर देती है। जब आप एक अनुमानित सीमा (predictable ceiling) चाहते हैं, तो CPUQuota= का उपयोग करें, उदाहरण के लिए किसी ऐसे बिल्ड या एजेंट पर जो अन्यथा एक घंटे तक पूरी क्षमता पर चलेगा। उस प्रकार के वर्कलोड का आकार निर्धारित करना अपने आप में एक अलग प्रश्न है, जिसे coding agent VPS को कितनी RAM और CPU की आवश्यकता होती है में कवर किया गया है।

यदि CPU व्यस्त दिखाई देता है जबकि आपकी कोई भी प्रोसेस ज्यादा काम नहीं कर रही है, तो इसका कारण हाइपरवाइजर के दूसरी तरफ हो सकता है। यह noisy neighbour से CPU steal time है, और आपके द्वारा सेट किया गया कोई भी कोटा इसे नहीं बदलेगा।

TasksMax एक fork loop को रोकता है

TasksMax= वह संख्या है जो एक unit में processes और threads की हो सकती है। Threads भी इसमें गिने जाते हैं, इसलिए Java या Go service को process list के अनुमान से अधिक headroom की आवश्यकता होती है। यह एक ऐसी script के खिलाफ सबसे सस्ता बचाव है जो loop में fork करती है, क्योंकि fork पूरी machine के process IDs खत्म होने के बजाय unit के भीतर ही विफल हो जाता है।

TasksMax=128

जब कोई unit इस limit तक पहुँचती है, तो kernel cgroup का नाम बताते हुए एक line log करता है:

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

Program स्वयं आमतौर पर fork: retry: Resource temporarily unavailable की रिपोर्ट करता है। यह जाँचें कि manager डिफ़ॉल्ट रूप से क्या लागू करता है, इसके लिए systemctl show -p DefaultTasksMax का उपयोग करें।

systemd-run के साथ एक बार चलने वाले जॉब को सीमित करना

इसके लिए आपको किसी unit file की आवश्यकता नहीं है। systemd-run एक कमांड के चारों ओर एक अस्थायी (transient) unit बनाता है।

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 प्रिंट करता है। आउटपुट आपकी स्क्रीन पर बना रहता है और कमांड के समाप्त होते ही सीमाएं (limits) हट जाती हैं। 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

जब आप root नहीं होते हैं, तब भी यही विकल्प --user के साथ काम करते हैं, हालाँकि आपके user manager के पास केवल वही controllers होते हैं जो उसे सौंपे (delegate) गए हैं, इसलिए वहाँ कोई प्रॉपर्टी अस्वीकार की जा सकती है। यदि ऐसा होता है, तो इसे sudo के साथ चलाएँ। जब किसी जॉब को स्थायी स्थान मिल जाता है, तो सेटिंग्स बिना किसी बदलाव के एक वास्तविक unit में चली जाती हैं: देखें running a script as a systemd service and timer।

Swap के बारे में सच्चाई

Swap विफलता को रोकने के बजाय उसके स्वरूप को बदल देता है।

Swap न होने पर, memory leak होने पर system तुरंत अपनी सीमा तक पहुँच जाता है और कुछ ही सेकंड में कोई process बंद हो जाती है। यह outage स्पष्ट, संक्षिप्त होती है और बाद में journal में आसानी से पढ़ी जा सकती है। Swap होने पर, kernel ठंडे anonymous pages को disk पर लिख देता है और समय खरीद लेता है। यदि process का memory usage स्थिर होने वाला था, तो swap आपको बचा लेता है। यदि यह एक runaway process है, तो swap पांच सेकंड की outage को बीस मिनट के ठहराव (stall) में बदल देता है। यह ठहराव अधिक हानिकारक है, क्योंकि एक मृत process के बाद भी आपको working shell मिल जाती है, जबकि thrashing कर रहा box पूरी तरह अनुत्तरदायी हो जाता है।

swapon --show
free -h

एक छोटे VPS पर व्यावहारिक तरीका यह है: उन pages के लिए एक छोटा swap file रखें जो एक बार allocate होकर दोबारा उपयोग नहीं होते, और उन units पर MemorySwapMax=0 सेट करें जिन्हें आप खोने के लिए तैयार हैं। महत्वपूर्ण services अपना swap बनाए रखती हैं। अनिश्चित services जल्दी ही सीमा तक पहुँच जाती हैं और उनकी cap के साथ लगा restart policy उन्हें वापस चालू कर देता है।

vm.swappiness को कम करना एक कमजोर उपाय है, और यह जानना जरूरी है कि क्यों। यह केवल page cache को हटाने और anonymous pages को swap करने के बीच के संतुलन को बदलता है, और दोनों ही स्थितियों में बाद में disk read की लागत चुकानी पड़ती है। यह केवल यह बदलता है कि कौन से pages thrash हो रहे हैं, यह नहीं कि box thrash होगा या नहीं।

एक early OOM daemon स्टॉल से पहले ही process को समाप्त कर देता है

Kernel मेमोरी reclaim के पूरी तरह विफल होने का इंतज़ार करता है, और एक छोटे VPS पर यही वह समय होता है जब आप मशीन का एक्सेस खो देते हैं। दो userspace daemons खुद मेमोरी की निगरानी करके और जल्दी kill करके इस समस्या को हल करते हैं।

earlyoom उपलब्ध मेमोरी और फ्री स्वैप की प्रति सेकंड दस बार तक जाँच करता है, और केवल तभी सबसे अधिक oom_score वाली process को समाप्त करता है जब दोनों अपने थ्रेशोल्ड से नीचे गिर जाते हैं। बिना स्वैप वाले बॉक्स पर, केवल मेमोरी थ्रेशोल्ड ही निर्णय लेता है।

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 फ्री स्वैप का न्यूनतम स्तर सेट करता है, जो डिफ़ॉल्ट रूप से 10 प्रतिशत होते हैं। प्रत्येक जोड़ी में दूसरी संख्या SIGKILL पॉइंट है: जब मेमोरी और स्वैप दोनों अपने पहले मानों से नीचे गिर जाते हैं, तो earlyoom SIGTERM भेजता है, और जब दोनों दूसरे मान से नीचे गिर जाते हैं, तो SIGKILL भेजता है, जो डिफ़ॉल्ट रूप से पहले मान का आधा होता है। यूनिट इस वेरिएबल को $EARLYOOM_ARGS के रूप में earlyoom को पास करती है, इसलिए systemd इसे व्हाइटस्पेस पर तर्कों (arguments) में विभाजित कर देता है। --avoid और --prefer पैटर्न को कोट करना सुरक्षित है: systemd फाइल पढ़ते समय बाहरी डबल कोट्स को हटा देता है, फिर वैल्यू के अंदर के सिंगल कोट्स का सम्मान करता है और उन्हें हटा देता है, इसलिए --avoid '^(sshd|systemd)$' ऊपर दिए गए बिना कोट्स वाले फॉर्म की तरह ही काम करता है। जिस पैटर्न में स्पेस होता है, उसे उन सिंगल कोट्स की आवश्यकता होती है, अन्यथा वह दो तर्कों में विभाजित हो जाता है। sudo systemctl restart earlyoom के साथ बदलाव लागू करें, और यह देखने के लिए journalctl -u earlyoom पढ़ें कि इसने किस process को समाप्त किया और वह process कितनी मेमोरी ले रही थी।

systemd-oomd दूसरा विकल्प है। इसका मैनुअल पेज इसे "एक सिस्टम सर्विस जो cgroups-v2 और pressure stall information (PSI) का उपयोग करती है ताकि kernel space में OOM होने से पहले निगरानी की जा सके और सुधारात्मक कार्रवाई की जा सके" के रूप में वर्णित करता है। यह एकल processes के बजाय पूरे cgroups पर कार्य करता है, इसलिए यह किसी stray child के बजाय एक यूनिट को समाप्त करता है। यूनिट्स ManagedOOMMemoryPressure=kill या ManagedOOMSwap=kill के साथ ऑप्ट-इन करती हैं, और थ्रेशोल्ड /etc/systemd/oomd.conf में स्थित होते हैं।

systemctl status systemd-oomd
oomctl

oomctl प्रिंट करता है कि यह वर्तमान में किसकी निगरानी कर रहा है, जो अक्सर सर्वर इमेज पर कुछ भी नहीं होता है, क्योंकि सेटिंग प्रति यूनिट ऑप्ट-इन है। एक daemon चुनें और वहीं रुक जाएं। दोनों को एक साथ चलाने का मतलब है कि दो चीजें victim चुनने की दौड़ में हैं, और किसी भी kill का कारण पता लगाना कठिन हो जाता है।

कौन सी unit जिम्मेदार थी?

सबसे पहले kernel की जाँच करें, क्योंकि यह अपने द्वारा किए गए हर kill का रिकॉर्ड रखता है।

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

Global OOM killer द्वारा किया गया kill कुछ इस तरह दिखता है:

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 वह anonymous memory है, जैसे heap, जिसे process ने मरने के समय RAM में रखा था, यहाँ लगभग 1.8 GB है। Resident file mappings और shared memory को अलग से file-rss और shmem-rss के रूप में गिना जाता है। कोष्ठक में दिए गए नाम को संदेह की दृष्टि से देखें। यह वह victim है जिसे kernel ने चुना है, और kernel सबसे बड़ी process को चुनता है, जो जरूरी नहीं कि हमेशा वही हो जिसने shortage पैदा की हो।

Cgroup limit से होने वाले kill का prefix अलग होता है, और उसके ऊपर छपी रिपोर्ट उस 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

वह prefix ही निदान का मुख्य हिस्सा है। Memory cgroup out of memory का अर्थ है कि एक unit आपके द्वारा दी गई MemoryMax= सीमा तक पहुँच गई थी और बाकी सर्वर ठीक था। एक साधारण Out of memory का अर्थ है कि पूरी मशीन की memory खत्म हो गई थी, जिसका मतलब है कि आपकी caps या तो गायब थीं या इतनी अधिक थीं कि उनका योग सीमा से बाहर हो गया।

इसके बाद 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 counters तीसरा स्रोत हैं, और एकमात्र ऐसा स्रोत जो throttling को रिकॉर्ड करता है, जिसके लिए कभी कोई log line नहीं बनती:

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 गिनता है कि unit को कितनी बार MemoryHigh= से ऊपर धकेला गया और throttle किया गया। max गिनता है कि यह कितनी बार hard cap तक पहुँची, और oom_kill उन processes को गिनता है जो वास्तव में kill की गईं। oom_kill 0 के साथ एक बड़ी high संख्या पहले बताए गए silent case का उदाहरण है: जब से इसका cgroup बनाया गया है, unit को बार-बार throttle किया गया है बिना एक भी kill के, इसलिए systemd ने कोई failure रिकॉर्ड नहीं किया है। यह counter केवल बढ़ता है, इसलिए इसे एक मिनट के अंतराल पर दो बार पढ़ें: यदि high लगातार बढ़ रहा है, तो इसका मतलब है कि throttling अभी हो रही है। memory.peak (Linux 5.19 और नए) उस उच्चतम usage को दर्शाता है जहाँ तक cgroup पहुँचा था, और इसी संख्या के आधार पर MemoryMax= को size करना चाहिए। unit के restart होने पर दोनों files reset हो जाती हैं, क्योंकि systemd cgroup को दोबारा बनाता है।

इन सबके नीचे एक पूर्व-शर्त है। यदि /var/log/journal मौजूद नहीं है, तो journal RAM में रहता है, और सर्वर को recover करने के लिए किए गए reboot के बाद हर line मिट जाती है।

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 से अधिक दिखाता है, तो इसका मतलब है कि history अब सुरक्षित है, इसलिए journalctl -k -b -1 आपको उस boot के kernel messages दिखा सकता है जो crash हुआ था।

छोटे VPS के लिए एक शुरुआती बिंदु

2 GB के प्लान पर, kernel और page cache के लिए 300 से 400 MB जगह छोड़ें। सुनिश्चित करें कि सभी caps का योग कुल 2 GB से कम हो, क्योंकि हर unit का उपयोग एक ही समय पर चरम (peak) पर पहुँच सकता है। सबसे महत्वपूर्ण service को सबसे बड़ा हिस्सा दें, और उसके आसपास की अन्य speculative सेवाओं को सीमित रखें।

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

सर्वर का एक्सेस बनाए रखना एक अतिरिक्त सेटिंग के लायक है। ssh.service के लिए एक drop-in में OOMScoreAdjust=-500 सेट करने से global OOM killer द्वारा आपके SSH daemon को victim के रूप में चुने जाने की संभावना काफी कम हो जाती है। यही वह अंतर है जो सर्वर को ठीक करने और उसे control panel से reboot करने के बीच होता है। यह केवल kernel द्वारा victim चुनने की प्राथमिकता को बदलता है। यह stall की अवधि को कम नहीं करता है।

Containers अपने स्वयं के cgroups में चलते हैं, जिन्हें आपके unit files के बजाय container runtime द्वारा बनाया जाता है, इसलिए docker.service पर लगाई गई सीमा एक container की सीमा नहीं बनती है। MemoryMax= और CPUQuota= के प्रति-container विकल्प Docker Compose में memory और CPU सीमाएं सेट करना में बताए गए हैं।

FAQ

मेरा VPS runaway process को kill करने के बजाय freeze क्यों हो गया?

क्योंकि kernel यह तय करता है कि reclaim ने pages वापस किए हैं या नहीं, न कि इसमें कितना समय लगा है। जब memory कम होती है, तो यह page cache को हटा देता है, जिसमें चल रहे programs के executable pages भी शामिल होते हैं, और फिर अगली instruction पर उन्हें वापस read करता है। सब कुछ storage पर निर्भर हो जाता है और तकनीकी रूप से कोई allocation fail नहीं होता, इसलिए OOM killer कभी call नहीं होता। ऐसा होने पर /proc/pressure/memory की जाँच करें: 40 से ऊपर का full avg10 मतलब है कि पिछले दस सेकंड में 40% से अधिक समय तक, हर non-idle task एक ही समय पर memory के कारण रुका हुआ था। earlyoom जैसा userspace daemon बॉक्स के उस स्थिति में पहुँचने से पहले ही process को kill कर देता है।

MemoryHigh और MemoryMax में क्या अंतर है?

MemoryHigh= एक soft cap है जो throttle करता है। Kernel unit से सख्ती से memory reclaim करता है और उसके allocations को धीमा कर देता है, लेकिन usage उस संख्या से अधिक हो सकता है और कुछ भी kill नहीं होता। MemoryMax= एक hard cap है: इसके तहत जो allocation पूरा नहीं हो पाता, वह उस unit के अपने cgroup के भीतर OOM killer को invoke करता है। इस प्रकार, पूरी machine पर सबसे बड़ी process के बजाय वही process मरती है जिसने समस्या पैदा की है। MemoryHigh= को MemoryMax= से नीचे सेट करें और उनके बीच के अंतर को warning zone मानें।

मुझे कैसे पता चलेगा कि OOM killer ने किस service को hit किया है?

journalctl -k --grep "Killed process" --since "2 hours ago" चलाएँ। Memory cgroup out of memory से शुरू होने वाली line का मतलब है कि एक unit ने अपना MemoryMax= hit किया है, जबकि एक साधारण Out of memory का मतलब है कि पूरी machine की memory खत्म हो गई थी। फिर journalctl -u <unit> -n 50 चलाएँ और Failed with result 'oom-kill' खोजें। यदि आपके सर्वर पर /var/log/journal मौजूद नहीं है, तो journal RAM में था और reboot के साथ सबूत मिट गए, इसलिए अगली घटना से पहले वह directory बना लें।

क्या मुझे छोटे VPS में swap जोड़ना चाहिए?

एक छोटा swap file उन cold pages के लिए मददगार होता है जो एक बार allocate होकर दोबारा कभी इस्तेमाल नहीं होते। यह runaway process के मामले में मदद नहीं करता: यह kill करने में देरी करता है और एक छोटे outage की जगह एक लंबे stall को ले आता है जिसे आप login करके ठीक नहीं कर सकते। Swap को सीमित रखें, और जिन units को आप खोने के लिए तैयार हैं उन पर MemorySwapMax=0 सेट करें, ताकि वे जल्दी अपनी सीमा तक पहुँच जाएँ और Restart=on-failure सेट होने पर, वे अपने आप वापस आ जाएँ जबकि महत्वपूर्ण services अपना swap बनाए रखें।

क्या मैं unit file लिखे बिना किसी command को limit कर सकता हूँ?

हाँ। sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh आपके terminal में उस command को उन limits के साथ एक transient scope में चलाता है, और exit होने पर वे limits खत्म हो जाती हैं। -p के बाद systemd.resource-control की हर property उपलब्ध होती है, इसलिए MemorySwapMax=, TasksMax= और CPUWeight= वहाँ भी काम करते हैं। --scope को हटाएँ और job को background में चलाने के लिए --unit=name जोड़ें, जिससे उसका output journal में सुरक्षित रहे।

क्या यह लेख उपयोगी था?