Linuxలో watch కమాండ్‌ను సరిగ్గా ఉపయోగించడం ఎలా

watch కమాండ్ ఏమి చేస్తుంది

watch కమాండ్ మరొక కమాండ్‌ను నిర్ణయించిన వ్యవధిలో మళ్లీ అమలు చేసి, దాని output ను స్క్రీన్‌పై అదే స్థానంలో తిరిగి చూపిస్తుంది. డిఫాల్ట్ వ్యవధి రెండు సెకన్లు. ఏదైనా సంఖ్య మారే వరకు వేచి ఉన్నప్పుడు దీనిని ఉపయోగించండి: disk నిండిపోవడం, container స్థిరపడటం, certificate renewal పూర్తవడం లేదా queue ఖాళీ కావడం వంటి సందర్భాల్లో ఇది ఉపయోగకరంగా ఉంటుంది.

watch, procps-ng లో భాగంగా వస్తుంది. కొత్త Ubuntu లేదా Debian VPS లో ఇది ఇప్పటికే procps package లో భాగంగా install అయి ఉంటుంది. దిగువలోని ఏదైనా flag ను ఉపయోగించే ముందు మీ version ను తనిఖీ చేయండి, ఎందుకంటే ఉపయోగకరమైన రెండు options ఇటీవలి versions లో మాత్రమే ఉన్నాయి.

watch --version

Ubuntu 24.04 లో ఇది watch from procps-ng 4.0.4 వంటి line ను చూపిస్తుంది. ఇప్పుడు సరళమైన ఉపయోగకరమైన ఉదాహరణను చూద్దాం.

watch df -h /

స్క్రీన్ clear అయి, ఒక header line, ఒక ఖాళీ line, తరువాత df -h / యొక్క output ను చూపిస్తుంది:

Every 2.0s: df -h /                          server1: Sun Aug  9 10:21:44 2026

ఎడమవైపు interval మరియు watch అమలు చేస్తున్న ఖచ్చితమైన command కనిపిస్తాయి. కుడివైపు hostname మరియు ప్రస్తుత సమయం కనిపిస్తాయి. clock భాగం ఉపయోగకరమైనది, ఎందుకంటే దిగువన ఉన్న సంఖ్యలు మారకపోయినా స్క్రీన్ ఇంకా refresh అవుతోందని అది నిర్ధారిస్తుంది. నిష్క్రమించడానికి Ctrl+C నొక్కండి.

watch terminal కు సరిపోయే ఒక frame ను మాత్రమే చూపిస్తుంది. పొడవైన lines wrap అవుతాయి. -w వాటిని బదులుగా truncate చేస్తుంది. దిగువ row దాటిన ఏదీ చూపించబడదు. Frame లో scrollback ఉండదు, ఎందుకంటే ప్రతి cycle మునుపటి frame ను పూర్తిగా overwrite చేస్తుంది. watch ఏ పనులకు అనుకూలమో నిర్ణయించేది ప్రధానంగా ఈ ఒక్క విషయం.

watch ఆదేశాన్ని ఎంత తరచుగా మళ్లీ అమలు చేయాలి?

రెండు సెకన్లు కేవలం డిఫాల్ట్ విలువ మాత్రమే. విలువ ఎంత వేగంగా మారుతుందో, ఒకసారి అమలు చేయడానికి ఎంత సమయం లేదా వనరులు అవసరమవుతాయో ఆధారంగా interval ఎంచుకోండి.

• -n 0.5 ను నిరంతరం మారే counters కోసం ఉపయోగించండి. ఉదాహరణకు ss -s లేదా interface byte count. watch అంగీకరించే కనిష్ఠ interval 0.1 seconds.
• disks మరియు certificates కోసం -n 30 లేదా -n 60 ఉపయోగించండి. ఒక రోజులో నిండే filesystem కు నిమిషానికి ముప్పై frames అవసరం లేదు.

