systemd மூலம் process memory மற்றும் CPU-ஐ
Linux VPS-ல் MemoryMax, CPUQuota மற்றும் TasksMax ஆகியவற்றை பயன்படுத்தி ஒரு process-ன் வளங்களை வரம்பிடவும். OOM killer செயல்பாட்டை தவிர்க்க இந்த முறையை பின்பற்றுங்கள்.
systemd drop-in மூலம் process memory மற்றும் CPU-ஐ வரம்பிடுதல்
Process-ஐ இயக்கும் unit-ல் சில வரிகளைச் சேர்ப்பதன் மூலம் Linux VPS-ல் அதன் memory மற்றும் CPU பயன்பாட்டை வரம்பிடலாம். MemoryMax= என்பது memory-க்கான கடினமான உச்சவரம்பாகும். CPUQuota= என்பது processor time-க்கான உச்சவரம்பாகும். இவை இரண்டும் cgroup v2 (control groups, version 2) மூலம் அமல்படுத்தப்படுகின்றன. ஒவ்வொரு service-ஐயும் அந்த system-ல் கணக்கிட systemd ஏற்கனவே பயன்படுத்தும் kernel அம்சமே இது.
sudo systemctl edit myapp.serviceComments-ல் உள்ள instructions-உடன் ஒரு drop-in file திறக்கும். அவற்றுக்கு மேலே இதைச் சேர்க்கவும்:
[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMaxsystemctl show, நீங்கள் உள்ளிட்ட numbers-ஐ kernel பயன்படுத்தும் சொந்த units-ல் மீண்டும் காட்ட வேண்டும்: MemoryMax=805306368 மற்றும் CPUQuotaPerSecUSec=800ms. அது MemoryMax=infinity என்று காட்டினால், drop-in load ஆகவில்லை. File /etc/systemd/system/myapp.service.d/override.conf என்ற இடத்தில் உருவாகியுள்ளதா என்பதைச் சரிபார்க்கவும். அது [Service] header-ல் தொடங்குகிறதா என்பதையும் உறுதிப்படுத்தவும். ஏனெனில் அதற்கு முன் section இல்லாமல் settings line இருந்தால், systemd Assignment outside of section. Ignoring. என்று log செய்து, எந்த limits-உம் இல்லாமல் service-ஐத் தொடங்கும்.
இந்த numbers-ஐ எவ்வாறு தேர்வு செய்வது, அவற்றை அமைத்த பிறகும் எந்தப் பிரச்சினைகள் ஏற்படலாம் என்பதே இந்த guide-ன் மீதமுள்ள பகுதி.
ஒரு runaway process ஏன் VPS-ஐ முடக்குகிறது (நினைவகம் நிரம்பாதபோதும்)
ஒரு process அதன் hard memory cap-ஐ எட்டும்போது, அது ஒரு நொடிக்குள் செயலிழந்து, service தானாகவே restart ஆகும். இது சாதகமான சூழல். ஆனால், எதுவும் செயலிழக்காத சூழல் ஆபத்தானது: server ping-க்கு பதில் அளிக்கும், SSH connection-ஐ ஏற்கும், ஆனால் shell prompt வராது. இயந்திரம் இயங்கிக்கொண்டிருக்கும், ஆனால் பயனுள்ள வேலை எதுவும் நடக்காது.
இதற்கான காரணம் வெளிப்படையானது அல்ல, அதன் நுட்பம் இதோ. free memory குறையும்போது, kernel புதிய பக்கங்களை (pages) வழங்குவதற்குப் பதிலாக, ஏற்கனவே உள்ள பக்கங்களை மீட்கத் தொடங்கும். இதில் எளிதாக மீட்கக்கூடியவை file-backed பக்கங்கள்; இயங்கிக்கொண்டிருக்கும் அனைத்து நிரல்களின் executable code-ம் page cache-ல் இருக்கும். எனவே, kernel sshd-ன் text pages-ஐ நீக்குகிறது. அடுத்தமுறை sshd ஒரு instruction-ஐ இயக்க முயலும்போது, அது page fault ஆகி, அந்த bytes-ஐ மீண்டும் storage-லிருந்து படிக்க வேண்டியிருக்கும். இதனால் ஒவ்வொரு process-ம் இயங்குவதற்குப் பதிலாக disk-க்காகக் காத்திருக்கும். ஒரே பக்கங்கள் வெளியேறுவதும் மீண்டும் வருவதுமாக இருக்கும் இந்தச் சுழற்சிக்கு thrashing என்று பெயர்.
ஒரு laptop-ஐ விட VPS-ல் இது இரண்டு காரணங்களால் மோசமாகிறது. முதலாவதாக, storage பெரும்பாலும் network attached அல்லது shared ஆக இருக்கும்; எனவே, local NVMe device-ஐ விட ஒவ்வொரு fault-க்கும் அதிக milliseconds செலவாகும். இரண்டாவதாக, kernel நேரத்தை அளவிடுவதில்லை, தோல்வியை மட்டுமே அளவிடுகிறது: reclaim செயல்முறை எவ்வளவு மெதுவாக இருந்தாலும், ஒரு பக்கத்தை வழங்க முடிந்தால், kernel தான் முன்னேற்றம் அடைவதாகவே கருதுகிறது. எனவே, அது out of memory (OOM) killer-ஐ அழைப்பதில்லை. எதையும் அழிப்பதற்கு முன், ஒரு server பல நிமிடங்கள் இந்த நிலையிலேயே இருக்கக்கூடும்.
இது நடப்பதை நீங்கள் கண்காணிக்கலாம். Linux 4.20 மற்றும் அதற்குப் பிந்தைய பதிப்புகளில், kernel pressure stall information (PSI)-ஐ வழங்குகிறது:
cat /proc/pressure/memory
cat /proc/pressure/iosome 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% நேரம், server-ல் உள்ள அனைத்து non-idle tasks-ம் ஒரே நேரத்தில் memory-க்காகத் தங்கியிருந்தன என்பதைக் குறிக்கிறது; அதாவது, உங்கள் வேலை எதுவும் முன்னேறவில்லை. ஆரோக்கியமான server-ல் full மதிப்பு பூஜ்ஜியத்திற்கு அருகில் இருக்கும். 10-க்கு மேல் இருந்தால் மனிதர்களுக்கு வேகம் குறைவாகத் தெரியும், 40 அல்லது அதற்கு மேல் இருந்தால் அது "frozen" அல்லது முடங்கிய நிலை என்று அழைக்கப்படுகிறது.
இதனால்தான், ஒரு limit மட்டும் தீர்வாகாது. MemoryHigh=-ன் கீழ் உள்ள ஒரு unit, கொல்லப்படுவதற்குப் பதிலாக throttled செய்யப்படுகிறது. எனவே, அது மெதுவாக இயங்கிக்கொண்டே இருக்கும்; systemd-ன் பார்வையில் அது தோல்வியடையாததால், அதை யாரும் restart செய்ய மாட்டார்கள். Swap செய்ய அனுமதிக்கப்பட்ட ஒரு capped unit, shared device மூலம் படிக்கவும் எழுதவும் செய்யும். இது server-ல் உள்ள மற்ற அனைத்து services-க்கும் /proc/pressure/io-ஐ அதிகரிக்கச் செய்யும். Limits என்பது பற்றாக்குறையை யார் எதிர்கொள்வது என்பதை மட்டுமே தீர்மானிக்கும், அவை கூடுதல் திறனை (capacity) உருவாக்காது.
உங்கள் VPS cgroup v2-ல் இயங்குகிறதா எனச் சரிபார்க்கவும்
stat -fc %T /sys/fs/cgroupcgroup2fs என்பது ஒருங்கிணைந்த படிநிலை (unified hierarchy) ஆகும், இதற்கு கீழே உள்ள memory அமைப்புகள் தேவைப்படுகின்றன. tmpfs என்பது அந்த server பழைய v1 அமைப்பில் boot ஆகியுள்ளது என்று பொருள்; அங்கு MemoryHigh= மற்றும் MemorySwapMax= ஆதரிக்கப்படாது, மேலும் ஒவ்வொரு unit-க்கும் உரிய OOM செயல்பாடு மாறுபடும். இருப்பினும், பழைய cpu.cfs_quota_us கோப்பு மூலம் CPUQuota= அங்கும் வேலை செய்யும். Ubuntu 22.04 மற்றும் அதற்குப் பிந்தைய பதிப்புகளும், Debian 11 மற்றும் அதற்குப் பிந்தைய பதிப்புகளும் இயல்பாகவே v2-ஐப் பயன்படுத்துகின்றன. பழைய image-களில் இது இருக்காது; systemd 257 அல்லது அதற்கு முந்தைய பதிப்புகளில் systemd.unified_cgroup_hierarchy=0 கொண்டு boot செய்யப்பட்ட kernel-லும் இது இருக்காது. systemd 258 பதிப்பில் cgroup v1 ஆதரவு நீக்கப்பட்டு, boot ஆகும்போதே ஒருங்கிணைந்த படிநிலை mount செய்யப்படுகிறது. எனவே, அந்தப் பதிப்பைக் கொண்ட releases-ல் இந்த argument-ஐப் பயன்படுத்தினாலும் v1 மீண்டும் வராது.
cgroup v2-ல் systemd ஒவ்வொரு unit-க்கும் memory accounting-ஐ இயல்பாகவே ஆன் செய்கிறது, எனவே அந்த எண்கள் ஏற்கனவே அங்கு இருக்கும்:
systemd-cgtop -mஇது memory பயன்பாட்டின் அடிப்படையில் cgroup-களை வரிசைப்படுத்தும். server இன்னும் பதிலளிக்கும் நிலையில் இருக்கும்போது, "எது இந்த server-ன் வளங்களை அதிகம் பயன்படுத்துகிறது" என்பதைக் கண்டறிய இதுவே மிக வேகமான வழியாகும். server புதியது என்றால், புதிய VPS-ல் முதல் பத்து நிமிடங்கள் என்ற பகுதியில் உள்ள கணக்கு மற்றும் firewall அமைப்புகளை முதலில் முடிக்க வேண்டும்.
MemoryHigh மற்றும் MemoryMax ஆகியவற்றின் செயல்பாடுகள்.
இந்த இரண்டு memory அமைப்புகளுக்கும் இடையே உள்ள வேறுபாடு, ஒரு செயலிழப்பு எவ்வாறு நிகழ்கிறது என்பதைத் தீர்மானிக்கிறது.
MemoryHigh=என்பது ஒரு மென்மையான வரம்பு (soft cap). இந்த அளவைத் தாண்டும்போது, kernel அந்த cgroup-லிருந்து நினைவகத்தை தீவிரமாக மீட்டெடுக்கிறது மற்றும் அதன் ஒதுக்கீடுகளை வேண்டுமென்றே மெதுவாக்குகிறது. பயன்பாடு இந்த எண்ணைத் தாண்டலாம், ஆனால் எந்தச் செயல்முறையும் (process) நிறுத்தப்படாது.MemoryMax=என்பது ஒரு கடுமையான வரம்பு (hard cap). இந்த வரம்பிற்குள் ஒரு ஒதுக்கீட்டைப் பூர்த்தி செய்ய முடியாதபோது, OOM killer அந்த cgroup-க்குள் இயங்கி, அந்த unit-ன் செயல்முறைகளில் ஒன்றைக் கொன்றுவிடும்.
நீங்கள் முழுமையாக நம்பாத எதற்கும் MemoryMax=-ஐ அமைப்பதற்கான உண்மையான காரணம் இதுதான். வரம்பு இல்லையென்றால், நினைவகப் பற்றாக்குறை என்பது முழு server-க்கும் பாதிப்பை ஏற்படுத்தும். அப்போது global OOM killer தனது இலக்கை oom_score அடிப்படையில் தேர்ந்தெடுக்கும், இது பெரும்பாலும் மிகப்பெரிய செயல்முறையாக இருக்கும். அந்த மிகப்பெரிய செயல்முறை பொதுவாக உங்கள் database-ஆகவே இருக்கும், நினைவகத்தை கசியவிட்ட script-ஆக இருக்காது. ஒரு வரம்பு இருக்கும்போது, அந்தத் தவறுக்குக் காரணமான unit-க்குள் மட்டுமே kill நிகழும்.
இரண்டையும் அமைக்கவும், MemoryHigh=-ஐ MemoryMax=-க்கு கீழே 20 முதல் 30 சதவீதம் வரை வைக்கவும். இந்த இடைவெளி ஒரு எச்சரிக்கை மண்டலமாகும்: மெதுவான கசிவு High-ஐக் கடக்கும்போது சேவை மெதுவாகும், அதேசமயம் திடீர் அதிகரிப்பு Max-ஐத் தாண்டி நேரடியாகச் செயலிழக்கும்.
சதவீத மதிப்புகள் நிறுவப்பட்ட physical memory-ஐ அடிப்படையாகக் கொண்டு கணக்கிடப்படுகின்றன. எனவே, 4 GB திட்டத்தில் MemoryMax=25% என்பது 1 GB ஆகும், மேலும் நீங்கள் திட்டத்தை மாற்றினாலும் அது அந்த அளவில் கால் பங்காகவே இருக்கும். MemorySwapMax=0 அந்த unit-ஐ swap-லிருந்து முழுமையாக விலக்கி வைக்கிறது, எனவே அது MemoryMax=-ஐ அடையும்போது, swap-ல் நீண்ட நேரம் ஊர்ந்து செல்வதற்குப் பதிலாக விரைவாக kill நிகழும். அந்தப் புள்ளிக்குக் கீழே MemoryHigh= அதைத் த்ரோட்டில் (throttle) செய்ய முடியும், மேலும் high limit-ஐத் தாண்டுவது OOM killer-ஐ ஒருபோதும் அழைக்காது, எனவே இரண்டுக்கும் இடையில் இருக்கும் ஒரு unit செயலிழப்பதற்குப் பதிலாக மெதுவாகவே இருக்கும்.
சில சேவைகள் தங்களின் நினைவகத் தேவையை அளவிடுவதற்குப் பதிலாக முன்கூட்டியே தீர்மானிக்க அனுமதிக்கின்றன: ஒரு Ollama unit நீங்கள் கொடுக்கும் context window-லிருந்து அதன் KV cache-ஐ அளவிடுகிறது, எனவே ஒரு வரம்பைத் தேர்ந்தெடுப்பதற்கு முன் num_ctx-ஐ அதிகரிப்பது RAM-ல் என்ன செலவை ஏற்படுத்தும் என்பதைப் படிக்கவும்.
ஒரு வரம்பிற்கு அருகில் restart policy தேவை, இல்லையெனில் kill நிகழ்ந்த பிறகு சேவை நிறுத்தப்பட்ட நிலையிலேயே இருக்கும்.
[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Restart=on-failure
RestartSec=5sStartLimit* என்பது [Unit]-லும், Restart= என்பது [Service]-லும் இருக்க வேண்டும். இரண்டையும் தவறான பிரிவில் வைத்தால் systemd அதை நிராகரித்துவிடும். ஐந்து நிமிடங்களில் ஐந்து முறை restart நிகழ்ந்தால் அது ஒரு தற்காலிகப் பிரச்சனை அல்ல, கசிவு என்று அர்த்தம். அதற்குப் பிறகு systemd முயற்சியைக் கைவிட்டு unit-ஐ failed நிலையில் வைக்கும். இதுவே ஒரு crash loop-ல் சிக்கிப் பிரச்சனையை மறைப்பதை விட, நீங்கள் கண்டறிய விரும்பும் நிலையாகும்.
CPUQuota மூலம் CPU-ஐ வரம்பிடுதல் அல்லது CPUWeight மூலம் பகிர்தல்
CPUQuota=, ஒரு CPU-ல் கிடைக்கும் நேரத்தின் குறிப்பிட்ட சதவீதத்தைப் பயன்படுத்தும். CPUQuota=50% என்பது ஒரு core-ன் பாதி. CPUQuota=200% என்பது இரண்டு cores-க்கு இணையானது; unit விரும்பும் அளவு threads-களில் அதை பகிர்ந்து இயக்கலாம். 2 vCPU plan-ல், CPUQuota=200% என்பது முழு machine-ஐ குறிக்கும்.
பெரும்பாலான services-க்கு CPUWeight= சிறந்த default தேர்வாகும். இது 1 முதல் 10000 வரையிலான relative share ஆகும்; kernel-ன் default மதிப்பு 100. வேறு process போட்டியிடும் நேரத்தில் மட்டுமே இதன் தாக்கம் தெரியும்: load இருக்கும் போது CPUWeight=20-ல் இயங்கும் backup job, 100 மதிப்பில் இயங்கும் web server-க்கு முன்னுரிமை விட்டுக்கொடுக்கும். machine idle-ஆக இருக்கும்போது அது முழு machine-ன் CPU-ஐயும் பயன்படுத்தும். கடுமையான quota, idle-ஆக இருக்கும் அந்த capacity-யை வீணாக்கும்.
CPU limit வழங்குவதன் பயனை யதார்த்தமாக மதிப்பிட வேண்டும். CPU-bound process பொதுவாக Linux-ஐ முடக்காது; scheduler அனைவருக்கும் தொடர்ந்து execution time வழங்கும். ஒரு machine-ஐ முடக்குவது பெரும்பாலும் memory பற்றாக்குறையே. Predictable ceiling தேவைப்படும் போது CPUQuota=-ஐ பயன்படுத்தவும். உதாரணமாக, ஒரு மணி நேரம் முழு CPU-யையும் பயன்படுத்தக்கூடிய build அல்லது agent-க்கு இது பொருந்தும். இத்தகைய workload-க்கான sizing தனியான கேள்வியாகும்; coding agent VPS-க்கு எவ்வளவு RAM மற்றும் CPU தேவை என்பதில் அது விளக்கப்பட்டுள்ளது.
உங்கள் processes எதுவும் அதிகமாக இயங்காதபோதும் CPU busy எனக் காட்டினால், காரணம் hypervisor-ன் மறுபுறத்தில் இருக்கலாம். இதுவே noisy neighbour காரணமான CPU steal time ஆகும். நீங்கள் அமைக்கும் எந்த quota-வும் இதை மாற்றாது.
TasksMax fork loop-ஐ நிறுத்துகிறது
TasksMax= என்பது ஒரு unit வைத்திருக்கக்கூடிய processes மற்றும் threads-ன் எண்ணிக்கையாகும். Threads-உம் கணக்கில் சேரும். எனவே, process list காட்டும் எண்ணிக்கையைவிட Java அல்லது Go service-க்கு அதிக headroom தேவைப்படும். Loop-ல் fork செய்யும் script-க்கு எதிரான குறைந்த செலவிலான பாதுகாப்பு இதுவாகும். ஏனெனில், முழு box-லும் process IDs தீர்ந்து போவதற்குப் பதிலாக, அந்த unit-க்குள் fork தோல்வியடையும்.
TasksMax=128ஒரு unit இந்த வரம்பை அடைந்ததும், kernel cgroup-ன் பெயரைக் குறிப்பிடும் ஒரு வரியை 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 மூலம் ஒரு முறை மட்டும் இயங்கும் job-ஐ வரம்புபடுத்துதல்
இதில் எதையும் பயன்படுத்த unit file தேவையில்லை. systemd-run, ஒரு command-ஐச் சுற்றி 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-ஐ print செய்த பிறகு, உங்கள் terminal-ல் command-ஐ இயக்குகிறது. Output உங்கள் screen-லேயே இருக்கும். Command முடிந்ததும் limits நீக்கப்படும். systemd.resource-control-இல் உள்ள எந்த property-யும் -p-க்குப் பிறகு செயல்படும்.
நீண்ட நேரம் இயங்கும் job-க்கு --scope-ஐ நீக்கி, அதற்கு ஒரு பெயர் வழங்கவும். அப்போது அது transient service-ஆக background-ல் இயங்கி, journal-ல் logs எழுதும்:
sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -froot ஆக இல்லாதபோதும் --user உடன் இதே options செயல்படும். ஆனால், உங்கள் user manager-க்கு delegate செய்யப்பட்ட controllers மட்டுமே இருக்கும். ஆகவே, ஒரு property அங்கு நிராகரிக்கப்படலாம். அது நடந்தால் sudo உடன் இயக்கவும். ஒரு job-க்கு நிரந்தரமான இடம் தேவைப்படும் நிலையில், settings மாற்றமின்றி உண்மையான unit-க்கு மாற்றப்படலாம்: script-ஐ systemd service மற்றும் timer ஆக இயக்குதல் என்பதைப் பார்க்கவும்.
Swap குறித்த கேள்வி, நேர்மையான பதில்
Swap என்பது தோல்வியைத் தடுப்பதற்குப் பதிலாக, அதன் தன்மையை மாற்றுகிறது.
Swap இல்லையெனில், memory கசிவு உச்சத்தை அடைந்தவுடன் ஏதேனும் ஒரு செயல்முறை நொடிகளில் நின்றுவிடும். இந்தச் செயலிழப்பு வெளிப்படையானது, குறுகிய காலமானது மற்றும் பின்னர் journal-ல் பார்ப்பதற்கு எளிதானது. Swap இருந்தால், kernel பயன்படுத்தப்படாத anonymous pages-ஐ disk-க்கு எழுதி நேரத்தை ஈட்டித் தரும். அந்தச் செயல்முறை ஒரு குறிப்பிட்ட அளவோடு நின்றுவிடும் என்றால், swap உங்களைக் காப்பாற்றும். அது ஒரு runaway process என்றால், swap ஐந்து வினாடி செயலிழப்பை இருபது நிமிட முடக்கமாக மாற்றும். முடக்கம் மோசமானது, ஏனெனில் ஒரு செயல்முறை நின்றுவிட்டால் shell-ஐப் பயன்படுத்த முடியும், ஆனால் box thrashing நிலையில் இருந்தால் எதையும் செய்ய முடியாது.
swapon --show
free -hசிறிய VPS-ல் ஒரு நடைமுறை வழி: ஒருமுறை ஒதுக்கப்பட்டு மீண்டும் பயன்படுத்தப்படாத பக்கங்களுக்காக ஒரு சிறிய swap file-ஐ வைத்துக்கொள்ளுங்கள். நீங்கள் இழக்கத் தயாராக இருக்கும் units-க்கு MemorySwapMax=0-ஐ அமைக்கவும். முக்கியமான சேவைகள் அவற்றின் swap-ஐத் தக்கவைக்கும். கணிக்க முடியாத சேவைகள் விரைவில் எல்லையை எட்டும், அவற்றின் restart policy அவற்றை மீண்டும் இயக்கும்.
vm.swappiness-ஐக் குறைப்பது ஒரு பலவீனமான வழிமுறை, அது ஏன் என்று தெரிந்துகொள்வது அவசியம். இது page cache-ஐ நீக்குவதற்கும் anonymous pages-ஐ swap செய்வதற்கும் இடையிலான சமநிலையை மட்டுமே மாற்றுகிறது, இவை இரண்டுமே பின்னர் disk read செலவை ஏற்படுத்தும். இது எந்தப் பக்கங்கள் thrash ஆகின்றன என்பதை மாற்றுகிறதே தவிர, box thrashing ஆவதைத் தடுப்பதில்லை.
முன்கூட்டியே செயல்படும் OOM daemon, stall ஏற்படுவதற்கு முன்பே செயல்களை நிறுத்துதல்
Kernel ஆனது reclaim தோல்வியடையும் வரை காத்திருக்கிறது. சிறிய VPS-களில், அந்த காத்திருப்பு நேரத்தில்தான் நீங்கள் server-ன் கட்டுப்பாட்டை இழக்கிறீர்கள். இரண்டு userspace daemon-கள் நினைவகத்தை (memory) தொடர்ந்து கண்காணித்து, முன்கூட்டியே செயல்முறைகளை (processes) நிறுத்துவதன் மூலம் இந்த சிக்கலைத் தவிர்க்கின்றன.
earlyoom ஆனது கிடைக்கக்கூடிய நினைவகம் மற்றும் free swap ஆகியவற்றை வினாடிக்கு பத்து முறை சரிபார்க்கிறது. இவை இரண்டும் அதன் வரம்பிற்குக் கீழே குறையும்போது மட்டுமே, அதிக oom_score கொண்ட process-ஐ இது நிறுத்துகிறது. swap இல்லாத கணினிகளில், நினைவக வரம்பு மட்டுமே முடிவெடுக்கும் காரணியாக இருக்கும்.
sudo apt install earlyoom
systemctl status earlyoomDebian மற்றும் Ubuntu தொகுப்புகள் நிறுவப்படும்போதே இந்த service-ஐத் தொடங்கிவிடும். இதற்கான விருப்பத்தேர்வுகள் /etc/default/earlyoom-ல் உள்ளன:
EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"-m PERCENT கிடைக்கக்கூடிய நினைவகத்தின் குறைந்தபட்ச அளவையும், -s PERCENT free swap-ன் குறைந்தபட்ச அளவையும் நிர்ணயிக்கிறது. இவை இரண்டும் முன்னிருப்பாக 10 சதவீதமாக இருக்கும். ஒவ்வொரு ஜோடியிலும் உள்ள இரண்டாவது எண் SIGKILL புள்ளியைக் குறிக்கிறது: நினைவகம் மற்றும் swap ஆகிய இரண்டும் முதல் மதிப்புகளை விடக் குறையும்போது earlyoom முதலில் SIGTERM-ஐ அனுப்பும். அவை இரண்டாவது மதிப்பை விடக் குறையும்போது SIGKILL-ஐ அனுப்பும்; இது முன்னிருப்பாக முதல் மதிப்பில் பாதியாக இருக்கும். --avoid மற்றும் --prefer வடிவங்களை மேற்கோள் குறிகள் (quotes) இல்லாமலும், இடைவெளிகள் இல்லாமலும் வைக்கவும். ஏனெனில் systemd மேற்கோள் குறிகளை அப்படியே கடத்தும், அவ்வாறு இருந்தால் அந்த வடிவம் பொருந்தாது. மாற்றங்களைச் செயல்படுத்த sudo systemctl restart earlyoom-ஐப் பயன்படுத்தவும். எந்த process நிறுத்தப்பட்டது மற்றும் அது எவ்வளவு நினைவகத்தை வைத்திருந்தது என்பதை அறிய journalctl -u earlyoom-ஐப் படிக்கவும்.
systemd-oomd மற்றொரு விருப்பத்தேர்வு ஆகும். இதன் manual பக்கம் இதை இவ்வாறு விவரிக்கிறது: "இது cgroups-v2 மற்றும் pressure stall information (PSI)-ஐப் பயன்படுத்தி, kernel space-ல் OOM ஏற்படும் முன்பே கண்காணித்து நடவடிக்கை எடுக்கும் ஒரு system service". இது தனிப்பட்ட process-களுக்குப் பதிலாக முழு cgroup-களின் மீது செயல்படுகிறது, எனவே இது ஒரு stray child-ஐ மட்டும் கொல்லாமல், முழு unit-ஐயும் நிறுத்துகிறது. Unit-கள் ManagedOOMMemoryPressure=kill அல்லது ManagedOOMSwap=kill மூலம் இதில் சேரலாம், இதற்கான வரம்புகள் /etc/systemd/oomd.conf-ல் உள்ளன.
systemctl status systemd-oomd
oomctloomctl தற்போது எதைக் கண்காணிக்கிறது என்பதை அச்சிடும். server image-களில் இது பெரும்பாலும் எதையும் காட்டாது, ஏனெனில் ஒவ்வொரு unit-க்கும் இது தனித்தனியாகத் தேர்ந்தெடுக்கப்பட வேண்டும் (opt-in). ஏதேனும் ஒரு daemon-ஐ மட்டும் தேர்வு செய்து பயன்படுத்தவும். இரண்டையும் ஒரே நேரத்தில் இயக்கினால், எதை நிறுத்துவது என்பதில் போட்டி ஏற்படும், மேலும் ஒரு process ஏன் நிறுத்தப்பட்டது என்பதைக் கண்டறிவது கடினமாகிவிடும்.
எந்த 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:0anon-rss என்பது அந்த process இறந்தபோது RAM-ல் வைத்திருந்த heap போன்ற anonymous memory ஆகும், இங்கே இது சுமார் 1.8 GB. Resident file mappings மற்றும் shared memory ஆகியவை file-rss மற்றும் shmem-rss எனத் தனித்தனியாகக் கணக்கிடப்படுகின்றன. அடைப்புக்குறிக்குள் உள்ள பெயரைச் சந்தேகத்துடன் கவனிக்கவும். அது kernel தேர்ந்தெடுத்த பாதிக்கப்பட்ட process; kernel மிகப்பெரிய process-ஐத் தேர்ந்தெடுக்கும், ஆனால் அதுவே பற்றாக்குறைக்குக் காரணமான process என்று சொல்ல முடியாது.
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அந்த முன்னொட்டே நோயறிதலில் பெரும்பகுதியாகும். Memory cgroup out of memory என்பது ஒரு unit நீங்கள் கொடுத்த MemoryMax=-ஐத் தொட்டுவிட்டது, மீதமுள்ள box சரியாக உள்ளது என்று பொருள். ஒரு சாதாரண Out of memory என்பது இயந்திரம் முழுவதுமாகத் தீர்ந்துவிட்டது என்று பொருள், எனவே உங்கள் வரம்புகள் (caps) விடுபட்டிருக்கலாம் அல்லது மொத்தமாகக் கணக்கிடும்போது மிக அதிகமாக இருந்திருக்கலாம்.
பிறகு systemd என்ன கண்டது என்று கேட்கவும்:
systemctl status myapp.service
journalctl -u myapp.service -n 50myapp.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 வரியையும் உருவாக்காது:
cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peaklow 0
high 4213
max 118
oom 12
oom_kill 12high என்பது அந்த unit எத்தனை முறை MemoryHigh=-க்கு மேல் தள்ளப்பட்டு throttled செய்யப்பட்டது என்பதைக் கணக்கிடுகிறது. max என்பது அது எத்தனை முறை hard cap-ஐ அடைந்தது என்பதையும், oom_kill என்பது எத்தனை process-கள் உண்மையில் கொல்லப்பட்டன என்பதையும் கணக்கிடுகிறது. oom_kill 0 உடன் கூடிய பெரிய high என்பது முன்னால் குறிப்பிட்ட அமைதியான நிகழ்வாகும்: அதன் cgroup உருவாக்கப்பட்டதிலிருந்து, அந்த unit ஒருமுறை கூட கொல்லப்படாமல் மீண்டும் மீண்டும் throttled செய்யப்பட்டுள்ளது, எனவே systemd எந்தப் பிழையையும் பதிவு செய்யவில்லை. இந்த counter எப்போதும் வளர்ந்து கொண்டே இருக்கும், எனவே ஒரு நிமிட இடைவெளியில் இரண்டு முறை படிக்கவும்: தொடர்ந்து உயரும் high என்பது throttling இப்போதும் நடக்கிறது என்று பொருள். memory.peak (Linux 5.19 மற்றும் புதியவை) அந்த cgroup அடைந்த அதிகபட்ச பயன்பாட்டைக் கொண்டுள்ளது, இது MemoryMax=-ஐ அளவிடுவதற்கான எண்ணாகும். Unit restart ஆகும்போது systemd அந்த cgroup-ஐ மீண்டும் உருவாக்குவதால், இரண்டு கோப்புகளும் reset ஆகிவிடும்.
இதற்கெல்லாம் கீழே ஒரு முன்நிபந்தனை உள்ளது. /var/log/journal இல்லை என்றால், journal RAM-ல் இருக்கும், மேலும் box-ஐ மீட்டெடுக்கத் தேவையான reboot-க்குப் பிறகு ஒவ்வொரு வரியும் அழிந்துவிடும்.
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-bootsjournalctl --list-boots தற்போதைய boot-ஐ விட அதிகமாகக் காட்டினால், வரலாறு இப்போது பாதுகாக்கப்படுகிறது என்று பொருள், எனவே journalctl -k -b -1 மூலம் இறந்த boot-ன் kernel செய்திகளை உங்களால் பார்க்க முடியும்.
சிறிய VPS-க்கான தொடக்க அமைப்பு
2 GB plan-ல் kernel மற்றும் page cache-க்காக 300 முதல் 400 MB வரை ஒதுக்கி வைக்கவும். Caps-ன் மொத்த அளவு முழு 2 GB-ஐ எட்டக்கூடாது. ஏனெனில் ஒவ்வொரு unit-மும் ஒரே நேரத்தில் peak நிலையை அடையலாம். முக்கியமான service-க்கு அதிகபட்ச memory share-ஐ வழங்கவும். அதைச் சுற்றியுள்ள ஊக அடிப்படையிலான services அனைத்திற்கும் cap அமைக்கவும்.
[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5sஉள்ளே நுழைவதற்கான வழியை வைத்திருப்பதற்கு இன்னொரு setting பயனுள்ளதாக இருக்கும். OOMScoreAdjust=-500-ஐ ssh.service-க்கான drop-in-ல் அமைத்தால், global OOM killer உங்கள் SSH daemon-ஐ victim-ஆகத் தேர்ந்தெடுக்கும் வாய்ப்பு மிகவும் குறையும். இதனால் control panel-ல் இருந்து server-ஐ reboot செய்வதற்குப் பதிலாக, அதைச் சரிசெய்ய முடியும். இது kernel தேர்ந்தெடுக்கும் victim-ஐ மட்டுமே மாற்றும். Stall நீடிக்கும் நேரத்தை இது குறைக்காது.
Containers தங்களுக்கென தனிப்பட்ட cgroups-ல் இயங்குகின்றன. இவற்றை உங்கள் unit files உருவாக்குவதில்லை; container runtime உருவாக்குகிறது. எனவே docker.service-க்கு அமைக்கும் limit, ஒரு container-க்கான limit ஆகாது. MemoryMax= மற்றும் CPUQuota=-ன் container-தனிப்பட்ட equivalents, Docker Compose-ல் memory மற்றும் CPU limits அமைத்தல் பகுதியில் விளக்கப்பட்டுள்ளன.
FAQ
runaway process-ஐ kill செய்வதற்குப் பதிலாக எனது VPS ஏன் உறைந்து (freeze) போகிறது?
ஏனெனில், ஒரு செயல்முறை எவ்வளவு நேரம் எடுத்துக்கொள்கிறது என்பதை விட, reclaim பக்கங்களை (pages) திரும்பப் பெறுகிறதா என்பதை வைத்தே kernel முன்னேற்றத்தை மதிப்பிடுகிறது. நினைவகம் குறைவாக இருக்கும்போது, அது page cache-ஐ வெளியேற்றும்; இதில் இயங்கும் நிரல்களின் executable பக்கங்களும் அடங்கும். அடுத்த கட்டளையின்போது அவை மீண்டும் படிக்கப்படும். சேமிப்பகத்திற்காக அனைத்தும் காத்திருக்கும், தொழில்நுட்ப ரீதியாக எந்த ஒதுக்கீடும் (allocation) தோல்வியடையாது, எனவே OOM killer அழைக்கப்படாது. இது நடக்கும்போது /proc/pressure/memory-ஐச் சரிபார்க்கவும்: full avg10 40-க்கு மேல் இருந்தால், கடந்த பத்து வினாடிகளில் 40%-க்கும் அதிகமான நேரம், idle-ஆக இல்லாத அனைத்து பணிகளும் ஒரே நேரத்தில் நினைவகத்திற்காகத் தங்கியிருந்தன என்று அர்த்தம். earlyoom போன்ற userspace daemon, அந்த நிலையை அடைவதற்கு முன்பே செயல்முறையை நிறுத்திவிடும்.
MemoryHigh மற்றும் MemoryMax-க்கு இடையே உள்ள வேறுபாடு என்ன?
MemoryHigh= என்பது வேகத்தைக் கட்டுப்படுத்தும் ஒரு soft cap ஆகும். kernel அந்த unit-லிருந்து கடுமையாக reclaim செய்யும் மற்றும் அதன் ஒதுக்கீடுகளை மெதுவாக்கும், ஆனால் பயன்பாடு அந்த எண்ணை விட அதிகமாகலாம், எதுவும் kill செய்யப்படாது. MemoryMax= என்பது ஒரு hard cap: அதன் கீழ் பூர்த்தி செய்ய முடியாத ஒரு ஒதுக்கீடு ஏற்படும்போது, அந்த unit-ன் சொந்த cgroup-க்குள் OOM killer அழைக்கப்படும். இதனால், கணினியில் உள்ள மிகப்பெரிய செயல்முறைக்கு பதிலாக, சிக்கலை ஏற்படுத்திய செயல்முறை மட்டுமே நிறுத்தப்படும். MemoryHigh=-ஐ MemoryMax=-க்குக் கீழே அமைக்கவும், அவற்றுக்கு இடைப்பட்ட பகுதியை எச்சரிக்கை மண்டலமாகக் கருதவும்.
OOM killer எந்த service-ஐ பாதித்தது என்பதை எப்படிக் கண்டறிவது?
journalctl -k --grep "Killed process" --since "2 hours ago"-ஐ இயக்கவும். Memory cgroup out of memory என்று தொடங்கும் வரி, ஒரு unit அதன் சொந்த MemoryMax=-ஐ எட்டியதைக் குறிக்கிறது, அதேசமயம் வெறும் Out of memory என்பது முழு கணினியிலும் நினைவகம் தீர்ந்துவிட்டதைக் குறிக்கிறது. பிறகு journalctl -u <unit> -n 50-ஐ இயக்கி Failed with result 'oom-kill'-ஐத் தேடவும். உங்கள் server-ல் /var/log/journal இல்லையென்றால், journal RAM-ல் வைக்கப்பட்டிருந்தது மற்றும் reboot-உடன் அந்த ஆதாரங்களும் அழிந்திருக்கும். எனவே, அடுத்த முறை நடப்பதற்கு முன்பே அந்த directory-ஐ உருவாக்கவும்.
சிறிய VPS-ல் swap-ஐச் சேர்க்க வேண்டுமா?
ஒருமுறை ஒதுக்கப்பட்டு மீண்டும் பயன்படுத்தப்படாத cold pages-க்கு சிறிய swap file உதவும். runaway process-க்கு இது உதவாது: இது kill செய்வதைத் தாமதப்படுத்தும், மேலும் குறுகிய கால செயலிழப்பை, உங்களால் லாக்-இன் செய்து சரிசெய்ய முடியாத நீண்ட கால முடக்கமாக மாற்றும். swap-ஐக் குறைவாக வைத்திருங்கள், நீங்கள் இழக்கத் தயாராக இருக்கும் units-ல் MemorySwapMax=0-ஐ அமைக்கவும். இதனால் அவை விரைவில் உச்சத்தை அடையும், மேலும் Restart=on-failure அமைக்கப்பட்டிருந்தால், முக்கியமான services-ன் swap பாதிக்கப்படாமல் இருக்கும்போது அவை தானாகவே மீண்டும் தொடங்கும்.
unit file எழுதாமல் ஒரு கட்டளையை (command) கட்டுப்படுத்த முடியுமா?
ஆம். sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh அந்த வரம்புகளுடன் உங்கள் terminal-ல் ஒரு transient scope-க்குள் கட்டளையை இயக்கும், அது வெளியேறியதும் வரம்புகள் மறைந்துவிடும். systemd.resource-control-ல் உள்ள ஒவ்வொரு பண்பும் -p-க்குப் பிறகு கிடைக்கும், எனவே MemorySwapMax=, TasksMax= மற்றும் CPUWeight= ஆகியவையும் அங்கு வேலை செய்யும். --scope-ஐ நீக்கிவிட்டு, வேலையை background-ல் இயக்கி அதன் வெளியீட்டை journal-ல் பெற --unit=name-ஐச் சேர்க்கவும்.