Linux watch கட்டளையை சரியாக பயன்படுத்துவது எப்படி?

watch கட்டளை என்ன செய்கிறது

watch கட்டளையானது, மற்றொரு கட்டளையை ஒரு குறிப்பிட்ட கால இடைவெளியில் மீண்டும் இயக்கி, அதன் வெளியீட்டைத் திரையில் ஒரே இடத்தில் மீண்டும் வரைகிறது. இயல்பான கால இடைவெளி இரண்டு வினாடிகள் ஆகும். ஒரு எண் மாறுவதற்காக நீங்கள் காத்திருக்கும்போது இதைப் பயன்படுத்தவும்: வட்டு (disk) நிரம்புதல், container நிலைபெறுதல், certificate புதுப்பித்தல் அல்லது வரிசை (queue) காலியாதல் போன்ற சூழல்களில் இது உதவும்.

watch ஆனது procps-ng தொகுப்பிலிருந்து வருகிறது, மேலும் இது புதிய Ubuntu அல்லது Debian VPS-ல் procps தொகுப்பின் ஒரு பகுதியாக ஏற்கனவே நிறுவப்பட்டிருக்கும். கீழே உள்ள எந்தவொரு flag-ஐயும் பயன்படுத்துவதற்கு முன்பு உங்கள் பதிப்பைச் சரிபார்க்கவும், ஏனெனில் பயனுள்ள விருப்பங்களில் இரண்டு சமீபத்தியவை.

watch --version

Ubuntu 24.04-ல் இது watch from procps-ng 4.0.4 போன்ற ஒரு வரியை அச்சிடும். இப்போது மிகவும் எளிமையான பயனுள்ள உதாரணத்தைப் பார்ப்போம்.

watch df -h /

திரை சுத்தப்படுத்தப்பட்டு, ஒரு தலைப்பு வரி, ஒரு காலியான வரி, பின்னர் df -h /-ன் வெளியீடு காட்டப்படும்:

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

இடதுபுறத்தில் கால இடைவெளியும், watch இயக்கும் துல்லியமான கட்டளையும் இருக்கும். வலதுபுறத்தில் hostname மற்றும் தற்போதைய நேரம் இருக்கும். கடிகாரம் பயனுள்ள பாதியாக இருக்கிறது, ஏனெனில் கீழே உள்ள எண்கள் மாறாதபோதும் திரை தொடர்ந்து புதுப்பிக்கப்படுகிறது என்பதை இது உறுதிப்படுத்துகிறது. வெளியேற Ctrl+C அழுத்தவும்.

watch ஆனது terminal-க்கு ஏற்றவாறு ஒரு சட்டத்தை (frame) வரைகிறது. நீண்ட வரிகள் மடிக்கப்படும் (wrap), -w அவற்றைக் குறுக்கிவிடும் (truncate), மேலும் கீழ் வரிசைக்குக் கீழே உள்ள எதுவும் வரையப்படாது. சட்டத்திற்குள் scrollback வசதி இல்லை, ஏனெனில் ஒவ்வொரு சுழற்சியும் முந்தையதை அழித்துவிட்டு புதியதை எழுதும். இந்த ஒற்றை உண்மைதான் watch எதற்குப் பொருந்தும் என்பதைத் தீர்மானிக்கிறது.

watch கட்டளையை எவ்வளவு அடிக்கடி இயக்க வேண்டும்?

இரண்டு வினாடிகள் என்பது ஒரு இயல்புநிலை (default) மட்டுமே. மதிப்புகள் எவ்வளவு வேகமாக மாறுகின்றன மற்றும் ஒருமுறை இயக்குவதற்கு எவ்வளவு செலவாகிறது என்பதைப் பொறுத்து இடைவெளியைத் தேர்வு செய்யவும்.

• -n 0.5: ss -s அல்லது interface byte count போன்ற தொடர்ந்து மாறும் counters-க்கு இதைப் பயன்படுத்தவும். watch ஏற்கும் மிகச்சிறிய இடைவெளி 0.1 வினாடிகள் ஆகும்.
• -n 30 அல்லது -n 60: disks மற்றும் certificates-க்கு இதைப் பயன்படுத்தவும். ஒரு நாளில் நிரம்பும் filesystem-க்கு நிமிடத்திற்கு முப்பது frames தேவையில்லை.

