Memóriatúllépés-elhárító beállítása itt: Linux PostgreSQL-hez

Amikor bent van Linux Az adatbázis-kiszolgáló váratlanul leáll, és meg kell állapítani az okát. Ennek 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

Amikor te szerver vagy a folyamatnak elfogy a memóriája, Linux Az Out-Of-Memory Killer két megoldást kínál: vagy a teljes rendszer összeomlását, vagy a memóriát fogyasztó folyamat (alkalmazás) leállítását. Természetesen jobb leállítani a folyamatot, és megmenteni az operációs rendszert az összeomlástól. Röviden, az Out-Of-Memory Killer egy olyan folyamat, amely leállít egy alkalmazást, hogy megmentse a kernelt az összeomlástól. Feláldozza az alkalmazást, hogy az operációs rendszer futni tudjon. Először is beszéljük meg, hogyan működik az OOM és hogyan vezérelhető, majd nézzük meg, hogyan dönti el az OOM Killer, hogy mely alkalmazásokat állítsa le.

Az egyik fő feladat Linux — Memória lefoglalása a folyamatoknak, amikor kérik. Egy folyamat vagy alkalmazás jellemzően memóriát kér az operációs rendszertől, de nem használja fel teljesen. Ha az operációs rendszer mindenkinek lefoglal memóriát, aki kéri, de nem tervezi használni, a rendszer gyorsan elfogy a memóriából, és összeomlik. Ennek megelőzése érdekében az operációs rendszer lefoglalja a memóriát egy folyamat számára, de valójában nem foglalja le. A memória lefoglalására csak akkor kerül sor, ha egy folyamat ténylegesen használni kívánja. Előfordul, hogy az operációs rendszernek nincs szabad memóriája, de lefoglalja a memóriát egy folyamatnak, és amikor a folyamatnak szüksége van rá, az operációs rendszer lefoglalja, ha tudja. A hátránya, hogy néha az operációs rendszer lefoglalja a memóriát, de amikor szükség van rá, nincs szabad memória, ami rendszerösszeomlást okoz. Az OOM kulcsszerepet játszik ebben a forgatókönyvben, leállítja a folyamatokat, hogy megakadályozza a kernel pánikba esését. Amikor a PostgreSQL folyamatot kényszerítetten leállítják, a következő ü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

В Linux 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 be- és kikapcsolható, ahogy azt már említettük. Linux több memóriát foglalhat le a folyamatok számára, mint amennyi elérhető, de valójában nem osztja le, és ezt a viselkedést egy kernel paraméter szabályozza LinuxA 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 lefoglal-e túl sok memóriát. Ez az alapértelmezett érték a legtöbb verzióban. Linux.
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