SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor

วิธีเลือก Type= ใน systemd service ให้ถูกต้องและแม่นยำ

แก้ปัญหา systemd แสดงสถานะ active ทั้งที่ daemon หยุดทำงานไปแล้ว เรียนรู้วิธีเลือก Type= simple, forking, notify หรือ oneshot เพื่อให้ระบบติดตาม main PID ได้อย่างถูกต้องแม่นยำ

เหตุใด systemd จึงรายงานว่า unit ยังคง active อยู่ทั้งที่ process ตายไปแล้ว

ด้วยค่าเริ่มต้นของ ExitType=main และ RemainAfterExit=no นั้น systemd service unit จะยังคงสถานะเป็น active ตราบเท่าที่ process หลักที่ systemd ตรวจสอบยังคงทำงานอยู่ โดย Type= ในส่วน [Service] จะเป็นตัวกำหนดว่า process ใดคือ process หลัก หากเลือกค่าไม่ถูกต้อง systemd จะเฝ้าติดตามเพียง shell wrapper หรือ process พ่อที่ทำงานเพียงชั่วคราว ในขณะที่ daemon ที่คุณต้องการใช้งานจริงได้หยุดทำงานไปแล้วภายใน unit เดียวกัน ดังนั้น unit จึงรายงานสถานะตามความเป็นจริงของ process ที่ถูกกำหนดให้เฝ้าติดตาม

การเปลี่ยนนโยบายการ restart จะไม่ช่วยแก้ปัญหานี้ Restart= จะตอบสนองต่อการสิ้นสุดของ process และความล้มเหลว เช่น การหมดเวลา (timeout) แต่จะไม่สามารถตรวจพบการหยุดทำงานของ background daemon ได้หาก PID (process identifier) หลักยังคงเป็นของ process อื่นที่ยังทำงานอยู่ คุณต้องแก้ไข Type= ให้ถูกต้องเสียก่อน ส่วนสิ่งที่ systemd จะดำเนินการหลังจาก process หลักหยุดทำงานจริงนั้นเป็นการตัดสินใจแยกต่างหาก ซึ่งอธิบายไว้ใน คู่มือการใช้งาน Restart= และ RestartSec=

ค่า Type= ตัดสินใจเรื่องอะไร

ค่า Type= แต่ละค่าจะตอบคำถามสองข้อพร้อมกัน คือ systemd จะถือว่า unit นี้เริ่มทำงานเมื่อใด และกระบวนการ (process) ใดคือกระบวนการหลัก

คำตอบแรกควบคุมลำดับการทำงาน unit ที่ระบุชื่อ unit ของคุณไว้ใน After= จะรอจนกว่า systemd จะเรียก unit ของคุณว่าเริ่มทำงานแล้ว หาก Type= รายงานว่า "เริ่มทำงานแล้ว" เร็วเกินไป จะทำให้ unit ที่ขึ้นต่อกันเริ่มทำงานก่อนที่ service ของคุณจะพร้อมให้บริการ

คำตอบที่สองควบคุมการกำกับดูแล systemd จะนำทุกกระบวนการที่ unit สร้างขึ้นไปไว้ใน cgroup (control group) ซึ่งเป็นฟีเจอร์ของ kernel ที่ใช้จัดกลุ่มกระบวนการเพื่อให้สามารถจำกัดทรัพยากรและสั่งยุติการทำงานพร้อมกันได้ cgroup คือวิธีที่ systemctl stop ใช้ในการล้างข้อมูล โดยค่าเริ่มต้นของ KillMode= คือ control-group ดังนั้นการหยุด unit จะส่งสัญญาณไปยังทุกกระบวนการที่อยู่ภายในนั้น ส่วน PID หลักจะมีขอบเขตที่แคบกว่า โดยค่าเริ่มต้นคือ ExitType=main และ RemainAfterExit=no ซึ่งหมายถึงกระบวนการเดียวที่หากยุติลงจะถือว่า unit นั้นจบการทำงาน และสถานะการออก (exit status) ของกระบวนการนั้นจะมีผลต่อผลลัพธ์ของ unit การเข้าใจผิดมักเกิดจากการมองว่า cgroup คือ PID หลัก

Type=simple รายงานว่าเริ่มทำงานก่อนที่ไฟล์ binary จะรัน

