Konfigureer Out-of-Memory Killer op Linux vir PostgreSQL

Wanneer 'n databasisbediener onverwags in Linux stop, moet jy die rede vind. Daar kan verskeie redes wees. Byvoorbeeld, SIGSEGV - mislukking as gevolg van 'n fout in die backend-bediener. Maar dit is skaars. Dikwels het jy eenvoudig nie meer skyfspasie of geheue nie. As jy nie meer skyfspasie het nie, is daar net een uitweg – maak spasie vry en herbegin die databasis.

Uit-Geheue-moordenaar

Wanneer 'n bediener of proses sonder geheue opraak, bied Linux 2 oplossings: crash die hele stelsel of beëindig die proses (toepassing) wat geheue opvreet. Dit is natuurlik beter om die proses te beëindig en die bedryfstelsel te red om te crash. In 'n neutedop, Out-Of-Memory Killer is 'n proses wat 'n toepassing doodmaak om te red dat die kern omval. Dit offer die toepassing op om die bedryfstelsel aan die gang te hou. Kom ons bespreek eers hoe OOM werk en hoe om dit te beheer, en kyk dan hoe OOM Killer besluit watter toepassing om te beëindig.

Een van die hooftake van Linux is om geheue aan prosesse toe te ken wanneer hulle daarvoor vra. Tipies, 'n proses of toepassing versoek geheue van die bedryfstelsel, maar gebruik dit nie ten volle nie. As die bedryfstelsel geheue uitdeel aan almal wat daarvoor vra, maar geen planne het om dit te gebruik nie, sal die geheue baie gou opraak en die stelsel sal misluk. Om dit te vermy, behou die bedryfstelsel geheue vir die proses, maar stel dit nie eintlik vry nie. Geheue word slegs toegeken wanneer 'n proses dit werklik gaan gebruik. Dit gebeur dat die bedryfstelsel nie vrye geheue het nie, maar dit ken geheue aan 'n proses toe, en wanneer 'n proses dit nodig het, ken die bedryfstelsel dit toe as dit kan. Die nadeel is dat die bedryfstelsel soms geheue behou, maar op die regte tyd is daar geen vrye geheue nie, en die stelsel stort ineen. OOM speel 'n belangrike rol in hierdie scenario en beëindig prosesse om te verhoed dat die kern paniekerig raak. Wanneer 'n PostgreSQL-proses gedwing word om te beëindig, verskyn 'n boodskap in die log:

Out of Memory: Killed process 12345 (postgres).

As die stelsel min geheue het en dit nie vrygestel kan word nie, word die funksie opgeroep out_of_memory. In hierdie stadium het sy net een ding oor om te doen – een of meer prosesse voltooi. Moet OOM-killer die proses onmiddellik beëindig of kan dit wag? Natuurlik, wanneer out_of_memory geroep word, is dit as gevolg van wag vir 'n I/O-operasie of blaai na skyf. Daarom moet die OOM-moordenaar eers tjeks uitvoer en op grond daarvan besluit dat die proses beëindig moet word. As al die tjeks hieronder positief is, sal OOM die proses beëindig.

Proses seleksie

Wanneer geheue opraak, word die funksie opgeroep out_of_memory(). Dit het 'n funksie select_bad_process(), wat 'n evaluering van die funksie ontvang badness(). Die “ergste” proses sal geteiken word. Funksie badness() kies 'n proses volgens sekere reëls.

1. Die kern benodig 'n minimum geheue vir homself.
2. Jy moet baie geheue vrystel.
3. Dit is nie nodig om prosesse te beëindig wat min geheue gebruik nie.
4. Minimum prosesse moet voltooi word.
5. Komplekse algoritmes wat die kanse op voltooiing verhoog vir daardie prosesse wat die gebruiker self wil voltooi.

Nadat al hierdie kontroles voltooi is, ondersoek OOM die telling (oom_score). OOM toewys oom_score elke proses, en vermenigvuldig dan hierdie waarde met die hoeveelheid geheue. Prosesse met groter waardes is meer geneig om die slagoffer van die OOM-moordenaar te word. Prosesse wat met die wortelgebruiker geassosieer word, het 'n laer telling en is minder geneig om gedwing te word om te beëindig.

postgres=# SELECT pg_backend_pid();
pg_backend_pid 
----------------
    3813
(1 row)

Die Postgres proses ID is 3813, so in 'n ander dop is dit moontlik om die telling te kry deur hierdie kern parameter te gebruik oom_score:

vagrant@vagrant:~$ sudo cat /proc/3813/oom_score
2

As jy glad nie wil hê OOM-Killer moet die proses doodmaak nie, is daar nog 'n kernopsie: oom_score_adj. Voeg 'n groot negatiewe waarde by om die kanse te verminder om 'n proses te voltooi wat jy waardeer.

