SSD Nodes Learn Hosting plans →

systemd service Type: simple, forking, notify விளக்கம்

உங்கள் systemd unit active என்று காட்டியும் daemon இயங்கவில்லையா? simple, forking, notify மற்றும் oneshot ஆகியவற்றுக்கு இடையே உள்ள வேறுபாடுகளை அறிந்து, சரியான main PID-ஐ கண்டறியவும்.

process செயலிழந்த பிறகும் systemd ஏன் ஒரு unit-ஐ active என்று காட்டுகிறது

இயல்பான ExitType=main மற்றும் RemainAfterExit=no அமைப்புகளுடன், systemd service unit-ஆனது, systemd எதை முதன்மை process (main process) என்று கருதுகிறதோ அது உயிருடன் இருக்கும் வரை active நிலையிலேயே இருக்கும். [Service] பிரிவில் உள்ள Type= என்பது எந்த process-ஐ கண்காணிக்க வேண்டும் என்பதைத் தீர்மானிக்கிறது. தவறான மதிப்பினைத் தேர்ந்தெடுத்தால், நீங்கள் கவனிக்க வேண்டிய daemon உள்ளே செயலிழந்தாலும், systemd ஒரு shell wrapper-ஐயோ அல்லது குறுகிய காலமே இயங்கும் parent process-ஐயோ கண்காணித்துக் கொண்டிருக்கும். அந்த unit, தான் கண்காணிக்கச் சொல்லப்பட்ட process-ஐப் பொறுத்தவரை உண்மையான தகவலையே உங்களுக்குத் தெரிவிக்கிறது.

Restart policy-ஐ மாற்றுவது இங்கு உதவாது. Restart= என்பது process வெளியேறுதல் மற்றும் timeout போன்ற தோல்விகளுக்கு மட்டுமே எதிர்வினையாற்றும். ஆனால், main PID (process identifier) இன்னும் இயங்கிக்கொண்டிருக்கும் ஒரு process-ஐச் சார்ந்திருக்கும்போது, பின்னணியில் இயங்கும் daemon வெளியேறுவதை இது கண்டறியாது. முதலில் Type=-ஐச் சரிசெய்யவும். main process உண்மையாகவே வெளியேறிய பிறகு systemd என்ன செய்ய வேண்டும் என்பது தனிப்பட்ட முடிவாகும்; இது Restart= மற்றும் RestartSec= குறித்த வழிகாட்டியில் விளக்கப்பட்டுள்ளது.

Type= எதனைத் தீர்மானிக்கிறது

ஒவ்வொரு Type= மதிப்பும் ஒரே நேரத்தில் இரண்டு கேள்விகளுக்குப் பதிலளிக்கிறது. systemd எப்போது இந்த unit தொடங்கப்பட்டதாகக் கருத வேண்டும், மற்றும் இதில் எது முதன்மையான process என்பதுதான் அவை.

முதல் பதில் வரிசைப்படுத்துதலை (ordering) கட்டுப்படுத்துகிறது. உங்கள் unit-ஐ After=-ல் குறிப்பிடும் ஒரு unit, systemd உங்கள் unit-ஐத் தொடங்கியதாக அறிவிக்கும் வரை காத்திருக்கும். மிக விரைவாக "started" என்று தெரிவிக்கும் ஒரு Type=, உங்கள் service தயாராகும் முன்பே அதைப் பொறுத்து இயங்கும் பிற unit-களைத் தொடங்கிவிடக்கூடும்.

இரண்டாவது பதில் கண்காணிப்பைக் (supervision) கட்டுப்படுத்துகிறது. ஒரு unit உருவாக்கும் ஒவ்வொரு process-ஐயும் systemd ஒரு cgroup-ல் (control group) வைக்கிறது. இது process-களை ஒன்றாகக் குழுவாக்கி, அவற்றைக் கட்டுப்படுத்தவும் ஒரே நேரத்தில் நிறுத்தவும் உதவும் ஒரு kernel வசதியாகும். systemctl stop எவ்வாறு cleanup செய்கிறது என்பதை இந்த cgroup தீர்மானிக்கிறது: KillMode= இயல்பாகவே control-group என்று இருப்பதால், ஒரு unit-ஐ நிறுத்தும்போது அதிலுள்ள அனைத்து process-களுக்கும் signal அனுப்பப்படும். Main PID என்பது இன்னும் குறுகிய வரம்பைக் கொண்டது. இயல்பான ExitType=main மற்றும் RemainAfterExit=no அமைப்புகளில், எந்த ஒரு process-ன் முடிவு unit-ன் செயல்பாட்டை முடிவுக்குக் கொண்டுவருகிறதோ, அதுவே main PID ஆகும்; அதன் exit status-தான் unit-ன் முடிவைத் தீர்மானிக்கும். cgroup-ஐ main PID என்று தவறாகப் புரிந்துகொள்வதே குழப்பங்களுக்குக் காரணமாகிறது.

