SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-30

systemd ஏன் service-ஐ restart செய்யவில்லை?

Restart= கட்டளை முதன்மை process-ஐ மட்டுமே கண்காணிக்கும். cgroup-ல் உள்ள மற்ற process-கள் செயலிழந்தால் systemd அதை அறியாது. Type= மற்றும் restart வரம்புகள் எவ்வாறு செயல்படுகின்றன என்பதை

சுருக்கமான பதில்: systemd restart கொள்கைகள் ஒரு process-ஐ மட்டுமே கவனிக்கின்றன

systemd restart கொள்கைகள் ஒவ்வொரு unit-க்கும் ஒரு process-ஐ மட்டுமே கவனிக்கின்றன: அதுதான் முதன்மை process (main process). Restart= அந்த ஒரு process-ன் exit status-ஐயும், அதைச் சுற்றி systemd இயக்கும் ExecStartPre=, ExecStartPost= மற்றும் ExecReload= போன்ற குறுகிய கட்டளைகளின் நிலையையும் மட்டுமே வாசிக்கும். அது வேறெதையும் கவனிப்பதில்லை. ஒரு unit-ன் control group-ல் இருபது process-கள் இருக்கலாம்; அவற்றில் ஒன்று செயலிழந்தாலும், முதன்மை process தொடர்ந்து இயங்குவதால் அந்த unit active (running) நிலையிலேயே இருக்கும். systemd-ஐப் பொறுத்தவரை எந்தப் பிழையும் ஏற்படவில்லை, எனவே எதையும் அது restart செய்யாது.

systemd-க்கு மற்ற process-களைப் பற்றித் தெரியும். unit நிறுத்தப்படும்போது அவற்றை அது கொல்லும், unit-ன் memory வரம்புகளுக்குள் அவற்றின் பயன்பாட்டைக் கணக்கிடும், unit-க்கான CPU ஒதுக்கீட்டை அவற்றுக்கு வழங்கும், மேலும் systemctl status-ல் அவற்றைப் பட்டியலிடும். ஆனால், அவற்றின் exit status-ஐ அது ஒருபோதும் வாசிப்பதில்லை. restart தர்க்கமும் (restart logic) cgroup-ம் வெவ்வேறு விஷயங்கள்; இந்த வழிகாட்டியின் பெரும்பகுதி அவற்றுக்கு இடையேயான இந்த இடைவெளியைப் பற்றியதுதான்.

cgroup எதைக் கொண்டுள்ளது மற்றும் restart logic எதைப் படிக்கிறது

cgroup (control group) என்பது ஒரு குறிப்பிட்ட செயல்முறைகளின் தொகுப்பைக் கொண்ட ஒரு kernel object ஆகும். ஒவ்வொரு service unit-க்கும் அதன் பெயரிலேயே ஒரு cgroup உருவாக்கப்படும். ஒரு செயல்முறை அதிலிருந்து வெளியேற முடியாது. அதன் குழந்தைகள் (children) தங்கள் பெற்றோரின் cgroup-ஐயே பெறுகின்றன, மேலும் ஒரு unprivileged செயல்முறை தன்னைத்தானே வேறொரு இடத்திற்கு மாற்றிக்கொள்ள முடியாது. இதனால்தான், பழைய init scripts-ஆல் செய்ய முடியாத வகையில், இரண்டு முறை fork செய்யும் ஒரு daemon-ஐ systemd-ஆல் முழுமையாக சுத்தம் செய்ய முடிகிறது.

இந்த இரண்டு உண்மைகளையும் அருகருகே கவனியுங்கள்:

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

systemd-cgls என்பது அந்த unit-ல் உள்ள ஒவ்வொரு செயல்முறையையும் பட்டியலிடுகிறது. MainPID என்பது restart policy படிக்கும் ஒரே ஒரு எண் ஆகும். இவை இரண்டும் உங்கள் எதிர்பார்ப்பிற்கு மாறாக இருந்தால், அந்த முரண்பாடே பிழை (bug) ஆகும். MainPID=0 என்றால், exit status-ஐப் படிக்க systemd-க்கு எந்த ஒரு main process-ம் இல்லை என்று அர்த்தம். இருப்பினும், அது cgroup-ஐத் தொடர்ந்து கண்காணிப்பதால், அதில் உள்ள கடைசி செயல்முறையும் முடிந்துவிட்டதை அது அறியும்; அதுவரை restart logic-ஆல் எந்த exit status-ஐயும் மதிப்பிட முடியாது.

main-process விதியில் ஒரு முக்கியமான விதிவிலக்கு உள்ளது. ஒரு unit-ன் cgroup-க்குள் இருக்கும் ஏதேனும் ஒரு செயல்முறையை kernel-ன் out-of-memory killer கொன்றுவிட்டால், systemd அதை கவனிக்கும், ஏனெனில் அது அந்த cgroup-ன் memory.events கோப்பைக் கண்காணிக்கிறது. OOMPolicy= அடுத்து என்ன நடக்க வேண்டும் என்பதைத் தீர்மானிக்கிறது, அதன் default மதிப்பு stop ஆகும்: முழு unit-ம் நிறுத்தப்படும், அதன் முடிவு oom-kill எனப் பதிவு செய்யப்படும், இது ஒரு தோல்வியாகக் கருதப்பட்டு, 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 பற்றாக்குறையால் கொல்லப்படும் ஒரு child செயல்முறை unit-ஐ நிறுத்திவிடும், ஆனால் அதே child செயல்முறை segmentation fault-ஆல் இறந்தால் unit நிற்காது. நீங்கள் ஒரு unit-க்கு memory வரம்புகளை அமைத்தால், restart policy-ஐ மாற்றியமைக்கும் முன் MemoryMax மற்றும் CPUQuota ஆகியவை unit-ன் cgroup-க்கு எவ்வாறு பொருந்தும் என்பதைப் படியுங்கள், ஏனெனில் இந்த இரண்டு அம்சங்களும் இங்குதான் ஒன்றிணைகின்றன.

Type= முதன்மை process-ஐ எவ்வாறு தேர்வு செய்கிறது

