SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-30

ตั้งค่า systemd จำกัด RAM และ CPU ของโพรเซส

เรียนรู้การตั้งค่า MemoryHigh, MemoryMax, CPUQuota และ TasksMax ใน systemd พร้อมตรวจสอบ MemoryMax=805306368 และแก้ปัญหา MemoryMax=infinity

การจำกัดหน่วยความจำและ CPU ของโพรเซสด้วย systemd drop-in

คุณสามารถจำกัดหน่วยความจำและ CPU ของโพรเซสบน Linux VPS ได้โดยการเพิ่มบรรทัดคำสั่งลงใน unit ที่รันโพรเซสนั้น MemoryMax= คือเพดานสูงสุดของหน่วยความจำ ส่วน CPUQuota= คือเพดานของเวลาประมวลผล ทั้งสองค่าถูกบังคับใช้โดย cgroup v2 (control groups เวอร์ชัน 2) ซึ่งเป็นฟีเจอร์ของ kernel ที่ systemd ใช้งานอยู่แล้วเพื่อจัดการทรัพยากรของทุก service บนเครื่อง

sudo systemctl edit myapp.service

คำสั่งนี้จะเปิดไฟล์ drop-in ที่มีคำแนะนำในรูปแบบคอมเมนต์ ให้เพิ่มบรรทัดต่อไปนี้ไว้ด้านบน:

