ការដំឡើង Out-Of-Memory Killer នៅក្នុង Linux សម្រាប់ PostgreSQL

នៅពេលដែលម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យបិទដោយមិនបានរំពឹងទុកនៅក្នុងលីនុច អ្នកត្រូវស្វែងរកមូលហេតុ។ វាអាចមានហេតុផលជាច្រើន។ ឧទាហរណ៍, SIGSEGV - ការបរាជ័យដោយសារតែកំហុសនៅក្នុងម៉ាស៊ីនមេខាងក្រោយ។ ប៉ុន្តែនេះគឺកម្រណាស់។ ភាគច្រើន អ្នកគ្រាន់តែអស់ទំហំថាស ឬអង្គចងចាំ។ ប្រសិន​បើ​អ្នក​អស់​ទំហំ​ផ្ទុក​ថាស មាន​ផ្លូវ​តែ​មួយ​គត់​គឺ​បង្កើន​ទំហំ​ទំនេរ ហើយ​ចាប់ផ្ដើម​មូលដ្ឋាន​ទិន្នន័យ​ឡើង​វិញ។

ឃាតករក្រៅសតិ

នៅពេលដែលម៉ាស៊ីនមេ ឬដំណើរការអស់អង្គចងចាំ លីនុចផ្តល់ដំណោះស្រាយ 2៖ គាំងប្រព័ន្ធទាំងមូល ឬបញ្ចប់ដំណើរការ (កម្មវិធី) ដែលស៊ីអង្គចងចាំ។ វាជាការប្រសើរក្នុងការបញ្ចប់ដំណើរការ និងរក្សាទុក OS ពីការគាំង។ សរុបមក Out-Of-Memory Killer គឺជាដំណើរការដែលសម្លាប់កម្មវិធីមួយដើម្បីរក្សាទុកខឺណែលពីការគាំង។ វាលះបង់កម្មវិធីដើម្បីរក្សាប្រព័ន្ធប្រតិបត្តិការ។ ដំបូងយើងពិភាក្សាពីរបៀបដែល OOM ដំណើរការ និងរបៀបគ្រប់គ្រងវា ហើយបន្ទាប់មកមើលពីរបៀបដែល OOM Killer សម្រេចថាតើកម្មវិធីមួយណាដែលត្រូវបញ្ចប់។

ភារកិច្ចចម្បងមួយនៃលីនុចគឺត្រូវបែងចែកអង្គចងចាំសម្រាប់ដំណើរការនៅពេលដែលពួកគេស្នើសុំវា។ ជាធម្មតា ដំណើរការ ឬកម្មវិធីស្នើសុំអង្គចងចាំពីប្រព័ន្ធប្រតិបត្តិការ ប៉ុន្តែមិនអាចប្រើវាបានពេញលេញទេ។ ប្រសិនបើ OS ផ្តល់អង្គចងចាំដល់អ្នករាល់គ្នាដែលស្នើសុំវា ប៉ុន្តែមិនមានគម្រោងប្រើវាទេ ឆាប់ៗនេះ អង្គចងចាំនឹងអស់ ហើយប្រព័ន្ធនឹងបរាជ័យ។ ដើម្បីជៀសវាងបញ្ហានេះ ប្រព័ន្ធប្រតិបត្តិការរក្សាទុកអង្គចងចាំសម្រាប់ដំណើរការ ប៉ុន្តែពិតជាមិនបានបញ្ចេញវាទេ។ អង្គចងចាំត្រូវបានបែងចែកតែនៅពេលដែលដំណើរការពិតជានឹងប្រើវា។ វាកើតឡើងថា OS មិនមានអង្គចងចាំឥតគិតថ្លៃ ប៉ុន្តែវាផ្តល់អង្គចងចាំទៅដំណើរការមួយ ហើយនៅពេលដែលដំណើរការត្រូវការវា OS បែងចែកវាប្រសិនបើវាអាច។ គុណវិបត្តិគឺថាពេលខ្លះ OS រក្សាទុកអង្គចងចាំ ប៉ុន្តែនៅពេលត្រឹមត្រូវមិនមានអង្គចងចាំទំនេរទេ ហើយប្រព័ន្ធគាំង។ OOM ដើរតួនាទីយ៉ាងសំខាន់នៅក្នុងសេណារីយ៉ូនេះ និងបញ្ចប់ដំណើរការដើម្បីការពារខឺណែលពីការភ័យស្លន់ស្លោ។ នៅពេលដែលដំណើរការ PostgreSQL ត្រូវបានបង្ខំឱ្យបញ្ចប់ សារមួយលេចឡើងក្នុងកំណត់ហេតុ៖

Out of Memory: Killed process 12345 (postgres).

ប្រសិនបើប្រព័ន្ធមានអង្គចងចាំទាប ហើយវាមិនអាចត្រូវបានដោះលែងទេ មុខងារត្រូវបានហៅ out_of_memory. នៅដំណាក់កាលនេះ នាងនៅសល់តែកិច្ចការមួយគត់ដែលត្រូវធ្វើ គឺបំពេញដំណើរការមួយ ឬច្រើន។ តើ OOM-killer គួរតែបញ្ចប់ដំណើរការភ្លាមៗ ឬអាចរង់ចាំបាន? ជាក់ស្តែងនៅពេលដែល 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។ ដំណើរការដែលភ្ជាប់ជាមួយអ្នកប្រើប្រាស់ root មានពិន្ទុទាបជាង ហើយទំនងជាមិនសូវត្រូវបានបង្ខំឱ្យបញ្ចប់នោះទេ។

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