Type=simple என்பது binary இயங்குவதற்கு முன்பே தொடங்கப்பட்டதாகக் காட்டுகிறது

Type=simple என்பது ExecStart= அமைக்கப்படும்போது இயல்பாக இருக்கும் அமைப்பாகும், அப்போது Type= அல்லது BusName= ஆகிய இரண்டும் இருக்காது, மேலும் அந்த unit எந்தவொரு credentials-ஐயும் பயன்படுத்தாது. உதாரணமாக LoadCredential= மூலம் credentials-ஐ ஏற்றிச் செயல்படும் ஒரு unit-க்கு, அதற்குப் பதிலாக Type=exec தானாகவே எடுத்துக்கொள்ளப்படும். simple-ன் கீழ், systemd அந்த process-ஐ உருவாக்கி, unit உடனடியாகத் தொடங்கிவிட்டதாகக் கருதி, அந்த process-ஐ முதன்மை PID-ஆகக் கையாளும். service binary இன்னும் செயல்படுத்தப்படுவதற்கு முன்பே, அடுத்தடுத்த unit-கள் உடனடியாகத் தொடங்கத் தொடங்கிவிடும்.

அந்தக் கடைசி விவரம் ஒரு பொதுவான ஆச்சரியத்தை விளக்குகிறது. ExecStart= பாதையில் உள்ள ஒரு தட்டச்சுப் பிழை (typo), வெற்றிகரமாகத் தொடங்கும் ஒரு பணியை (start job) உருவாக்கும், ஆனால் execution தோல்வியடையும் போது சிறிது நேரத்தில் பிழை ஏற்படும். systemd அந்தச் சூழலை exit code 203-உடன் பதிவு செய்யும், அதன் சொந்த அட்டவணை அதை EXIT_EXEC என்று பெயரிட்டு, உண்மையான process execution தோல்வியடைந்ததாக வரையறுக்கிறது. எனவே, systemctl start எந்தப் பிழையும் இன்றித் திரும்புவது, உங்கள் binary இருப்பதை உறுதிப்படுத்தாது.

முன்புறத்தில் (foreground) தங்கி, தன்னை ஒருபோதும் பின்புலத்திற்கு (background) மாற்றிக்கொள்ளாத நிரல்களுக்கு simple-ஐப் பயன்படுத்தவும். இது பெரும்பாலான நவீன daemons-களுக்கும், நீங்கள் சொந்தமாக எழுதும் எதற்கும் பொருந்தும்.

Type=exec என்பது நிரல் தொடங்கும் வரை காத்திருக்கிறது

Type=exec என்பது simple-ன் மேம்படுத்தப்பட்ட வடிவம். fork மற்றும் binary-ன் execution ஆகிய இரண்டும் வெற்றிகரமாக முடிந்த பின்னரே, அந்த unit தொடங்கிவிட்டதாக systemd கருதும். binary கோப்பு இல்லையென்றாலோ அல்லது User=-ஐத் தீர்க்க முடியாவிட்டாலோ, அது வெற்றிகரமாகத் தொடங்கிவிட்டுச் சிறிது நேரத்தில் செயலிழப்பதற்குப் பதிலாக, தொடக்க நிலையிலேயே (start job) தோல்வியடையும்.

Type=exec ஆனது systemd 240 பதிப்பில் அறிமுகமானது, ஆனால் பழைய பதிப்புகளிலும் விநியோகங்கள் (distributions) இதை backport செய்துள்ளன: RHEL 8 இதை systemd-239-15.el8-ல் சேர்த்தது. ஆதரவுள்ள பழைய பதிப்புகளில் இது இல்லாமல் இருக்கலாம்: Ubuntu 18.04 ஆனது ஏப்ரல் 2028 வரை ESM-ன் கீழ் உள்ளது, அதன் systemd 237 கையேட்டில் exec ஒரு supported type-ஆகக் குறிப்பிடப்படவில்லை. அக்டோபர் 2026 நிலவரப்படி, Ubuntu 24.04-ல் systemd 255-ம், Debian 13-ல் systemd 257-ம் உள்ளன. உங்கள் பதிப்பை systemctl --version மற்றும் அந்த விநியோகத்தின் systemd.service கையேடு மூலம் சரிபார்க்கவும்.

இதன் விலை, தொடக்கத்தில் ஒரு கூடுதல் synchronisation படி மட்டுமே. இதன் பயன், systemctl start-லிருந்து கிடைக்கும் துல்லியமான exit status ஆகும். foreground-ல் இயங்கும் நிரல்களுக்கு, simple-ஐ விட exec-ஐப் பயன்படுத்துவதே சிறந்தது.

Type=forking மற்றும் முதன்மை PID தொலைந்து போதல்

