המדריך המלא לשימוש בפקודה watch בלינוקס

מה עושה הפקודה watch

הפקודה watch מריצה פקודה אחרת במרווחי זמן קבועים ומציגה את הפלט שלה מחדש באותו מיקום על המסך. מרווח הזמן כברירת מחדל הוא שתי שניות. השתמשו בה כאשר אתם ממתינים לשינוי בנתון כלשהו: התמלאות דיסק, ייצוב של מכולה, קבלת תעודה חדשה או התרוקנות של תור.

watch מגיעה מחבילת procps-ng ומותקנת כברירת מחדל בשרתי VPS חדשים של Ubuntu או Debian כחלק מחבילת procps. בדקו את הגרסה שלכם לפני שתסתמכו על הדגלים המפורטים מטה, שכן שתיים מהאפשרויות השימושיות הן חדשות יחסית.

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 מצייר פריים אחד שמתאים לגודל הטרמינל. שורות ארוכות גולשות לשורה הבאה, בעוד ש־-w קוטע אותן, וכל מה שחורג מהשורה התחתונה אינו מוצג כלל. אין אפשרות גלילה (scrollback) בתוך הפריים, כיוון שכל מחזור דורס את קודמו. עובדה יחידה זו קובעת את רוב השימושים שבהם watch יעיל.

באיזו תדירות על watch להריץ מחדש את הפקודה?

שתי שניות הן רק ברירת המחדל. בחרו את המרווח לפי קצב השינוי של הערך ועלות ההרצה של הפקודה.

• -n 0.5 עבור מונים שמשתנים ללא הרף, כגון ss -s או ספירת בתים בממשק רשת. המרווח המינימלי ש-watch מקבל הוא 0.1 שניות.
• -n 30 או -n 60 עבור דיסקים ותעודות. מערכת קבצים שמתמלאת לאורך יממה אינה זקוקה לשלושים רענון לדקה.

הפקודה watch מריצה את הפקודה, ממתינה לסיומה, ורק אז נכנסת למצב שינה למשך המרווח שהוגדר. זמן הריצה מתווסף למרווח, כך שפקודה שלוקחת שמונה שניות תחת -n 2 תספק רענון כל עשר שניות ותעסיק את המכונה לכל אורך הזמן. הוסיפו את -p (--precise) כדי ש-watch תשאף להתחיל הרצה בכל מספר שניות מוגדר, החל מתחילת הרצה אחת ועד לתחילת הבאה.

אם ברצונכם לשנות את ברירת המחדל באופן קבוע, בצעו export למשתנה WATCH_INTERVAL בפרופיל ה-shell שלכם. דגל -n מפורש תמיד יגבר על הגדרה זו. הריצו את watch --help כדי לוודא שה-build שלכם קורא את המשתנה הזה.

הדגשת שינויים באמצעות -d

קריאת גוש טקסט זהה כדי למצוא שדה בודד שהשתנה היא משימה קשה. -d (--differences) מבצע זאת עבורכם.

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

תווים השונים מהפריים הקודם מוצגים בוידאו הפוך, כך שתא ה-Use% מואר ברגע שהוא משתנה, בעוד שאר התוכן נשאר רגוע. אם /var אינו מערכת קבצים נפרדת, תראו את מערכת הקבצים root מופיעה פעמיים; זו דרך מהירה ללמוד כיצד השרת חולק למחיצות.

ההשוואה היא מבוססת מיקום, מה שאומר ש-watch משווה את הפריים החדש מול הישן תו אחר תו. פלט שרוחב העמודות שלו משתנה יואר כמעט כולו, לכן העדיפו פקודות עם פריסה יציבה. הגרסה הנוכחית של procps-ng מקבלת גם את watch --differences=permanent, ששומר על כל מיקום שהשתנה אי פעם מודגש, במקום להציג רק את השינוי האחרון. אשרו זאת באמצעות watch --help לפני שתסתמכו על כך.

כיצד לגרום ל-watch לצאת כאשר הפלט משתנה?

הדגל -g (או --chgexit) עוצר את watch בפעם הראשונה שהפלט שונה מההרצה הקודמת. שורת הפקודה שלך תחזור, כך שניתן להוסיף פקודה נוספת באותה שורה לאחר מכן.

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

