Linux मधील watch कमांड योग्य प्रकारे वापरणे

watch कमांड काय करते

watch कमांड ठरावीक अंतराने दुसरी कमांड पुन्हा चालवते आणि तिचे आउटपुट स्क्रीनवर त्याच ठिकाणी पुन्हा रेखाटते. डीफॉल्ट अंतर दोन सेकंदांचे असते. एखादा आकडा बदलण्याची वाट पाहत असताना ही कमांड वापरा: डिस्कमधील वापरलेली जागा वाढत असणे, container स्थिर होणे, प्रमाणपत्राचे renewal पूर्ण होणे किंवा queue रिकामी होणे.

watch हे procps-ng मधून येते आणि नवीन Ubuntu किंवा Debian VPS वर procps package चा भाग म्हणून आधीपासून install केलेले असते. खालीलपैकी कोणताही flag वापरण्यापूर्वी तुमची version तपासा, कारण यांपैकी दोन उपयुक्त options अलीकडेच जोडले गेले आहेत.

watch --version

Ubuntu 24.04 वर यामुळे watch from procps-ng 4.0.4 सारखी ओळ दिसते. आता सर्वांत सोपे उपयुक्त उदाहरण पाहू.

watch df -h /

स्क्रीन साफ होते आणि त्यावर header line, एक रिकामी ओळ आणि त्यानंतर df -h / चे output दिसते:

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

डावीकडे interval आणि watch चालवत असलेली अचूक command दिसते. उजवीकडे hostname आणि सध्याची वेळ दिसते. घड्याळ हा उपयुक्त भाग आहे, कारण खालील आकडे बदलत नसले तरी स्क्रीन refresh होत आहे, हे त्यावरून समजते. बाहेर पडण्यासाठी Ctrl+C दाबा.

watch terminal मध्ये बसणारी एक frame रेखाटते. लांब ओळी wrap होतात; -w त्याऐवजी त्या truncate करते; आणि खालच्या row च्या पुढील कोणताही मजकूर रेखाटला जात नाही. frame मध्ये scrollback नसतो, कारण प्रत्येक cycle मागील cycle वर लिहिते. watch कशासाठी उपयुक्त आहे, हे मुख्यतः याच एका बाबीवर ठरते.

watch ने command पुन्हा किती वेळाने चालवावे?

दोन सेकंद हा केवळ default आहे. value किती वेगाने बदलते आणि प्रत्येक run साठी किती संसाधने लागतात यानुसार interval निवडा.

• सतत बदलणाऱ्या counters साठी -n 0.5 वापरा, जसे ss -s किंवा interface byte count. watch स्वीकारत असलेला सर्वात कमी interval 0.1 seconds आहे.
• disks आणि certificates साठी -n 30 किंवा -n 60 वापरा. एका दिवसात भरून येणाऱ्या filesystem साठी प्रति मिनिट तीस frames आवश्यक नसतात.

watch command चालवते, त्याचे execution पूर्ण होण्याची वाट पाहते आणि त्यानंतरच interval इतका वेळ थांबते. त्यामुळे command चालण्याचा वेळ gap मध्ये जोडला जातो. -n 2 अंतर्गत एखाद्या command ला आठ seconds लागत असल्यास, प्रत्येक दहा seconds ने एक frame मिळतो आणि संपूर्ण वेळ machine व्यस्त राहते. -p (--precise) जोडा. त्यानंतर watch प्रत्येक interval seconds ने run सुरू करण्याचा प्रयत्न करते. हे एका run च्या सुरुवातीपासून पुढील run च्या सुरुवातीपर्यंत मोजले जाते.

तुम्हाला नेहमी वेगळा default हवा असल्यास, तुमच्या shell profile मध्ये WATCH_INTERVAL export करा. Explicit -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 दोनदा सूचीबद्ध दिसेल. यावरून सिस्टमचे partitioning कसे केले आहे हे पटकन समजू शकते.

