SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-30

systemd service restart क्यों नहीं हो रही है?

Restart= केवल मुख्य process की निगरानी करता है, इसलिए cgroup में किसी child process की मृत्यु का पता नहीं चलता। Type= और restart limits के काम करने का सही तरीका जानें।

संक्षिप्त उत्तर: systemd restart policies केवल एक process की निगरानी करती हैं

systemd restart policies प्रति unit केवल एक process की निगरानी करती हैं: मुख्य process। Restart= उस एक process के exit status को पढ़ता है, साथ ही उन संक्षिप्त commands को भी जिन्हें systemd स्वयं उसके आसपास चलाता है, जैसे कि ExecStartPre=, ExecStartPost= और ExecReload=। यह इसके अलावा कुछ भी नहीं पढ़ता है। एक unit के control group में बीस processes हो सकती हैं, उनमें से एक मर सकती है, और unit active (running) बनी रहती है क्योंकि मुख्य process अभी भी मौजूद है। systemd के दृष्टिकोण से कुछ भी विफल नहीं हुआ है, इसलिए कुछ भी restart नहीं किया जाता है।

systemd अन्य processes के बारे में जानता है। जब unit रुकती है तो यह उन्हें मार देता है, यह unit की limits के विरुद्ध उनकी memory की गणना करता है, यह उन पर unit का CPU quota लागू करता है, और यह उन्हें systemctl status में print करता है। यह बस कभी भी उनके exit status को नहीं पढ़ता है। restart logic और cgroup दो अलग-अलग चीजें हैं, और इस गाइड का अधिकांश हिस्सा उनके बीच के अंतर के बारे में है।

cgroup में क्या होता है, और restart logic क्या पढ़ता है

cgroup (control group) एक kernel object है जो processes के एक समूह का स्वामी होता है। प्रत्येक service unit को एक cgroup मिलता है, जिसका नाम unit के नाम पर रखा जाता है। कोई process इसे छोड़ नहीं सकती। Children अपने parent की cgroup को inherit करते हैं, और एक unprivileged process खुद को कहीं और स्थानांतरित नहीं कर सकती। यही कारण है कि systemd उस daemon को clean up कर सकता है जो दो बार fork होता है, जिसे पुराने init scripts कभी भी भरोसेमंद तरीके से नहीं कर पाते थे।

दोनों तथ्यों को साथ रखकर देखें:

systemd-cgls --unit myapp.service
systemctl show -p MainPID -p NRestarts -p Restart -p RestartUSec myapp.service

systemd-cgls unit की प्रत्येक process को list करता है। MainPID वह एकमात्र संख्या है जिसे restart policy पढ़ती है। जब ये दोनों आपके mental model से मेल नहीं खाते, तो वही विसंगति bug है। MainPID=0 का अर्थ है कि systemd के पास exit status पढ़ने के लिए कोई main process नहीं है। यह अभी भी cgroup को track करता है, इसलिए यह notice करता है कि इसमें मौजूद आखिरी process कब खत्म हो गई है, लेकिन तब तक restart logic के पास निर्णय लेने के लिए कोई exit status नहीं होता।

main-process नियम का एक वास्तविक अपवाद है। यदि kernel का out-of-memory killer unit की cgroup के अंदर किसी भी process को मार देता है, तो systemd इसे देख लेता है, क्योंकि यह cgroup की memory.events file को monitor करता है। OOMPolicy= तय करता है कि आगे क्या होगा, और इसका default stop है: पूरी unit stop हो जाती है, परिणाम oom-kill के रूप में record होता है, और इसे एक failure माना जाता है, इसलिए Restart=on-failure trigger होता है। Journal इसे स्पष्ट रूप से बताता है।

myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Failed with result 'oom-kill'.

इसलिए memory के कारण मारी गई child unit को बंद कर देती है, जबकि segmentation fault से मरने वाली वही child ऐसा नहीं करती। यदि आप unit पर memory limits set करते हैं, तो restart policy को tune करने से पहले how MemoryMax and CPUQuota apply to a unit's cgroup पढ़ें, क्योंकि ये दोनों features यहीं मिलते हैं और कहीं नहीं।

Type= मुख्य प्रक्रिया का चयन कैसे करता है