Type= என்பது [Service] பிரிவில் தொடக்க வரிசைப்படுத்துதலை (start-up ordering) மட்டும் குறிப்பதல்ல. எந்த PID (process ID) MainPID ஆக மாறும் என்பதைத் தீர்மானிக்கும் விதியும் இதுவே; இதுவே Restart= எதைக் காண முடியும் என்பதையும் தீர்மானிக்கிறது.

  • Type=simple என்பது default ஆகும். systemd, ExecStart=-லிருந்து fork செய்யும் process-தான் முதன்மை process. exec வேலை செய்ததா இல்லையா என்பதை அறிவதற்கு முன்பே, unit தொடங்கிவிட்டதாக systemd குறித்துக்கொள்ளும். binary பாதையில் எழுத்துப் பிழை (typo) இருந்தால், start job வெற்றி பெற்றதாகக் காட்டும், ஆனால் ஒரு கணம் கழித்து Main process exited, code=exited, status=203/EXEC தோல்வியடையும்.
  • Type=exec என்பது simple போலவே செயல்படும், ஆனால் exec வெற்றி பெறும் வரை start job காத்திருக்கும். இது மேற்சொன்ன எழுத்துப் பிழையை ஒரு உண்மையான start தோல்வியாக மாற்றும். இதற்கு systemd 240 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை. Ubuntu 20.04 மற்றும் அதற்குப் பிந்தைய பதிப்புகள் மற்றும் Debian 12 ஆகியவற்றில் இது உள்ளது, ஆனால் Ubuntu 18.04 (Ubuntu Pro மூலம் இன்னும் ஆதரிக்கப்படுகிறது) systemd 237-ஐக் கொண்டிருப்பதால் இதில் இது இல்லை. இது கிடைக்கும் இடங்களில், simple-க்கு பதிலாக இதையே பயன்படுத்தவும்.
  • Type=forking என்பது ExecStart=-லிருந்து வரும் process ஒரு background daemon-ஐ fork செய்துவிட்டு வெளியேறும் என்று எதிர்பார்க்கிறது. parent process வெளியேறும் வரை systemd காத்திருந்து, பின் உண்மையான daemon-ஐத் தேடும். இதற்கு PIDFile=-ஐ வழங்கவும். அது இல்லையெனில், GuessMainPID= (default-ஆகச் செயல்படும்) cgroup-ல் ஒரே ஒரு process இருக்கும்போது மட்டுமே வேலை செய்யும். இரண்டு process-களை விட்டுச் சென்றால், MainPID என்பது 0 நிலையிலேயே இருக்கும்.
  • Type=notify என்பது service ஆனது sd_notify(3)-ஐ அழைத்து, traffic-ஐக் கையாளத் தயாரானதும் READY=1-ஐ அனுப்பும் என்று பொருள். systemd கண்காணிக்க வேண்டிய வேறொரு process-ஐ வழங்க MAINPID=-ஐயும் அது அனுப்பலாம். Type=notify உடன், நீங்கள் மாற்றாவிட்டால் NotifyAccess= என்பது main என அமைக்கப்படும்; எனவே child அனுப்பும் அறிவிப்பு புறக்கணிக்கப்படும் மற்றும் journal அந்த PID-ஐ அதன் பெயரிலேயே காட்டும்.
  • Type=oneshot-க்கு நிலையான முதன்மை process கிடையாது. நீங்கள் RemainAfterExit=yes-ஐ அமைக்காதவரை, ExecStart= முடிந்தவுடன் unit inactive நிலைக்குச் சென்றுவிடும். 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 பிழைகளை நினைவில் கொள்வது அவசியம், ஏனெனில் இவை ஒவ்வொன்றும் எந்தக் காரணமும் இன்றி 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 கோப்பை வேறொரு இடத்தில் எழுதுகிறது அல்லது systemd தேடும் நேரத்தை விடத் தாமதமாக எழுதுகிறது என்று பொருள். இரண்டாவது பிழை, PID கோப்பு unit-ன் cgroup-க்கு வெளியே உள்ள ஒரு process-ஐக் குறிப்பிடுகிறது என்று பொருள். இதை systemd ஏற்காது, ஏனெனில் எழுதக்கூடிய PID கோப்பு இருந்தால், systemd-ஐப் பயன்படுத்தி server-ல் உள்ள எந்த process-க்கும் signal அனுப்பும் வாய்ப்பு உருவாகிவிடும்.

wrapper script ஏன் அதன் child process-களின் இறப்பை மறைக்கிறது

தலைப்பில் உள்ள கேள்விக்கு வழிவகுக்கும் அமைப்பு இதோ.

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

இந்த unit Type=simple ஆக இருப்பதால், முதன்மை process ஒரு shell ஆகும். வாதங்கள் (arguments) ஏதுமின்றி wait பயன்படுத்தப்படும்போது, அனைத்து child process-களும் வெளியேறிய பின்னரே அது திரும்பும். worker process-ஐ kill செய்தாலும், shell தொடர்ந்து web process-க்காகக் காத்திருக்கும். இதனால் shell வெளியேறாது, எனவே MainPID வெளியேறாது, மேலும் Restart= ஒருபோதும் அழைக்கப்படாது. cgroup-ல் இப்போது ஒரு process குறைவாக இருக்கும், systemctl status சுருக்கப்பட்ட tree-ஐக் காட்டும், மேலும் unit இன்னும் active (running) நிலையிலேயே இருக்கும். அந்த tree-ல் ஏற்படும் மாற்றங்களை systemd கண்காணிப்பதில்லை.

இதே தவறின் இரண்டாவது வடிவம் இன்னும் அமைதியானது:

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-ஆகவே இருக்கும், மேலும் signal-கள் நேரடியாக அதைச் சென்றடையும். அதைவிடச் சிறந்தது, shell-ஐ நீக்கிவிட்டு unit-ல் Environment= அல்லது EnvironmentFile=-ஐப் பயன்படுத்துவதாகும். -c சரத்தில் ஒரே ஒரு command மட்டும் இருந்தால் இந்த bug மறைந்துவிடும் என்பதை கவனிக்கவும், ஏனெனில் bash மற்றும் dash ஆகிய இரண்டும் அந்தச் சூழலில் நேரடியாக exec-ஐச் செய்யும் வகையில் optimize செய்கின்றன. அந்தச் சரத்தில் இரண்டாவது command-ஐச் சேர்த்தால், shell உங்கள் program-க்கு முன்னால் தொடர்ந்து இயங்கிக்கொண்டே இருக்கும்.

