SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

systemd చరిత్ర: అది ఎందుకు గెలిచింది?

SysV init చేయలేనివి, Upstart మరియు launchd ముందుగా ప్రయత్నించినవి, నాలుగేళ్లలో అన్ని distributions systemd వైపు ఎందుకు మారాయి, సరైన అభ్యంతరాలు ఏవో తెలుసుకోండి.

systemd ఎందుకు విజయం సాధించింది

systemd చరిత్రను SysV init చేయలేని రెండు విషయాలతో ప్రారంభించవచ్చు. SysV init (System V init; AT&T Unix నుంచి Linux స్వీకరించిన startup system) కు ఒక service దేనిపై ఆధారపడుతుందో వివరించే మార్గం లేదు. అది ప్రారంభమైన తర్వాత ఆ service కు చెందిన processes ఏవో తెలుసుకునే మార్గం కూడా లేదు. Shell script చేరుకోలేని kernel features ద్వారా systemd ఈ రెండు సమస్యలకు పరిష్కారం ఇచ్చింది: processes ను track చేయడానికి control groups, అలాగే సేవల క్రమాన్ని నిర్వహించడానికి ముందుగానే open చేసిన listening sockets. ఆ రెండు పరిష్కారాలు మిగతా userland అంతటా ఎలా విస్తరించాయన్నదే తరువాతి కథ. అభ్యంతరాలు అక్కడి నుంచే ప్రారంభమయ్యాయి. వాటిలో కొన్ని అభ్యంతరాలు సరైనవే.

SysV init వాస్తవంగా ఏం చేసింది

SysV వ్యవస్థలో PID 1 (process ID 1, kernel ప్రారంభించే మొదటి process) /etc/inittab ను చదివి, ఒక runlevel ను ఎంచుకుని, ఆ runlevel కు చెందిన scripts ను అమలు చేసేది. ఆ scripts /etc/init.d/ లో ఉండేవి. /etc/rc3.d/ లోని symbolic links ఏ scripts అమలవ్వాలి, ఏ క్రమంలో అమలవ్వాలి అన్నది నిర్ణయించేవి. అందువల్ల /etc/rc3.d/S20nginx /etc/init.d/nginx ను సూచిస్తూ, start argument తో పిలవబడేది.

#!/bin/sh
### BEGIN INIT INFO
# Provides:          nginx
# Required-Start:    $local_fs $remote_fs $network $syslog
# Required-Stop:     $local_fs $remote_fs $network $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
### END INIT INFO

case "$1" in
  start)
    start-stop-daemon --start --quiet --pidfile /run/nginx.pid \
      --exec /usr/sbin/nginx
    ;;
  stop)
    start-stop-daemon --stop --quiet --retry TERM/30/KILL/5 \
      --pidfile /run/nginx.pid
    ;;
esac

S20nginx లోని 20 ఒక స్థానం; అది dependency కాదు. ఈ script S19 తర్వాత, S21 ముందు అమలవుతుందని మాత్రమే అది చెబుతుంది. కారణం ఏమిటో అది చెప్పదు. అందువల్ల ఏదీ దీనిని తనిఖీ చేయలేదు. మానవుడు సురక్షితమని నిర్ణయించకుండా, సంబంధం లేని రెండు scripts ను ఒకేసారి సురక్షితంగా అమలు చేయడం కూడా సాధ్యం కాదు.

rc program ప్రతి script ను వరుసగా అమలు చేసి, అది exit అయ్యే వరకు వేచి ఉండేది. Network address కోసం ముప్పై seconds వేచి ఉండి ఒక script block అయితే, network ను ఎప్పుడూ ఉపయోగించని services తో సహా మొత్తం boot ముప్పై seconds పాటు ఆగిపోయేది.

ఆ script ప్రారంభంలో ఉన్న LSB (Linux Standard Base) header దీనిని అంతర్గతంగా పరిష్కరించే ప్రయత్నం. 2011లో Debian 6.0 insserv ను default గా చేసింది. అది ప్రతి script నుంచి Required-Start ను చదివి, ఒక graph ను నిర్మించి, symlinks కు మళ్లీ సంఖ్యలు కేటాయించేది. ఆ తర్వాత Debian startpar తో independent scripts ను ఒకేసారి అమలు చేయగలిగింది. ఇది కొంత సహాయపడింది, కానీ అసలు లోతైన సమస్యను పరిష్కరించలేదు. Dependency ఇప్పటికీ ఒక script exit అవడంపైనే ఆధారపడి ఉంది. S20nginx 0 ను తిరిగి ఇవ్వడం అంటే shell function తిరిగి వచ్చింది అని మాత్రమే. nginx connections ను స్వీకరిస్తోందని దాని అర్థం కాదు.

