VPSలో systemd సర్వీస్ ఎలా తయారు చేయాలి

systemd సర్వీస్ అంటే ఏమిటి, మరి దాని అవసరం ఎందుకు

systemd సర్వీస్ అనేది ఒక చిన్న టెక్స్ట్ ఫైల్. ఇది మీ సర్వర్‌కు ఒక ప్రోగ్రామ్‌ను ఎలా నడపాలో చెబుతుంది: బూట్ అయినప్పుడు ప్రారంభించడం, క్రాష్ అయితే రీస్టార్ట్ చేయడం, మరియు దాని అవుట్‌పుట్‌ను సిస్టమ్ లాగ్‌కు పంపడం. ఇది దాని పూర్తి పని. మీరు SSH సెషన్‌లో మాన్యువల్‌గా ప్రారంభించిన ప్రోగ్రామ్, మీరు లాగౌట్ అయినా లేదా సర్వర్ రీబూట్ అయినా వెంటనే ఆగిపోతుంది. systemd సర్వీస్‌లో అమలవుతున్న ప్రోగ్రామ్ నిరంతరం నడుస్తూనే ఉంటుంది, ఎందుకంటే మీ షెల్ కాకుండా సర్వర్ స్వయంగా దాన్ని నియంత్రిస్తుంది.

Ubuntu, Debian, Fedora మరియు చాలా ఆధునిక Linux సర్వర్‌లలో systemd అనేది init సిస్టమ్. ఇది మొదట ప్రారంభమయ్యే ప్రాసెస్ మరియు మిగతా అన్నింటినీ పర్యవేక్షించేది. మీరు సర్వీస్ ఫైల్ రాసినప్పుడు, మీ ప్రోగ్రామ్‌ను ఆ సూపర్‌వైజర్‌కు అప్పగిస్తారు. ఈ గైడ్ పనిచేసే అతి చిన్న యూనిట్‌ను, ప్రతి యూనిట్‌లో ఉండే మూడు విభాగాలను, దాన్ని ఆన్ చేసి దాని లాగ్‌లను చదవడం ఎలా, టైమర్‌తో షెడ్యూల్ ప్రకారం నడపడం ఎలా, మరియు అత్యల్ప అధికారంతో నడిపేలా దాన్ని లాక్ చేయడం ఎలా అనే విషయాలను వివరిస్తుంది.

పనిచేసే అతి చిన్న సర్వీస్

ఒక సర్వీస్ ఫైల్ /etc/systemd/system/ లో ఉంటుంది, .service తో ముగుస్తుంది, మరియు కేవలం కొన్ని లైన్లు మాత్రమే అవసరం. /usr/local/bin/myapp వద్ద ఉన్న ప్రోగ్రామ్ కోసం ఒకటి సృష్టించండి:

sudo nano /etc/systemd/system/myapp.service

[Unit]
Description=My application

[Service]
ExecStart=/usr/local/bin/myapp

[Install]
WantedBy=multi-user.target

అది ఒక పూర్తి, పనిచేసే యూనిట్. ExecStart అనేది నడిపే ఆదేశం. WantedBy=multi-user.target అంటే సర్వర్ సాధారణ మల్టీ-యూజర్ ఆపరేషన్‌కు చేరుకున్న తర్వాత దీన్ని ఒకసారి ప్రారంభించమని అర్థం, అదే బూట్ సమయంలో దీన్ని ప్రారంభిస్తుంది. మిగతా అన్నీ మెరుగుదలే.

మూడు విభాగాలు, మరియు ప్రతి ఒక్కటి దేనికి ఉపయోగపడుతుంది

ప్రతి యూనిట్ ఫైల్ చతురస్ర బ్రాకెట్‌లలో విభాగాలుగా విభజించబడి ఉంటుంది. ఒక సర్వీస్ మూడింటిని ఉపయోగిస్తుంది.

[Unit] సర్వీస్ మరియు దాని సంబంధాలను వివరిస్తుంది. మీరు ఎక్కువగా ఉపయోగించే రెండు పంక్తులు:

[Unit]
Description=My application
After=network-online.target
Wants=network-online.target