Type=simple คือค่าเริ่มต้นเมื่อตั้งค่า ExecStart= โดยไม่มีทั้ง Type= และ BusName= และ unit ไม่ได้ใช้ credentials ใดๆ หาก unit มีการโหลด credentials เช่น การใช้ LoadCredential= จะส่งผลให้ใช้ Type=exec โดยอัตโนมัติ ภายใต้ simple นั้น systemd จะสร้างกระบวนการทำงานขึ้นมา ถือว่า unit เริ่มทำงานทันที และนับกระบวนการนั้นเป็น PID หลัก ส่งผลให้ unit ลำดับถัดไปเริ่มทำงานทันที ก่อนที่ไฟล์ binary ของ service จะถูกเรียกใช้งานจริงเสียอีก

รายละเอียดสุดท้ายนี้อธิบายถึงสิ่งที่มักทำให้ผู้ใช้ประหลาดใจ หากมีการพิมพ์ path ของ ExecStart= ผิดพลาด งานที่สั่งให้เริ่มทำงาน (start job) ก็ยังคงแสดงสถานะว่าสำเร็จ และความล้มเหลวจะปรากฏขึ้นในภายหลังเมื่อการเรียกใช้งานจริงล้มเหลว systemd จะบันทึกกรณีดังกล่าวด้วย exit code 203 ซึ่งตารางของระบบระบุว่าเป็น EXIT_EXEC และนิยามว่าเป็นความล้มเหลวในการเรียกใช้งานกระบวนการจริง ดังนั้นการที่ systemctl start ส่งค่ากลับโดยไม่มีข้อผิดพลาด จึงไม่ได้เป็นเครื่องยืนยันว่าไฟล์ binary ของคุณมีอยู่จริง

ให้ใช้ simple สำหรับโปรแกรมที่ทำงานใน foreground และไม่มีการย้ายตัวเองไปทำงานใน background ซึ่งครอบคลุมถึง daemon สมัยใหม่ส่วนใหญ่และเกือบทุกโปรแกรมที่คุณเขียนขึ้นเอง

Type=exec รอให้โปรแกรมเริ่มทำงานจริง

Type=exec คือ simple ที่เพิ่มขั้นตอนการตรวจสอบอีกหนึ่งขั้น systemd จะถือว่า unit เริ่มทำงานสำเร็จก็ต่อเมื่อทั้งการ fork และการรัน binary สำเร็จเท่านั้น หากหา binary ไม่พบ หรือ User= ไม่สามารถ resolve ได้ งานเริ่มต้น (start job) จะล้มเหลวทันที แทนที่จะรายงานว่าสำเร็จแล้วค่อยล้มเหลวในภายหลัง

Type=exec ถูกเพิ่มเข้ามาใน systemd เวอร์ชัน 240 แต่การ backport ของแต่ละ distribution อาจรองรับในเวอร์ชันที่เก่ากว่านั้น เช่น RHEL 8 เพิ่มฟีเจอร์นี้เข้ามาใน systemd-239-15.el8 สำหรับ release เก่าที่ยังรองรับอยู่อาจไม่มีฟีเจอร์นี้ เช่น Ubuntu 18.04 ซึ่งยังอยู่ในช่วง ESM จนถึงเดือนเมษายน 2028 และคู่มือของ systemd 237 ไม่ได้ระบุว่า exec เป็น type ที่รองรับ ณ เดือนตุลาคม 2026 Ubuntu 24.04 ใช้ systemd 255 และ Debian 13 ใช้ systemd 257 ให้ตรวจสอบเวอร์ชันของคุณด้วย systemctl --version และคู่มือ systemd.service ของ distribution นั้นๆ

สิ่งที่ต้องแลกคือขั้นตอนการซิงโครไนซ์ที่เพิ่มขึ้นหนึ่งขั้นตอนตอนเริ่มทำงาน แต่สิ่งที่ได้รับคือสถานะการ exit ที่ถูกต้องจาก systemctl start สำหรับโปรแกรมที่รันใน foreground ควรเลือกใช้ exec แทน simple

Type=forking และปัญหาการหา PID หลักไม่พบ

Type=forking เป็นการแจ้งให้ systemd ทราบว่ากระบวนการใน ExecStart= จะทำการ fork กระบวนการลูกออกมาแล้วจบการทำงานลงโดยเจตนา systemd จะรอให้กระบวนการแรกนั้นจบลงก่อน แล้วจึงถือว่า unit นั้นเริ่มทำงานแล้ว กระบวนการลูกที่เหลืออยู่คือ daemon พฤติกรรมนี้สืบทอดมาจากยุค SysV ซึ่งไม่มีระบบคอยกำกับดูแล daemon หลังจากที่ init script ทำงานเสร็จสิ้น และไฟล์ PID เป็นเพียงบันทึกเดียวที่ระบุว่ามีอะไรทำงานอยู่ ซึ่งเป็นข้อจำกัดที่เป็นหัวใจสำคัญของ เหตุผลที่ systemd เข้ามาแทนที่ init scripts