init script ఏదీ పరిష్కరించలేని ఐదు విషయాలు

  • సమాంతర ప్రారంభం. ఫైల్ పేర్ల ఆధారంగా చేసే క్రమం యంత్రంలోని ప్రతి సేవపై సంపూర్ణ క్రమాన్ని విధిస్తుంది. అందువల్ల boot సమయం అన్ని సేవల ప్రారంభ సమయాల మొత్తానికి సమానంగా ఉంటుంది.
  • సిద్ధంగా ఉండటం. Start script daemon ను fork చేసిన వెంటనే ముగుస్తుంది. Daemon అభ్యర్థనను అందించగలదా అనే దాని కోసం అది వేచి ఉండదు. అందువల్ల తరువాతి script తరచుగా చాలా ముందుగానే ప్రారంభమవుతుంది.
  • పర్యవేక్షణ. Daemon రెండుసార్లు fork అయి, దాని parent ముగుస్తుంది. దీంతో అది terminal నుండి వేరవుతుంది మరియు PID 1 కు reparent అవుతుంది. Child ముగిసిందని init చూస్తుంది. కానీ కొనసాగి నడుస్తున్న process తో నమ్మదగిన సంబంధం దానికి ఉండదు.
  • అవసరమైనప్పుడు ప్రారంభం. inetd (internet super-server) కు connection వచ్చినప్పుడు daemon ను ప్రారంభించగల సామర్థ్యం ఉండేది. కానీ అది స్వంత configuration file కలిగిన ప్రత్యేక వ్యవస్థ. Boot సమయంలో మిగిలిన సేవల ప్రారంభ క్రమంపై అది ఎలాంటి నియంత్రణ చూపేది కాదు.
  • వనరుల నియంత్రణ. ఒక సేవ వినియోగించగల memory పరిమాణాన్ని లేదా CPUలో దాని వాటాను init script పరిమితం చేయలేకపోయేది. ulimit ఒక process కు మాత్రమే వర్తించేది. nice scheduler ను మాత్రమే ప్రభావితం చేసేది. అందువల్ల సేవకు చెందిన అదుపు తప్పిన child, ఆ యంత్రంలోని ఇతర process లాగానే కనిపించేది.

రోజువారీ నిర్వహణలో ఎక్కువ సమస్య కలిగించినది supervision లోని లోటు. దీనికి పరిష్కారంగా PID file ఉపయోగించబడేది. Daemon తన process ID ని /run/nginx.pid లో రాసేది. Stop function ఆ file ను చదివేది. Daemon ను బలవంతంగా terminate చేస్తే file అలాగే మిగిలేది. తరువాత kernel అదే సంఖ్యను వేరే process కు కేటాయించేది. అప్పుడు start-stop-daemon --stop --pidfile ఆ సంఖ్యను ప్రస్తుతం కలిగి ఉన్న process కు signal పంపేది. పాత PID file వల్ల init script తప్పు process ను terminate చేస్తుంది.

socket సమస్యను ముందుగా launchd పరిష్కరించింది

Apple, Dave Zarzycki రచించిన launchd ను 2005లో Mac OS X 10.4లో విడుదల చేసింది. ఒకే process, init, rc, xinetd, crond మరియు watchdogd స్థానాలను భర్తీ చేసింది.

అనుసరించదగిన ఆలోచన socket activation. launchd ముందుగా ప్రతి listening socket ను సృష్టించి, తరువాత daemons ను ప్రారంభిస్తుంది. ఇంకా ప్రారంభం కాని daemon కు client కనెక్ట్ అయినప్పుడు connection refused రాదు. ఎందుకంటే daemon accept() ను call చేసే వరకు kernel ఆ connection ను సంబంధిత socket యొక్క backlog queueలో ఉంచుతుంది. రెండు daemons మధ్య క్రమాన్ని ఇకపై ఒక వ్యక్తి నిర్వచించాల్సిన అవసరం ఉండదు. ఆ socket దాన్ని నిర్వహిస్తుంది.

launchd, Mach IPC (inter-process communication)పై నిర్మించబడింది. ఇది Apple యొక్క XNU kernelకు చెందినది. దీనికి Linuxలో సమానమైన implementation లేదు. ఆ codeను port చేయడం ఎప్పుడూ వాస్తవికం కాదు. అయినప్పటికీ ఆ ఆలోచన వ్యాపించింది.

Upstartలో పని యూనిట్‌లుగా events

Scott James Remnant రూపొందించిన Canonical యొక్క Upstart, October 2006లో Ubuntu 6.10తో విడుదలైంది. Fedora 9 నుంచి Fedora 14 వరకు, అలాగే RHEL 6 మరియు Chrome OS కూడా దీనిని ఉపయోగించాయి. ఇది runlevel స్థానంలో eventను ప్రవేశపెట్టింది. ఏ events వచ్చినప్పుడు job ప్రారంభం కావాలి, ఆగాలి అనే విషయాన్ని job నిర్వచించేది.

# /etc/init/example.conf
start on filesystem and net-device-up IFACE!=lo
stop on runlevel [!2345]
respawn
respawn limit 10 5
exec /usr/local/bin/exampled

Jobల సంఖ్య పెరిగేకొద్దీ రెండు సమస్యలు కనిపించాయి. మొదటిది దిశకు సంబంధించినది. ఒక job “ఇది జరిగినప్పుడు నన్ను ప్రారంభించు” అని చెబుతుంది. అందువల్ల ఏది దేనిపై ఆధారపడుతుందో తెలిపే సమాచారం తప్పు fileలో ఉంటుంది. ఒక serviceకు తనకు అవసరమైనవి తెలిసి ఉండవచ్చు. కానీ వచ్చే సంవత్సరం దానిపై ఎవరు ఆధారపడతారో అది తెలుసుకోలదు. ఒక serviceను చేర్చడం కోసం ఇప్పటికే ఉన్న jobను సవరించి, అది కొత్త eventను ఉత్పత్తి చేసేలా చేయాల్సి వచ్చేది.