Description అనేది systemctl status లో మీరు చూసే మానవ లేబుల్. After=network-online.target అనేది నెట్‌వర్క్ పనిచేసే వరకు మీ ప్రోగ్రామ్‌ను ప్రారంభించవద్దని systemd‌కు చెబుతుంది. పోర్ట్‌ను బైండ్ చేసే లేదా అవుట్‌బౌండ్ కనెక్షన్‌ను చేసే దేనికైనా ఇది ముఖ్యం.

[Service] అనేది ప్రోగ్రామ్ ఎలా నడుస్తుందో తెలియజేస్తుంది. మీ సెట్టింగులలో ఎక్కువ భాగం ఇక్కడే ఉంటాయి:

[Service]
ExecStart=/usr/local/bin/myapp --config /etc/myapp/config.toml
WorkingDirectory=/opt/myapp
User=myapp
Restart=on-failure
RestartSec=5
Environment=LOG_LEVEL=info

User=myapp ప్రోగ్రామ్‌ను root బదులుగా ఒక అన్‌ప్రివిలేజ్డ్ అకౌంట్‌గా నడుపుతుంది. భద్రత కోసం ఇదే అత్యంత ముఖ్యమైన పంక్తి. Restart=on-failure మరియు RestartSec=5 కింద వాటికి ప్రత్యేక విభాగం ఉంది, ఎందుకంటే అవి చాలా మంది వ్యక్తులు సర్వీస్ వ్రాసే కారణం.

[Install] మీరు సర్వీస్‌ను ఎనేబుల్ చేసినప్పుడు ఏమి జరుగుతుందో తెలియజేస్తుంది:

[Install]
WantedBy=multi-user.target

WantedBy=multi-user.target మీరు systemctl enable నడిపినప్పుడు సర్వీస్‌ను బూట్‌లోకి లింక్ చేసేది. [Install] విభాగం లేకుండా ఒక సర్వీస్‌ను మానవులు ప్రారంభించగలరు, కానీ రీబూట్ తర్వాత అది స్వయంగా ప్రారంభించబడదు.

దాన్ని ఆన్ చేసి పరిశీలించండి

ఏ యూనిట్ ఫైల్‌ను వ్రాసిన లేదా సవరించిన తర్వాత, systemd మార్పును చదివేలా రీలోడ్ చేయండి. తర్వాత ఒకే దశలో సర్వీస్‌ను ఎనేబుల్ చేసి ప్రారంభించండి:

sudo systemctl daemon-reload
sudo systemctl enable --now myapp.service

daemon-reload అనేది ప్రజలు మర్చిపోయే దశ: systemd యూనిట్ ఫైళ్లను క్యాష్ చేస్తుంది, కాబట్టి మీరు రీలోడ్ చేసే వరకు సవరణ ఏమీ చేయదు. enable --now సర్వీస్‌ను బూట్ కోసం ఎనేబుల్ చేస్తుంది మరియు వెంటనే ప్రారంభిస్తుంది. దాన్ని తనిఖీ చేయండి:

sudo systemctl status myapp.service

* myapp.service - My application
     Loaded: loaded (/etc/systemd/system/myapp.service; enabled)
     Active: active (running) since Wed 2026-07-15 22:40:11 UTC; 3s ago
   Main PID: 4123 (myapp)

Active: active (running) మరియు enabled మీకు కావలసినవి. ప్రోగ్రామ్ అవుట్‌పుట్‌ను చదవడానికి, జర్నల్‌ను కేవలం ఈ యూనిట్ కోసం అడగండి:

sudo journalctl -u myapp.service -f

-f కొత్త లైన్లు వచ్చినప్పుడల్లా వాటిని అనుసరిస్తుంది, tail -f లాగా. మీ ప్రోగ్రామ్ స్టాండర్డ్ అవుట్‌పుట్ లేదా స్టాండర్డ్ ఎర్రర్‌కు వ్రాసే ప్రతిదీ ఇక్కడ చేరుతుంది, మీ వైపు ఏ లాగింగ్ అమరిక లేకుండా.

వైఫల్యంపై పునఃప్రారంభం, మీరు ఇక్కడ ఉన్న కారణం

ఒక సర్వీసు యొక్క ప్రధాన ప్రయోజనం ఏమిటంటే, మీ ప్రోగ్రామ్ ఆగిపోయినప్పుడు systemd దాన్ని పునఃప్రారంభిస్తుంది. దీనికి రెండు లైన్లు సరిపోతాయి:

[Service]
Restart=on-failure
RestartSec=5