Type=forking என்பது, ExecStart=-ல் உள்ள process ஒரு child-ஐ உருவாக்கிவிட்டு, திட்டமிட்டபடி வெளியேறும் என்பதை systemd-க்கு உணர்த்துகிறது. அந்த முதல் process வெளியேறும் வரை systemd காத்திருந்து, அதன் பிறகே unit தொடங்கப்பட்டதாகக் கருதும். எஞ்சியிருக்கும் child-தான் daemon ஆகும். இந்த வழக்கம் SysV காலத்திலிருந்தே தொடர்கிறது; அப்போது init script முடிந்த பிறகு daemon-ஐக் கண்காணிக்க எதுவுமில்லை, PID file மட்டுமே இயங்கும் process-ஐக் குறிக்கும் ஒரே ஆதாரமாக இருந்தது. இந்த வரம்புதான் systemd ஏன் init scripts-க்கு மாற்றாக வந்தது என்பதன் மையக் காரணமாகும்.

இதில் உள்ள சிக்கல் அடையாளத்தைக் கண்டறிவதாகும். systemd தொடங்கிய process முடிந்துவிட்டதால், எஞ்சியிருப்பவற்றில் எது முதன்மையானது என்பதை அது கண்டறிய வேண்டும். PIDFile=-ஐ daemon எழுதும் கோப்பாக அமைக்கவும்; இது பொதுவாக /run-ன் கீழ் உள்ள ஒரு பாதையாக இருக்கும். அதிலிருந்து PID-ஐ systemd வாசிக்கும். அந்த file ஒரு சாதாரண பயனருக்குச் சொந்தமானதாக இருந்தால், அதில் உள்ள PID அந்த service-க்கு உரியதா என்பதையும் systemd சரிபார்க்கும். எனவே, தொடர்பில்லாத process-ஐக் குறிக்கும் பழைய அல்லது தவறான கோப்புகள் நிராகரிக்கப்படும்.

PIDFile= இல்லையெனில், GuessMainPID= பயன்படுத்தப்படும், இதன் default மதிப்பு yes ஆகும். service ஒரே ஒரு process-ஆகச் சுருங்கும் போது மட்டுமே இந்த ஊகம் நம்பகமானது. இதற்கான வரம்பை கையேடு தெளிவாகக் கூறுகிறது: daemon ஒன்றுக்கும் மேற்பட்ட process-களைக் கொண்டிருந்தால், இந்த ஊகம் தவறான முடிவுக்கு வரலாம். முதன்மை PID-ஐக் கண்டறிய முடியாவிட்டால், தோல்வியைக் கண்டறிதல் மற்றும் தானாகவே restart செய்தல் போன்றவை சரியாகச் செயல்படாது. ஒரு unit-ன் முதன்மை PID 0 என்று மாறக்கூடும்; அதாவது, daemon-ன் process-கள் cgroup-ல் இயங்கிக்கொண்டிருந்தாலும், systemd எந்த முதன்மை process-ஐயும் கண்காணிக்கவில்லை என்று அர்த்தம்.

fork செய்யும் பெரும்பாலான daemon-கள், அவற்றை foreground-ல் இயங்க வைக்கும் ஒரு switch-ஐக் கொண்டிருக்கும். அந்த switch-ஐ Type=exec-உடன் பயன்படுத்தவும், மேலும் PIDFile= வரியை நீக்கிவிடவும். குறைவான பாகங்கள் இருந்தால், PID தொலைந்து போவதற்கான வாய்ப்புகளும் குறையும்.

Type=oneshot என்பது முடிவடையும் பணிகளுக்கானது

Type=oneshot என்பது ஒரு process இயங்கி முடிவடையும் என்று எதிர்பார்க்கிறது. அந்த process முடிவடைந்த பின்னரே, அந்த unit தொடங்கப்பட்டதாக systemd கருதுகிறது. எனவே, மற்றொரு unit காத்திருக்க வேண்டிய எந்தவொரு பணிக்கும் oneshot சரியான அமைப்பாகும். ஒரு unit-ல் Type= மற்றும் ExecStart= ஆகிய இரண்டுமே குறிப்பிடப்படாதபோது, இதுவே இயல்பான (default) அமைப்பாகக் கருதப்படுகிறது.

oneshot-க்கு என்று இரண்டு தனித்துவமான செயல்பாடுகள் உள்ளன. ஒன்றுக்கு மேற்பட்ட ExecStart= வரிகளை அனுமதிக்கும் ஒரே வகை இதுவாகும், மேலும் அந்த வரிகள் வரிசைப்படி இயங்கும். இதன் start timeout இயல்பாகவே முடக்கப்பட்டிருக்கும், எனவே oneshot செயலிழந்தால், நீங்கள் நீங்களாகவே TimeoutStartSec=-ஐ அமைக்காவிட்டால் அது காலவரையின்றி காத்திருக்கும்.

