PostgreSQL ಗಾಗಿ Linux ನಲ್ಲಿ ಔಟ್-ಆಫ್-ಮೆಮೊರಿ ಕಿಲ್ಲರ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್ ಅನಿರೀಕ್ಷಿತವಾಗಿ ನಿರ್ಗಮಿಸಿದಾಗ, ನೀವು ಕಾರಣವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು. ಹಲವಾರು ಕಾರಣಗಳಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, SIGSEGV - ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ನಲ್ಲಿನ ದೋಷದಿಂದಾಗಿ ವೈಫಲ್ಯ. ಆದರೆ ಇದು ಅಪರೂಪ. ಹೆಚ್ಚಾಗಿ, ನೀವು ಡಿಸ್ಕ್ ಸ್ಥಳ ಅಥವಾ ಮೆಮೊರಿಯ ಕೊರತೆಯನ್ನು ಹೊಂದಿರುತ್ತೀರಿ. ನಿಮ್ಮ ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶವಿಲ್ಲದಿದ್ದರೆ, ಒಂದೇ ಒಂದು ಮಾರ್ಗವಿದೆ - ಜಾಗವನ್ನು ಮುಕ್ತಗೊಳಿಸಿ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ.

ಔಟ್-ಆಫ್-ಮೆಮೊರಿ ಕಿಲ್ಲರ್

ಸರ್ವರ್ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯು ಮೆಮೊರಿ ಖಾಲಿಯಾದಾಗ, ಲಿನಕ್ಸ್ 2 ಪರಿಹಾರಗಳನ್ನು ನೀಡುತ್ತದೆ: ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್ ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡಿ ಅಥವಾ ಮೆಮೊರಿಯನ್ನು ತಿನ್ನುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು (ಅಪ್ಲಿಕೇಶನ್) ಕೊನೆಗೊಳಿಸಿ. ಸಹಜವಾಗಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸುವುದು ಮತ್ತು OS ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಆಗದಂತೆ ಉಳಿಸುವುದು ಉತ್ತಮ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಔಟ್-ಆಫ್-ಮೆಮೊರಿ ಕಿಲ್ಲರ್ ಎನ್ನುವುದು ಕರ್ನಲ್ ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಆಗದಂತೆ ಉಳಿಸಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕೊಲ್ಲುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. OS ಅನ್ನು ಚಾಲನೆಯಲ್ಲಿಡಲು ಇದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತದೆ. OOM ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ನಿಯಂತ್ರಿಸಬೇಕು ಎಂಬುದನ್ನು ಮೊದಲು ಚರ್ಚಿಸೋಣ, ಮತ್ತು OOM ಕಿಲ್ಲರ್ ಯಾವ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಬೇಕೆಂದು ಹೇಗೆ ನಿರ್ಧರಿಸುತ್ತಾನೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ಲಿನಕ್ಸ್‌ನ ಮುಖ್ಯ ಕಾರ್ಯವೆಂದರೆ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಮೆಮೊರಿಯನ್ನು ಕೇಳಿದಾಗ ಅದನ್ನು ನಿಯೋಜಿಸುವುದು. ವಿಶಿಷ್ಟವಾಗಿ, ಪ್ರಕ್ರಿಯೆ ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್ 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 ಕಿಲ್ಲರ್‌ಗೆ ಬಲಿಯಾಗುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು. ರೂಟ್ ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂಯೋಜಿತವಾಗಿರುವ ಪ್ರಕ್ರಿಯೆಗಳು ಕಡಿಮೆ ಸ್ಕೋರ್ ಅನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಬಲವಂತವಾಗಿ ಕೊನೆಗೊಳ್ಳುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ.

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

ಪೋಸ್ಟ್‌ಗ್ರೆಸ್ ಪ್ರಕ್ರಿಯೆ ID 3813 ಆಗಿದೆ, ಆದ್ದರಿಂದ ಇನ್ನೊಂದು ಶೆಲ್‌ನಲ್ಲಿ ಈ ಕರ್ನಲ್ ಪ್ಯಾರಾಮೀಟರ್ ಬಳಸಿ ಸ್ಕೋರ್ ಪಡೆಯಲು ಸಾಧ್ಯವಿದೆ oom_score:

vagrant@vagrant:~$ sudo cat /proc/3813/oom_score
2

OOM-ಕಿಲ್ಲರ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕೊಲ್ಲಲು ನೀವು ಬಯಸದಿದ್ದರೆ, ಇನ್ನೊಂದು ಕರ್ನಲ್ ಆಯ್ಕೆ ಇದೆ: 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-ಕಿಲ್ಲರ್ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ oom_kill_task(). ಈ ಕಾರ್ಯವು ಪ್ರಕ್ರಿಯೆಗೆ ಮುಕ್ತಾಯ ಸಂಕೇತವನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಮೆಮೊರಿ ಕೊರತೆಯ ಸಂದರ್ಭದಲ್ಲಿ oom_kill() ಪ್ರಕ್ರಿಯೆಗೆ SIGKILL ಸಂಕೇತವನ್ನು ಕಳುಹಿಸಲು ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ. ಕರ್ನಲ್ ಲಾಗ್‌ಗೆ ಸಂದೇಶವನ್ನು ಬರೆಯಲಾಗಿದೆ.

Out of Memory: Killed process [pid] [name].

OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಹೇಗೆ ನಿಯಂತ್ರಿಸುವುದು