రెండవది tracking. Forking daemonను అనుసరించడానికి Upstart fork() callsను ptraceతో లెక్కించేది. దీన్ని expect fork లేదా expect daemonగా configure చేసేవారు. Forkల సంఖ్యను తప్పుగా అంచనా వేస్తే, ఇప్పటికే exit అయిన processను Upstart supervise చేస్తుంది లేదా ఇప్పటికే జరిగిన fork కోసం వేచి ఉంటుంది. Error లేకుండా initctl start hang అవడం దీని లక్షణం. దీనికి కారణాన్ని job file ద్వారా వివరించే మార్గం ఉండదు.

అదనంగా, Upstartకు contributors, Canonical యొక్క contributor agreementపై సంతకం చేయాలి. అది engineering లోపం కాదు. అయితే దాని వల్ల దానిపై పనిచేసిన వ్యక్తుల పరిధి ప్రభావితమైంది.

PID 1 గురించి పునరాలోచన, April 2010

30 April 2010న Lennart Poettering "Rethinking PID 1" అనే post ను ప్రచురించారు. Kay Sievers ఆయనతో కలిసి ఈ project పై పనిచేశారు. ఆ వాదనలో నాలుగు భాగాలు ఉన్నాయి.

  • తక్కువగా ప్రారంభించండి. ఏదైనా సేవను నిజంగా కోరే వరకు అనేక services వేచి ఉండవచ్చు.
  • socket ద్వారా క్రమం స్పష్టమయ్యే చోట ప్రత్యేకంగా క్రమాన్ని ప్రకటించవద్దు. అన్ని sockets ను ఒకే pass లో open చేసి, తరువాత అన్నింటినీ ఒకేసారి ప్రారంభించండి.
  • PID files కు బదులుగా control groups తో processes ను track చేయండి.
  • ఒక service ను declarative file లో వివరించండి. అప్పుడు ఒకే description ప్రతి distribution లో పనిచేస్తుంది.

ఆ సంవత్సరం మొదటి release వచ్చింది. Fedora 14, November 2010లో systemd ను ఒక option గా విడుదల చేసింది. Fedora 15, May 2011లో దాన్ని default గా చేసింది.

పర్యవేక్షణను cgroups ఎలా విశ్వసనీయంగా మార్చాయి

cgroup (control group) అనేది processes ను సమూహాలుగా నిర్వహించే kernel feature. ఇది 2008లో Linux 2.6.24లో చేర్చబడింది. systemd ప్రతి service ను దాని స్వంత cgroupలో ఉంచుతుంది. ఒక child, దాని parent యొక్క cgroupను వారసత్వంగా పొందుతుంది. unprivileged process తాను ఉన్న cgroup నుంచి బయటకు తనను తాను తరలించుకోలేరు. అందువల్ల double forking ఏదీ దాచదు. PID 1 ప్రతి unitకు చెందిన processes యొక్క ఖచ్చితమైన సమూహాన్ని ఎల్లప్పుడూ నిర్వహిస్తుంది. ఒక serviceను ఆపడం అంటే దాని cgroupలోని ప్రతిదానినీ kill చేయడం. Default KillMode=control-group అదే చేస్తుంది.

systemctl status ఆ groupను చూపిస్తుంది:

● nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Tue 2026-08-11 09:14:22 UTC; 3min ago
   Main PID: 1042 (nginx)
      Tasks: 3 (limit: 4653)
     Memory: 6.1M (peak: 7.4M)
     CGroup: /system.slice/nginx.service
             ├─1042 "nginx: master process /usr/sbin/nginx"
             ├─1043 "nginx: worker process"
             └─1044 "nginx: worker process"

stale PID file సమస్యకు పూర్తి సమాధానం ఇదే. ఆ file stale అయ్యే అవకాశం లేదు, ఎందుకంటే ఈ జాబితా kernel state ఆధారంగా ఉంటుంది.

అదే tree limits ను కూడా నిర్వహిస్తుంది. ఎందుకంటే cgroupsను process tracking కోసం ఉపయోగించకముందే accounting కోసం రూపొందించారు. MemoryMax=, CPUQuota= మరియు TasksMax= ఒక్కొక్కటి ఒక్క line మాత్రమే. ఒక serviceకు hard memory మరియు CPU cap అమర్చడం ఒక serviceపై hard memory మరియు CPU cap అమర్చడం ప్రస్తుతం drop-in file ద్వారా చేయవచ్చు. 2009లో అదే పని ఎవరూ రాయని shell scriptకు patchగా ఉండేది.

2011 మరియు 2015 మధ్య ప్రతి డిస్ట్రిబ్యూషన్ ఎందుకు మారింది

  • Fedora 15, మే 2011.
  • openSUSE 12.1, నవంబర్ 2011.
  • Mageia 2, మే 2012.
  • Arch Linux, అక్టోబర్ 2012 నుండి కొత్త ఇన్‌స్టాలేషన్‌లకు డిఫాల్ట్.
  • RHEL 7, జూన్ 2014.
  • SLES 12, అక్టోబర్ 2014.
  • Debian 8, ఏప్రిల్ 2015.
  • Ubuntu 15.04, ఏప్రిల్ 2015.