Process முடிவடைந்த பிறகு, அந்த unit inactive நிலைக்குத் திரும்பும். RemainAfterExit=yes அந்த unit-ஐ எந்த process-ம் இயங்காத நிலையிலும் active ஆக வைத்திருக்கும். இந்தப் பக்கத்தின் தொடக்கத்தில் குறிப்பிடப்பட்ட அறிகுறியின் திட்டமிட்ட வடிவம் இதுவாகும். ஒரு unit-ன் பணி ஏதேனும் ஒன்றை இயங்க வைப்பதற்குப் பதிலாக, ஒரு நிலையை (state) உருவாக்கி விட்டுச் செல்வதாக இருக்கும்போது இது சரியானதாகும்: firewall ruleset-ஐ ஏற்றுவது அல்லது container stack-ஐத் தொடங்குவது போன்றவை. reboot-க்குப் பிறகு மீண்டும் வரும் Docker Compose stack-ன் பின்னணியில் உள்ள முறை இதுவே; இதில் unit ஆனது compose கட்டளையை இயக்கிவிட்டு வெளியேறுகிறது, ஆனால் அது தொடங்கிய containers தொடர்ந்து இயங்குவதால் அந்த unit active நிலையிலேயே நீடிக்கிறது. ஒரு oneshot unit ஆனது கால அட்டவணைப்படி (schedule) தூண்டப்படும் பணிகளுக்கும் ஏற்றது, இது cron-க்கு பதிலாக systemd timer மூலம் ஒரு பணியை இயக்குதல் என்பதன் மற்றொரு பகுதியாகும்.

Type=notify என்பது ஒரு service தயாராக இருக்கும்போது அதைத் தெரிவிக்க அனுமதிக்கிறது

Type=notify முடிவெடுக்கும் பொறுப்பை service-க்கே மாற்றுகிறது. service ஆனது READY=1 செய்தியை ஒரு Unix socket வழியாக அனுப்பும் வரை systemd அதன் start job-ஐத் திறந்து வைத்திருக்கும்; அந்த socket-ன் பாதை NOTIFY_SOCKET environment variable-ல் கிடைக்கும். இதற்கான C interface sd_notify(3) ஆகும், பல servers இதை ஏற்கனவே ஆதரிக்கின்றன.

"service தொடங்கப்பட்டதா" என்ற கேள்விக்கு இதுவே சரியான பதில். simple மற்றும் exec ஆகியவை service தனது configuration-ஐப் படிப்பதற்கு முன்போ அல்லது listening socket-ஐத் திறப்பதற்கு முன்போ "தொடங்கப்பட்டது" என்று தெரிவித்துவிடும். இதனால், அதைச் சார்ந்திருக்கும் unit மிக விரைவாகத் தொடங்கி, முதல் connection-ஐ ஏற்படுத்த முடியாமல் தோல்வியடையலாம். notify என்பது service தானாகவே தயாராக இருப்பதாகக் கூறும் தருணத்தில் "தொடங்கப்பட்டது" என்று தெரிவிக்கிறது.

systemd இந்தச் செய்தியை main process-லிருந்து மட்டுமே ஏற்கும், இதுவே NotifyAccess=main என்பதன் பொருள், மேலும் Type=notify இதை வலியுறுத்துகிறது. ஒரு child process அல்லது helper-லிருந்து செய்தி வந்தால், NotifyAccess=all-ஐ அமைக்கவும். ஒரு shell script systemd-notify --ready-ஐ அழைக்கலாம். அதற்குத் தேவையான உரிமைகள் இருக்கும்போது, systemd-notify செய்தியை அதன் parent-ன் PID-ன் கீழ் அனுப்பும். எனவே, script-ஏ main process-ஆக இருந்தால் NotifyAccess=main-ஐப் பயன்படுத்தவும்; இல்லையெனில் அது அதன் சொந்த PID-க்குத் திரும்பிவிடும், அப்போது அந்த unit-க்கு NotifyAccess=all தேவைப்படும். இயல்பாக, systemd செய்தியைச் செயலாக்கும் வரை அது காத்திருக்கும், எனவே --no-block-ஐத் தவிர்க்கவும், ஏனெனில் அது அந்த காத்திருப்பை நிறுத்திவிடும். இந்த protocol-ஐ நேரடியாகப் பயன்படுத்தும் service அதிக நம்பகத்தன்மை கொண்டது.

