🥇అవుట్-ఆఫ్-మెమరీ కిల్లర్‌ను కాన్ఫిగర్ చేయడం Linux PostgreSQL కోసం

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

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

మీరు ఎప్పుడు సర్వర్ లేదా ప్రాసెస్ మెమరీ అయిపోతుంది, Linux అవుట్-ఆఫ్-మెమరీ కిల్లర్ రెండు పరిష్కారాలను అందిస్తుంది: మొత్తం సిస్టమ్‌ను క్రాష్ చేయడం లేదా మెమరీని ఎక్కువగా వాడుతున్న ప్రాసెస్‌ను (అప్లికేషన్‌ను) టెర్మినేట్ చేయడం. వాస్తవానికి, ప్రాసెస్‌ను టెర్మినేట్ చేసి, 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() నిర్దిష్ట నిబంధనల ప్రకారం ప్రక్రియను ఎంచుకుంటుంది.

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

ఈ తనిఖీలన్నింటినీ పూర్తి చేసిన తర్వాత, 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-Killerను ఎనేబుల్ లేదా డిసేబుల్ చేయవచ్చు (అయితే డిసేబుల్ చేయడం సిఫార్సు చేయబడదు). దానిని ఎనేబుల్ లేదా డిసేబుల్ చేయడానికి, ఈ పారామీటర్‌ను ఉపయోగించండి. 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