Type= में [Service] सेक्शन केवल start-up क्रम के बारे में नहीं है। यह वह नियम है जो तय करता है कि कौन सा PID (process ID) MainPID बनेगा, जो यह तय करने के समान है कि Restart= क्या देख सकता है।

  • Type=simple डिफ़ॉल्ट है। systemd जिस प्रक्रिया को ExecStart= से fork करता है, वही मुख्य प्रक्रिया होती है। systemd यूनिट को तुरंत started के रूप में चिह्नित कर देता है, इससे पहले कि उसे पता चले कि exec सफल हुआ भी या नहीं। बाइनरी पाथ में टाइपो होने पर start job सफल हो जाता है, और फिर कुछ क्षण बाद Main process exited, code=exited, status=203/EXEC हो जाता है।
  • Type=exec, simple की तरह व्यवहार करता है, सिवाय इसके कि start job तब तक प्रतीक्षा करता है जब तक exec सफल न हो जाए। यह ऊपर बताए गए टाइपो को एक स्पष्ट start failure में बदल देता है। इसके लिए systemd 240 या उससे नया संस्करण चाहिए। Ubuntu 20.04 और उसके बाद के संस्करणों तथा Debian 12 में यह उपलब्ध है, लेकिन Ubuntu 18.04, जो अभी भी Ubuntu Pro के अंतर्गत कवर है, में systemd 237 है और यह सुविधा नहीं है। जहाँ भी यह उपलब्ध हो, simple के बजाय इसे प्राथमिकता दें।
  • Type=forking यह अपेक्षा करता है कि ExecStart= से निकली प्रक्रिया एक background daemon को fork करेगी और फिर exit हो जाएगी। systemd parent के exit होने की प्रतीक्षा करता है, फिर वास्तविक daemon को ढूँढता है। इसे PIDFile= दें। इसके बिना, GuessMainPID= (जो डिफ़ॉल्ट रूप से चालू है) केवल तभी काम करता है जब cgroup में ठीक एक प्रक्रिया बची हो। यदि दो प्रक्रियाएँ पीछे रह जाती हैं, तो MainPID, 0 ही रहता है।
  • Type=notify का अर्थ है कि सर्विस sd_notify(3) को कॉल करती है और ट्रैफिक सर्व करने के लिए तैयार होने पर READY=1 भेजती है। यह systemd को ट्रैक करने के लिए एक अलग प्रक्रिया देने हेतु MAINPID= भी भेज सकता है। Type=notify के साथ, NotifyAccess= को main पर सेट किया जाता है जब तक कि आप अन्यथा न चुनें, इसलिए child द्वारा भेजा गया नोटिफिकेशन अनदेखा कर दिया जाता है और journal उस PID का नाम लेता है जहाँ से वह आया था।
  • Type=oneshot की कोई स्थायी मुख्य प्रक्रिया नहीं होती। यूनिट ExecStart= के समाप्त होते ही 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 सहित अन्य मान स्वीकार किए जाते हैं।

दो Type=forking त्रुटियों को याद रखना उपयोगी है, क्योंकि प्रत्येक के कारण यूनिट बिना किसी स्पष्ट कारण के खराब दिखाई देती है:

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 फ़ाइल कहीं और लिखता है, या systemd के जाँचने के बाद लिखता है। दूसरी का अर्थ है कि PID फ़ाइल यूनिट के cgroup के बाहर की किसी प्रक्रिया का नाम लेती है, जिसे systemd अपनाने से मना कर देता है, क्योंकि एक writable PID फ़ाइल अन्यथा systemd को बॉक्स पर किसी भी प्रक्रिया को सिग्नल भेजने का माध्यम बना सकती है।

Wrapper script अपने child processes की मृत्यु को क्यों छिपाता है

यहाँ वह संरचना दी गई है जो शीर्षक में दिए गए प्रश्न को जन्म देती है।

#!/bin/bash
/usr/local/bin/myapp-web &
/usr/local/bin/myapp-worker &
wait

यह unit Type=simple है, इसलिए मुख्य process shell है। wait बिना किसी argument के केवल तभी return होता है जब प्रत्येक child process exit हो जाती है। worker को kill करें, तो shell web process के लिए प्रतीक्षा करता रहता है। इसलिए shell exit नहीं होता, इसलिए MainPID exit नहीं होता, और इसलिए Restart= को कभी नहीं देखा जाता है। cgroup में अब एक process कम है, systemctl status छोटा tree print करता है, और unit अभी भी active (running) है। systemd में कोई भी उस tree में बदलावों पर नजर नहीं रखता है।

इसी गलती का दूसरा संस्करण अधिक शांत है:

ExecStart=/bin/sh -c 'export APP_ENV=production; /usr/local/bin/myapp'

मुख्य process shell है, myapp नहीं। systemctl stop पर, systemd मुख्य process को SIGTERM भेजता है, और foreground child की प्रतीक्षा कर रहा shell उस signal को आगे नहीं बढ़ाता है। stop प्रक्रिया फिर पूरा TimeoutStopSec समय लेती है, जो डिफ़ॉल्ट रूप से 90 सेकंड है, और इस तरह समाप्त होती है:

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= का उपयोग करें। ध्यान दें कि यह bug तब छिप जाता है जब -c string में केवल एक command हो, क्योंकि bash और dash दोनों उस स्थिति को सीधे exec में optimize कर देते हैं। string में दूसरी command जोड़ें और shell आपके program के सामने जीवित रहेगा।

इसे दो मिनट में test VPS पर reproduce करें

