PostgreSQL కోసం Linuxలో అవుట్-ఆఫ్-మెమరీ కిల్లర్‌ని సెటప్ చేస్తోంది

Linuxలో డేటాబేస్ సర్వర్ ఊహించని విధంగా నిష్క్రమించినప్పుడు, మీరు కారణాన్ని కనుగొనాలి. అనేక కారణాలు ఉండవచ్చు. ఉదాహరణకి, SIGSEGV — బ్యాకెండ్ సర్వర్‌లోని బగ్ కారణంగా వైఫల్యం. కానీ ఇది అరుదు. చాలా తరచుగా, మీరు కేవలం డిస్క్ స్థలం లేదా మెమరీ అయిపోతారు. మీరు డిస్క్ స్థలం అయిపోతే, ఒకే ఒక మార్గం ఉంది - ఖాళీని ఖాళీ చేయండి మరియు డేటాబేస్ను పునఃప్రారంభించండి.

అవుట్-ఆఫ్-మెమరీ కిల్లర్

సర్వర్ లేదా ప్రాసెస్ మెమరీ అయిపోయినప్పుడు, Linux 2 పరిష్కారాలను అందిస్తుంది: మొత్తం సిస్టమ్‌ను క్రాష్ చేయండి లేదా మెమరీని తినే ప్రక్రియను (అప్లికేషన్) ముగించండి. ప్రక్రియను ముగించడం మరియు OS క్రాష్ కాకుండా సేవ్ చేయడం మంచిది. క్లుప్తంగా, అవుట్-ఆఫ్-మెమరీ కిల్లర్ అనేది కెర్నల్ క్రాష్ కాకుండా సేవ్ చేయడానికి అప్లికేషన్‌ను చంపే ప్రక్రియ. ఇది OS అమలులో ఉంచడానికి అప్లికేషన్‌ను త్యాగం చేస్తుంది. OOM ఎలా పని చేస్తుందో మరియు దానిని ఎలా నియంత్రించాలో మొదట చర్చిద్దాం, ఆపై OOM కిల్లర్ ఏ అప్లికేషన్‌ను ముగించాలో ఎలా నిర్ణయిస్తుందో చూద్దాం.

ప్రాసెస్‌లు కోరినప్పుడు మెమరీని కేటాయించడం Linux యొక్క ప్రధాన పని. సాధారణంగా, ఒక ప్రక్రియ లేదా అప్లికేషన్ OS నుండి మెమరీని అభ్యర్థిస్తుంది, కానీ దానిని పూర్తిగా ఉపయోగించదు. OS మెమరీని అడిగే ప్రతి ఒక్కరికీ అందించినట్లయితే, దానిని ఉపయోగించుకునే ఆలోచన లేనట్లయితే, అతి త్వరలో మెమరీ అయిపోతుంది మరియు సిస్టమ్ విఫలమవుతుంది. దీన్ని నివారించడానికి, OS ప్రాసెస్ కోసం మెమరీని రిజర్వ్ చేస్తుంది, కానీ వాస్తవానికి దానిని కేటాయించదు. ఒక ప్రక్రియ వాస్తవానికి దానిని ఉపయోగించబోతున్నప్పుడు మాత్రమే మెమరీ కేటాయించబడుతుంది. OSకి ఉచిత మెమరీ లేదు, కానీ అది ఒక ప్రాసెస్‌కి మెమరీని కేటాయిస్తుంది మరియు ఒక ప్రాసెస్‌కి అవసరమైనప్పుడు, OS అది వీలైతే దాన్ని కేటాయిస్తుంది. ప్రతికూలత ఏమిటంటే, కొన్నిసార్లు OS మెమరీని నిల్వ చేస్తుంది, కానీ సరైన సమయంలో ఉచిత మెమరీ లేదు మరియు సిస్టమ్ క్రాష్ అవుతుంది. ఈ దృష్టాంతంలో OOM ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది మరియు కెర్నల్ భయాందోళనలకు గురికాకుండా నిరోధించడానికి ప్రక్రియలను ముగించింది. PostgreSQL ప్రక్రియను ముగించవలసి వచ్చినప్పుడు, లాగ్‌లో సందేశం కనిపిస్తుంది:

Out of Memory: Killed process 12345 (postgres).

సిస్టమ్ మెమరీలో తక్కువగా ఉంటే మరియు దానిని విడుదల చేయలేకపోతే, ఫంక్షన్ అంటారు out_of_memory. ఈ దశలో, ఆమె చేయవలసినది ఒక్కటే మిగిలి ఉంది - ఒకటి లేదా అంతకంటే ఎక్కువ ప్రక్రియలను పూర్తి చేయండి. OOM-కిల్లర్ ప్రక్రియను వెంటనే ముగించాలా లేదా వేచి ఉండగలదా? సహజంగానే, out_of_memory అని పిలవబడినప్పుడు, అది I/O ఆపరేషన్ కోసం వేచి ఉండటం లేదా డిస్క్‌కి పేజింగ్ చేయడం వల్ల వస్తుంది. అందువల్ల, OOM కిల్లర్ ముందుగా తనిఖీలు చేయాలి మరియు వాటి ఆధారంగా ప్రక్రియను ముగించాలని నిర్ణయించుకోవాలి. దిగువన ఉన్న అన్ని తనిఖీలు సానుకూలంగా ఉంటే, OOM ప్రక్రియను ముగిస్తుంది.

