Jinsi ya Kuweka Kikomo cha RAM na CPU kwa systemd
Zuia mchakato usile VPS nzima kwa kuweka MemoryHigh=512M, MemoryMax=768M, CPUQuota=80% na TasksMax=128 kwenye systemd, kisha soma hitilafu ya OOM.
Kuwekea mchakato kikomo cha kumbukumbu na CPU kwa kutumia systemd drop-in
Unaweka kikomo cha kumbukumbu na CPU kwa mchakato kwenye Linux VPS kwa kuongeza mistari michache kwenye unit inayouendesha mchakato huo. MemoryMax= ni kikomo cha juu cha kumbukumbu. CPUQuota= ni kikomo cha muda wa processor. Vyote vinasimamiwa na cgroup v2 (control groups, version 2), kipengele cha kernel ambacho systemd tayari inakitumia kufuatilia kila huduma kwenye seva.
sudo systemctl edit myapp.serviceHii inafungua faili ya drop-in yenye maelekezo kwenye maoni. Ongeza mistari hii hapo juu:
[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 lazima irudishe namba zako kwa kutumia vipimo vya kernel vyenyewe: MemoryMax=805306368 na CPUQuotaPerSecUSec=800ms. Ikiwa inachapisha MemoryMax=infinity, basi drop-in haikupakiwa. Hakikisha faili imetua kwenye /etc/systemd/system/myapp.service.d/override.conf, na kwamba inaanza na kichwa cha habari cha [Service], kwa sababu mstari wa mipangilio usio na sehemu (section) hapo juu huifanya systemd kuandika Assignment outside of section. Ignoring. kwenye logi na kuanzisha huduma bila vikomo vyovyote.
Sehemu iliyobaki ya mwongozo huu inaelezea jinsi ya kuchagua namba hizo, na nini kinaweza kwenda vibaya baada ya kuwekwa.
Kwa nini mchakato unaokimbia bila mpangilio hugandisha VPS hata kama haujajaza kumbukumbu
Mchakato unaofikia kikomo cha kumbukumbu (hard memory cap) hufa ndani ya sekunde moja na huduma huanza upya. Hiyo ndiyo hali nzuri. Hali mbaya ni ile ambapo hakuna kinachokufa: seva inajibu ping, SSH inakubali muunganisho, lakini prompt ya shell haijitokezi. Mashine iko hai na ina shughuli nyingi, lakini hakuna kazi yoyote inayofanyika.
Huu hapa ni utaratibu wake, kwa sababu si dhahiri. Kumbukumbu ya bure inapopungua, kernel hurejesha (reclaim) kurasa (pages) badala ya kutoa mpya. Kurasa za bei nafuu zaidi kurejeshwa ni zile zinazotegemea faili, na page cache huhifadhi msimbo wa executable wa kila kitu kinachoendeshwa. Kwa hivyo, kernel huondoa kurasa za maandishi za sshd, na maelekezo yanayofuata ambayo sshd huendesha ni page fault inayolazimika kusoma baiti hizo kutoka kwenye hifadhi. Kila mchakato huishia kusubiri diski badala ya kuendelea. Kurasa zilezile huondoka na kurudi katika mzunguko, hali inayojulikana kama thrashing.
Mambo mawili hufanya hali hii kuwa mbaya zaidi kwenye VPS kuliko kwenye laptop. Hifadhi mara nyingi huunganishwa kupitia mtandao au inashirikiwa, kwa hivyo kila fault hugharimu milisekunde nyingi zaidi kuliko kifaa cha ndani cha NVMe. Na kernel haipimi muda, inapima kushindwa: mradi tu urejeshaji unaendelea kutoa ukurasa, hata kwa polepole, kernel huamini kuwa inapiga hatua na haitoi amri ya out of memory (OOM) killer. Sanduku linaweza kukaa katika hali hiyo kwa dakika nyingi kabla ya kitu chochote kuuawa.
Unaweza kutazama hali hii ikitokea. Kernel hutoa taarifa za pressure stall information (PSI) kwenye Linux 4.20 na matoleo mapya zaidi:
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=9114233Mstari wa full ndio muhimu. full avg10=48.15 inamaanisha kuwa kwa 48% ya sekunde kumi zilizopita, kazi zote zisizo na kazi (non-idle tasks) kwenye seva zilikuwa zimekwama kwenye kumbukumbu kwa wakati mmoja, kwa hivyo hakuna kazi yako iliyokuwa ikipiga hatua. Seva yenye afya husoma karibu na sifuri kwenye full. Zaidi ya 10 huhisiwa kuwa polepole na binadamu, na 40 au zaidi ndiyo hali ambayo watu huielezea kama kuganda.
Hii ndiyo sababu kikomo pekee si ahadi. Kitengo kinachoshikiliwa chini ya MemoryHigh= hupunguzwa kasi badala ya kuuawa, kwa hivyo kinabaki hai na kinabaki polepole, na hakuna kinachokianzisha upya kwa sababu kwa mtazamo wa systemd hakijawahi kushindwa. Kitengo kilichowekewa kikomo ambacho bado kinaruhusiwa kutumia swap huzalisha usomaji na uandikaji unaotozwa kwa kitengo hicho lakini hufanywa na kifaa kimoja kinachoshirikiwa, kwa hivyo kinaweza kupandisha /proc/pressure/io kwa kila huduma nyingine kwenye seva. Vikomo huamua nani atalipia uhaba, na haviwezi kuongeza uwezo wa mfumo.
Thibitisha kuwa VPS yako inaendesha cgroup v2
stat -fc %T /sys/fs/cgroupcgroup2fs ni mfumo wa uongozi uliounganishwa, ambao mipangilio ya kumbukumbu hapa chini inahitaji. tmpfs inamaanisha kuwa seva iliwaka kwa kutumia mpangilio wa zamani wa v1, ambapo MemoryHigh= na MemorySwapMax= hazitumiki na tabia ya OOM kwa kila unit ni tofauti, ingawa CPUQuota= bado inafanya kazi hapo kupitia faili la zamani la cpu.cfs_quota_us. Ubuntu 22.04 na matoleo mapya zaidi, pamoja na Debian 11 na matoleo mapya zaidi, hutumia v2 kwa chaguo-msingi. Image ya zamani haitumii, na kwenye systemd 255 au ya zamani zaidi, kernel iliyowaka na systemd.unified_cgroup_hierarchy=0 pia haitumii. systemd 256 na 257 hukataa kuwaka chini ya v1 isipokuwa SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 pia iko kwenye mstari wa amri wa kernel. systemd 258 iliondoa usaidizi wa cgroup v1 na huweka mfumo wa uongozi uliounganishwa wakati wa kuwaka, kwa hivyo kwenye matoleo yanayokuja na toleo hilo, hakuna hoja inayorejesha v1.
Kwenye cgroup v2, systemd huwasha uhasibu wa kumbukumbu kwa kila unit kwa chaguo-msingi, kwa hivyo namba hizo tayari zipo:
systemd-cgtop -mHiyo huorodhesha cgroups zilizopangwa kulingana na matumizi ya kumbukumbu, ambayo ndiyo njia ya haraka zaidi ya kujibu "nini kinakula seva hii" wakati bado inaweza kujibu. Ikiwa seva ni mpya, kazi ya akaunti na firewall katika dakika kumi za kwanza kwenye VPS mpya inatangulia hatua hii.
MemoryHigh hupunguza kasi. MemoryMax huua mchakato.
Tofauti kati ya mipangilio hii miwili ya kumbukumbu huamua jinsi hitilafu inavyoonekana.
MemoryHigh=ni kikomo laini (soft cap). Ikiwa matumizi yatazidi hapo, kernel itarejesha kumbukumbu kwa nguvu kutoka kwa cgroup hiyo na kupunguza kasi ya ugawaji wa kumbukumbu kwa makusudi. Matumizi yanaweza bado kuzidi namba hiyo, na hakuna mchakato unaouawa.MemoryMax=ni kikomo kigumu (hard cap). Wakati ugawaji wa kumbukumbu hauwezi kutimizwa ndani ya kikomo hicho, OOM killer huanza kufanya kazi ndani ya cgroup hiyo na kuua mchakato mmoja wa kitengo hicho.
Nusu ya pili ndiyo sababu kuu ya kuweka MemoryMax= kwenye kitu chochote ambacho hukiamini kikamilifu. Bila kikomo, uhaba wa kumbukumbu huwa tatizo la seva nzima, na OOM killer ya kimataifa huchagua mwathiriwa wake kulingana na oom_score, ambayo mara nyingi inamaanisha mchakato mkubwa zaidi. Mchakato mkubwa zaidi kwa kawaida ni database yako, si script iliyovujisha kumbukumbu. Kwa kikomo, mauaji hutokea ndani ya kitengo kilichosababisha tatizo.
Weka zote mbili, huku MemoryHigh= ikiwa asilimia 20 hadi 30 chini ya MemoryMax=. Pengo hilo ni eneo la onyo: uvujaji wa polepole huvuka High na kuonekana kama huduma iliyopungua kasi, wakati ongezeko la ghafla hupita moja kwa moja kupitia Max na kufa.
Thamani za asilimia husomwa kulingana na kumbukumbu halisi iliyopo (physical memory), kwa hivyo MemoryMax=25% kwenye mpango wa 4 GB ni 1 GB na inabaki kuwa robo ya seva baada ya kubadilisha ukubwa wa mpango wako. MemorySwapMax=0 huizuia kitengo hicho kutumia swap kabisa, kwa hivyo kinapofika MemoryMax=, mauaji hutokea haraka badala ya kusubiri baada ya muda mrefu wa kutumia swap. Chini ya hatua hiyo, MemoryHigh= bado inaweza kupunguza kasi yake, na kuvuka kikomo cha juu hakusababishi OOM killer, kwa hivyo kitengo kinachozunguka kati ya viwili hivyo hubaki na kasi ndogo badala ya kufa.
Huduma chache hukuruhusu kuamua mahitaji yake mapema badala ya kuyapima: kitengo cha Ollama hupanga ukubwa wa KV cache yake kutoka kwa context window unayoiweka, kwa hivyo soma gharama ya kuongeza num_ctx kwenye RAM kabla ya kuchagua kikomo cha kitengo hicho.
Kikomo kinahitaji sera ya kuanzisha upya (restart policy) karibu nacho, vinginevyo mauaji yatakuacha na huduma iliyosimama.
[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Restart=on-failure
RestartSec=5sStartLimit* inapaswa kuwekwa kwenye [Unit] na Restart= kwenye [Service]. Ukiweka mojawapo kwenye sehemu isiyo sahihi, systemd itaipuuza. Kuanzisha upya mara tano ndani ya dakika tano ni uvujaji badala ya tatizo la muda mfupi, kwa hivyo baada ya hapo systemd huacha na kukiacha kitengo kikiwa kimefeli, hali ambayo unataka kuikuta baadaye badala ya crash loop inayoficha tatizo.
Punguza matumizi ya CPU kwa CPUQuota, au igawane kwa kutumia CPUWeight
CPUQuota= huchukua asilimia ya muda unaopatikana kwenye CPU moja. CPUQuota=50% ni nusu ya core moja. CPUQuota=200% ni sawa na core mbili, ambazo kitengo kinaweza kuzisambaza kwenye threads nyingi kadiri kinavyotaka. Kwenye mpango wa 2 vCPU, CPUQuota=200% ni mashine nzima.
CPUWeight= ni chaguo bora zaidi kwa huduma nyingi. Hii ni sehemu ya uwiano kuanzia 1 hadi 10000, na thamani ya msingi ya kernel ni 100. Inafanya kazi tu wakati kuna ushindani: kazi ya backup iliyowekwa kwenye CPUWeight=20 itapisha web server iliyo kwenye 100 wakati wa msongamano, na bado itatumia mashine nzima wakati haina kazi. Quota ngumu hupoteza uwezo huo wa ziada.
Kuwa mkweli kuhusu faida unayopata kwa kuweka kikomo cha CPU. Mchakato unaotumia CPU nyingi mara chache husababisha Linux kuganda, kwa sababu scheduler huendelea kutoa muda kwa kila mchakato. Kumbukumbu (RAM) ndiyo inayoweza kuangusha seva. Tumia CPUQuota= unapotaka kikomo kinachotabirika, kwa mfano kwenye kazi ya build au agent ambayo ingeweza kufanya kazi kwa kasi ya juu kwa saa nzima. Kupima ukubwa wa kazi ya aina hiyo ni swali tofauti, linalojadiliwa katika kiasi gani cha RAM na CPU ambacho VPS ya coding agent inahitaji.
Ikiwa CPU inaonekana kuwa na shughuli nyingi wakati hakuna mchakato wako unaofanya kazi kubwa, sababu inaweza kuwa upande mwingine wa hypervisor. Hiyo ni CPU steal time kutoka kwa jirani mwenye kelele, na hakuna quota utakayoweka itakayobadilisha hali hiyo.
TasksMax inazuia fork loop
TasksMax= ni idadi ya processes na threads ambazo unit inaweza kuwa nazo. Threads huhesabiwa, kwa hivyo huduma ya Java au Go inahitaji nafasi kubwa zaidi kuliko inavyoonekana kwenye orodha ya processes. Hii ndiyo njia rahisi zaidi ya kujilinda dhidi ya script inayofanya fork kwenye loop, kwa sababu fork inafeli ndani ya unit badala ya seva kuishiwa na process IDs.
TasksMax=128Wakati unit inapofikia kikomo hiki, kernel huandika mstari kwenye logi unaotaja cgroup husika:
cgroup: fork rejected by pids controller in /system.slice/myapp.serviceProgramu yenyewe kwa kawaida huripoti fork: retry: Resource temporarily unavailable. Angalia kile ambacho meneja hutumia kwa chaguo-msingi kwa kutumia systemctl show -p DefaultTasksMax.
Kuwekea kikomo kazi ya mara moja kwa kutumia systemd-run
Hauhitaji faili ya unit ili kutumia haya yote. systemd-run hutengeneza unit ya muda mfupi kuzunguka amri moja.
sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh--scope huendesha amri hiyo kwenye terminal yako, baada ya kuchapisha Running scope as unit: run-r7c1a....scope. Matokeo hubaki kwenye skrini yako na vikomo hivyo hupotea wakati amri inapomaliza kufanya kazi. Sifa yoyote kutoka systemd.resource-control hufanya kazi baada ya -p.
Kwa kazi ndefu, ondoa --scope na uipe jina. Kisha huendesha kwa nyuma kama huduma ya muda mfupi na kuandika kumbukumbu kwenye journal:
sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -fChaguzi zilezile hufanya kazi na --user wakati wewe si root, ingawa meneja wa mtumiaji wako anayo tu vidhibiti vilivyokabidhiwa kwake, kwa hivyo sifa inaweza kukataliwa hapo. Iendeshe na sudo ikiwa hilo litatokea. Wakati kazi inapopata makazi ya kudumu, mipangilio huhamia bila kubadilika kwenda kwenye unit halisi: angalia kuendesha script kama systemd service na timer.
Swali la swap, limejibiwa kwa uaminifu
Swap hubadilisha namna ya kutokea kwa hitilafu badala ya kuizuia.
Bila swap, leak ikifika ukomo wa kumbukumbu, kitu fulani hufa ndani ya sekunde chache. Hitilafu hiyo huwa ya ghafla, fupi, na rahisi kusomeka kwenye journal baadaye. Ukiwa na swap, kernel huandika kurasa za kumbukumbu zisizotumika (cold anonymous pages) kwenye diski na kupata muda zaidi. Ikiwa mchakato ulikuwa unakaribia kutulia, swap itakuokoa. Ikiwa mchakato unakimbia bila kudhibitiwa (runaway), swap hubadilisha hitilafu ya sekunde tano kuwa kukwama kwa dakika ishirini, na kukwama huko ni kubaya zaidi, kwa sababu mchakato uliokufa bado hukuacha na shell inayofanya kazi, wakati seva inayopata thrashing haifanyi kazi.
swapon --show
free -hNjia ya kati inayofaa kwenye VPS ndogo: weka swap file ya wastani kwa ajili ya kurasa zinazotengwa mara moja na kutotumiwa tena, na uweke MemorySwapMax=0 kwenye vitengo (units) ambavyo uko tayari kupoteza. Huduma muhimu hubaki na swap yao. Huduma zisizotabirika hugonga ukuta haraka, na sera ya kuanzisha upya (restart policy) iliyo karibu na kikomo chao huirudisha huduma hiyo.
Kupunguza vm.swappiness ni njia dhaifu, na ni muhimu kujua kwa nini. Inabadilisha tu uwiano kati ya kuondoa page cache na kufanya swap ya anonymous pages, na zote mbili hugharimu usomaji wa diski baadaye. Inabadilisha ni kurasa zipi zinazopata thrashing, si kama seva itapata thrashing au la.
Daemon ya OOM ya mapema huua kabla ya kukwama
Kernel husubiri hadi mchakato wa reclaim ushindwe kabisa, na kwenye VPS ndogo, muda huo wa kusubiri ndio wakati hasa unapopoteza uwezo wa kuifikia seva. Daemons mbili za userspace hufunga mwanya huu kwa kufuatilia kumbukumbu wenyewe na kuua michakato mapema zaidi.
earlyoom hukagua kumbukumbu inayopatikana na swap ya bure hadi mara kumi kwa sekunde, na huua mchakato wenye oom_score ya juu zaidi pale tu zote mbili zinaposhuka chini ya viwango vyake vilivyowekwa. Kwenye mashine isiyo na swap, kiwango cha kumbukumbu pekee ndicho huamua.
sudo apt install earlyoom
systemctl status earlyoomKifurushi cha Debian na Ubuntu huanzisha huduma hii wakati wa usakinishaji. Chaguzi zake hukaa ndani ya /etc/default/earlyoom:
EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"-m PERCENT huweka kiwango cha chini cha kumbukumbu inayopatikana na -s PERCENT huweka kiwango cha chini cha swap ya bure, zote zikiwa na asilimia 10 kwa chaguomsingi. Nambari ya pili katika kila jozi ni sehemu ya SIGKILL: earlyoom hutuma SIGTERM pindi kumbukumbu na swap zote zinaposhuka chini ya thamani zao za kwanza, kisha SIGKILL pindi zote zinaposhuka chini ya thamani ya pili, ambayo kwa chaguomsingi ni nusu ya ile ya kwanza. Systemd hupitisha kigezo hiki kwa earlyoom kama $EARLYOOM_ARGS, hivyo systemd hugawanya kigezo hicho kuwa hoja (arguments) kwenye nafasi nyeupe (whitespace). Kuweka alama za kunukuu (quotes) kwenye mifumo ya --avoid na --prefer ni salama: systemd huondoa alama za kunukuu za nje (double quotes) inaposoma faili, kisha huheshimu na kuondoa alama za kunukuu za ndani (single quotes) inapoigawanya, hivyo --avoid '^(sshd|systemd)$' hufanya kazi sawa na fomu isiyo na alama za kunukuu hapo juu. Mfumo wenye nafasi (space) unahitaji alama hizo za kunukuu za ndani, vinginevyo utagawanywa kuwa hoja mbili. Tekeleza mabadiliko kwa sudo systemctl restart earlyoom, na usome journalctl -u earlyoom ili kuona ni mchakato gani uliouawa na ni kiasi gani cha kumbukumbu mchakato huo ulikuwa unatumia.
systemd-oomd ndiyo chaguo jingine. Ukurasa wake wa mwongozo (manual page) unaielezea kama "huduma ya mfumo inayotumia cgroups-v2 na pressure stall information (PSI) kufuatilia na kuchukua hatua za kurekebisha kabla ya OOM kutokea katika nafasi ya kernel". Inafanya kazi kwenye cgroups nzima badala ya michakato ya mtu mmoja mmoja, hivyo huua unit nzima, si mtoto (child) aliyepotea. Units hujiunga na huduma hii kwa ManagedOOMMemoryPressure=kill au ManagedOOMSwap=kill, na viwango vya ukomo (thresholds) hukaa ndani ya /etc/systemd/oomd.conf.
systemctl status systemd-oomd
oomctloomctl huchapisha kile inachofuatilia kwa sasa, ambacho mara nyingi huwa hakuna kitu kwenye image ya seva, kwa sababu mpangilio huu unahitaji kujiunga (opt-in) kwa kila unit. Chagua daemon moja na uishie hapo. Kuendesha zote mbili kunamaanisha vitu viwili vinashindana kuchagua mhanga, na sababu ya mauaji yoyote inakuwa ngumu zaidi kuijua.
Ni kitengo kipi kilichohusika?
Anza na kernel, kwa sababu inarekodi kila mchakato inaouua.
journalctl -k --grep "Killed process" --since "2 hours ago"Uuaji kutoka kwa OOM killer wa mfumo mzima huonekana hivi:
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 ni kumbukumbu ya anonymous, kama vile heap, ambayo mchakato ulikuwa nayo kwenye RAM wakati unakufa, takriban 1.8 GB hapa. Resident file mappings na shared memory huhesabiwa kando, kama file-rss na shmem-rss. Soma jina lililo kwenye mabano kwa tahadhari. Huyo ndiye mwathiriwa aliyechaguliwa na kernel, na kernel huchagua mchakato mkubwa zaidi, ambao si mara zote ndio uliosababisha uhaba wa kumbukumbu.
Uuaji kutoka kwa kikomo cha cgroup huwa na kiambishi tofauti, na ripoti iliyochapishwa juu yake hutaja cgroup iliyofikia ukomo wake:
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:0Kiambishi hicho ndicho kiini cha utambuzi. Memory cgroup out of memory inamaanisha kitengo kimoja kilifikia MemoryMax= uliyokipa na sehemu nyingine ya seva ilikuwa sawa. Out of memory ya kawaida inamaanisha mashine nzima iliishiwa na rasilimali, kwa hivyo mipaka yako ilikuwa haipo au ilikuwa kubwa mno kiasi kwamba haikusaidia.
Kisha uliza systemd kile ilichokiona:
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 inasema kitu kilekile kwenye mstari mmoja, kama Active: failed (Result: oom-kill).
Kaunta za cgroup ndizo chanzo cha tatu, na ndizo pekee zinazorekodi throttling, ambayo haitoi ujumbe wowote kwenye 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 huhesabu mara ngapi kitengo kilisukumwa zaidi ya MemoryHigh= na kupata throttling. max huhesabu mara ngapi kilifikia kikomo kigumu (hard cap), na oom_kill huhesabu michakato iliyouawa kweli. high kubwa ikiwa na oom_kill 0 ni kisa cha kimya kilichotajwa awali: tangu cgroup yake ilipoundwa, kitengo hicho kimekuwa kikipata throttling mara kwa mara bila hata mchakato mmoja kuuawa, kwa hivyo systemd haijarekodi hitilafu yoyote. Kaunta hukua tu, kwa hivyo isome mara mbili kwa muda wa dakika moja: high inayozidi kupanda inamaanisha throttling inatokea sasa. memory.peak (Linux 5.19 na mpya zaidi) huhifadhi matumizi ya juu zaidi ambayo cgroup ilifikia, ambayo ndiyo namba ya kutumia kupima MemoryMax=. Faili zote mbili hurejeshwa kwenye sifuri wakati kitengo kinapoanzishwa upya, kwa sababu systemd huunda cgroup hiyo tena.
Sharti moja la msingi lipo chini ya yote haya. Ikiwa /var/log/journal haipo, journal hukaa kwenye RAM, na kila mstari hupotea baada ya reboot uliyohitaji ili kuirejesha seva.
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-bootsjournalctl --list-boots inayoonyesha zaidi ya boot ya sasa inamaanisha historia sasa inahifadhiwa, kwa hivyo journalctl -k -b -1 inaweza kukuonyesha ujumbe wa kernel kutoka kwa boot iliyokufa.
Sehemu ya kuanzia kwa VPS ndogo
Kwenye mpango wa 2 GB, acha 300 hadi 400 MB kwa ajili ya kernel na page cache, na usiruhusu jumla ya mipaka (caps) ifikie 2 GB kamili, kwa sababu kila kitengo kinaweza kufikia kilele cha matumizi kwa wakati mmoja. Ipe huduma muhimu sehemu kubwa zaidi, kisha wekea mipaka huduma zote zisizo za lazima zinazoizunguka.
[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5sKuweka njia ya kuingia ni muhimu kwa mpangilio mmoja zaidi. OOMScoreAdjust=-500 katika faili ya drop-in ya ssh.service hufanya OOM killer wa mfumo mzima kuwa na uwezekano mdogo sana wa kuchagua SSH daemon yako kama mwathiriwa, jambo ambalo ni tofauti kati ya kurekebisha seva na kuianzisha upya kutoka kwenye control panel. Hii inabadilisha tu chaguo la kernel la nani wa kumuua. Haifupishi muda wa kukwama kwa mfumo.
Containers huendeshwa katika cgroups zao wenyewe, zilizoundwa na container runtime badala ya unit files zako, kwa hivyo kikomo kwenye docker.service hakigeuki kuwa kikomo cha container moja. Mambo yanayolingana na MemoryMax= na CPUQuota= kwa kila container yamefafanuliwa katika kuweka mipaka ya kumbukumbu na CPU katika Docker Compose.
FAQ
Kwa nini VPS yangu iliganda badala ya kuua mchakato uliopitiliza?
Kwa sababu kernel hupima maendeleo kwa kuangalia kama reclaim inarejesha kurasa za kumbukumbu, si kwa muda unaotumika. Wakati kumbukumbu ni haba, kernel huondoa page cache, ikiwemo kurasa za programu zinazoendelea, kisha huzisoma tena wakati wa maelekezo yanayofuata. Kila kitu husubiri hifadhi na hakuna allocation iliyoshindwa kitaalamu, kwa hivyo OOM killer haianzishwi. Chunguza /proc/pressure/memory wakati tatizo linatokea: full avg10 inayozidi 40 inamaanisha kuwa kwa zaidi ya 40% ya sekunde kumi zilizopita, kila task isiyo idle ilikuwa imekwama kwenye kumbukumbu kwa wakati mmoja. Daemon ya userspace kama earlyoom huua mchakato kabla ya seva kufikia hali hiyo.
Kuna tofauti gani kati ya MemoryHigh na MemoryMax?
MemoryHigh= ni kikomo laini (soft cap) kinachopunguza kasi. Kernel hufanya reclaim kwa nguvu kutoka kwa unit hiyo na kupunguza kasi ya allocation zake, lakini matumizi yanaweza kuzidi namba hiyo na hakuna kinachouawa. MemoryMax= ni kikomo kigumu (hard cap): allocation isiyoweza kutimizwa chini ya kikomo hiki huita OOM killer ndani ya cgroup ya unit hiyo, hivyo mchakato uliosababisha tatizo ndio unaokufa badala ya mchakato mkubwa zaidi kwenye seva. Weka MemoryHigh= chini ya MemoryMax= na chukulia pengo kati yao kama eneo la onyo.
Ninawezaje kujua ni huduma gani iliyopigwa na OOM killer?
Endesha journalctl -k --grep "Killed process" --since "2 hours ago". Mstari unaoanza na Memory cgroup out of memory unamaanisha unit moja iligonga MemoryMax= yake yenyewe, wakati Out of memory ya kawaida inamaanisha mashine nzima iliishiwa na kumbukumbu. Kisha endesha journalctl -u <unit> -n 50 na utafute Failed with result 'oom-kill'. Ikiwa /var/log/journal haipo kwenye seva yako, journal ilikuwa imehifadhiwa kwenye RAM na ushahidi ulipotea wakati wa reboot, kwa hivyo tengeneza saraka hiyo kabla ya tukio lijalo.
Je, niongeze swap kwenye VPS ndogo?
Swap file ndogo husaidia na kurasa baridi (cold pages) ambazo hutengwa mara moja na haziguswi tena. Haikusaidii na mchakato uliopitiliza: inachelewesha kifo cha mchakato na kubadilisha kukatika kwa muda mfupi na kukwama kwa muda mrefu ambako huwezi kuingia ili kurekebisha. Weka swap kwa kiasi kidogo, na uweke MemorySwapMax=0 kwenye unit ambazo uko tayari kupoteza, ili zifikie kikomo chake haraka na, kwa Restart=on-failure iliyowekwa, zijianzishe zenyewe wakati huduma muhimu zikibaki na swap yao.
Je, ninaweza kuzuia amri bila kuandika unit file?
Ndiyo. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh huendesha amri kwenye terminal yako ndani ya transient scope yenye vikomo hivyo, na vikomo hivyo hupotea inapotoka. Kila sifa kutoka systemd.resource-control inapatikana baada ya -p, kwa hivyo MemorySwapMax=, TasksMax= na CPUWeight= hufanya kazi huko pia. Ondoa --scope na uongeze --unit=name ili kuendesha kazi hiyo kwa nyuma (background) huku matokeo yake yakiwa kwenye journal.