watch ఆదేశాన్ని అమలు చేసి, అది పూర్తయ్యే వరకు వేచి ఉంటుంది. ఆ తర్వాతే interval పాటు నిద్రిస్తుంది. Runtime కూడా gap లో భాగమవుతుంది. అందువల్ల -n 2 కింద ఎనిమిది seconds పట్టే ఆదేశం ప్రతి పది seconds కు ఒక frame ఇస్తుంది. ఆ సమయంలో మొత్తం machine busyగా ఉంటుంది. -p (--precise) జోడిస్తే, watch ప్రతి interval seconds కు ఒకసారి run ప్రారంభించడానికి ప్రయత్నిస్తుంది. ఇది ఒక run ప్రారంభం నుంచి తదుపరి run ప్రారంభం వరకు కొలుస్తుంది.

మీరు ఎల్లప్పుడూ వేరే default కోరుకుంటే, మీ shell profileలో WATCH_INTERVAL ను export చేయండి. దానికంటే స్పష్టంగా ఇచ్చిన -n కు ప్రాధాన్యం ఉంటుంది. మీ build ఆ variable ను చదువుతుందో లేదో నిర్ధారించడానికి watch --help అమలు చేయండి.

-d తో మార్పులను హైలైట్ చేయండి

ఒకేలా ఉన్న పాఠ్యంతో నిండిన గోడలో మారిన ఒక్క field‌ను గుర్తించడం కష్టం. -d (--differences) ఆ పనిని మీ కోసం చేస్తుంది.

watch -n 30 -d 'df -h / /var'

మునుపటి frame‌తో పోలిస్తే భిన్నంగా ఉన్న characters reverse videoలో కనిపిస్తాయి. అందువల్ల Use% cell కదిలిన వెంటనే వెలుగుతుంది, మిగతావన్నీ అలాగే ఉంటాయి. /var ప్రత్యేక filesystem కాకపోతే root filesystem రెండుసార్లు కనిపిస్తుంది. దీని ద్వారా సిస్టమ్ ఎలా partition చేయబడిందో వేగంగా తెలుసుకోవచ్చు.

ఈ comparison స్థాన క్రమాన్ని ఆధారంగా చేసుకుంటుంది. అంటే watch కొత్త frameలోని ప్రతి line‌ను పాత frameతో character-by-characterగా పోలుస్తుంది. Columns వెడల్పు మారే output దాదాపు మొత్తం హైలైట్ అవుతుంది. కాబట్టి స్థిరమైన layout ఉన్న commands‌ను ఉపయోగించండి. ప్రస్తుత procps-ng కూడా watch --differences=permanent ను అంగీకరిస్తుంది. ఇది ఇటీవలి మార్పును మాత్రమే కాకుండా, ఎప్పుడైనా మారిన ప్రతి స్థానాన్ని హైలైట్‌గా ఉంచుతుంది. దానిపై ఆధారపడే ముందు watch --help తో నిర్ధారించండి.

watch అవుట్‌పుట్ మారినప్పుడు ఎలా ముగియాలి?

-g (--chgexit) ముందు రన్‌తో పోలిస్తే అవుట్‌పుట్ మొదటిసారి భిన్నంగా కనిపించిన వెంటనే watch ను ఆపుతుంది. Prompt తిరిగి కనిపిస్తుంది. అందువల్ల అదే లైన్‌లో దాని తర్వాత మరొకదాన్ని ఉంచవచ్చు.

watch -n 10 -g 'systemctl is-active myapp' ; echo 'state changed'

ఈ flag watch ను “deploy పూర్తయినప్పుడు నాకు తెలియజేయి” అనే సాధనంగా మారుస్తుంది. ఇందులో ఒక సమస్య ఉంది. అది అందరినీ ప్రభావితం చేస్తుంది: పోలిక మొత్తం అవుట్‌పుట్‌పై జరుగుతుంది. అందులోని clock లేదా PID (process identifier) మొదటి refresh లోనే మారుతుంది. దాంతో watch వెంటనే ముగుస్తుంది. systemctl status myapp గడిచిన సమయం మరియు memory వినియోగాన్ని చూపుతుంది. అందువల్ల దానిపై -g ఉపయోగించడం ప్రయోజనం లేనిది. మీరు వేచి చూస్తున్న ఒకే స్థిరమైన సమాచారానికి command ను పరిమితం చేయండి. దానినే systemctl is-active అందిస్తుంది.