ความยากคือการระบุตัวตน กระบวนการที่ systemd สั่งเริ่มทำงานได้จบลงไปแล้ว systemd จึงต้องหาว่ากระบวนการใดที่เหลืออยู่คือกระบวนการหลัก ให้ตั้งค่า PIDFile= ไปที่ไฟล์ที่ daemon เขียนขึ้น ซึ่งปกติจะเป็น path ภายใต้ /run แล้ว systemd จะอ่านค่า PID จากไฟล์นั้น เมื่อไฟล์ดังกล่าวมีผู้ใช้งานที่ไม่มีสิทธิ์พิเศษเป็นเจ้าของ systemd จะตรวจสอบด้วยว่า PID ในไฟล์นั้นเป็นกระบวนการที่อยู่ใน service นี้จริงหรือไม่ เพื่อป้องกันไม่ให้ไฟล์ที่ค้างอยู่หรือไฟล์ที่ถูกสร้างขึ้นเพื่อหลอกให้ระบุถึงกระบวนการที่ไม่เกี่ยวข้องถูกนำมาใช้งาน

หากไม่มี PIDFile= ค่า GuessMainPID= จะถูกนำมาใช้ ซึ่งค่าเริ่มต้นคือ yes การคาดเดานี้จะเชื่อถือได้ก็ต่อเมื่อ service นั้นทำงานเหลือเพียงกระบวนการเดียวเท่านั้น คู่มือระบุข้อจำกัดไว้อย่างชัดเจนว่า การคาดเดาอาจได้ข้อสรุปที่ผิดพลาดหาก daemon ประกอบด้วยกระบวนการมากกว่าหนึ่งกระบวนการ และหากไม่สามารถระบุ PID หลักได้ การตรวจจับความล้มเหลวและการเริ่มทำงานใหม่โดยอัตโนมัติจะไม่ทำงานอย่างน่าเชื่อถือ unit อาจจบลงด้วยการมี PID หลักเป็น 0 ซึ่งหมายความว่า systemd ไม่ได้ติดตามกระบวนการหลักใดๆ เลย แม้ว่ากระบวนการของ daemon จะยังคงทำงานอยู่ใน cgroup ของ unit นั้นก็ตาม

daemon ส่วนใหญ่ที่ fork กระบวนการมักจะมีสวิตช์ที่ช่วยให้มันทำงานใน foreground ได้ ให้ใช้สวิตช์นั้นร่วมกับ Type=exec และลบบรรทัด PIDFile= ออก ยิ่งมีส่วนประกอบที่ซับซ้อนน้อยลง โอกาสที่จะสูญเสีย PID ก็ยิ่งน้อยลงตามไปด้วย

Type=oneshot สำหรับงานที่ทำงานจนเสร็จสิ้น

Type=oneshot คาดหวังให้กระบวนการทำงานและจบการทำงานลง systemd จะถือว่า unit เริ่มทำงานก็ต่อเมื่อกระบวนการนั้นจบลงแล้วเท่านั้น ซึ่งทำให้ oneshot เป็นรูปแบบที่เหมาะสมสำหรับงานใดๆ ที่ unit อื่นจำเป็นต้องรอ นอกจากนี้ยังเป็นค่าเริ่มต้นโดยนัยเมื่อ unit ไม่ได้ระบุทั้ง Type= และ ExecStart=

มีพฤติกรรมสองอย่างที่เฉพาะเจาะจงสำหรับ oneshot คือเป็น type เดียวที่ยอมรับบรรทัด ExecStart= ได้มากกว่าหนึ่งบรรทัด และบรรทัดเหล่านั้นจะทำงานตามลำดับ นอกจากนี้การตั้งค่าเวลาเริ่มต้น (start timeout) จะถูกปิดใช้งานโดยค่าเริ่มต้น ดังนั้น oneshot ที่ค้างอยู่จะรอไปเรื่อยๆ เว้นแต่คุณจะตั้งค่า TimeoutStartSec= ด้วยตนเอง

