Linux watch command का सही उपयोग कैसे करें

watch command क्या करता है

watch command किसी अन्य command को एक निश्चित अंतराल पर बार-बार चलाती है और उसके output को स्क्रीन पर उसी स्थान पर फिर से दिखाती है। डिफ़ॉल्ट अंतराल दो सेकंड का है। जब आप किसी संख्या के बदलने का इंतज़ार कर रहे हों, तो इसका उपयोग करें: जैसे डिस्क का भरना, container का स्थिर होना, certificate renewal का पूरा होना, या queue का खाली होना।

watch, procps-ng से आता है और एक नए Ubuntu या Debian VPS पर procps package के हिस्से के रूप में पहले से ही installed होता है। नीचे दिए गए किसी भी flag पर भरोसा करने से पहले अपना version जाँच लें, क्योंकि उपयोगी विकल्पों में से दो हाल ही के हैं।

watch --version

Ubuntu 24.04 पर यह watch from procps-ng 4.0.4 जैसी एक लाइन print करता है। अब सबसे सरल उपयोगी उदाहरण देखें।

watch df -h /

स्क्रीन साफ़ हो जाती है और एक header लाइन, एक खाली लाइन, और फिर df -h / का output दिखाई देता है:

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

बाईं ओर अंतराल और वह सटीक command है जिसे watch चला रहा है। दाईं ओर hostname और वर्तमान समय है। घड़ी वाला हिस्सा उपयोगी है, क्योंकि यह साबित करता है कि स्क्रीन अभी भी refresh हो रही है, भले ही नीचे की संख्याएँ न बदल रही हों। बाहर निकलने के लिए Ctrl+C दबाएं।

watch एक ऐसा frame बनाता है जो terminal में फिट हो जाए। लंबी लाइनें wrap हो जाती हैं, जबकि -w उन्हें काट (truncate) देता है, और नीचे की पंक्ति से आगे का कुछ भी दिखाई नहीं देता। frame के अंदर कोई scrollback नहीं होता, क्योंकि हर cycle पिछली सामग्री को overwrite कर देता है। यही एकमात्र तथ्य यह तय करता है कि watch किसके लिए सबसे उपयुक्त है।

watch को कमांड कितनी बार फिर से चलाना चाहिए?

दो सेकंड केवल एक डिफ़ॉल्ट मान है। अंतराल का चयन इस आधार पर करें कि मान कितनी तेजी से बदलता है और एक बार कमांड चलाने में कितनी लागत (संसाधन) लगती है।

• -n 0.5 उन काउंटरों के लिए जो लगातार बदलते रहते हैं, जैसे कि ss -s या इंटरफ़ेस बाइट काउंट। watch द्वारा स्वीकार किया जाने वाला सबसे छोटा अंतराल 0.1 सेकंड है।
• -n 30 या -n 60 डिस्क और प्रमाणपत्रों के लिए। जो फाइलसिस्टम एक दिन में भरता है, उसे प्रति मिनट तीस फ्रेम की आवश्यकता नहीं होती है।

watch कमांड को चलाता है, उसके समाप्त होने की प्रतीक्षा करता है, और उसके बाद ही अंतराल के लिए स्लीप मोड में जाता है। रनटाइम अंतराल में जुड़ जाता है, इसलिए जो कमांड -n 2 के तहत आठ सेकंड लेती है, वह आपको हर दस सेकंड में एक फ्रेम देती है और मशीन को पूरे समय व्यस्त रखती है। -p (--precise) जोड़ें और watch इसके बजाय हर अंतराल सेकंड में एक रन शुरू करने का लक्ष्य रखेगा, जिसे एक रन की शुरुआत से अगले रन की शुरुआत तक मापा जाता है।

