systemd Type=simple, forking, notify: योग्य पर्याय
unit active दिसत असूनही daemon बंद आहे? simple, exec, forking, oneshot आणि notify मधून योग्य Type= निवडा आणि खरा main PID शोधण्याची पद्धत समजा.
systemd प्रक्रिया बंद पडल्यावर unit active का दाखवते
मुलभूत ExitType=main आणि RemainAfterExit=no सह, systemd सेवा unit चे एकमेव मुख्य प्रक्रिया म्हणून systemd ज्या प्रक्रियेला ओळखते ती जिवंत असेपर्यंत unit active राहते. कोणती प्रक्रिया मुख्य प्रक्रिया आहे हे Type= मधील [Service] विभाग ठरवतो. चुकीचे मूल्य निवडल्यास systemd shell wrapper किंवा अल्पकाळ चालणाऱ्या parent प्रक्रियेवर लक्ष ठेवते, आणि तुम्हाला आवश्यक असलेला daemon त्याच unit मध्ये बंद पडतो. ज्यावर लक्ष ठेवण्यास systemd ला सांगितले आहे, त्या प्रक्रियेबाबत unit अचूक स्थिती सांगत असते.
Restart policy बदलल्याने या समस्येचे निराकरण होणार नाही. Restart= timeout किंवा process exit सारख्या failure वर प्रतिक्रिया देते. मात्र main PID (process identifier) अजूनही चालू असलेल्या दुसऱ्या प्रक्रियेकडे असल्यास, background daemon बंद पडल्याचे ते ओळखत नाही. आधी Type= दुरुस्त करा. मुख्य प्रक्रिया प्रत्यक्षात बंद पडल्यानंतर systemd काय करते हा स्वतंत्र निर्णय आहे. त्याचे स्पष्टीकरण Restart= आणि RestartSec= वरील मार्गदर्शकात दिले आहे.
Type= नेमके काय ठरवते
प्रत्येक Type= मूल्य एकाच वेळी दोन प्रश्नांची उत्तरे देते. systemd या unit ला कधी सुरू झाले असे मानू शकते, आणि मुख्य process कोणता आहे.
पहिले उत्तर ordering नियंत्रित करते. After= मध्ये तुमच्या unit चे नाव देणारे unit, systemd तुमचा unit सुरू झाल्याचे मान्य करेपर्यंत प्रतीक्षा करते. "started" असा अहवाल खूप लवकर देणारे Type= dependent units ना तुमची सेवा विनंत्यांना प्रतिसाद देण्यापूर्वीच सुरू होऊ देते.
दुसरे उत्तर supervision नियंत्रित करते. unit ने सुरू केलेला प्रत्येक process systemd एका cgroup (control group) मध्ये ठेवते. ही processes गटबद्ध करणारी kernel सुविधा आहे; त्यामुळे त्यांच्यावर एकत्र मर्यादा घालता येतात आणि त्यांना एकत्र बंद करता येते. systemctl stop cleanup करण्यासाठी cgroup वापरते: KillMode= चे default control-group आहे, त्यामुळे unit थांबवताना त्यातील प्रत्येक process ला signal पाठवला जातो. Main PID अधिक मर्यादित असतो. Default ExitType=main आणि RemainAfterExit=no सह, unit संपवणारा एकमेव process तोच असतो आणि त्याचा exit status unit च्या result मध्ये योगदान देतो. cgroup ला main PID समजून वाचल्यापासून हा गोंधळ सुरू होतो.
Type=simple हे binary चालण्यापूर्वीच सेवा सुरू झाल्याचे दर्शवते
Type=simple हे default असते, जेव्हा ExecStart= सेट केलेले असते, Type= किंवा BusName= यापैकी कोणतेही उपस्थित नसते आणि unit कोणतीही credentials वापरत नाही. उदाहरणार्थ, LoadCredential= द्वारे credentials लोड करणाऱ्या unit साठी त्याऐवजी Type=exec आपोआप गृहीत धरले जाते. simple अंतर्गत systemd process तयार करते, unit सुरू झाल्याचे तत्काळ मानते आणि त्या process ला मुख्य PID म्हणून हाताळते. सेवा binary प्रत्यक्ष execute होण्यापूर्वीच त्यानंतरच्या units सुरू होतात.
या शेवटच्या तपशीलामुळे एक सामान्य अनपेक्षित परिणाम स्पष्ट होतो. ExecStart= path मध्ये typo असला तरी start job यशस्वी झाल्याचे दिसते. Execution अयशस्वी झाल्यावर काही क्षणांनी failure दिसतो. systemd ही स्थिती exit code 203 सह नोंदवते. त्याच्या स्वतःच्या तक्त्यात याला EXIT_EXEC असे नाव दिले आहे आणि प्रत्यक्ष process execution अयशस्वी झाल्याचे त्यात स्पष्ट केले आहे. त्यामुळे systemctl start त्रुटीशिवाय परत आले, याचा अर्थ तुमचे binary अस्तित्वात आहे असे सिद्ध होत नाही.
Foreground मध्ये चालणाऱ्या आणि स्वतःला background मध्ये हलवत नसलेल्या program साठी simple वापरा. बहुतेक आधुनिक daemons आणि तुम्ही स्वतः लिहिलेल्या जवळजवळ सर्व programs साठी हे योग्य आहे.
Type=exec वापरल्यास प्रोग्राम प्रत्यक्ष सुरू होईपर्यंत प्रतीक्षा केली जाते
Type=exec हे simple सारखेच आहे, परंतु त्यात आणखी एक पायरी असते. fork आणि binary चे execution हे दोन्ही यशस्वी झाल्यानंतरच systemd unit सुरू झाल्याचे मानते. binary उपलब्ध नसल्यास किंवा निराकरण करता न येणारा User= असल्यास आता start job स्वतःच अपयशी ठरते. त्यामुळे यशस्वी झाल्याचे दाखवून काही क्षणांनी शांतपणे अपयशी होण्याची स्थिती टळते.
Type=exec systemd 240 मध्ये upstream समाविष्ट झाले. मात्र distribution backports मुळे जुन्या आवृत्त्यांमध्येही त्याला समर्थन मिळते: RHEL 8 ने ते systemd-239-15.el8 मध्ये समाविष्ट केले. समर्थित जुन्या releases मध्येही ते नसू शकते: Ubuntu 18.04 साठी ESM April 2028 पर्यंत सुरू आहे आणि त्याच्या systemd 237 manual मध्ये exec समर्थित type म्हणून नमूद केलेले नाही. October 2026 नुसार Ubuntu 24.04 मध्ये systemd 255 आणि Debian 13 मध्ये systemd 257 समाविष्ट आहे. तुमची आवृत्ती systemctl --version आणि distribution च्या systemd.service manual द्वारे तपासा.
यासाठी start वेळी एक अतिरिक्त synchronization step लागतो. त्याचा फायदा म्हणजे systemctl start कडून मिळणारा exit status अचूक असतो. foreground program साठी simple ऐवजी exec प्राधान्याने वापरा.
Type=forking आणि main PID कसा हरवतो
Type=forking मुळे systemd ला कळते की ExecStart= मधील प्रक्रिया एक child प्रक्रिया तयार करून जाणीवपूर्वक बाहेर पडेल. systemd त्या पहिल्या प्रक्रियेच्या बाहेर पडण्याची प्रतीक्षा करते आणि त्यानंतरच unit सुरू झाल्याचे मानते. मागे राहिलेली child प्रक्रिया daemon असते. ही पद्धत SysV युगापासून चालत आली आहे. त्या काळात init script परतल्यानंतर daemon वर देखरेख ठेवणारी कोणतीही यंत्रणा नव्हती. त्यामुळे काय चालू आहे याची एकमेव नोंद PID file असायची. ही मर्यादा systemd ने init scripts ची जागा का घेतली याच्या केंद्रस्थानी आहे.
अडचण प्रक्रियेची ओळख पटवण्यात आहे. systemd ने सुरू केलेली प्रक्रिया संपलेली असल्यामुळे, उरलेल्या प्रक्रियांपैकी मुख्य प्रक्रिया कोणती हे systemd ला ठरवावे लागते. PIDFile= मध्ये daemon लिहित असलेली file द्या. ही file सहसा /run अंतर्गत असलेल्या path वर असते. त्यानंतर systemd त्या file मधून PID वाचते. ही file unprivileged user च्या मालकीची असल्यास, त्यातील PID या service शी आधीपासून संबंधित असलेल्या प्रक्रियेकडे निर्देश करतो का हेही systemd तपासते. त्यामुळे stale किंवा मुद्दाम तयार केलेली file एखाद्या असंबंधित प्रक्रियेचे नाव देत असल्यास, तिच्यावर विश्वास ठेवला जात नाही.
PIDFile= नसल्यास GuessMainPID= लागू होते आणि त्याची default value yes असते. Service एकाच प्रक्रियेत स्थिरावत असल्यासच हा अंदाज विश्वासार्ह असतो. Manual मध्ये ही मर्यादा स्पष्टपणे सांगितली आहे: daemon मध्ये एकापेक्षा जास्त प्रक्रिया असल्यास हा अंदाज चुकीचा निष्कर्ष देऊ शकतो. तसेच मुख्य PID ठरवता न आल्यास failure detection आणि automatic restarting विश्वासार्हपणे कार्य करणार नाही. एखाद्या unit चा main PID 0 देखील होऊ शकतो. याचा अर्थ systemd कोणत्याही मुख्य प्रक्रियेवर देखरेख ठेवत नाही, जरी daemon च्या प्रक्रिया त्या unit च्या cgroup मध्ये अद्याप चालू असल्या तरी.
fork करणाऱ्या बहुतेक daemons मध्ये त्या प्रक्रिया foreground मध्ये ठेवणारा switch असतो. तो switch Type=exec सोबत वापरा आणि PIDFile= ही line काढून टाका. घटकांची संख्या कमी असेल तर PID हरवण्याचे मार्गही कमी होतात.
पूर्ण होणाऱ्या कामासाठी Type=oneshot
Type=oneshot मध्ये प्रक्रिया चालू होऊन समाप्त होणे अपेक्षित असते. प्रक्रिया समाप्त झाल्यानंतरच systemd unit सुरू झाल्याचे मानतो. त्यामुळे दुसऱ्या unit ने ज्याची प्रतीक्षा करणे आवश्यक आहे, अशा कोणत्याही कामासाठी oneshot योग्य प्रकार आहे. एखाद्या unit मध्ये Type= किंवा ExecStart= यांपैकी काहीही निर्दिष्ट केलेले नसल्यास, हाच गृहीत धरलेला default असतो.
oneshot साठी दोन वर्तन वैशिष्ट्यपूर्ण आहेत. एकापेक्षा अधिक ExecStart= ओळी स्वीकारणारा हा एकमेव प्रकार आहे आणि त्या ओळी क्रमाने चालतात. याचा start timeout देखील default ने disabled असतो. त्यामुळे अडकलेला oneshot तुम्ही स्वतः TimeoutStartSec= सेट करेपर्यंत अमर्याद काळ प्रतीक्षा करतो.
प्रक्रिया समाप्त झाल्यानंतर unit पुन्हा inactive स्थितीत जाते. RemainAfterExit=yes कोणतीही प्रक्रिया चालू नसतानाही त्याला active स्थितीत ठेवते. या पृष्ठाच्या सुरुवातीला वर्णन केलेल्या लक्षणाची ही जाणीवपूर्वक केलेली आवृत्ती आहे. unit चे काम एखादी स्थिती निर्माण करून ठेवणे, सतत काहीतरी चालू ठेवणे नव्हे, असेल तेव्हा हे योग्य असते. उदाहरणार्थ, firewall ruleset लोड करणे किंवा container stack सुरू करणे. रीबूटनंतर पुन्हा सुरू होणाऱ्या Docker Compose stack मागील हीच पद्धत आहे. त्यात unit compose command चालवते, समाप्त होते आणि सुरू केलेले containers त्यापेक्षा अधिक काळ चालू राहत असल्यामुळे unit active स्थितीत राहते. वेळापत्रकानुसार सुरू होणाऱ्या कामासाठीही oneshot unit योग्य आहे. हा cron ऐवजी systemd timer वर job चालवण्याचा दुसरा भाग आहे.
Type=notify मुळे सेवा तयार झाल्याची माहिती देऊ शकते
Type=notify मुळे हा निर्णय सेवेवर सोपवला जातो. सेवा NOTIFY_SOCKET environment variable मध्ये मिळालेल्या Unix socket च्या path वरून READY=1 पाठवत नाही, तोपर्यंत systemd start job उघडे ठेवते. C interface sd_notify(3) आहे आणि अनेक servers त्याला आधीपासून support करतात.
"is it started" या प्रश्नाचे अचूक उत्तर हेच आहे. simple आणि exec सेवा configuration वाचण्यापूर्वी किंवा listening socket उघडण्यापूर्वीच started असल्याचे report करतात. त्यामुळे dependent unit खूप लवकर सुरू होऊ शकते आणि तिचे पहिले connection fail होऊ शकते. notify सेवा स्वतः तयार असल्याचे सांगते त्याच क्षणी started असल्याचे report करते.
systemd हा message फक्त main process कडून स्वीकारते. याचा अर्थ NotifyAccess=main असा आहे आणि Type=notify त्याचा संकेत देते. हा message child किंवा helper कडून येत असल्यास NotifyAccess=all सेट करा. Shell script systemd-notify --ready call करू शकते. आवश्यक privileges असल्यास systemd-notify त्याच्या parent च्या PID अंतर्गत message पाठवते. त्यामुळे script स्वतः main process असल्यास NotifyAccess=main पुरेसे आहे; अन्यथा ते स्वतःच्या PID वर fallback करते आणि unit ला NotifyAccess=all आवश्यक असते. By default, message process केल्यानंतर systemd कडून confirmation मिळेपर्यंत ते थांबते. हा wait बंद करणारे --no-block त्यामुळे वगळा. Protocol स्वतः implement करणारी सेवा अधिक reliable असते.
यासंबंधीच्या दोन settings माहिती असणे उपयुक्त आहे. systemd 253 पासून उपलब्ध असलेले Type=notify-reload हेच handshake reloads पर्यंत विस्तारित करते. त्यामुळे systemctl reload signal पाठवल्यावर लगेच return न होता सेवा reload पूर्ण झाल्याचे report करेपर्यंत return करत नाही. September 2026 मध्ये released झालेल्या systemd 262 पासून, notify-reload सेवा तिचे reload signal catch किंवा block न करता READY=1 पाठवत असल्यास (ReloadSignal= वेगळे सांगत नसल्यास SIGHUP), ती protocol error सह start होण्यात fail होते. पहिल्या reload वेळी त्या signal मुळे process killed होण्याऐवजी हे घडते. WatchdogSec= notifying service ला ठरावीक interval वर keep-alive message पाठवण्यास सांगते. हा deadline चुकल्यास systemd त्याला failure मानते.
Type=dbus आणि Type=idle
Type=dbus सेवा D-Bus वर नाव नोंदवते तोपर्यंत प्रतीक्षा करते. D-Bus हा system आणि desktop सेवा परस्परांशी संवाद साधण्यासाठी वापरत असलेला message bus आहे. यासाठी BusName= आवश्यक आहे. BusName= सेट केल्यावर ते default होते. प्रत्यक्षात bus name नोंदवणाऱ्या सेवेसाठीच याचा वापर करा.
Type=idle हे simple प्रमाणे कार्य करते. मात्र queued jobs dispatch होईपर्यंत program चालवण्यास विलंब करते. हा विलंब जास्तीत जास्त five seconds असतो. Boot वेळी console output आणि status messages एकमेकांत मिसळू नयेत म्हणून हे उपलब्ध आहे. हे ordering tool नाही. त्यामुळे सामान्य service मध्ये याचा वापर करू नका.
रॅपर स्क्रिप्टमुळे 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 shell ला मुख्य PID म्हणून नोंदवते. exporter foreground मध्ये चालू असताना shell जिवंत राहते. server बंद पडल्यास shell ला त्याची जाणीव होत नाही. त्यामुळे मुख्य PID जिवंतच राहतो, unit active स्थितीतच राहते आणि Restart= कडे कारवाई करण्यासाठी काहीच राहत नाही. दोन्ही प्रक्रिया संपूर्ण वेळ unit च्या cgroup मध्ये असतात. त्यामुळे systemctl stop अजूनही cleanup योग्य प्रकारे करते. बिघडलेले supervision आहे; cleanup नाही.
दुरुस्ती unit मध्ये प्रत्यक्षात किती दीर्घकाळ चालणाऱ्या प्रक्रिया आहेत यावर अवलंबून असते.
एकच प्रक्रिया असल्यास shell ऐवजी ती प्रक्रिया चालवा.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec shell च्या जागी नमूद केलेला प्रोग्राम चालवते आणि तोच PID ठेवते. त्यामुळे systemd ने नोंदवलेला PID आता daemon चा असतो. त्याहून चांगला उपाय म्हणजे wrapper काढून टाकणे. Environment= आणि EnvironmentFile= variables पुरवतात, तर ExecStartPre= setup step पुरवते. त्यामुळे systemd daemon थेट सुरू करू शकते आणि त्याचा PID सुरुवातीपासूनच अचूकपणे ओळखू शकते.
दोन प्रक्रिया असल्यास एकच PID संपूर्ण unit चे प्रतिनिधित्व करू शकत नाही. त्या दोन स्वतंत्र units मध्ये विभाजित करा आणि After= व Wants= वापरून त्यांचा क्रम ठरवा. प्रत्येक प्रक्रियेसाठी एक unit ही systemd उत्तम प्रकारे supervise करू शकणारी रचना आहे. प्रत्येक प्रक्रियेला स्वतंत्र restart behaviour मिळवून देण्याचा हाच एकमेव मार्ग आहे.
ExitType=cgroup मुळे काय बदलते
ExitType= हे systemd 250 मध्ये जोडले गेले. डीफॉल्ट मूल्य main आहे: मुख्य process बंद झाल्यावर unit थांबलेली मानली जाते. ExitType=cgroup वापरल्यास, त्याच्या cgroup मधील कोणताही process जिवंत असेपर्यंत unit चालू मानली जाते.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherयामुळे एक विशिष्ट समस्या सुटते. प्रत्यक्ष काम सुरू करून नंतर बंद होणारा launcher ExitType=main अंतर्गत चालवल्यास, systemd unit थांबलेली मानते आणि उरलेले processes बंद करते. ExitType=cgroup वापरल्यास unit त्याऐवजी संपूर्ण process group च्या स्थितीनुसार चालते.
यामुळे कोणती समस्या सुटत नाही, हे स्पष्टपणे समजून घ्या. ExitType=cgroup मुळे किमान एक process जिवंत असेपर्यंत unit active राहते. त्यामुळे दोन daemons धारण करणारी unit त्यांपैकी एक daemon बंद झाल्यानंतरही active राहते. यामुळे launcher ची समस्या सुटते. मात्र, एका unit चे अनेक स्वतंत्र processes साठी supervisor मध्ये रूपांतर होत नाही. ExitType=cgroup हे Type=oneshot सोबत एकत्र वापरता येत नाही.
cgroup मध्ये resource accounting देखील होते. त्यामुळे MemoryMax= आणि CPUQuota= सारख्या मर्यादा unit ने सुरू केलेल्या प्रत्येक process वर लागू होतात; मुख्य PID बद्दल Type= काय सांगते याने फरक पडत नाही. या विषयाचा दुसरा भाग systemd वापरून सेवेची memory आणि CPU मर्यादित करणे येथे आहे.
systemd प्रत्यक्षात कोणत्या process वर लक्ष ठेवत आहे हे कसे शोधावे
तुम्ही ज्या unit चे debugging करत आहात त्यावर हे काम दिलेल्या क्रमाने करा. प्रथम unit files वाचा. त्यानंतर systemd कोणत्या process चा मागोवा घेत आहे ते तपासा. शेवटी process table शी तुलना करा.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat disk वरील unit file आणि त्याला लागू होणारे सर्व drop-in एकत्र दाखवते. Files मध्ये daemon-reload शिवाय बदल झाले असल्यास, ही माहिती systemd ने load केलेल्या माहितीपेक्षा वेगळी असू शकते. systemctl show प्रभावी values दाखवते. यात तुम्ही स्पष्टपणे नोंदवलेली नसलेली 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 दाखवते. ps line systemd supervise करत असलेल्या एकमेव process चे वर्णन करते. या दोन्ही माहितीचा एकत्रित विचार करा. MainPID ची value 0 असल्यास systemd कोणत्याही main process चा मागोवा घेत नाही. तरीही systemd-cgls unit च्या cgroup मधील processes दाखवू शकते. cgroup मध्ये तुमचा daemon असताना MainPID shell कडे निर्देश करत असल्यास, वर वर्णन केलेली wrapper परिस्थिती आहे. अपेक्षेपेक्षा जास्त processes असलेला cgroup असल्यास launcher किंवा forking daemon वापरात आहे.
systemctl status app.service
journalctl -u app.service -bsystemctl status state line आणि cgroup tree एकत्र दाखवते. त्यामुळे अनेकदा दोन्ही प्रश्नांची उत्तरे एकाच वेळी मिळतात. journalctl -u ला -b सह केवळ या boot पुरते मर्यादित केल्यास, systemd ने unit साठी नोंदवलेल्या start आणि stop events दिसतात. त्यात systemd ने पाहिलेले exit codes देखील असतात. daemon journal ऐवजी स्वतःच्या log file मध्ये लिहित असल्यास, ती file देखील वाचा. systemd पर्यंत पोहोचलेली माहितीच systemd नोंदवू शकते.
तुम्ही 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 disk वरील unit files पुन्हा वाचते. बदललेली Type= आधीपासून चालू असलेल्या unit वर लागू होत नाही. त्यामुळे restart आवश्यक आहे; तो ऐच्छिक नाही.
त्यानंतर बदलाची चाचणी घ्या. systemd-cgls मधून तुम्हाला प्रत्यक्षात महत्त्वाच्या असलेल्या process चा PID घ्या आणि तो kill करा. लगेच systemctl is-active app.service चालवा. ExitType=main आणि RemainAfterExit=no वापरल्यास main 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. - background मध्ये जाण्याचा आग्रह धरणाऱ्या daemon साठी:
PIDFile=सहType=forking, किंवा त्याचा foreground switchType=execसह. - काम करून बंद होणाऱ्या script साठी:
Type=oneshot; आणि उद्देश state मागे ठेवण्याचा असल्यासRemainAfterExit=yes. - child processes सुरू ठेवून स्वतः बंद होणाऱ्या launcher साठी:
ExitType=cgroupसहType=simple.
तृतीय-पक्ष daemon साठी कोणता पर्याय आवश्यक आहे याबद्दल खात्री नसल्यास, प्रथम त्यासोबत पॅकेज केलेली unit file वाचा. distribution ने पुरवलेल्या unit वर systemctl cat चालवल्यास packaged Type= निवड आणि स्थानिक overrides दिसतात.
FAQ
माझे systemd unit process बंद पडल्यानंतरही active का राहते?
Default ExitType=main आणि RemainAfterExit=no सह असे होते, कारण systemd मुख्य process मानत असलेला process अजून चालू असतो. या default मध्ये systemd प्रत्येक सेवेसाठी एकच मुख्य PID वापरते. हा PID Type= नुसार निवडला जातो. Type=simple ने सुरू केलेली wrapper script हे याचे नेहमीचे कारण आहे. त्यामुळे shell हा मुख्य PID ठरतो. shell ने background मध्ये सुरू केलेला daemon बंद पडला तरी unit active राहते. systemctl show -p MainPID app.service चालवा. त्यानंतर systemd-cgls --unit=app.service ने unit चे cgroup सूचीबद्ध करा आणि दोन्हींची तुलना करा.
Type=simple आणि Type=exec मध्ये काय फरक आहे?
Type=simple नुसार systemd ने process तयार करताच unit सुरू झाल्याचे मानले जाते. त्या वेळी binary चालवलेले नसते. त्यामुळे 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 PID file लिहित असल्यास ते आवश्यक आहे. ते नसल्यास systemd GuessMainPID= वर अवलंबून राहते. हा अंदाज असतो आणि एकाच process मध्ये स्थिरावणाऱ्या सेवेसाठीच विश्वासार्ह असतो. अंदाज चुकीचा ठरल्यास किंवा लागू होत नसल्यास त्या unit साठी failure detection आणि automatic restarting विश्वासार्हपणे कार्य करत नाही. PIDFile= मध्ये daemon लिहित असलेला अचूक path द्या. हा path सामान्यतः /run अंतर्गत असतो.
RemainAfterExit=yes कधी वापरावे?
जेव्हा unit चा उद्देश process चालू ठेवणे नसून system state मध्ये बदल करणे असतो, तेव्हा ते वापरावे. Firewall rules लोड करणारे किंवा container stack सुरू करणारे Type=oneshot unit काम पूर्ण होताच बंद होते. RemainAfterExit=yes नसल्यास unit थेट starting अवस्थेतून stopping अवस्थेत जाते. त्यामुळे कोणतेही ExecStop= cleanup काम पूर्ण होताच चालते, unit थांबवण्याची तुमची वेळ येईपर्यंत नाही. तसेच systemctl stop कडे थांबवण्यासाठी काहीही उरत नाही. RemainAfterExit=yes सह 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 behaviour चे निरीक्षण करत असाल.