ஒரு test VPS-ல் இரண்டு நிமிடங்களில் இதைச் செய்து பாருங்கள்

மேலே உள்ள wrapper-ஐ /usr/local/bin/two-children.sh எனச் சேமித்து, chmod +x மூலம் executable ஆக்கி, இரண்டு program path-களையும் sleep 3600 என மாற்றவும். Type=simple மற்றும் Restart=on-failure மூலம் ஒரு unit-ஐ உருவாக்கி, பின் systemctl daemon-reload செய்து அதைத் தொடங்கவும். systemd-cgls --unit two-children.service-ஐ இயக்கினால் மூன்று PID-களைக் காணலாம்: shell மற்றும் அதன் இரண்டு child-கள். ஒரு child-ஐ sudo kill <pid> மூலம் kill செய்யவும். unit-ஐ மீண்டும் சரிபார்க்கவும். tree-ல் ஒரு process குறைவாக இருக்கும், நிலை இன்னும் active (running) என்றே இருக்கும், மேலும் journal-ல் புதிய தகவல்கள் எதுவும் இருக்காது. இப்போது அதற்குப் பதிலாக sudo kill -9 <shell pid>-ஐ இயக்கவும். unit தோல்வியடையும், மீதமுள்ள child process நீக்கப்படும் (ஏனெனில் KillMode=control-group என்பது இயல்பான அமைப்பு), மேலும் journal-ல் Scheduled restart job, restart counter is at 1. என்று காட்டும்.

முழுமையான Restart= சொற்களஞ்சியம் மற்றும் on-failure எப்போது always-ஐ விடச் சிறந்தது

Restart= ஏழு மதிப்புகளில் ஒன்றை ஏற்கும். எவை 'சுத்தமான' (clean) வெளியேற்றம் என்பதைக் கொண்டே இவை வேறுபடுகின்றன. systemd, 0 வெளியேற்றக் குறியீடு, SuccessExitStatus=-ல் பட்டியலிடப்பட்டுள்ள குறியீடுகள், மற்றும் Type=oneshot தவிர மற்ற அனைத்து வகைகளுக்கும் SIGHUP, SIGINT, SIGTERM, SIGPIPE ஆகிய சிக்னல்களைச் சுத்தமான வெளியேற்றமாகக் கருதுகிறது. மற்ற அனைத்தும், SIGKILL மற்றும் SIGSEGV உட்பட, சுத்தமற்றவை (unclean).

  • no என்பது இயல்பான அமைப்பாகும் (default). இந்த unit தானாக மீண்டும் தொடங்காது. இதனால்தான் Restart= வரி இல்லாத unit, முதல்முறை செயலிழக்கும்போது (crash) நின்றுவிடும், மீண்டும் இயங்காது.
  • on-success சுத்தமான வெளியேற்றத்திற்குப் பிறகு மட்டுமே மீண்டும் தொடங்கும்.
  • on-failure பூஜ்ஜியமற்ற வெளியேற்றக் குறியீடு, சுத்தமற்ற சிக்னல், start அல்லது stop காலாவதி (timeout), அல்லது watchdog காலாவதி ஏற்படும்போது மீண்டும் தொடங்கும்.
  • on-abnormal சுத்தமற்ற சிக்னல், காலாவதி அல்லது watchdog காலாவதி ஏற்படும்போது மீண்டும் தொடங்கும், ஆனால் சாதாரண பூஜ்ஜியமற்ற வெளியேற்றக் குறியீட்டிற்கு மீண்டும் தொடங்காது.
  • on-abort சுத்தமற்ற சிக்னலில், அதாவது ஒரு crash ஏற்படும்போது மட்டுமே மீண்டும் தொடங்கும்.
  • on-watchdog WatchdogSec= காலாவதியாகும் போது மட்டுமே மீண்டும் தொடங்கும்.
  • always மேலே உள்ள அனைத்துச் சூழல்களிலும், 0 என்ற சுத்தமான வெளியேற்ற நிலையிலும் கூட மீண்டும் தொடங்கும்.

நீண்ட நேரம் இயங்கும் daemon-களுக்கு on-failure சரியான இயல்பான அமைப்பாகும். இது ஒரு crash-ஐச் சரிசெய்து மீண்டும் இயக்கும், அதே சமயம் திட்டமிட்ட exit 0 வெளியேற்றத்தை அப்படியே விட்டுவிடும். always என்பது தனது கட்டுப்பாட்டிற்கு அப்பாற்பட்ட காரணங்களால் சுத்தமாக வெளியேறும் நிரல்களுக்கு உரியது. உதாரணமாக, தொலைதூர முனை துண்டிக்கப்படும்போது 0 என வெளியேறும் tunnel client-ஐக் கூறலாம். always-ன் குறைபாடு என்னவென்றால், இது பிழைகளை மறைத்துவிடும்: ஒரு service தொடங்கி, பழுதடைந்த config கோப்பை வாசித்து, பிழையைப் பதிவு செய்து 0 என வெளியேறினால், அது மீண்டும் தொடங்கப்படும். இயல்பான 100 மில்லி விநாடி இடைவெளியுடன், அது விரைவில் கீழே விவரிக்கப்பட்டுள்ள start rate limit-ஐ எட்டி, start-limit-hit நிலையில் தோல்வியடையும். அந்த வரம்பிற்குள் இருக்கும் வகையில் RestartSec= போதுமான அளவு நீளமாக இருந்தால், அது முடிவில்லாமல் சுழலும் (loop), restart counter அதிகரிப்பது மட்டுமே அதன் அறிகுறியாக இருக்கும்.