watch கட்டளையை இயக்கி, அது முடிவடையும் வரை காத்திருந்து, அதன் பிறகுதான் இடைவெளி நேரத்திற்கு உறங்கும் (sleep). கட்டளை இயங்கும் நேரம் இடைவெளியுடன் சேர்க்கப்படும். எனவே, -n 2-ன் கீழ் எட்டு வினாடிகள் எடுக்கும் ஒரு கட்டளை, ஒவ்வொரு பத்து வினாடிகளுக்கும் ஒரு frame-ஐத் தரும் மற்றும் இயந்திரத்தை எப்போதும் பிஸியாக வைத்திருக்கும். -p (--precise)-ஐச் சேர்த்தால், ஒரு இயக்கம் தொடங்கும் நேரத்திலிருந்து அடுத்த இயக்கம் தொடங்கும் நேரம் வரை கணக்கிடப்பட்டு, ஒவ்வொரு இடைவெளி வினாடிகளிலும் ஒரு இயக்கத்தைத் தொடங்க watch முயற்சிக்கும்.

உங்களுக்கு எப்போதும் வேறு ஒரு இயல்புநிலை தேவைப்பட்டால், உங்கள் shell profile-ல் WATCH_INTERVAL-ஐ export செய்யவும். ஒரு குறிப்பிட்ட -n எப்போதும் அதைவிட முன்னுரிமை பெறும். உங்கள் build அந்த variable-ஐப் படிக்கிறதா என்பதை உறுதிப்படுத்த watch --help-ஐ இயக்கவும்.

-d flag மூலம் ஏற்படும் மாற்றங்களை முன்னிலைப்படுத்துதல்

ஒரே மாதிரியான உரைத் தொகுப்பில் மாறியுள்ள ஒரு குறிப்பிட்ட புலத்தைக் கண்டறிவது கடினமான வேலை. -d (--differences) இந்த வேலையை உங்களுக்காகச் செய்கிறது.

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

முந்தைய திரையில் இருந்து மாறுபடும் எழுத்துக்கள் reverse video-வில் காட்டப்படும். எனவே, ஒரு Use% cell நகரும் தருணத்தில் அது ஒளிரும், மற்றவை அமைதியாக இருக்கும். /var என்பது தனி filesystem இல்லை என்றால், root filesystem இரண்டு முறை பட்டியலிடப்படுவதைக் காண்பீர்கள். சர்வர் எவ்வாறு partition செய்யப்பட்டுள்ளது என்பதை அறிய இது ஒரு விரைவான வழியாகும்.

இந்த ஒப்பீடு இட அமைப்பின் (positional) அடிப்படையில் அமைகிறது. அதாவது, புதிய திரையில் உள்ள வரிகளை பழைய திரையுடன் எழுத்து வாரியாக ஒப்பிடுகிறது. நெடுவரிசைகளின் அகலம் மாறும் வெளியீடுகள் முழுமையாக ஒளிரும் என்பதால், நிலையான அமைப்பைக் கொண்ட கட்டளைகளைப் பயன்படுத்துவது சிறந்தது. தற்போதைய procps-ng பதிப்பில் watch --differences=permanent வசதியும் உள்ளது. இது சமீபத்திய மாற்றத்தை மட்டும் காட்டாமல், இதுவரை மாறிய அனைத்து இடங்களையும் தொடர்ந்து ஒளிரச் செய்யும். இதைச் சார்ந்திருக்கும் முன் watch --help மூலம் உறுதிப்படுத்திக் கொள்ளுங்கள்.

வெளியீடு மாறும்போது watch கட்டளையை எவ்வாறு வெளியேறச் செய்வது?

-g (--chgexit) கொடியானது, முந்தைய இயக்கத்திலிருந்து வெளியீடு மாறுபட்டவுடன் watch கட்டளையை நிறுத்திவிடும். உங்கள் prompt மீண்டும் வருவதால், அதே வரியில் நீங்கள் வேறு ஏதேனும் கட்டளையைச் சேர்க்கலாம்.

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

இது watch கட்டளையை "deploy முடிந்தவுடன் எனக்குத் தெரியப்படுத்து" என்ற கருவியாக மாற்றும் கொடியாகும். இதில் ஒரு சிக்கல் உள்ளது, இது அனைவரையும் பாதிக்கும்: ஒப்பீடு முழு வெளியீட்டையும் உள்ளடக்கியது, எனவே அதில் உள்ள கடிகாரம் அல்லது PID (process identifier) முதல் refresh-லேயே மாறிவிடும், இதனால் watch உடனடியாக வெளியேறிவிடும். systemctl status myapp கட்டளையானது கடந்த நேரம் மற்றும் memory பயன்பாட்டை அச்சிடும், எனவே அதன் மீது -g பயன்படுத்துவது பயனற்றது. நீங்கள் எதற்காகக் காத்திருக்கிறீர்களோ, அந்த நிலையான தகவலை மட்டும் தரும் வகையில் கட்டளையைச் சுருக்கவும், அதைத்தான் systemctl is-active உங்களுக்கு வழங்கும்.