หลังจากกระบวนการจบลง unit จะกลับสู่สถานะ inactive แต่ RemainAfterExit=yes จะคงสถานะไว้เป็น active โดยไม่มีกระบวนการใดๆ ทำงานอยู่เลย นี่คือเวอร์ชันที่ตั้งใจให้เป็นของอาการที่กล่าวถึงที่ด้านบนของหน้านี้ และเป็นสิ่งที่ถูกต้องเมื่อหน้าที่ของ unit คือการทิ้งสถานะไว้เบื้องหลังแทนที่จะคงให้บางอย่างทำงานอยู่ เช่น การโหลดชุดกฎของ firewall หรือการเริ่ม stack ของ container นี่คือรูปแบบเบื้องหลัง Docker Compose stack ที่กลับมาทำงานใหม่หลังรีบูต ซึ่ง unit จะรันคำสั่ง compose แล้วจบการทำงานลง แต่ยังคงสถานะ active ไว้เพราะ container ที่มันเริ่มทำงานนั้นยังคงอยู่ต่อไป นอกจากนี้ unit แบบ oneshot ยังเหมาะกับงานที่ถูกกระตุ้นตามกำหนดเวลา ซึ่งเป็นอีกครึ่งหนึ่งของ การรันงานบน systemd timer แทนการใช้ cron

Type=notify ช่วยให้ service แจ้งสถานะเมื่อพร้อมทำงาน

Type=notify เป็นการย้ายการตัดสินใจไปไว้ที่ตัว service เอง โดย systemd จะค้างสถานะการเริ่มทำงานไว้จนกว่า process จะส่ง READY=1 ผ่าน Unix socket ซึ่งได้รับ path มาในตัวแปร environment NOTIFY_SOCKET สำหรับ C interface นั้นใช้ sd_notify(3) ซึ่งเซิร์ฟเวอร์จำนวนมากรองรับอยู่แล้ว

นี่คือคำตอบที่แม่นยำสำหรับคำถามที่ว่า "เริ่มทำงานหรือยัง" เพราะ simple และ exec จะรายงานว่าเริ่มทำงานแล้วตั้งแต่ก่อนที่ service จะอ่าน configuration หรือเปิด listening socket ทำให้ unit ที่ขึ้นต่อกันเริ่มทำงานเร็วเกินไปและล้มเหลวในการเชื่อมต่อครั้งแรก ส่วน notify จะรายงานว่าเริ่มทำงาน ณ วินาทีที่ service ยืนยันว่าพร้อมใช้งานจริง

systemd จะยอมรับข้อความดังกล่าวจาก main process เท่านั้น ซึ่งเป็นความหมายของ NotifyAccess=main และ Type=notify ก็สื่อถึงเรื่องนี้ หากข้อความถูกส่งมาจาก child process หรือ helper ให้ตั้งค่า NotifyAccess=all สคริปต์ shell สามารถเรียกใช้ systemd-notify --ready ได้ หากมีสิทธิ์เพียงพอ systemd-notify จะส่งข้อความภายใต้ PID ของ parent ดังนั้นสคริปต์ที่เป็น main process เองจะต้องส่ง NotifyAccess=main มิฉะนั้นสคริปต์จะย้อนกลับไปใช้ PID ของตัวเองและ unit จำเป็นต้องมี NotifyAccess=all โดยปกติแล้ว systemd จะรอจนกว่าจะประมวลผลข้อความเสร็จสิ้นก่อนจะจบการทำงาน ดังนั้นไม่ต้องใส่ --no-block ซึ่งเป็นการปิดการรอคอยดังกล่าว service ที่สื่อสารผ่านโปรโตคอลนี้โดยตรงจะมีความน่าเชื่อถือมากกว่า

มีอีกสองการตั้งค่าที่เกี่ยวข้องซึ่งควรทราบ คือ Type=notify-reload ซึ่งมีให้ใช้งานตั้งแต่ systemd 253 เป็นต้นไป โดยขยายการทำ handshake แบบเดียวกันนี้ไปถึงการ reload ทำให้ systemctl reload จะส่งผลตอบกลับเมื่อ service รายงานว่าการ reload เสร็จสิ้นแล้ว แทนที่จะตอบกลับทันทีที่ส่งสัญญาณไป และตั้งแต่ systemd 262 ซึ่งปล่อยออกมาในเดือนกันยายน 2026 service แบบ notify-reload ที่ส่ง READY=1 โดยไม่ดักจับหรือบล็อกสัญญาณ reload (ปกติคือ SIGHUP เว้นแต่ ReloadSignal= จะกำหนดไว้เป็นอย่างอื่น) จะล้มเหลวในการเริ่มทำงานพร้อมข้อผิดพลาดของโปรโตคอล แทนที่จะถูกฆ่าด้วยสัญญาณนั้นในการ reload ครั้งแรก ส่วน WatchdogSec= จะสั่งให้ service ที่ใช้การแจ้งสถานะส่งข้อความ keep-alive ตามช่วงเวลาที่กำหนด และ systemd จะถือว่าการพลาดกำหนดเวลาดังกล่าวเป็นความล้มเหลว