SuccessExitStatus= சுத்தமான மற்றும் சுத்தமற்ற வெளியேற்றங்களுக்கு இடையிலான கோட்டை மாற்றுகிறது. Borg எச்சரிக்கைகளுக்கு 1 மற்றும் பிழைகளுக்கு 2 என வெளியேறும். எனவே, SuccessExitStatus=1 இல்லாத backup unit, படிக்க முடியாத ஒரு கோப்பைத் தவிர்க்கும்போதெல்லாம் தோல்வியடைந்ததாகக் குறிக்கப்படும். RestartPreventExitStatus=, always-ன் கீழும் மீண்டும் தொடங்குவதைத் தடுக்கும் குறியீடுகளைப் பட்டியலிடுகிறது. ஒரு நிரல் மீண்டும் தொடங்கப்படக்கூடாது என்று கூறுவதற்கான சுத்தமான வழி இதுவே. RestartForceExitStatus= இதற்கு நேர்மாறானதைச் செய்கிறது. ஒரு backup பணி, restart loop-ல் இருப்பதை விட, timer மூலம் இயக்கப்படும் Type=oneshot unit-ல் இருக்க வேண்டும். ஒரு குறிப்பிட்ட கால அட்டவணையில் பணியை இயக்கும் service மற்றும் timer ஜோடி இதற்கான சரியான அமைப்பாகும்.

சோதனை செய்வது குறித்து ஒரு எச்சரிக்கை. உங்கள் service-ஐ சாதாரண kill <pid> மூலம் நிறுத்தினால், அது SIGTERM-ஐ அனுப்பும். இது சுத்தமான பட்டியலில் இருப்பதால், Restart=on-failure சரியாக எதையும் செய்யாது, இதனால் உங்கள் config பழுதடைந்துள்ளது என்று நீங்கள் தவறாக நினைக்கக்கூடும். அதற்குப் பதிலாக kill -9 <pid> அல்லது systemctl kill -s SIGKILL myapp.service-ஐப் பயன்படுத்தவும். மேலும், systemctl stop-க்குப் பிறகோ, அல்லது BindsTo= அல்லது PartOf= சார்ந்திருக்கும் சேவை (dependency) நீக்கப்பட்டதால் unit நிறுத்தப்பட்டாலோ, எந்த Restart= மதிப்பும் செயல்படாது என்பதை நினைவில் கொள்க. ஒரு stop பணி என்பது தோல்வி அல்ல.

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=-ஐ மாற்றியிருந்தால் ஒழிய, இதுவே இயல்புநிலை மதிப்பாக இருக்கும். ஒருமுறை செயலிழந்து மீண்டும் தொடங்கும் service-க்கு இந்த இயல்புநிலை போதுமானது. ஆனால், தொடக்கத்திலேயே தோல்வியடையும் ஒரு service-க்கு இது தவறானது. ஏனெனில், உடனடியாகத் தோல்வியடையும் ஒரு நிரலுக்கு, முதல் தொடக்கம் மற்றும் நான்கு மறுதொடக்கங்கள் ஒரு விநாடிக்கும் குறைவான நேரத்திலேயே முடிந்துவிடும். இது, அடுத்து விவரிக்கப்படும் rate limit அனுமதிக்கும் ஐந்து தொடக்க வாய்ப்புகளை விரைவாகப் பயன்படுத்திவிடும். database, mount, அல்லது network route ஆகியவற்றிற்காகக் காத்திருக்கும் எதற்கும், RestartSec=5s அல்லது அதற்கு மேற்பட்ட கால அளவை அமைக்கவும்.

அக்டோபர் 2026 நிலவரப்படி, systemd 254 மற்றும் அதற்குப் பிந்தைய பதிப்புகள் RestartSteps= மற்றும் RestartMaxDelaySec= ஆகியவற்றை வழங்குகின்றன. இவை, குறிப்பிட்ட எண்ணிக்கையிலான முயற்சிகளுக்குள் RestartSec=-லிருந்து ஒரு உச்ச வரம்பு வரை தாமதத்தை அதிகரிக்கச் செய்கின்றன. Ubuntu 24.04, systemd 255-ஐக் கொண்டுள்ளது மற்றும் இந்த வசதியைக் கொண்டுள்ளது. Debian 12, systemd 252-ஐக் கொண்டுள்ளது, இதில் இந்த வசதி இல்லை; இருப்பினும் bookworm-backports-ல் systemd 254 கிடைக்கிறது. ஒரு dependency நீண்ட நேரம் செயலிழந்திருக்க வாய்ப்புள்ள சூழலில், படிப்படியாக அதிகரிக்கும் தாமதங்களே சரியான தீர்வாகும்.

"start request repeated too quickly" என்பதன் உண்மையான பொருள்

systemd தன்னிச்சையாகச் செயல்படுவதை நிறுத்திவிட்டது என்று பயனர்கள் கருதும் நிலை இது. இது ஒரு counter ஆகும். விதிமுறை இதுதான்: ஒரு unit-ஐ StartLimitIntervalSec= காலத்திற்குள் StartLimitBurst= முறைக்கு மேல் தொடங்க முயற்சித்தால், systemd அதை மீண்டும் தொடங்க மறுத்து, failed நிலைக்குக் கொண்டு செல்லும். இயல்பான அமைப்புகள் (defaults) 10 வினாடிகளில் 5 முறை தொடங்குவதாகும்.

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 நிலையையும் நீக்கும். இதைச் செய்யாவிட்டால், StartLimitIntervalSec= கால அளவு முடியும் வரை ஒரு சாதாரண systemctl start கட்டளை நிராகரிக்கப்படும், மேலும் ஏதேனும் ஒன்று unit-ஐ மீண்டும் தொடங்கும் வரை automatic restarts முடங்கியிருக்கும். கைமுறையாகத் தொடங்கும் முயற்சிகளும் (manual starts) இந்த வரம்பிற்குள் அடங்கும். எனவே, நீங்கள் config file-ஐத் திருத்தும்போது அவசரத்தில் சில முறை systemctl restart கட்டளையை இயக்கினால், எந்தவிதமான crash-ம் இல்லாமலேயே இந்த வரம்பு எட்டப்படலாம்.

மக்களைத் தவறாக வழிநடத்தும் பகுதி இதுதான்: service ஏன் தோல்வியடைந்தது என்பதற்கான காரணத்தை start-limit-hit ஒருபோதும் கூறாது. அது மீண்டும் மீண்டும் விரைவாகத் தோல்வியடைந்தது என்பதை மட்டுமே அது தெரிவிக்கும். உண்மையான காரணம் அதற்கு மேலே உள்ள journal வரிகளில் இருக்கும்.