លេខសម្គាល់ដំណើរការ Postgres គឺ 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

នៅលើលីនុច អ្នកអាចបើក ឬបិទ 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 មិនត្រឹមតែអាចបើក និងបិទប៉ុណ្ណោះទេ។ យើងបាននិយាយរួចមកហើយថាលីនុចអាចបម្រុងទុកអង្គចងចាំបានច្រើនសម្រាប់ដំណើរការជាងដែលអាចប្រើបានដោយមិនចាំបាច់បែងចែកវា ហើយឥរិយាបថនេះត្រូវបានគ្រប់គ្រងដោយប៉ារ៉ាម៉ែត្រខឺណែលលីនុច។ អថេរទទួលខុសត្រូវចំពោះបញ្ហានេះ vm.overcommit_memory.

អ្នកអាចបញ្ជាក់តម្លៃខាងក្រោមសម្រាប់វា៖

0: ខឺណែលខ្លួនឯងសម្រេចចិត្តថាតើត្រូវរក្សាទុកអង្គចងចាំច្រើនពេកឬអត់។ នេះគឺជាលំនាំដើមនៅលើកំណែភាគច្រើននៃលីនុច។
1: ខឺណែលនឹងរក្សាទុកអង្គចងចាំបន្ថែមជានិច្ច។ នេះគឺជាការប្រថុយប្រថាន ពីព្រោះអង្គចងចាំអាចនឹងអស់ ព្រោះទំនងជាថ្ងៃណាមួយ ដំណើរការនឹងត្រូវការវា។
2: ខឺណែល​នឹង​មិន​ទុក​អង្គ​ចងចាំ​ច្រើន​ជាង​ការ​បញ្ជាក់​ក្នុង​ប៉ារ៉ាម៉ែត្រ​ទេ។ overcommit_ratio.

ជាមួយនឹងប៉ារ៉ាម៉ែត្រនេះ អ្នកបញ្ជាក់ភាគរយនៃអង្គចងចាំដែលត្រូវបានអនុញ្ញាតឱ្យរក្សាទុកលើស។ ប្រសិនបើ​គ្មាន​កន្លែង​សម្រាប់​វា​ទេ នោះ​ការ​ចងចាំ​មិន​ត្រូវ​បាន​បែងចែក​ទេ ហើយ​ការ​កក់​ទុក​នឹង​ត្រូវ​បដិសេធ។ នេះគឺជាជម្រើសសុវត្ថិភាពបំផុតដែលត្រូវបានណែនាំសម្រាប់ PostgreSQL ។ OOM-Killer ត្រូវបានប៉ះពាល់ដោយធាតុមួយផ្សេងទៀត - សមត្ថភាពផ្លាស់ប្តូរ ដែលត្រូវបានគ្រប់គ្រងដោយអថេរ cat /proc/sys/vm/swappiness. តម្លៃទាំងនេះប្រាប់ខឺណែលពីរបៀបគ្រប់គ្រងទំព័រ។ តម្លៃកាន់តែខ្ពស់ វាទំនងជាតិចជាងដែល OOM នឹងបញ្ចប់ដំណើរការ ប៉ុន្តែដោយសារប្រតិបត្តិការ I/O វាមានផលប៉ះពាល់អវិជ្ជមានលើមូលដ្ឋានទិន្នន័យ។ ហើយផ្ទុយមកវិញ - តម្លៃកាន់តែទាប លទ្ធភាពនៃការអន្តរាគមន៍ OOM-Killer កាន់តែខ្ពស់ ប៉ុន្តែដំណើរការនៃមូលដ្ឋានទិន្នន័យក៏ខ្ពស់ជាងដែរ។ តម្លៃលំនាំដើមគឺ 60 ប៉ុន្តែប្រសិនបើមូលដ្ឋានទិន្នន័យទាំងមូលសមនឹងអង្គចងចាំ វាជាការប្រសើរក្នុងការកំណត់តម្លៃទៅ 1 ។

លទ្ធផល

កុំអោយ "ឃាតករ" នៅក្នុង OOM-Killer បំភ័យអ្នក។ ក្នុងករណីនេះ ឃាតករនឹងជាអ្នកសង្គ្រោះប្រព័ន្ធរបស់អ្នក។ វា "សម្លាប់" ដំណើរការដ៏អាក្រក់បំផុត និងរក្សាទុកប្រព័ន្ធពីការគាំង។ ដើម្បីជៀសវាងការប្រើ OOM-Killer ដើម្បីបញ្ចប់ PostgreSQL សូមកំណត់ទៅ vm.overcommit_memory តម្លៃ 2. នេះមិនធានាថា OOM-Killer នឹងមិនចាំបាច់ធ្វើអន្តរាគមន៍នោះទេ ប៉ុន្តែវានឹងកាត់បន្ថយលទ្ធភាពនៃការបង្ខំឱ្យដំណើរការ PostgreSQL បញ្ចប់។

ប្រភព: www.habr.com