sudo echo -100 > /proc/3813/oom_score_adj

Om 'n waarde te stel oom_score_adj, stel OOMScoreAdjust in die diensblok:

[Service]
OOMScoreAdjust=-1000

Of gebruik oomprotect in 'n span rcctl.

rcctl set <i>servicename</i> oomprotect -1000

Forseer beëindiging van 'n proses

Wanneer een of meer prosesse reeds gekies is, roep OOM-Killer die funksie oom_kill_task(). Hierdie funksie stuur 'n beëindigingssein na die proses. In die geval van geheue tekort oom_kill() Roep hierdie funksie op om 'n SIGKILL-sein na die proses te stuur. 'n Boodskap word na die kernlogboek geskryf.

Out of Memory: Killed process [pid] [name].

Hoe om OOM-Killer te beheer

Op Linux kan jy OOM-Killer aktiveer of deaktiveer (hoewel laasgenoemde nie aanbeveel word nie). Gebruik die parameter om te aktiveer of te deaktiveer vm.oom-kill. Om OOM-Killer tydens hardlooptyd te aktiveer, voer die opdrag uit sysctl.

sudo -s sysctl -w vm.oom-kill = 1

Om OOM-Killer te deaktiveer, spesifiseer die waarde 0 in dieselfde opdrag:

sudo -s sysctl -w vm.oom-kill = 0

Die resultaat van hierdie opdrag sal nie vir ewig gestoor word nie, maar slegs tot die eerste herlaai. As jy meer volharding nodig het, voeg hierdie reël by die lêer /etc/sysctl.conf:

echo vm.oom-kill = 1 >>/etc/sysctl.conf

Nog 'n manier om te aktiveer en deaktiveer is om 'n veranderlike te skryf panic_on_oom. Die waarde kan altyd ingeboek word /proc.

$ cat /proc/sys/vm/panic_on_oom
0

As jy die waarde op 0 stel, sal daar geen kernpaniek wees wanneer geheue opraak nie.

$ echo 0 > /proc/sys/vm/panic_on_oom

As jy die waarde op 1 stel, sal 'n kernpaniek voorkom wanneer die geheue opraak.

echo 1 > /proc/sys/vm/panic_on_oom

OOM-Killer kan nie net aan- en afgeskakel word nie. Ons het reeds gesê dat Linux meer geheue vir prosesse kan reserveer as wat beskikbaar is sonder om dit werklik toe te ken, en hierdie gedrag word beheer deur 'n Linux-kernparameter. Die veranderlike is hiervoor verantwoordelik vm.overcommit_memory.

U kan die volgende waardes daarvoor spesifiseer:

0: Die kern besluit self of te veel geheue gereserveer moet word. Dit is die verstek op die meeste weergawes van Linux.
1: Die kern sal altyd ekstra geheue reserveer. Dit is riskant, want die geheue kan opraak, want heel waarskynlik sal die prosesse dit eendag vereis.
2: die kern sal nie meer geheue reserveer as wat in die parameter gespesifiseer is nie overcommit_ratio.

Met hierdie parameter spesifiseer jy die persentasie geheue wat toegelaat word om oorgereserveer te word. As daar nie plek daarvoor is nie, word geen geheue toegeken nie, en die bespreking sal geweier word. Dit is die veiligste opsie wat aanbeveel word vir PostgreSQL. OOM-Killer word deur 'n ander element beïnvloed - die ruilvermoë, wat deur die veranderlike beheer word cat /proc/sys/vm/swappiness. Hierdie waardes vertel die kern hoe om blaai te hanteer. Hoe hoër die waarde, hoe minder waarskynlik is dit dat OOM die proses sal beëindig, maar as gevolg van I/O-bewerkings het dit wel 'n negatiewe impak op die databasis. En omgekeerd - hoe laer die waarde, hoe groter is die waarskynlikheid van OOM-Killer-ingryping, maar die databasisprestasie is ook hoër. Die verstekwaarde is 60, maar as die hele databasis in die geheue pas, is dit beter om die waarde op 1 te stel.

Resultate van

Moenie dat die "moordenaar" in OOM-Killer jou bang maak nie. In hierdie geval sal die moordenaar die redder van jou stelsel wees. Dit "maak dood" die ergste prosesse en red die stelsel van ineenstorting. Om te verhoed dat u OOM-Killer moet gebruik om PostgreSQL te beëindig, stel op vm.overcommit_memory waarde 2. Dit waarborg nie dat OOM-Killer nie hoef in te gryp nie, maar dit sal die waarskynlikheid verminder om die PostgreSQL-proses te dwing om te beëindig.

Bron: will.com