ప్రక్రియ ఎంపిక

మెమరీ అయిపోయినప్పుడు, ఫంక్షన్ అంటారు out_of_memory(). దీనికి ఒక ఫంక్షన్ ఉంది select_bad_process(), ఇది ఫంక్షన్ నుండి మూల్యాంకనాన్ని పొందుతుంది badness(). "చెత్త" ప్రక్రియ లక్ష్యంగా ఉంటుంది. ఫంక్షన్ badness() నిర్దిష్ట నిబంధనల ప్రకారం ప్రక్రియను ఎంచుకుంటుంది.

1. కెర్నల్‌కు కొంత కనీస మెమరీ అవసరం.
2. మీరు చాలా మెమరీని ఖాళీ చేయాలి.
3. తక్కువ మెమరీని ఉపయోగిస్తున్న ప్రక్రియలను ముగించాల్సిన అవసరం లేదు.
4. కనీస ప్రక్రియలు పూర్తి కావాలి.
5. వినియోగదారు స్వయంగా పూర్తి చేయాలనుకునే ప్రక్రియల కోసం పూర్తి చేసే అవకాశాలను పెంచే సంక్లిష్ట అల్గారిథమ్‌లు.

ఈ తనిఖీలన్నింటినీ పూర్తి చేసిన తర్వాత, OOM స్కోర్‌ను పరిశీలిస్తుంది (oom_score) OOM కేటాయిస్తుంది oom_score ప్రతి ప్రక్రియ, ఆపై ఈ విలువను మెమరీ మొత్తంతో గుణిస్తుంది. పెద్ద విలువలతో కూడిన ప్రక్రియలు OOM కిల్లర్‌కు గురయ్యే అవకాశం ఉంది. రూట్ వినియోగదారుతో అనుబంధించబడిన ప్రక్రియలు తక్కువ స్కోర్‌ను కలిగి ఉంటాయి మరియు బలవంతంగా ముగించబడే అవకాశం తక్కువ.

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

పోస్ట్‌గ్రెస్ ప్రాసెస్ ID 3813, కాబట్టి మరొక షెల్‌లో ఈ కెర్నల్ పరామితిని ఉపయోగించి స్కోర్‌ను పొందడం సాధ్యమవుతుంది oom_score:

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

మీరు OOM-కిల్లర్ ప్రక్రియను పూర్తిగా చంపకూడదనుకుంటే, మరొక కెర్నల్ ఎంపిక ఉంది: oom_score_adj. మీరు విలువైన ప్రక్రియను పూర్తి చేసే అవకాశాలను తగ్గించడానికి పెద్ద ప్రతికూల విలువను జోడించండి.

sudo echo -100 > /proc/3813/oom_score_adj

విలువను సెట్ చేయడానికి oom_score_adj, సర్వీస్ బ్లాక్‌లో OOMScoreAdjustని సెట్ చేయండి:

[Service]
OOMScoreAdjust=-1000

లేదా ఉపయోగించండి oomprotect ఒక జట్టులో rcctl.

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

ప్రక్రియను బలవంతంగా ముగించడం

ఒకటి లేదా అంతకంటే ఎక్కువ ప్రక్రియలు ఇప్పటికే ఎంపిక చేయబడినప్పుడు, OOM-కిల్లర్ ఫంక్షన్‌ని పిలుస్తుంది oom_kill_task(). ఈ ఫంక్షన్ ప్రక్రియకు ముగింపు సంకేతాన్ని పంపుతుంది. మెమరీ కొరత విషయంలో oom_kill() ప్రాసెస్‌కి SIGKILL సిగ్నల్‌ని పంపడానికి ఈ ఫంక్షన్‌కి కాల్ చేస్తుంది. కెర్నల్ లాగ్‌కు సందేశం వ్రాయబడింది.

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

OOM-కిల్లర్‌ని ఎలా నియంత్రించాలి

Linuxలో, మీరు OOM-కిల్లర్‌ని ప్రారంభించవచ్చు లేదా నిలిపివేయవచ్చు (అయితే రెండోది సిఫార్సు చేయబడలేదు). ఎనేబుల్ లేదా డిసేబుల్ పారామీటర్ ఉపయోగించండి vm.oom-kill. రన్‌టైమ్‌లో OOM-కిల్లర్‌ని ప్రారంభించడానికి, ఆదేశాన్ని అమలు చేయండి sysctl.

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

OOM-కిల్లర్‌ని నిలిపివేయడానికి, అదే ఆదేశంలో విలువ 0ని పేర్కొనండి:

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

ఈ ఆదేశం యొక్క ఫలితం ఎప్పటికీ సేవ్ చేయబడదు, కానీ మొదటి రీబూట్ వరకు మాత్రమే. మీకు మరింత పట్టుదల అవసరమైతే, ఫైల్‌కి ఈ పంక్తిని జోడించండి /etc/sysctl.conf:

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

