Az Out-Of-Memory Killer beállítása Linuxban PostgreSQL-hez

Ha egy adatbázis-kiszolgáló váratlanul kilép Linux alatt, meg kell találnia az okot. Több oka is lehet. Például, SIGSEGV — hiba a háttérkiszolgáló hibája miatt. De ez ritka. Leggyakrabban egyszerűen elfogy a lemezterület vagy a memória. Ha elfogy a lemezterület, csak egy kiút van – szabadítson fel helyet, és indítsa újra az adatbázist.

Kimerült memória gyilkos

Ha egy szerver vagy folyamat memória elfogy, a Linux két megoldást kínál: összeomlik a teljes rendszert, vagy leállítja a memóriát felemésztő folyamatot (alkalmazást). Természetesen jobb, ha leállítja a folyamatot, és megmenti az operációs rendszert az összeomlástól. Dióhéjban az Out-Of-Memory Killer egy olyan folyamat, amely leállítja az alkalmazásokat, hogy megmentse a kernelt az összeomlástól. Feláldozza az alkalmazást, hogy az operációs rendszer működjön. Először beszéljük meg az OOM működését és vezérlését, majd nézzük meg, hogyan dönti el az OOM Killer, hogy melyik alkalmazást kell leállítani.

A Linux egyik fő feladata, hogy memóriát rendeljen a folyamatokhoz, amikor azt kérik. Általában egy folyamat vagy alkalmazás memóriát kér az operációs rendszertől, de nem használja ki teljesen. Ha az operációs rendszer memóriát ad mindenkinek, aki kéri, de nem tervezi használni, nagyon hamar elfogy a memória, és a rendszer meghibásodik. Ennek elkerülése érdekében az operációs rendszer memóriát tart fenn a folyamat számára, de valójában nem engedi fel. A memória csak akkor kerül lefoglalásra, ha egy folyamat ténylegesen használni fogja. Előfordul, hogy az operációs rendszernek nincs szabad memóriája, de memóriát rendel egy folyamathoz, és amikor egy folyamatnak szüksége van rá, az operációs rendszer lefoglalja, ha tud. Hátránya, hogy az operációs rendszer néha lefoglal memóriát, de a megfelelő időben nincs szabad memória, és a rendszer összeomlik. Az OOM fontos szerepet játszik ebben a forgatókönyvben, és leállítja a folyamatokat, hogy megakadályozza a kernel pánikba esését. Amikor egy PostgreSQL folyamat kénytelen leállni, egy üzenet jelenik meg a naplóban:

Out of Memory: Killed process 12345 (postgres).

Ha a rendszerben kevés a memória, és nem lehet felszabadítani, a függvény meghívásra kerül out_of_memory. Ebben a szakaszban már csak egy dolga van hátra: egy vagy több folyamat elvégzése. Az OOM-killer azonnal leállítja a folyamatot, vagy várhat? Nyilvánvaló, hogy az out_of_memory meghívásakor egy I/O műveletre vagy a lemezre lapozásra kell várni. Ezért az OOM-gyilkosnak először ellenőrzéseket kell végrehajtania, és ezek alapján döntenie kell arról, hogy a folyamatot le kell állítani. Ha az alábbi ellenőrzések mindegyike pozitív, az OOM leállítja a folyamatot.

Folyamat kiválasztása

Ha kifogy a memória, a függvény meghívásra kerül out_of_memory(). Van egy funkciója select_bad_process(), amely értékelést kap a függvénytől badness(). A „legrosszabb” folyamat lesz a cél. Funkció badness() bizonyos szabályok szerint választ ki egy folyamatot.

1. A kernelnek szüksége van némi minimális memóriára.
2. Sok memóriát kell felszabadítania.
3. Nincs szükség a kevés memóriát használó folyamatok leállítására.
4. Minimális folyamatokat kell végrehajtani.
5. Komplex algoritmusok, amelyek növelik azoknak a folyamatoknak az esélyét, amelyeket a felhasználó maga akar végrehajtani.

Az összes ellenőrzés elvégzése után az OOM megvizsgálja a pontszámot (oom_score). OOM hozzárendeli oom_score minden folyamatot, majd ezt az értéket megszorozza a memória mennyiségével. A nagyobb értékű folyamatok nagyobb valószínűséggel esnek áldozatul az OOM Killernek. A root felhasználóhoz kapcsolódó folyamatok alacsonyabb pontszámmal rendelkeznek, és kisebb valószínűséggel kényszerülnek leállításra.

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

A Postgres folyamatazonosító 3813, így egy másik shellben lehetőség van a pontszám lekérésére ezzel a kernelparaméterrel oom_score:

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