זהו הדגל שהופך את watch לכלי מסוג "הודע לי כשה-deploy מסתיים". יש לו מלכודת אחת שכולם נופלים בה: ההשוואה מתבצעת על כל הפלט, לכן כל שעון או PID (מזהה תהליך) שמופיע בו ישתנה כבר ברענון הראשון, ו-watch יצא מיד. הפקודה systemctl status myapp מדפיסה זמן שחלף וצריכת זיכרון, לכן שימוש ב--g עליה הוא חסר תועלת. צמצמו את הפקודה לנתון היציב היחיד שאתם ממתינים לו, כפי שמאפשרת systemctl is-active.

גרסאות חדשות יותר של procps-ng מוסיפות את הבדיקה ההפוכה, --equexit <cycles>, אשר יוצאת לאחר שהפלט נשאר זהה למשך מספר מחזורים מסוים. היא עונה על הצורך ב"הודע לי כשהפעילות פסקה". בדקו את watch --help, כיוון שבגרסאות ישנות יותר דגל זה אינו קיים.

מדוע watch מתעלם מה-pipe ומה-glob שלי?

זוהי תקלה שכולם נתקלים בה לפחות פעם אחת, והסיבה נעוצה ב-shell שלכם ולא ב-watch.

watch docker compose ps | grep web

ה-shell האינטראקטיבי שלכם קורא את כל השורה לפני שמתבצעת הרצה כלשהי, והוא מפצל את השורה בנקודת ה-pipe. הוא מפעיל את watch docker compose ps ומחבר את פלט המסך של watch עצמו אל grep. כעת watch אינו כותב לטרמינל, ולכן התצוגה משובשת או ריקה, ו-grep מסנן את פלט הריענון במקום את רשימת המכולות.

השתמשו במירכאות עבור כל ה-pipeline כדי שיגיע כארגומנט יחיד.

watch 'docker compose ps | grep web'

הפקודה watch מעבירה את המחרוזת הזו אל sh -c, וה-shell הזה מריץ את ה-pipeline פעם אחת בכל מחזור. ב-globs חל אותו כלל, עם תסמינים שקטים יותר.

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

השורה הראשונה מרחיבה את ה-glob פעם אחת, בתוך ה-shell שלכם, ברגע שאתם לוחצים על Enter. לאחר מכן watch מריץ שוב ושוב רשימה קפואה של שמות קבצים, כך שקובץ לוג שנוצר דקה לאחר מכן לעולם לא יופיע. השורה השנייה מעבירה את ה-glob אל watch, שמרחיב אותו בתוך sh בכל מחזור, כך שקבצים חדשים מופיעים באופן אוטומטי.

מירכאות קובעות גם מתי משתנה או החלפת פקודה (command substitution) עוברים הערכה. watch "echo $(date)" מריץ את date פעם אחת, בתוך ה-shell שלכם, ואז מהדהד את המחרוזת הקבועה הזו לנצח. watch 'echo $(date)' מריץ את date בכל מחזור. מירכאות בודדות פירושן "מאוחר יותר". מירכאות כפולות פירושן "עכשיו".

שתי השלכות נוספות של sh -c:

• Alias ופונקציות shell אינם קיימים בתוכו. watch ll נכשל עם sh: 1: ll: not found, כיוון ש-sh -c לעולם לא קורא את ה-.bashrc שלכם. כתבו את הפקודה המלאה, או ספקו את הנתיב המלא לקובץ בינארי שנמצא רק ב-PATH האינטראקטיבי שלכם.
• כדאי ללכוד את ה-standard error. הציבו את 2>&1 בתוך המירכאות כאשר אתם רוצים שטקסט השגיאה יוצג בתוך המסגרת במקום להתפזר על פניה.

כאשר השימוש במירכאות הופך למסורבל, -x (--exec) מריץ את הפקודה ישירות במקום דרך sh -c. ארגומנטים עם רווחים הופכים לקלים יותר לניהול, אך pipes ו-globs מפסיקים לעבוד לחלוטין, כיוון שלא נותר shell שיפרש אותם.

הרשאות פועלות לפי אותו היגיון, שכן watch הוא תהליך רגיל. watch 'sudo ss -tulpn' נתקל בהנחיית סיסמה שאינכם יכולים לראות או להקליד לתוכה. הריצו את sudo watch 'ss -tulpn' במקום זאת, וזכרו שכל הלולאה רצה כ-root עד שתלחצו על Ctrl+C.

