Out-Of-Memory Killer-ის დაყენება Linux PostgreSQL-ისთვის

როდესაც შიგნით Linux მონაცემთა ბაზის სერვერი მოულოდნელად ითიშება და მიზეზის დადგენაა საჭირო. შეიძლება რამდენიმე მიზეზი არსებობდეს. მაგალითად, SIGSEGV — წარუმატებლობა Backend სერვერზე არსებული შეცდომის გამო. მაგრამ ეს იშვიათია. ყველაზე ხშირად, თქვენ უბრალოდ ამოგეწურებათ დისკის ადგილი ან მეხსიერება. თუ დისკზე სივრცე ამოგეწურებათ, გამოსავალი მხოლოდ ერთია - გაათავისუფლეთ სივრცე და გადატვირთეთ მონაცემთა ბაზა.

მეხსიერების გარეშე მკვლელი

როდესაც შენ სერვერი ან პროცესს მეხსიერება ეწურება, 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-მკვლელმა პროცესი დაუყოვნებლივ თუ შეიძლება დაელოდოს? ცხადია, როდესაც 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 პროცესის 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, დააყენეთ OOMScore Adjust სერვისის ბლოკში:

[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-ში შეგაშინოთ. ამ შემთხვევაში მკვლელი იქნება თქვენი სისტემის მხსნელი. ის „კლავს“ ყველაზე ცუდ პროცესებს და იხსნის სისტემას ავარიისგან. იმისათვის, რომ არ დაგჭირდეთ OOM-Killer-ის გამოყენება PostgreSQL-ის შესაწყვეტად, დააყენეთ vm.overcommit_memory მნიშვნელობა 2. ეს არ იძლევა გარანტიას, რომ OOM-Killer-ს არ მოუწევს ჩარევა, მაგრამ ეს შეამცირებს PostgreSQL პროცესის იძულების შეწყვეტის ალბათობას.

წყარო: www.habr.com