🥇මතකයෙන් තොර ඝාතකයා වින්‍යාස කිරීම 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 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මේ සඳහා විචල්‍යය වගකිව යුතුය. 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