ही तुलना positional असते. म्हणजे watch नवीन frame मधील प्रत्येक line ची जुन्या frame शी character-by-character तुलना करते. ज्या output मधील columns ची width बदलते, ते जवळजवळ पूर्णपणे प्रकाशित होईल. त्यामुळे layout स्थिर असलेल्या commands ला प्राधान्य द्या. सध्याचे procps-ng watch --differences=permanent देखील स्वीकारते. यामुळे केवळ सर्वात अलीकडील बदलाऐवजी यापूर्वी कधीही बदललेली प्रत्येक position highlighted राहते. यावर अवलंबून राहण्यापूर्वी 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 elapsed time आणि memory वापर दाखवतो, त्यामुळे त्यावर -g वापरणे निरुपयोगी आहे. तुम्ही ज्या एकाच स्थिर तथ्याची वाट पाहत आहात, त्या तथ्यापुरतीच कमांड मर्यादित करा. हेच systemctl is-active देते.

नवीन procps-ng मध्ये याच्या उलट चाचणी, --equexit <cycles>, उपलब्ध आहे. आउटपुट दिलेल्या संख्येइतक्या cycles पर्यंत समान राहिल्यावर ती बाहेर पडते. याचा अर्थ "हे शांत झाल्यावर मला कळवा" असा होतो. watch --help तपासा, कारण जुन्या builds मध्ये हा flag उपलब्ध नसतो.

माझ्या pipe आणि glob कडे watch दुर्लक्ष का करतो?

ही चूक प्रत्येकाला कधीतरी होते. याचे कारण watch मध्ये नसून तुमच्या shell मध्ये असते.

watch docker compose ps | grep web

तुमचा interactive shell कोणतीही कमांड चालवण्यापूर्वी संपूर्ण ओळ वाचतो आणि pipe वर ती ओळ विभाजित करतो. तो watch docker compose ps सुरू करतो आणि watch च्या स्वतःच्या screen output ला grep शी जोडतो. watch आता terminal वर लिहित नसल्यामुळे display चुकीचा किंवा रिकामा दिसतो. तसेच grep container list ऐवजी redraw output filter करते.

संपूर्ण pipeline ला quotes मध्ये लिहा, जेणेकरून ती एकाच 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'

पहिल्या ओळीत Enter दाबताच तुमचा shell glob एकदाच expand करतो. त्यानंतर watch filename ची स्थिर झालेली यादी पुन्हा चालवतो. त्यामुळे एका मिनिटानंतर तयार झालेली log file दिसत नाही. दुसऱ्या ओळीत glob watch कडे पाठवला जातो. watch प्रत्येक cycle मध्ये sh च्या आत तो expand करतो, त्यामुळे नवीन files आपोआप दिसतात.

Quotes मुळे variable किंवा command substitution कधी evaluate होईल हेही ठरते. 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 ठेवा.

Quotes वापरणे अवघड होत असल्यास -x (--exec) command थेट चालवतो; तो sh -c मार्फत चालवत नाही. Spaces असलेले arguments हाताळणे सोपे होते. मात्र pipes आणि globs पूर्णपणे काम करणे थांबवतात, कारण त्यांचा अर्थ लावण्यासाठी shell उरत नाही.

Privileges बाबतही हाच नियम लागू होतो, कारण watch ही सामान्य process आहे. watch 'sudo ss -tulpn' असा password prompt दाखवतो जो तुम्हाला दिसत नाही किंवा ज्यात तुम्ही input देऊ शकत नाही. त्याऐवजी sudo watch 'ss -tulpn' चालवा. तसे केल्यावर Ctrl+C दाबेपर्यंत संपूर्ण loop root म्हणून चालतो हे लक्षात ठेवा.

VPS वर लक्ष ठेवण्यासारख्या चार गोष्टी

भरत चाललेली disk

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

