🥇ការកំណត់រចនាសម្ព័ន្ធ Out-Of-Memory Killer ក្នុង Linux សម្រាប់ PostgreSQL

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

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

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

ភារកិច្ចចម្បងមួយ Linux — បែងចែកអង្គចងចាំទៅដំណើរការនៅពេលដែលពួកគេស្នើសុំវា។ ជាធម្មតា ដំណើរការ ឬកម្មវិធីស្នើសុំអង្គចងចាំពីប្រព័ន្ធប្រតិបត្តិការ ប៉ុន្តែមិនប្រើប្រាស់វាទាំងស្រុងទេ។ ប្រសិនបើប្រព័ន្ធប្រតិបត្តិការបែងចែកអង្គចងចាំទៅអ្នករាល់គ្នាដែលស្នើសុំវា ប៉ុន្តែមិនមានគម្រោងប្រើប្រាស់វាទេ ប្រព័ន្ធនឹងអស់អង្គចងចាំយ៉ាងឆាប់រហ័ស ហើយប្រព័ន្ធនឹងគាំង។ ដើម្បីទប់ស្កាត់បញ្ហានេះ ប្រព័ន្ធប្រតិបត្តិការបម្រុងទុកអង្គចងចាំសម្រាប់ដំណើរការមួយ ប៉ុន្តែមិនបែងចែកវាពិតប្រាកដទេ។ អង្គចងចាំត្រូវបានបែងចែកតែនៅពេលដែលដំណើរការមួយពិតជាមានបំណងប្រើប្រាស់វាប៉ុណ្ណោះ។ ពេលខ្លះប្រព័ន្ធប្រតិបត្តិការមិនមានអង្គចងចាំទំនេរទេ ប៉ុន្តែវាបែងចែកអង្គចងចាំទៅដំណើរការមួយ ហើយនៅពេលដែលដំណើរការត្រូវការវា ប្រព័ន្ធប្រតិបត្តិការនឹងបែងចែកវាប្រសិនបើវាអាចធ្វើបាន។ ចំណុចអវិជ្ជមានគឺថា ពេលខ្លះប្រព័ន្ធប្រតិបត្តិការបម្រុងទុកអង្គចងចាំ ប៉ុន្តែនៅពេលដែលត្រូវការ មិនមានអង្គចងចាំទំនេរទេ ដែលបណ្តាលឱ្យប្រព័ន្ធគាំង។ 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() ជ្រើសរើសដំណើរការមួយយោងទៅតាមច្បាប់ជាក់លាក់។

ខឺណែលត្រូវការអង្គចងចាំអប្បបរមាខ្លះសម្រាប់ខ្លួនវា។
អ្នកត្រូវបង្កើនអង្គចងចាំឱ្យបានច្រើន។
មិនចាំបាច់បញ្ចប់ដំណើរការដែលកំពុងប្រើអង្គចងចាំតិចតួចទេ។
ដំណើរការអប្បបរមាចាំបាច់ត្រូវបញ្ចប់។
ក្បួនដោះស្រាយស្មុគស្មាញដែលបង្កើនឱកាសនៃការបញ្ចប់សម្រាប់ដំណើរការទាំងនោះដែលអ្នកប្រើប្រាស់ខ្លួនគាត់ចង់បញ្ចប់។

ដោយបានបញ្ចប់ការត្រួតពិនិត្យទាំងអស់នេះ 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

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

ប្រភព: www.habr.com