இரண்டு அமைப்புகளும் [Unit] பிரிவில் இருக்க வேண்டும். பழைய systemd பதிப்புகள் [Service] பிரிவில் உள்ள அமைப்புகளை ஏற்றுக்கொண்டன, அங்கிருந்துதான் குழப்பம் தொடங்குகிறது. எனவே அவற்றை [Unit] பிரிவில் எழுதவும், பின்னர் systemctl show கட்டளையைப் பயன்படுத்தி systemd எதை ஏற்றுக் கொண்டுள்ளது என்று சரிபார்க்கவும், ஏனெனில் ஏற்றப்பட்ட (loaded) மதிப்பு மட்டுமே கணக்கில் கொள்ளப்படும்.

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

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

இது, unit கைவிடப்படுவதற்கு முன்பு 5 நிமிட காலத்திற்குள் ஐந்து முறை முயற்சி செய்ய அனுமதிக்கும். StartLimitIntervalSec=0 இந்த வரம்பை முழுமையாக நீக்கிவிடும். நீங்கள் எதைத் தேர்ந்தெடுக்கிறீர்கள் என்பதை அறிந்திருக்க வேண்டும்: தொடங்க முடியாத ஒரு service, இனி எப்போதும் மீண்டும் மீண்டும் முயற்சி செய்து கொண்டே இருக்கும் மற்றும் ஒவ்வொரு முறையும் journal-ல் பதிவுகளை எழுதும். கணினி அளவிலான இயல்புநிலை அமைப்புகள் /etc/systemd/system.conf கோப்பில் DefaultStartLimitIntervalSec= மற்றும் DefaultStartLimitBurst= என இருக்கும்.

அருகிலுள்ள ஒரு அமைப்பிற்கு எச்சரிக்கை தேவை. வரம்பு எட்டப்படும்போது என்ன நடக்க வேண்டும் என்பதை StartLimitAction= தீர்மானிக்கிறது, இது reboot, reboot-force மற்றும் poweroff போன்ற மதிப்புகளை ஏற்கும். இயல்புநிலை none ஆகும், இது unit-ஐத் தோல்வியடையச் செய்து கணினியை அப்படியே விட்டுவிடும். ஒரு remote VPS-ல், poweroff என்பது, நீங்கள் provider-ன் console-ஐத் திறக்கும் வரை கணினி அணைந்தே இருக்கும் என்பதைக் குறிக்கும்.

தீர்வு ஒன்று: ஒரு unit-க்கு ஒரு process

இதுவே பெரும்பாலான சிக்கல்களுக்கு தீர்வாகும். இரண்டு நிரல்கள் இயங்க வேண்டும் என்றால், இரண்டு unit-களை எழுதவும். அப்போதுதான் ஒவ்வொன்றுக்கும் தனித்தனி முதன்மை process, சரியான exit status மற்றும் அதற்கே உரிய restart policy இருக்கும். மேலும், அதிகாலை 3 மணிக்கு உங்களுக்குத் தேவைப்படும் தனித்தனி logs, தனித்தனி resource limits மற்றும் தனித்தனி restart counters ஆகியவையும் கிடைக்கும்.

Unit-களுக்கு இடையிலான தொடர்பை shell script-ல் அல்லாமல், unit file-களிலேயே குறிப்பிடவும்.

  • After= தொடக்கத்தை (start-up) மட்டுமே வரிசைப்படுத்தும். தோல்விகளைப் பற்றி இது எதையும் கூறாது.
  • Requires= மற்றொரு unit-ஐ இதனுடன் சேர்த்துத் தொடங்கும்; அந்த unit வேண்டுமென்றே நிறுத்தப்பட்டால், இதையும் நிறுத்திவிடும்.
  • BindsTo= என்பது Requires= மற்றும் நீங்கள் கவனிக்க வேண்டிய கூடுதல் அம்சம்: ஏதேனும் ஒரு காரணத்தால் (crash உட்பட) மற்றொன்று நின்றால், இந்த unit-ம் நின்றுவிடும். இதை After= உடன் இணைக்கவும், இல்லையெனில் வரிசைமுறை (ordering) வரையறுக்கப்படாமல் போகும்.
  • PartOf= நிறுத்தம் மற்றும் மறுதொடக்கத்தை (restart) கீழ்நோக்கிப் பரப்பும், இதனால் systemctl restart myapp.target என்பது அதைச் சார்ந்திருக்கும் (PartOf=) அனைத்து unit-களுக்கும் சென்றடையும்.
  • Upholds= (systemd 249 மற்றும் அதற்குப் பிந்தைய பதிப்புகள், அதாவது Ubuntu 22.04 மற்றும் அதற்குப் பிறகு) குறிப்பிட்ட unit-ஐ தொடர்ந்து இயங்க வைக்கும்: அது நின்றால், systemd அதை மீண்டும் தொடங்கும். மற்ற அனைத்தையும் போலவே இதற்கும் start rate limit பொருந்தும்.

API server இல்லாமல் இயங்கக்கூடாத ஒரு worker, மற்றும் 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=5s

இந்த worker-க்கு [Install] பகுதி கிடையாது, இதை நீங்களாகவே enable செய்யக்கூடாது. API unit இதை Upholds= மூலம் இழுத்துக்கொள்ளும், எனவே systemctl enable --now myapp-api.service மட்டுமே நீங்கள் இயக்க வேண்டிய கட்டளை. Reload செய்து, இந்த ஜோடியை systemd எவ்வாறு கையாண்டுள்ளது என்பதைச் சரிபார்க்கவும்:

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

கோப்பு சரியாக இருந்தால் systemd-analyze verify எதையும் அச்சிடாது. ஏதேனும் வெளியீடு வந்தால் அது ஒரு சிக்கல்; பெரும்பாலும் நீங்கள் எழுதிய பகுதியில் systemd அடையாளம் காணாத ஒரு key அல்லது இல்லாத ஒரு unit-ன் மீதான dependency காரணமாக இருக்கலாம்.

இரண்டாவது தீர்வு: Type=notify, systemd-க்கு PID-ஐ விட கூடுதல் தகவல்களை வழங்குதல்