df kernel कडे आधीपासून उपलब्ध असलेली आकडेवारी मागते, त्यामुळे ती सतत पुन्हा चालवणे पुरेसे स्वस्त असते. du -sh /var/log तसे नाही, कारण प्रत्येक cycle मध्ये ते tree मधील प्रत्येक file तपासते. watch अंतर्गत ते disk सतत वाचते आणि तुम्ही निदान करण्याचा प्रयत्न करत असलेल्या machine ची गती कमी करते. du एकदा चालवा किंवा ncdu वापरा. त्यानंतर संख्या अजून वाढत आहे का हे पाहण्यासाठी df watch अंतर्गत चालवा.

वारंवार restart होणारा container

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

Status column प्रत्येक container किती वेळेपासून सुरू आहे ते दाखवतो. Crash loop मध्ये असलेला container पुन्हा पुन्हा "Up 2 seconds" वर reset होतो आणि -d हे एका दृष्टीक्षेपात स्पष्ट करते. प्रथम directory बदला, कारण watch तो सुरू करणाऱ्या shell ची working directory वापरते आणि docker compose ला त्याची project directory आवश्यक असते. watch restart होत असल्याचे सांगते. 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 एक ओळ, notAfter=Nov 7 09:14:22 2026 GMT, आणि त्याव्यतिरिक्त काहीही print करते. त्यामुळे file renewed file ने replace होताच -g नेमके तेव्हाच कार्यान्वित होते. /etc/letsencrypt/live अंतर्गत असलेल्या files फक्त root ला वाचता येतात. म्हणून हे root shell मध्ये चालवले जाते. लक्षात ठेवा, हे disk वरील certificate वर लक्ष ठेवते. Running web server reload होईपर्यंत जुने certificate memory मध्ये ठेवतो. त्यामुळे प्रत्यक्षात कोणते certificate serve केले जात आहे हे echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate ने तपासा. तसेच public host वर हा command दोन सेकंदांच्या interval ने चालवू नका. Renewal स्वतः systemd service आणि timer कडे सोपवलेले असते. systemctl list-timers ते पुढच्या वेळी कधी चालेल हे दाखवते.

रिकामी होत जाणारी 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 तपासू शकत नाही. त्यामुळे count शून्यावर पोहोचला आहे हे ते कधीही सांगू शकत नाही. साधा shell loop हे करू शकतो. प्रत्येक pass मधील count capture करण्यासाठी command substitution वापरा:

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

watch command हे योग्य साधन नसते

watch प्रत्येक वेळी तुमची command पुन्हा चालवतो. मागील run ची कोणतीही माहिती त्याच्याकडे राहत नाही आणि ती command काय करते याचीही त्याला जाणीव नसते. df साठी हे योग्य आहे. मात्र खालील चार परिस्थितींमध्ये ते चुकीचे साधन आहे.

• Logs. watch ठरावीक frame पुन्हा दाखवतो. त्यामुळे दोन cycles च्या दरम्यान दिसून scroll होऊन गेलेल्या lines हरवतात. journalctl -fu nginx किंवा tail -f वापरा. या commands लिहिल्या जाणाऱ्या नवीन lines सतत stream करतात.
• Expensive commands. du -sh / किंवा व्यस्त database वरील query कोणत्याही interval वर कायमचा background load निर्माण करू शकते. कारण watch ती command पुन्हा पुन्हा सुरू करत राहतो.
• Anything with side effects. लिहिणारी, post करणारी, restart करणारी किंवा install करणारी command प्रत्येक cycle मध्ये ते काम पुन्हा करेल. API विरुद्ध दर दोन seconds ला केलेला curl दिवसाला 43,200 requests करतो. त्यामुळे free API key suspend होऊ शकते.
• Long-lived checks. watch तुमच्या terminal मध्ये चालतो आणि तुमचे session संपल्यावर बंद होतो. तो कोणालाही alert करत नाही आणि laptop बंद केल्यानंतर कोणताही history ठेवत नाही. त्यासाठी Uptime Kuma सारखा खरा status monitor किंवा server वर चालणारी scheduled check वापरा.