ऊपर दिए गए wrapper को /usr/local/bin/two-children.sh के रूप में save करें, chmod +x के साथ इसे executable बनाएँ, और दोनों program paths को sleep 3600 से बदलें। Type=simple और Restart=on-failure के साथ एक unit को उस पर point करें, फिर systemctl daemon-reload करें और इसे start करें। systemd-cgls --unit two-children.service चलाएँ और तीन PIDs नोट करें: shell और उसके दो children। एक child को sudo kill <pid> के साथ kill करें। unit को फिर से जाँचें। tree में एक process कम है, state अभी भी active (running) है, और journal में कहने के लिए कुछ नया नहीं है। अब इसके बजाय sudo kill -9 <shell pid> चलाएँ। unit fail हो जाती है, जीवित बचा हुआ child clean up हो जाता है क्योंकि KillMode=control-group डिफ़ॉल्ट है, और journal Scheduled restart job, restart counter is at 1. दिखाता है।

Restart= के सभी विकल्प, और on-failure कब always से बेहतर है

Restart= सात मानों में से एक ले सकता है, और इनके बीच का अंतर इस बात पर निर्भर करता है कि किसे 'clean' माना जाता है। systemd exit code 0, SuccessExitStatus= में सूचीबद्ध कोई भी कोड, और Type=oneshot को छोड़कर बाकी सभी प्रकारों के लिए SIGHUP, SIGINT, SIGTERM और SIGPIPE सिग्नल्स को clean exit मानता है। इसके अलावा सब कुछ, जिसमें SIGKILL और SIGSEGV शामिल हैं, unclean माना जाता है।

  • no डिफ़ॉल्ट है। यूनिट कभी खुद को रीस्टार्ट नहीं करती, इसीलिए जिस यूनिट में Restart= लाइन नहीं होती, वह पहली बार क्रैश होने पर बंद हो जाती है और बंद ही रहती है।
  • on-success केवल clean exit के बाद ही रीस्टार्ट होता है।
  • on-failure गैर-शून्य (non-zero) exit code, unclean signal, start या stop timeout, या watchdog expiry पर रीस्टार्ट होता है।
  • on-abnormal unclean signal, timeout या watchdog expiry पर रीस्टार्ट होता है, लेकिन सामान्य गैर-शून्य exit code पर कभी नहीं।
  • on-abort केवल unclean signal पर रीस्टार्ट होता है, जिसका अर्थ है क्रैश।
  • on-watchdog केवल तब रीस्टार्ट होता है जब WatchdogSec= समाप्त (expire) हो जाता है।
  • always ऊपर बताए गए हर मामले के बाद रीस्टार्ट होता है, जिसमें 0 स्टेटस के साथ clean exit भी शामिल है।

on-failure लंबे समय तक चलने वाले डेमन (daemon) के लिए सही डिफ़ॉल्ट है। यह क्रैश होने पर सर्विस को वापस लाता है और जानबूझकर किए गए exit 0 को नहीं छेड़ता। always ऐसे प्रोग्राम के लिए है जो अपने नियंत्रण से बाहर के कारणों से clean exit करता है, जैसे कि टनल क्लाइंट जो दूरस्थ छोर (far end) के डिस्कनेक्ट होने पर 0 रिटर्न करता है। always की कीमत यह है कि यह बग्स को छिपा देता है: एक सर्विस जो स्टार्ट होती है, खराब कॉन्फ़िगरेशन फ़ाइल पढ़ती है, एरर लॉग करती है और 0 के साथ एग्जिट हो जाती है, वह बस दोबारा स्टार्ट हो जाती है। 100 मिलीसेकंड के डिफ़ॉल्ट अंतराल के साथ, यह जल्द ही नीचे वर्णित स्टार्ट रेट लिमिट तक पहुँच जाती है और start-limit-hit के साथ फेल हो जाती है। यदि RestartSec= इतना लंबा हो कि वह उस लिमिट के नीचे रहे, तो यह अनिश्चित काल तक लूप में चलती रहती है, और इसका एकमात्र संकेत रीस्टार्ट काउंटर का बढ़ना होता है।

SuccessExitStatus= clean और unclean के बीच की रेखा को बदल देता है। Borg चेतावनियों के लिए 1 और त्रुटियों के लिए 2 के साथ एग्जिट होता है, इसलिए SuccessExitStatus=1 के बिना एक बैकअप यूनिट हर बार फेल मार्क हो जाती है जब वह एक भी अपठनीय (unreadable) फ़ाइल छोड़ती है। RestartPreventExitStatus= उन कोड्स को सूचीबद्ध करता है जो always के तहत भी रीस्टार्ट को रोकते हैं, जो किसी प्रोग्राम के लिए यह कहने का सही तरीका है कि उसे वापस नहीं आना चाहिए। RestartForceExitStatus= इसके विपरीत काम करता है। बैकअप जॉब को रीस्टार्ट लूप के बजाय टाइमर द्वारा संचालित Type=oneshot यूनिट में होना चाहिए, और शेड्यूल पर जॉब चलाने वाला सर्विस और टाइमर पेयर ही वह तरीका है जिसे यहाँ कॉपी करना चाहिए।