தொடர்புடைய இரண்டு அமைப்புகளைத் தெரிந்துகொள்வது பயனுள்ளது. Type=notify-reload, systemd 253 முதல் கிடைக்கிறது, இது இதே handshake-ஐ reload-களுக்கும் நீட்டிக்கிறது. எனவே, signal அனுப்பப்பட்டவுடன் திரும்புவதற்குப் பதிலாக, reload முடிந்துவிட்டதாக service தெரிவிக்கும்போது systemctl reload திரும்பும். செப்டம்பர் 2026-ல் வெளியான systemd 262 முதல், notify-reload service ஆனது READY=1-ஐ அனுப்பிவிட்டு, தனது reload signal-ஐ (ReloadSignal= வேறுவிதமாகக் கூறாதவரை SIGHUP) தடுக்கவோ அல்லது கையாளவோ தவறினால், அது முதல் reload-ல் signal மூலம் கொல்லப்படுவதற்குப் பதிலாக, protocol பிழையுடன் தொடங்கத் தவறிவிடும். WatchdogSec= ஒரு notifying service-ஐ குறிப்பிட்ட இடைவெளியில் keep-alive செய்தியை அனுப்பக் கோருகிறது, மேலும் அந்த காலக்கெடு தவறினால் systemd அதைத் தோல்வியாகக் கருதும்.

Type=dbus மற்றும் Type=idle

Type=dbus என்பது, system மற்றும் desktop services தங்களுக்குள் தொடர்புகொள்ளப் பயன்படுத்தும் D-Bus-ல், ஒரு service தனது பெயரைப் பதிவு செய்யும் வரை காத்திருக்கும். இதற்கு BusName= தேவைப்படுகிறது, மேலும் BusName= அமைக்கப்பட்டவுடன் இதுவே இயல்புநிலை (default) ஆகிவிடும். ஒரு service உண்மையாகவே bus name-ஐப் பதிவு செய்தால் மட்டுமே இதைப் பயன்படுத்தவும்.

Type=idle என்பது simple போலவே செயல்படும், ஆனால் வரிசையில் உள்ள பணிகள் (queued jobs) முடிவடையும் வரை இது நிரலை இயக்குவதைத் தாமதப்படுத்தும்; இதற்கு ஐந்து வினாடிகள் காலவரம்பு உண்டு. boot-ன் போது வெளியாகும் console தகவல்கள், status செய்திகளுடன் கலந்துவிடாமல் இருக்கவே இது உருவாக்கப்பட்டது. இது ஒரு வரிசைப்படுத்தும் கருவி (ordering tool) அல்ல, சாதாரண service-களுக்கு இதைப் பயன்படுத்தக்கூடாது.

wrapper script ஏன் systemd-ஐ தவறான PID-ல் நிறுத்துகிறது

இந்த அறிகுறிகளை உருவாக்கும் கட்டமைப்பு இதோ.

[Service]
Type=simple
ExecStart=/opt/app/run.sh
#!/bin/bash
export APP_ENV=production
/opt/app/bin/server --config /etc/app.yaml &
/opt/app/bin/exporter --port 9101

systemd, shell-ஐ முதன்மை PID-ஆகப் பதிவு செய்கிறது. exporter foreground-ல் இயங்கும்போது shell உயிர்ப்புடன் இருக்கும். server செயலிழந்தால், shell அதை கவனிக்காது; எனவே முதன்மை PID இன்னும் உயிர்ப்புடன் இருக்கும், unit இன்னும் active நிலையிலேயே இருக்கும், மேலும் Restart= செயல்படுவதற்கு ஏதுமில்லை. இரண்டு process-களும் unit-ன் cgroup-ல் தொடர்ந்து இருப்பதால், systemctl stop இன்னும் சரியாகவே cleanup செய்கிறது. மேற்பார்வை (supervision) மட்டுமே பாதிக்கப்பட்டுள்ளது, cleanup அல்ல.

இந்தச் சிக்கலைச் சரிசெய்வது, அந்த unit-ல் உண்மையில் எத்தனை நீண்டகால process-கள் இயங்குகின்றன என்பதைப் பொறுத்தது.

ஒரே ஒரு process இருந்தால், shell-க்கு பதிலாக அதை மாற்றவும்.

#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yaml

exec, shell-ஐ குறிப்பிட்ட நிரலால் (program) இடமாற்றம் செய்து அதே PID-ஐத் தக்கவைக்கும், எனவே systemd பதிவு செய்த PID இப்போது daemon-க்கு உரியதாகிவிடும். அதைவிடச் சிறந்தது, wrapper-ஐ நீக்குவதாகும். Environment= மற்றும் EnvironmentFile= மாறிகளை (variables) எடுத்துச் செல்லும், ExecStartPre= setup படியைக் கையாளும்; எனவே systemd நேரடியாக daemon-ஐத் தொடங்கி, அதன் PID-ஐ உருவாக்கத்தின்போதே தெரிந்துகொள்ள முடியும்.