याची खरी मर्यादा वेळ ही आहे. एखादी विशिष्ट गोष्ट घडण्याची दहा minutes प्रतीक्षा करताना watch वापरा. उद्याही तपासणी सुरू राहणे आवश्यक असेल, तर ते scheduled timer किंवा खऱ्या monitor कडे सोपवा.

SSH वापरत असताना watch tmux मध्ये चालवा

SSH द्वारे वापरताना watch ची टिकाऊपणा connection इतकीच असते. Link तुटल्यावर तुमच्या shell ला SIGHUP मिळतो आणि watch देखील बंद होते. tmux ही समस्या सोडवतो. त्यामुळे remote box वर watch खरोखर उपयुक्त ठरतो.

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

Detach करण्यासाठी Ctrl+b आणि नंतर d दाबा. Loop server वर सुरूच राहतो. नंतर पुन्हा connect करण्यासाठी tmux attach -t ops वापरा. Frame अजूनही update होत असेल आणि header मधील clock सुरू असल्याचे दिसत असेल. Window split केल्यावर एका बाजूला watch आणि दुसऱ्या बाजूला journalctl -f ठेवता येतात. हीच tmux आधारित terminal workbench ची मुख्य संकल्पना आहे. एकच प्रश्न एकाच वेळी अनेक boxes वर लागू होत असेल, तर watch panes ची भिंत उभी करण्याऐवजी अनेक Linux servers व्यवस्थापित करण्यासाठी तयार केलेले tool वापरा.

येथे दिलेले screens केवळ उदाहरणासाठी आहेत. Column layout आणि version strings distributions तसेच procps-ng releases नुसार बदलतात. त्यामुळे तुमच्या machine वर तुमच्या build मध्ये प्रत्यक्ष उपलब्ध असलेले flags पाहण्यासाठी man watch वाचा.

FAQ

watch mycmd | grep foo मधील pipe कडे watch दुर्लक्ष का करतो?

watch सुरू होण्यापूर्वीच तुमचा shell ही ओळ pipe वर विभाजित करतो. त्यामुळे watch चे स्वतःचे screen drawing grep कडे pipe केले जाते आणि command च्या output वर filter लागू होत नाही. संपूर्ण pipeline ला quote करा: watch 'mycmd | grep foo'. watch हा एकच argument sh -c कडे देतो आणि sh -c प्रत्येक cycle मध्ये pipeline एकदा चालवतो. हाच नियम globs आणि command substitution साठीही लागू होतो.

watch सोबत कोणता interval वापरावा?

तो value किती वेगाने बदलतो आणि एक run किती खर्चिक आहे, यानुसार interval ठरवा. जलद counters साठी अर्धा सेकंद योग्य आहे आणि 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 चा मागोवा घेऊ शकतो का?

नाही. watch एक frame पुन्हा draw करतो आणि कोणताही history ठेवत नाही. त्यामुळे दोन cycles दरम्यान दिसून scroll होऊन गेलेली कोणतीही line कायमची हरवते. journalctl -fu <unit> आणि tail -f नवीन lines उपलब्ध होताच stream करतात. Logs साठी हेच आवश्यक असते. सध्याची state असलेल्या values साठी watch वापरा, जसे disk percentage किंवा queue length.

मी ज्या घटनेची वाट पाहत आहे ती घडल्यावर watch कसा थांबवू?

-g (--chgexit) वापरा आणि अशी command द्या जिचे output ती घटना घडेपर्यंत समान राहते. Clock किंवा PID असलेले output पहिल्याच refresh वेळी बदलते आणि लगेच exit होते. त्यामुळे systemctl is-active myapp तेथे काम करते जिथे systemctl status myapp काम करत नाही. Count शून्यावर पोहोचण्यासारख्या वास्तविक 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 वापरा.