RHEL 7 తేదీ మిగిలిన వాటి కంటే ఎక్కువ ప్రభావం చూపింది, ఎందుకంటే CentOS 7 దీనిని పునర్నిర్మించింది. అక్కడే చాలా మంది అడ్మినిస్ట్రేటర్లు మొదటిసారిగా unit file ను చూశారు. ఇది Red Hat Linux నుండి CentOS మీదుగా Rocky మరియు AlmaLinux వరకు సాగే సుదీర్ఘ కథలో ఒక మలుపు.

దీనికి కారణాలు చాలా వరకు సాధారణమైనవి, అందుకే ఈ మార్పు వేగంగా జరిగింది.

  • ఒక unit file ప్రతి డిస్ట్రిబ్యూషన్‌లో పనిచేస్తుంది, కాబట్టి అప్‌స్ట్రీమ్ ప్రాజెక్ట్‌లు .service ఫైల్‌ను అందించడం ప్రారంభించాయి. దీనితో ప్రతి ప్యాకేజీకి, ప్రతి రిలీజ్‌కు ఒక షెల్ స్క్రిప్ట్‌ను నిర్వహించాల్సిన అవసరం డిస్ట్రిబ్యూషన్‌లకు తప్పింది.
  • 2012 ప్రాంతంలో ConsoleKit నిర్వహణ ఆగిపోవడంతో, డెస్క్‌టాప్ సెషన్ ట్రాకింగ్ systemd-logind కి మారింది. GNOME కు logind అవసరం, కాబట్టి systemd లేని డిస్ట్రిబ్యూషన్ ఒక ప్రత్యామ్నాయాన్ని వెతకాల్సి వచ్చింది. ఆ ప్రత్యామ్నాయం, elogind, systemd యొక్క logind ను విడిగా తీసి నిర్వహించబడింది.
  • డివైజ్ మేనేజర్ అయిన udev, ఏప్రిల్ 2012లో systemd సోర్స్ ట్రీలో విలీనం చేయబడింది. udev ను అందించే డిస్ట్రిబ్యూషన్‌లు అప్పటి నుండి systemd రిపోజిటరీని అనుసరించడం ప్రారంభించాయి. దీనికి ప్రతిస్పందనగా Gentoo eudev ను ఫోర్క్ చేసింది.
  • కంటైనర్లు నమ్మదగిన ప్రాసెస్ ట్రాకింగ్ మరియు ప్రతి-సేవ పరిమితులను (per-service limits) ముఖ్యమైనవిగా మార్చాయి, ఎందుకంటే ఇవి రెండూ cgroup ఫీచర్లు. మీరు Docker Compose స్టాక్‌ను రీబూట్ తర్వాత తిరిగి ప్రారంభించినప్పుడు, కంటైనర్ ప్రాసెస్‌ను ఏ సూపర్వైజర్ నియంత్రిస్తుందనే ప్రశ్న ఇప్పటికీ ప్రాధాన్యత కలిగి ఉంది.

Debian తీసుకున్న నిర్ణయం పెద్ద చర్చకు దారితీసింది. ఫిబ్రవరి 2014లో టెక్నికల్ కమిటీ ఓటింగ్ నిర్వహించింది, ఓట్లు సమానంగా రావడంతో చైర్ Bdale Garbee systemd కి అనుకూలంగా నిర్ణయాత్మక ఓటు వేశారు. కొన్ని రోజుల తర్వాత, Upstart తో కొనసాగకుండా Debian ను అనుసరిస్తామని Ubuntu ప్రకటించింది. నవంబర్ 2014లో Debian డెవలపర్ల బృందం Devuan పేరుతో డిస్ట్రిబ్యూషన్‌ను ఫోర్క్ చేసి, మే 2017లో Devuan 1.0 ను విడుదల చేసింది.

అభ్యంతరాలు, నిష్పక్షపాతంగా చెప్పాలంటే

పరిధి. ఒక ప్రాజెక్ట్ ఇప్పుడు PID 1, లాగింగ్ డెమోన్, లాగిన్ సెషన్ మేనేజ్‌మెంట్, డివైజ్ మేనేజర్, నెట్‌వర్క్ కాన్ఫిగరేషన్ డెమోన్, DNS (డొమైన్ నేమ్ సిస్టమ్) రిజాల్వర్, NTP (నెట్‌వర్క్ టైమ్ ప్రోటోకాల్) క్లయింట్, కంటైనర్ రన్నర్ మరియు బూట్ లోడర్‌లను అందిస్తోంది. ఇవి విడివిడి బైనరీలు కాబట్టి మీరు అన్నింటినీ ఇన్‌స్టాల్ చేయనవసరం లేదు అనే సాధారణ వాదన నిజమే, కానీ అది అభ్యంతరానికి సమాధానం కాదు. ఒక డెస్క్‌టాప్‌కు logind అవసరమైనప్పుడు, మరియు logind ను systemd ట్రీ నుండి విడదీసినప్పుడు, ఎంపిక స్వేచ్ఛగా ఉండదు. వాదనలో 'కప్లింగ్' (coupling) అంటే ఇదే, మరియు అది జరిగింది.

