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

Amikor a Linux adatbázis-szerver váratlanul leáll, meg kell találni az okot. Ennek több oka is lehet. Például, SIGSEGV — hiba a háttérszerverben. De ez ritkaság. Leggyakrabban egyszerűen elfogy a lemezterület vagy a memória. Ha a lemezterület elfogyott, az egyetlen megoldás az, hogy helyet szabadítunk fel, és újraindítjuk az adatbázist.

Out-Of-Memory Killer

Amikor a a szerver vagy folyamat memória végére ér, a Linux két megoldást kínál: összeomlasztja az egész rendszert, vagy leállítja azt a folyamatot (alkalmazást), amelyik túlságosan használja a memóriát. Természetesen jobb, ha leállítjuk a folyamatot, és megvédjük az operációs rendszert a váratlan leállítástól. Röviden, az Out-Of-Memory Killer egy olyan folyamat, amely leállít egy alkalmazást, hogy megvédje a kernelt a hibától. Feláldozza az alkalmazást, hogy megőrizze az operációs rendszer működését. Először beszéljünk arról, hogyan működik az OOM, és hogyan lehet irányítani, majd nézzük meg, hogy az OOM Killer hogyan dönt arról, hogy melyik alkalmazást állítsa le.

A Linux egyik fő feladata, hogy memóriát biztosítson a folyamatoknak, amikor kérik. Általában a folyamat vagy alkalmazás memóriát kér az operációs rendszertől, de valójában nem használja fel teljesen. Ha az operációs rendszer mindenkinek kiadja a memóriát, aki kéri, de nem tervezi felhasználni, nagyon hamar elfogy a memória, és a rendszer leáll. Ennek elkerülése érdekében az operációs rendszer lefoglalja a memóriát a folyamat számára, de valójában nem adja oda. A memória csak akkor kerül kiadásra, amikor a folyamat valóban használni akarja. Előfordulhat, hogy az operációs rendszernek nincs szabad memóriája, de lefoglalja a memóriát a folyamat számára, és amikor a folyamatnak szüksége van rá, az operációs rendszer kiadja, ha tudja. A hátrány az, hogy néha az operációs rendszer lefoglalja a memóriát, de a szükséges pillanatban 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 megvédje a kernelt a pániktól. Amikor a PostgreSQL folyamatot kényszerítik leállítani, a naplóban megjelenik a következő üzenet:

Out of Memory: Killed process 12345 (postgres).

Ha a rendszerben kevés a memória, és nem lehet felszabadítani, akkor a következő függvény hívódik meg: out_of_memoryEzen a ponton csak egy dolog maradt hátra - befejezni egy vagy több folyamatot. Az OOM-killernek azonnal le kell állítania a folyamatot, vagy várhatunk? Nyilvánvaló, hogy amikor a memóriahiány lép fel, az kötődik egy I/O művelet várakozásához vagy a lapok lemezre való kiírásához. Ezért az OOM-killernek először ellenőrzéseket kell végrehajtania, és ezek alapján el kell döntenie, hogy melyik folyamatot kell leállítani. Ha az alábbi ellenőrzések mind pozitív eredményt adnak, az OOM leállítja a folyamatot.

Folyamat kiválasztása

Amikor véget ér a memória, a következő függvény hívódik meg out_of_memory(). Ebben van egy függvény select_bad_process(), amely egy értékelést kap a következő függvénytől badness(). A leg "rosszabb" folyamat kerül kiválasztásra. A függvény badness() bizonyos szabályok szerint választ folyamatot.

1. A kernelnak szüksége van egy minimális memória mennyiségre önmagának.
2. Sok memóriát kell felszabadítani.
3. Nem kell leállítani azokat a folyamatokat, amelyek kevés memóriát használnak.
4. Legalább egy kis számú folyamatot le kell állítani.
5. Összetett algoritmusok, amelyek növelik annak esélyét, hogy azokat a folyamatokat állítsák le, amelyeket a felhasználó szeretne leállítani.

Ezeknek az ellenőrzéseknek a végrehajtása után az OOM megvizsgálja az értékelést (oom_score). Az OOM minden folyamatnak elkülönített értéket rendel, majd ezt az értéket megszorozza a memória mennyiségével. A nagyobb értékekkel rendelkező folyamatok nagyobb eséllyel válnak az OOM Killer áldozataivá. A privilégiumokkal rendelkező felhasználókhoz kapcsolódó folyamatok alacsonyabb értékeléssel rendelkeznek, és kisebb eséllyel állítják le őket erőszakkal. oom_score postgres=# SELECT pg_backend_pid(); pg_backend_pid ---------------- 3813 (1 sor)

A Postgres folyamat azonosítója - 3813, ezért egy másik shellben értékelést kaphatunk e kernel paraméter felhasználásával

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

Ha egyáltalán nem szeretné, hogy az OOM-Killer leállítson egy folyamatot, van egy másik kerneli paraméter:

