PostgreSQL සඳහා Linux හි Out-Of-Memory Killer පිහිටුවීම

Linux හි දත්ත සමුදා සේවාදායකයක් අනපේක්ෂිත ලෙස ඉවත් වූ විට, ඔබ හේතුව සොයා ගත යුතුය. හේතු කිහිපයක් තිබිය හැක. උදාහරණ වශයෙන්, SIGSEGV - පසුපෙළ සේවාදායකයේ දෝෂයක් හේතුවෙන් අසාර්ථක වීම. නමුත් මෙය දුර්ලභ ය. බොහෝ විට, ඔබට තැටි ඉඩ හෝ මතකය අවසන් වේ. ඔබට තැටියේ ඉඩ නොමැති නම්, ඇත්තේ එක් මාර්ගයක් පමණි - ඉඩ නිදහස් කර දත්ත සමුදාය නැවත ආරම්භ කරන්න.

මතකයෙන් බැහැර ඝාතකයා

සේවාදායකයක් හෝ ක්‍රියාවලියක් මතකය අවසන් වූ විට, Linux විසඳුම් 2ක් ඉදිරිපත් කරයි: සම්පූර්ණ පද්ධතියම බිඳ දමන්න හෝ මතකය විනාශ කරන ක්‍රියාවලිය (යෙදුම) අවසන් කරන්න. ඇත්ත වශයෙන්ම, ක්‍රියාවලිය අවසන් කර මෙහෙයුම් පද්ධතිය බිඳ වැටීමෙන් සුරැකීම වඩා හොඳය. කෙටියෙන් කිවහොත්, Out-Of-Memory Killer යනු කර්නලය බිඳ වැටීමෙන් සුරැකීමට යෙදුමක් විනාශ කරන ක්‍රියාවලියකි. එය OS ක්‍රියාත්මක වීමට යෙදුම කැප කරයි. අපි මුලින්ම OOM ක්‍රියා කරන ආකාරය සහ එය පාලනය කරන්නේ කෙසේද යන්න සාකච්ඡා කරමු, ඉන්පසු OOM Killer කුමන යෙදුම අවසන් කළ යුතුද යන්න තීරණය කරන්නේ කෙසේදැයි බලමු.

Linux හි ප්‍රධාන කාර්යයක් වන්නේ ක්‍රියාවලි සඳහා මතකය ඉල්ලා සිටින විට එය වෙන් කිරීමයි. සාමාන්‍යයෙන්, ක්‍රියාවලියක් හෝ යෙදුමක් 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 Killer ට ගොදුරු වීමට වැඩි ඉඩක් ඇත. මූල පරිශීලකයා හා සම්බන්ධ ක්‍රියාවලීන්ට අඩු ලකුණු ඇති අතර අවසන් කිරීමට බල කිරීමට ඇති ඉඩකඩ අඩුය.

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

Postgres process ID එක 3813, එබැවින් වෙනත් කවචයක මෙම කර්නල් පරාමිතිය භාවිතයෙන් ලකුණු ලබා ගත හැක. oom_score:

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

OOM-Killer ක්‍රියාවලිය සම්පූර්ණයෙන්ම විනාශ කිරීමට ඔබට අවශ්‍ය නැතිනම්, තවත් කර්නල් විකල්පයක් ඇත: 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-Killer ශ්‍රිතය අමතයි oom_kill_task(). මෙම කාර්යය ක්රියාවලිය අවසන් කිරීමේ සංඥාවක් යවයි. මතකය අඩු වුනොත් oom_kill() ක්‍රියාවලියට SIGKILL සංඥාවක් යැවීමට මෙම ශ්‍රිතය අමතයි. කර්නල් ලොගයට පණිවිඩයක් ලියා ඇත.

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

OOM-Killer පාලනය කරන්නේ කෙසේද?

Linux මත, ඔබට OOM-Killer සක්‍රිය හෝ අක්‍රිය කළ හැක (දෙවැන්න නිර්දේශ කර නැතත්). සක්රිය හෝ අක්රිය කිරීමට පරාමිතිය භාවිතා කරන්න vm.oom-kill. ධාවන වේලාවේදී OOM-Killer සබල කිරීමට, විධානය ක්‍රියාත්මක කරන්න sysctl.

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