यदि आप हमेशा एक अलग डिफ़ॉल्ट मान चाहते हैं, तो अपने शेल प्रोफ़ाइल में WATCH_INTERVAL को एक्सपोर्ट करें। एक स्पष्ट -n अभी भी उस पर प्रभावी रहेगा। यह पुष्टि करने के लिए कि आपका बिल्ड उस वेरिएबल को पढ़ता है, watch --help चलाएँ।

-d के साथ क्या बदला है, इसे हाइलाइट करें

एक जैसे टेक्स्ट की लंबी सूची को पढ़कर यह पता लगाना कि कौन सा field बदला है, कठिन काम है। -d (--differences) आपके लिए यह काम करता है।

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

पिछले frame से जो characters अलग होते हैं, उन्हें reverse video में दिखाया जाता है। इसलिए, जैसे ही Use% cell बदलती है, वह चमकने लगती है और बाकी सब स्थिर रहता है। यदि /var एक अलग filesystem नहीं है, तो आपको root filesystem दो बार दिखाई देगा। यह जानने का एक त्वरित तरीका है कि box को कैसे partition किया गया था।

तुलना positional होती है, जिसका अर्थ है कि watch नए frame को पुराने frame के साथ character-दर-character मिलाता है। जिन output के columns की चौड़ाई बदलती है, वे लगभग पूरी तरह से चमकने लगेंगे, इसलिए स्थिर layout वाले commands को प्राथमिकता दें। वर्तमान procps-ng watch --differences=permanent को भी स्वीकार करता है, जो केवल सबसे हालिया बदलाव के बजाय हर उस position को हाइलाइट रखता है जो कभी भी बदली है। इस पर निर्भर होने से पहले watch --help के साथ इसकी पुष्टि करें।

मैं watch को आउटपुट बदलने पर exit कैसे करूँ?

-g (--chgexit) का उपयोग करने पर watch पहली बार आउटपुट में बदलाव आते ही रुक जाता है। इसके बाद आपका prompt वापस आ जाता है, इसलिए आप एक ही लाइन में इसके बाद कोई अन्य कमांड भी लिख सकते हैं।

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

यह वह flag है जो watch को "deploy पूरा होने पर मुझे सूचित करें" टूल में बदल देता है। इसमें एक सामान्य समस्या है जो सभी को प्रभावित करती है: तुलना पूरे आउटपुट पर की जाती है, इसलिए यदि आउटपुट में कोई clock या PID (process identifier) है, तो वह पहले ही refresh में बदल जाएगा और watch तुरंत exit हो जाएगा। systemctl status myapp elapsed time और memory usage प्रिंट करता है, इसलिए इस पर -g का उपयोग करना व्यर्थ है। कमांड को केवल उस स्थिर जानकारी तक सीमित रखें जिसका आप इंतजार कर रहे हैं, जो कि systemctl is-active आपको प्रदान करता है।

नए procps-ng में इसके विपरीत परीक्षण, --equexit <cycles>, जोड़ा गया है, जो आउटपुट के उतने cycles तक स्थिर रहने के बाद exit हो जाता है। यह "मुझे बताएं कि यह कब शांत हो गया है" का उत्तर देता है। watch --help की जाँच करें, क्योंकि पुराने builds में यह सुविधा उपलब्ध नहीं है।

watch मेरे pipe और glob को अनदेखा क्यों करता है?

यह वह विफलता है जिसका सामना हर कोई एक बार जरूर करता है, और इसका कारण 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 को 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'

पहली लाइन glob को एक बार, आपके shell में, Enter दबाते ही expand कर देती है। watch फिर filenames की एक स्थिर सूची को बार-बार चलाता है, इसलिए एक मिनट बाद बनाई गई log file कभी दिखाई नहीं देती। दूसरी लाइन glob को watch को सौंपती है, जो इसे हर cycle पर sh के भीतर expand करता है, इसलिए नई files अपने आप दिखाई देने लगती हैं।

