Konfigurerar Out-Of-Memory Killer i Linux för PostgreSQL

När en databasserver i Linux oväntat kraschar, måste man hitta orsaken. Det kan finnas flera orsaker. Till exempel, SIGSEGV — ett krasch på grund av en bugg i backend-servern. Men det är sällsynt. Oftast tar bara diskutrymmet eller minnet slut. Om diskutrymmet tar slut, finns det ingen annan väg — man måste frigöra utrymme och starta om databasen.

Out-Of-Memory Killer

När en servern eller process får slut på minne, erbjuder Linux 2 lösningar: att krascha hela systemet eller avsluta den process (applikation) som förbrukar minnet. Det är givetvis bättre att avsluta processen och rädda operativsystemet från en krasch. Kort sagt, Out-Of-Memory Killer är en process som avslutar applikationen för att rädda kärnan från att krascha. Den offrar applikationen för att bevara operativsystemets funktion. Låt oss först diskutera hur OOM fungerar och hur den kan kontrolleras, och sedan titta på hur OOM Killer bestämmer vilken applikation som ska avslutas.

En av de viktigaste uppgifterna för Linux är att tilldela minne till processer när de begär det. Vanligtvis begär en process eller applikation minne från operativsystemet, men de utnyttjar det inte helt. Om operativsystemet ger minne till alla som ber om det, men som inte planerar att använda det, kommer minnet snart att ta slut och systemet kommer att falla. För att undvika detta reserverar operativsystemet minnet för processen, men ger det faktiskt inte ut. Minne tilldelas först när processen verkligen ska använda det. Det händer att operativsystemet inte har något ledigt minne, men det reserverar minnet för processen, och när processen behöver det, tilldelar operativsystemet det, om det kan. Nackdelen är att ibland reserverar operativsystemet minne, men vid behov finns det inget ledigt minne, och systemet kraschar. OOM spelar en viktig roll i detta scenario och avslutar processer för att skydda kärnan från panik. När en PostgreSQL-process avslutas tvingat, visas ett meddelande i loggen:

Out of Memory: Killed process 12345 (postgres).

Om det finns lite minne i systemet och det inte går att frigöra, anropas funktionen out_of_memory. Vid det här steget återstår det bara för den att avsluta en eller flera processer. OOM-killer bör avsluta processen omedelbart eller kan man vänta? Det är uppenbart att när out_of_memory anropas handlar det om att vänta på I/O-operationer eller att byta ut sidor till disk. Därför bör OOM-killer först göra kontroller och baserat på dem besluta vilken process som ska avslutas. Om alla kontroller nedan ger ett positivt resultat kommer OOM att avsluta processen.

Val av process

När minnet tar slut anropas funktionen out_of_memory(). Den har en funktion select_bad_process(), som får en bedömning från funktionen badness(). Den mest "dåliga" processen kommer att väljas. Funktionen badness() väljer processer enligt specifika regler.

1. Kärnan behöver en viss mängd minne för sig själv.
2. Det behövs för att frigöra mycket minne.
3. Det är inte nödvändigt att avsluta processer som använder lite minne.
4. Minst några processer bör avslutas.
5. Komplexa algoritmer som ökar chansen att avsluta de processer som användaren själv vill avsluta.

Efter att ha genomfört alla dessa kontroller analyserar OOM bedömningen (oom_score). OOM tilldelar oom_score varje process ett värde och multiplicerar sedan detta värde med mängden minne. Processer med högre värden har större chans att bli offer för OOM Killer. Processer som är kopplade till privilegierade användare har en lägre bedömning och mindre chans att bli tvångsavslutade.

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

Postgres-processens ID är 3813, så i ett annat terminalfönster kan man få bedömningen med hjälp av detta kärnparameter oom_score:

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

Om du helt och hållet inte vill att OOM-Killer ska avsluta processen finns det en annan kärnparameter: oom_score_adj. Lägg till ett stort negativt värde för att minska chansen att din viktiga process avslutas.