ఎనేబుల్ మరియు డిసేబుల్ చేయడానికి మరొక మార్గం వేరియబుల్ రాయడం panic_on_oom. విలువను ఎల్లప్పుడూ చెక్ ఇన్ చేయవచ్చు /proc.

$ cat /proc/sys/vm/panic_on_oom
0

మీరు విలువను 0కి సెట్ చేస్తే, మెమరీ అయిపోయినప్పుడు, కెర్నల్ పానిక్ ఉండదు.

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

మీరు విలువను 1కి సెట్ చేస్తే, మెమరీ అయిపోయినప్పుడు, కెర్నల్ పానిక్ ఏర్పడుతుంది.

echo 1 > /proc/sys/vm/panic_on_oom

OOM-కిల్లర్ ఆన్ మరియు ఆఫ్ మాత్రమే కాదు. Linux ప్రాసెస్‌ల కోసం అందుబాటులో ఉన్న దానికంటే ఎక్కువ మెమరీని కేటాయించకుండానే రిజర్వ్ చేయగలదని మేము ఇప్పటికే చెప్పాము మరియు ఈ ప్రవర్తన Linux కెర్నల్ పారామీటర్ ద్వారా నియంత్రించబడుతుంది. వేరియబుల్ దీనికి బాధ్యత వహిస్తుంది vm.overcommit_memory.

మీరు దాని కోసం క్రింది విలువలను పేర్కొనవచ్చు:

0: ఎక్కువ మెమరీని రిజర్వ్ చేయాలా వద్దా అని కెర్నల్ స్వయంగా నిర్ణయిస్తుంది. Linux యొక్క చాలా సంస్కరణల్లో ఇది డిఫాల్ట్.
1: కెర్నల్ ఎల్లప్పుడూ అదనపు మెమరీని రిజర్వ్ చేస్తుంది. ఇది ప్రమాదకరం, ఎందుకంటే మెమరీ అయిపోవచ్చు, ఎందుకంటే, చాలా మటుకు, ఒక రోజు ప్రక్రియలకు ఇది అవసరం అవుతుంది.
2: కెర్నల్ పారామీటర్‌లో పేర్కొన్న దానికంటే ఎక్కువ మెమరీని రిజర్వ్ చేయదు overcommit_ratio.

ఈ పరామితితో, మీరు ఓవర్ రిజర్వ్ చేయడానికి అనుమతించబడిన మెమరీ శాతాన్ని పేర్కొనండి. దానికి స్థలం లేకపోతే, మెమరీ కేటాయించబడదు మరియు రిజర్వేషన్ నిరాకరించబడుతుంది. ఇది PostgreSQL కోసం సిఫార్సు చేయబడిన సురక్షితమైన ఎంపిక. OOM-కిల్లర్ మరొక మూలకం ద్వారా ప్రభావితమవుతుంది - మార్పిడి సామర్ధ్యం, ఇది వేరియబుల్ ద్వారా నియంత్రించబడుతుంది cat /proc/sys/vm/swappiness. ఈ విలువలు పేజింగ్‌ను ఎలా నిర్వహించాలో కెర్నల్‌కు తెలియజేస్తాయి. అధిక విలువ, OOM ప్రక్రియను ముగించే అవకాశం తక్కువగా ఉంటుంది, కానీ I/O ఆపరేషన్ల కారణంగా ఇది డేటాబేస్‌పై ప్రతికూల ప్రభావాన్ని చూపుతుంది. మరియు వైస్ వెర్సా - తక్కువ విలువ, OOM-కిల్లర్ జోక్యం యొక్క సంభావ్యత ఎక్కువగా ఉంటుంది, కానీ డేటాబేస్ పనితీరు కూడా ఎక్కువగా ఉంటుంది. డిఫాల్ట్ విలువ 60, కానీ మొత్తం డేటాబేస్ మెమరీలో సరిపోతుంటే, విలువను 1కి సెట్ చేయడం మంచిది.

ఫలితాలు

OOM-కిల్లర్‌లోని "కిల్లర్" మిమ్మల్ని భయపెట్టనివ్వవద్దు. ఈ సందర్భంలో, కిల్లర్ మీ సిస్టమ్ యొక్క రక్షకుడిగా ఉంటారు. ఇది చెత్త ప్రక్రియలను "చంపుతుంది" మరియు క్రాష్ నుండి సిస్టమ్‌ను సేవ్ చేస్తుంది. PostgreSQLని ముగించడానికి OOM-కిల్లర్‌ని ఉపయోగించకుండా ఉండటానికి, సెట్ చేయండి vm.overcommit_memory విలువ 2. OOM-కిల్లర్ జోక్యం చేసుకోనవసరం లేదని ఇది హామీ ఇవ్వదు, అయితే ఇది PostgreSQL ప్రక్రియను బలవంతంగా ముగించే అవకాశాన్ని తగ్గిస్తుంది.

మూలం: www.habr.com