బైనరీ జర్నల్. journald సాధారణ టెక్స్ట్‌కు బదులుగా ఇండెక్స్ చేయబడిన బైనరీ ఫార్మాట్‌లో లాగ్‌లను రాస్తుంది. టెక్స్ట్ ఫైల్స్ అందించలేని ప్రయోజనాలు ఇందులో ఉన్నాయి: ప్రతి యూనిట్ మరియు ప్రతి ప్రాధాన్యత ఆధారంగా ఫిల్టరింగ్, స్ట్రక్చర్డ్ ఫీల్డ్స్, మరియు పంపే ప్రోగ్రామ్ మార్చలేని మెటాడేటా. ఎందుకంటే journald యూనిట్ మరియు cgroup వివరాలను స్వయంగా నమోదు చేస్తుంది. journalctl -u nginx -p err --since "-1h" అనేది తేదీ రెగ్యులర్ ఎక్స్‌ప్రెషన్‌తో grep చేసే పద్ధతిని భర్తీ చేస్తుంది. దీనికి కొంత ధర చెల్లించాల్సి ఉంటుంది. బూట్ కాని మెషీన్‌లో, మీరు రెస్క్యూ షెల్ నుండి less తో లాగ్‌ను చదవలేరు. దానికి బదులుగా, మౌంట్ చేసిన డిస్క్ వైపు journalctl ను ఇలా మళ్లించాలి:

sudo journalctl --directory /mnt/var/log/journal --boot -1 --priority err

ఇక్కడ ప్రజలను ఒకసారి ఇబ్బంది పెట్టే రెండవ సమస్య ఉంది. /var/log/journal లేకపోతే, journald లాగ్‌లను /run/log/journal లో, అంటే మెమరీలో ఉంచుతుంది. అది లేని బాక్స్‌లో, రీబూట్ తర్వాత journalctl -b -1 లో చూపించడానికి ఏమీ ఉండదు, సరిగ్గా అదే సమయంలో మీకు లాగ్ అవసరమవుతుంది. దీన్ని తనిఖీ చేసి సరిచేయండి:

journalctl --disk-usage
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald

journalctl --disk-usage ఇప్పుడు /var/log/journal కింద ఆర్కైవ్ చేసిన జర్నల్స్‌ను చూపించాలి. మీకు సాధారణ టెక్స్ట్ కూడా కావాలంటే, /etc/systemd/journald.conf లో ForwardToSyslog=yes ను సెట్ చేసి, rsyslog ను ఇన్‌స్టాల్ చేసి ఉంచండి.

బూట్ డీబగ్గింగ్. ఒక యూనిట్ హ్యాంగ్ అయినప్పుడు, కన్సోల్ ఒక లైన్ మాత్రమే చూపిస్తుంది:

[  *** ] A start job is running for Wait for Network to be Configured (1min 32s / no limit)

దీనిని అధిగమించడానికి సాధనాలు ఉన్నాయి: అది ఆగిపోయినప్పుడు systemctl list-jobs, ఆ తర్వాత systemd-analyze blame మరియు systemd-analyze critical-chain, మరియు కెర్నల్ కమాండ్ లైన్‌లో systemd.log_level=debug. ఈ ఫిర్యాదులో ఉన్న న్యాయమైన అంశం ఏమిటంటే, sh తెలిసిన ఎవరైనా ఒక init స్క్రిప్ట్‌ను పై నుండి కిందకు చదవగలరు, కానీ ఆగిపోయిన యూనిట్ కోసం డజను కమాండ్లలో దేనిని వాడాలో తెలియాలి. ఇది నిజమైన భారం. ఇది ప్రతి అడ్మినిస్ట్రేటర్ ఒకసారి భరించాల్సి ఉంటుంది, మరియు చాలా మంది అడ్మినిస్ట్రేటర్లు దీన్ని ఒకే సమయంలో భరించారు.

అందరికీ మారే డిఫాల్ట్. 2016లో systemd 230, logind యొక్క డిఫాల్ట్‌ను మార్చింది, దీనివల్ల లాగౌట్ అయినప్పుడు మిగిలిపోయిన యూజర్ ప్రాసెస్‌లు ముగిసిపోతాయి. డిటాచ్ అయిన tmux మరియు screen సెషన్లు, వాటిని ప్రారంభించిన సెషన్ ముగియగానే అంతమైపోయాయి. డిస్ట్రిబ్యూషన్లు /etc/systemd/logind.conf లో KillUserProcesses=no ను అందించాయి, మరియు దీనికి మద్దతు ఇచ్చే సమాధానం loginctl enable-linger <user>. ఒక ప్రాజెక్ట్‌లోని ఒక డిఫాల్ట్ మార్పు మిలియన్ల మంది ప్రజలు అలవాటు చేసుకున్న పద్ధతిని మార్చేసింది, ఆచరణలో "యూజర్‌ల్యాండ్‌లో ఒకే చోట మరీ ఎక్కువ ఉండటం" అంటే ఇదే.

