systemd service Type: simple, forking, notify का सही चुनाव
क्या आपकी systemd service active है पर daemon बंद हो चुका है? simple, forking, notify और oneshot के बीच का अंतर समझें और अपनी unit के लिए सही main PID ट्रैक करना सीखें।
जब process मर जाती है तो systemd unit को active क्यों दिखाता है
डिफ़ॉल्ट ExitType=main और RemainAfterExit=no के साथ, एक systemd service unit तब तक active रहती है जब तक वह process जीवित है जिसे systemd मुख्य process मानता है, और [Service] section में मौजूद Type= यह तय करता है कि वह process कौन सी है। यदि आप गलत value चुनते हैं, तो systemd किसी shell wrapper या कम समय तक चलने वाले parent process को monitor करने लगता है, जबकि वह daemon जिसे आप वास्तव में track करना चाहते हैं, उसी unit के अंदर मर जाता है। unit आपको उस process के बारे में सही जानकारी दे रही है जिसे उसे monitor करने के लिए कहा गया है।
restart policy बदलने से यहाँ कोई मदद नहीं मिलेगी। Restart= process के exit होने और timeouts जैसी विफलताओं पर प्रतिक्रिया करता है, लेकिन यह किसी background daemon के exit होने का पता तब नहीं लगा पाता जब main PID (process identifier) किसी ऐसी चीज़ से संबंधित हो जो अभी भी चल रही है। सबसे पहले Type= को ठीक करें। मुख्य process के वास्तव में exit होने के बाद systemd क्या करेगा, यह एक अलग निर्णय है, जो Restart= और RestartSec= के लिए गाइड में शामिल है।
Type= वास्तव में क्या निर्धारित करता है
प्रत्येक Type= मान एक साथ दो सवालों के जवाब देता है। systemd कब यह मानेगा कि यह unit शुरू हो गई है, और मुख्य process कौन सी है।
पहला जवाब ordering को नियंत्रित करता है। जो unit After= में आपकी unit का नाम लेती है, वह तब तक प्रतीक्षा करती है जब तक systemd आपकी unit को 'started' घोषित नहीं कर देता। यदि कोई Type= बहुत जल्दी "started" रिपोर्ट कर देता है, तो dependent units आपकी service के तैयार होने से पहले ही चल सकती हैं।
दूसरा जवाब supervision को नियंत्रित करता है। systemd एक unit द्वारा शुरू की गई हर process को एक cgroup (control group) में डालता है। यह kernel का एक feature है जो processes को एक समूह में रखता है ताकि उन्हें सीमित किया जा सके और एक साथ बंद किया जा सके। cgroup के जरिए ही systemctl stop cleanup करता है: KillMode= का default मान control-group होता है, इसलिए unit को stop करने पर उसके अंदर की हर process को signal भेजा जाता है। main PID का दायरा इससे छोटा होता है। default ExitType=main और RemainAfterExit=no के साथ, यह वह एकमात्र process है जिसके exit होने पर unit समाप्त मानी जाती है, और जिसका exit status unit के परिणाम में योगदान देता है। भ्रम तब शुरू होता है जब cgroup को main PID मान लिया जाता है।
Type=simple रिपोर्ट करता है कि प्रक्रिया शुरू हो गई है
Type=simple डिफ़ॉल्ट मान है जब ExecStart= सेट हो, न तो Type= और न ही BusName= मौजूद हों, और यूनिट किसी क्रेडेंशियल का उपयोग न करती हो। जो यूनिट क्रेडेंशियल लोड करती है, उदाहरण के लिए LoadCredential= के साथ, उसमें इसके बजाय Type=exec निहित होता है। simple के तहत, systemd प्रक्रिया बनाता है, यूनिट को तुरंत शुरू हुआ मानता है, और उस प्रक्रिया को मुख्य PID के रूप में देखता है। सर्विस बाइनरी के निष्पादित होने से पहले ही, फॉलो-अप यूनिट्स तुरंत शुरू हो जाती हैं।
यह अंतिम विवरण एक सामान्य आश्चर्य की व्याख्या करता है। ExecStart= पथ में टाइपो होने पर भी एक स्टार्ट जॉब सफल हो जाती है, और विफलता कुछ क्षण बाद आती है जब निष्पादन विफल हो जाता है। systemd उस मामले को एग्जिट कोड 203 के साथ रिकॉर्ड करता है, जिसे उसकी अपनी तालिका EXIT_EXEC नाम देती है और वास्तविक प्रक्रिया निष्पादन की विफलता के रूप में परिभाषित करती है। इसलिए systemctl start का बिना किसी त्रुटि के वापस आना यह साबित नहीं करता है कि आपकी बाइनरी मौजूद है।
ऐसे प्रोग्राम के लिए simple का उपयोग करें जो फॉरग्राउंड में रहता है और खुद को कभी बैकग्राउंड में नहीं ले जाता है। यह अधिकांश आधुनिक डेमन्स और आपके द्वारा लिखे गए लगभग किसी भी प्रोग्राम को कवर करता है।
Type=exec प्रोग्राम के वास्तव में शुरू होने का इंतजार करता है
Type=exec, simple का ही एक उन्नत रूप है। systemd यूनिट को तभी शुरू हुआ मानता है जब fork और binary का निष्पादन (execution) दोनों सफल हो जाते हैं। यदि binary मौजूद न हो या User= को resolve न किया जा सके, तो अब यह start job को ही विफल कर देता है। इसके बजाय कि यह पहले सफलता की रिपोर्ट दे और कुछ क्षण बाद चुपचाप विफल हो जाए।
Type=exec को systemd 240 में upstream किया गया था, लेकिन distribution backports इसे पुराने संस्करणों पर भी समर्थन देते हैं: RHEL 8 ने इसे systemd-239-15.el8 में जोड़ा था। समर्थित पुराने releases में अभी भी इसकी कमी हो सकती है: Ubuntu 18.04 अप्रैल 2028 तक ESM के अंतर्गत है, और इसका systemd 237 मैनुअल exec को समर्थित प्रकार के रूप में सूचीबद्ध नहीं करता है। अक्टूबर 2026 तक, Ubuntu 24.04 में systemd 255 और Debian 13 में systemd 257 उपलब्ध है। अपने सिस्टम पर इसे systemctl --version और distribution के systemd.service मैनुअल से जाँचें।
इसकी कीमत शुरुआत में एक अतिरिक्त सिंक्रनाइज़ेशन चरण है। इसका लाभ systemctl start से मिलने वाला एक सटीक exit status है। foreground प्रोग्राम के लिए, simple के बजाय exec को प्राथमिकता दें।
Type=forking, और मुख्य PID कैसे खो जाता है
Type=forking, systemd को बताता है कि ExecStart= में मौजूद process एक child process बनाएगा और फिर जानबूझकर exit हो जाएगा। systemd उस पहली process के exit होने का इंतज़ार करता है और उसके बाद ही unit को started मानता है। पीछे बची हुई child process ही daemon होती है। यह आदत SysV युग से चली आ रही है, जब init script के return होने के बाद daemon की निगरानी के लिए कुछ नहीं होता था और PID file ही एकमात्र रिकॉर्ड होती थी कि क्या चल रहा है। यह एक ऐसी सीमा है जो systemd ने init scripts की जगह क्यों ली के मुख्य कारणों में से एक है।
कठिनाई पहचान की है। जिस process को systemd ने launch किया था, वह अब मौजूद नहीं है, इसलिए systemd को यह पता लगाना पड़ता है कि बची हुई प्रक्रियाओं में से मुख्य कौन सी है। PIDFile= को उस file पर सेट करें जिसे daemon लिखता है, जो आमतौर पर /run के अंतर्गत एक path होता है, और systemd उससे PID पढ़ लेता है। जब वह file किसी unprivileged user के स्वामित्व में होती है, तो systemd यह भी जाँचता है कि उसमें मौजूद PID उसी service से संबंधित process की है या नहीं, ताकि किसी पुरानी या गलत file पर भरोसा करने के बजाय उसे reject किया जा सके।
PIDFile= के बिना, GuessMainPID= लागू होता है, और इसका default मान yes होता है। यह अनुमान केवल तभी विश्वसनीय होता है जब service एक ही process में स्थिर हो जाए। manual इस सीमा को स्पष्ट रूप से बताता है: यदि daemon में एक से अधिक processes हैं, तो अनुमान गलत हो सकता है। यदि मुख्य PID निर्धारित नहीं किया जा सकता है, तो failure detection और automatic restarting विश्वसनीय रूप से काम नहीं करेंगे। एक unit का मुख्य PID 0 भी हो सकता है, जिसका अर्थ है कि systemd किसी भी मुख्य process को track नहीं कर रहा है, भले ही daemon की processes unit के cgroup में चल रही हों।
fork करने वाले अधिकांश daemons में एक switch होता है जो उन्हें foreground में रखता है। उस switch का उपयोग Type=exec के साथ करें और PIDFile= line को हटा दें। कम जटिलता का मतलब है PID खोने की कम संभावना।
Type=oneshot ऐसे कार्यों के लिए जो समाप्त हो जाते हैं
Type=oneshot यह अपेक्षा करता है कि process चले और exit हो जाए। systemd unit को तभी started मानता है जब वह exit हो चुकी हो, जो oneshot को किसी भी ऐसी चीज़ के लिए सही स्वरूप बनाता है जिसका अन्य units को इंतज़ार करना चाहिए। जब कोई unit न तो Type= और न ही ExecStart= निर्दिष्ट करती है, तो यह निहित डिफ़ॉल्ट भी है।
दो व्यवहार विशेष रूप से oneshot के लिए हैं। यह एकमात्र type है जो एक से अधिक ExecStart= लाइनों को स्वीकार करता है, और वे लाइनें क्रम में चलती हैं। इसका start timeout भी डिफ़ॉल्ट रूप से अक्षम होता है, इसलिए यदि आप स्वयं TimeoutStartSec= सेट नहीं करते हैं, तो एक oneshot जो हैंग हो जाता है, वह हमेशा के लिए प्रतीक्षा करता है।
process के exit होने के बाद, unit inactive स्थिति में लौट आती है। RemainAfterExit=yes इसे बिना किसी चल रही process के active बनाए रखता है। यह इस पृष्ठ के शीर्ष पर बताए गए लक्षण का जानबूझकर किया गया संस्करण है, और यह तब सही होता है जब unit का कार्य कुछ चलाने के बजाय स्थिति (state) को पीछे छोड़ना हो: जैसे firewall ruleset लोड करना, या container stack को ऊपर लाना। यह reboot के बाद वापस आने वाले Docker Compose stack के पीछे का पैटर्न है, जहाँ unit compose command चलाती है, exit हो जाती है, और active बनी रहती है क्योंकि इसके द्वारा शुरू किए गए containers इसके बाद भी चलते रहते हैं। एक oneshot unit शेड्यूल द्वारा ट्रिगर किए गए कार्यों के लिए भी उपयुक्त है, जो cron के बजाय systemd timer पर job चलाने का दूसरा भाग है।
Type=notify सेवा को यह बताने की अनुमति देता है कि वह कब तैयार है
Type=notify निर्णय लेने की जिम्मेदारी सेवा पर डाल देता है। systemd तब तक start job को खुला रखता है जब तक कि process READY=1 नहीं भेज देती। यह संदेश एक Unix socket के माध्यम से भेजा जाता है, जिसका path उसे NOTIFY_SOCKET environment variable में प्राप्त होता है। इसके लिए C interface sd_notify(3) है, और कई servers इसे पहले से ही support करते हैं।
"क्या यह शुरू हो गया है" प्रश्न का यह सटीक उत्तर है। simple और exec सेवा द्वारा अपना configuration पढ़ने या listening socket खोलने से पहले ही 'started' की रिपोर्ट दे देते हैं। इस कारण, कोई dependent unit बहुत जल्दी शुरू हो सकती है और अपना पहला connection बनाने में विफल हो सकती है। notify उस क्षण 'started' की रिपोर्ट देता है जब सेवा स्वयं यह बताती है कि वह तैयार है।
systemd केवल main process से ही वह संदेश स्वीकार करता है, जिसका अर्थ NotifyAccess=main है, और Type=notify इसे सूचित करता है। यदि संदेश किसी child या helper process से आता है, तो NotifyAccess=all सेट करें। एक shell script systemd-notify --ready को call कर सकती है। जब इसके पास आवश्यक privileges होती हैं, तो systemd-notify अपने parent के PID के तहत संदेश भेजता है। इसलिए, जो script स्वयं main process है, वह NotifyAccess=main पास करती है; अन्यथा यह अपने स्वयं के PID पर वापस आ जाती है और unit को NotifyAccess=all की आवश्यकता होती है। डिफ़ॉल्ट रूप से, यह संदेश process होने तक प्रतीक्षा करता है, इसलिए --no-block को न लिखें, जो उस प्रतीक्षा को बंद कर देता है। जो सेवा स्वयं इस protocol का उपयोग करती है, वह अधिक विश्वसनीय होती है।
दो संबंधित settings जानना उपयोगी है। Type=notify-reload, जो systemd 253 से उपलब्ध है, इसी handshake को reloads तक बढ़ा देता है। इससे systemctl reload तब return होता है जब सेवा यह रिपोर्ट करती है कि reload पूरा हो गया है, न कि तब जब signal भेजा गया था। systemd 262 से, जिसे सितंबर 2026 में release किया गया था, एक notify-reload सेवा जो अपने reload signal (जब तक ReloadSignal= कुछ और न कहे, तब तक SIGHUP) को catch या block किए बिना READY=1 भेजती है, वह protocol error के साथ start होने में विफल हो जाती है, बजाय इसके कि वह अपने पहले reload पर उस signal द्वारा kill कर दी जाए। WatchdogSec= एक notifying सेवा को एक निश्चित अंतराल पर keep-alive संदेश भेजने के लिए कहता है, और systemd समय सीमा चूकने को विफलता मानता है।
Type=dbus और Type=idle
Type=dbus तब तक प्रतीक्षा करता है जब तक service D-Bus पर कोई नाम register नहीं कर लेती। D-Bus वह message bus है जिसका उपयोग system और desktop services एक-दूसरे से संवाद करने के लिए करती हैं। इसके लिए BusName= की आवश्यकता होती है, और जैसे ही BusName= सेट किया जाता है, यह default बन जाता है। इसका उपयोग केवल उसी service के लिए करें जो वास्तव में bus name register करती है।
Type=idle, simple की तरह कार्य करता है, लेकिन यह program को चलाने में तब तक देरी करता है जब तक कि queued jobs dispatch न हो जाएं। इसमें पांच सेकंड की समय सीमा होती है। यह इसलिए मौजूद है ताकि boot के समय console output, status messages के साथ न मिल जाए। यह एक ordering tool नहीं है, और इसे सामान्य service पर उपयोग नहीं किया जाना चाहिए।
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 9101systemd शेल को मुख्य PID के रूप में रिकॉर्ड करता है। जब तक exporter फोरग्राउंड में चलता है, शेल जीवित रहता है। यदि server समाप्त हो जाता है, तो शेल को इसका पता नहीं चलता है, इसलिए मुख्य PID अभी भी जीवित है, यूनिट अभी भी active है, और Restart= के पास कार्रवाई करने के लिए कुछ नहीं है। दोनों प्रक्रियाएं पूरे समय यूनिट के cgroup में रहती हैं, इसलिए systemctl stop अभी भी सही ढंग से सफाई करता है। पर्यवेक्षण (supervision) टूटा है, सफाई नहीं।
इसका समाधान इस बात पर निर्भर करता है कि यूनिट में वास्तव में कितनी लंबी चलने वाली प्रक्रियाएं हैं।
यदि केवल एक प्रक्रिया है, तो शेल को उससे बदल दें।
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec शेल को नामित प्रोग्राम से बदल देता है और वही PID रखता है, इसलिए systemd द्वारा रिकॉर्ड किया गया PID अब डेमन (daemon) का है। इससे भी बेहतर, रैपर को हटा दें। Environment= और EnvironmentFile= वेरिएबल्स को ले जाते हैं, और ExecStartPre= सेटअप चरण को संभालता है, ताकि systemd सीधे डेमन को लॉन्च कर सके और निर्माण के आधार पर ही उसका PID जान सके।
यदि दो प्रक्रियाएं हैं, तो कोई भी एक PID यूनिट का प्रतिनिधित्व नहीं करता है। उन्हें दो यूनिट्स में विभाजित करें और After= तथा Wants= के साथ उनका क्रम निर्धारित करें। प्रति प्रक्रिया एक यूनिट वह व्यवस्था है जिसे systemd अच्छी तरह से पर्यवेक्षित करता है, और यही एकमात्र तरीका है जिससे प्रत्येक प्रक्रिया को अपना स्वयं का रीस्टार्ट व्यवहार मिलता है।
ExitType=cgroup में क्या बदलाव आए
ExitType= को systemd 250 में जोड़ा गया था। डिफ़ॉल्ट मान main है: जब मुख्य प्रक्रिया (main process) समाप्त हो जाती है, तो यूनिट को बंद माना जाता है। ExitType=cgroup के साथ, यूनिट तब तक चलती हुई मानी जाती है जब तक कि उसके cgroup में कोई भी प्रक्रिया जीवित रहती है।
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherयह एक विशिष्ट समस्या का समाधान करता है। एक लॉन्चर जो वास्तविक कार्य शुरू करता है और फिर बाहर निकल जाता है, वह ExitType=main के तहत systemd को यह सोचने पर मजबूर करेगा कि यूनिट बंद हो गई है और वह बची हुई प्रक्रियाओं को समाप्त कर देगा। ExitType=cgroup के साथ यूनिट पूरे समूह का अनुसरण करती है।
यह स्पष्ट रहें कि यह क्या हल नहीं करता है। ExitType=cgroup यूनिट को तब तक सक्रिय रखता है जब तक कम से कम एक प्रक्रिया जीवित रहती है, इसलिए दो डेमन्स (daemons) वाली यूनिट उनमें से एक के मरने के बाद भी सक्रिय रहती है। यह लॉन्चर वाली समस्या को ठीक करता है। यह एक यूनिट को कई स्वतंत्र प्रक्रियाओं के पर्यवेक्षक (supervisor) में नहीं बदलता है। ExitType=cgroup को Type=oneshot के साथ भी संयोजित नहीं किया जा सकता है।
cgroup वह स्थान है जहाँ संसाधन लेखांकन (resource accounting) भी होता है, इसलिए MemoryMax= और CPUQuota= जैसी सीमाएं यूनिट द्वारा उत्पन्न प्रत्येक प्रक्रिया पर लागू होती हैं, चाहे Type= मुख्य PID के बारे में कुछ भी कहे। इसका वह पहलू systemd के साथ किसी सर्विस की मेमोरी और CPU को सीमित करना में दिया गया है।
यह कैसे पता करें कि systemd वास्तव में किस process की निगरानी कर रहा है
इसे उस unit पर क्रमवार तरीके से करें जिसे आप debug कर रहे हैं। पहले unit files को पढ़ें, फिर देखें कि systemd क्या track कर रहा है, और अंत में इसकी तुलना process table से करें।
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat unit file को डिस्क से उस पर लागू होने वाले हर drop-in के साथ print करता है; यदि files को daemon-reload के बिना बदला गया है, तो ये उस जानकारी से भिन्न हो सकते हैं जिसे systemd ने load किया है। systemctl show प्रभावी values को print करता है, जिसमें वे defaults भी शामिल हैं जिन्हें आपने कभी नहीं लिखा था। आगे बढ़ने से पहले MainPID की value को नोट कर लें।
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls unit के cgroup में मौजूद हर process को list करता है। ps line उस एकमात्र process का वर्णन करती है जिसकी निगरानी systemd करता है। इन दोनों को एक साथ पढ़ें। MainPID का 0 होने का मतलब है कि systemd किसी मुख्य process को track नहीं कर रहा है, भले ही systemd-cgls अभी भी unit के cgroup में processes को list कर रहा हो। यदि MainPID एक shell को दर्शाता है जबकि cgroup में आपका daemon भी मौजूद है, तो यह ऊपर बताया गया wrapper का मामला है। यदि cgroup में आपकी अपेक्षा से अधिक processes हैं, तो इसका मतलब है कि कोई launcher या forking daemon शामिल है।
systemctl status app.service
journalctl -u app.service -bsystemctl status state line और cgroup tree को एक साथ print करता है, इसलिए यह अक्सर दोनों सवालों का जवाब एक साथ दे देता है। journalctl -u को -b के साथ केवल इस boot तक सीमित करने पर वे start और stop events दिखते हैं जिन्हें systemd ने unit के लिए record किया है, साथ ही वे exit codes भी जो उसने देखे। यदि daemon journal के बजाय अपनी log file में लिखता है, तो उस file को भी पढ़ें, क्योंकि systemd केवल उसी को record कर सकता है जो उस तक पहुँचा है।
जब आप Type= बदलते हैं, तो reload और restart करें।
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify file को parse करता है और उन settings की रिपोर्ट करता है जिन्हें वह स्वीकार नहीं कर सकता। daemon-reload systemd को डिस्क से unit files को फिर से पढ़ने के लिए मजबूर करता है। बदला हुआ Type= पहले से चल रही unit पर लागू नहीं होता है, इसलिए restart अनिवार्य है, वैकल्पिक नहीं।
फिर बदलाव का परीक्षण करें। systemd-cgls से उस process का PID लें जिसकी आपको वास्तव में परवाह है और उसे kill कर दें। तुरंत बाद systemctl is-active app.service चलाएँ। ExitType=main और RemainAfterExit=no के साथ, मुख्य process को kill करने से वह चल रहा instance समाप्त हो जाता है, हालाँकि restart policy आपके जाँचने से पहले उसे वापस ला सकती है। यदि यह restart हुए बिना active रहता है, तो जाँचें कि क्या systemd किसी और चीज़ की निगरानी कर रहा है या unit ExitType=cgroup या RemainAfterExit=yes का उपयोग करती है।
आपको systemd service के लिए किस Type= का उपयोग करना चाहिए
- ऐसा प्रोग्राम जो foreground में रहता है:
Type=exec। - ऐसा प्रोग्राम जो readiness notification का समर्थन करता है:
Type=notify, और यदि यह reloads की भी पुष्टि करता है तोnotify-reload। - ऐसा daemon जो background में जाने पर जोर देता है:
PIDFile=के साथType=forking, याType=execके साथ उसका foreground switch। - ऐसी script जो काम करती है और exit हो जाती है:
Type=oneshot, साथ हीRemainAfterExit=yesजब उद्देश्य state को पीछे छोड़ना हो। - ऐसा launcher जो exit हो जाता है जबकि उसके children चलते रहते हैं:
ExitType=cgroupके साथType=simple।
यदि आप सुनिश्चित नहीं हैं कि किसी third party daemon को किसकी आवश्यकता है, तो पहले उसकी packaged unit file पढ़ें। distribution द्वारा प्रदान की गई unit पर systemctl cat चलाने से packaged Type= विकल्प और local overrides दिखाई देते हैं।
FAQ
मेरी systemd unit तब भी active क्यों रहती है जब process मर चुकी होती है?
डिफ़ॉल्ट ExitType=main और RemainAfterExit=no के साथ, ऐसा इसलिए होता है क्योंकि systemd जिसे मुख्य process मानता है, वह अभी भी जीवित है। इन डिफ़ॉल्ट सेटिंग्स के तहत, systemd प्रति service एक मुख्य PID का पालन करता है, जिसे Type= के अनुसार चुना जाता है। Type=simple के साथ शुरू की गई wrapper script इसका सामान्य कारण है: shell ही मुख्य PID होती है, इसलिए जब shell द्वारा background में शुरू किया गया daemon exit होता है, तब भी unit active बनी रहती है। systemctl show -p MainPID app.service चलाएँ, फिर systemd-cgls --unit=app.service के साथ unit की cgroup सूची देखें, और दोनों की तुलना करें।
Type=simple और Type=exec में क्या अंतर है?
Type=simple unit को तब शुरू हुआ मानता है जैसे ही systemd ने process बना ली हो, binary के execute होने से पहले ही। इसलिए ExecStart= में गलत path होने पर भी start job सफल दिखाई देता है और उसके बाद failure आता है। Type=exec तब तक प्रतीक्षा करता है जब तक execution सफल न हो जाए, ताकि failure की सूचना start job द्वारा ही मिल जाए। दोनों ही एक ही process को मुख्य PID मानते हैं। Type=exec को upstream में systemd 240 में पेश किया गया था, लेकिन distributions इसे पुराने versions में backport कर सकते हैं, जैसा कि RHEL 8 ने systemd-239-15.el8 में किया था।
क्या मुझे Type=forking के साथ अभी भी PIDFile= की आवश्यकता है?
हाँ, जब भी daemon इसे लिखता है। इसके बिना, systemd GuessMainPID= पर वापस चला जाता है, जो केवल एक अनुमान है और केवल उस service के लिए विश्वसनीय है जो एक ही process में स्थिर हो जाती है। जब अनुमान गलत या असंभव होता है, तो उस unit के लिए failure detection और automatic restarting विश्वसनीय रूप से काम नहीं करते हैं। PIDFile= को उस सटीक path पर point करें जिसे daemon लिखता है, जो सामान्यतः /run के अंतर्गत होता है।
मुझे RemainAfterExit=yes का उपयोग कब करना चाहिए?
जब unit का उद्देश्य process को चालू रखना नहीं, बल्कि system state को बदलना हो। एक Type=oneshot unit जो firewall rules load करती है या container stack शुरू करती है, अपना काम पूरा होते ही exit हो जाती है। RemainAfterExit=yes के बिना unit सीधे starting से stopping पर चली जाती है, इसलिए कोई भी ExecStop= cleanup काम पूरा होने के तुरंत बाद चल जाता है, न कि तब जब आप unit को stop करना चुनते हैं, और systemctl stop के पास stop करने के लिए कुछ नहीं बचता। इसके साथ, unit बिना किसी process के active बनी रहती है, और यहाँ यही अपेक्षित है।
क्या Type= बदलने के लिए daemon-reload की आवश्यकता होती है?
हाँ, और unit को restart करने की भी। systemctl daemon-reload systemd को disk पर मौजूद unit files को फिर से पढ़ने के लिए मजबूर करता है, लेकिन एक चल रही instance उसी Type= को बनाए रखती है जिसके साथ वह शुरू हुई थी। परीक्षण करने से पहले sudo systemctl daemon-reload और फिर sudo systemctl restart app.service चलाएँ, अन्यथा आप अभी भी पुराने supervision व्यवहार को ही देख रहे होंगे।