நிரல் systemd notification protocol-ஐ ஆதரித்தால், அதைப் பயன்படுத்தவும். Type=notify மூலம், service தயாரானதும் systemd-க்குத் தெரிவிக்கும். இது வெறும் எதிர்பார்ப்பாக இல்லாமல், முறையான வரிசைப்படுத்தலை (ordering) உறுதி செய்கிறது. மேலும், launcher-ஐக் குறிக்காமல், முக்கியமான process-ஐக் குறிக்க MAINPID=-ஐ அனுப்ப முடியும்.

WatchdogSec= என்பது முயற்சிக்குரிய ஒரு அம்சமாகும். இதை அமைத்தால், service குறிப்பிட்ட கால இடைவெளிக்குள் WATCHDOG=1-ஐ sd_notify(3) வழியாக அனுப்ப வேண்டும். செய்திகள் வருவது நின்றால், systemd அந்த service-ஐ SIGABRT மூலம் நிறுத்தி, failed என்று குறிக்கும். இதனால் Restart=on-failure அல்லது Restart=on-watchdog மூலம் அது மீண்டும் தொடங்கும். இயங்கிக்கொண்டிருந்தாலும் முடங்கிப்போன (stuck) ஒரு process-ஐ மீண்டும் தொடங்க இதுவே உள்ளமைக்கப்பட்ட ஒரே வழியாகும்; எந்த exit-status கொள்கையாலும் இதைக் கண்டறிய முடியாது.

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

Watchdog தூண்டப்பட்டால், journal-ல் myapp.service: Watchdog timeout (limit 30s)! என்று பதிவாகி, பின் process கொல்லப்படும். மாறாக, TimeoutStartSec முடியும் வரை unit activating (start) நிலையிலேயே இருந்தால், READY=1 வரவில்லை அல்லது கணக்கிடப்படவில்லை என்று அர்த்தம். ஒன்று, அந்த நிரல் இந்த protocol-ஐ ஆதரிக்கவில்லை; அல்லது NotifyAccess=main ஒரு child process-லிருந்து வந்த notification-ஐ நிராகரிக்கிறது (இதை journal இரண்டு PID-களுடன் காட்டும்); அல்லது ஒரு helper process செய்தியை அனுப்பிவிட்டு, அது எந்த unit-லிருந்து வந்தது என்று systemd அறிவதற்கு முன்பே வெளியேறியிருக்கலாம். அந்த கடைசி செய்தி NotifyAccess=all-ன் கீழும் புறக்கணிக்கப்படும். இதற்கான தீர்வு நிரலிலேயே உள்ளது: helper வெளியேறுவதற்கு முன் அது sd_notify_barrier()-ஐ அழைக்க வேண்டும்.

HTTP health endpoint-ஐக் கொண்ட ஆனால் sd_notify ஆதரவு இல்லாத மென்பொருள்களுக்கு, இரண்டு நேர்மையான வழிகள் உள்ளன: ஒன்று, endpoint-ஐச் சோதித்து systemctl restart-ஐ அழைக்கும் ஒரு சிறிய timer unit-ஐ உருவாக்குவது; அல்லது container runtime-ஐக் கொண்டு சோதிப்பது. இதற்காகவே Compose healthchecks மற்றும் அவற்றின் restart செயல்பாடுகள் உள்ளன.

தீர்வு மூன்று: வேறு வழியில்லாதபோது, unit-க்குள் ஒரு supervisor-ஐப் பயன்படுத்துதல்

சில மென்பொருட்கள் பிரிக்க முடியாத launcher-க்கு பின்னால் பல செயல்முறைகளின் (processes) தொகுப்பாகவே வருகின்றன. அத்தகைய சூழலில், நீங்கள் unit-க்குள் ஒரு supervisor-ஐ இயக்க வேண்டும். இதன் விளைவுகளை நீங்கள் ஏற்றுக்கொண்டாக வேண்டும்: systemd அந்த supervisor-ஐக் கண்காணிக்கும், supervisor மற்ற அனைத்தையும் கண்காணிக்கும், மேலும் உங்கள் restart policy இரண்டு கோப்புகளில் அமையும்.

இதன் பொதுவான வடிவம் container runtime ஆகும். ஒரு docker compose அல்லது podman unit என்பது சரியாக இந்த அமைப்பைக் கொண்டது. இதில் container-க்கான restart policy என்பது Compose கோப்பில் குறிப்பிடப்பட்டிருக்கும், systemd unit அந்த runtime-ஐ மட்டும் இயங்க வைக்கும். உங்கள் அமைப்பு இது போன்றது என்றால், boot நேரத்தில் Compose stack-ஐ இயக்கும் unit இதற்கான சரியான முறையைக் காட்டுகிறது. இதில் ஏன் Type=oneshot உடன் RemainAfterExit=yes பயன்படுத்துவது பொதுவாகச் சரியானது என்பதும் விளக்கப்பட்டுள்ளது.

cgroup இன்னும் உங்களுக்குச் சாதகமாகவே செயல்படும். supervisor தொடங்கும் அனைத்தும் அந்த unit-ன் cgroup-க்குள்ளேயே இருக்கும். எனவே MemoryMax=, CPUQuota= மற்றும் நிறுத்தப்படும்போது செய்யப்படும் cleanup ஆகிய அனைத்தும் முழு மரத்தையும் (tree) உள்ளடக்கும். restart செய்வதற்கான முடிவு மட்டுமே மாற்றியமைக்கப்படுகிறது.

நீங்கள் எந்த supervisor-ஐத் தேர்ந்தெடுத்தாலும், வெளிப்புற unit-ல் Restart=always-ஐ அமைத்துவிட்டு, உள்ளே தீவிரமான restart policy-ஐச் சிந்திக்காமல் அமைக்க வேண்டாம். இரண்டு அடுக்குகளில் restart logic இருக்கும்போது, ஒவ்வொன்றும் அதன் சொந்த backoff-ஐக் கொண்டிருக்கும். இது சேவை பல நிமிடங்களுக்குத் தடையின்றித் துடிக்க (flapping) வழிவகுக்கும், மேலும் அதற்கான காரணத்தை journal-ல் கண்டறிவது கடினமாகிவிடும்.

ExitType=cgroup என்பது "ஏதேனும் ஒரு process நின்றால் restart செய்" என்று பொருள்படாது