புதிய procps-ng தொகுப்பில் இதற்கு நேர்மாறான சோதனை, --equexit <cycles> சேர்க்கப்பட்டுள்ளது. இது குறிப்பிட்ட சுழற்சிகளுக்கு வெளியீடு மாறாமல் இருந்தால் வெளியேறிவிடும். இது "இது எப்போது அமைதியாகிறது என்று எனக்குச் சொல்" என்ற கேள்விக்கு விடையளிக்கிறது. உங்கள் பதிப்பில் இது உள்ளதா என watch --help மூலம் சரிபார்க்கவும், ஏனெனில் பழைய build-களில் இது இருக்காது.

watch ஏன் எனது pipe மற்றும் glob-ஐ புறக்கணிக்கிறது?

இது அனைவரும் ஒருமுறை சந்திக்கும் தோல்வியாகும். இதன் காரணம் watch-ல் இல்லை, உங்கள் shell-ல் உள்ளது.

watch docker compose ps | grep web

நீங்கள் கட்டளையை இயக்கும் முன், உங்கள் interactive shell முழு வரியையும் வாசித்து, pipe-ஐ வைத்து அந்த வரியைப் பிரிக்கிறது. இது watch docker compose ps-ஐத் தொடங்கி, watch-ன் சொந்த screen output-ஐ grep-க்கு இணைக்கிறது. இப்போது watch ஒரு terminal-க்கு எழுதுவதில்லை, எனவே திரை சிதைந்து அல்லது காலியாக இருக்கும். மேலும், grep container பட்டியலுக்குப் பதிலாக, redraw output-ஐ வடிகட்டுகிறது.

முழு 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-ஐ ஒருமுறை விரிவுபடுத்துகிறது. அதன் பிறகு watch கோப்புப் பெயர்களின் உறைந்த (frozen) பட்டியலையே மீண்டும் மீண்டும் இயக்குகிறது; எனவே ஒரு நிமிடம் கழித்து உருவாக்கப்பட்ட log கோப்பு அதில் தோன்றாது. இரண்டாவது வரி glob-ஐ watch-க்கு அனுப்புகிறது. இது ஒவ்வொரு சுழற்சியிலும் sh-க்குள் அதை விரிவுபடுத்துவதால், புதிய கோப்புகள் தானாகவே தோன்றும்.

ஒரு variable அல்லது command substitution எப்போது மதிப்பீடு செய்யப்பட வேண்டும் என்பதையும் மேற்கோள் குறிகளே தீர்மானிக்கின்றன. watch "echo $(date)" என்பது date-ஐ உங்கள் shell-ல் ஒருமுறை இயக்கி, அந்த நிலையான string-ஐ எப்போதும் echo செய்கிறது. watch 'echo $(date)' என்பது ஒவ்வொரு சுழற்சியிலும் date-ஐ இயக்குகிறது. ஒற்றை மேற்கோள் குறிகள் (single quotes) தாமதத்தைக் குறிக்கின்றன. இரட்டை மேற்கோள் குறிகள் (double quotes) உடனடியைக் குறிக்கின்றன.

அந்த sh -c-ன் மேலும் இரண்டு விளைவுகள்:

• Aliases மற்றும் shell functions அதற்குள் செயல்படாது. watch ll என்பது sh: 1: ll: not found-உடன் தோல்வியடையும், ஏனெனில் sh -c உங்கள் .bashrc-ஐ ஒருபோதும் வாசிப்பதில்லை. உண்மையான கட்டளையை முழுமையாக எழுதுங்கள் அல்லது உங்கள் interactive PATH-ல் மட்டுமே உள்ள binary-க்கு முழுப் பாதையை (full path) கொடுங்கள்.
• Standard error-ஐப் பிடிப்பது பயனுள்ளது. பிழைச் செய்திகள் திரையில் சிதறாமல், சட்டத்திற்குள் (frame) தெரிய வேண்டுமெனில், 2>&1-ஐ மேற்கோள் குறிகளுக்குள் இடுங்கள்.