இரண்டு process-கள் இருந்தால், எந்த ஒரு PID-ம் அந்த unit-ஐ முழுமையாகப் பிரதிநிதித்துவப்படுத்தாது. அவற்றை இரண்டு unit-களாகப் பிரித்து, After= மற்றும் Wants= மூலம் வரிசைப்படுத்தவும். ஒரு process-க்கு ஒரு unit என்ற அமைப்பையே systemd சிறப்பாக மேற்பார்வையிடும்; ஒவ்வொரு process-க்கும் தனித்தனி restart நடத்தை (behaviour) கிடைக்க இதுவே ஒரே வழியாகும்.

ExitType=cgroup மாற்றங்கள்

ExitType= ஆனது systemd 250 பதிப்பில் சேர்க்கப்பட்டது. இதன் இயல்புநிலை மதிப்பு main ஆகும்: முதன்மைச் செயல்முறை (main process) வெளியேறியவுடன், அந்த unit நிறுத்தப்பட்டதாகக் கருதப்படும். ExitType=cgroup அமைப்பைப் பயன்படுத்தினால், அதன் cgroup-ல் ஏதேனும் ஒரு செயல்முறை உயிருடன் இருக்கும் வரை அந்த unit இயங்கிக்கொண்டிருப்பதாகக் கருதப்படும்.