टेस्टिंग के बारे में एक चेतावनी। अपनी सर्विस को सामान्य kill <pid> से किल करने पर SIGTERM भेजा जाता है, जो clean लिस्ट में है, इसलिए Restart=on-failure सही ढंग से कुछ नहीं करता और आप निष्कर्ष निकालते हैं कि आपका कॉन्फ़िगरेशन खराब है। इसके बजाय kill -9 <pid> या systemctl kill -s SIGKILL myapp.service का उपयोग करें। यह भी याद रखें कि Restart= का कोई भी मान systemctl stop के बाद, या तब काम नहीं करता जब यूनिट को इसलिए रोका गया क्योंकि कोई BindsTo= या PartOf= निर्भरता (dependency) समाप्त हो गई थी। स्टॉप जॉब विफलता (failure) नहीं है।

RestartSec, और 100 मिलीसेकंड का डिफ़ॉल्ट

RestartSec= वह विराम है जो unit के रुकने और systemd द्वारा उसे फिर से शुरू करने के बीच होता है, और इसका डिफ़ॉल्ट मान 100 मिलीसेकंड है। जाँचें कि आपकी unit ने वास्तव में क्या लोड किया है:

systemctl show -p RestartUSec -p StartLimitIntervalUSec -p StartLimitBurst myapp.service

जो unit इसे सेट नहीं करती है, वह RestartUSec=100ms प्रिंट करती है, जब तक कि किसी ने /etc/systemd/system.conf में DefaultRestartSec= को न बदला हो, जहाँ से unset मान आता है। यह डिफ़ॉल्ट उस service के लिए ठीक है जो एक बार क्रैश होकर वापस आ जाती है। यह उस service के लिए गलत है जो बिल्कुल भी शुरू नहीं हो सकती, क्योंकि एक प्रोग्राम जो तुरंत विफल हो जाता है, उसके लिए पहला स्टार्ट और चार रीस्टार्ट एक सेकंड से भी कम समय में पूरे हो जाते हैं, और यह उन पाँच स्टार्ट्स का उपयोग कर लेता है जिनकी अनुमति आगे वर्णित rate limit देती है। किसी भी ऐसी चीज़ के लिए जो डेटाबेस, माउंट या नेटवर्क रूट की प्रतीक्षा करती है, RestartSec=5s या उससे अधिक सेट करें।

अक्टूबर 2026 तक, systemd 254 और उसके नए संस्करण RestartSteps= और RestartMaxDelaySec= भी प्रदान करते हैं, जो उन प्रयासों के दौरान देरी को RestartSec= से एक अधिकतम सीमा तक बढ़ा देते हैं। Ubuntu 24.04 में systemd 255 आता है और उसमें ये सुविधाएँ हैं। Debian 12 में systemd 252 आता है और उसमें ये नहीं हैं, हालाँकि bookworm-backports में systemd 254 उपलब्ध है। जब dependency लंबे समय तक डाउन रह सकती है, तो बढ़ती हुई देरी (growing delays) सही समाधान है।

"start request repeated too quickly" का वास्तविक अर्थ क्या है

यह वह स्थिति है जिसे देखकर पाठक यह मान लेते हैं कि systemd ने मनमाने ढंग से प्रयास करना छोड़ दिया है। यह वास्तव में एक काउंटर है। नियम यह है: यदि कोई unit StartLimitBurst= के भीतर StartLimitIntervalSec= से अधिक बार start की जाती है, तो systemd उसे फिर से start करने से मना कर देता है और उसे failed स्थिति में डाल देता है। डिफ़ॉल्ट रूप से यह 10 सेकंड में 5 बार start होने का प्रयास है।

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 काउंटर और failed स्थिति को साफ़ करता है। इसके बिना, एक साधारण systemctl start को तब तक अस्वीकार किया जाता रहेगा जब तक कि StartLimitIntervalSec= विंडो समाप्त नहीं हो जाती, और automatic restarts तब तक बंद रहते हैं जब तक कोई और उस unit को start न करे। मैन्युअल start भी इस सीमा में गिने जाते हैं, इसलिए कॉन्फ़िगरेशन फ़ाइल को एडिट करते समय कुछ बार जल्दबाजी में systemctl restart चलाने से बिना किसी क्रैश के भी यह स्थिति उत्पन्न हो सकती है।

जो बात लोगों को भ्रमित करती है वह यह है: start-limit-hit कभी नहीं बताता कि service क्यों विफल हो रही थी। यह केवल यह बताता है कि यह बार-बार और तेज़ी से विफल हुई है। वास्तविक कारण इसके ऊपर की journal लाइनों में होता है।

दोनों सेटिंग्स [Unit] सेक्शन में होनी चाहिए। आपको ऐसे उदाहरण मिलेंगे जो इन्हें [Service] में रखते हैं, जिसे पुराने systemd ने स्वीकार किया था, और यहीं से भ्रम शुरू होता है। इन्हें [Unit] में लिखें, फिर systemd से पूछें कि उसने systemctl show के साथ क्या लोड किया है, क्योंकि लोड किया गया मान ही एकमात्र मान्य मान है।