Quotes यह भी तय करते हैं कि variable या command substitution का मूल्यांकन कब किया जाए। watch "echo $(date)", date को आपके shell में एक बार चलाता है, और फिर उस fixed string को हमेशा echo करता रहता है। watch 'echo $(date)', date को हर cycle में चलाता है। Single quotes का अर्थ है बाद में। Double quotes का अर्थ है अभी।

उस sh -c के दो और परिणाम हैं:

• Aliases और shell functions इसके भीतर मौजूद नहीं होते हैं। watch ll, sh: 1: ll: not found के साथ विफल हो जाता है, क्योंकि sh -c कभी भी आपके .bashrc को नहीं पढ़ता है। वास्तविक command लिखें, या उस binary का पूरा path दें जो केवल आपके interactive 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' एक password prompt पर रुक जाता है जिसे आप देख या टाइप नहीं कर सकते। इसके बजाय sudo watch 'ss -tulpn' चलाएँ, और याद रखें कि तब तक पूरा loop root के रूप में चलता है जब तक आप Ctrl+C नहीं दबाते।

VPS पर निगरानी रखने योग्य चार चीजें

भरती हुई डिस्क

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

df कर्नल से वे आंकड़े मांगता है जो उसके पास पहले से मौजूद हैं, इसलिए इसे बार-बार चलाना सस्ता पड़ता है। du -sh /var/log ऐसा नहीं है, क्योंकि यह हर चक्र में ट्री की प्रत्येक फाइल को स्कैन करता है। निगरानी के दौरान यह लगातार डिस्क को पढ़ता है और उस मशीन को धीमा कर देता है जिसे आप डायग्नोस करने की कोशिश कर रहे हैं। du को एक बार चलाएं, या ncdu का उपयोग करें, फिर df को निगरानी में छोड़ दें ताकि आपको पता चल सके कि संख्या अभी भी बढ़ रही है या नहीं।

बार-बार रीस्टार्ट होता कंटेनर

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

स्टेटस कॉलम दिखाता है कि प्रत्येक कंटेनर कितनी देर से चल रहा है। क्रैश लूप में फंसा कंटेनर बार-बार "Up 2 seconds" पर रीसेट होता रहता है, और -d इसे एक नज़र में स्पष्ट कर देता है। पहले डायरेक्टरी बदलें, क्योंकि watch उस शेल की वर्किंग डायरेक्टरी को इनहेरिट करता है जिसने इसे शुरू किया है और docker compose को अपनी प्रोजेक्ट डायरेक्टरी की आवश्यकता होती है। watch आपको बताता है कि रीस्टार्ट हो रहा है। docker compose logs -f web आपको कारण बताता है। एक बार जब आप कारण जान जाते हैं, तो उत्तर को एक Compose healthcheck में बदलें जो आपके लिए कंटेनर को रीस्टार्ट करे ताकि किसी को स्क्रीन के सामने बैठकर उसे देखते न रहना पड़े।

सर्टिफिकेट रिन्यूअल का पूरा होना

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

यह कमांड एक लाइन, notAfter=Nov 7 09:14:22 2026 GMT, और कुछ नहीं प्रिंट करती है, इसलिए -g ठीक उसी समय ट्रिगर होता है जब फाइल को रिन्यू की गई फाइल से बदल दिया जाता है। /etc/letsencrypt/live के अंतर्गत फाइलें केवल root द्वारा पढ़ी जा सकती हैं, इसीलिए यह root शेल में चलता है। ध्यान दें कि यह डिस्क पर मौजूद सर्टिफिकेट की निगरानी करता है। एक चलता हुआ वेब सर्वर पुराने सर्टिफिकेट को तब तक मेमोरी में रखता है जब तक कि वह रीलोड न हो जाए, इसलिए echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate के साथ जांचें कि वास्तव में क्या सर्व किया जा रहा है, और उस कमांड को पब्लिक होस्ट पर दो सेकंड के अंतराल पर न रखें। रिन्यूअल का कार्य एक systemd service और timer का है, और systemctl list-timers दिखाता है कि यह अगली बार कब चलेगा।