Type=dbus และ Type=idle

Type=dbus จะรอจนกว่าบริการจะลงทะเบียนชื่อบน D-Bus ซึ่งเป็น message bus ที่บริการของระบบและเดสก์ท็อปใช้สื่อสารกัน การตั้งค่านี้จำเป็นต้องมี BusName= และจะกลายเป็นค่าเริ่มต้นทันทีที่มีการตั้งค่า BusName= ให้ใช้ค่านี้เฉพาะกับบริการที่มีการลงทะเบียนชื่อบน bus จริงๆ เท่านั้น

Type=idle ทำงานคล้ายกับ simple แต่จะหน่วงเวลาการรันโปรแกรมไว้จนกว่างานที่ค้างอยู่ในคิวจะถูกประมวลผลเสร็จสิ้น โดยมีระยะเวลาจำกัดสูงสุดที่ 5 วินาที ค่านี้มีไว้เพื่อป้องกันไม่ให้ข้อความที่แสดงบนคอนโซลระหว่างการบูตปะปนกับข้อความสถานะของระบบ ไม่ใช่เครื่องมือสำหรับจัดการลำดับการทำงาน (ordering tool) และไม่ควรนำไปใช้กับบริการทั่วไป

เหตุใด wrapper script จึงทำให้ systemd ติดอยู่ที่ PID ที่ไม่ถูกต้อง

นี่คือรูปแบบที่ทำให้เกิดอาการดังกล่าว

[Service]
Type=simple
ExecStart=/opt/app/run.sh
#!/bin/bash
export APP_ENV=production
/opt/app/bin/server --config /etc/app.yaml &
/opt/app/bin/exporter --port 9101

systemd บันทึก shell ไว้เป็น PID หลัก shell จะยังคงทำงานอยู่ตราบเท่าที่ exporter ทำงานในเบื้องหน้า หาก server หยุดทำงาน shell จะไม่รับรู้ ดังนั้น PID หลักจึงยังคงทำงานอยู่ สถานะของ unit จึงยังคงเป็น active และ Restart= ก็ไม่มีสิ่งใดให้ดำเนินการ ทั้งสองกระบวนการยังคงอยู่ใน cgroup ของ unit ตลอดเวลา ดังนั้น systemctl stop จึงยังคงล้างข้อมูลได้อย่างถูกต้อง สิ่งที่ล้มเหลวคือการกำกับดูแล (supervision) ไม่ใช่การล้างข้อมูล

วิธีแก้ไขขึ้นอยู่กับจำนวนกระบวนการที่ทำงานยาวนานใน unit นั้นจริงๆ

หากมีเพียงกระบวนการเดียว ให้แทนที่ shell ด้วยกระบวนการนั้น

#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yaml

exec จะแทนที่ shell ด้วยโปรแกรมที่ระบุและรักษา PID เดิมไว้ ดังนั้น PID ที่ systemd บันทึกไว้จึงกลายเป็นของ daemon โดยตรง วิธีที่ดีกว่าคือการลบ wrapper ออก Environment= และ EnvironmentFile= สามารถจัดการตัวแปรต่างๆ ได้ และ ExecStartPre= สามารถจัดการขั้นตอนการตั้งค่าได้ ดังนั้น systemd จึงสามารถเรียกใช้ daemon ได้โดยตรงและทราบ PID ของมันโดยโครงสร้าง

หากมีสองกระบวนการ จะไม่มี PID เดียวที่แสดงถึง unit นั้น ให้แยกออกเป็นสอง unit และกำหนดลำดับด้วย After= และ Wants= การจัดรูปแบบให้หนึ่ง unit ต่อหนึ่งกระบวนการคือสิ่งที่ systemd กำกับดูแลได้ดี และเป็นวิธีเดียวที่แต่ละกระบวนการจะได้รับพฤติกรรมการรีสตาร์ทเป็นของตนเอง