[Unit]
Description=My application
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Type=exec
ExecStart=/usr/local/bin/myapp
Restart=on-failure
RestartSec=10s

यह unit को पांच मिनट की विंडो के भीतर पांच प्रयास करने की अनुमति देता है, जिसके बाद यह प्रयास करना छोड़ देता है। StartLimitIntervalSec=0 इस सीमा को पूरी तरह से बंद कर देता है, और आपको पता होना चाहिए कि आप क्या चुन रहे हैं: एक service जो कभी start नहीं हो सकती, वह अब हमेशा retry करती रहेगी और हर बार journal में लिखेगी। मशीन-व्यापी डिफ़ॉल्ट सेटिंग्स /etc/systemd/system.conf में DefaultStartLimitIntervalSec= और DefaultStartLimitBurst= के रूप में रहती हैं।

एक संबंधित सेटिंग चेतावनी के योग्य है। StartLimitAction= यह तय करता है कि सीमा तक पहुँचने पर क्या होगा, और यह reboot, reboot-force और poweroff जैसे मान स्वीकार करता है। डिफ़ॉल्ट none है, जो unit को विफल कर देता है और मशीन को वैसे ही छोड़ देता है। एक रिमोट VPS पर, poweroff का मतलब एक ऐसी मशीन है जो तब तक बंद रहेगी जब तक आप प्रदाता का कंसोल नहीं खोलते।

समाधान एक: प्रति यूनिट एक प्रोसेस

लगभग हर मामले में यही सही उत्तर है। यदि दो प्रोग्राम चलाने आवश्यक हैं, तो दो यूनिट लिखें। इस तरह प्रत्येक का अपना वास्तविक मुख्य प्रोसेस, वास्तविक एग्जिट स्टेटस और अपनी रीस्टार्ट पॉलिसी होती है। आपको अलग-अलग लॉग्स, अलग-अलग रिसोर्स लिमिट्स और अलग-अलग रीस्टार्ट काउंटर्स भी मिलते हैं, जो कि रात के तीन बजे आपको चाहिए होते हैं।

यूनिट्स के बीच के संबंध को शेल स्क्रिप्ट में नहीं, बल्कि यूनिट फाइल्स में ही व्यक्त करें।

  • After= केवल स्टार्ट-अप को व्यवस्थित करता है। यह विफलताओं के बारे में कुछ नहीं कहता।
  • Requires= दूसरी यूनिट को इसके साथ शुरू करता है, और यदि दूसरी यूनिट को स्पष्ट रूप से रोका जाता है, तो यह भी रुक जाती है।
  • BindsTo= का अर्थ है Requires= और वह स्थिति जो आपके लिए महत्वपूर्ण है: यह यूनिट तब रुक जाती है जब दूसरी यूनिट किसी भी कारण से रुकती है, जिसमें क्रैश होना भी शामिल है। इसे After= के साथ जोड़ें, अन्यथा ऑर्डरिंग अनिश्चित रहेगी।
  • PartOf= स्टॉप और रीस्टार्ट को नीचे की ओर प्रसारित करता है, ताकि systemctl restart myapp.target हर उस यूनिट तक पहुँचे जो इसके साथ PartOf= है।
  • Upholds= (systemd 249 और नए वर्ज़न, यानी Ubuntu 22.04 और बाद के वर्ज़न) नामित यूनिट को चालू रखता है: यदि वह रुकती है, तो systemd उसे फिर से शुरू कर देता है। यह बाकी सभी चीजों की तरह ही स्टार्ट रेट लिमिट के अधीन है।

एक वर्कर जिसे अपने API सर्वर के बिना कभी नहीं चलना चाहिए, और जिसे systemd तब तक चालू रखता है जब तक API चल रहा है:

# /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=5s

वर्कर में कोई [Install] सेक्शन नहीं है और इसे कभी भी मैन्युअल रूप से इनेबल नहीं किया जाता है। API यूनिट इसे Upholds= के साथ खींचती है, इसलिए systemctl enable --now myapp-api.service ही वह एकमात्र कमांड है जिसे आप चलाते हैं। रिलोड करें और देखें कि systemd ने इस जोड़ी के बारे में क्या किया है:

sudo systemctl daemon-reload
systemd-analyze verify /etc/systemd/system/myapp-worker.service
systemctl list-dependencies myapp-api.service

systemd-analyze verify फाइल साफ होने पर कुछ भी प्रिंट नहीं करता है। कोई भी आउटपुट एक समस्या है, आमतौर पर ऐसी की (key) जिसे systemd उस सेक्शन में नहीं पहचानता जहाँ आपने उसे लिखा है, या किसी ऐसी यूनिट पर निर्भरता जो मौजूद नहीं है।

दूसरा समाधान: Type=notify, ताकि systemd को PID से अधिक जानकारी मिले

