SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-30

Paano Limitahan ang Memory at CPU sa systemd

Alamin kung bakit puwedeng mag-freeze ang VPS kahit capped ang process, at paano itakda ang MemoryHigh, MemoryMax, CPUQuota at TasksMax sa systemd unit.

Limitahan ang memory at CPU ng process gamit ang systemd drop-in

Nililimitahan mo ang memory at CPU ng process sa Linux VPS sa pamamagitan ng pagdaragdag ng ilang linya sa unit na nagpapatakbo sa process. Ang MemoryMax= ang hard ceiling ng memory. Ang CPUQuota= ang ceiling ng processor time. Pareho itong ipinapatupad ng cgroup v2 (control groups, version 2), ang kernel feature na ginagamit na ng systemd para subaybayan ang paggamit ng bawat service sa server.

sudo systemctl edit myapp.service

Binubuksan nito ang drop-in file na may mga instruction sa comments. Idagdag ito sa itaas ng mga iyon:

[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

Dapat ulitin ng systemctl show ang iyong mga numero gamit ang sariling units ng kernel: MemoryMax=805306368 at CPUQuotaPerSecUSec=800ms. Kung MemoryMax=infinity ang i-print nito, hindi na-load ang drop-in. Suriing nasa /etc/systemd/system/myapp.service.d/override.conf ang file at nagsisimula ito sa [Service] header, dahil kapag walang section sa itaas ng isang settings line, ila-log ng systemd ang Assignment outside of section. Ignoring. at sisimulan nito ang service nang walang anumang limitasyon.

Ipinapaliwanag ng natitirang bahagi ng guide na ito kung paano piliin ang mga numerong iyon at kung ano pa rin ang maaaring magkamali kapag naitakda na ang mga ito.

Bakit nagfi-freeze ang isang VPS dahil sa runaway process kahit hindi nito nauubos ang memory

Ang process na tumama sa hard memory cap ay namamatay makalipas ang humigit-kumulang isang segundo at nagre-restart ang service. Iyan ang mabuting sitwasyon. Ang masamang sitwasyon ay kapag walang namamatay: sumasagot ang box sa ping, tinatanggap ng SSH ang connection, pero hindi lumalabas ang shell prompt. Buhay at abala ang machine, ngunit walang silbi ang ginagawa nito.

Narito ang mekanismo, dahil hindi ito agad halata. Kapag kumokonti ang free memory, nagre-reclaim ng pages ang kernel sa halip na mamigay ng bago. Ang pinakamadaling i-reclaim ay ang file-backed pages, at nasa page cache ang executable code ng lahat ng tumatakbong process. Kaya ine-evict ng kernel ang text pages ng sshd, at ang susunod na instruction na tatakbo, sshd, ay nagdudulot ng page fault na kailangang basahin muli ang mga byte na iyon mula sa storage. Nauuwi sa paghihintay sa disk ang bawat process sa halip na tumakbo. Paulit-ulit na umaalis at bumabalik ang parehong pages. Tinatawag itong thrashing.

Dalawang bagay ang nagpapalala nito sa VPS kumpara sa laptop. Madalas na network-attached o shared ang storage, kaya mas maraming milliseconds ang inaabot ng bawat fault kaysa sa local NVMe device. At hindi oras ang sinusukat ng kernel; failure ang sinusukat nito. Hangga't nakakapagbalik ng page ang reclaim, gaano man ito kabagal, ipinapalagay ng kernel na umuusad ito at hindi nito tinatawag ang out of memory (OOM) killer. Maaaring manatili ang box sa ganitong kalagayan nang maraming minuto bago may mapatay.

Maaari mong obserbahan habang nangyayari ito. Nag-e-export ang kernel ng pressure stall information (PSI) sa Linux 4.20 at mas bago:

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

Ang linyang full ang mahalaga. Ibig sabihin ng full avg10=48.15 na sa 48% ng nakaraang sampung segundo, lahat ng non-idle task sa box ay sabay-sabay na naka-stall dahil sa memory, kaya walang umuusad sa iyong trabaho. Ang isang healthy server ay karaniwang malapit sa zero ang full. Kapag lampas 10, mararamdaman ng user na mabagal ito. Kapag 40 o higit pa, ito ang kalagayang inilalarawan ng mga tao bilang frozen.

Ito rin ang dahilan kung bakit hindi sapat na may limit lamang. Ang unit na sakop ng MemoryHigh= ay tina-throttle sa halip na patayin, kaya nananatili itong buhay at mabagal. Hindi rin ito nire-restart dahil sa pananaw ng systemd, hindi naman ito nag-fail. Ang capped unit na pinapayagang gumamit pa rin ng swap ay bumubuo ng reads at writes na sinisingil sa unit na iyon ngunit pinoproseso ng iisang shared device. Dahil dito, maaari nitong pataasin ang /proc/pressure/io para sa lahat ng iba pang service sa box. Tinutukoy ng limits kung sino ang sasagot sa gastos ng kakulangan, ngunit hindi ito makakalikha ng capacity.

Tiyaking gumagamit ang iyong VPS ng cgroup v2

stat -fc %T /sys/fs/cgroup

cgroup2fs ang unified hierarchy na kailangan ng mga memory setting sa ibaba. Ibig sabihin ng tmpfs ay nag-boot ang server gamit ang mas lumang v1 layout, kung saan hindi sinusuportahan ang MemoryHigh= at MemorySwapMax= at iba ang OOM behavior sa bawat unit, bagama't gumagana pa rin doon ang CPUQuota= gamit ang legacy na cpu.cfs_quota_us file. Bilang default, gumagamit ng v2 ang Ubuntu 22.04 at mas bagong bersyon, pati ang Debian 11 at mas bagong bersyon. Hindi ito ginagawa ng lumang image. Sa systemd 255 o mas luma, hindi rin gumagamit ng v2 ang kernel na nag-boot gamit ang systemd.unified_cgroup_hierarchy=0. Tumangging mag-boot ang systemd 256 at 257 sa ilalim ng v1 maliban kung kasama rin ang SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 sa kernel command line. Inalis ng systemd 258 ang suporta sa cgroup v1 at palaging mina-mount ang unified hierarchy sa pag-boot. Kaya sa mga release na gumagamit nito, walang argumentong makapagbabalik sa v1.

Sa cgroup v2, awtomatikong ino-on ng systemd ang memory accounting para sa bawat unit. Kaya naroon na ang mga value:

systemd-cgtop -m

Inililista nito ang mga cgroup ayon sa memory use, mula sa pinakamalaki. Ito ang pinakamabilis na paraan para malaman kung ano ang kumokonsumo sa server habang nakakasagot pa ito. Kung bago ang server, unahin ang account at firewall setup sa unang sampung minuto sa bagong VPS bago ito.

MemoryHigh nagti-throttle. MemoryMax pumapatay.

Ang pagkakaiba ng dalawang memory setting ang tumutukoy sa magiging anyo ng failure.

  • Ang MemoryHigh= ay soft cap. Kapag lumampas dito, agresibong nagre-reclaim ang kernel mula sa cgroup na iyon at sinadyang pinapabagal ang mga allocation nito. Maaari pa ring lumampas ang usage sa value, at walang pinapatay.
  • Ang MemoryMax= ay hard cap. Kapag hindi maibigay ang allocation habang nasa ilalim ng limitasyong ito, tatakbo ang OOM killer sa loob ng cgroup na iyon at papatayin ang isa sa mga sariling process ng unit.

Iyan ang tunay na dahilan para magtakda ng MemoryMax= sa anumang hindi mo lubusang pinagkakatiwalaan. Kapag walang cap, nagiging problema ng buong server ang memory shortage, at pinipili ng global OOM killer ang biktima batay sa oom_score, na karaniwang nangangahulugang pinakamalaking process. Kadalasan, ang pinakamalaking process ay ang database mo, hindi ang script na nag-leak. Kapag may cap, sa loob ng unit na naging sanhi ng problema mapupunta ang pagpatay.

Itakda ang dalawa, at panatilihing nasa humigit-kumulang 20 hanggang 30 percent na mas mababa ang MemoryHigh= kaysa sa MemoryMax=. Ang pagitan ay warning zone: kapag mabagal ang memory leak at nalampasan nito ang High, lalabas ito bilang serbisyong bumagal; kapag biglaan ang spike, lampasan nito agad ang Max at mamamatay ang service.

Binabasa ang percentage value batay sa naka-install na physical memory. Kaya ang MemoryMax=25% sa 4 GB plan ay 1 GB, at mananatili itong one-quarter ng server kapag ni-resize mo ang plan. Ganap na inilalayo ng MemorySwapMax=0 ang unit na iyon sa swap. Kaya kapag umabot ito sa MemoryMax=, mabilis na magaganap ang pagpatay sa halip na matapos ang mahabang pagbagal habang gumagamit ng swap. Bago umabot doon, maaari pa rin itong i-throttle ng MemoryHigh=. Ang paglampas sa high limit ay hindi kailanman nagpapatakbo ng OOM killer, kaya ang unit na nananatili sa pagitan ng dalawang limit ay mananatiling mabagal sa halip na mamatay.

May ilang service na hinahayaan kang itakda nang maaga ang memory appetite nito sa halip na sukatin ito. Tinatantiya ng isang Ollama unit ang KV cache nito batay sa context window na ibinigay mo rito. Basahin ang halaga sa RAM ng pagtataas ng num_ctx bago pumili ng ceiling para rito.

Kailangang may restart policy kasabay ng cap. Kung wala, mag-iiwan lamang sa iyo ng stopped service ang pagpatay.

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

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

Ang StartLimit* ay dapat nasa [Unit], at ang Restart= ay dapat nasa [Service]. Kapag inilagay ang alinman sa maling section, hindi ito papansinin ng systemd. Ang limang restart sa loob ng limang minuto ay leak, hindi panandaliang aberya. Pagkatapos nito, susuko ang systemd at iiwan ang unit sa failed state. Iyan ang state na gusto mong makita sa susunod, sa halip na isang crash loop na nagtatago sa problema.

Limitahan ang CPU gamit ang CPUQuota, o hatiin ito gamit ang CPUWeight

CPUQuota= ang gumagamit ng porsiyento ng oras na available sa isang CPU. CPUQuota=50% ang katumbas ng kalahati ng isang core. CPUQuota=200% ang katumbas ng dalawang core, na maaaring ipamahagi ng unit sa kahit ilang thread na kailangan nito. Sa isang 2 vCPU plan, CPUQuota=200% ang buong machine.

CPUWeight= ang mas magandang default para sa karamihan ng mga serbisyo. Isa itong relative share mula 1 hanggang 10000, at 100 ang default ng kernel. May epekto lamang ito kapag may nagkukumpitensiya sa CPU: ang backup job na may CPUWeight=20 ay magbibigay-daan sa web server na may 100 kapag mataas ang load, at magagamit pa rin nito ang buong machine kapag idle ang machine. Sinasayang ng hard quota ang idle capacity na iyon.

Maging tumpak sa pakinabang ng CPU limit. Bihirang mapahinto ng CPU-bound process ang Linux, dahil patuloy na nagbibigay ang scheduler ng oras sa lahat ng proseso. Ang memory ang karaniwang nagpapabagsak sa machine. Gamitin ang CPUQuota= kapag kailangan mo ng predictable ceiling, halimbawa sa build o agent na kung hindi lilimitahan ay tatakbo nang todo sa loob ng isang oras. Ang pag-size ng ganitong workload ay hiwalay na usapin at tinatalakay sa kung gaano karaming RAM at CPU ang kailangan ng coding agent VPS.

Kung mukhang busy ang CPU kahit kaunti lamang ang ginagawa ng mga proseso mo, maaaring nasa kabilang panig ng hypervisor ang sanhi. Ito ang CPU steal time mula sa maingay na katabing tenant, at walang quota na itatakda mo ang makapagbabago rito.

TasksMax pinipigil ang fork loop

Ang TasksMax= ay ang bilang ng mga process at thread na maaaring hawakan ng isang unit. Kasama sa bilang ang mga thread, kaya mas maraming headroom ang kailangan ng Java o Go service kaysa sa ipinapakita ng process list. Ito ang pinakamurang proteksyon laban sa script na patuloy na nagfo-fork sa loop, dahil mabibigo ang fork sa loob ng unit sa halip na maubusan ng process ID ang buong server.

TasksMax=128

Kapag naabot ng isang unit ang limit, nagla-log ang kernel ng linya na naglalaman ng pangalan ng cgroup:

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

Karaniwang nag-uulat ang mismong program ng fork: retry: Resource temporarily unavailable. Suriin kung ano ang default na ipinapatupad ng manager gamit ang systemctl show -p DefaultTasksMax.

Limitahan ang isang one-off job gamit ang systemd-run

Hindi mo kailangan ng unit file para magamit ang mga ito. Gumagawa ang systemd-run ng transient unit para sa isang command.

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

Pinapatakbo ng --scope ang command sa terminal mo matapos ipakita ang Running scope as unit: run-r7c1a....scope. Nanatili sa screen mo ang output, at nawawala ang mga limit kapag natapos ang command. Gumagana ang anumang property mula sa systemd.resource-control pagkatapos ng -p.

Para sa matagal na job, alisin ang --scope at bigyan ito ng pangalan. Tatakbo ito sa background bilang transient service at magla-log sa journal:

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

Gumagana ang parehong option sa --user kapag hindi ka root, pero ang user manager mo ay may mga controller lamang na na-delegate rito, kaya maaaring tanggihan nito ang isang property. Patakbuhin ito gamit ang sudo kapag nangyari iyon. Kapag kailangan na ng permanenteng lugar ang isang job, ilipat nang walang pagbabago ang mga setting sa isang aktuwal na unit: tingnan ang pagpapatakbo ng script bilang systemd service at timer.

Ang tanong tungkol sa swap, tapat na sagot

Binabago ng swap ang anyo ng failure sa halip na pigilan ito.

Kapag walang swap, aabot sa limit ang memory leak at may mamamatay sa loob ng ilang segundo. Maingay at maikli ang outage, at madaling basahin ang nangyari sa journal pagkatapos. Kapag may swap, isinusulat ng kernel sa disk ang mga cold anonymous page at bumibili ito ng oras. Kung magle-level off sana ang proseso, maililigtas ka ng swap. Kung runaway ito, ginagawa ng swap na dalawampung minutong stall ang limang segundong outage, at mas masama ang stall dahil nagbibigay pa rin sa iyo ng gumaganang shell ang patay na proseso, samantalang hindi ito magagawa ng isang box na patuloy na nagta-thrash.

swapon --show
free -h

Isang praktikal na setup para sa maliit na VPS: magpanatili ng katamtamang swap file para sa mga page na isang beses lang ina-allocate at hindi na muling ginagamit, at itakda ang MemorySwapMax=0 sa mga unit na handa mong mawala. Nananatili ang swap ng mahahalagang serbisyo. Mabilis na maaabot ng mga hindi mahulaan ang limit, at ibabalik sila ng restart policy na nakalagay sa tabi ng kanilang cap.

Mahina ang epekto ng pagpapababa sa vm.swappiness, at mahalagang malaman kung bakit. Inililipat lang nito ang balanse sa pagitan ng pag-evict ng page cache at pag-swap ng anonymous page, at parehong mangangailangan ng disk read sa susunod. Binabago nito kung aling mga page ang nagta-thrash, hindi kung magta-thrash ang box.

Pinapatay ng early OOM daemon ang proseso bago ang system stall

Hinihintay ng kernel na tuluyang mabigo ang reclaim. Sa maliit na VPS, ang paghihintay na iyon ang eksaktong panahong nawawala sa iyo ang machine. Isinasara ito ng dalawang userspace daemon sa pamamagitan ng sarili nilang pag-monitor sa memory at mas maagang pagpatay sa proseso.

Sinusuri ng earlyoom ang available memory at free swap nang hanggang sampung beses bawat segundo. Pinapatay nito ang prosesong may pinakamataas na oom_score kapag parehong bumaba sa kani-kanilang threshold ang mga ito. Sa machine na walang swap, memory threshold lamang ang nagpapasya.

sudo apt install earlyoom
systemctl status earlyoom

Awtomatikong sinisimulan ng Debian at Ubuntu package ang service kapag na-install ito. Nasa /etc/default/earlyoom ang mga option nito:

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

Itinatakda ng -m PERCENT ang minimum na available memory, at ng -s PERCENT ang minimum na free swap. Pareho itong 10 porsyento bilang default. Ang ikalawang numero sa bawat pares ang SIGKILL point: nagpapadala ang earlyoom ng SIGTERM kapag parehong mas mababa sa unang value ang memory at swap. Pagkatapos, nagpapadala ito ng SIGKILL kapag parehong mas mababa sa ikalawang value ang mga ito. Bilang default, kalahati ito ng unang value. Ipinapasa ng unit ang variable na ito sa earlyoom bilang $EARLYOOM_ARGS, kaya hinahati ito ng systemd sa mga argument batay sa whitespace. Ligtas na i-quote ang mga pattern na --avoid at --prefer. Inaalis ng systemd ang panlabas na double quotes kapag binabasa nito ang file. Pagkatapos, kinikilala at inaalis nito ang single quotes sa loob ng value habang hinahati ito, kaya pareho ang epekto ng --avoid '^(sshd|systemd)$' at ng form na walang quotes sa itaas. Kung may space ang pattern, kailangan nito ang mga single quote. Kung wala, hahatiin ito sa dalawang argumento. Ilapat ang pagbabago gamit ang sudo systemctl restart earlyoom. Basahin ang journalctl -u earlyoom upang makita kung aling proseso ang pinatay nito at kung gaano karaming memory ang hawak ng prosesong iyon.

Ang systemd-oomd ang isa pang option. Inilalarawan ito ng manual page nito bilang “isang system service na gumagamit ng cgroups-v2 at pressure stall information (PSI) upang mag-monitor at magsagawa ng corrective action bago magkaroon ng OOM sa kernel space.” Kumilos ito sa buong cgroups sa halip na sa mga indibidwal na proseso. Kaya unit ang pinapatay nito, hindi isang hiwalay na child process. Nag-o-opt in ang mga unit gamit ang ManagedOOMMemoryPressure=kill o ManagedOOMSwap=kill. Nasa /etc/systemd/oomd.conf ang mga threshold.

systemctl status systemd-oomd
oomctl

Ipinapakita ng oomctl kung ano ang kasalukuyang mino-monitor nito. Madalas ay wala itong mino-monitor sa server image dahil opt-in ang setting para sa bawat unit. Pumili lamang ng isang daemon at iyon lang ang gamitin. Kapag parehong tumatakbo ang mga ito, parehong mag-uunahan sa pagpili ng victim. Dahil dito, mas mahirap tukuyin kung ano ang dahilan ng pagpatay sa proseso.

Aling unit ang responsable?

Magsimula sa kernel, dahil itinatala nito ang bawat prosesong pinapatay nito.

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

Ganito ang hitsura ng kill mula sa global OOM killer:

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

Ang anon-rss ay ang anonymous memory, gaya ng heap, na hawak ng process sa RAM nang mamatay ito—humigit-kumulang 1.8 GB dito. Hiwalay na binibilang ang resident file mappings at shared memory bilang file-rss at shmem-rss. Basahin nang may pag-iingat ang pangalan sa loob ng bracket. Iyon ang victim na pinili ng kernel. Pinipili ng kernel ang pinakamalaking process, na hindi palaging siyang nagdulot ng kakulangan.

Iba ang prefix kapag cgroup limit ang nagdulot ng kill. Ang report sa itaas nito ang naglalaman ng pangalan ng cgroup na umabot sa sarili nitong limit:

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

Karamihan ng diagnosis ay nasa prefix na iyon. Ibig sabihin ng Memory cgroup out of memory, isang unit ang umabot sa MemoryMax= na itinakda mo at maayos naman ang natitirang bahagi ng server. Ang simpleng Out of memory ay nangangahulugang naubusan ng memory ang buong machine. Ibig sabihin, maaaring walang caps o masyadong mataas ang mga ito kapag pinagsama.

Pagkatapos, tanungin ang systemd kung ano ang nakita nito:

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'.

Ipinapakita ng systemctl status ang parehong impormasyon sa isang linya, bilang Active: failed (Result: oom-kill).

Ang cgroup counters ang ikatlong source. Ito lamang ang nagtatala ng throttling, na hindi kailanman gumagawa ng 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

Binibilang ng high kung ilang beses lumampas ang unit sa MemoryHigh= at na-throttle. Binibilang ng max kung gaano kadalas nitong naabot ang hard cap, at binibilang ng oom_kill ang mga process na aktuwal na pinatay. Ang malaking high na may oom_kill 0 ay ang tahimik na kaso mula kanina: mula nang malikha ang cgroup nito, paulit-ulit nang na-throttle ang unit nang walang kahit isang kill, kaya walang failure na naitala ang systemd. Patuloy lamang tumataas ang counter. Basahin ito nang dalawang beses na may pagitan na isang minuto: ang high na patuloy pang tumataas ay nangangahulugang kasalukuyang nagaganap ang throttling. Nasa memory.peak (Linux 5.19 at mas bago) ang pinakamataas na usage na naabot ng cgroup. Iyon ang numerong gagamitin sa pag-size ng MemoryMax=. Parehong nagre-reset ang dalawang file kapag nag-restart ang unit, dahil nililikha muli ng systemd ang cgroup.

May isang prerequisite na mahalaga sa lahat ng ito. Kung hindi umiiral ang /var/log/journal, nasa RAM ang journal, at mawawala ang bawat line pagkatapos ng reboot na kailangan mo para ma-recover ang server.

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

Ang journalctl --list-boots na nagpapakita ng higit sa kasalukuyang boot ay nangangahulugang nananatili na ang history. Dahil dito, maipapakita ng journalctl -k -b -1 ang mga kernel message mula sa boot na nagdulot ng pagkamatay ng server.

Panimulang punto para sa maliit na VPS

Sa isang 2 GB plan, maglaan ng 300 hanggang 400 MB para sa kernel at page cache. Huwag hayaang umabot sa buong 2 GB ang kabuuan ng mga cap, dahil maaaring mag-peak nang sabay-sabay ang bawat unit. Ilaan ang pinakamalaking bahagi sa pinakamahalagang service, at limitahan ang lahat ng speculative service sa paligid nito.

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

Mahalagang may natitira kang paraan para makapasok sa server. OOMScoreAdjust=-500 sa isang drop-in para sa ssh.service ay lubos na nagpapaliit sa posibilidad na piliin ng global OOM killer ang SSH daemon bilang victim nito. Ito ang maaaring magtakda kung maaayos mo ang server o kailangan mo itong i-reboot mula sa control panel. Binabago lamang nito ang pinipiling victim ng kernel. Hindi nito pinaiikli ang stall.

Tumatakbo ang mga container sa sarili nilang cgroup. Ginagawa ang mga ito ng container runtime, hindi ng iyong unit files. Kaya ang limitasyon sa docker.service ay hindi nagiging limitasyon para sa isang container. Ang katumbas na per-container ng MemoryMax= at CPUQuota= ay ipinaliliwanag sa pagtatakda ng memory at CPU limits sa Docker Compose.

FAQ

Bakit nag-freeze ang VPS ko sa halip na patayin ang runaway process?

Dahil sinusukat ng kernel ang pag-usad batay sa kung nakakapagbalik ng pages ang reclaim, hindi sa kung gaano ito katagal. Kapag kapos ang memory, ine-evict nito ang page cache, kabilang ang executable pages ng mga tumatakbong program, at binabasa muli ang mga ito sa susunod na instruction. Naghihintay ang lahat sa storage at wala pang allocation na teknikal na nag-fail, kaya hindi kailanman tinatawag ang OOM killer. Suriin ang /proc/pressure/memory habang nangyayari ito: ang full avg10 na lampas 40 ay nangangahulugang sa mahigit 40% ng nakaraang sampung segundo, sabay-sabay na na-stall sa memory ang bawat non-idle task. Pinapatay ng userspace daemon gaya ng earlyoom ang process bago umabot ang server sa ganitong estado.

Ano ang kaibahan ng MemoryHigh at MemoryMax?

Ang MemoryHigh= ay soft cap na nagti-throttle. Agresibong nagre-reclaim ang kernel mula sa unit at pinapabagal ang allocations nito, pero maaaring lumampas ang usage sa value at walang pinapatay. Ang MemoryMax= ay hard cap: kapag hindi matugunan ang allocation sa loob nito, tinatawag ang OOM killer sa sariling cgroup ng unit. Dahil dito, ang process na nagdulot ng problema ang namamatay sa halip na ang pinakamalaking process sa server. Itakda ang MemoryHigh= na mas mababa sa MemoryMax= at ituring na warning zone ang pagitan ng mga ito.

Paano ko malalaman kung aling service ang tinamaan ng OOM killer?

Patakbuhin ang journalctl -k --grep "Killed process" --since "2 hours ago". Ang linyang nagsisimula sa Memory cgroup out of memory ay nangangahulugang may unit na tumama sa sarili nitong MemoryMax=, samantalang ang plain na Out of memory ay nangangahulugang naubusan ng memory ang buong machine. Pagkatapos, patakbuhin ang journalctl -u <unit> -n 50 at hanapin ang Failed with result 'oom-kill'. Kung wala ang /var/log/journal sa server mo, nasa RAM ang journal at nawala ang ebidensya kasabay ng reboot. Gawin ang directory na iyon bago ang susunod na insidente.

Dapat ba akong magdagdag ng swap sa maliit na VPS?

Nakakatulong ang maliit na swap file para sa cold pages na isang beses lang ina-allocate at hindi na muling ginagamit. Hindi ito nakakatulong sa runaway process: pinapahaba nito ang oras bago ang kill at pinapalitan ang maikling outage ng mahabang stall na hindi mo maa-access para maayos. Panatilihing katamtaman ang swap, at itakda ang MemorySwapMax=0 sa mga unit na handa mong mawala, upang mabilis nilang maabot ang ceiling. Kapag nakatakda ang Restart=on-failure, makakabalik ang mga ito nang kusa habang nananatili ang swap ng mahahalagang service.

Maaari ko bang limitahan ang isang command nang hindi gumagawa ng unit file?

Oo. Pinapatakbo ng sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh ang command sa terminal mo sa loob ng transient scope na may mga limitasyong iyon, at nawawala ang mga limitasyon kapag natapos ito. Available ang bawat property mula sa systemd.resource-control pagkatapos ng -p, kaya gumagana rin doon ang MemorySwapMax=, TasksMax= at CPUWeight=. Alisin ang --scope at idagdag ang --unit=name upang patakbuhin ang job sa background at ilagay ang output nito sa journal.

Nakatulong ba ang artikulong ito?