sudo echo -100 > /proc/3813/oom_score_adj

För att ställa in värdet oom_score_adj, ställ in OOMScoreAdjust i serviceblocket:

[Service]
OOMScoreAdjust=-1000

Eller använd oomprotect i kommandot rcctl.

rcctl set servicename oomprotect -1000

Tvinga avslut av process

När en eller flera processer redan har valts, anropar OOM-Killer funktionen oom_kill_task(). Denna funktion skickar en avslutningssignal till processen. Vid minnesbrist oom_kill() anropar denna funktion för att skicka SIGKILL-signalen till processen. Ett meddelande loggas i kärnan.

Ut ur minne: Processen [pid] [name] dödades.

Hur man kontrollerar OOM-Killer

I Linux kan OOM-Killer aktiveras och inaktiveras (även om det sistnämnda inte rekommenderas). För att aktivera eller inaktivera, använd parametern vm.oom-kill. För att aktivera OOM-Killer i körningsmiljön, kör kommandot sysctl.

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

För att inaktivera OOM-Killer, ange värdet 0 i samma kommando:

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

Resultatet av detta kommando kommer inte att sparas permanent, utan endast till den första omstarten. Om mer beständighet behövs, lägg till denna rad i filen /etc/sysctl.conf:

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

Ett annat sätt att aktivera och inaktivera är att skriva variabeln panic_on_oom. Värdet kan alltid kontrolleras med /proc.

$ cat /proc/sys/vm/panic_on_oom
0

Om värdet sätts till 0, kommer det inte att bli någon kernel panic när minnet tar slut.

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

Om värdet sätts till 1, kommer det att inträffa en kernel panic när minnet tar slut.

echo 1 > /proc/sys/vm/panic_on_oom

OOM-Killer kan inte bara aktiveras och inaktiveras. Vi har redan nämnt att Linux kan reservera mer minne för processer än som faktiskt finns, men inte tilldela det, och detta beteende styrs av Linux-kärnans parameter. Denna hanteras av variabeln vm.overcommit_memory.

För denna kan följande värden anges:

0: Kärnan bestämmer själv om det är vettigt att reservera för mycket minne. Detta värde är standard i de flesta versioner av Linux.
1: Kärnan kommer alltid att reservera extra minne. Detta är riskabelt, eftersom minnet kan ta slut, eftersom processerna troligtvis kommer att begära det reserverade någon gång.
2: Kärnan kommer inte att reservera mer minne än vad som anges i parametern overcommit_ratio.

I detta parameter anger du den procentandel av minnet som tillåts för överkompensation. Om det inte finns något utrymme för det, kommer minnet inte att tilldelas och överkompensationen kommer att nekas. Detta är det säkraste alternativet, rekommenderat för PostgreSQL. OOM-Killer påverkas också av en annan faktor - swapmöjligheten, som hanteras av variabeln cat /proc/sys/vm/swappiness. Dessa värden indikerar för kärnan hur man behandlar sidutbyte. Ju högre värde, desto mindre sannolikhet att OOM avslutar processen, men på grund av in- och utdataoperationer påverkar detta databasen negativt. Omvänt, ju lägre värde, desto högre sannolikhet för ingrepp från OOM-Killer, men databasen presterar också bättre. Standardvärdet är 60, men om hela databasen får plats i minnet är det bättre att ställa in värdet till 1.

Sammanfattning

Låt er inte skrämmas av "killer" i OOM-Killer. I det här fallet kommer killern att vara räddaren för ert system. Den "dödar" de mest problematiska processerna och räddar systemet från krash. För att undvika att behöva använda OOM-Killer för att avsluta PostgreSQL, ställ in för vm.overcommit_memory värdet 2. Det garanterar inte att OOM-Killer inte behöver ingripa, men det minskar sannolikheten för att PostgreSQL-processen tvingas avslutas.

Källa: habr.com