மேற்கோள் குறிகளைப் பயன்படுத்துவது கடினமாக இருக்கும்போது, -x (--exec) கட்டளையை sh -c வழியாக இயக்காமல் நேரடியாக இயக்குகிறது. இடைவெளிகளைக் கொண்ட arguments-ஐக் கையாள்வது எளிதாகிறது. ஆனால், அவற்றை விளக்குவதற்கு shell இல்லாததால், pipes மற்றும் globs முற்றிலும் வேலை செய்வதை நிறுத்திவிடும்.

watch ஒரு சாதாரண process என்பதால், சலுகைகளும் (privileges) இதே தர்க்கத்தையே பின்பற்றுகின்றன. watch 'sudo ss -tulpn' என்பது உங்களால் பார்க்கவோ அல்லது தட்டச்சு செய்யவோ முடியாத password prompt-ஐக் காட்டும். அதற்குப் பதிலாக sudo watch 'ss -tulpn'-ஐ இயக்குங்கள். நீங்கள் Ctrl+C அழுத்தும் வரை முழு loop-ம் root பயனர் உரிமையுடன் இயங்கும் என்பதை நினைவில் கொள்ளுங்கள்.

VPS-ல் கவனிக்க வேண்டிய நான்கு விஷயங்கள்

நிரம்பிக்கொண்டிருக்கும் வட்டு (Disk)

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

df கர்னலிடம் ஏற்கனவே உள்ள தரவுகளைக் கேட்பதால், அதைத் தொடர்ந்து இயக்குவது சுலபமானது. du -sh /var/log அவ்வாறு அல்ல; அது ஒவ்வொரு சுழற்சியிலும் கோப்பு முறைமையில் உள்ள அனைத்து கோப்புகளையும் சரிபார்க்கும். watch கட்டளையின் கீழ் இயங்கும்போது, அது தொடர்ந்து வட்டை வாசிப்பதால், நீங்கள் சரிசெய்ய முயலும் கணினியின் வேகம் குறையும். du கட்டளையை ஒருமுறை இயக்கவும் அல்லது ncdu-ஐப் பயன்படுத்தவும். பின்னர், வட்டின் அளவு தொடர்ந்து அதிகரிக்கிறதா என்பதைக் கண்டறிய df-ஐ watch கட்டளையுடன் பயன்படுத்தவும்.

தொடர்ந்து restart ஆகும் container

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

status நெடுவரிசை ஒவ்வொரு container-ம் எவ்வளவு நேரமாக இயங்குகிறது என்பதைக் காட்டுகிறது. crash loop-ல் உள்ள ஒரு container தொடர்ந்து "Up 2 seconds" என்று காட்டும். -d இதைப் பார்த்தவுடன் புரிந்துகொள்ள உதவுகிறது. முதலில் அந்த directory-க்குச் செல்லவும், ஏனெனில் watch கட்டளை அதைத் தொடங்கிய shell-ன் working directory-யையே பயன்படுத்தும், மேலும் docker compose-க்கு அதன் project directory தேவை. ஒரு container restart ஆவதை watch காட்டுகிறது. docker compose logs -f web அதற்கான காரணத்தைக் கூறுகிறது. காரணம் தெரிந்தவுடன், அதை container-ஐ மீண்டும் தொடங்கும் Compose healthcheck ஆக மாற்றவும்; அப்போதுதான் நீங்கள் திரையைப் பார்த்துக்கொண்டிருக்க வேண்டிய அவசியம் இருக்காது.