Restart=on-failure అనేది ప్రోగ్రామ్ సున్నా కాని కోడ్‌తో నిష్క్రమించినప్పుడు లేదా SIGKILL లేదా SIGSEGV వంటి క్రాష్ సిగ్నల్ వల్ల ఆగిపోయినప్పుడు దాన్ని పునఃప్రారంభిస్తుంది. సాధారణ నిష్క్రమణ, లేదా SIGTERM, SIGINT, SIGHUP, లేదా SIGPIPE ద్వారా ఆపడం దీన్ని ప్రేరేపించదు. RestartSec=5 ప్రయత్నాల మధ్య ఐదు సెకన్లు వేచి ఉంటుంది, తద్వారా తక్షణమే క్రాష్ అయ్యే ప్రోగ్రామ్ వేగంగా పునరావృతమవ్వదు. ప్రాసెస్‌ను కొట్టి వేసి, systemd దాన్ని తిరిగి తీసుకురావడాన్ని గమనించడం ద్వారా దీన్ని ధృవీకరించుకోండి. SIGKILL ఉపయోగించండి: అప్రమేయ SIGTERM అనేది సాధారణ స్టాప్‌గా పరిగణించబడుతుంది, కాబట్టి on-failure సర్వీసును పునఃప్రారంభించదు:

sudo systemctl kill -s SIGKILL myapp.service
sudo systemctl status myapp.service

ఐదు సెకన్ల లోపల స్టేటస్ కొత్త Main PID చూపిస్తుంది మరియు active (running) మళ్లీ జరుగుతుంది. ఇది ఆ ఫీచర్ మొత్తం, మరియు ఒక ప్రోగ్రామ్‌ను tmux లేదా screen లో నడుపుతూ ఉండటం కంటే ఒక సర్వీసు మెరుగైనది అని చెప్పడానికి ఇదే కారణం.

అనుమతి లేని వినియోగదారుగా నడపండి, మరియు దాన్ని బలోపేతం చేయండి

root గా నడిచే సేవ, ప్రోగ్రామ్ ఎప్పుడైనా దుర్వినియోగం చేయబడితే మీ సర్వర్‌కు ఏదైనా చేయగలదు. దాన్ని దాని స్వంత వినియోగదారుగా నడపండి. systemd కు దాన్ని పరిమితం చేసే కొన్ని డైరెక్టివ్‌లను ఇవ్వండి. ముందుగా, లాగిన్ లేని మరియు హోమ్ లేని ఒక సిస్టమ్ ఖాతాను సృష్టించండి:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin myapp

తర్వాత User=myapp ను సెట్ చేయండి మరియు [Service] కు బలోపేత పంక్తులను జోడించండి:

[Service]
User=myapp
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true

ప్రతి పంక్తి ప్రోగ్రామ్‌కు అవసరం లేని దాన్ని తొలగిస్తుంది. NoNewPrivileges=true, setuid బైనరీ ద్వారా కూడా, ప్రక్రియ కొత్త అధికారాలను పొందకుండా నిరోధిస్తుంది. PrivateTmp=true దానికి ఇతర ప్రక్రియలు చూడలేని ఒక ప్రైవేట్ /tmp ని ఇస్తుంది. ProtectSystem=strict మీరు ReadWritePaths= తో పేర్కొన్న కొన్ని పాత్‌లను మినహాయించి మొత్తం ఫైల్‌సిస్టమ్‌ను చదవడానికి మాత్రమే చేస్తుంది. ProtectHome=true దాని నుండి /home ను పూర్తిగా దాచిపెడుతుంది. సేవను ఫైర్‌వాల్ వెనుక ఉంచడం వంటి కనీస-అధికార ఆలోచన ఇదే: అది అవసరమైనదాన్ని మాత్రమే ఇవ్వండి. మీరు VPSలో IPv6 ఫైర్‌వాల్ అంతరాన్ని మూసివేయడం గురించిన గైడ్‌ను చదివి ఉంటే, ఇది అదే ఆలోచన యొక్క హోస్ట్-పై సగభాగం. ఇంటర్నెట్‌ను ఎదుర్కొనే సేవకు, ఈ బలోపేతాన్ని SSH ముందు Fail2ban మరియు డిఫాల్ట్-డినై ఫైర్‌వాల్‌తో జతపరచండి.