[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128
sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMax

systemctl show จะต้องแสดงตัวเลขที่คุณตั้งค่าไว้กลับมาในหน่วยของ kernel เอง นั่นคือ MemoryMax=805306368 และ CPUQuotaPerSecUSec=800ms หากระบบแสดงผลเป็น MemoryMax=infinity แสดงว่า drop-in ไม่ได้ถูกโหลด ให้ตรวจสอบว่าไฟล์ถูกสร้างไว้ที่ /etc/systemd/system/myapp.service.d/override.conf และขึ้นต้นด้วย header [Service] เนื่องจากหากมีบรรทัดการตั้งค่าโดยไม่มีส่วนหัวกำกับ systemd จะบันทึก log เป็น Assignment outside of section. Ignoring. และเริ่ม service โดยไม่มีการจำกัดใดๆ เลย

เนื้อหาที่เหลือของคู่มือนี้จะอธิบายวิธีการเลือกตัวเลขเหล่านี้ และปัญหาที่อาจเกิดขึ้นได้หลังจากตั้งค่าเสร็จสิ้นแล้ว

เหตุใดกระบวนการที่ทำงานผิดปกติจึงทำให้ VPS ค้างทั้งที่หน่วยความจำยังไม่เต็ม

กระบวนการที่ใช้หน่วยความจำถึงขีดจำกัดที่กำหนดไว้จะถูกยุติการทำงานภายในเวลาประมาณหนึ่งวินาที และบริการจะเริ่มทำงานใหม่ นี่คือกรณีปกติ ส่วนกรณีที่เลวร้ายคือกรณีที่ไม่มีสิ่งใดหยุดทำงาน: เครื่องยังตอบสนองต่อ ping, SSH ยอมรับการเชื่อมต่อ แต่กลับไม่แสดง shell prompt เครื่องยังคงทำงานอยู่แต่ไม่มีงานใดที่เป็นประโยชน์เกิดขึ้น

กลไกที่เกิดขึ้นมีดังนี้ เนื่องจากไม่ใช่เรื่องที่เห็นได้ชัดเจน เมื่อหน่วยความจำว่างเหลือน้อย เคอร์เนลจะเรียกคืนหน้าหน่วยความจำ (page) แทนการจัดสรรหน้าใหม่ หน้าหน่วยความจำที่เรียกคืนได้ง่ายที่สุดคือหน้าที่มีไฟล์รองรับ (file-backed) และ page cache จะเก็บโค้ดคำสั่งของทุกโปรแกรมที่กำลังทำงานอยู่ ดังนั้นเคอร์เนลจึงขับหน้าหน่วยความจำส่วนที่เป็นโค้ดของ sshd ออกไป และคำสั่งถัดไปที่ sshd จะเรียกใช้คือ page fault ซึ่งต้องอ่านไบต์เหล่านั้นกลับมาจากหน่วยเก็บข้อมูล ทุกกระบวนการจึงลงเอยด้วยการรอคอยดิสก์แทนที่จะได้ทำงาน หน้าหน่วยความจำเดิมถูกขับออกและอ่านกลับเข้ามาวนเวียนอยู่เช่นนี้ ซึ่งเรียกว่า thrashing

มีสองปัจจัยที่ทำให้สถานการณ์นี้บน VPS เลวร้ายกว่าบนแล็ปท็อป: หน่วยเก็บข้อมูลมักเป็นแบบเครือข่ายหรือแบบใช้ร่วมกัน ดังนั้นแต่ละ fault จึงใช้เวลามากกว่าการอ่านจากอุปกรณ์ NVMe ในเครื่องหลายมิลลิวินาที และเคอร์เนลไม่ได้วัดเวลา แต่จะวัดความล้มเหลว: ตราบใดที่การเรียกคืนหน่วยความจำยังคงคืนหน้าหน่วยความจำให้ได้ แม้จะช้าเพียงใด เคอร์เนลจะเชื่อว่าระบบยังคงมีความคืบหน้าและจะไม่เรียกใช้ out of memory (OOM) killer เครื่องอาจอยู่ในสถานะนี้ได้นานหลายนาทีก่อนที่จะมีสิ่งใดถูกยุติการทำงาน

คุณสามารถตรวจสอบเหตุการณ์นี้ได้ เคอร์เนลจะส่งออกข้อมูล pressure stall information (PSI) บน Linux เวอร์ชัน 4.20 ขึ้นไป:

cat /proc/pressure/memory
cat /proc/pressure/io
some avg10=63.72 avg60=41.02 avg300=12.33 total=13729481
full avg10=48.15 avg60=30.44 avg300=8.90 total=9114233

บรรทัด full คือส่วนที่สำคัญ full avg10=48.15 หมายความว่าในช่วง 10 วินาทีที่ผ่านมา งานที่ไม่ใช่ idle ทั้งหมดบนเครื่องติดขัดที่หน่วยความจำพร้อมกันเป็นเวลา 48% ของเวลาทั้งหมด ดังนั้นงานของคุณจึงไม่มีความคืบหน้าเลย เซิร์ฟเวอร์ที่มีสถานะปกติจะมีค่าบน full ใกล้ศูนย์ หากค่าสูงกว่า 10 มนุษย์จะรู้สึกว่าระบบช้า และหากเป็น 40 หรือมากกว่านั้นคือสถานะที่ผู้คนมักเรียกว่าเครื่องค้าง

นี่คือเหตุผลที่การจำกัดทรัพยากรเพียงอย่างเดียวไม่ใช่คำตอบเสมอไป หน่วยที่ถูกจำกัดภายใต้ MemoryHigh= จะถูกลดความเร็วลงแทนที่จะถูกยุติการทำงาน ดังนั้นมันจึงยังคงทำงานอยู่และทำงานช้า และไม่มีสิ่งใดเริ่มการทำงานใหม่เพราะในมุมมองของ systemd มันไม่เคยล้มเหลว หน่วยที่ถูกจำกัดซึ่งยังได้รับอนุญาตให้ใช้ swap จะสร้างการอ่านและเขียนที่ถูกนับรวมในหน่วยนั้น แต่ถูกให้บริการโดยอุปกรณ์ที่ใช้ร่วมกัน ดังนั้นมันจึงสามารถดันค่า /proc/pressure/io ให้สูงขึ้นสำหรับบริการอื่นทุกตัวบนเครื่อง การจำกัดทรัพยากรเป็นเพียงการตัดสินว่าใครจะเป็นผู้รับภาระเมื่อทรัพยากรขาดแคลน แต่ไม่สามารถสร้างความจุเพิ่มขึ้นได้

ตรวจสอบว่า VPS ของคุณรัน cgroup v2

stat -fc %T /sys/fs/cgroup

cgroup2fs คือลำดับชั้นแบบรวม (unified hierarchy) ซึ่งการตั้งค่าหน่วยความจำด้านล่างจำเป็นต้องใช้งาน tmpfs หมายความว่าเครื่องบูตด้วยโครงสร้างแบบ v1 รุ่นเก่า ซึ่ง MemoryHigh= และ MemorySwapMax= ไม่รองรับ และพฤติกรรม OOM ของแต่ละหน่วยจะแตกต่างออกไป แม้ว่า CPUQuota= จะยังคงทำงานได้ที่นั่นผ่านไฟล์ cpu.cfs_quota_us แบบดั้งเดิมก็ตาม Ubuntu 22.04 ขึ้นไป และ Debian 11 ขึ้นไป ใช้ v2 เป็นค่าเริ่มต้น อิมเมจรุ่นเก่าจะไม่ได้ใช้ และบน systemd 255 หรือเก่ากว่านั้น เคอร์เนลที่บูตด้วย systemd.unified_cgroup_hierarchy=0 ก็ไม่ได้ใช้เช่นกัน systemd 256 และ 257 ปฏิเสธที่จะบูตภายใต้ v1 เว้นแต่จะมี SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1 อยู่ในบรรทัดคำสั่งของเคอร์เนลด้วย systemd 258 ได้ลบการรองรับ cgroup v1 ออกและ mount ลำดับชั้นแบบรวมไว้ที่บูตเสมอ ดังนั้นในรุ่นที่ใช้เวอร์ชันนี้ อาร์กิวเมนต์ใดๆ ก็ไม่สามารถนำ v1 กลับมาได้

บน cgroup v2 นั้น systemd จะเปิดใช้งานการนับหน่วยความจำสำหรับทุกหน่วยโดยค่าเริ่มต้น ดังนั้นตัวเลขจึงมีอยู่แล้ว:

systemd-cgtop -m

คำสั่งดังกล่าวจะแสดงรายการ cgroups ที่เรียงลำดับตามการใช้งานหน่วยความจำ ซึ่งเป็นวิธีที่เร็วที่สุดในการตอบคำถามว่า "อะไรกำลังกินทรัพยากรเครื่องนี้" ในขณะที่เครื่องยังคงตอบสนองได้ หากเซิร์ฟเวอร์เป็นเครื่องใหม่ งานด้านบัญชีและไฟร์วอลล์ใน สิบนาทีแรกบน VPS ใหม่ ควรทำก่อนขั้นตอนนี้

การจำกัด MemoryHigh และ MemoryMax

ความแตกต่างระหว่างการตั้งค่าหน่วยความจำทั้งสองแบบนี้เป็นตัวกำหนดลักษณะของความล้มเหลวที่เกิดขึ้น

  • MemoryHigh= เป็นการจำกัดแบบผ่อนปรน (soft cap) เมื่อการใช้งานเกินค่านี้ เคอร์เนลจะพยายามเรียกคืนหน่วยความจำจาก cgroup นั้นอย่างหนักหน่วงและจงใจทำให้การจัดสรรหน่วยความจำช้าลง การใช้งานจริงยังคงเกินค่านี้ได้และไม่มีกระบวนการใดถูกสั่งยุติการทำงาน
  • MemoryMax= เป็นการจำกัดแบบเข้มงวด (hard cap) เมื่อไม่สามารถจัดสรรหน่วยความจำภายใต้ขีดจำกัดนี้ได้ OOM killer จะทำงาน ภายใน cgroup นั้น และสั่งยุติการทำงานของกระบวนการใดกระบวนการหนึ่งภายใน unit นั้นเอง

เหตุผลสำคัญที่ควรตั้งค่า MemoryMax= สำหรับบริการที่คุณไม่ไว้วางใจเต็มร้อยคือประเด็นหลังนี้ หากไม่มีการจำกัด เมื่อเกิดภาวะหน่วยความจำขาดแคลนจะกลายเป็นปัญหาของทั้งระบบ และ OOM killer ระดับ global จะเลือกเหยื่อตามค่า oom_score ซึ่งมักหมายถึงกระบวนการที่ใช้หน่วยความจำมากที่สุด ซึ่งโดยปกติคือฐานข้อมูลของคุณ ไม่ใช่สคริปต์ที่เกิด memory leak แต่หากมีการจำกัดไว้ การสั่งยุติการทำงานจะเกิดขึ้นเฉพาะภายใน unit ที่เป็นต้นเหตุเท่านั้น

ควรตั้งค่าทั้งสองอย่าง โดยให้ MemoryHigh= ต่ำกว่า MemoryMax= ประมาณ 20 ถึง 30 เปอร์เซ็นต์ ช่องว่างนี้เปรียบเสมือนโซนแจ้งเตือน: หากเกิด memory leak อย่างช้าๆ การใช้งานจะข้าม High และแสดงผลเป็นบริการที่ทำงานช้าลง ในขณะที่หากเกิดการใช้งานพุ่งสูงขึ้นอย่างกะทันหัน มันจะทะลุผ่าน Max และถูกสั่งยุติการทำงานทันที

ค่าเปอร์เซ็นต์จะถูกคำนวณจากหน่วยความจำจริงที่ติดตั้งไว้ ดังนั้น MemoryMax=25% บนแผน 4 GB จะเท่ากับ 1 GB และจะยังคงเป็นหนึ่งในสี่ของระบบเสมอแม้คุณจะปรับขนาดแผนในภายหลัง MemorySwapMax=0 จะช่วยป้องกันไม่ให้ unit นั้นใช้งาน swap โดยสิ้นเชิง ดังนั้นเมื่อถึง MemoryMax= การสั่งยุติการทำงานจะเกิดขึ้นอย่างรวดเร็วแทนที่จะต้องรอให้ระบบทำงานช้าลงจากการใช้ swap เป็นเวลานาน ต่ำกว่าจุดนั้น MemoryHigh= ยังคงสามารถจำกัดความเร็วได้ และการเกินขีดจำกัดสูง (high limit) จะไม่เรียกใช้ OOM killer ดังนั้น unit ที่มีการใช้งานแกว่งตัวอยู่ระหว่างสองค่านี้จะทำงานช้าลงแทนที่จะถูกสั่งยุติการทำงาน

บริการบางอย่างอนุญาตให้คุณกำหนดความต้องการหน่วยความจำล่วงหน้าแทนการวัดผล: unit ของ Ollama จะกำหนดขนาด KV cache จาก context window ที่คุณระบุ ดังนั้นโปรดอ่าน ต้นทุนการเพิ่ม num_ctx ใน RAM ก่อนที่คุณจะเลือกเพดานหน่วยความจำสำหรับบริการดังกล่าว

การจำกัดหน่วยความจำจำเป็นต้องมีนโยบายการรีสตาร์ทกำกับไว้ด้วย มิฉะนั้นเมื่อถูกสั่งยุติการทำงาน บริการของคุณจะหยุดทำงานไปเฉยๆ

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Restart=on-failure
RestartSec=5s

StartLimit* ควรอยู่ใน [Unit] และ Restart= ควรอยู่ใน [Service] หากใส่ผิดส่วน systemd จะเพิกเฉยต่อการตั้งค่านั้น การรีสตาร์ท 5 ครั้งภายใน 5 นาทีถือเป็นสัญญาณของ memory leak ไม่ใช่ความผิดพลาดชั่วคราว ดังนั้นหลังจากนั้น systemd จะหยุดพยายามและปล่อยให้ unit อยู่ในสถานะ failed ซึ่งเป็นสถานะที่คุณต้องการตรวจสอบในภายหลัง แทนที่จะปล่อยให้เกิด crash loop ที่บดบังปัญหาที่แท้จริง

จำกัดการใช้งาน CPU ด้วย CPUQuota หรือจัดสรรด้วย CPUWeight

CPUQuota= จะกำหนดเปอร์เซ็นต์ของเวลาที่ใช้งานได้บน CPU หนึ่งคอร์ CPUQuota=50% คือครึ่งหนึ่งของหนึ่งคอร์ CPUQuota=200% เทียบเท่ากับการใช้งานสองคอร์ ซึ่งยูนิตนั้นอาจกระจายภาระงานไปยังเธรดจำนวนเท่าใดก็ได้ตามต้องการ บนแผนบริการที่มี 2 vCPU นั้น CPUQuota=200% คือการใช้งานเครื่องทั้งหมด

CPUWeight= เป็นค่าเริ่มต้นที่เหมาะสมกว่าสำหรับบริการส่วนใหญ่ โดยเป็นค่าสัดส่วนสัมพัทธ์ตั้งแต่ 1 ถึง 10000 ซึ่งค่าเริ่มต้นของเคอร์เนลคือ 100 ค่านี้จะทำงานเฉพาะเมื่อมีการแย่งชิงทรัพยากรกันเท่านั้น เช่น งานสำรองข้อมูลที่ตั้งค่าไว้ที่ CPUWeight=20 จะหลีกทางให้กับเว็บเซิร์ฟเวอร์ที่ตั้งค่าไว้ที่ 100 เมื่อมีภาระงานสูง และยังคงสามารถใช้งานทรัพยากรทั้งเครื่องได้ในขณะที่เครื่องว่างงาน การใช้โควตาแบบจำกัดตายตัว (hard quota) จะทำให้เสียความสามารถในการใช้ทรัพยากรส่วนที่ว่างอยู่นี้ไปโดยเปล่าประโยชน์

ควรพิจารณาให้ชัดเจนว่าการจำกัด CPU ให้ผลลัพธ์อย่างไร กระบวนการที่เน้นการคำนวณ CPU (CPU-bound) แทบจะไม่ทำให้ Linux ค้าง เพราะตัวจัดตารางเวลา (scheduler) จะคอยจัดสรรเวลาให้กับทุกกระบวนการอยู่เสมอ หน่วยความจำต่างหากที่เป็นสาเหตุให้เครื่องหยุดทำงาน ให้เลือกใช้ CPUQuota= เมื่อคุณต้องการเพดานการใช้งานที่คาดการณ์ได้ เช่น ในงาน build หรือ agent ที่อาจทำงานเต็มกำลังต่อเนื่องเป็นชั่วโมง การกำหนดขนาดสำหรับภาระงานประเภทนี้เป็นหัวข้อเฉพาะ ซึ่งครอบคลุมอยู่ใน จำนวน RAM และ CPU ที่ VPS สำหรับ coding agent ต้องการ

หากค่า CPU แสดงว่ามีการใช้งานสูงในขณะที่ไม่มีกระบวนการใดของคุณทำงานหนัก สาเหตุอาจมาจากฝั่งตรงข้ามของ hypervisor ซึ่งนั่นคือ CPU steal time จากเพื่อนบ้านที่ใช้ทรัพยากรมากเกินไป และไม่มีโควตาใดที่คุณตั้งค่าไว้จะสามารถแก้ไขปัญหานี้ได้

TasksMax ช่วยหยุดการทำงานของ fork loop

TasksMax= คือจำนวนของ process และ thread ที่ unit หนึ่งสามารถถือครองได้ เนื่องจาก thread ก็นับรวมด้วย บริการที่เขียนด้วย Java หรือ Go จึงต้องการพื้นที่รองรับมากกว่าที่รายการ process จะแสดงให้เห็น นี่คือการป้องกันที่ประหยัดทรัพยากรที่สุดสำหรับสคริปต์ที่ทำ fork ใน loop เพราะการ fork จะล้มเหลวภายใน unit นั้น แทนที่จะทำให้เครื่องแม่ข่ายขาดแคลน process ID จนใช้งานไม่ได้

TasksMax=128

เมื่อ unit ถึงขีดจำกัด kernel จะบันทึก log ระบุชื่อ cgroup ไว้ดังนี้:

cgroup: fork rejected by pids controller in /system.slice/myapp.service

โดยปกติโปรแกรมจะรายงานข้อผิดพลาด fork: retry: Resource temporarily unavailable ตรวจสอบค่าที่ตัวจัดการระบบกำหนดไว้เป็นค่าเริ่มต้นได้ด้วยคำสั่ง systemctl show -p DefaultTasksMax

จำกัดการทำงานของงานแบบครั้งเดียวด้วย systemd-run

คุณไม่จำเป็นต้องมีไฟล์ unit เพื่อใช้งานสิ่งเหล่านี้ systemd-run จะสร้าง unit ชั่วคราวขึ้นมาล้อมรอบคำสั่งเดียว

sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh

--scope จะรันคำสั่งใน terminal ของคุณหลังจากแสดง Running scope as unit: run-r7c1a....scope ผลลัพธ์จะแสดงบนหน้าจอของคุณและข้อจำกัดต่างๆ จะหายไปเมื่อคำสั่งทำงานเสร็จสิ้น คุณสมบัติใดๆ จาก systemd.resource-control สามารถใช้งานได้หลังจาก -p

สำหรับงานที่ใช้เวลานาน ให้ละ --scope ออกและตั้งชื่อให้กับงานนั้น งานจะทำงานในเบื้องหลังในฐานะ transient service และบันทึก log ลงใน journal:

sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -f

ตัวเลือกเดียวกันนี้สามารถใช้กับ --user ได้ในกรณีที่คุณไม่ได้เป็น root แม้ว่า user manager ของคุณจะมีเฉพาะ controller ที่ถูกมอบหมายให้เท่านั้น ซึ่งอาจทำให้คุณสมบัติบางอย่างถูกปฏิเสธ ให้รันด้วย sudo หากเกิดกรณีดังกล่าว เมื่อต้องการให้งานนั้นมีสถานะถาวร คุณสามารถย้ายการตั้งค่าไปไว้ใน unit จริงได้โดยไม่ต้องเปลี่ยนแปลงค่าใดๆ: ดูที่ การรันสคริปต์ในฐานะ systemd service และ timer

คำถามเรื่อง swap ตอบแบบตรงไปตรงมา

Swap เปลี่ยนรูปแบบของความล้มเหลวแทนที่จะป้องกันไม่ให้เกิดขึ้น

หากไม่มี swap เมื่อหน่วยความจำรั่วจนเต็มเพดาน ระบบจะหยุดทำงานภายในไม่กี่วินาที การล่มนั้นเกิดขึ้นอย่างรวดเร็วและชัดเจน ซึ่งสามารถตรวจสอบสาเหตุได้ง่ายจาก journal ในภายหลัง แต่ถ้ามี swap เคอร์เนลจะเขียน anonymous pages ที่ไม่ได้ใช้งานลงดิสก์เพื่อซื้อเวลา หากกระบวนการนั้นหยุดรั่วไปเอง swap จะช่วยคุณไว้ได้ แต่ถ้าเป็นกระบวนการที่รั่วไม่หยุด swap จะเปลี่ยนการล่มเพียง 5 วินาทีให้กลายเป็นอาการค้างนาน 20 นาที ซึ่งอาการค้างนั้นแย่กว่า เพราะกระบวนการที่ตายไปแล้วยังเหลือ shell ให้คุณใช้งานได้ ในขณะที่เครื่องที่กำลัง thrashing จะไม่ตอบสนองเลย

swapon --show
free -h

ทางสายกลางที่ใช้งานได้จริงบน VPS ขนาดเล็กคือ การเก็บ swap file ขนาดพอเหมาะไว้สำหรับหน้าหน่วยความจำที่ถูกจองไว้ครั้งเดียวแล้วไม่ได้ใช้งานอีก และตั้งค่า MemorySwapMax=0 บน unit ที่คุณยอมรับได้หากมันจะถูกปิดตัวลง บริการที่สำคัญจะยังคงใช้ swap ต่อไป ส่วนบริการที่คาดเดาไม่ได้จะชนเพดานอย่างรวดเร็ว และนโยบายการรีสตาร์ทที่กำหนดไว้จะช่วยกู้คืนบริการเหล่านั้นกลับมา

การลดค่า vm.swappiness เป็นวิธีแก้ปัญหาที่ไม่ค่อยได้ผลนัก และควรทราบเหตุผลว่าทำไม เพราะมันทำได้เพียงปรับสมดุลระหว่างการล้าง page cache กับการทำ swap anonymous pages เท่านั้น ซึ่งทั้งสองอย่างล้วนต้องเสียเวลาอ่านดิสก์ในภายหลัง มันทำได้เพียงเปลี่ยนว่าหน้าหน่วยความจำส่วนไหนที่จะเกิดการ thrash ไม่ใช่การป้องกันไม่ให้เครื่องเกิดอาการ thrash

การใช้ OOM daemon ตั้งแต่เนิ่นๆ เพื่อป้องกันระบบค้าง

Kernel จะรอจนกว่ากระบวนการเรียกคืนหน่วยความจำ (reclaim) จะล้มเหลวโดยสมบูรณ์ ซึ่งบน VPS ขนาดเล็ก ช่วงเวลานี้คือจังหวะที่ระบบจะหยุดตอบสนองจนคุณสูญเสียการควบคุมเครื่องไป มี daemon สองตัวในระดับ userspace ที่ช่วยปิดช่องว่างนี้ได้โดยการเฝ้าดูหน่วยความจำด้วยตนเองและสั่งยุติกระบวนการให้เร็วขึ้น

earlyoom จะตรวจสอบหน่วยความจำที่ใช้งานได้และ swap ที่ว่างอยู่สูงสุดถึง 10 ครั้งต่อวินาที และจะสั่งยุติกระบวนการที่มีค่า oom_score สูงสุดก็ต่อเมื่อทั้งสองค่าลดลงต่ำกว่าเกณฑ์ที่กำหนด ในกรณีที่เครื่องไม่มี swap เกณฑ์ของหน่วยความจำเพียงอย่างเดียวจะเป็นตัวตัดสิน

sudo apt install earlyoom
systemctl status earlyoom

แพ็กเกจบน Debian และ Ubuntu จะเริ่มการทำงานของ service ทันทีที่ติดตั้ง โดยตัวเลือกการตั้งค่าจะอยู่ใน /etc/default/earlyoom:

EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"

-m PERCENT ใช้กำหนดค่าขั้นต่ำของหน่วยความจำที่ใช้งานได้ และ -s PERCENT ใช้กำหนดค่าขั้นต่ำของ swap ที่ว่างอยู่ โดยค่าเริ่มต้นของทั้งคู่คือ 10 เปอร์เซ็นต์ ตัวเลขตัวที่สองในแต่ละคู่คือจุดที่ใช้ส่งสัญญาณ SIGKILL: earlyoom จะส่ง SIGTERM เมื่อหน่วยความจำและ swap ลดลงต่ำกว่าค่าแรก จากนั้นจะส่ง SIGKILL เมื่อทั้งคู่ลดลงต่ำกว่าค่าที่สอง ซึ่งค่าเริ่มต้นคือครึ่งหนึ่งของค่าแรก unit จะส่งตัวแปรนี้ไปยัง earlyoom ในรูปแบบ $EARLYOOM_ARGS ดังนั้น systemd จะแยกค่านี้ออกเป็นอาร์กิวเมนต์ตามช่องว่าง การใส่เครื่องหมายคำพูดให้กับรูปแบบ --avoid และ --prefer สามารถทำได้อย่างปลอดภัย: systemd จะลบเครื่องหมายคำพูดคู่ชั้นนอกออกเมื่ออ่านไฟล์ จากนั้นจะประมวลผลและลบเครื่องหมายคำพูดเดี่ยวที่อยู่ภายในค่าขณะแยกอาร์กิวเมนต์ ดังนั้น --avoid '^(sshd|systemd)$' จึงทำงานได้เหมือนกับรูปแบบที่ไม่มีเครื่องหมายคำพูดด้านบน รูปแบบที่มีช่องว่างจำเป็นต้องใช้เครื่องหมายคำพูดเดี่ยว มิฉะนั้นจะถูกแยกออกเป็นสองอาร์กิวเมนต์ ให้ใช้คำสั่ง sudo systemctl restart earlyoom เพื่อนำการเปลี่ยนแปลงไปใช้ และอ่าน journalctl -u earlyoom เพื่อดูว่ากระบวนการใดถูกยุติไปและกระบวนการนั้นใช้หน่วยความจำไปเท่าใด

systemd-oomd เป็นอีกตัวเลือกหนึ่ง หน้าคู่มือระบุว่าเป็น "system service ที่ใช้ cgroups-v2 และ pressure stall information (PSI) เพื่อเฝ้าดูและดำเนินการแก้ไขก่อนที่ภาวะ OOM จะเกิดขึ้นในระดับ kernel" มันจะทำงานกับ cgroups ทั้งกลุ่มแทนที่จะเป็นกระบวนการเดี่ยวๆ ดังนั้นมันจะยุติการทำงานของ unit ทั้ง unit ไม่ใช่แค่ child process ที่หลงเหลืออยู่ unit ต่างๆ สามารถเลือกเข้าร่วมได้ด้วย ManagedOOMMemoryPressure=kill หรือ ManagedOOMSwap=kill และเกณฑ์การตั้งค่าจะอยู่ใน /etc/systemd/oomd.conf

systemctl status systemd-oomd
oomctl

oomctl จะแสดงสิ่งที่กำลังเฝ้าดูอยู่ ซึ่งมักจะไม่พบสิ่งใดบน server image เนื่องจากต้องตั้งค่า opt-in แยกในแต่ละ unit ให้เลือกใช้ daemon เพียงตัวเดียวก็เพียงพอแล้ว การรันทั้งสองตัวพร้อมกันจะทำให้เกิดการแย่งชิงกันเพื่อเลือกกระบวนการที่จะถูกยุติ และจะทำให้การวิเคราะห์หาสาเหตุของการสั่ง kill ทำได้ยากขึ้น

หน่วยใดเป็นต้นเหตุ

ให้เริ่มตรวจสอบจาก kernel เนื่องจาก kernel จะบันทึกทุกเหตุการณ์การสั่ง kill ที่เกิดขึ้น

journalctl -k --grep "Killed process" --since "2 hours ago"

การสั่ง kill จาก OOM killer ส่วนกลางจะมีลักษณะดังนี้:

Out of memory: Killed process 4127 (node) total-vm:2731084kB, anon-rss:1874232kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:4212kB oom_score_adj:0

anon-rss คือหน่วยความจำแบบ anonymous เช่น heap ที่ process นั้นถือครองอยู่ใน RAM ขณะที่ถูกสั่งปิด ซึ่งในกรณีนี้คือประมาณ 1.8 GB ส่วนการ mapping ไฟล์ในหน่วยความจำและหน่วยความจำร่วม (shared memory) จะถูกนับแยกต่างหากใน file-rss และ shmem-rss ให้พิจารณาชื่อที่อยู่ในวงเล็บด้วยความระมัดระวัง นั่นคือเหยื่อที่ kernel เลือก ซึ่ง kernel มักจะเลือก process ที่ใช้หน่วยความจำมากที่สุดเสมอ แต่ process นั้นอาจไม่ใช่สาเหตุที่แท้จริงของการขาดแคลนหน่วยความจำ

การสั่ง kill ที่เกิดจากขีดจำกัดของ cgroup จะมี prefix ที่แตกต่างออกไป และรายงานที่แสดงอยู่ด้านบนจะระบุชื่อ cgroup ที่ใช้งานเกินขีดจำกัดของตนเอง:

Memory cgroup out of memory: Killed process 8811 (python3) total-vm:1044320kB, anon-rss:769112kB, file-rss:0kB, shmem-rss:0kB, UID:998 pgtables:1720kB oom_score_adj:0

prefix ดังกล่าวคือหัวใจสำคัญของการวินิจฉัย Memory cgroup out of memory หมายความว่าหน่วยหนึ่งใช้งานเกิน MemoryMax= ที่คุณกำหนดไว้ แต่ส่วนอื่นของเครื่องยังทำงานได้ตามปกติ หากเป็น Out of memory เฉยๆ หมายความว่าเครื่องโดยรวมขาดแคลนหน่วยความจำ ซึ่งแสดงว่าคุณไม่ได้กำหนดขีดจำกัดไว้ หรือกำหนดไว้สูงเกินไปจนรวมกันแล้วเกินทรัพยากรที่มี

จากนั้นให้สอบถาม systemd ว่าพบเหตุการณ์ใดบ้าง:

systemctl status myapp.service
journalctl -u myapp.service -n 50
myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Main process exited, code=killed, status=9/KILL
myapp.service: Failed with result 'oom-kill'.

systemctl status จะแสดงข้อมูลเดียวกันในบรรทัดเดียว เช่นเดียวกับ Active: failed (Result: oom-kill)

ตัวนับของ cgroup เป็นแหล่งข้อมูลที่สาม และเป็นแหล่งเดียวที่บันทึกเหตุการณ์ throttling ซึ่งเหตุการณ์นี้จะไม่สร้างบรรทัด log ใดๆ ออกมาเลย:

cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peak
low 0
high 4213
max 118
oom 12
oom_kill 12

high จะนับจำนวนครั้งที่หน่วยนั้นถูกผลักให้เกิน MemoryHigh= และถูกจำกัดความเร็ว (throttled) ส่วน max จะนับจำนวนครั้งที่ใช้งานถึงขีดจำกัดสูงสุด (hard cap) และ oom_kill จะนับจำนวน process ที่ถูกสั่ง kill จริงๆ หากค่า high สูงแต่ oom_kill 0 เป็นศูนย์ นั่นคือกรณีเงียบที่กล่าวถึงก่อนหน้านี้: ตั้งแต่ cgroup ถูกสร้างขึ้น หน่วยนั้นถูกจำกัดความเร็วซ้ำแล้วซ้ำเล่าโดยไม่มีการสั่ง kill เลย systemd จึงไม่ได้บันทึกความล้มเหลวใดๆ ตัวนับนี้จะเพิ่มขึ้นเรื่อยๆ ดังนั้นให้ลองอ่านค่าห่างกันนาทีละครั้ง หาก high ยังคงเพิ่มขึ้นเรื่อยๆ แสดงว่ากำลังเกิดการ throttling อยู่ในขณะนี้ ส่วน memory.peak (สำหรับ Linux 5.19 ขึ้นไป) จะเก็บค่าการใช้งานสูงสุดที่ cgroup เคยไปถึง ซึ่งเป็นตัวเลขที่ควรนำไปใช้กำหนดขนาด MemoryMax= ไฟล์ทั้งสองจะถูกรีเซ็ตเมื่อหน่วยนั้นรีสตาร์ท เนื่องจาก systemd จะสร้าง cgroup ขึ้นมาใหม่

มีข้อกำหนดเบื้องต้นประการหนึ่งที่อยู่ภายใต้กระบวนการทั้งหมดนี้ หาก /var/log/journal ไม่มีอยู่จริง journal จะถูกเก็บไว้ใน RAM และทุกบรรทัดจะหายไปหลังจากที่คุณรีบูตเครื่องเพื่อกู้คืนระบบ

sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-boots

หาก journalctl --list-boots แสดงค่ามากกว่าการบูตปัจจุบัน แสดงว่าประวัติการทำงานถูกบันทึกไว้แล้ว ดังนั้น journalctl -k -b -1 จะสามารถแสดงข้อความจาก kernel ในช่วงการบูตที่เกิดปัญหาได้

จุดเริ่มต้นสำหรับ VPS ขนาดเล็ก

บนแผนบริการขนาด 2 GB ให้แบ่งพื้นที่ไว้ 300 ถึง 400 MB สำหรับ kernel และ page cache และอย่าตั้งค่าขีดจำกัดรวมกันจนเต็ม 2 GB เนื่องจากทุก unit อาจมีการใช้งานสูงสุดพร้อมกันได้ ให้จัดสรรทรัพยากรส่วนใหญ่ให้กับบริการที่สำคัญที่สุด จากนั้นจึงจำกัดทรัพยากรของบริการอื่นๆ ที่มีความเสี่ยงหรือยังไม่ผ่านการทดสอบ (speculative) ที่อยู่รอบๆ บริการนั้น

[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5s

การรักษาช่องทางเข้าถึงระบบไว้เป็นสิ่งที่ควรค่าแก่การตั้งค่าเพิ่มอีกหนึ่งอย่าง การใช้ OOMScoreAdjust=-500 ในไฟล์ drop-in สำหรับ ssh.service จะช่วยลดโอกาสที่ OOM killer ของระบบจะเลือก SSH daemon ของคุณเป็นเหยื่อ ซึ่งเป็นจุดตัดสินว่าคุณจะสามารถแก้ไขเซิร์ฟเวอร์ได้โดยตรงหรือต้องสั่ง reboot จาก control panel การตั้งค่านี้เพียงแค่เปลี่ยนตัวเลือกเหยื่อของ kernel เท่านั้น ไม่ได้ช่วยลดระยะเวลาที่ระบบค้าง

คอนเทนเนอร์ทำงานอยู่ใน cgroup ของตนเอง ซึ่งถูกสร้างโดย container runtime ไม่ใช่โดย unit file ของคุณ ดังนั้นการจำกัดค่าที่ docker.service จึงไม่ส่งผลเป็นการจำกัดคอนเทนเนอร์นั้นๆ โดยตรง สำหรับการตั้งค่าที่เทียบเท่ากันในระดับคอนเทนเนอร์ของ MemoryMax= และ CPUQuota= ได้อธิบายไว้ใน การตั้งค่าขีดจำกัดหน่วยความจำและ CPU ใน Docker Compose

FAQ

ทำไม VPS ของฉันถึงค้างแทนที่จะสั่ง kill กระบวนการที่ทำงานผิดปกติ?

เพราะ kernel ตัดสินความคืบหน้าจากว่าการเรียกคืนหน่วยความจำ (reclaim) คืนค่าหน้าหน่วยความจำ (pages) ได้หรือไม่ ไม่ใช่จากระยะเวลาที่ใช้ ในขณะที่หน่วยความจำขาดแคลน kernel จะไล่หน้าหน่วยความจำใน cache ออก รวมถึงหน้าหน่วยความจำที่เป็นไฟล์สั่งการ (executable pages) ของโปรแกรมที่กำลังทำงานอยู่ แล้วค่อยอ่านกลับเข้ามาใหม่เมื่อมีการเรียกใช้คำสั่งถัดไป ทุกอย่างจึงต้องรอการอ่านจาก storage และในทางเทคนิคยังไม่มีการจัดสรรหน่วยความจำใดที่ล้มเหลว OOM killer จึงไม่ถูกเรียกใช้งาน ให้ตรวจสอบ /proc/pressure/memory ในขณะที่เกิดปัญหา หากค่า full avg10 สูงกว่า 40 หมายความว่าในช่วง 10 วินาทีที่ผ่านมา มีช่วงเวลามากกว่า 40% ที่ทุกงานที่ไม่ใช่ idle task ต่างติดขัดอยู่ที่หน่วยความจำพร้อมกัน daemon ใน userspace เช่น earlyoom จะทำการ kill กระบวนการก่อนที่เครื่องจะเข้าสู่สถานะดังกล่าว

MemoryHigh และ MemoryMax ต่างกันอย่างไร?

MemoryHigh= เป็นเพดานแบบอ่อน (soft cap) ที่ทำหน้าที่หน่วงการทำงาน kernel จะพยายามเรียกคืนหน่วยความจำจาก unit นั้นอย่างหนักและทำให้การจัดสรรหน่วยความจำช้าลง แต่การใช้งานจริงสามารถเกินตัวเลขนี้ได้และไม่มีกระบวนการใดถูก kill ส่วน MemoryMax= เป็นเพดานแบบแข็ง (hard cap): หากมีการจัดสรรหน่วยความจำที่ไม่สามารถทำได้ภายใต้ขีดจำกัดนี้ จะเป็นการเรียก OOM killer ภายใน cgroup ของ unit นั้นเอง ส่งผลให้กระบวนการที่เป็นต้นเหตุถูก kill แทนที่จะเป็นกระบวนการที่ใช้หน่วยความจำมากที่สุดในเครื่อง ให้ตั้งค่า MemoryHigh= ให้ต่ำกว่า MemoryMax= และมองว่าช่องว่างระหว่างค่าทั้งสองเป็นโซนแจ้งเตือน

ฉันจะทราบได้อย่างไรว่าบริการใดที่ถูก OOM killer จัดการ?

ให้รันคำสั่ง journalctl -k --grep "Killed process" --since "2 hours ago" หากบรรทัดใดขึ้นต้นด้วย Memory cgroup out of memory หมายความว่า unit นั้นชนเพดาน MemoryMax= ของตัวเอง ในขณะที่ข้อความ Out of memory ปกติหมายความว่าหน่วยความจำของทั้งเครื่องหมดลง จากนั้นให้รัน journalctl -u <unit> -n 50 แล้วค้นหา Failed with result 'oom-kill' หาก /var/log/journal ไม่มีอยู่บนเซิร์ฟเวอร์ของคุณ แสดงว่า journal ถูกเก็บไว้ใน RAM และหลักฐานสูญหายไปพร้อมกับการ reboot ดังนั้นควรสร้าง directory ดังกล่าวไว้ก่อนที่จะเกิดเหตุการณ์ครั้งถัดไป

ฉันควรเพิ่ม swap ให้กับ VPS ขนาดเล็กหรือไม่?

ไฟล์ swap ขนาดเล็กช่วยจัดการกับหน้าหน่วยความจำที่ถูกเรียกใช้ครั้งเดียวแล้วไม่ได้ใช้งานอีก (cold pages) แต่ไม่ได้ช่วยกรณีมีกระบวนการทำงานผิดปกติ เพราะมันจะช่วยยืดเวลาการ kill ออกไปและเปลี่ยนจากปัญหาการหยุดชะงักสั้นๆ เป็นการค้างยาวนานจนคุณไม่สามารถล็อกอินเข้าไปแก้ไขได้ ควรตั้งค่า swap ไว้พอประมาณ และตั้งค่า MemorySwapMax=0 ใน unit ที่คุณยอมรับได้หากต้องถูกปิดตัวลง เพื่อให้ unit เหล่านั้นถึงเพดานอย่างรวดเร็ว และเมื่อตั้งค่า Restart=on-failure ไว้ บริการเหล่านั้นจะกลับมาทำงานใหม่ได้เองในขณะที่บริการสำคัญยังคงใช้ swap ได้ตามปกติ

ฉันสามารถจำกัดคำสั่งโดยไม่ต้องเขียน unit file ได้หรือไม่?

ได้ sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh จะรันคำสั่งใน terminal ของคุณภายใน transient scope พร้อมกับขีดจำกัดเหล่านั้น และขีดจำกัดจะหายไปเมื่อคำสั่งทำงานเสร็จสิ้น คุณสมบัติทุกอย่างจาก systemd.resource-control สามารถใช้งานได้หลังจาก -p ดังนั้น MemorySwapMax=, TasksMax= และ CPUWeight= จึงใช้งานได้เช่นกัน ให้ละ --scope และเพิ่ม --unit=name เพื่อรันงานในเบื้องหลังโดยให้ผลลัพธ์ถูกบันทึกลงใน journal

บทความนี้มีประโยชน์หรือไม่