சான்றிதழ் புதுப்பித்தல் (Certificate renewal)

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 shell-ல் இயங்குகிறது. வட்டில் உள்ள சான்றிதழை இது கவனிக்கிறது என்பதை நினைவில் கொள்க. இயங்கிக்கொண்டிருக்கும் web server, reload செய்யப்படும் வரை பழைய சான்றிதழையே நினைவகத்தில் வைத்திருக்கும். எனவே, echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate மூலம் உண்மையில் எந்தச் சான்றிதழ் வழங்கப்படுகிறது என்பதைச் சரிபார்க்கவும். பொதுவான host-ல் இந்த கட்டளையை இரண்டு வினாடி இடைவெளியில் இயக்க வேண்டாம். புதுப்பித்தல் செயல்முறை 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 கட்டளையின் வரம்பு தொடங்குகிறது. இது தற்போதைய திரையை முந்தைய திரையுடன் மட்டுமே ஒப்பிடும்; ஒரு நிபந்தனையைச் சோதிக்க முடியாது. எனவே, "எண்ணிக்கை பூஜ்ஜியத்தை அடைந்துவிட்டது" என்று உங்களால் சொல்ல முடியாது. ஒரு சாதாரண shell loop மூலம் இதைச் செய்யலாம், ஒவ்வொரு முறையும் எண்ணிக்கையைப் பிடிக்க 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 ஒரு நிலையான திரையை மட்டுமே புதுப்பிக்கும். எனவே, இரண்டு சுழற்சிகளுக்கு இடையில் தோன்றி மறையும் வரிகள் கண்காணிக்கப்படாது. இதற்குப் பதிலாக journalctl -fu nginx அல்லது tail -f-ஐப் பயன்படுத்தவும்; இவை புதிய வரிகள் எழுதப்படும்போது அவற்றை உடனுக்குடன் காட்டும்.
• அதிக சுமை கொண்ட கட்டளைகள் (Expensive commands). du -sh / அல்லது அதிக வேலைப்பளு கொண்ட database-ல் செய்யப்படும் query-கள், watch மூலம் தொடர்ந்து இயக்கப்படும்போது, அவை நிரந்தரமான பின்னணிச் சுமையாக மாறிவிடும்.
• பக்கவிளைவுகளைக் கொண்ட கட்டளைகள். தரவுகளை எழுதுதல், பதிவிடுதல், restart செய்தல் அல்லது நிறுவுதல் போன்ற செயல்களைச் செய்யும் கட்டளைகள், ஒவ்வொரு சுழற்சியிலும் மீண்டும் மீண்டும் இயங்கும். ஒரு API-க்கு எதிராக இரண்டு வினாடிகளுக்கு ஒருமுறை curl-ஐ இயக்குவது, ஒரு நாளைக்கு 43,200 கோரிக்கைகளை உருவாக்கும். இதுவே இலவச API key முடக்கப்படுவதற்கு முக்கிய காரணமாகும்.
• நீண்ட கால கண்காணிப்பு. watch உங்கள் terminal-ல் இயங்குவதால், உங்கள் session முடிந்தவுடன் அதுவும் நின்றுவிடும். நீங்கள் laptop-ஐ மூடிய பிறகு, அது யாருக்கும் எச்சரிக்கை அனுப்பாது, எந்த வரலாற்றையும் சேமிக்காது. இதற்கு Uptime Kuma போன்ற ஒரு முறையான status monitor அல்லது server-ல் திட்டமிடப்பட்ட கண்காணிப்பு முறை அவசியம்.

நேரமே இதற்கான சரியான எல்லை. ஒரு குறிப்பிட்ட நிகழ்வு நடக்கும் வரை காத்திருக்கும் அந்த பத்து நிமிடங்களுக்கு மட்டுமே watch பயன்படும். நாளை வரை தொடர்ந்து கண்காணிக்கப்பட வேண்டிய எதற்கும், திட்டமிடப்பட்ட timer அல்லது முறையான monitor-ஐப் பயன்படுத்துவதே சிறந்தது.

SSH இணைப்பில் இருக்கும்போது tmux-க்குள் watch-ஐ இயக்குதல்

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 கட்டளை மூலம் மீண்டும் இணையும்போது, header-ல் உள்ள கடிகாரம் காட்டுவது போல, அந்தத் திரை தொடர்ந்து புதுப்பிக்கப்பட்டிருக்கும். திரையைப் பிரிப்பதன் மூலம், ஒரு பக்கத்தில் watch மற்றும் மறுபக்கத்தில் journalctl -f ஆகியவற்றை ஒரே நேரத்தில் வைத்திருக்கலாம்; இதுவே tmux அடிப்படையிலான terminal workbench அமைப்பின் அடிப்படை நோக்கமாகும். ஒரே கேள்வி பல server-களுக்குப் பொருந்தும்போது, பல watch திரைகளைத் திறப்பதற்குப் பதிலாக பல Linux server-களை நிர்வகிப்பதற்கான கருவியைப் பயன்படுத்துவதே சிறந்தது.

இங்கே காட்டப்பட்டுள்ள திரைகள் உதாரணத்திற்காக மட்டுமே. Column அமைப்பு மற்றும் version விவரங்கள் ஒவ்வொரு distribution மற்றும் procps-ng release-க்கும் மாறுபடும். எனவே, உங்கள் கணினியில் உள்ள build-க்கு எந்தெந்த flags உள்ளன என்பதை அறிய man watch கட்டளையைப் பார்க்கவும்.

FAQ