ఇవన్నీ చేతితో టైప్ చేసి ఒక డైరెక్టివ్‌ను తప్పుగా గుర్తుంచుకోవడం కంటే, పూర్తి, బలోపేత యూనిట్‌ను సృష్టించి దాన్ని కాపీ చేయండి:

టైమర్‌లు: ఆధునిక క్రాన్

ఒక systemd టైమర్ ఒక షెడ్యూల్ ప్రకారం సర్వీస్‌ను నడుపుతుంది. ఇది క్రాన్ జాబ్‌కు ఆధునిక ప్రత్యామ్నాయం. టైమర్ అనేది రెండు ఫైళ్లు: పనిని చేసే .service, ఎప్పుడు చేయాలో చెప్పే .timer. ప్రతిరోజూ ఉదయం 3 గంటలకు బ్యాకప్ కావాలనుకుంటున్నారనుకోండి. సర్వీస్ పనిని ఒకసారి చేసి నిష్క్రమిస్తుంది:

# /etc/systemd/system/backup.service
[Unit]
Description=Nightly backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

Type=oneshot అనేది systemd కి ప్రోగ్రామ్ నడుస్తుంది, పూర్తవుతుంది, మరియు ముగుస్తుందని చెబుతుంది. అది నివాసయుతంగా ఉండదు. టైమర్ దానిని షెడ్యూల్ చేస్తుంది:

# /etc/systemd/system/backup.timer
[Unit]
Description=Run the nightly backup

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

OnCalendar=*-*-* 03:00:00 అంటే ప్రతిరోజూ ఉదయం 3 గంటలు. ఏదైనా క్యాలెండర్ ఎక్స్‌ప్రెషన్‌ను systemd-analyze calendar "*-*-* 03:00:00" తో పరీక్షించండి. అది దాన్ని పార్స్ చేసిందని నిర్ధారిస్తుంది మరియు తదుపరి ఎప్పుడు ట్రిగ్గర్ అవుతుందో ముద్రిస్తుంది. ఉదయం 3 గంటలకు సర్వర్ ఆఫ్‌లో ఉంటే, Persistent=true సర్వర్ తిరిగి వచ్చిన వెంటనే ఆపైని నడుపుతుంది. దీన్ని క్రాన్ చేయలేదు. టైమర్‌ను multi-user.target ద్వారా కాకుండా timers.target ద్వారా ఎనేబుల్ చేస్తారని గమనించండి. సర్వీస్‌ను కాకుండా టైమర్‌ను ఎనేబుల్ చేయండి:

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer
systemctl list-timers

list-timers ప్రతి టైమర్‌ను దాని తదుపరి మరియు చివరి రన్‌తో చూపుతుంది. కాబట్టి మీ జాబ్ తదుపరి ఎప్పుడు ట్రిగ్గర్ అవుతుందో మీరు ఒకే చూపులో చూడవచ్చు. మీరు టైమర్ మోడ్‌ను ఆన్ చేసినప్పుడు పై జనరేటర్ మీ కోసం జతపరచబడిన .service మరియు .timer ను సృష్టిస్తుంది. ఒక క్రాన్ లైన్‌తో పోలిస్తే, టైమర్ జర్నల్‌లో నిజమైన లాగ్‌లను ఇస్తుంది. ఏ సర్వీస్‌తో సమానమైన హార్డెనింగ్ డైరెక్టివ్‌లను ఇస్తుంది. మరియు Persistent=true అందించే మిస్డ్-రన్ క్యాచ్-అప్‌ను ఇస్తుంది. సాధారణ జాబ్‌కు క్రాన్ ఇప్పటికీ సరిపోతుంది. జాబ్ ముఖ్యమైనది అయినప్పుడు టైమర్ మెరుగైన పరికరం.

FAQ

systemd సర్వీస్ మరియు cron జాబ్ మధ్య తేడా ఏమిటి?