खाली होती कतार (Queue)

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

यह -- 24 Kbytes in 6 Requests. जैसी एक सारांश लाइन प्रिंट करता है, या पूरा होने पर Mail queue is empty। यही तरीका किसी भी ऐसी कतार के लिए काम करता है जिसे आप गिन सकते हैं: watch -n 5 'find /srv/queue/incoming -type f | wc -l'।

यहाँ watch अपनी सीमा तक पहुँच जाता है। यह एक फ्रेम की तुलना पिछले फ्रेम से करता है, और यह किसी शर्त (condition) का परीक्षण नहीं कर सकता, इसलिए यह आपको कभी नहीं बता सकता कि "गिनती शून्य तक पहुँच गई है"। एक साधारण शेल लूप ऐसा कर सकता है, जो प्रत्येक पास पर गिनती को कैप्चर करने के लिए command substitution का उपयोग करता है:

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

जब watch command सही tool न हो

watch आपके command को पिछली बार के execution की जानकारी रखे बिना बार-बार चलाता है और उसे यह नहीं पता होता कि वह command क्या कर रहा है। यह df के लिए तो ठीक है, लेकिन चार स्थितियों में यह गलत है।

• Logs. watch एक निश्चित frame को फिर से draw करता है, इसलिए दो cycles के बीच आने वाली और scroll होकर गायब होने वाली lines खो जाती हैं। इसके बजाय journalctl -fu nginx या tail -f का उपयोग करें, जो नई lines के लिखे जाते ही उन्हें stream करते हैं।
• Expensive commands. du -sh / या किसी व्यस्त database पर की गई query किसी भी interval पर एक स्थायी background load बन जाती है, क्योंकि watch उसे बार-बार शुरू करता रहता है।
• Side effects वाली कोई भी चीज़. कोई भी command जो लिखता है, post करता है, restart करता है या install करता है, वह हर cycle पर फिर से वही काम करेगा। हर दो सेकंड में API के खिलाफ किया गया curl दिन भर में 43,200 requests बन जाता है, जिससे free API key suspend हो सकती है।
• Long-lived checks. watch आपके terminal में चलता है और आपके session के खत्म होते ही बंद हो जाता है। यह किसी को alert नहीं करता और laptop बंद करने के बाद कोई history नहीं रखता। इसके लिए आपको Uptime Kuma जैसा एक वास्तविक status monitor चाहिए, या फिर server पर चलने वाला एक scheduled check।

समय ही वह वास्तविक सीमा है। watch उन दस मिनटों के लिए है जो आप किसी विशिष्ट चीज़ के होने के इंतज़ार में बिताते हैं। जो कुछ भी कल भी check किया जाना चाहिए, उसे एक scheduled timer या वास्तविक monitor में होना चाहिए।

SSH पर होने पर tmux के अंदर watch चलाएं

SSH के माध्यम से, watch की निरंतरता केवल कनेक्शन की स्थिरता पर निर्भर करती है। जब लिंक टूटता है, तो आपकी shell को SIGHUP प्राप्त होता है और यह watch को भी बंद कर देता है। tmux इस समस्या का समाधान करता है, और यही कारण है कि यह remote box पर watch को वास्तव में उपयोगी बनाता है।

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

Detach करने के लिए Ctrl+b और फिर d दबाएं। लूप सर्वर पर चलता रहता है। बाद में tmux attach -t ops के साथ फिर से कनेक्ट करें और फ्रेम अभी भी अपडेट हो रहा होगा, जिसे हेडर क्लॉक से सत्यापित किया जा सकता है। विंडो को split करें और आप एक तरफ watch और दूसरी तरफ journalctl -f रख सकते हैं, जो कि tmux आधारित टर्मिनल वर्कबेंच के पीछे का मुख्य विचार है। जब एक ही प्रश्न कई बॉक्स पर एक साथ लागू होता है, तो यह काम कई Linux सर्वर प्रबंधित करने के लिए बने टूल का है, न कि watch panes की एक दीवार का।