ExitType= (systemd 250 மற்றும் அதற்குப் பிந்தைய பதிப்புகள், எனவே Ubuntu 24.04 மற்றும் Debian 12 இரண்டிலும் இது உள்ளது) என்பது இந்தச் சிக்கலைத் தேடும்போது பயனர்கள் கண்டறியும் அமைப்பாகும், ஆனால் இது பெயருக்கு மாறான செயல்பாட்டையே செய்கிறது. இயல்புநிலை அமைப்பான ExitType=main, முதன்மை process வெளியேறும்போது service நிறுத்தப்பட்டதாகக் கருதப்படும் என்பதைக் குறிக்கிறது. ExitType=cgroup என்பது cgroup-ல் உள்ள கடைசி process வெளியேறும் வரை service இயங்கிக்கொண்டிருப்பதாகக் கருதப்படும் என்பதைக் குறிக்கிறது.

எனவே, ExitType=cgroup என்பது ஒரு process நின்றால் service-ஐ பாதிக்காதவாறே செயல்படுகிறது, மாறாக அதிக உணர்திறன் கொண்டதாக மாற்றாது. PID file-ஐ உருவாக்காமல் தனது உண்மையான worker process-ஐ fork செய்துவிட்டு, parent process-ஐ முடித்துக்கொள்ளும் நிரல்களுக்கு இதுவே சரியான அமைப்பாகும்; ஏனெனில் அத்தகைய சூழலில் Type=forking-ஆல் daemon-ஐக் கண்டறிய முடியாது. இங்கே விவரிக்கப்பட்டுள்ள தோல்விக்கு இது தவறான அமைப்பாகும்.

"cgroup-ல் உள்ள ஏதேனும் ஒரு process நின்றால் unit-ஐ restart செய்" என்று பொருள்படும் Restart= மதிப்பு எதுவும் இல்லை. உங்களுக்கு அத்தகைய செயல்பாடு தேவைப்பட்டால், ஒரு unit-க்கு ஒரு process என்ற அடிப்படையில் அமைக்க வேண்டும். நிரலைப் பிரிக்க முடியாமல், wrapper script-ஐ நீங்கள் கட்டுப்படுத்துகிறீர்கள் என்றால், அதற்கு நெருக்கமான வழி 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 செயல்படும். இது ஒரு தற்காலிகத் தீர்வே தவிர, முழுமையான சரிசெய்தல் அல்ல. இதில் இரண்டு நிரல்களுக்கும் ஒரே restart counter மற்றும் ஒரே log stream மட்டுமே இருக்கும், மேலும் தோல்வியடையும் பாதியை மட்டும் தனியாக restart செய்ய முடியாது.

உண்மையில் என்ன நடந்தது என்பதை ஆய்வு செய்வது எப்படி

இந்த வரிசையில் நான்கு கட்டளைகள் உள்ளன.

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 ஒரு திரையில் service-ன் நிலை, முதன்மை PID மற்றும் cgroup படிநிலையைக் காட்டும். சரியாக இயங்கும் ஒரு unit, Active: active (running) என்ற நிலையையும், நீங்கள் எதிர்பார்க்கும் process-ஐக் குறிப்பிடும் Main PID: வரியையும் கொண்டிருக்கும். கீழே உள்ள படிநிலையில் உங்களுக்குத் தெரியாத process-கள் இருந்தாலோ அல்லது நீங்கள் எதிர்பார்க்கும் process விடுபட்டிருந்தாலோ, அதற்கான விடை உங்களுக்குக் கிடைத்துவிடும்.

systemd-cgls --unit அதே படிநிலையைச் சுருக்காமல் முழுமையாக அச்சிடும். ஒரு unit-ல் பல process-கள் இயங்கும்போது இது முக்கியமானது.

systemctl show கணினியால் வாசிக்கக்கூடிய தகவல்களை வழங்கும். NRestarts= என்பது restart எண்ணிக்கையைக் குறிக்கும். ஒரு service 40 முறை restart ஆகியுள்ளதா அல்லது boot செய்ததிலிருந்து இயங்குகிறதா என்பதை அறிய இதுவே அதிவேகமான வழி. Result= கடைசி தோல்விக்கான காரணத்தைக் கொண்டிருக்கும்: exit-code, signal, timeout, oom-kill, watchdog அல்லது start-limit-hit. ExecMainStatus= என்பது கடைசியாக இயங்கிய முதன்மை process-ன் raw exit status ஆகும்.

Journal-ல் வரிசைமுறை பதிவுகள் இருக்கும். தேட வேண்டிய மூன்று வரிகள் இவை:

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 என்ற குறியீட்டைத் திரும்ப அனுப்பியுள்ளது என்று பொருள்; எனவே பிழை நிரலிலோ அல்லது அதன் configuration-லோ உள்ளது. code=killed, signal=SEGV என்றால் அது crash ஆகியுள்ளது என்று பொருள். code=killed, signal=TERM என்பது பொதுவாக வேறொரு காரணி அதை நிறுத்தச் சொன்னதைக் குறிக்கும்; இது தோல்வி அல்ல, எனவே இது Restart=on-failure-ஐத் தூண்டாது. code=dumped என்றால் அது core file-ஐ விட்டுச் சென்றுள்ளது என்று பொருள்; systemd-coredump நிறுவப்பட்டிருந்தால், coredumpctl list மூலம் அதை நீங்கள் பார்க்கலாம்.

ஒன்றுக்கும் மேற்பட்ட server-களில், NRestarts என்பது குறிப்பிட்ட கால இடைவெளியில் சேகரிக்க வேண்டிய முக்கியமான எண். ஒரு unit-ன் counter தினமும் அதிகரித்தால், அது தினமும் தோல்வியடைகிறது என்று பொருள்; யாராவது கவனித்தார்களோ இல்லையோ, அது தோல்வியடைகிறது. இரண்டு அல்லது மூன்று server-களுக்கு மேல் செல்லும்போது, ஒவ்வொரு server-லும் ஒரே கட்டளையை இயக்கும் சீரான வழி இதைக் வெறும் ஊகமாக இல்லாமல் ஒரு அறிக்கையாக மாற்றும்.