Ha egyáltalán nem szeretné, hogy az OOM-Killer megölje a folyamatot, van egy másik kernelopció: oom_score_adj. Adjon hozzá egy nagy negatív értéket, hogy csökkentse az Ön által értékelt folyamat befejezésének esélyét.

sudo echo -100 > /proc/3813/oom_score_adj

Érték beállításához oom_score_adj, állítsa be az OOMScoreAdjust beállítást a szolgáltatásblokkban:

[Service]
OOMScoreAdjust=-1000

Vagy használja oomprotect csapatban rcctl.

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

Egy folyamat kényszerített befejezése

Ha egy vagy több folyamat már ki van választva, az OOM-Killer meghívja a függvényt oom_kill_task(). Ez a funkció befejező jelet küld a folyamatnak. Memóriahiány esetén oom_kill() Meghívja ezt a funkciót, hogy SIGKILL jelet küldjön a folyamatnak. Üzenet íródik a kernelnaplóba.

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

Az OOM-Killer vezérlése

Linuxon engedélyezheti vagy letilthatja az OOM-Killert (bár ez utóbbi nem ajánlott). Az engedélyezéshez vagy letiltáshoz használja a paramétert vm.oom-kill. Az OOM-Killer futás közbeni engedélyezéséhez futtassa a parancsot sysctl.

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

Az OOM-Killer letiltásához adja meg a 0 értéket ugyanabban a parancsban:

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

A parancs eredménye nem lesz mentve örökre, hanem csak az első újraindításig. Ha nagyobb kitartásra van szüksége, adja hozzá ezt a sort a fájlhoz /etc/sysctl.conf:

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

Az engedélyezés és a letiltás másik módja egy változó írása panic_on_oom. Az érték mindig ellenőrizhető /proc.

$ cat /proc/sys/vm/panic_on_oom
0

Ha az értéket 0-ra állítja, akkor a memória elfogyásakor nem lesz kernelpánik.

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

Ha az értéket 1-re állítja, akkor a memória elfogyásakor kernelpánik lép fel.

echo 1 > /proc/sys/vm/panic_on_oom

Az OOM-Killer nem csak be- és kikapcsolható. Már említettük, hogy a Linux több memóriát tud lefoglalni a folyamatok számára, mint amennyi rendelkezésre áll anélkül, hogy ténylegesen lefoglalná, és ezt a viselkedést egy Linux kernelparaméter szabályozza. A változó felelős ezért vm.overcommit_memory.

A következő értékeket adhatja meg neki:

0: A kernel maga dönti el, hogy túl sok memóriát foglal-e le. Ez az alapértelmezett a Linux legtöbb verziójában.
1: A kernel mindig extra memóriát foglal le. Ez kockázatos, mert kifogyhat a memória, mert nagy valószínűséggel egy napon a folyamatok ezt megkívánják.
2: a kernel nem foglal le több memóriát a paraméterben megadottnál overcommit_ratio.

Ezzel a paraméterrel megadhatja, hogy a memória hány százaléka legyen túlfoglalva. Ha nincs rá hely, a rendszer nem foglal memóriát, és a foglalás elutasításra kerül. Ez a PostgreSQL-hez ajánlott legbiztonságosabb lehetőség. Az OOM-Killert egy másik elem is érinti - a csereképesség, amelyet a változó vezérel cat /proc/sys/vm/swappiness. Ezek az értékek megmondják a kernelnek, hogyan kezelje a lapozást. Minél magasabb ez az érték, annál kevésbé valószínű, hogy az OOM leállítja a folyamatot, de az I/O műveletek miatt ez negatív hatással van az adatbázisra. És fordítva - minél alacsonyabb az érték, annál nagyobb az OOM-Killer beavatkozás valószínűsége, de az adatbázis teljesítménye is magasabb. Az alapértelmezett érték 60, de ha a teljes adatbázis elfér a memóriában, akkor jobb az értéket 1-re állítani.

Eredményei

Ne hagyja, hogy az OOM-Killer "gyilkosa" megijesszen. Ebben az esetben a gyilkos lesz a rendszered megmentője. „Megöli” a legrosszabb folyamatokat, és megmenti a rendszert az összeomlástól. Annak elkerülése érdekében, hogy az OOM-Killert kelljen használnia a PostgreSQL leállításához, állítsa be a következőt: vm.overcommit_memory 2. érték. Ez nem garantálja, hogy az OOM-Killernek nem kell beavatkoznia, de csökkenti annak valószínűségét, hogy a PostgreSQL folyamat leállásra kényszerítse.

Forrás: will.com