यहाँ दी गई स्क्रीन केवल उदाहरण के लिए हैं। कॉलम लेआउट और version strings अलग-अलग distributions और procps-ng releases के बीच भिन्न हो सकते हैं, इसलिए अपनी मशीन पर उन flags के लिए man watch पढ़ें जो वास्तव में आपके build में उपलब्ध हैं।

FAQ

watch, watch mycmd | grep foo में पाइप (pipe) को अनदेखा क्यों करता है?

आपका शेल watch शुरू होने से पहले ही लाइन को पाइप पर विभाजित कर देता है। इस कारण यह watch के स्वयं के स्क्रीन ड्राइंग को grep में पाइप कर देता है, और कमांड का आउटपुट कभी फिल्टर नहीं होता। पूरे पाइपलाइन को कोट (quote) करें: watch 'mycmd | grep foo'। watch उस एकल तर्क को sh -c को सौंप देता है, जो हर चक्र में एक बार पाइपलाइन को चलाता है। यही नियम ग्लोब्स (globs) और कमांड सब्स्टिट्यूशन पर भी लागू होता है।

watch के साथ मुझे कौन सा अंतराल (interval) उपयोग करना चाहिए?

इसे इस आधार पर चुनें कि मान कितनी तेजी से बदलता है और एक बार चलने में कमांड कितनी महंगी है। आधा सेकंड तेज काउंटरों के लिए उपयुक्त है, और 0.1 सेकंड सबसे छोटा अंतराल है जिसे watch स्वीकार करता है। डिस्क और सर्टिफिकेट के लिए तीस से साठ सेकंड का समय सही रहता है। कमांड का रनटाइम अंतराल में जुड़ जाता है, जब तक कि आप -p का उपयोग न करें। इसलिए -n 1 के तहत एक धीमी कमांड बिना रुके लगातार चलती रहती है।

क्या watch किसी लॉग फाइल को फॉलो कर सकता है?

नहीं। watch एक फ्रेम को फिर से बनाता है और कोई इतिहास नहीं रखता, इसलिए दो चक्रों के बीच जो भी लाइन आती है और स्क्रॉल हो जाती है, वह हमेशा के लिए चली जाती है। journalctl -fu <unit> और tail -f नई लाइनों को आते ही स्ट्रीम करते हैं, जो लॉग के लिए आवश्यक है। watch का उपयोग उन मानों के लिए करें जिनकी वर्तमान स्थिति होती है, जैसे डिस्क प्रतिशत या कतार की लंबाई।

जब मैं जिस चीज का इंतजार कर रहा हूं वह हो जाए, तो watch को कैसे रोकूं?

-g (--chgexit) का उपयोग करें और इसे एक ऐसी कमांड दें जिसका आउटपुट उस घटना के होने तक समान रहे। घड़ी या PID वाला आउटपुट पहले रिफ्रेश पर ही बदल जाता है और तुरंत बाहर निकल जाता है, इसलिए systemctl is-active myapp वहां काम करता है जहां systemctl status myapp नहीं करता। वास्तविक स्थिति जैसे कि काउंट का शून्य तक पहुंचना, के लिए शेल until लूप का उपयोग करें, क्योंकि watch केवल यह पता लगा सकता है कि आउटपुट बदल गया है।

watch किसी ऐसी चीज के लिए 'command not found' क्यों कहता है जो मेरे शेल में काम करती है?

watch कमांड को sh -c को पास करता है, और वह शेल .bashrc को नहीं पढ़ता है, इसलिए आपके एलायस (aliases) और शेल फंक्शन्स वहां मौजूद नहीं होते हैं। संदेश आमतौर पर sh: 1: ll: not found होता है। वास्तविक कमांड लिखें, या उस बाइनरी के लिए पूर्ण पथ (full path) का उपयोग करें जो केवल आपके इंटरैक्टिव PATH पर स्थित है।