కొత్త procps-ng లో దీనికి విరుద్ధమైన పరీక్ష అయిన --equexit <cycles> కూడా ఉంది. నిర్దిష్ట సంఖ్యలో cycles వరకు అవుట్‌పుట్ మారకుండా ఉన్న తర్వాత ఇది ముగుస్తుంది. “ఇది ఎప్పుడు నిశ్శబ్దంగా మారుతుందో నాకు తెలియజేయి” అనే అవసరానికి ఇది సరిపోతుంది. మీ వద్ద ఉన్న build లో ఇది ఉందో లేదో watch --help తో పరిశీలించండి. పాత builds లో ఇది ఉండకపోవచ్చు.

watch నా pipe మరియు glob ను ఎందుకు పట్టించుకోదు?

ఈ సమస్యను ప్రతి ఒక్కరూ కనీసం ఒకసారి ఎదుర్కొంటారు. కారణం watch లో కాకుండా మీ shell లో ఉంటుంది.

watch docker compose ps | grep web

ఏదైనా అమలు కావడానికి ముందు మీ interactive shell మొత్తం command line ను చదివి, pipe వద్ద విభజిస్తుంది. అది watch docker compose ps ను ప్రారంభించి, watch యొక్క స్వంత screen output ను grep కు అనుసంధానిస్తుంది. watch ఇక terminal కు రాయడం లేదు. అందువల్ల display తప్పుగా లేదా ఖాళీగా కనిపిస్తుంది. grep కూడా container list కు బదులుగా redraw output ను filter చేస్తుంది.

మొత్తం pipeline ను quote చేయండి. అప్పుడు అది ఒకే argument గా చేరుతుంది.

watch 'docker compose ps | grep web'

watch ఆ string ను sh -c కు పంపుతుంది. ఆ shell ప్రతి cycle లో pipeline ను ఒకసారి అమలు చేస్తుంది. Globs కూడా ఇదే నియమాన్ని అనుసరిస్తాయి. అయితే వాటి ప్రభావం అంత స్పష్టంగా కనిపించదు.