FAQ

process செயலிழந்த பிறகும் systemctl ஏன் service active என்று காட்டுகிறது?

systemd ஒரு service unit-க்கு ஒரு process-ஐ மட்டுமே கண்காணிக்கும். அது முதன்மை process ஆகும். Restart= அந்த process-ன் exit status-ஐ மட்டுமே வாசிக்கும். அந்த unit தொடங்கும் மற்ற அனைத்து process-களும் அதே cgroup-ல் இருக்கும். unit நிறுத்தப்படும்போது systemd அவற்றை அழித்துவிடும், ஆனால் அவை வெளியேறுவதை அது கண்காணிப்பதில்லை. systemctl show -p MainPID myapp.service-ஐ இயக்கி, அந்த எண்ணிக்கையை systemd-cgls --unit myapp.service-உடன் ஒப்பிட்டுப் பார்க்கவும். செயலிழந்த process அந்த tree-ல் இருந்து, ஆனால் அது MainPID இல்லை என்றால், systemd அதன் வடிவமைப்பின்படியே செயல்படுகிறது என்று அர்த்தம். இதற்குத் தீர்வாக, ஒரு unit-க்கு ஒரு process-ஐ மட்டும் வைத்துக்கொண்டு, unit-களுக்கு இடையே BindsTo= மற்றும் Upholds= உறவை வரையறுக்க வேண்டும்.

"start request repeated too quickly" என்பதன் பொருள் என்ன?

இதன் பொருள், அந்த unit StartLimitIntervalSec= காலத்திற்குள் StartLimitBurst= முறைக்கு மேல் தொடங்கப்பட்டுள்ளது என்பதாகும். இது இயல்பாக 10 வினாடிகளில் 5 முறை என அமைக்கப்பட்டுள்ளது. எனவே systemd மீண்டும் முயற்சிப்பதை நிறுத்திவிட்டது. இது ஒரு rate limit ஆகும்; இது service ஏன் தோல்வியடைந்தது என்று கூறாது. எனவே, அதற்கு முந்தைய journal வரிகளைப் படிக்கவும். systemctl reset-failed myapp.service மூலம் நிலையைச் சரிசெய்துவிட்டு, அடிப்படைப் பிழையைச் சரிசெய்யவும். ஒரு service தொடங்குவதற்கு அதிக நேரம் எடுக்கும் என்றால், RestartSec=-ஐ அதிகரிக்கவும். ஏனெனில், இயல்பான 100 milliseconds இடைவெளி, ஐந்து முயற்சிகளையும் ஒரு வினாடிக்குள் முடித்துவிடும்.

நான் Restart=always பயன்படுத்த வேண்டுமா அல்லது Restart=on-failure பயன்படுத்த வேண்டுமா?

பெரும்பாலானவற்றிற்கு on-failure-ஐப் பயன்படுத்தவும். இது crash, non-zero exit, timeout மற்றும் watchdog trip ஆகியவற்றை மீண்டும் தொடங்கும். மேலும், திட்டமிட்டுச் செய்யப்படும் exit 0-ஐ இது தவிர்க்கும். ஒரு நிரல் தனது கட்டுப்பாட்டிற்கு அப்பாற்பட்ட காரணங்களால் cleanly exit ஆகும்போது மட்டும் always-ஐப் பயன்படுத்தவும். உதாரணமாக, peer disconnect ஆகும்போது 0-ஐத் திருப்பி அனுப்பும் client. always-ன் குறைபாடு என்னவென்றால், தவறான configuration-ஐ வாசித்து, ஒரு error-ஐ log செய்துவிட்டு 0 என exit ஆகும் service மீண்டும் மீண்டும் தொடங்கப்படும். இயல்பான இடைவெளியில் அது விரைவில் start-limit-hit பிழையைத் தரும். நீண்ட RestartSec= இருந்தால், அது முடிவில்லாமல் loop ஆகலாம். அப்போது systemctl show-ல் NRestarts அதிகரிப்பது மட்டுமே தெரியும் அறிகுறியாக இருக்கும்.

எனது process-ஐ நான் கைமுறையாகக் கொல்லும்போது ஏன் restart தூண்டப்படுவதில்லை?

ஏனெனில், Type=oneshot தவிர மற்ற அனைத்து வகைகளுக்கும், SIGHUP, SIGINT, SIGTERM மற்றும் SIGPIPE ஆகியவற்றை systemd clean exit-ஆகக் கருதுகிறது. ஒரு சாதாரண kill <pid> கட்டளை SIGTERM-ஐ அனுப்பும். Restart=on-failure விதியின்படி, clean exit என்பது தோல்வி அல்ல. எனவே எதுவும் restart ஆகாது, configuration சரியாக இருந்தாலும் அது தவறாகத் தோன்றும். kill -9 <pid> அல்லது systemctl kill -s SIGKILL myapp.service மூலம் சோதிக்கவும்; இது unclean termination என்பதால், அது restart policy-ஐத் தூண்டும். systemctl stop ஏன் உங்கள் restart policy-உடன் முரண்படுவதில்லை என்பதற்கும் இதே விதியே காரணம்.

StartLimitIntervalSec மற்றும் StartLimitBurst ஆகியவற்றை எங்கே சேர்க்க வேண்டும்?

அவற்றை [Unit] பிரிவில் சேர்க்க வேண்டும். பழைய ஆவணங்கள் மற்றும் பழைய systemd பதிப்புகள் அவற்றை [Service] பிரிவில் வைத்திருந்தன, எனவே நகலெடுக்கப்பட்ட உதாரணங்கள் முரண்படலாம். உங்கள் பதிப்பு எதை ஏற்கும் என்று யூகிக்க வேண்டாம். systemctl daemon-reload-க்கு பிறகு, systemctl show -p StartLimitBurst -p StartLimitIntervalUSec myapp.service மூலம் systemd எதை load செய்தது என்று சரிபார்க்கவும். அந்த எண்களையே உண்மையாகக் கருதவும். systemd-analyze verify /etc/systemd/system/myapp.service கட்டளை systemd-க்குத் தெரியாத keys-ஐக் கண்டறியும்; கோப்பு சுத்தமாக இருந்தால் அது எதையும் அச்சிடாது.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

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