การเปลี่ยนแปลงของ ExitType=cgroup

ExitType= ถูกเพิ่มเข้ามาใน systemd เวอร์ชัน 250 ค่าเริ่มต้นคือ main ซึ่งหมายความว่า unit จะถูกพิจารณาว่าหยุดทำงานเมื่อกระบวนการหลัก (main process) จบลง แต่ด้วย ExitType=cgroup unit จะยังคงถูกพิจารณาว่าทำงานอยู่ตราบเท่าที่ยังมีกระบวนการใดๆ ใน cgroup ของ unit นั้นทำงานอยู่

[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcher

การตั้งค่านี้ช่วยแก้ปัญหาเฉพาะอย่างหนึ่ง นั่นคือตัวเรียกใช้งาน (launcher) ที่ทำหน้าที่เริ่มงานจริงแล้วจบการทำงานลง หากใช้ ExitType=main ระบบ systemd จะถือว่า unit นั้นหยุดทำงานและสั่งยุติกระบวนการที่เหลืออยู่ทั้งหมด แต่ด้วย ExitType=cgroup ตัว unit จะติดตามสถานะของทั้งกลุ่มแทน

ต้องทำความเข้าใจให้ชัดเจนว่าสิ่งนี้ไม่ได้แก้ปัญหาอะไรบ้าง ExitType=cgroup จะรักษา unit ให้ทำงานอยู่ตราบเท่าที่มีอย่างน้อยหนึ่งกระบวนการทำงานอยู่ ดังนั้น unit ที่ดูแล daemon สองตัวจะยังคงทำงานอยู่แม้ว่าตัวหนึ่งจะตายไป มันช่วยแก้ปัญหาในกรณีของตัวเรียกใช้งานเท่านั้น แต่ไม่ได้เปลี่ยน unit ให้กลายเป็นตัวควบคุม (supervisor) ของกระบวนการอิสระหลายตัว นอกจากนี้ ExitType=cgroup ยังไม่สามารถใช้งานร่วมกับ Type=oneshot ได้

cgroup ยังเป็นจุดที่ใช้ในการบันทึกการใช้ทรัพยากร ดังนั้นขีดจำกัดต่างๆ เช่น MemoryMax= และ CPUQuota= จะมีผลกับทุกกระบวนการที่ unit นั้นสร้างขึ้น ไม่ว่า Type= จะระบุเกี่ยวกับ main PID ไว้อย่างไรก็ตาม รายละเอียดในส่วนนี้อยู่ใน การจำกัดหน่วยความจำและ CPU ของบริการด้วย systemd

วิธีค้นหา process ที่ systemd กำลังเฝ้าติดตามอยู่จริง

ให้ดำเนินการตามขั้นตอนต่อไปนี้กับ unit ที่คุณกำลังดีบั๊ก โดยเริ่มจากการอ่านไฟล์ unit จากนั้นตรวจสอบสิ่งที่ systemd ติดตามอยู่ แล้วนำไปเปรียบเทียบกับตาราง process

systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.service

systemctl cat จะแสดงไฟล์ unit พร้อมกับไฟล์ drop-in ทั้งหมดที่เกี่ยวข้องซึ่งอ่านจากดิสก์ ค่าเหล่านี้อาจแตกต่างจากสิ่งที่ systemd โหลดไว้หากมีการแก้ไขไฟล์โดยไม่ได้รัน daemon-reload ส่วน systemctl show จะแสดงค่าที่ใช้งานจริง รวมถึงค่าเริ่มต้นที่คุณไม่ได้ระบุไว้ในไฟล์ ให้จดค่าของ MainPID ไว้ก่อนดำเนินการในขั้นตอนถัดไป

systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"

systemd-cgls จะแสดงรายการ process ทั้งหมดที่อยู่ใน cgroup ของ unit นั้น บรรทัด ps จะอธิบายถึง process หลักที่ systemd กำลังดูแลอยู่ ให้พิจารณาทั้งสองส่วนประกอบกัน หาก MainPID เป็น 0 หมายความว่า systemd ไม่ได้ติดตาม process หลักใดๆ แม้ว่า systemd-cgls จะยังแสดงรายการ process ที่อยู่ใน cgroup ของ unit นั้นก็ตาม หาก MainPID ชี้ไปยัง shell ในขณะที่ cgroup ยังคงมี daemon ของคุณอยู่ แสดงว่าเป็นกรณีของ wrapper ที่กล่าวถึงข้างต้น หาก cgroup มีจำนวน process มากกว่าที่คุณคาดไว้ แสดงว่ามีการใช้งาน launcher หรือ forking daemon อยู่

systemctl status app.service
journalctl -u app.service -b

systemctl status จะแสดงบรรทัดสถานะและโครงสร้าง cgroup พร้อมกัน ซึ่งมักจะตอบคำถามทั้งสองข้อได้ในคราวเดียว journalctl -u ที่จำกัดขอบเขตไว้เฉพาะการบูตปัจจุบันด้วย -b จะแสดงเหตุการณ์การเริ่มและหยุดทำงานที่ systemd บันทึกไว้สำหรับ unit นั้น พร้อมกับ exit code ที่ตรวจพบ หาก daemon เขียน log ลงในไฟล์ของตัวเองแทนที่จะเป็น journal ให้ตรวจสอบไฟล์นั้นด้วย เพราะ systemd สามารถบันทึกได้เฉพาะสิ่งที่ส่งมาถึงตัวมันเท่านั้น

เมื่อคุณเปลี่ยนแปลง Type= ให้ทำการ reload และ restart เสมอ

systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.service

systemd-analyze verify จะทำการวิเคราะห์ไฟล์และรายงานการตั้งค่าที่ไม่สามารถยอมรับได้ ส่วน daemon-reload จะสั่งให้ systemd อ่านไฟล์ unit จากดิสก์ใหม่อีกครั้ง การเปลี่ยนแปลง Type= จะไม่มีผลกับ unit ที่กำลังทำงานอยู่ ดังนั้นการ restart จึงเป็นสิ่งที่จำเป็น ไม่ใช่ทางเลือก

จากนั้นให้ทดสอบการเปลี่ยนแปลง โดยนำ PID ของ process ที่คุณต้องการตรวจสอบจาก systemd-cgls แล้วสั่ง kill process นั้น จากนั้นรัน systemctl is-active app.service ทันที สำหรับ ExitType=main และ RemainAfterExit=no การ kill process หลักจะเป็นการยุติ instance ที่กำลังทำงานอยู่ แม้ว่านโยบาย restart อาจทำให้มันกลับมาทำงานใหม่ก่อนที่คุณจะตรวจสอบก็ตาม หากสถานะยังคงเป็น active โดยไม่มีการ restart ให้ตรวจสอบว่า systemd กำลังเฝ้าติดตามสิ่งอื่นอยู่หรือไม่ หรือ unit นั้นมีการใช้ ExitType=cgroup หรือ RemainAfterExit=yes อยู่หรือไม่

คุณควรใช้ systemd service Type= แบบใด

  • โปรแกรมที่ทำงานใน foreground: Type=exec
  • โปรแกรมที่รองรับการแจ้งเตือนสถานะพร้อมใช้งาน: Type=notify และ notify-reload หากโปรแกรมนั้นยืนยันการโหลดซ้ำ (reload) ด้วย
  • daemon ที่ต้องการย้ายตัวเองไปทำงานใน background: Type=forking ร่วมกับ PIDFile= หรือใช้สวิตช์สำหรับทำงานใน foreground ของโปรแกรมนั้นร่วมกับ Type=exec
  • สคริปต์ที่ทำงานจนเสร็จแล้วจบการทำงาน: Type=oneshot และใช้ RemainAfterExit=yes หากมีจุดประสงค์เพื่อทิ้งสถานะไว้เบื้องหลัง
  • ตัวเรียกใช้งาน (launcher) ที่จบการทำงานในขณะที่กระบวนการลูกยังคงทำงานอยู่: Type=simple ร่วมกับ ExitType=cgroup

หากคุณไม่แน่ใจว่า daemon ของบุคคลที่สามต้องการค่าใด ให้ตรวจสอบไฟล์ unit ที่มาพร้อมกับแพ็กเกจก่อน การรันคำสั่ง systemctl cat บน unit ที่มาพร้อมกับ distribution จะแสดงตัวเลือก Type= ที่กำหนดไว้ รวมถึงการตั้งค่าที่เขียนทับในเครื่อง (local overrides)

FAQ

ทำไม unit ของ systemd ถึงยังคงสถานะ active ทั้งที่ process ตายไปแล้ว?

หากใช้ค่าเริ่มต้นของ ExitType=main และ RemainAfterExit=no เหตุการณ์นี้จะเกิดขึ้นเพราะ process ที่ systemd มองว่าเป็น process หลักยังคงทำงานอยู่ ภายใต้ค่าเริ่มต้นดังกล่าว systemd จะติดตาม PID หลักเพียงตัวเดียวต่อหนึ่ง service ซึ่งเลือกตาม Type= สาเหตุที่พบบ่อยคือการใช้ wrapper script ที่เริ่มด้วย Type=simple โดยตัว shell จะกลายเป็น PID หลัก ดังนั้น unit จึงยังคงสถานะ active แม้ว่า daemon ที่ shell เรียกทำงานในเบื้องหลังจะจบการทำงานไปแล้ว ให้รัน systemctl show -p MainPID app.service จากนั้นแสดงรายการ cgroup ของ unit ด้วย systemd-cgls --unit=app.service แล้วเปรียบเทียบค่าทั้งสอง

ความแตกต่างระหว่าง Type=simple และ Type=exec คืออะไร?

Type=simple จะถือว่า unit เริ่มทำงานทันทีที่ systemd สร้าง process ขึ้นมา ก่อนที่ binary จะถูกเรียกใช้งานจริง ดังนั้นหากระบุ path ผิดใน ExecStart= ระบบจะยังคงรายงานว่า start job สำเร็จก่อนจะตามด้วยความล้มเหลวในภายหลัง ส่วน Type=exec จะรอจนกว่าการเรียกใช้งานจะสำเร็จ ดังนั้นความล้มเหลวจะถูกรายงานโดยตัว start job เอง ทั้งสองแบบถือว่า process เดียวกันเป็น PID หลัก Type=exec ถูกเพิ่มเข้ามาใน systemd เวอร์ชัน 240 แต่ละ distribution อาจ backport ไปยังเวอร์ชันที่เก่ากว่าได้ เช่นที่ RHEL 8 ทำใน systemd-239-15.el8

ยังจำเป็นต้องใช้ PIDFile= เมื่อใช้ Type=forking หรือไม่?

จำเป็น หาก daemon มีการเขียนไฟล์ดังกล่าว หากไม่มี systemd จะใช้วิธี GuessMainPID= ซึ่งเป็นการคาดเดาและเชื่อถือได้เฉพาะกับ service ที่ทำงานเป็น process เดียวเท่านั้น เมื่อการคาดเดาผิดพลาดหรือไม่สามารถทำได้ การตรวจจับความล้มเหลวและการเริ่มทำงานใหม่โดยอัตโนมัติจะไม่ทำงานอย่างแม่นยำสำหรับ unit นั้น ให้ชี้ PIDFile= ไปยัง path ที่ daemon เขียนไฟล์จริง ซึ่งปกติจะอยู่ภายใต้ /run

ควรใช้ RemainAfterExit=yes เมื่อใด?

ใช้เมื่อจุดประสงค์ของ unit คือการเปลี่ยนสถานะของระบบแทนที่จะเป็นการรักษา process ให้ทำงานอยู่ตลอดเวลา unit ประเภท Type=oneshot ที่โหลดกฎ firewall หรือเริ่ม container stack จะจบการทำงานทันทีที่งานเสร็จสิ้น หากไม่มี RemainAfterExit=yes unit จะเปลี่ยนสถานะจาก starting ไปเป็น stopping ทันที ทำให้คำสั่ง ExecStop= ที่ใช้ทำความสะอาดระบบทำงานทันทีหลังจากงานเสร็จสิ้น แทนที่จะทำงานเมื่อคุณสั่งหยุด unit และ systemctl stop ก็จะไม่มีสิ่งใดให้หยุด แต่หากใช้ตัวเลือกนี้ unit จะยังคงสถานะ active โดยไม่มี process ใดๆ ซึ่งเป็นสิ่งที่ต้องการในกรณีนี้

การเปลี่ยน Type= จำเป็นต้องใช้ daemon-reload หรือไม่?

จำเป็น และต้อง restart unit ด้วย systemctl daemon-reload จะทำให้ systemd อ่านไฟล์ unit บนดิสก์ใหม่อีกครั้ง แต่ instance ที่กำลังทำงานอยู่จะยังคงใช้ Type= ที่เริ่มมาตั้งแต่ต้น ให้รัน sudo systemctl daemon-reload และตามด้วย sudo systemctl restart app.service ก่อนทำการทดสอบ มิฉะนั้นคุณจะยังคงเฝ้าดูพฤติกรรมการควบคุมแบบเดิมอยู่

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