watch ls -l /var/log/*.log
watch 'ls -l /var/log/*.log'

మొదటి line లోని glob, మీరు Enter నొక్కిన సమయంలో, మీ shell లో ఒకసారి expand అవుతుంది. తరువాత watch స్థిరంగా ఉన్న filenames జాబితాను మళ్లీ అమలు చేస్తుంది. అందువల్ల ఒక నిమిషం తరువాత సృష్టించిన log file కనిపించదు. రెండవ line glob ను watch కు అందిస్తుంది. watch ప్రతి cycle లో sh లో దాన్ని expand చేస్తుంది. అందువల్ల కొత్త files స్వయంచాలకంగా కనిపిస్తాయి.

Variable లేదా command substitution ఎప్పుడు evaluate కావాలో కూడా quotes నిర్ణయిస్తాయి. watch "echo $(date)" మీ shell లో date ను ఒకసారి అమలు చేసి, ఆ స్థిరమైన string ను ఎప్పటికీ echo చేస్తుంది. watch 'echo $(date)' ప్రతి cycle లో date ను అమలు చేస్తుంది. Single quotes అంటే తరువాత. Double quotes అంటే ఇప్పుడు.

ఆ sh -c వల్ల మరో రెండు ప్రభావాలు ఉంటాయి:

• దాని లోపల aliases మరియు shell functions అందుబాటులో ఉండవు. watch ll, sh: 1: ll: not found తో విఫలమవుతుంది, ఎందుకంటే sh -c మీ .bashrc ను చదవదు. అసలు command ను నేరుగా రాయండి. లేదా మీ interactive PATH లో మాత్రమే ఉన్న binary కు పూర్తి path ఇవ్వండి.
• Standard error ను capture చేయడం ఉపయోగకరం. Error text frame లో అమరికతో కనిపించాలి, దాని మీద చెల్లాచెదురుగా కనిపించకూడదంటే quotes లోపల 2>&1 ను ఉంచండి.

Quoting క్లిష్టంగా మారినప్పుడు, -x (--exec) command ను sh -c ద్వారా కాకుండా నేరుగా అమలు చేస్తుంది. Spaces ఉన్న arguments సులభంగా నిర్వహించవచ్చు. అయితే pipes మరియు globs పూర్తిగా పనిచేయడం ఆగిపోతాయి, ఎందుకంటే వాటిని interpret చేసే shell ఇక ఉండదు.

Privileges కూడా ఇదే విధంగా పనిచేస్తాయి, ఎందుకంటే watch ఒక సాధారణ process. watch 'sudo ss -tulpn' మీరు చూడలేని లేదా type చేయలేని password prompt వద్ద ఆగిపోతుంది. దాని బదులుగా sudo watch 'ss -tulpn' ను అమలు చేయండి. ఆ తరువాత మీరు Ctrl+C నొక్కే వరకు మొత్తం loop root గా నడుస్తుందని గుర్తుంచుకోండి.

VPSలో గమనించాల్సిన నాలుగు అంశాలు

నిండిపోతున్న డిస్క్

watch -n 30 -d 'df -h / /var'

df kernel వద్ద ఇప్పటికే ఉన్న గణాంకాలను మాత్రమే అడుగుతుంది, కాబట్టి దీన్ని నిరంతరం పునరావృతం చేసినా ఖర్చు తక్కువ. du -sh /var/log అలా కాదు, ఎందుకంటే ప్రతి cycleలో అది treeలోని ప్రతి fileను పరిశీలిస్తుంది. దీన్ని watch కింద నడిపితే diskను నిరంతరం చదివి, మీరు నిర్ధారించడానికి ప్రయత్నిస్తున్న machineను నెమ్మదింపజేస్తుంది. du ను ఒకసారి run చేయండి, లేదా ncdu ఉపయోగించండి. తరువాత సంఖ్య ఇంకా పెరుగుతోందో లేదో తెలుసుకోవడానికి df ను watch కింద ఉంచండి.

మళ్లీ మళ్లీ restart అవుతున్న container

cd /srv/myapp
watch -n 5 -d 'docker compose ps'

Status column ప్రతి container ఎంతసేపటి నుంచి upలో ఉందో చూపిస్తుంది. Crash loopలో ఉన్న container మళ్లీ "Up 2 seconds" స్థితికి వెళ్తూనే ఉంటుంది. -d దీన్ని ఒక్క చూపులో స్పష్టంగా చూపిస్తుంది. ముందుగా directory మార్చండి. ఎందుకంటే watchను ప్రారంభించిన shell యొక్క working directoryను watch వారసత్వంగా పొందుతుంది, అలాగే docker compose కు దాని project directory అవసరం. Restart జరుగుతోందని watch చెబుతుంది. దానికి కారణం ఏమిటో docker compose logs -f web చెబుతుంది. కారణం తెలిసిన తర్వాత, దాన్ని containerను మీ కోసం restart చేసే Compose healthcheckగా అమలు చేయండి. అప్పుడు ఎవరూ screenను చూస్తూ కూర్చోవాల్సిన అవసరం ఉండదు.

Certificate renewal పూర్తవడం

sudo -i
watch -n 60 -g 'openssl x509 -noout -enddate -in /etc/letsencrypt/live/example.com/fullchain.pem'

ఈ command ఒక lineను, notAfter=Nov 7 09:14:22 2026 GMT ను మాత్రమే print చేస్తుంది; మరేమీ print చేయదు. అందువల్ల renewed certificateతో file replace అయినప్పుడు మాత్రమే -g ఖచ్చితంగా trigger అవుతుంది. /etc/letsencrypt/live కింద ఉన్న filesను root మాత్రమే చదవగలదు. అందుకే ఇది root shellలో run అవుతుంది. ఇది diskలోని certificateను మాత్రమే monitor చేస్తుందని గుర్తుంచుకోండి. Running web server reload అయ్యే వరకు పాత certificateను memoryలో ఉంచుతుంది. కాబట్టి నిజంగా serve అవుతున్న certificateను echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate తో తనిఖీ చేయండి. Public hostపై ఆ commandను రెండు seconds intervalతో run చేయవద్దు. Renewal ప్రక్రియ systemd service మరియు timer కు చెందుతుంది. తదుపరి run ఎప్పుడు జరుగుతుందో systemctl list-timers చూపిస్తుంది.

Empty అవుతున్న queue

watch -n 15 'postqueue -p | tail -n 1'

ఇది -- 24 Kbytes in 6 Requests. వంటి summary lineను print చేస్తుంది, లేదా పూర్తయిన తర్వాత Mail queue is empty ను print చేస్తుంది. మీరు లెక్కించగల ఏ queueకైనా ఇదే విధానం పనిచేస్తుంది: watch -n 5 'find /srv/queue/incoming -type f | wc -l'.

ఇక్కడ watch పరిమితి కనిపిస్తుంది. ఇది ఒక frameను దాని ముందు ఉన్న frameతో మాత్రమే పోలుస్తుంది. అలాగే ఇది conditionను test చేయలదు. అందువల్ల "count zeroకి చేరింది" అని ఎప్పటికీ చెప్పలదు. సాధారణ shell loop మాత్రం ప్రతి passలో countను సేకరించడానికి command substitution ఉపయోగించి అలా చేయగలదు:

until [ "$(find /srv/queue/incoming -type f | wc -l)" -eq 0 ]; do sleep 5; done; echo 'queue drained'

watch కమాండ్ సరైన సాధనం కానప్పుడు

watch కమాండ్ మీ కమాండ్‌ను మునుపటి అమలు గురించి ఎలాంటి సమాచారం లేకుండా, ఆ కమాండ్ ఏమి చేస్తుందో అర్థం చేసుకోకుండా మళ్లీ అమలు చేస్తుంది. df కోసం ఇది సరిపోతుంది. అయితే నాలుగు సందర్భాల్లో ఇది సరైనది కాదు.

• Logs. watch స్థిరమైన ఫ్రేమ్‌ను మళ్లీ గీస్తుంది. అందువల్ల రెండు cycles మధ్య కనిపించి scroll అయిపోయే lines కోల్పోతారు. కొత్త lines రాయబడుతున్నప్పుడు వాటిని stream చేసే journalctl -fu nginx లేదా tail -f ఉపయోగించండి.
• ఖరీదైన commands. du -sh / లేదా busy database పై query ఏ intervalలోనైనా నిరంతర background loadగా మారుతుంది, ఎందుకంటే watch దాన్ని మళ్లీ మళ్లీ ప్రారంభిస్తూనే ఉంటుంది.
• Side effects కలిగించే ఏదైనా. రాయడం, post చేయడం, restart చేయడం లేదా install చేయడం చేసే command ప్రతి cycleలో మళ్లీ అదే పని చేస్తుంది. ప్రతి రెండు secondsకు APIపై curl అమలు చేస్తే రోజుకు 43,200 requests అవుతాయి. దాంతో free API key suspend అవుతుంది.
• ఎక్కువసేపు అమలయ్యే checks. watch మీ terminalలో నడుస్తుంది మరియు మీ session ముగిసినప్పుడు ఆగిపోతుంది. ఇది ఎవరికీ alert పంపదు. laptop మూసిన తర్వాత history కూడా ఉంచదు. ఇందుకోసం Uptime Kuma వంటి నిజమైన status monitor, లేదా serverపై అమలయ్యే scheduled check ఉపయోగించాలి.

స్పష్టమైన హద్దు సమయం. ఒక నిర్దిష్ట విషయం జరిగే వరకు మీరు వేచి చూసే పది నిమిషాల పనికి watch సరిపోతుంది. రేపు కూడా check చేస్తూ ఉండాల్సిన ఏదైనా scheduled timer లేదా నిజమైన monitor పరిధిలోకి వస్తుంది.

SSHలో ఉన్నప్పుడు watch ను tmux లో అమలు చేయండి

SSH ద్వారా నడిపినప్పుడు watch యొక్క కొనసాగింపు కనెక్షన్‌పై ఆధారపడి ఉంటుంది. కనెక్షన్ తెగిపోతే మీ shell కు SIGHUP అందుతుంది. దాంతో watch కూడా ఆగిపోతుంది. tmux ఈ సమస్యను పరిష్కరిస్తుంది. అందువల్ల remote server పై watch నిజంగా ఉపయోగకరంగా ఉంటుంది.

tmux new -As ops
watch -n 30 -d 'df -h /'

Detach చేయడానికి Ctrl+b ఆపై d నొక్కండి. Loop server పై కొనసాగుతుంది. తరువాత మళ్లీ కనెక్ట్ అయి tmux attach -t ops ఉపయోగిస్తే frame ఇంకా update అవుతూనే ఉంటుంది. Header clock మారుతుండటం దీనికి నిర్ధారణ. Window ను split చేస్తే ఒక వైపు watch, మరో వైపు journalctl -f ఉంచవచ్చు. ఇదే tmux ఆధారిత terminal workbench యొక్క ప్రధాన ఉద్దేశం. ఒకే ప్రశ్నను ఒకేసారి అనేక serverలపై పరిశీలించాల్సి వస్తే, watch panesతో నిండిన window కంటే అనేక Linux serverలను నిర్వహించడానికి రూపొందించిన tool ఉపయోగించడం సరైనది.

ఇక్కడ చూపిన screens ఉదాహరణ కోసం మాత్రమే. Column layout మరియు version strings distributions, procps-ng releases మధ్య మారవచ్చు. అందువల్ల మీ buildలో నిజంగా అందుబాటులో ఉన్న flags కోసం మీ స్వంత machineపై man watch ను పరిశీలించండి.

FAQ

watch mycmd | grep foo లో pipe ను watch ఎందుకు పట్టించుకోదు?

watch ప్రారంభం కాకముందే మీ shell ఆ లైన్‌ను pipe వద్ద విభజిస్తుంది. అందువల్ల watch స్వయంగా తెరపై చూపించే output grep కు pipe అవుతుంది. కమాండ్ output ఎప్పటికీ filter కాదు. మొత్తం pipeline ను ఇలా quote చేయండి: watch 'mycmd | grep foo'. watch ఆ ఒక argument ను sh -c కు అందిస్తుంది. అది ప్రతి cycleలో pipeline ను ఒకసారి నడుపుతుంది. ఇదే నియమం globs మరియు command substitutionకూ వర్తిస్తుంది.

watch తో ఏ interval ఉపయోగించాలి?

ఆ విలువ ఎంత వేగంగా మారుతుందో, ఒకసారి run చేయడానికి ఎంత ఖర్చవుతుందో దానికి అనుగుణంగా interval ఎంచుకోండి. వేగంగా మారే countersకు half a second సరిపోతుంది. watch అంగీకరించే కనిష్ట interval 0.1 seconds. disks మరియు certificatesకు thirty నుంచి sixty seconds సరిపోతాయి. -p pass చేయకపోతే command runtime gapకు అదనంగా చేరుతుంది. అందువల్ల -n 1 కింద slow command వరుసగా back to backగా మాత్రమే నడుస్తుంది. మధ్యలో pause ఉండదు.

watch తో log fileను follow చేయవచ్చా?

లేదు. watch ఒక frameను redraw చేస్తుంది. ఇది historyని నిల్వ చేయదు. అందువల్ల రెండు cycles మధ్య కనిపించి scroll అయిపోయిన line శాశ్వతంగా కనుమరుగవుతుంది. journalctl -fu <unit> మరియు tail -f కొత్త lines వచ్చిన వెంటనే stream చేస్తాయి. Logsకు అవసరమైన విధానం ఇదే. Disk percentage లేదా queue length వంటి ప్రస్తుత state కలిగిన values కోసం watchను ఉపయోగించండి.

నేను ఎదురుచూస్తున్న సంఘటన జరిగినప్పుడు watch ఆగేలా ఎలా చేయాలి?

-g (--chgexit) ఉపయోగించి, ఆ సంఘటన జరిగే వరకు output మారకుండా ఉండే command ఇవ్వండి. Clock లేదా PID ఉన్న output మొదటి refreshలోనే మారుతుంది. అందువల్ల systemctl is-active myapp పనిచేసే చోట systemctl status myapp పనిచేయదు. Count zeroకి చేరడం వంటి నిజమైన condition కోసం shell until loopను ఉపయోగించండి. ఎందుకంటే output మారిందో లేదో మాత్రమే watch గుర్తించగలదు.

నా shellలో పనిచేసే దానికి watch ఎందుకు command not found అంటుంది?

watch commandను sh -c కు అందిస్తుంది. ఆ shell .bashrc ను చదవదు. అందువల్ల మీ aliases మరియు shell functions అక్కడ అందుబాటులో ఉండవు. ఆ సందేశం సాధారణంగా sh: 1: ll: not found. అసలు commandను పూర్తిగా రాయండి. లేదా మీ interactive PATH లో మాత్రమే ఉన్న binary కోసం full pathను ఉపయోగించండి.