यदि प्रोग्राम systemd notification protocol का उपयोग करता है, तो इसका लाभ उठाएं। Type=notify के साथ, service systemd को बताती है कि वह कब तैयार है। इससे ordering केवल एक उम्मीद नहीं, बल्कि वास्तविक बन जाती है। साथ ही, यह launcher के बजाय उस process की ओर इशारा करने के लिए MAINPID= भेज सकती है जो वास्तव में महत्वपूर्ण है।

WatchdogSec= वह हिस्सा है जिसके लिए यह प्रयास सार्थक है। इसे set करें, और service को कम से कम उतनी बार WATCHDOG=1 के माध्यम से sd_notify(3) भेजना होगा। जब ये संदेश आने बंद हो जाते हैं, तो systemd service को SIGABRT के साथ समाप्त कर देता है और उसे failed चिह्नित कर देता है, ताकि Restart=on-failure या Restart=on-watchdog उसे वापस ला सकें। यह किसी ऐसी process को restart करने का एकमात्र इन-बिल्ट तरीका है जो चल तो रही है लेकिन अटक गई है, जिसे कोई भी exit-status policy कभी नहीं पकड़ सकती।

[Service]
Type=notify
NotifyAccess=main
ExecStart=/usr/local/bin/myapp serve
WatchdogSec=30s
Restart=on-failure
RestartSec=5s

Watchdog trip journal में myapp.service: Watchdog timeout (limit 30s)! के रूप में दिखाई देता है, जिसके बाद kill कमांड चलती है। यदि इसके बजाय unit activating (start) में तब तक रुकी रहती है जब तक TimeoutStartSec समाप्त नहीं हो जाता, तो इसका मतलब है कि READY=1 कभी नहीं पहुंचा या कभी गिना नहीं गया। या तो प्रोग्राम protocol का समर्थन नहीं करता है, या NotifyAccess=main किसी ऐसी notification को अस्वीकार कर रहा है जो child process से आई है (जिसे journal दोनों PIDs के साथ रिपोर्ट करता है), या किसी helper process ने संदेश भेजा और systemd के यह पहचानने से पहले ही exit कर गई कि यह किस unit से आया था। वह अंतिम संदेश NotifyAccess=all के तहत भी अनदेखा कर दिया जाता है, और इसका समाधान प्रोग्राम में ही है: helper के exit होने से पहले उसे sd_notify_barrier() कॉल करना चाहिए।

ऐसे software के लिए जो HTTP health endpoint तो expose करता है लेकिन जिसमें sd_notify का समर्थन नहीं है, ईमानदार विकल्प यह है कि एक छोटा timer unit बनाया जाए जो endpoint को probe करे और systemctl restart को कॉल करे, या फिर container runtime को probing करने दी जाए, जिसके लिए Compose healthchecks और उनका restart व्यवहार मौजूद है।

उपाय तीन: यूनिट के भीतर एक सुपरवाइजर, केवल तब जब कोई विकल्प न हो

कुछ सॉफ्टवेयर वास्तव में ऐसे लॉन्चर के साथ आते हैं जिसके पीछे कई प्रोसेस का बंडल होता है जिसे आप अलग नहीं कर सकते। ऐसी स्थिति में आप यूनिट के भीतर एक सुपरवाइजर चलाते हैं और इसके परिणामों को स्वीकार करते हैं: systemd सुपरवाइजर की निगरानी करता है, सुपरवाइजर बाकी सब चीजों की निगरानी करता है, और आपकी रीस्टार्ट पॉलिसी अब दो फाइलों में रहती है।

इसका सामान्य रूप एक कंटेनर रनटाइम है। एक docker compose या podman यूनिट बिल्कुल इसी पैटर्न पर आधारित है, जिसमें प्रति-कंटेनर रीस्टार्ट पॉलिसी Compose फाइल में दी गई होती है और systemd यूनिट केवल रनटाइम को चालू रखती है। यदि आपका सेटअप ऐसा है, तो बूट पर Compose स्टैक को चालू करने वाली यूनिट कार्यशील संस्करण दिखाती है, जिसमें यह भी शामिल है कि वहां Type=oneshot के साथ RemainAfterExit=yes का उपयोग आमतौर पर सही क्यों होता है।

cgroup अभी भी आपके पक्ष में काम करता है। सुपरवाइजर जो कुछ भी शुरू करता है वह यूनिट के cgroup के भीतर ही रहता है, इसलिए MemoryMax=, CPUQuota= और स्टॉप के समय सफाई की प्रक्रिया पूरी ट्री को कवर करती है। केवल रीस्टार्ट का निर्णय डेलिगेट किया जाता है।

आप चाहे जो भी सुपरवाइजर चुनें, बाहरी यूनिट पर Restart=always और उसके भीतर एक आक्रामक रीस्टार्ट पॉलिसी को बिना सोचे-समझे सेट न करें। रीस्टार्ट लॉजिक की दो परतें, जिनमें से प्रत्येक का अपना बैकऑफ होता है, एक ऐसी सर्विस बनाती हैं जो मिनटों तक फ्लैप करती रहती है और जिसका जर्नल यह नहीं बताता कि ऐसा क्यों हो रहा है।