oom_score_adj . Adj hozzá egy nagy negatív értéket, hogy csökkentsd a kedvenc folyamatod leállításának esélyeit.sudo echo -100 > /proc/3813/oom_score_adj

Az érték beállításához

, állítsd be az OOMScoreAdjust-ot a szolgáltatás blokkban: . Adj hozzá egy nagy negatív értéket, hogy csökkentsd a kedvenc folyamatod leállításának esélyeit.[Service] OOMScoreAdjust=-1000

Vagy használd a

oomprotect rcctl a jogok és tulajdonosok megőrzéséhez. rcctl set servicename oomprotect -1000.

Folyamat erőszakos leállítása

Ha egy vagy több folyamatot már kiválasztottak, az OOM-Killer meghívja a következő függvényt

oom_kill_task() . Ez a függvény jelet küld a folyamatnak a leállításhoz. Ha memóriahiány vanoom_kill() ez a függvény hívódik meg, hogy jelet küldjön a folyamatnak a SIGKILL-hoz. A kernel naplójába üzenet kerül rögzítésre. Out of Memory: Killed process [pid] [name].

Memóriahiány: A folyamatot megszüntették [pid] [name].

Hogyan lehet vezérelni az OOM-Killert

Linux rendszerben az OOM-Killert be- és kikapcsolhatjuk (bár az utóbbi nem ajánlott). A be- és kikapcsolá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 kikapcsolásához adja meg a 0 értéket ugyanabban a parancsban:

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

E parancs eredménye nem marad meg véglegesen, csak az első újraindításig. Ha tartósabb megoldásra van szükség, adja hozzá ezt a sort a fájlhoz /etc/sysctl.conf:

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

Egy másik módszer a be- és kikapcsolásra, ha megírja a változót panic_on_oom. Az értékét mindig ellenőrizheti itt: /proc.

$ cat /proc/sys/vm/panic_on_oom
0

Ha a 0 értéket állítja be, akkor ha elfogy a memória, nem lesz kernel panic.

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

Ha 1 értékre állítjuk, akkor ha elfogy a memória, akkor kernel panic fog bekövetkezni.

echo 1 > /proc/sys/vm/panic_on_oom

Az OOM-Killert nemcsak be- és ki lehet kapcsolni. Már említettük, hogy a Linux több memóriát is lefoglalhat a folyamatok számára, mint amennyi fizikailag van, de azt nem fogja ténylegesen kiosztani, és ezt a Linux kernel paramétere irányítja. Ehhez a változóhoz vm.overcommit_memory.

a következő értékeket lehet megadni:

0: a kernel dönti el, hogy érdemes-e túl sok memóriát lefoglalni. Ez az alapértelmezett érték a legtöbb Linux verzióban.
1: a kernel mindig túl sok memóriát fog lefoglalni. Ez kockázatos, mivel a memória kimerülhet, hiszen valószínű, hogy egyszer a folyamatok meg fogják igényelni a fent meghatározott mennyiséget.
2: a kernel nem fog több memóriát lefoglalni, mint ami a overcommit_ratio.

paraméterben meg van határozva. Ebben a paraméterben meg kell adnia azt a memórián belüli százalékot, amelyre a túlzott lefoglalás megengedett. Ha erre nincs elegendő hely, a memória nem kerül kiosztásra, a lefoglalás megtagadásra kerül. Ez a legbiztonságosabb lehetőség, amelyet a PostgreSQL-hez ajánlanak. Az OOM-Killerra még egy tényező hatással van - a swap lehetősége, amit a változó irányít: cat /proc/sys/vm/swappinessEzek az értékek azt mondják a rendszernek, hogyan kezelje a lapozást. Minél nagyobb az érték, annál kisebb a valószínűsége, hogy a OOM leállítja a folyamatot, de a be- és kimeneti műveletek miatt ez negatívan befolyásolja az adatbázist. Fordítva is igaz: minél kisebb az érték, annál nagyobb a valószínűsége, hogy a OOM-Killer beavatkozik, de az adatbázis teljesítménye is jobb lesz. Az alapértelmezett érték 60, de ha az egész adatbázis a memóriában van, jobb beállítani az értéket 1-re.

Összegzés

Ne ijesszen meg az OOM-Killerben a "gyilkos" kifejezés. Ebben az esetben a gyilkos lesz a rendszer megmentője. Ő "öli meg" a legrosszabb folyamatokat, és menti meg a rendszert a váratlan leállástól. Annak érdekében, hogy ne kelljen az OOM-Killer-t használni a PostgreSQL leállításához, állítsa be a vm.overcommit_memory 2-es értékre. Ez nem garantálja, hogy a OOM-Killernek ne kelljen beavatkoznia, de csökkenti a PostgreSQL folyamat kényszerített leállításának valószínűségét.

Forrás: habr.com