డిఫాల్ట్ డిపెండెన్సీ ఒక సెక్యూరిటీ సర్ఫేస్. మార్చి 2024లో xz-utils లోని బ్యాక్‌డోర్ Debian మరియు Fedora లోని sshd ను లక్ష్యంగా చేసుకుంది. అది పట్టుబడకముందే Debian testing, unstable మరియు Fedora డెవలప్‌మెంట్ రిలీజ్‌లకు చేరుకుంది; ఏ Debian stable రిలీజ్ కూడా దీన్ని కలిగి లేదు, మరియు Ubuntu సెక్యూరిటీ ట్రాకర్ విడుదలైన ప్రతి Ubuntu వెర్షన్ ప్రభావితం కాలేదని పేర్కొంది, ఎందుకంటే ఆ బ్యాక్‌డోర్ ఉన్న ప్యాకేజీ 24.04 proposed పాకెట్ దాటి బయటకు రాలేదు. అప్‌స్ట్రీమ్ OpenSSH, libsystemd తో లింక్ అవ్వదు. ఆ డిస్ట్రిబ్యూషన్లు sshd సిద్ధంగా ఉందని systemd కి తెలియజేయడానికి దాన్ని ప్యాచ్ చేశాయి, ఆ క్రమంలో libsystemd, liblzma ను తీసుకువచ్చింది, అక్కడే ఆ బ్యాక్‌డోర్ ఉంది. ఆ రెడీనెస్ ప్రోటోకాల్ అనేది $NOTIFY_SOCKET లో పేర్కొన్న సాకెట్‌కు పంపే ఒకే ఒక డేటాగ్రామ్, కాబట్టి దానికి ఎటువంటి లైబ్రరీ అవసరం లేదు. libsystemd ఇప్పుడు దాని కంప్రెషన్ లైబ్రరీలను dlopen తో లోడ్ చేస్తుంది, అంటే ఏదైనా ప్రోగ్రామ్ వాటి అవసరమున్న జర్నల్ APIని పిలిచినప్పుడు మాత్రమే, కాబట్టి అవి డిఫాల్ట్‌గా లింక్ అవ్వవు. ఈ పని బ్యాక్‌డోర్ వెలుగులోకి రాకముందే ప్రారంభమైందని ఒక systemd మెయింటైనర్ చెప్పారు. ఇలాంటిదే మరొక బగ్: 2017లో అంకెతో ప్రారంభమయ్యే User= విలువను చెల్లనిదిగా పరిగణించి, యూనిట్ ఫెయిల్ అవ్వడానికి బదులుగా root గా రన్ అయ్యింది, అంటే ఒక టైపో ప్రివిలేజ్ ఎస్కలేషన్‌గా మారింది. తర్వాతి వెర్షన్లు ఆ యూనిట్‌ను ప్రారంభించడానికి నిరాకరిస్తాయి.

మీ స్వంత systemctl ప్రాంప్ట్ వద్ద చరిత్ర

పైన పేర్కొన్న ప్రతి సమస్య ఇప్పుడు మీరు చదవగలిగే ఫైల్‌లోని ఒక డైరెక్టివ్ మాత్రమే.

  • సీరియల్ బూట్ అనేది After= మరియు Wants= గా మారింది, మరియు మీ బూట్‌ను వాస్తవానికి ఏది ఆపివేసిందో systemd-analyze critical-chain చూపుతుంది.
  • సర్వీస్ సిద్ధంగా ఉన్నప్పుడు READY=1 ను $NOTIFY_SOCKET కు రాసే Type=notify విధానం అందుబాటులోకి వచ్చింది. పాత డెమోన్‌ల కోసం PIDFile= తో కూడిన Type=forking ఇప్పటికీ ఉంది, మరియు PID ఫైల్ ఎప్పటికీ కనిపించనప్పుడు start operation timed out. Terminating. తో విఫలమయ్యే రకం ఇదే. తప్పు రకాన్ని ఎంచుకోవడం వల్లే, డెమోన్ ఇప్పటికే ఆగిపోయినా యూనిట్ మాత్రం active అని చూపిస్తుంది, కాబట్టి మీరు ఆ లైన్ రాయడానికి ముందు మీ డెమోన్ ప్రారంభమయ్యే విధానానికి ఏ Type= సరిపోతుందో తెలుసుకోవడం ముఖ్యం.
  • సూపర్‌విజన్ అనేది cgroup గా మారింది, కాబట్టి RestartSec= తో కూడిన Restart=on-failure ఒక వ్రాపర్ స్క్రిప్ట్‌ను భర్తీ చేస్తుంది, మరియు StartLimitBurst= ఒక క్రాష్ లూప్ నిరంతరం నడవకుండా ఆపుతుంది.
  • inetd అనేది .service యూనిట్ పక్కన ఉండే .socket యూనిట్‌గా మారింది.
  • ulimit అనేది MemoryMax=, CPUQuota= మరియు TasksMax= గా మారింది.
  • ఇనిట్ స్క్రిప్ట్‌లోని su - appuser -c లైన్ User=, NoNewPrivileges=yes మరియు ProtectSystem=strict గా మారింది, కాబట్టి అన్‌ప్రివిలేజ్డ్ యూజర్‌గా సర్వీస్‌ను రన్ చేయడం అనేది అదనపు పని కాకుండా, యూనిట్ యొక్క డిఫాల్ట్ రూపంగా మారింది.
[Unit]
Description=Example API
Wants=network-online.target
After=network-online.target postgresql.service
Requires=postgresql.service

[Service]
Type=notify
ExecStart=/usr/local/bin/exampled
Restart=on-failure
RestartSec=2
MemoryMax=512M
CPUQuota=50%
TasksMax=128
User=exampled
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
StateDirectory=exampled

[Install]
WantedBy=multi-user.target