ארבעה דברים שכדאי לעקוב אחריהם ב-VPS

דיסק שמתמלא

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

df פונה ל-kernel לקבלת נתונים שכבר נמצאים בזיכרון, ולכן הוא זול מספיק להרצה מתמשכת. du -sh /var/log אינו כזה, כיוון שהוא סורק כל קובץ בעץ בכל מחזור. תחת watch הוא קורא מהדיסק ללא הפסקה ומאט את המכונה שאתם מנסים לאבחן. הריצו את du פעם אחת, או השתמשו ב-ncdu, ואז השאירו את df תחת watch כדי לדעת אם המספר ממשיך לעלות.

מכולה שמבצעת הפעלה מחדש ללא הרף

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

עמודת הסטטוס מציגה כמה זמן כל מכולה פעילה. מכולה שנמצאת בלולאת קריסה מתאפסת ללא הרף ל-"Up 2 seconds", ו--d הופך זאת לברור במבט חטוף. עברו תחילה לספרייה הרלוונטית, כיוון ש-watch יורש את ספריית העבודה של ה-shell שהפעיל אותו ו-docker compose זקוק לספריית הפרויקט שלו. watch מדווח על התרחשות של הפעלה מחדש. docker compose logs -f web מסביר מדוע זה קורה. ברגע שתדעו את הסיבה, הגדירו את הפתרון כ-בדיקת תקינות ב-Compose שמפעילה מחדש את המכולה עבורכם כדי שאף אחד לא יצטרך לשבת ולבהות במסך.

הגעת מועד חידוש תעודה

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 בלבד, וזו הסיבה שהפקודה רצה ב-shell של root. שימו לב שהיא עוקבת אחר התעודה שעל הדיסק. שרת אינטרנט פעיל שומר את התעודה הישנה בזיכרון עד לביצוע reload, לכן בדקו מה באמת מוצג למשתמשים בעזרת echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate, ואל תריצו פקודה זו במרווח של שתי שניות מול שרת ציבורי. תהליך החידוש עצמו שייך ל-שירות וטיימר של systemd, ו-systemctl list-timers מציג מתי הוא ירוץ בפעם הבאה.

ריקון תור

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 פשוטה יכולה לעשות זאת, באמצעות הצבת פקודה כדי ללכוד את המונה בכל מעבר:

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

מתי הפקודה watch אינה הכלי המתאים

הפקודה watch מריצה מחדש את הפקודה שלכם ללא זיכרון של ההרצה הקודמת וללא הבנה של מה שהפקודה עושה. זה תקין עבור df. זה שגוי בארבעה מצבים:

• לוגים. watch מציירת מחדש מסגרת קבועה, לכן שורות שמופיעות ונעלמות בין שני מחזורי ריצה הולכות לאיבוד. השתמשו ב-journalctl -fu nginx או ב-tail -f, שמזרימים שורות חדשות ברגע שהן נכתבות.
• פקודות יקרות משאבים. du -sh / או שאילתה מול מסד נתונים עמוס הופכים לעומס רקע קבוע בכל מרווח זמן, כיוון ש-watch ממשיכה להפעיל אותם שוב ושוב.
• כל דבר עם תופעות לוואי. פקודה שכותבת, מפרסמת, מאתחלת או מתקינה תבצע זאת שוב בכל מחזור. curl מול API בכל שתי שניות משמעותו 43,200 בקשות ביום, וזו הדרך שבה מפתח API חינמי נחסם.
• בדיקות ארוכות טווח. watch רצה בתוך הטרמינל שלכם ונסגרת עם סיום הסשן. היא לא מתריעה לאיש ולא שומרת היסטוריה לאחר סגירת המחשב הנייד. עבור מקרים אלו אתם זקוקים ל-ניטור סטטוס אמיתי כגון Uptime Kuma, או לבדיקה מתוזמנת שפועלת על השרת.

הגבול ההגיוני הוא זמן. watch מיועדת לעשר הדקות שבהן אתם ממתינים שמשהו ספציפי יקרה. כל דבר שצריך להמשיך להיבדק גם מחר שייך לטיימר מתוזמן או לכלי ניטור אמיתי.

הרצת watch בתוך tmux בעת עבודה ב-SSH