సర్వీస్ ఒక దీర్ఘకాలిక ప్రోగ్రామ్‌ను నడుపుతూ ఉంచుతుంది: ఇది బూట్ సమయంలో ప్రారంభమవుతుంది, వైఫల్యం జరిగినప్పుడు పునఃప్రారంభమవుతుంది, మరియు జర్నల్‌కు లాగ్ చేస్తుంది. cron జాబ్ ఒక షెడ్యూల్‌పై ఒక స్వల్ప కమాండ్‌ను నడుపుతుంది మరియు ఆపై నిష్క్రమిస్తుంది. మీకు షెడ్యూలింగ్ కావాలి మరియు జర్నల్ లాగ్‌లు, హార్డెనింగ్, మరియు జరగని రన్‌ల కోసం క్యాచ్-అప్ కూడా కావాలి అనుకుంటే, systemd టైమర్‌ను ఉపయోగించండి. ఇది .timer షెడ్యూల్‌ను oneshot సర్వీస్‌తో జతపరుస్తుంది మరియు చాలా సర్వర్ టాస్క్‌ల కోసం cron స్థానంలో ఉపయోగిస్తుంది.

నా systemd సర్వీస్ ఫైల్‌ను నేను ఎక్కడ ఉంచాలి?

మీ స్వంత యూనిట్‌లను /etc/systemd/system/లో ఉంచండి, దాని పేరు .serviceతో ముగియాలి. ఆ డైరెక్టరీ అడ్మినిస్ట్రేటర్ జోడించే యూనిట్‌ల కోసం ఉద్దేశించబడింది, మరియు ఇది /lib/systemd/system/లో ప్యాకేజీలు అందించే యూనిట్‌ల కంటే ప్రాధాన్యత తీసుకుంటుంది. అక్కడ ఫైల్‌ను సృష్టించిన తర్వాత లేదా సవరించిన తర్వాత, sudo systemctl daemon-reload అమలు చేయండి తద్వారా systemd మార్పును స్వీకరిస్తుంది.

ఒక సర్వీస్ క్రాష్ అయితే దాన్ని పునఃప్రారంభించేలా ఎలా చేస్తాను?

[Service] విభాగానికి Restart=on-failure మరియు RestartSec=5 జోడించండి, తర్వాత sudo systemctl daemon-reload అమలు చేసి సర్వీస్‌ను పునఃప్రారంభించండి. ప్రోగ్రామ్ నాన్-జీరో కోడ్‌తో నిష్క్రమించినప్పుడు లేదా క్రాష్ సిగ్నల్ వల్ల ఆగిపోయినప్పుడు systemd దాన్ని మళ్లీ ప్రారంభిస్తుంది, ప్రయత్నాల మధ్య ఐదు సెకన్లు వేచి ఉంటుంది. sudo systemctl kill -s SIGKILL myapp.serviceతో పరీక్షించండి — SIGTERM, డిఫాల్ట్ సిగ్నల్, క్లీన్ స్టాప్‌గా పరిగణించబడుతుంది మరియు on-failureను ట్రిగ్గర్ చేయదు — మరియు కొన్ని సెకన్లలోపు systemctl status కొత్త PIDని చూపుతుందని గమనించండి.

systemd సర్వీస్‌ను non-root యూజర్‌గా ఎలా నడుపుతాను?

sudo useradd --system --no-create-home --shell /usr/sbin/nologin myappతో ఒక సిస్టమ్ అకౌంట్ సృష్టించండి, తర్వాత [Service] విభాగానికి User=myapp జోడించండి. NoNewPrivileges=true, PrivateTmp=true, మరియు ProtectSystem=strict జోడించండి తద్వారా ప్రాసెస్‌కు అవసరమైనంత తక్కువ యాక్సెస్‌తో నడుస్తుంది. అన్‌ప్రివిలేజ్డ్ యూజర్‌గా నడపడం అనేది ఒక సర్వీస్ భద్రతకు మీరు చేయగలిగే అత్యంత ముఖ్యమైన మార్పు.

నా సర్వీస్ ప్రారంభం కావడంలో విఫలమైంది ఎందుకు?

సారాంశం కోసం systemctl status myapp.service అమలు చేయండి మరియు పూర్తి అవుట్‌పుట్ కోసం journalctl -u myapp.service అమలు చేయండి. అత్యంత సాధారణ కారణాలు ExecStartలో తప్పుడు పాత్, లేని WorkingDirectory, User= ఫైల్‌ను చదవలేకపోవడం వల్ల వచ్చే అనుమతి లోపం, లేదా సవరణ తర్వాత మర్చిపోయిన sudo systemctl daemon-reload. జర్నల్ ప్రోగ్రామ్ స్వంత ఎర్రర్ సందేశాన్ని చూపుతుంది, ఇది సాధారణంగా సమస్యను నేరుగా పేర్కొంటుంది.