ఆ ఫైల్‌లోని ఒక లైన్ ప్రతి ఒక్కరూ చేసే పొరపాటు. Requires=postgresql.service అనేది ఒక అవసరం, ఆర్డరింగ్ కాదు: Postgres విఫలమైతే మీ యూనిట్ విఫలమవుతుందని ఇది చెబుతుంది, కానీ Postgres ను ముందుగా ప్రారంభించమని ఇది చెప్పదు. After=postgresql.service లేకుండా రెండూ ఒకే సమయంలో ప్రారంభమవుతాయి, మరియు ఏదీ ఇంకా వినని (listening) పోర్ట్‌కు మీ సర్వీస్ కనెక్ట్ అవ్వడానికి ప్రయత్నిస్తుంది. ఈ రెండూ ఉద్దేశపూర్వకంగానే వేరు చేయబడ్డాయి, ఎందుకంటే కొన్నిసార్లు మీకు ఒకటి ఉండి మరొకటి లేకపోయినా పర్వాలేదు. ProtectSystem=strict ఈ సర్వీస్ కోసం ఫైల్ సిస్టమ్‌ను read-only గా మౌంట్ చేస్తుంది, అందుకే StateDirectory= అక్కడ ఉంది: ఇది సర్వీస్‌కు /var/lib కింద ఒక writable పాత్‌ను ఇస్తుంది.

2026 సర్వర్‌పై 2005 నాటి పద్ధతిని చూడటానికి స్పష్టమైన ఉదాహరణ Ubuntu 24.04 లోని SSH, ఇది అక్టోబర్ 2026 నాటికి systemd 255 ను కలిగి ఉంది. ssh.service డిఫాల్ట్‌గా సాకెట్ యాక్టివేట్ చేయబడుతుంది: ssh.socket లిజనింగ్ సాకెట్‌ను కలిగి ఉంటుంది, మరియు కనెక్షన్ వచ్చినప్పుడు sshd ప్రారంభమవుతుంది. /etc/ssh/sshd_config లోని Port 2222 ఇప్పటికీ పనిచేస్తుంది, కానీ అది పాత పద్ధతిలో కాదు. పోర్ట్‌ను తెరిచే ప్రాసెస్ sshd కాదు, కాబట్టి ఒక systemd జనరేటర్ sshd కాన్ఫిగరేషన్ నుండి పోర్ట్ మరియు అడ్రస్ సెట్టింగ్‌లను చదివి, ssh.socket కోసం సరిపోలే ListenStream= లైన్లను రాస్తుంది. systemd తన కాన్ఫిగరేషన్‌ను రీలోడ్ చేసినప్పుడు జనరేటర్లు రన్ అవుతాయి, ఇదే చాలామంది మర్చిపోయే దశ: కేవలం ssh.service ను రీస్టార్ట్ చేయడం వల్ల సాకెట్ పాత పోర్ట్ వద్దే ఉండిపోతుంది.

echo 'Port 2222' | sudo tee /etc/ssh/sshd_config.d/port.conf

ఆ తర్వాత అప్లై చేసి చెక్ చేయండి, ఈ మొత్తం సమయంలో రెండవ SSH సెషన్‌ను ఓపెన్‌గా ఉంచండి:

sudo systemctl daemon-reload
sudo systemctl restart ssh.socket
sudo ss -lntp | grep 2222

ss అనేది sshd ద్వారా కాకుండా, systemd యాజమాన్యంలోని పోర్ట్ 2222 వద్ద ఒక సాకెట్‌ను చూపాలి. ఇరవై ఏళ్ల తర్వాత, మీ VPS లో ఉన్న launchd డిజైన్ ఇదే. Ubuntu 22.10 నుండి 23.10 వరకు, పోర్ట్ /etc/systemd/system/ssh.socket.d/ కింద చేతితో రాసిన డ్రాప్-ఇన్ ఫైల్‌లో ఉండేది, కొత్త లైన్‌కు ముందు ఖాళీ ListenStream= లైన్ ఉండేది, ఎందుకంటే systemd ఒక జాబితాను భర్తీ చేయడానికి బదులుగా దానికి అదనంగా చేరుస్తుంది. మీరు పాత పద్ధతినే ఇష్టపడితే, Canonical డాక్యుమెంట్ చేసిన మార్గం ఇది:

sudo systemctl disable --now ssh.socket
sudo rm -f /etc/systemd/system/ssh.service.d/00-socket.conf
sudo rm -f /etc/systemd/system/ssh.socket.d/addresses.conf
sudo systemctl daemon-reload
sudo systemctl enable --now ssh.service

ఇది మీకు ఎక్కువ కాలం నడిచే sshd ని ఇస్తుంది, ఇది Port లో పేర్కొన్న పోర్ట్‌ను స్వయంగా తెరుస్తుంది.