בעבודה ב-SSH, השרידות של הפקודה watch תלויה ביציבות החיבור. כאשר החיבור מתנתק, ה-shell מקבל אות SIGHUP ומפסיק את פעולת ה-watch. השימוש ב-tmux פותר בעיה זו, והוא מה שהופך את watch לכלי שימושי באמת בשרתים מרוחקים.

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

לחצו על Ctrl+b ולאחר מכן על d כדי להתנתק מה-session. הלולאה תמשיך לרוץ בשרת. התחברו מחדש מאוחר יותר באמצעות tmux attach -t ops, ותראו שהתצוגה עדיין מתעדכנת, כפי שניתן לראות בשעון שבכותרת. פצלו את החלון כדי להריץ את watch בצד אחד ואת journalctl -f בצד השני; זהו העיקרון העומד מאחורי סביבת עבודה מבוססת tmux. כאשר אותה שאלה רלוונטית לכמה שרתים בו-זמנית, זו משימה עבור כלי המיועד לניהול שרתים מרובים, ולא עבור ריבוי חלונות watch.

המסכים המוצגים כאן הם להמחשה בלבד. פריסת העמודות וגרסאות התוכנה עשויות להשתנות בין הפצות שונות ובין גרסאות של procps-ng, לכן קראו את man watch במכונה שלכם כדי לראות אילו דגלים זמינים בגרסה שמותקנת אצלכם.

FAQ

מדוע watch מתעלם מה־pipe ב־watch mycmd | grep foo?

ה־shell מפצל את השורה בסימן ה־pipe עוד לפני ש־watch מתחיל לפעול. כתוצאה מכך, הפלט של watch עצמו מוזרם ל־grep, והפלט של הפקודה המקורית אינו מסונן. יש להקיף את כל ה־pipeline במירכאות: watch 'mycmd | grep foo'. כך watch מקבל ארגומנט יחיד ומעביר אותו ל־sh -c, שמריץ את ה־pipeline בכל מחזור. כלל זה תקף גם עבור globs ועבור החלפת פקודות (command substitution).

באיזה מרווח זמן כדאי להשתמש עם watch?

התאימו את המרווח לקצב השינוי של הערך ולמשאבים שהפקודה צורכת. חצי שנייה מתאימה למונים מהירים, ו-0.1 שניות הוא המרווח המינימלי ש־watch מאפשר. מרווח של 30 עד 60 שניות מתאים לבדיקת דיסקים ותעודות. זמן הריצה של הפקודה מתווסף למרווח ההמתנה, אלא אם משתמשים ב־-p; במקרה כזה, פקודה איטית תחת -n 1 תרוץ ברצף ללא הפסקה.

האם watch יכול לעקוב אחר קובץ לוג?

לא. watch מצייר מחדש את המסך בכל פעם ואינו שומר היסטוריה, לכן כל שורה שמופיעה ונעלמת בין שני מחזורים אובדת. journalctl -fu <unit> ו־tail -f מציגים שורות חדשות בזמן אמת, וזהו הכלי המתאים ללוגים. השתמשו ב־watch עבור ערכים בעלי מצב נוכחי, כגון אחוז ניצול דיסק או אורך תור.

איך גורמים ל־watch לעצור כאשר האירוע שאני ממתין לו מתרחש?

השתמשו ב־-g (--chgexit) וספקו פקודה שהפלט שלה נשאר זהה עד להתרחשות האירוע. פלט המכיל שעון או PID משתנה בכל רענון וגורם ליציאה מיידית, לכן systemctl is-active myapp עובד במקרים שבהם systemctl status myapp נכשל. עבור תנאי לוגי מורכב, כמו הגעת מונה לאפס, השתמשו בלולאת until בתוך ה־shell, כיוון ש־watch מסוגל לזהות רק שינוי כללי בפלט.

מדוע watch מציג שגיאת command not found עבור פקודה שעובדת ב־shell שלי?

watch מעביר את הפקודה ל־sh -c, וה־shell הזה אינו קורא את .bashrc, לכן ה-aliases ופונקציות ה-shell שלכם אינם קיימים שם. ההודעה היא בדרך כלל sh: 1: ll: not found. כתבו את הפקודה המלאה, או השתמשו בנתיב המלא לקובץ הבינארי אם הוא נמצא רק ב־PATH האינטראקטיבי שלכם.