systemd ने तुमची service restart का केली नाही?
Restart= फक्त main process पाहते; त्याच cgroup मधील मृत child process दिसत नाही. Type=, restart limits आणि journal प्रत्यक्षात कसे काम करतात ते जाणून घ्या.
थोडक्यात: systemd restart धोरणे एका unit मधील एका process वर लक्ष ठेवतात
systemd restart धोरणे प्रत्येक unit मधील एका process वर लक्ष ठेवतात: main process वर. Restart= त्या process चा exit status आणि त्याच्या आसपास systemd स्वतः चालवणाऱ्या लहान commands चा exit status वाचते, जसे ExecStartPre=, ExecStartPost= आणि ExecReload=. ते इतर कोणतीही माहिती वाचत नाही. एखाद्या unit च्या control group मध्ये वीस processes असू शकतात. त्यांपैकी एक process बंद पडला तरी main process सुरू असल्यास unit active (running) राहते. systemd च्या दृष्टीने काहीही अयशस्वी झालेले नसते, त्यामुळे काहीही restart केले जात नाही.
systemd ला इतर processes विषयी माहिती असते. unit थांबवल्यावर ते त्यांना बंद करते, त्यांची memory unit च्या मर्यादेत मोजते, त्यांच्यावर unit ची CPU quota लागू करते आणि त्यांना systemctl status मध्ये दाखवते. मात्र ते त्यांचा exit status कधीही वाचत नाही. Restart logic आणि cgroup या दोन वेगळ्या गोष्टी आहेत. या दोन्हींमधील अंतर या मार्गदर्शकाचा बहुतांश भाग स्पष्ट करतो.
cgroup मध्ये काय असते आणि restart logic काय वाचते
cgroup (control group) हा प्रक्रियांचा संच नियंत्रित करणारा kernel object आहे. प्रत्येक service unit ला unit च्या नावावर आधारित एक cgroup मिळतो. एखादी प्रक्रिया त्यातून बाहेर पडू शकत नाही. Child processes ना त्यांच्या parent चा cgroup वारशाने मिळतो आणि unprivileged process स्वतःला दुसरीकडे हलवू शकत नाही. म्हणून systemd दोनदा fork करणाऱ्या daemon ची साफसफाई करू शकते. जुन्या init scripts ना हे विश्वसनीयपणे करता येत नव्हते.
ही दोन्ही तथ्ये शेजारीशेजारी पाहा:
systemd-cgls --unit myapp.service
systemctl show -p MainPID -p NRestarts -p Restart -p RestartUSec myapp.servicesystemd-cgls unit मधील प्रत्येक process ची यादी दाखवते. MainPID हा restart policy वाचणारा एकमेव आकडा आहे. या दोन्ही गोष्टी तुमच्या मानसिक मॉडेलशी जुळत नसतील, तर ती विसंगतीच bug आहे. MainPID=0 याचा अर्थ systemd कडे exit status वाचण्यासाठी main process नाही. ते cgroup चा मागोवा घेत राहते. त्यामुळे त्यातील शेवटची process निघून गेल्याचे ते ओळखते. परंतु तोपर्यंत restart logic कडे तपासण्यासाठी exit status नसतो.
main-process नियमाला एक वास्तविक अपवाद आहे. kernel out-of-memory killer ने unit च्या cgroup मधील कोणतीही process kill केली, तर systemd ते ओळखते, कारण ते cgroup मधील memory.events file वर लक्ष ठेवते. पुढे काय होईल हे OOMPolicy= ठरवते. त्याचे default stop आहे: संपूर्ण unit थांबवली जाते, निकाल oom-kill म्हणून नोंदवला जातो आणि ही failure मानली जाते. त्यामुळे Restart=on-failure सक्रिय होते. journal मध्ये हे स्पष्टपणे दिसते.
myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Failed with result 'oom-kill'.म्हणून memory मुळे kill झालेली child process unit बंद पाडते. मात्र तीच child process segmentation fault मुळे बंद झाली, तर तसे होत नाही. एखाद्या unit वर memory limits सेट करत असल्यास restart policy समायोजित करण्यापूर्वी MemoryMax आणि CPUQuota unit च्या cgroup वर कसे लागू होतात हे पाहा. कारण ही दोन्ही वैशिष्ट्ये येथे एकत्र येतात; इतरत्र नाही.
Type= मुख्य प्रक्रिया कशी निवडते
Type= मधील [Service] हा भाग केवळ सुरू होण्याच्या क्रमाविषयी नाही. कोणता PID (process ID) MainPID बनेल हे ठरवणारा नियम तो आहे. यावरून Restart= ला काय दिसू शकते हेही ठरते.
Type=simpleहे default आहे. systemd नेExecStart=मधून fork केलेली process ही main process असते.execप्रत्यक्षात यशस्वी झाले आहे की नाही हे समजण्यापूर्वीच systemd unit सुरू झाल्याचे चिन्हांकित करते. Binary path मध्ये typo असल्यास start job यशस्वी होते आणि त्यानंतर क्षणभरातMain process exited, code=exited, status=203/EXECहोते.Type=execहेsimpleप्रमाणेच कार्य करते. मात्रexecयशस्वी होईपर्यंत start job थांबते. त्यामुळे वरील typo मुळे स्पष्ट start failure मिळते. यासाठी systemd 240 किंवा त्यानंतरची आवृत्ती आवश्यक आहे. Ubuntu 20.04 आणि त्यानंतरच्या आवृत्त्यांमध्ये तसेच Debian 12 मध्ये ते उपलब्ध आहे. मात्र Ubuntu Pro द्वारे अजूनही समर्थित Ubuntu 18.04 मध्ये systemd 237 आहे आणि ते उपलब्ध नाही. जेथे ते उपलब्ध असेल तेथेsimpleऐवजी त्याला प्राधान्य द्या.Type=forkingमध्येExecStart=मधील process ने background daemon fork करून स्वतः exit करणे अपेक्षित असते. Parent exit होईपर्यंत systemd थांबते आणि त्यानंतर प्रत्यक्ष daemon शोधते. त्यालाPIDFile=द्या. ते नसल्यास, default ने सुरू असलेलेGuessMainPID=फक्त cgroup मध्ये नेमकी एक process उरल्यावरच कार्य करते. दोन process मागे ठेवल्यासMainPIDहे0राहते.Type=notifyम्हणजे सेवाsd_notify(3)call करते आणि traffic स्वीकारण्यास तयार झाल्यावरREADY=1पाठवते. systemd ने track करण्यासाठी वेगळी process देण्यासाठी तीMAINPID=देखील पाठवू शकते.Type=notifyसह, तुम्ही वेगळे निवडले नसल्यासNotifyAccess=हेmainवर सेट केले जाते. त्यामुळे child ने पाठवलेली notification दुर्लक्षित केली जाते आणि journal मध्ये notification पाठवणाऱ्या process चा PID दाखवला जातो.Type=oneshotमध्ये कायमस्वरूपी main process नसते.ExecStart=पूर्ण होताच unit inactive होते, जोपर्यंत तुम्हीRemainAfterExit=yesसेट करत नाही. येथेRestart=alwaysआणिRestart=on-successनाकारले जातात आणिService has Restart= set to either always or on-success, which isn't allowed for Type=oneshot services. Refusing.हा संदेश दिला जातो.on-failureसहित इतर values स्वीकारल्या जातात.
दोन Type=forking errors लक्षात ठेवण्यासारखे आहेत. प्रत्येकामुळे कोणतेही स्पष्ट कारण दिसत नसताना unit बिघडल्यासारखी स्थिती निर्माण होऊ शकते:
myapp.service: Can't open PID file /run/myapp.pid (yet?) after start: No such file or directory
myapp.service: New main PID 4711 does not belong to service, and PID file is not owned by root. Refusing.पहिल्याचा अर्थ daemon आपली PID file दुसरीकडे लिहितो किंवा systemd तपासते त्यापेक्षा उशिरा ती लिहितो. दुसऱ्याचा अर्थ PID file मध्ये unit च्या cgroup बाहेरील process चे नाव दिलेले आहे. systemd अशी process स्वीकारत नाही, कारण लिहिता येणारी PID file अन्यथा systemd कडून सर्व्हरवरील कोणत्याही process ला signals पाठवण्याचे साधन बनू शकते.
रॅपर स्क्रिप्टमुळे तिच्या child process चा termination का लपतो
शीर्षकातील प्रश्न निर्माण करणारी रचना पुढीलप्रमाणे आहे.
#!/bin/bash
/usr/local/bin/myapp-web &
/usr/local/bin/myapp-worker &
waitUnit म्हणजे Type=simple, त्यामुळे मुख्य process shell असतो. wait कोणतेही arguments नसताना प्रत्येक child process बंद झाल्यानंतरच परत येतो. Worker process बंद केल्यावर shell web process साठी प्रतीक्षा करत राहतो. त्यामुळे shell बंद होत नाही, MainPID बंद होत नाही आणि Restart= तपासलेच जात नाही. आता cgroup मध्ये एक process कमी असतो, systemctl status लहान झालेली process tree दाखवतो आणि unit अजूनही active (running) असतो. या tree मधील बदलांवर systemd लक्ष ठेवत नाही.
हीच चूक दुसऱ्या प्रकारे अधिक शांतपणे दिसते:
ExecStart=/bin/sh -c 'export APP_ENV=production; /usr/local/bin/myapp'मुख्य process myapp नसून shell असतो. systemctl stop वेळी systemd मुख्य process ला SIGTERM पाठवतो. Foreground child साठी प्रतीक्षा करणारा shell हा signal पुढे पाठवत नाही. त्यामुळे stop प्रक्रिया पूर्ण TimeoutStopSec घेते, जी default ने 90 seconds असते, आणि शेवटी असे दिसते:
myapp.service: State 'stop-sigterm' timed out. Killing.
myapp.service: Killing process 4711 (myapp) with signal SIGKILL.यावर उपाय म्हणजे exec. exec /usr/local/bin/myapp लिहिल्यावर shell ऐवजी program चालतो. त्यामुळे MainPID हा program असतो आणि signals त्याच्यापर्यंत पोहोचतात. याहून चांगले म्हणजे shell काढून unit मध्ये Environment= किंवा EnvironmentFile= वापरा. -c string मध्ये एकच command असल्यास ही समस्या दिसत नाही, हे लक्षात ठेवा. bash आणि dash दोन्ही त्या परिस्थितीला थेट exec मध्ये optimize करतात. String मध्ये दुसरा command जोडल्यावर shell तुमच्या program च्या पुढे जिवंत राहतो.
दोन मिनिटांत test VPS वर ही समस्या पुन्हा निर्माण करा
वरील wrapper /usr/local/bin/two-children.sh म्हणून save करा, chmod +x वापरून तो executable करा आणि दोन program paths sleep 3600 ने बदला. Type=simple आणि Restart=on-failure वापरून unit ला त्याकडे निर्देशित करा. त्यानंतर systemctl daemon-reload चालवून unit सुरू करा. systemd-cgls --unit two-children.service चालवा आणि तीन PIDs नोंदवा: shell आणि त्याचे दोन child processes. sudo kill <pid> वापरून एक child process बंद करा. Unit पुन्हा तपासा. Tree मध्ये एक process कमी असेल, state अजूनही active (running) असेल आणि journal मध्ये नवीन काहीही नसेल. आता त्याऐवजी sudo kill -9 <shell pid> चालवा. Unit fail होईल, KillMode=control-group default असल्यामुळे जिवंत राहिलेला child process साफ केला जाईल आणि journal मध्ये Scheduled restart job, restart counter is at 1. दिसेल.
Restart= मधील संपूर्ण मूल्यसंच आणि on-failure कधी always पेक्षा योग्य ठरते
`Restart= सातपैकी एक मूल्य स्वीकारते. या मूल्यांमधील मुख्य फरक म्हणजे कोणता exit clean मानायचा. systemd exit code 0, SuccessExitStatus= मध्ये नमूद केलेला कोणताही code आणि Type=oneshot` वगळता प्रत्येक प्रकारासाठी SIGHUP, SIGINT, SIGTERM आणि SIGPIPE हे signals clean exit मानते. SIGKILL आणि SIGSEGV यांसह इतर सर्व बाबी unclean मानल्या जातात.
- `
noहे default आहे. Unit स्वतःहून पुन्हा सुरू होत नाही. त्यामुळेRestart=` line नसलेली unit पहिल्या crash वेळी बंद होते आणि बंदच राहते. - `
on-success` फक्त clean exit नंतर पुन्हा सुरू होते. - `
on-failure` non-zero exit code, unclean signal, start किंवा stop timeout किंवा watchdog expiry नंतर पुन्हा सुरू होते. - `
on-abnormal` unclean signal, timeout किंवा watchdog expiry नंतर पुन्हा सुरू होते; परंतु साध्या non-zero exit code नंतर कधीही पुन्हा सुरू होत नाही. - `
on-abort` फक्त unclean signal नंतर पुन्हा सुरू होते. म्हणजेच crash नंतर. - `
on-watchdogफक्तWatchdogSec=` संपल्यानंतर पुन्हा सुरू होते. - `
always` वरील प्रत्येक परिस्थितीनंतर पुन्हा सुरू होते. यात status 0 सह clean exit देखील समाविष्ट आहे.
दीर्घकाळ चालणाऱ्या daemon साठी `on-failure हा योग्य default आहे. तो crash नंतर सेवा पुन्हा सुरू करतो आणि जाणीवपूर्वक केलेल्या exit 0 ला दुर्लक्षित करतो. नियंत्रणाबाहेरील कारणांमुळे clean exit होणाऱ्या प्रोग्रामसाठी always योग्य आहे. उदाहरणार्थ, दूरच्या टोकाचा connection तुटल्यावर 0 परत करणारा tunnel client. always चा तोटा असा की ते bugs लपवते. एखादी service सुरू होऊन खराब config file वाचते, error log करते आणि 0 सह बंद होते, तर ती पुन्हा सुरू केली जाते. Default 100 millisecond अंतर असल्यास ती लवकरच खाली वर्णन केलेल्या start rate limit ला पोहोचते आणि start-limit-hit सह failed होते. या limit च्या खाली राहण्यासाठी पुरेसा मोठा RestartSec=` दिल्यास ती अनिश्चित काळ loop मध्ये राहते. त्याचे एकमेव चिन्ह म्हणजे restart counter वाढत राहणे.
`SuccessExitStatus= clean आणि unclean यांमधील सीमा बदलते. Borg warnings साठी 1 आणि errors साठी 2 सह बंद होते. त्यामुळे SuccessExitStatus=1 नसलेली backup unit unreadable file वगळली की प्रत्येक वेळी failed म्हणून चिन्हांकित होते. RestartPreventExitStatus= अशा codes ची यादी देते जे always अंतर्गत देखील restart रोखतात. एखाद्या प्रोग्रामने पुन्हा सुरू होऊ नये असे सांगण्याचा हा योग्य मार्ग आहे. RestartForceExitStatus= याच्या उलट कार्य करते. Backup job साठी restart loop ऐवजी timer द्वारे चालवलेली Type=oneshot` unit वापरा. ठराविक वेळापत्रकानुसार job चालवणारी service आणि timer pair यासाठी अनुकरण करण्यास योग्य रचना आहे.
Testing बाबत एक सूचना. साध्या `kill <pid> ने service बंद केल्यास SIGTERM पाठवले जाते. ते clean list मध्ये असल्यामुळे Restart=on-failure योग्यरीत्या काहीही करत नाही आणि तुमची config खराब आहे असा निष्कर्ष निघतो. त्याऐवजी kill -9 <pid> किंवा systemctl kill -s SIGKILL myapp.service वापरा. तसेच लक्षात ठेवा की Restart= मधील कोणतेही मूल्य systemctl stop नंतर कार्य करत नाही. BindsTo= किंवा PartOf=` dependency नाहीशी झाल्यामुळे unit थांबवली गेली तरी ते कार्य करत नाही. Stop job म्हणजे failure नाही.
RestartSec आणि 100 मिलिसेकंदचा default
RestartSec= म्हणजे unit थांबल्यानंतर systemd ने ती पुन्हा सुरू करण्यापूर्वीचा विलंब. याचा default 100 मिलिसेकंद आहे. तुमच्या unit ने प्रत्यक्षात कोणती value load केली आहे ते तपासा:
systemctl show -p RestartUSec -p StartLimitIntervalUSec -p StartLimitBurst myapp.serviceज्या unit मध्ये ही value सेट केलेली नाही, तिथे RestartUSec=100ms असे दिसते. मात्र /etc/systemd/system.conf मध्ये कोणीतरी DefaultRestartSec= बदलले असल्यास अपवाद आहे; unset value तिथून येते. एकदा crash होऊन पुन्हा सुरू होणाऱ्या सेवेसाठी हा default योग्य आहे. मात्र एखादी सेवा अजिबात सुरू होऊ शकत नसेल, तर तो चुकीचा आहे. लगेच fail होणाऱ्या program साठी पहिला start आणि चार restart एका सेकंदापेक्षा खूप कमी वेळात पूर्ण होतात. त्यामुळे पुढे वर्णन केलेल्या rate limit मध्ये परवानगी असलेले पाच starts वापरले जातात. Database, mount किंवा network route उपलब्ध होण्याची प्रतीक्षा करणाऱ्या कोणत्याही सेवेसाठी RestartSec=5s किंवा त्याहून अधिक value सेट करा.
October 2026 पासून systemd 254 आणि त्यानंतरच्या आवृत्त्यांमध्ये RestartSteps= आणि RestartMaxDelaySec= देखील उपलब्ध आहेत. हे अनेक attempts दरम्यान RestartSec= पासून सुरुवात करून delay वाढवतात आणि तो एका कमाल मर्यादेपर्यंत नेतात. Ubuntu 24.04 मध्ये systemd 255 येते आणि त्यात ही features उपलब्ध आहेत. Debian 12 मध्ये systemd 252 येते आणि ही features उपलब्ध नाहीत. मात्र bookworm-backports मध्ये systemd 254 उपलब्ध आहे. Dependency बराच काळ down असण्याची शक्यता असल्यास वाढणारे delays हा योग्य उपाय आहे.
“start request repeated too quickly” याचा खरा अर्थ
systemd मनमानीपणे प्रयत्न थांबवते, असे वाचकांना वाटण्याची ही स्थिती आहे. हा एक counter आहे. नियम असा आहे: एखादी unit StartLimitBurst= च्या आत StartLimitIntervalSec= पेक्षा जास्त वेळा सुरू केली गेली, तर systemd तिला पुन्हा सुरू करण्यास नकार देते आणि तिला failed state मध्ये ठेवते. Default 10 सेकंदांत 5 starts असा आहे.
journal मध्ये हा क्रम दिसतो:
myapp.service: Scheduled restart job, restart counter is at 5.
myapp.service: Start request repeated too quickly.
myapp.service: Failed with result 'start-limit-hit'.
Failed to start myapp.service - My application.आणि systemctl start मध्ये उपाय आधीच लिहिलेला आहे:
Job for myapp.service failed because start of the service was attempted too often. See "systemctl status myapp.service" and "journalctl -xeu myapp.service" for details. To force a start use "systemctl reset-failed myapp.service" followed by "systemctl start myapp.service" again.systemctl reset-failed myapp.service counter आणि failed state साफ करते. हे न केल्यास, साधा systemctl start StartLimitIntervalSec= चा कालावधी पूर्ण होईपर्यंत नाकारला जात राहतो. एखादी गोष्ट unit पुन्हा सुरू करेपर्यंत automatic restarts देखील बंद राहतात. Manual starts देखील या मर्यादेत मोजले जातात. त्यामुळे configuration file संपादित करताना केलेले काही अधीर systemctl restart runs कोणताही crash न होता ही मर्यादा लागू करू शकतात.
लोकांची दिशाभूल करणारा मुद्दा असा आहे: start-limit-hit सेवा का fail झाली हे कधीही सांगत नाही. ते फक्त सेवा वारंवार आणि कमी वेळात fail झाली, एवढेच सांगते. खरे कारण त्यावरील journal lines मध्ये असते.
दोन्ही settings [Unit] section मध्ये असतात. काही उदाहरणांमध्ये त्या [Service] मध्ये ठेवलेल्या आढळतात. जुन्या systemd आवृत्त्यांनी ते स्वीकारले होते आणि इथूनच गोंधळ सुरू होतो. त्या [Unit] मध्ये लिहा. त्यानंतर systemd ने काय load केले ते systemctl show ने तपासा, कारण load झालेली valueच ग्राह्य धरली जाते.
[Unit]
Description=My application
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Type=exec
ExecStart=/usr/local/bin/myapp
Restart=on-failure
RestartSec=10sयामुळे systemd ने हार मानण्यापूर्वी unit ला 5 minute window मध्ये 5 attempts मिळतात. StartLimitIntervalSec=0 ही मर्यादा पूर्णपणे बंद करते. मात्र तुम्ही काय निवडत आहात हे समजून घ्या: जी सेवा कधीही सुरू होऊ शकत नाही ती आता अनंतकाळ retry करेल आणि प्रत्येक वेळी journal मध्ये नोंद लिहील. संपूर्ण मशीनसाठीचे default /etc/systemd/system.conf मध्ये DefaultStartLimitIntervalSec= आणि DefaultStartLimitBurst= म्हणून असतात.
शेजारील एका setting बाबत सावध रहा. मर्यादा गाठल्यावर काय करायचे हे StartLimitAction= ठरवते. ती reboot, reboot-force आणि poweroff यांसह विविध values स्वीकारते. Default none आहे. यामुळे unit fail होते आणि मशीनची स्थिती तशीच ठेवली जाते. Remote VPS वर poweroff म्हणजे provider चे console उघडेपर्यंत बंद राहणारी मशीन.
प्रत्येक युनिटसाठी एक process
बहुतेक सर्व प्रकरणांत हेच योग्य उत्तर असते. दोन programs चालवायचे असतील, तर दोन units लिहा. त्यामुळे प्रत्येक unit कडे स्वतंत्र मुख्य process, स्वतंत्र exit status आणि स्वतःचे restart policy असते. तसेच स्वतंत्र logs, स्वतंत्र resource limits आणि स्वतंत्र restart counters मिळतात. पहाटे तीन वाजता तुम्हाला हेच हवे असते.
Units मधील संबंध shell script मध्ये नव्हे, तर unit files मध्ये व्यक्त करा.
After=केवळ start-up चा क्रम ठरवते. failures बाबत ते काहीही सांगत नाही.Requires=या unit सोबत दुसरी unit सुरू करते आणि दुसरी unit स्पष्टपणे थांबवली गेल्यास ही unit थांबवते.BindsTo=मध्येRequires=चे कार्य तसेच तुम्हाला आवश्यक असलेले अतिरिक्त कार्य असते: दुसरी unit कोणत्याही कारणामुळे, crash मुळेही, थांबली तर ही unit थांबते. यासोबतAfter=वापरा; अन्यथा क्रम निश्चित नसतो.PartOf=stop आणि restart खालच्या दिशेने प्रसारित करते. त्यामुळेsystemctl restart myapp.targetला पोहोचल्यावरPartOf=असलेल्या प्रत्येक unit पर्यंत ते पोहोचते.Upholds=(systemd 249 आणि त्यानंतरच्या आवृत्त्यांमध्ये, म्हणजे Ubuntu 22.04 आणि त्यानंतर) नामनिर्दिष्ट unit चालू ठेवते: ती थांबली तर systemd तिला पुन्हा सुरू करते. इतर सर्व units प्रमाणेच ती start rate limit च्या अधीन असते.
ज्या worker ने त्याच्या API server शिवाय कधीही चालू नये आणि API सुरू असेपर्यंत systemd ने तो चालू ठेवावा:
# /etc/systemd/system/myapp-api.service
[Unit]
Description=myapp API server
Wants=network-online.target
After=network-online.target
Upholds=myapp-worker.service
[Service]
Type=exec
User=myapp
ExecStart=/usr/local/bin/myapp serve
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=multi-user.target# /etc/systemd/system/myapp-worker.service
[Unit]
Description=myapp background worker
BindsTo=myapp-api.service
After=myapp-api.service
StartLimitIntervalSec=120
StartLimitBurst=5
[Service]
Type=exec
User=myapp
ExecStart=/usr/local/bin/myapp worker
Restart=on-failure
RestartSec=5sworker मध्ये [Install] section नाही आणि तो स्वतःहून कधीही enable केला जात नाही. API unit Upholds= वापरून त्याला समाविष्ट करते. त्यामुळे तुम्ही फक्त systemctl enable --now myapp-api.service command चालवता. Reload करा आणि systemd ने या दोन्ही units ची रचना कशी केली ते तपासा:
sudo systemctl daemon-reload
systemd-analyze verify /etc/systemd/system/myapp-worker.service
systemctl list-dependencies myapp-api.servicefile योग्य असल्यास systemd-analyze verify काहीही output देत नाही. कोणतेही output दिसल्यास समस्या आहे. सामान्यतः तुम्ही लिहिलेल्या section मध्ये systemd ला न ओळखता येणारी key असते किंवा अस्तित्वात नसलेल्या unit वर dependency असते.
दुरुस्ती दोन: Type=notify, त्यामुळे systemd ला PID पेक्षा अधिक माहिती मिळते
प्रोग्राम systemd notification protocol वापरत असेल, तर तो वापरा. Type=notify सह सेवा तयार झाल्यावर systemd ला कळवते. त्यामुळे ordering अंदाजावर अवलंबून न राहता प्रत्यक्ष स्थितीवर आधारित होते. तसेच सेवा MAINPID= पाठवून launcher ऐवजी महत्त्वाच्या process कडे systemd चे लक्ष वेधू शकते.
WatchdogSec= हा प्रयत्न करण्यासारखा भाग आहे. तो सेट केल्यावर सेवेला किमान तेवढ्या वारंवारतेने WATCHDOG=1, sd_notify(3) द्वारे पाठवावे लागते. संदेश येणे थांबल्यावर systemd सेवा SIGABRT सह terminate करते आणि तिला failed म्हणून नोंदवते. त्यामुळे Restart=on-failure किंवा Restart=on-watchdog तिला पुन्हा सुरू करते. जिवंत पण अडकलेल्या process ला पुन्हा सुरू करण्याचा हा एकमेव built-in मार्ग आहे. कोणतीही exit-status policy अशी स्थिती पकडू शकत नाही.
[Service]
Type=notify
NotifyAccess=main
ExecStart=/usr/local/bin/myapp serve
WatchdogSec=30s
Restart=on-failure
RestartSec=5sWatchdog सक्रिय झाल्याची नोंद journal मध्ये myapp.service: Watchdog timeout (limit 30s)! आणि त्यानंतरच्या kill म्हणून दिसते. त्याऐवजी unit activating (start) स्थितीत राहिली आणि TimeoutStartSec संपले, तर READY=1 कधीच आले नाही किंवा त्याची मोजणी झाली नाही. प्रोग्राम protocol वापरत नसण्याची शक्यता आहे. किंवा NotifyAccess=main child process कडून आलेली notification नाकारत असू शकते. अशा वेळी journal मध्ये दोन्ही PIDs नोंदवले जातात. आणखी एक शक्यता अशी की helper process ने संदेश पाठवला आणि systemd त्याचा unit कोणता हे ठरवण्यापूर्वी तो बंद झाला. NotifyAccess=all असतानाही तो शेवटचा संदेश दुर्लक्षित केला जातो. दुरुस्ती प्रोग्राममध्ये करावी लागते: helper बंद होण्यापूर्वी त्याने sd_notify_barrier() कॉल करावे.
HTTP health endpoint उपलब्ध असलेल्या पण sd_notify support नसलेल्या software साठी दोन व्यवहार्य पर्याय आहेत. Endpoint तपासणारे आणि systemctl restart कॉल करणारे छोटे timer unit वापरा. किंवा probing container runtime कडे सोपवा. Compose healthchecks आणि त्यांचे restart behaviour याच कारणासाठी उपलब्ध आहेत.
युनिटच्या आत supervisor चालवणे: पर्याय नसतानाच वापरा
काही software प्रत्यक्षात अशा process bundle स्वरूपात releases होते की ते विभाजित करता येत नाही. अशा वेळी युनिटच्या आत supervisor चालवा आणि त्याचे परिणाम स्वीकारा: systemd supervisor वर लक्ष ठेवते, supervisor इतर सर्व गोष्टींवर लक्ष ठेवतो आणि restart policy आता दोन files मध्ये असते.
याचे सामान्य उदाहरण container runtime आहे. docker compose किंवा podman unit ही याच पद्धतीची उदाहरणे आहेत. त्यात प्रत्येक container ची restart policy Compose file मध्ये असते आणि systemd unit फक्त runtime चालू ठेवते. तुमची रचना अशी असल्यास, boot वेळी Compose stack सुरू करणारे unit याची कार्यरत आवृत्ती दाखवते. त्यात Type=oneshot सोबत RemainAfterExit=yes का सामान्यतः योग्य असते हेही स्पष्ट केले आहे.
cgroup अजूनही तुमच्या उपयोगी ठरते. supervisor ने सुरू केलेली प्रत्येक गोष्ट युनिटच्या cgroup मध्येच राहते. त्यामुळे MemoryMax=, CPUQuota= आणि stop वेळी होणारी cleanup प्रक्रिया संपूर्ण process tree वर लागू राहते. फक्त restart करण्याचा निर्णय supervisor कडे सोपवला जातो.
तुम्ही कोणताही supervisor निवडला तरी विचार न करता बाहेरील unit वर Restart=always आणि त्याच्या आत आक्रमक restart policy सेट करू नका. स्वतंत्र backoff असलेल्या restart logic चे दोन स्तर असल्यास service अनेक मिनिटे वारंवार बंद-चालू होते आणि असे का घडते हे journal मधून स्पष्ट होत नाही.
ExitType=cgroup म्हणजे “कोणतीही process बंद झाल्यावर restart करा” असा अर्थ नाही
ExitType= (systemd 250 आणि त्यानंतरच्या आवृत्त्यांमध्ये; त्यामुळे Ubuntu 24.04 आणि Debian 12 या दोन्हींमध्ये ते उपलब्ध आहे) हे setting या समस्येसाठी शोध घेताना आढळते. मात्र, त्याचा परिणाम नावावरून वाटतो त्याच्या उलट असतो. Default ExitType=main मध्ये main process बंद झाल्यावर service थांबलेली मानली जाते. ExitType=cgroup मध्ये cgroup मधील शेवटची process बंद होईपर्यंत service चालू मानली जाते.
त्यामुळे ExitType=cgroup मुळे एखादी process बंद झाल्यावर unit कमी संवेदनशील होते, अधिक नाही. एखादा program त्याचा वास्तविक worker fork करून parent process बंद करतो आणि PID file लिहित नाही, अशा वेळी हे योग्य setting आहे. अशा परिस्थितीत Type=forking ला daemon सापडत नाही. येथे वर्णन केलेल्या failure साठी हे setting चुकीचे आहे.
“cgroup मधील कोणतीही process बंद झाल्यावर unit restart करा” असा अर्थ देणारे कोणतेही Restart= value नाही. असे behaviour हवे असल्यास प्रत्येक unit मध्ये एकच process ठेवावी लागते. Program विभाजित करता येत नसेल आणि wrapper script वर तुमचे नियंत्रण असेल, तर त्याच्या सर्वात जवळचे setting wait -n आहे. पहिली child process बंद होताच ते परत येते:
#!/bin/bash
/usr/local/bin/myapp-web &
/usr/local/bin/myapp-worker &
wait -n
exit 1आता कोणतीही child process बंद झाल्यास wrapper non-zero status सह बंद होईल, त्यामुळे Restart=on-failure लागू होईल. हा तडजोडीचा उपाय आहे; पूर्ण निराकरण नाही. दोन programs साठी तुम्हाला एकच restart counter, एकच log stream आणि बिघडलेल्या भागाला स्वतंत्रपणे restart करण्याची कोणतीही पद्धत मिळत नाही.
प्रत्यक्षात काय घडले ते कसे तपासावे
या क्रमाने चार commands चालवा.
systemctl status myapp.service
systemd-cgls --unit myapp.service
systemctl show -p MainPID -p NRestarts -p Result -p ExecMainStatus myapp.service
journalctl -u myapp.service -b -o short-precisesystemctl status एकाच screen वर स्थिती, मुख्य PID आणि cgroup tree दाखवते. निरोगी unit मध्ये Active: active (running) दिसते आणि Main PID: line मध्ये अपेक्षित process चे नाव असते. खालील tree मध्ये तुम्हाला अपरिचित processes दिसत असतील किंवा अपेक्षित process नसेल, तर कारण समोरच आहे.
systemd-cgls --unit हाच tree truncation न करता दाखवते. एखाद्या unit कडे मोजक्या processes पेक्षा अधिक processes असतील, तेव्हा हे महत्त्वाचे ठरते.
systemctl show machine-readable माहिती देते. NRestarts= हा restart counter आहे. रीबूटपासून सुरू असलेल्या service आणि चाळीस वेळा restart झालेल्या service यांच्यात फरक ओळखण्याचा हा सर्वात जलद मार्ग आहे. Result= मध्ये शेवटचे failure reason असते: exit-code, signal, timeout, oom-kill, watchdog किंवा start-limit-hit. ExecMainStatus= हा शेवटच्या मुख्य process चा raw exit status आहे.
Journal मध्ये घटनाक्रम असतो. शोधण्यासाठी या तीन lines वापरा:
myapp.service: Main process exited, code=exited, status=1/FAILURE
myapp.service: Failed with result 'exit-code'.
myapp.service: Scheduled restart job, restart counter is at 1.code=exited, status=N म्हणजे program ने N return करण्याचा निर्णय घेतला. त्यामुळे fault program मध्ये किंवा त्याच्या configuration मध्ये आहे. code=killed, signal=SEGV म्हणजे ते crash झाले. code=killed, signal=TERM सहसा दुसऱ्या घटकाने त्याला थांबवण्याची विनंती केली असे दर्शवते. हे failure नसते आणि Restart=on-failure trigger करणार नाही. code=dumped म्हणजे त्याने core file तयार केली. systemd-coredump installed असल्यास coredumpctl list ती दाखवेल.
एकापेक्षा अधिक machines वर NRestarts हा नियमितपणे collect करण्यासारखा number आहे. ज्या unit चा counter दररोज वाढतो, ती unit दररोज fail होत असते, कोणाच्या लक्षात आले असेल किंवा नसेल तरी. दोन किंवा तीन boxes पेक्षा अधिक झाल्यावर प्रत्येक server वर एक command चालवण्याची सुसंगत पद्धत अंदाजाला report मध्ये बदलते.
FAQ
systemctl प्रक्रिया बंद झाल्यावरही सेवा active असल्याचे का सांगते?
systemd प्रत्येक service unit साठी एक प्रक्रिया track करते. तिला main process म्हणतात आणि Restart= केवळ त्या प्रक्रियेचा exit status वाचते. Unit ने सुरू केलेल्या इतर सर्व प्रक्रिया त्याच cgroup मध्ये असतात. Unit थांबल्यावर systemd त्या प्रक्रिया बंद करते. मात्र त्यांच्या exit स्थितीवर ते लक्ष ठेवत नाही. systemctl show -p MainPID myapp.service चालवा आणि त्याची संख्या systemd-cgls --unit myapp.service सोबत तुलना करा. बंद झालेली प्रक्रिया tree मध्ये दिसत असेल, पण ती MainPID नसेल, तर systemd ने अपेक्षेप्रमाणेच काम केले आहे. प्रत्येक unit मध्ये एकच प्रक्रिया ठेवा. Units मधील संबंध BindsTo= आणि Upholds= म्हणून स्पष्टपणे लिहा.
"start request repeated too quickly" याचा अर्थ काय?
याचा अर्थ unit StartLimitIntervalSec= कालावधीत StartLimitBurst= पेक्षा जास्त वेळा सुरू करण्यात आली. हा कालावधी default ने 10 seconds असतो आणि त्यात 5 starts अनुमत असतात. त्यामुळे systemd ने पुन्हा प्रयत्न करणे थांबवले. ही rate limit आहे. सेवा का fail होत होती हे ती सांगत नाही. त्यामुळे तिच्या आधीच्या journal lines वाचा. systemctl reset-failed myapp.service ने state clear करा आणि नंतर मूळ failure दुरुस्त करा. सेवा सुरू होण्यासाठी एखाद्या धीम्या dependency ची वाट पाहत असेल, तर RestartSec= वाढवा. कारण default 100 milliseconds gap मुळे पाचही attempts एका second पेक्षा कमी वेळात संपतात.
Restart=always किंवा Restart=on-failure यापैकी कोणता वापरावा?
बहुतेक सर्व प्रसंगी on-failure वापरा. Crash, non-zero exit, timeout आणि watchdog trip झाल्यावर ते सेवा पुन्हा सुरू करते. मात्र जाणीवपूर्वक केलेला exit 0 ते failure मानत नाही. Program त्याच्या नियंत्रणाबाहेरील कारणामुळे cleanly exit होत असेल, तेव्हाच always वापरा. उदाहरणार्थ, peer disconnect झाल्यावर एखादा client 0 return करत असेल. always ची अडचण अशी आहे की broken config वाचून, एक error log करून आणि 0 सह exit होणारी सेवा पुन्हा पुन्हा सुरू केली जाते. Default gap सह ती लवकरच start-limit-hit मुळे fail होते. RestartSec= मोठा असल्यास ती indefinitely loop करू शकते. अशा वेळी systemctl show मधील NRestarts हेच एकमेव दिसणारे लक्षण असू शकते आणि त्याची संख्या वाढत जाते.
प्रक्रिया manually kill केल्यावर restart का होत नाही?
Type=oneshot वगळता प्रत्येक type साठी systemd SIGHUP, SIGINT, SIGTERM आणि SIGPIPE यांना clean exits मानते. साधा kill <pid> SIGTERM पाठवतो. Restart=on-failure अंतर्गत clean exit हे failure मानले जात नाही. त्यामुळे काहीही restart होत नाही आणि configuration चुकीची असल्यासारखी दिसते, जरी ती चुकीची नसते. kill -9 <pid> किंवा systemctl kill -s SIGKILL myapp.service वापरून चाचणी करा. त्यातून unclean termination होते आणि restart policy लागू होते. याच नियमामुळे systemctl stop तुमच्या restart policy मध्ये हस्तक्षेप करत नाही.
StartLimitIntervalSec आणि StartLimitBurst कुठे ठेवायचे?
ते [Unit] section मध्ये ठेवा. जुन्या सामग्रीमध्ये आणि जुन्या systemd versions मध्ये ते [Service] मध्ये ठेवलेले आढळतात. त्यामुळे copy केलेली examples एकमेकांशी विसंगत असतात. तुमची version कोणते settings स्वीकारते याचा अंदाज लावू नका. systemctl daemon-reload नंतर systemctl show -p StartLimitBurst -p StartLimitIntervalUSec myapp.service वापरून systemd ने कोणते settings load केले ते तपासा. तीच values अंतिम सत्य माना. systemd-analyze verify /etc/systemd/system/myapp.service systemd ला अजिबात ओळखता न येणाऱ्या keys शोधते. File योग्य असल्यास ती काहीही print करत नाही.