watch mycmd | grep foo-ல் pipe-ஐ watch ஏன் புறக்கணிக்கிறது?

watch தொடங்குவதற்கு முன்பே உங்கள் shell அந்த வரியை pipe-ல் பிரிக்கிறது. எனவே, அது watch-ன் திரை வெளியீட்டை grep-க்கு அனுப்புகிறது, கட்டளையின் வெளியீடு வடிகட்டப்படுவதில்லை. முழு pipeline-ஐயும் மேற்கோள் குறிகளுக்குள் (quotes) இடவும்: watch 'mycmd | grep foo'. watch அந்த ஒற்றை வாதத்தை sh -c-க்கு வழங்குகிறது, அது ஒவ்வொரு சுழற்சியிலும் அந்த pipeline-ஐ இயக்குகிறது. இதே விதி globs மற்றும் command substitution-க்கும் பொருந்தும்.

watch-க்கு என்ன interval-ஐ நான் பயன்படுத்த வேண்டும்?

மதிப்பு எவ்வளவு வேகமாக மாறுகிறது மற்றும் ஒருமுறை இயக்குவதற்கு எவ்வளவு செலவாகும் என்பதைப் பொறுத்து இதைத் தீர்மானிக்கவும். வேகமான counters-க்கு அரை வினாடி போதுமானது; watch ஏற்கும் மிகச்சிறிய இடைவெளி 0.1 வினாடிகள் ஆகும். disks மற்றும் certificates-க்கு 30 முதல் 60 வினாடிகள் வரை பொருத்தமானது. நீங்கள் -p-ஐப் பயன்படுத்தாவிட்டால், கட்டளை இயங்கும் நேரம் இடைவெளியுடன் சேர்க்கப்படும். எனவே, -n 1-ன் கீழ் ஒரு மெதுவான கட்டளை இடைவெளியின்றி ஒன்றன்பின் ஒன்றாக இயங்கும்.

log file-ஐ watch கண்காணிக்க முடியுமா?

முடியாது. watch ஒரு சட்டத்தை (frame) மட்டுமே வரைந்து காட்டுகிறது, வரலாற்றைச் சேமிப்பதில்லை. எனவே, இரண்டு சுழற்சிகளுக்கு இடையில் தோன்றி மறையும் வரிகள் நிரந்தரமாக நீக்கப்படும். journalctl -fu <unit> மற்றும் tail -f ஆகியவை புதிய வரிகள் வரும்போது அவற்றை உடனுக்குடன் காட்டும், இதுவே log-களுக்குத் தேவை. disk சதவீதம் அல்லது queue நீளம் போன்ற தற்போதைய நிலையை மட்டும் காட்டும் மதிப்புகளுக்கு watch-ஐப் பயன்படுத்தவும்.

நான் காத்திருக்கும் நிகழ்வு நடக்கும்போது watch-ஐ எப்படி நிறுத்துவது?

-g (--chgexit)-ஐப் பயன்படுத்தவும். அந்த நிகழ்வு நடக்கும் வரை மாறாத வெளியீட்டைத் தரும் கட்டளையை அதற்கு வழங்கவும். கடிகாரம் அல்லது PID போன்ற வெளியீடுகள் முதல் refresh-லேயே மாறிவிடும், எனவே அவை உடனடியாக வெளியேறிவிடும். systemctl status myapp வேலை செய்யாத இடங்களில் systemctl is-active myapp வேலை செய்யும். எண்ணிக்கை பூஜ்ஜியத்தை அடைவது போன்ற உண்மையான நிபந்தனைகளுக்கு, shell until loop-ஐப் பயன்படுத்தவும், ஏனெனில் வெளியீடு மாறியதை மட்டுமே watch-ஆல் கண்டறிய முடியும்.

எனது shell-ல் வேலை செய்யும் ஒரு கட்டளைக்கு, watch ஏன் command not found என்று காட்டுகிறது?

watch அந்த கட்டளையை sh -c-க்கு அனுப்புகிறது. அந்த shell .bashrc-ஐ வாசிப்பதில்லை, எனவே உங்கள் aliases மற்றும் shell functions அங்கு இருக்காது. இந்தச் செய்தி பொதுவாக sh: 1: ll: not found என்று இருக்கும். உண்மையான கட்டளையை முழுமையாக எழுதவும் அல்லது உங்கள் interactive PATH-ல் மட்டுமே உள்ள binary-க்கு அதன் முழுப் பாதையை (full path) பயன்படுத்தவும்.