SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor · Bijgewerkt 2026-10-28

Geheugen en CPU beperken met systemd

Beperk een systemd-service met MemoryHigh, MemoryMax, CPUQuota en TasksMax. Leer waarom MemoryMax=infinity verschijnt en hoe u een OOM-kill controleert.

Geheugen- en CPU-gebruik van processen beperken met een systemd drop-in

U beperkt het geheugen- en CPU-gebruik van een proces op een Linux VPS door enkele regels toe te voegen aan de unit die het proces uitvoert. MemoryMax= is de harde limiet voor geheugen. CPUQuota= is de limiet voor processortijd. Beide worden afgedwongen door cgroup v2 (control groups, versie 2), de kernel-functionaliteit die systemd al gebruikt om elke service op de server te administreren.

sudo systemctl edit myapp.service

Hiermee opent u een drop-in-bestand met instructies in de vorm van commentaar. Voeg het volgende daarboven toe:

[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 moet uw getallen bevestigen in de eigen eenheden van de kernel: MemoryMax=805306368 en CPUQuotaPerSecUSec=800ms. Als het MemoryMax=infinity weergeeft, is de drop-in niet geladen. Controleer of het bestand op /etc/systemd/system/myapp.service.d/override.conf is opgeslagen en of het begint met de [Service]-header, omdat een instellingsregel zonder sectie erboven ertoe leidt dat systemd Assignment outside of section. Ignoring. logt en de service zonder enige beperkingen start.

De rest van deze handleiding beschrijft hoe u deze getallen kiest en wat er nog mis kan gaan zodra ze zijn ingesteld.

Waarom een op hol geslagen proces een VPS bevriest zonder deze volledig te vullen

Een proces dat een harde geheugenlimiet bereikt, stopt binnen ongeveer een seconde en de service start opnieuw op. Dat is het gunstige scenario. Het ongunstige scenario is dat er niets stopt: de server reageert op ping, SSH accepteert de verbinding, maar de shell-prompt verschijnt nooit. De machine is actief en bezet, maar het werk is niet nuttig.

Dit is het mechanisme, aangezien het niet direct duidelijk is. Wanneer het vrije geheugen laag is, claimt de kernel pagina's terug in plaats van nieuwe toe te wijzen. De goedkoopste pagina's om terug te claimen zijn bestand-gebaseerd, en de page cache bevat de uitvoerbare code van alles wat draait. De kernel verwijdert dus de tekstpagina's van sshd, en de volgende instructie die sshd uitvoert, is een page fault die die bytes terug moet lezen van de opslag. Elk proces wacht uiteindelijk op de schijf in plaats van te draaien. Dezelfde pagina's verlaten het geheugen en komen in een lus terug; dit wordt thrashing genoemd.

Twee factoren maken dit op een VPS erger dan op een laptop. Opslag is vaak netwerkgebonden of gedeeld, waardoor elke fout meer milliseconden kost dan bij een lokaal NVMe-apparaat. Bovendien meet de kernel geen tijd, maar falen: zolang het terugclaimen van een pagina lukt, hoe traag ook, gelooft de kernel dat er vooruitgang wordt geboekt en roept deze de out of memory (OOM) killer niet aan. Een server kan vele minuten in die staat verkeren voordat er iets wordt beëindigd.

U kunt dit proces observeren. De kernel exporteert pressure stall information (PSI) op Linux 4.20 en nieuwer:

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

De regel full is de relevante regel. full avg10=48.15 betekent dat gedurende 48% van de laatste tien seconden alle niet-inactieve taken op de server tegelijkertijd stonden te wachten op geheugen, waardoor er geen vooruitgang werd geboekt. Een gezonde server geeft een waarde dicht bij nul op full. Boven 10 voelt het voor een gebruiker traag aan, en 40 of meer is de staat die mensen omschrijven als bevroren.

Dit is ook de reden waarom een limiet op zichzelf geen garantie is. Een unit die onder MemoryHigh= wordt gehouden, wordt vertraagd in plaats van beëindigd, dus deze blijft actief en traag, en niets start de unit opnieuw op omdat deze vanuit het perspectief van systemd nooit heeft gefaald. Een gelimiteerde unit die nog steeds mag swappen, genereert lees- en schrijfacties die aan die unit worden toegerekend, maar worden afgehandeld door één gedeeld apparaat. Hierdoor kan de waarde van /proc/pressure/io voor elke andere service op de server stijgen. Limieten bepalen wie betaalt voor een tekort, maar ze kunnen geen capaciteit creëren.

Controleer of uw VPS cgroup v2 gebruikt

stat -fc %T /sys/fs/cgroup

cgroup2fs is de uniforme hiërarchie die nodig is voor de onderstaande geheugeninstellingen. tmpfs betekent dat de server is opgestart met de oudere v1-layout, waarbij MemoryHigh= en MemorySwapMax= niet worden ondersteund en het OOM-gedrag per unit anders is, hoewel CPUQuota= daar nog steeds werkt via het legacy cpu.cfs_quota_us-bestand. Ubuntu 22.04 en nieuwer, en Debian 11 en nieuwer, gebruiken standaard v2. Een oude image doet dit niet, en op systemd 255 of ouder geldt dit ook niet voor een kernel die is opgestart met systemd.unified_cgroup_hierarchy=0. systemd 256 en 257 weigeren op te starten onder v1 tenzij SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 ook op de kernel-commandline staat. systemd 258 heeft de ondersteuning voor cgroup v1 verwijderd en koppelt de uniforme hiërarchie altijd aan bij het opstarten, dus op releases die deze versie bevatten, herstelt geen van beide argumenten v1.

Op cgroup v2 schakelt systemd standaard geheugenaccounting in voor elke unit, waardoor de cijfers al beschikbaar zijn:

systemd-cgtop -m

Dit geeft de cgroups weer, gesorteerd op geheugengebruik. Dit is de snelste manier om de vraag "wat verbruikt het geheugen op deze server" te beantwoorden terwijl het systeem nog reageert. Als de server nieuw is, moet het account- en firewallbeheer uit de eerste tien minuten op een nieuwe VPS voorafgaan aan deze stap.

MemoryHigh throttles. MemoryMax kills.

Het verschil tussen deze twee geheugeninstellingen bepaalt hoe een fout zich manifesteert.

  • MemoryHigh= is een zachte limiet. Boven deze waarde zal de kernel agressief geheugen terugvorderen van de cgroup en de toewijzingen bewust vertragen. Het gebruik kan nog steeds boven dit getal uitkomen en er wordt niets beëindigd.
  • MemoryMax= is een harde limiet. Wanneer een toewijzing niet binnen deze limiet kan worden voldaan, voert de OOM killer een actie uit binnen die cgroup en beëindigt een van de eigen processen van de unit.

Dat tweede punt is de werkelijke reden om MemoryMax= in te stellen voor alles wat u niet volledig vertrouwt. Zonder limiet is een tekort een probleem voor de gehele server, waarbij de globale OOM killer zijn slachtoffer kiest op basis van oom_score, wat meestal neerkomt op het grootste proces. Het grootste proces is doorgaans uw database, niet het script dat geheugen lekt. Met een limiet vindt de beëindiging plaats binnen de unit die het probleem veroorzaakte.

Stel beide in, waarbij MemoryHigh= ongeveer 20 tot 30 procent onder MemoryMax= ligt. De ruimte daartussen is een waarschuwingszone: een langzaam lek overschrijdt High en uit zich als een service die traag wordt, terwijl een plotselinge piek direct door Max gaat en de service beëindigt.

Percentage-waarden worden berekend op basis van het geïnstalleerde fysieke geheugen. MemoryMax=25% op een 4 GB-plan is dus 1 GB en blijft een kwart van de server, ook nadat u het plan schaalt. MemorySwapMax=0 houdt de unit volledig uit de swap, waardoor de beëindiging snel volgt wanneer MemoryMax= wordt bereikt, in plaats van na een langdurig proces via swap. Onder dat punt kan MemoryHigh= de unit nog steeds vertragen, en het overschrijden van de hoge limiet roept nooit de OOM killer aan, waardoor een unit die tussen de twee waarden schommelt traag blijft in plaats van te crashen.

Enkele services laten u hun behoefte vooraf bepalen in plaats van deze te meten: een Ollama-unit bepaalt de grootte van zijn KV-cache op basis van het contextvenster dat u opgeeft. Lees daarom wat het verhogen van num_ctx kost aan RAM voordat u een plafond voor een dergelijke unit kiest.

Een limiet vereist een restart policy, anders blijft u na een beëindiging achter met een gestopte service.

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

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

StartLimit* hoort thuis in [Unit] en Restart= in [Service]. Als u een van beide in de verkeerde sectie plaatst, negeert systemd deze. Vijf herstarts in vijf minuten duiden op een lek in plaats van een incident; na vijf pogingen geeft systemd het op en laat de unit in de status failed staan. Dit is de status die u later wilt aantreffen in plaats van een crash-loop die het probleem maskeert.

CPU beperken met CPUQuota of delen met CPUWeight

CPUQuota= neemt een percentage van de tijd die beschikbaar is op één CPU. CPUQuota=50% staat gelijk aan de helft van één core. CPUQuota=200% is het equivalent van twee cores, waarbij de unit deze capaciteit over zoveel threads mag verdelen als gewenst. Op een plan met 2 vCPU's is CPUQuota=200% de volledige machine.

CPUWeight= is voor de meeste services de betere standaardinstelling. Het is een relatief aandeel van 1 tot 10000, waarbij de standaardwaarde van de kernel 100 is. Dit is alleen merkbaar wanneer er sprake is van concurrentie: een back-uptaak op CPUWeight=20 wijkt onder belasting voor een webserver op 100, maar gebruikt nog steeds de volledige capaciteit van de server wanneer deze inactief is. Een harde quota verspilt die onbenutte capaciteit.

Wees realistisch over wat een CPU-limiet u oplevert. Een CPU-intensief proces laat Linux zelden vastlopen, omdat de scheduler tijd blijft toewijzen aan alle processen. Geheugengebruik is wat een server daadwerkelijk onderuit haalt. Gebruik CPUQuota= wanneer u een voorspelbaar plafond wilt, bijvoorbeeld bij een build-proces of een agent die anders een uur lang op volle kracht zou draaien. Het bepalen van de omvang van dergelijke workloads is een apart vraagstuk, dat wordt behandeld in hoeveel RAM en CPU een coding agent VPS nodig heeft.

Als de CPU als bezet wordt aangegeven terwijl geen van uw processen veel uitvoert, kan de oorzaak aan de andere kant van de hypervisor liggen. Dit is CPU steal time door een luidruchtige buur, en geen enkele quota die u instelt zal daar verandering in brengen.

TasksMax stopt een fork-loop

TasksMax= is het aantal processen en threads dat een unit mag bevatten. Threads tellen mee, dus een Java- of Go-service heeft meer ruimte nodig dan de proceslijst doet vermoeden. Dit is de meest efficiënte bescherming tegen een script dat in een loop fork-opdrachten uitvoert, omdat de fork binnen de unit faalt in plaats van dat de server geen proces-ID's meer beschikbaar heeft.

TasksMax=128

Wanneer een unit de limiet bereikt, logt de kernel een regel met de naam van de cgroup:

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

Het programma zelf rapporteert meestal fork: retry: Resource temporarily unavailable. Controleer wat de manager standaard toepast met systemctl show -p DefaultTasksMax.

Beperk een eenmalige taak met systemd-run

U heeft geen unit-bestand nodig om dit te gebruiken. systemd-run bouwt een tijdelijke unit rondom een enkel commando.

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

--scope voert het commando uit in uw terminal, nadat Running scope as unit: run-r7c1a....scope is afgedrukt. De output blijft op uw scherm staan en de limieten vervallen zodra het commando is afgesloten. Elke eigenschap van systemd.resource-control werkt na -p.

Voor een langdurige taak laat u --scope weg en geeft u het een naam. Het draait dan op de achtergrond als een tijdelijke service en logt naar de journal:

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

Dezelfde opties werken met --user wanneer u niet als root bent ingelogd, hoewel uw user manager alleen beschikt over de controllers die eraan zijn gedelegeerd; een eigenschap kan daar dus worden geweigerd. Voer het uit met sudo als dat gebeurt. Wanneer een taak een permanente plek krijgt, verhuizen de instellingen ongewijzigd naar een echte unit: zie een script uitvoeren als een systemd service en timer.

De swap-vraag, eerlijk beantwoord

Swap verandert de aard van een fout in plaats van deze te voorkomen.

Zonder swap bereikt een geheugenlek het plafond en sterft er binnen enkele seconden een proces. De uitval is luidruchtig, kort en achteraf eenvoudig terug te lezen in de journal. Met swap schrijft de kernel koude anonieme pagina's naar de schijf en koopt u tijd. Als het proces zou stabiliseren, redt swap u. Als het proces echter ongecontroleerd blijft groeien, verandert swap een uitval van vijf seconden in een blokkade van twintig minuten. Die blokkade is erger, omdat een gestopt proces u nog een werkende shell laat, terwijl een systeem dat constant naar de schijf schrijft (thrashing) dat niet doet.

swapon --show
free -h

Een werkbaar midden op een kleine VPS: behoud een bescheiden swap-bestand voor pagina's die eenmalig worden toegewezen en daarna nooit meer worden aangeraakt, en stel MemorySwapMax=0 in op de units die u bereid bent te verliezen. De belangrijke services behouden hun swap. De onvoorspelbare services lopen snel tegen de muur aan, en het herstartbeleid naast hun limiet brengt ze weer terug.

Het verlagen van vm.swappiness is een zwak instrument, en het is nuttig om te weten waarom. Het verschuift enkel de balans tussen het verwijderen van de page cache en het swappen van anonieme pagina's, en beide acties kosten later een schijf-read. Het verandert enkel welke pagina's voor thrashing zorgen, niet of het systeem als geheel gaat thrash-en.

Een vroege OOM-daemon beëindigt processen vóór de blokkade

De kernel wacht tot het vrijmaken van geheugen volledig faalt. Op een kleine VPS is die wachttijd precies het moment waarop u de controle over de machine verliest. Twee userspace-daemons sluiten dit gat door zelf het geheugen te monitoren en eerder in te grijpen.

earlyoom controleert tot tien keer per seconde het beschikbare geheugen en de vrije swap. Het beëindigt het proces met de hoogste oom_score pas wanneer beide onder hun drempelwaarden zakken. Op een systeem zonder swap bepaalt alleen de geheugendrempel het ingrijpen.

sudo apt install earlyoom
systemctl status earlyoom

Het Debian- en Ubuntu-pakket start de service direct na installatie. De opties staan in /etc/default/earlyoom:

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

-m PERCENT stelt het minimum voor beschikbaar geheugen in en -s PERCENT het minimum voor vrije swap; beide staan standaard op 10 procent. Het tweede getal in elk paar is het SIGKILL-punt: earlyoom verstuurt een SIGTERM zodra zowel het geheugen als de swap onder hun eerste waarden zakken, en vervolgens een SIGKILL zodra beide onder de tweede waarde komen (standaard de helft van de eerste). De unit geeft deze variabele door aan earlyoom als $EARLYOOM_ARGS, waardoor systemd deze bij spaties opsplitst in argumenten. Het plaatsen van aanhalingstekens rond de --avoid en --prefer patronen is veilig: systemd verwijdert de buitenste dubbele aanhalingstekens bij het inlezen van het bestand, en respecteert en verwijdert vervolgens de enkele aanhalingstekens binnen de waarde tijdens het splitsen. Hierdoor werkt --avoid '^(sshd|systemd)$' hetzelfde als de niet-gequote vorm hierboven. Een patroon dat een spatie bevat, heeft die enkele aanhalingstekens nodig, anders wordt het gesplitst in twee argumenten. Pas een wijziging toe met sudo systemctl restart earlyoom en lees journalctl -u earlyoom om te zien welk proces is beëindigd en hoeveel geheugen dat proces in beslag nam.

systemd-oomd is de andere optie. De handleiding beschrijft dit als "een systeemservice die cgroups-v2 en pressure stall information (PSI) gebruikt om te monitoren en corrigerende maatregelen te nemen voordat een OOM optreedt in de kernel-space". Het werkt op basis van volledige cgroups in plaats van individuele processen, waardoor het een unit beëindigt in plaats van een losstaand subproces. Units melden zich aan met ManagedOOMMemoryPressure=kill of ManagedOOMSwap=kill, en de drempelwaarden staan in /etc/systemd/oomd.conf.

systemctl status systemd-oomd
oomctl

oomctl toont wat er momenteel wordt gemonitord. Op een server-image is dit vaak niets, omdat de instelling per unit moet worden geactiveerd. Kies één daemon en beperk u daartoe. Het gelijktijdig draaien van beide betekent dat twee processen strijden om een slachtoffer te kiezen, waardoor de reden voor een beëindiging lastiger te achterhalen is.

Welke unit was verantwoordelijk?

Begin bij de kernel, aangezien deze elk proces dat hij beëindigt, registreert.

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

Een beëindiging door de globale OOM-killer ziet er als volgt uit:

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 is het anonieme geheugen, zoals de heap, dat het proces in het RAM-geheugen vasthield op het moment van overlijden; in dit geval ongeveer 1,8 GB. Residentiële bestandstoewijzingen en gedeeld geheugen worden afzonderlijk geteld als file-rss en shmem-rss. Bekijk de naam tussen haakjes kritisch. Dit is het slachtoffer dat de kernel heeft gekozen. De kernel kiest het grootste proces, wat niet altijd het proces is dat het tekort heeft veroorzaakt.

Een beëindiging door een cgroup-limiet heeft een ander voorvoegsel en het rapport dat erboven wordt afgedrukt, benoemt de cgroup die zijn eigen limiet heeft bereikt:

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

Dat voorvoegsel vormt het grootste deel van de diagnose. Memory cgroup out of memory betekent dat één unit de MemoryMax= bereikte die u had ingesteld, terwijl de rest van de server in orde was. Een eenvoudige Out of memory betekent dat het geheugen van de machine als geheel op was; uw limieten ontbraken dus of waren te ruim ingesteld.

Vraag vervolgens aan systemd wat het heeft waargenomen:

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 zegt hetzelfde in één regel, als Active: failed (Result: oom-kill).

De cgroup-tellers zijn de derde bron en de enige die throttling registreert, wat nooit een logregel genereert:

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 telt hoe vaak de unit over de MemoryHigh= werd geduwd en werd vertraagd (throttled). max telt hoe vaak de harde limiet werd bereikt en oom_kill telt het aantal daadwerkelijk beëindigde processen. Een hoge high met oom_kill 0 is het stille geval van eerder: sinds de cgroup is aangemaakt, is de unit herhaaldelijk vertraagd zonder dat er een proces is beëindigd, waardoor systemd geen fout heeft geregistreerd. De teller loopt alleen maar op, dus lees deze twee keer met een minuut ertussen: een high die nog steeds oploopt, betekent dat de throttling op dit moment plaatsvindt. memory.peak (Linux 5.19 en nieuwer) bevat het hoogste gebruik dat de cgroup heeft bereikt; dit is het getal waartegen u MemoryMax= moet afzetten. Beide bestanden worden gereset wanneer de unit opnieuw opstart, omdat systemd de cgroup opnieuw aanmaakt.

Eén vereiste ligt aan de basis van dit alles. Als /var/log/journal niet bestaat, bevindt de journal zich in het RAM-geheugen en is elke regel verdwenen na de reboot die u nodig had om de server te herstellen.

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 die meer toont dan de huidige boot betekent dat de geschiedenis nu bewaard blijft, waardoor journalctl -k -b -1 u de kernelberichten kan tonen van de boot die is vastgelopen.

Een startpunt voor een kleine VPS

Houd op een abonnement van 2 GB ongeveer 300 tot 400 MB vrij voor de kernel en de page cache. Zorg dat de som van alle limieten niet de volledige 2 GB bereikt, omdat elke unit op hetzelfde moment een piek kan vertonen. Wijs de belangrijkste service het grootste deel toe en beperk alle overige, speculatieve processen daaromheen.

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

Het behouden van een toegangsweg is een extra instelling waard. OOMScoreAdjust=-500 in een drop-in voor ssh.service zorgt ervoor dat de globale OOM killer uw SSH daemon veel minder snel als slachtoffer kiest. Dit is het verschil tussen het herstellen van de server en het herstarten via het configuratiescherm. Het wijzigt enkel de keuze van de kernel voor het slachtoffer. Het verkort de vertraging niet.

Containers draaien in hun eigen cgroups, die door de container runtime worden aangemaakt in plaats van door uw unit files. Een limiet op docker.service wordt daarom geen limiet voor een individuele container. De equivalenten per container voor MemoryMax= en CPUQuota= worden behandeld in geheugen- en CPU-limieten instellen in Docker Compose.

FAQ

Waarom bevriest mijn VPS in plaats van het op hol geslagen proces te beëindigen?

Omdat de kernel voortgang beoordeelt op basis van of het vrijmaken van geheugen pagina's oplevert, en niet op basis van hoe lang dat duurt. Bij een tekort aan geheugen verwijdert de kernel de page cache, inclusief de uitvoerbare pagina's van draaiende programma's, om deze bij de volgende instructie weer in te lezen. Alles wacht op opslag en technisch gezien is er geen toewijzing mislukt, waardoor de OOM killer niet wordt geactiveerd. Controleer /proc/pressure/memory terwijl dit gebeurt: een full avg10 boven 40 betekent dat gedurende meer dan 40% van de laatste tien seconden elke niet-inactieve taak tegelijkertijd stilstond vanwege geheugenproblemen. Een userspace-daemon zoals earlyoom beëindigt processen voordat de server die toestand bereikt.

Wat is het verschil tussen MemoryHigh en MemoryMax?

MemoryHigh= is een zachte limiet die het proces vertraagt. De kernel dwingt het vrijmaken van geheugen af binnen de unit en vertraagt de toewijzingen, maar het gebruik kan het getal overschrijden zonder dat er processen worden beëindigd. MemoryMax= is een harde limiet: een toewijzing die hierbinnen niet kan worden voldaan, activeert de OOM killer binnen de cgroup van die specifieke unit. Hierdoor wordt het proces dat het probleem veroorzaakte beëindigd, in plaats van het grootste proces op de server. Stel MemoryHigh= in onder MemoryMax= en beschouw de ruimte daartussen als een waarschuwingszone.

Hoe achterhaal ik welke service door de OOM killer is beëindigd?

Voer journalctl -k --grep "Killed process" --since "2 hours ago" uit. Een regel die begint met Memory cgroup out of memory betekent dat een unit zijn eigen MemoryMax= heeft overschreden, terwijl een gewone Out of memory betekent dat het geheugen van de gehele machine op was. Voer daarna journalctl -u <unit> -n 50 uit en zoek naar Failed with result 'oom-kill'. Als /var/log/journal niet bestaat op uw server, werd de journal in het RAM bewaard en is het bewijs verloren gegaan bij de reboot. Maak die map daarom aan vóór het volgende incident.

Moet ik swap toevoegen aan een kleine VPS?

Een klein swap-bestand helpt bij 'koude' pagina's die eenmalig worden toegewezen en daarna niet meer worden gebruikt. Het helpt niet bij een op hol geslagen proces: het vertraagt de beëindiging en vervangt een korte uitval door een lange blokkade waardoor u niet meer kunt inloggen om het probleem te herstellen. Houd swap bescheiden en stel MemorySwapMax=0 in op de units die u bereid bent te verliezen. Zo bereiken deze snel hun limiet en kunnen ze, met Restart=on-failure ingeschakeld, zelfstandig herstarten terwijl de belangrijke services hun swap behouden.

Kan ik een commando beperken zonder een unit-bestand te schrijven?

Ja. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh voert het commando in uw terminal uit binnen een tijdelijke scope met die limieten; de limieten vervallen zodra het proces stopt. Elke eigenschap uit systemd.resource-control is beschikbaar na -p, dus MemorySwapMax=, TasksMax= en CPUWeight= werken daar ook. Laat --scope weg en voeg --unit=name toe om de taak op de achtergrond uit te voeren met de uitvoer in de journal.

Was dit artikel nuttig?