მეხსიერების გარეშე მკვლელის დაყენება Linux-ში PostgreSQL-ისთვის

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

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

როდესაც სერვერს ან პროცესს მეხსიერება ამოიწურება, Linux გთავაზობთ 2 გადაწყვეტილებას: ავარია მთელი სისტემის ან პროცესის (აპლიკაციის) შეწყვეტა, რომელიც ჭამს მეხსიერებას. უმჯობესია, რა თქმა უნდა, შეწყვიტოთ პროცესი და გადავარჩინოთ OS ავარიისგან. მოკლედ, Out-Of-Memory Killer არის პროცესი, რომელიც კლავს აპლიკაციას ბირთვის ავარიისგან გადასარჩენად. ის სწირავს აპლიკაციას ოპერაციული სისტემის შესანარჩუნებლად. მოდით ჯერ განვიხილოთ, თუ როგორ მუშაობს OOM და როგორ გავაკონტროლოთ იგი, შემდეგ კი ვნახოთ, როგორ გადაწყვეტს OOM Killer რომელი აპლიკაცია შეწყვიტოს.

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() ირჩევს პროცესს გარკვეული წესების მიხედვით.

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