[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcher

இது ஒரு குறிப்பிட்ட சிக்கலைத் தீர்க்கிறது. உண்மையான பணியைத் தொடங்கிவிட்டு வெளியேறும் ஒரு launcher, ExitType=main அமைப்பின் கீழ் இயங்கும்போது, systemd அந்த unit-ஐ நிறுத்தப்பட்டதாகக் கருதி எஞ்சியிருக்கும் செயல்முறைகளைக் கொன்றுவிடும். ExitType=cgroup அமைப்பைப் பயன்படுத்தினால், அந்த unit முழு குழுவையும் கண்காணிக்கும்.

இது எதைத் தீர்க்காது என்பதில் தெளிவாக இருக்கவும். ExitType=cgroup அமைப்பானது, குறைந்தது ஒரு செயல்முறை இருக்கும் வரை unit-ஐச் செயல்பாட்டில் வைத்திருக்கும்; எனவே, இரண்டு daemons-ஐக் கொண்ட ஒரு unit-ல் ஒன்று இறந்தாலும் அது தொடர்ந்து இயங்கும். இது launcher சிக்கலை மட்டுமே சரிசெய்கிறது. இது ஒரு unit-ஐப் பல சுதந்திரமான செயல்முறைகளைக் கண்காணிக்கும் கருவியாக மாற்றாது. மேலும், ExitType=cgroup அமைப்பை Type=oneshot உடன் இணைக்க முடியாது.

வளக் கணக்கீடு (resource accounting) cgroup-ல் தான் நடைபெறுகிறது, எனவே Type= அமைப்பில் முதன்மை PID பற்றி என்ன சொல்லப்பட்டிருந்தாலும், MemoryMax= மற்றும் CPUQuota= போன்ற வரம்புகள் அந்த unit உருவாக்கிய ஒவ்வொரு செயல்முறைக்கும் பொருந்தும். இது குறித்த கூடுதல் தகவல்களை capping a service's memory and CPU with systemd பகுதியில் காணலாம்.

systemd உண்மையில் கண்காணிக்கும் process-ஐக் கண்டறிவது எப்படி

நீங்கள் பிழைத்திருத்தம் (debug) செய்யும் unit-ல் வரிசையாகச் செயல்படுங்கள். முதலில் unit கோப்புகளைப் படியுங்கள், பிறகு systemd எதைக் கண்காணிக்கிறது என்று பாருங்கள், இறுதியாக அதை process table-உடன் ஒப்பிடுங்கள்.

systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.service

systemctl cat கட்டளையானது, வட்டில் (disk) உள்ள அனைத்து drop-in கோப்புகளுடன் சேர்த்து unit கோப்பையும் அச்சிடும்; கோப்புகள் daemon-reload செய்யப்படாமல் மாற்றப்பட்டிருந்தால், இவை systemd ஏற்றிக் கொண்டவற்றிலிருந்து மாறுபடலாம். systemctl show கட்டளையானது, நீங்கள் குறிப்பிடாத defaults உட்பட, நடைமுறையில் உள்ள மதிப்புகளை அச்சிடும். அடுத்த கட்டத்திற்குச் செல்லும் முன் MainPID-ன் மதிப்பைக் குறித்துக் கொள்ளுங்கள்.

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 வரியானது, systemd கண்காணிக்கும் முதன்மை process-ஐ விவரிக்கும். இரண்டையும் சேர்த்துப் படியுங்கள். MainPID மதிப்பு 0 எனில், அந்த unit-ன் cgroup-ல் systemd-cgls மூலம் process-கள் பட்டியலிடப்பட்டாலும், systemd எந்த முதன்மை process-யையும் கண்காணிக்கவில்லை என்று அர்த்தம். cgroup-ல் உங்கள் daemon இருக்கும்போது MainPID ஒரு shell-ஐக் காட்டினால், அது மேலே குறிப்பிட்ட wrapper சூழலாகும். நீங்கள் எதிர்பார்த்ததை விட அதிகமான process-கள் cgroup-ல் இருந்தால், அங்கு ஒரு launcher அல்லது forking daemon செயல்படுகிறது என்று பொருள்.

systemctl status app.service
journalctl -u app.service -b

systemctl status கட்டளையானது, state வரியையும் cgroup மரத்தையும் ஒன்றாக அச்சிடும், எனவே இது பெரும்பாலும் இரண்டு கேள்விகளுக்கும் ஒரே நேரத்தில் பதிலளிக்கும். journalctl -u கட்டளையை -b உடன் சேர்த்துப் பயன்படுத்தினால், அந்த unit-க்காக systemd பதிவு செய்த start மற்றும் stop நிகழ்வுகளையும், அது கண்ட exit codes-களையும் காட்டும். daemon தனது log-ஐ journal-க்கு அனுப்பாமல் சொந்தமாக ஒரு கோப்பில் எழுதினால், அதையும் படியுங்கள்; ஏனெனில் systemd-க்குக் கிடைக்கும் தகவல்களை மட்டுமே அதனால் பதிவு செய்ய முடியும்.

நீங்கள் Type=-ஐ மாற்றும்போது, reload மற்றும் restart செய்யுங்கள்.

systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.service

systemd-analyze verify கட்டளையானது கோப்பைப் பகுப்பாய்வு செய்து, ஏற்க முடியாத அமைப்புகளைத் தெரிவிக்கும். daemon-reload கட்டளையானது, வட்டில் உள்ள unit கோப்புகளை மீண்டும் படிக்க systemd-ஐத் தூண்டும். மாற்றப்பட்ட Type= ஏற்கனவே இயங்கிக் கொண்டிருக்கும் unit-க்கு உடனடியாகப் பொருந்தாது, எனவே restart செய்வது கட்டாயமாகும், விருப்பத்தேர்வு அல்ல.

பிறகு மாற்றத்தைச் சோதிக்கவும். systemd-cgls மூலம் நீங்கள் கவனிக்க வேண்டிய process-ன் PID-ஐ எடுத்து அதை kill செய்யுங்கள். உடனே systemctl is-active app.service கட்டளையை இயக்கவும். ExitType=main மற்றும் RemainAfterExit=no ஆகியவற்றைப் பயன்படுத்தும்போது, முதன்மை process-ஐக் கொல்வது அந்த instance-ஐ முடிவுக்குக் கொண்டுவரும், இருப்பினும் restart policy நீங்கள் சரிபார்க்கும் முன்பே அதை மீண்டும் கொண்டு வரலாம். அது restart ஆகாமல் தொடர்ந்து இயங்கினால், systemd வேறு எதையாவது கண்காணிக்கிறதா அல்லது அந்த unit ExitType=cgroup அல்லது RemainAfterExit=yes-ஐப் பயன்படுத்துகிறதா என்று சரிபார்க்கவும்.

எந்த systemd service Type=-ஐ நீங்கள் பயன்படுத்த வேண்டும்

  • foreground-ல் இயங்கும் ஒரு program: Type=exec.
  • readiness notification-ஐ ஆதரிக்கும் ஒரு program: Type=notify, மேலும் reloads-ஐயும் உறுதிப்படுத்தினால் notify-reload.
  • background-க்குச் செல்ல விரும்பும் ஒரு daemon: PIDFile= உடன் Type=forking, அல்லது அதன் foreground switch-உடன் Type=exec.
  • வேலை செய்துவிட்டு வெளியேறும் ஒரு script: Type=oneshot, மேலும் state-ஐ அப்படியே விட்டுச் செல்வது நோக்கமாக இருந்தால் RemainAfterExit=yes.
  • அதன் children தொடர்ந்து இயங்கும்போது வெளியேறும் ஒரு launcher: ExitType=cgroup உடன் Type=simple.

ஒரு third party daemon-க்கு எது தேவை என்பதில் உங்களுக்கு உறுதியில்லை என்றால், முதலில் அதன் packaged unit file-ஐப் படிக்கவும். distribution வழங்கிய unit-ல் systemctl cat-ஐ இயக்குவது, உள்ளூர் மாற்றங்களுடன் (local overrides) சேர்த்து packaged Type= தேர்வைக் காட்டும்.

FAQ

process இறந்த பிறகும் எனது systemd unit ஏன் active நிலையில் உள்ளது?

இயல்புநிலை ExitType=main மற்றும் RemainAfterExit=no அமைப்புகளில், systemd முதன்மை process எனக் கருதும் process இன்னும் உயிருடன் இருப்பதால் இது நிகழ்கிறது. அந்த இயல்புநிலைகளின் கீழ், Type=-ன் படி தேர்ந்தெடுக்கப்பட்ட ஒரு முதன்மை PID-ஐ மட்டுமே systemd கவனிக்கிறது. Type=simple மூலம் தொடங்கப்பட்ட wrapper script பொதுவாக இதற்கு காரணமாகிறது: shell தான் முதன்மை PID-ஆக இருக்கும், எனவே shell பின்னணியில் இயக்கிய daemon வெளியேறிய பிறகும் unit active நிலையிலேயே இருக்கும். systemctl show -p MainPID app.service-ஐ இயக்கவும், பின் systemd-cgls --unit=app.service மூலம் அந்த unit-ன் cgroup-ஐ பட்டியலிட்டு இரண்டையும் ஒப்பிட்டுப் பார்க்கவும்.

Type=simple மற்றும் Type=exec ஆகியவற்றிற்கு இடையே உள்ள வேறுபாடு என்ன?

Type=simple, binary இயக்கப்படுவதற்கு முன்பே, systemd process-ஐ உருவாக்கியவுடன் unit தொடங்கிவிட்டதாகக் கருதுகிறது. எனவே, ExecStart=-ல் தவறான path இருந்தாலும், start job வெற்றிகரமாக முடிந்ததாகக் காட்டிவிட்டு, பின் தோல்வியடையும். Type=exec, execution வெற்றிகரமாக முடியும் வரை காத்திருக்கும், எனவே அந்தத் தோல்வி start job-லேயே தெரிவிக்கப்படும். இவை இரண்டுமே ஒரே process-ஐ முதன்மை PID-ஆகக் கருதுகின்றன. Type=exec, systemd 240-ல் அறிமுகப்படுத்தப்பட்டது, ஆனால் RHEL 8-ல் systemd-239-15.el8 செய்தது போல, பழைய பதிப்புகளுக்கு விநியோக நிறுவனங்கள் இதை backport செய்யலாம்.

Type=forking பயன்படுத்தும்போது எனக்கு இன்னும் PIDFile= தேவையா?

ஆம், daemon அதை உருவாக்கும் போதெல்லாம் தேவை. அது இல்லையென்றால், systemd GuessMainPID=-க்குத் திரும்பும்; இது ஒரு ஊகம் மட்டுமே, ஒரே ஒரு process-ஆக இயங்கும் service-களுக்கு மட்டுமே இது நம்பகமானது. அந்த ஊகம் தவறாகவோ அல்லது சாத்தியமற்றதாகவோ இருக்கும்போது, அந்த unit-க்கான தோல்வி கண்டறிதல் மற்றும் தானியங்கி மறுதொடக்கம் (automatic restarting) சரியாக வேலை செய்யாது. daemon எழுதும் சரியான path-ஐ PIDFile=-ல் குறிப்பிடவும், இது பொதுவாக /run-ன் கீழ் இருக்கும்.

RemainAfterExit=yes-ஐ நான் எப்போது பயன்படுத்த வேண்டும்?

ஒரு process-ஐத் தொடர்ந்து இயக்குவதை விட, system-ன் நிலையை மாற்றுவதே unit-ன் நோக்கமாக இருக்கும்போது இதைப் பயன்படுத்த வேண்டும். firewall விதிகளை ஏற்றும் அல்லது container stack-ஐத் தொடங்கும் ஒரு Type=oneshot unit, தனது வேலை முடிந்தவுடன் வெளியேறிவிடும். RemainAfterExit=yes இல்லையென்றால், unit starting நிலையிலிருந்து நேரடியாக stopping நிலைக்குச் சென்றுவிடும். இதனால், நீங்கள் unit-ஐ நிறுத்த விரும்பும் நேரத்திற்குப் பதிலாக, வேலை முடிந்த உடனேயே ExecStop= cleanup இயங்கிவிடும், மேலும் systemctl stop-ல் நிறுத்த எதுவுமே இருக்காது. இதைச் சேர்த்தால், process-கள் ஏதுமின்றி unit active நிலையில் இருக்கும், இதுவே இங்கு எதிர்பார்க்கப்படும் செயல்பாடு.

Type=-ஐ மாற்றினால் daemon-reload தேவையா?

ஆம், அத்துடன் அந்த unit-ஐ restart செய்வதும் அவசியம். systemctl daemon-reload, disk-ல் உள்ள unit கோப்புகளை systemd மீண்டும் படிக்கச் செய்யும், ஆனால் இயங்கிக்கொண்டிருக்கும் instance அது தொடங்கியபோது இருந்த Type=-ஐயே வைத்திருக்கும். சோதிப்பதற்கு முன் sudo systemctl daemon-reload-ஐ இயக்கி, பின் sudo systemctl restart app.service-ஐ இயக்கவும்; இல்லையெனில், நீங்கள் பழைய கண்காணிப்பு முறையையே கவனித்துக் கொண்டிருப்பீர்கள்.

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