OOM-Killer අක්‍රිය කිරීමට, එම විධානයේම 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-Killer සක්‍රිය සහ අක්‍රිය කිරීම පමණක් කළ නොහැක. අපි දැනටමත් පවසා ඇත්තේ Linux හට ක්‍රියාවලි සඳහා පවතින මතකයට වඩා වැඩි මතකයක් වෙන්කර නොගෙන එය වෙන් කර ගත හැකි බවත්, මෙම හැසිරීම Linux kernel පරාමිතියකින් පාලනය වන බවත්ය. විචල්‍යය මේ සඳහා වගකිව යුතුය vm.overcommit_memory.

ඔබට එය සඳහා පහත අගයන් නියම කළ හැකිය:

0: වැඩි මතකයක් වෙන්කර ගත යුතුද යන්න කර්නලය විසින්ම තීරණය කරයි. Linux හි බොහෝ අනුවාද වල පෙරනිමිය මෙයයි.
1: කර්නලය සෑම විටම අමතර මතකයක් වෙන් කරයි. මෙය අවදානම් සහගත ය, මන්ද මතකය අවසන් විය හැක, මන්ද, බොහෝ විට, එක් දිනක් ක්රියාවලීන් එය අවශ්ය වනු ඇත.
2: කර්නලය පරාමිතියෙහි දක්වා ඇති මතකයට වඩා වැඩි මතකයක් වෙන්කර නොගනී overcommit_ratio.

මෙම පරාමිතිය සමඟ, ඔබ වැඩිපුර වෙන් කිරීමට ඉඩ දී ඇති මතකයේ ප්රතිශතය සඳහන් කරයි. ඒ සඳහා ඉඩක් නොමැති නම්, මතකයක් වෙන් නොකෙරේ, වෙන් කිරීම ප්රතික්ෂේප කරනු ලැබේ. PostgreSQL සඳහා නිර්දේශිත ආරක්ෂිතම විකල්පය මෙයයි. OOM-Killer වෙනත් මූලද්‍රව්‍යයකින් බලපායි - හුවමාරු කිරීමේ හැකියාව, විචල්‍යය මගින් පාලනය වේ cat /proc/sys/vm/swappiness. මෙම අගයන් පේජිං හැසිරවිය යුතු ආකාරය කර්නලයට කියයි. අගය වැඩි වන තරමට, OOM ක්‍රියාවලිය අවසන් කිරීමට ඇති ඉඩකඩ අඩුය, නමුත් I/O මෙහෙයුම් හේතුවෙන් එය දත්ත සමුදාය මත ඍණාත්මක බලපෑමක් ඇති කරයි. සහ අනෙක් අතට - අඩු අගය, OOM-Killer මැදිහත්වීමේ සම්භාවිතාව වැඩි, නමුත් දත්ත සමුදායේ කාර්ය සාධනය ද ඉහළ ය. පෙරනිමි අගය 60 වේ, නමුත් සම්පූර්ණ දත්ත ගබඩාව මතකයට ගැලපේ නම්, අගය 1 ලෙස සැකසීම වඩා හොඳය.

ප්රතිඵල

OOM-Killer හි "ඝාතකයා" ඔබව බිය ගැන්වීමට ඉඩ නොදෙන්න. මෙම අවස්ථාවේ දී, ඝාතකයා ඔබේ පද්ධතියේ ගැලවුම්කරු වනු ඇත. එය නරකම ක්රියාවලීන් "මරන" සහ පද්ධතිය බිඳ වැටීමෙන් බේරා ගනී. PostgreSQL අවසන් කිරීමට OOM-Killer භාවිතා කිරීම වළක්වා ගැනීමට, ලෙස සකසන්න vm.overcommit_memory අගය 2. OOM-Killer හට මැදිහත් වීමට සිදු නොවන බවට මෙය සහතික නොවේ, නමුත් එය PostgreSQL ක්‍රියාවලිය අවසන් කිරීමට බලකිරීමේ සම්භාවිතාව අඩු කරනු ඇත.

මූලාශ්රය: www.habr.com