Linux ನಲ್ಲಿ, ನೀವು OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬಹುದು ಅಥವಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು (ಆದರೂ ಎರಡನೆಯದನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ). ಪ್ಯಾರಾಮೀಟರ್ ಬಳಸಿ ಸಕ್ರಿಯಗೊಳಿಸಲು ಅಥವಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು vm.oom-kill. ರನ್ಟೈಮ್ನಲ್ಲಿ OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ sysctl.

sudo -s sysctl -w vm.oom-kill = 1

OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು, ಅದೇ ಆಜ್ಞೆಯಲ್ಲಿ ಮೌಲ್ಯ 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-ಕಿಲ್ಲರ್ ಅನ್ನು ಆನ್ ಮತ್ತು ಆಫ್ ಮಾಡಲು ಮಾತ್ರ ಸಾಧ್ಯವಿಲ್ಲ. ಲಿನಕ್ಸ್ ಅನ್ನು ವಾಸ್ತವವಾಗಿ ನಿಯೋಜಿಸದೆ ಲಭ್ಯವಿರುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಕಾಯ್ದಿರಿಸಬಹುದು ಎಂದು ನಾವು ಈಗಾಗಲೇ ಹೇಳಿದ್ದೇವೆ ಮತ್ತು ಈ ನಡವಳಿಕೆಯನ್ನು ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಪ್ಯಾರಾಮೀಟರ್ ನಿಯಂತ್ರಿಸುತ್ತದೆ. ವೇರಿಯೇಬಲ್ ಇದಕ್ಕೆ ಕಾರಣವಾಗಿದೆ vm.overcommit_memory.

ಇದಕ್ಕಾಗಿ ನೀವು ಈ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

0: ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸಬೇಕೆ ಎಂದು ಕರ್ನಲ್ ಸ್ವತಃ ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದು Linux ನ ಹೆಚ್ಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಆಗಿದೆ.
1: ಕರ್ನಲ್ ಯಾವಾಗಲೂ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತದೆ. ಇದು ಅಪಾಯಕಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಮೆಮೊರಿ ಖಾಲಿಯಾಗಬಹುದು, ಏಕೆಂದರೆ, ಹೆಚ್ಚಾಗಿ, ಒಂದು ದಿನ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಇದು ಅಗತ್ಯವಿರುತ್ತದೆ.
2: ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಕರ್ನಲ್ ಕಾಯ್ದಿರಿಸುವುದಿಲ್ಲ overcommit_ratio.

ಈ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ, ಅತಿಯಾಗಿ ಕಾಯ್ದಿರಿಸಲು ಅನುಮತಿಸಲಾದ ಮೆಮೊರಿಯ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೀರಿ. ಅದಕ್ಕೆ ಸ್ಥಳವಿಲ್ಲದಿದ್ದರೆ, ಯಾವುದೇ ಸ್ಮರಣೆಯನ್ನು ನಿಗದಿಪಡಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಮೀಸಲಾತಿಯನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ. ಇದು PostgreSQL ಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಸುರಕ್ಷಿತ ಆಯ್ಕೆಯಾಗಿದೆ. OOM-ಕಿಲ್ಲರ್ ಮತ್ತೊಂದು ಅಂಶದಿಂದ ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ - ವಿನಿಮಯ ಸಾಮರ್ಥ್ಯ, ಇದು ವೇರಿಯೇಬಲ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುತ್ತದೆ cat /proc/sys/vm/swappiness. ಈ ಮೌಲ್ಯಗಳು ಪೇಜಿಂಗ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕೆಂದು ಕರ್ನಲ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಮೌಲ್ಯ, OOM ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ, ಆದರೆ I/O ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರಣದಿಂದಾಗಿ ಅದು ಡೇಟಾಬೇಸ್ ಮೇಲೆ ನಕಾರಾತ್ಮಕ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ - ಕಡಿಮೆ ಮೌಲ್ಯ, OOM-ಕಿಲ್ಲರ್ ಹಸ್ತಕ್ಷೇಪದ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆ, ಆದರೆ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಕ್ಷಮತೆ ಕೂಡ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು 60 ಆಗಿದೆ, ಆದರೆ ಸಂಪೂರ್ಣ ಡೇಟಾಬೇಸ್ ಮೆಮೊರಿಗೆ ಸರಿಹೊಂದಿದರೆ, ಮೌಲ್ಯವನ್ನು 1 ಗೆ ಹೊಂದಿಸುವುದು ಉತ್ತಮ.

ಫಲಿತಾಂಶಗಳು

OOM-ಕಿಲ್ಲರ್‌ನಲ್ಲಿರುವ "ಕೊಲೆಗಾರ" ನಿಮ್ಮನ್ನು ಹೆದರಿಸಲು ಬಿಡಬೇಡಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕೊಲೆಗಾರ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಸಂರಕ್ಷಕನಾಗಿರುತ್ತಾನೆ. ಇದು ಕೆಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು "ಕೊಲ್ಲುತ್ತದೆ" ಮತ್ತು ಕ್ರ್ಯಾಶಿಂಗ್ನಿಂದ ಸಿಸ್ಟಮ್ ಅನ್ನು ಉಳಿಸುತ್ತದೆ. PostgreSQL ಅನ್ನು ಅಂತ್ಯಗೊಳಿಸಲು OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಲು, ಹೊಂದಿಸಿ vm.overcommit_memory ಮೌಲ್ಯ 2. OOM-ಕಿಲ್ಲರ್ ಮಧ್ಯಪ್ರವೇಶಿಸಬೇಕಾಗಿಲ್ಲ ಎಂದು ಇದು ಖಾತರಿ ನೀಡುವುದಿಲ್ಲ, ಆದರೆ ಇದು PostgreSQL ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲು ಒತ್ತಾಯಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಮೂಲ: www.habr.com