ExitType=cgroup का अर्थ यह नहीं है कि "किसी भी process के मरने पर restart करें"

ExitType= (systemd 250 और उसके बाद के संस्करण, इसलिए Ubuntu 24.04 और Debian 12 दोनों में यह उपलब्ध है) वह setting है जिसे लोग इस समस्या को खोजने पर पाते हैं, और यह नाम के विपरीत काम करती है। default, ExitType=main, का अर्थ है कि मुख्य process के exit होने पर service को बंद माना जाता है। ExitType=cgroup का अर्थ है कि service को तब तक चलता हुआ माना जाता है जब तक कि cgroup की अंतिम process exit न हो जाए।

इसलिए ExitType=cgroup एक unit को किसी एक process के मरने के प्रति कम संवेदनशील बनाता है, न कि अधिक। यह उस program के लिए सही setting है जो अपने वास्तविक worker को fork करता है और PID file लिखे बिना parent को exit कर देता है, जहाँ Type=forking daemon को नहीं ढूँढ पाता। यह यहाँ वर्णित विफलता के लिए गलत setting है।

ऐसा कोई Restart= मान नहीं है जिसका अर्थ "cgroup में किसी भी process के मरने पर unit को restart करें" हो। यदि आपको उस व्यवहार की आवश्यकता है, तो आपको प्रति unit एक process की आवश्यकता होगी। यदि आप program को विभाजित नहीं कर सकते और आप wrapper script को नियंत्रित करते हैं, तो सबसे निकटतम विकल्प wait -n है, जो पहली child के exit होते ही वापस आ जाता है:

#!/bin/bash
/usr/local/bin/myapp-web &
/usr/local/bin/myapp-worker &
wait -n
exit 1

अब किसी भी child के मरने पर 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-precise

systemctl status एक ही स्क्रीन पर स्थिति, मुख्य PID और cgroup ट्री दिखाता है। एक स्वस्थ unit Active: active (running) दिखाती है, जिसमें एक Main PID: लाइन होती है जो उस process का नाम बताती है जिसकी आपको अपेक्षा है। यदि नीचे दिए गए ट्री में ऐसी processes सूचीबद्ध हैं जिन्हें आप नहीं पहचानते, या कोई ऐसी process गायब है जो होनी चाहिए थी, तो आपको अपना उत्तर मिल गया है।

systemd-cgls --unit बिना truncation के वही ट्री प्रिंट करता है, जो तब महत्वपूर्ण हो जाता है जब एक unit में मुट्ठी भर से अधिक processes हों।

systemctl show मशीन-पठनीय तथ्य देता है। NRestarts= रीस्टार्ट काउंटर है, और यह किसी ऐसी service को पहचानने का सबसे तेज़ तरीका है जो चालीस बार रीस्टार्ट हो चुकी है, उस service के मुकाबले जो बूट के समय से चल रही है। Result= में अंतिम विफलता का कारण होता है: exit-code, signal, timeout, oom-kill, watchdog या start-limit-hit। ExecMainStatus= अंतिम मुख्य process की raw exit status है।

जर्नल में अनुक्रम सुरक्षित रहता है। खोजने के लिए ये तीन लाइनें हैं:

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 का अर्थ है कि प्रोग्राम ने N रिटर्न करने का विकल्प चुना, इसलिए दोष प्रोग्राम या उसके कॉन्फ़िगरेशन में है। code=killed, signal=SEGV का अर्थ है कि यह क्रैश हो गया। code=killed, signal=TERM का आमतौर पर अर्थ है कि किसी और चीज़ ने इसे रुकने के लिए कहा, जो कि विफलता नहीं है और इससे Restart=on-failure ट्रिगर नहीं होगा। code=dumped का अर्थ है कि इसने एक core file छोड़ी है, जिसे coredumpctl list आपको दिखाएगा जब systemd-coredump इंस्टॉल हो।

एक से अधिक मशीनों पर, NRestarts वह संख्या है जिसे शेड्यूल पर एकत्र करना चाहिए। जिस unit का काउंटर हर दिन बढ़ता है, वह हर दिन विफल हो रही है, चाहे किसी ने ध्यान दिया हो या नहीं। एक बार जब आप दो या तीन मशीनों से आगे निकल जाते हैं, तो हर सर्वर पर एक कमांड चलाने का एक सुसंगत तरीका इसे अनुमान से बदलकर एक रिपोर्ट बना देता है।

FAQ

systemctl यह क्यों कहता है कि मेरी service active है, जबकि process मर चुकी है?