ఈ వివరాలలో మీరు దేనిని ఎదుర్కొంటారు అనేది మీరు రన్ చేసే రిలీజ్‌పై ఆధారపడి ఉంటుంది, కాబట్టి అప్‌గ్రేడ్ ప్లాన్ చేయడానికి ముందు LTS మరియు ఇంటెరిమ్ Ubuntu రిలీజ్ మధ్య వ్యత్యాసాన్ని తెలుసుకోవడం ముఖ్యం. ఒకటి కంటే ఎక్కువ మెషీన్‌లలో, యూనిట్ ఫైల్ ప్రతిచోటా ఒకేలా ఉండటం వల్లే ఒకే చోట నుండి అనేక సర్వర్లను నిర్వహించడం అనేది ఇప్పుడు షెల్ స్క్రిప్టింగ్ సమస్య కాకుండా, కాన్ఫిగరేషన్ సమస్యగా మారింది. మరియు మీరు మీ స్వంత యూనిట్లను రాసేటప్పుడు, సర్వీస్ మరియు టైమర్ జత అనేది 2009లో మీరు ఇనిట్ స్క్రిప్ట్ మరియు క్రోన్ లైన్ మధ్య విభజించిన పనిని పూర్తి చేస్తుంది.

FAQ

Linux distributions SysV init ను systemd తో ఎందుకు భర్తీ చేశాయి?

దీనికి రెండు engineering కారణాలు మరియు ఒక maintenance కారణం ఉన్నాయి. SysV init సేవలను filename ఆధారంగా క్రమబద్ధం చేసేది. అది dependency కాకుండా ఒక స్థానం మాత్రమే. Parent నుంచి fork అయి విడిపోయిన daemon గురించి కూడా అది track చేయలేకపోయేది. అందుకే stale PID files తప్పు process ను terminate చేయగలిగేవి. systemd socket activation మరియు dependency directives ద్వారా ordering సమస్యను పరిష్కరించింది. Control groups ద్వారా process tracking సమస్యను పరిష్కరించింది. Maintenance కారణం మార్పు వేగాన్ని నిర్ణయించింది: ప్రతి distribution లో ఒకే unit file పనిచేస్తుంది. అందువల్ల upstream projects ఒక .service file ను విడుదల చేశాయి. Distribution maintainers ప్రతి package కోసం ప్రత్యేక shell script రాయడం ఆపేశారు. Fedora 15 May 2011లో మారింది. Ubuntu 15.04 April 2015లో మారిన చివరి పెద్ద distribution.

systemd ఒకే పెద్ద binaryనా?

కాదు. Source tree అనేక ప్రత్యేక programs ను build చేస్తుంది. PID 1 అనేది /usr/lib/systemd/systemd. journald, logind మరియు udevd తమ స్వంత binaries కలిగిన వేర్వేరు processes. మీ systemలో వాటిని చూడటానికి ls /usr/lib/systemd/ ను run చేయండి. మిగిలి ఉన్న విమర్శ binary size గురించి కాదు; release coupling గురించి. ఈ programs ఒకేసారి విడుదలవుతాయి మరియు private interfaces ను పంచుకుంటాయి. అందువల్ల distributions సాధారణంగా వాటిని ఒక setగా స్వీకరిస్తాయి. GNOME వంటి software ప్రత్యేకంగా logind పై ఆధారపడటం ప్రారంభించింది.

systemd లేకుండా Linux ను ఇంకా run చేయవచ్చా?

అవును. Devuan sysvinit ను ship చేస్తుంది. Gentoo కి OpenRC default. Void runit ను ఉపయోగిస్తుంది. Alpine OpenRCతో busybox init ను ఉపయోగిస్తుంది. Slackware BSD style scripts ను కొనసాగిస్తుంది. దీని ఖర్చు compatibility work. logind ను ఆశించే desktop software కు elogind అవసరం. ఇది standalone packageగా maintain చేయబడే systemd యొక్క logind. ప్రస్తుతం పెరుగుతున్న server softwareలో కేవలం .service file మాత్రమే ship అవుతోంది. అందువల్ల startup script ను మీరే రాసి maintain చేయాలి.

journal plain text file బదులుగా binaryగా ఎందుకు ఉంది?

journald indexed structured fields ను store చేస్తుంది. దీనివల్ల per-unit filtering, priority filtering మరియు sending program forge చేయలేని metadata లభిస్తాయి. Log line ను నమ్మకుండా journald స్వయంగా unit, cgroup మరియు real UID ను record చేస్తుంది. దీని ప్రతికూలత ఏమిటంటే చదవడానికి journalctl అవసరం. Rescue system నుంచి చదివేటప్పుడు కూడా ఇదే అవసరం. అక్కడ mounted disk ను journalctl --directory /mnt/var/log/journal తో చూపించాలి. Text format కూడా కావాలంటే /etc/systemd/journald.conf లో ForwardToSyslog=yes ను set చేయండి.

నా /etc/init.d script ను edit చేయడానికి బదులుగా ఏమి ఉపయోగించాలి?

Drop-in files ను ఉపయోగించాలి. /usr/lib/systemd/system/ లోని unit ను edit చేయకండి. Package upgrade దాన్ని overwrite చేస్తుంది. sudo systemctl edit nginx.service ను run చేయండి. అప్పుడు systemd /etc/systemd/system/nginx.service.d/override.conf ను సృష్టిస్తుంది. ఇది packaged unit పై merge అవుతుంది. Merge అయిన result ను systemctl cat nginx.service చూపిస్తుంది. Machineలోని అన్ని overrides ను systemd-delta list చేస్తుంది. చేతితో చేసిన ఏ edit తరువాత అయినా sudo systemctl daemon-reload ను run చేయండి. లేకపోతే తదుపరి command Warning: The unit file, source configuration file or drop-ins of nginx.service changed on disk. ను print చేస్తుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#systemd#linux#init#sysvinit#history