systemd प्रति service unit केवल एक मुख्य process को ट्रैक करता है, और Restart= केवल उसी process के exit status को पढ़ता है। unit द्वारा शुरू की गई अन्य सभी चीजें एक ही cgroup में रहती हैं, और unit के रुकने पर systemd उन processes को मार देता है, लेकिन वह कभी भी उनके exit पर नजर नहीं रखता। systemctl show -p MainPID myapp.service चलाएं और उस संख्या की तुलना systemd-cgls --unit myapp.service से करें। यदि जो process मर गई है वह tree में दिखाई देती है लेकिन MainPID नहीं है, तो systemd ने बिल्कुल वैसा ही व्यवहार किया है जैसा उसे करने के लिए डिज़ाइन किया गया था। इसका समाधान प्रति unit एक process रखना है, जिसमें units के बीच संबंध को BindsTo= और Upholds= के रूप में लिखा गया हो।

"start request repeated too quickly" का क्या अर्थ है?

इसका मतलब है कि unit को StartLimitIntervalSec= के भीतर StartLimitBurst= से अधिक बार शुरू किया गया था, जो डिफ़ॉल्ट रूप से 10 सेकंड में 5 बार शुरू होने की सीमा है, इसलिए systemd ने प्रयास करना बंद कर दिया। यह एक rate limit है और यह कभी नहीं बताता कि service क्यों विफल हो रही थी, इसलिए इसके ऊपर की journal लाइनों को पढ़ें। systemctl reset-failed myapp.service के साथ state को साफ़ करें, फिर अंतर्निहित विफलता को ठीक करें। यदि service किसी धीमी चीज़ के शुरू होने का इंतज़ार करती है, तो RestartSec= को बढ़ाएं, क्योंकि 100 मिलीसेकंड का डिफ़ॉल्ट अंतराल एक सेकंड से भी कम समय में सभी पांच प्रयासों को समाप्त कर देता है।

क्या मुझे Restart=always का उपयोग करना चाहिए या Restart=on-failure का?

लगभग हर चीज़ के लिए on-failure का उपयोग करें। यह क्रैश, नॉन-जीरो एग्जिट, टाइमआउट और वॉचडॉग ट्रिप को रीस्टार्ट करता है, और यह जानबूझकर किए गए exit 0 को अकेला छोड़ देता है। always का उपयोग केवल तब करें जब प्रोग्राम अपने नियंत्रण से बाहर के कारणों से साफ़ तौर पर एग्जिट हो जाए, जैसे कि कोई क्लाइंट जो अपने peer के डिस्कनेक्ट होने पर 0 रिटर्न करता है। always की कीमत यह है कि जो service खराब कॉन्फ़िगरेशन पढ़ती है, एक त्रुटि लॉग करती है और 0 के साथ एग्जिट होती है, उसे बार-बार शुरू किया जाता है। डिफ़ॉल्ट अंतराल के साथ यह जल्द ही start-limit-hit के साथ विफल हो जाती है, और लंबे RestartSec= के साथ यह अनिश्चित काल तक लूप कर सकती है, जिसमें systemctl show में NRestarts का बढ़ना ही एकमात्र दृश्य लक्षण होता है।

मेरी process को हाथ से kill करने पर रीस्टार्ट ट्रिगर क्यों नहीं होता?

क्योंकि, Type=oneshot को छोड़कर हर प्रकार के लिए, systemd SIGHUP, SIGINT, SIGTERM और SIGPIPE को साफ़ एग्जिट मानता है, और एक साधारण kill <pid>, SIGTERM भेजता है। Restart=on-failure के तहत एक साफ़ एग्जिट विफलता नहीं है, इसलिए कुछ भी रीस्टार्ट नहीं होता और कॉन्फ़िगरेशन तब भी टूटा हुआ दिखता है जब वह नहीं होता। kill -9 <pid> या systemctl kill -s SIGKILL myapp.service के साथ परीक्षण करें, जो एक अशुद्ध समाप्ति है और नीति को ट्रिगर करती है। यही नियम बताता है कि systemctl stop आपकी रीस्टार्ट नीति से कभी क्यों नहीं लड़ता।

StartLimitIntervalSec और StartLimitBurst कहाँ जाते हैं?

[Unit] सेक्शन में। पुरानी सामग्री और पुराने systemd वर्ज़न उन्हें [Service] में रखते हैं, इसलिए कॉपी किए गए उदाहरण एक-दूसरे से असहमत होते हैं। यह अनुमान न लगाएं कि आपका वर्ज़न किसका सम्मान करता है। systemctl daemon-reload के बाद, systemd से पूछें कि उसने systemctl show -p StartLimitBurst -p StartLimitIntervalUSec myapp.service के साथ क्या लोड किया है, और उन संख्याओं को ही सत्य मानें। systemd-analyze verify /etc/systemd/system/myapp.service उन keys को पकड़ता है जिन्हें systemd बिल्कुल नहीं पहचानता, और जब फ़ाइल साफ़ होती है तो कुछ भी प्रिंट नहीं करता।

क्या यह लेख उपयोगी था?

#systemd#restart#service-unit#cgroups#reliability