Comando watch Linux: intervalli, diff e pipe

Cosa fa il comando watch

Il comando watch esegue nuovamente un altro comando a intervalli fissi e ridisegna il relativo output nella stessa posizione dello schermo. L'intervallo predefinito è di due secondi. Usalo quando devi attendere che un valore cambi: lo spazio su disco che si esaurisce, un container che completa l'avvio, il rinnovo di un certificato o una coda che si svuota.

watch fa parte di procps-ng ed è già installato su una VPS Ubuntu o Debian appena distribuita, come componente del pacchetto procps. Controlla la versione prima di usare le opzioni riportate di seguito, perché due delle opzioni utili sono state introdotte di recente.

watch --version

Su Ubuntu 24.04 viene visualizzata una riga simile a watch from procps-ng 4.0.4. Ora vediamo l'esempio utile più semplice.

watch df -h /

Lo schermo viene cancellato e mostra una riga di intestazione, una riga vuota, quindi l'output di df -h /:

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

A sinistra sono indicati l'intervallo e il comando esatto eseguito da watch. A destra sono indicati il nome host e l'ora corrente. L'orologio è la parte utile, perché dimostra che lo schermo continua ad aggiornarsi anche quando i valori riportati sotto non cambiano. Premi Ctrl+C per uscire.

watch disegna un singolo riquadro che entra nel terminale. Le righe lunghe vanno a capo; -w le tronca invece, mentre tutto ciò che supera l'ultima riga non viene disegnato. Nel riquadro non è disponibile lo scrollback, perché ogni ciclo sovrascrive quello precedente. Questo determina gran parte degli utilizzi adatti a watch.

Con quale frequenza watch deve rieseguire il comando?

Due secondi sono solo il valore predefinito. Scegliere l'intervallo in base alla velocità con cui cambia il valore e al costo di ogni esecuzione.

• -n 0.5 per i contatori che cambiano continuamente, ad esempio ss -s o il conteggio dei byte di un'interfaccia. L'intervallo minimo accettato da watch è 0.1 secondi.
• -n 30 o -n 60 per dischi e certificati. Un filesystem che si riempie nell'arco di una giornata non deve essere controllato trenta volte al minuto.

watch esegue il comando, attende che termini e solo dopo attende per l'intervallo specificato. La durata dell'esecuzione si aggiunge all'intervallo: quindi, se un comando richiede otto secondi con -n 2, si ottiene un aggiornamento ogni dieci secondi e la macchina resta occupata per tutto il tempo. Aggiungere -p (--precise) fa invece sì che watch tenti di avviare un'esecuzione ogni intervallo di secondi, misurando il tempo dall'avvio di un'esecuzione all'avvio della successiva.

Se si desidera sempre un valore predefinito diverso, esportare WATCH_INTERVAL nel profilo della shell. Un -n esplicito ha comunque la precedenza. Eseguire watch --help per verificare che la propria build legga questa variabile.

Evidenziare le modifiche con -d

Leggere una schermata piena di testo identico per trovare il campo che è cambiato è faticoso. -d (--differences) lo fa per voi.

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

I caratteri diversi rispetto al frame precedente vengono visualizzati in video inverso. La cella Use% si illumina non appena cambia, mentre tutto il resto rimane invariato. Se /var non è un filesystem separato, vedrete il filesystem root elencato due volte. È un modo rapido per capire come è stato partizionato il sistema.

Il confronto è posizionale: watch allinea il nuovo frame a quello precedente e confronta i caratteri uno per uno. L'output dei comandi le cui colonne cambiano larghezza verrà evidenziato quasi interamente. Preferite quindi comandi con un layout stabile. Le versioni attuali di procps-ng accettano anche watch --differences=permanent, che mantiene evidenziata ogni posizione che ha subito una modifica, invece di evidenziare soltanto la modifica più recente. Verificate il comportamento con watch --help prima di farvi affidamento.

Come faccio a terminare watch quando cambia l'output?

-g (--chgexit) arresta watch la prima volta che l'output differisce da quello dell'esecuzione precedente. Il prompt torna disponibile, quindi puoi inserire qualcosa dopo il comando sulla stessa riga.

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

Questa è l'opzione che trasforma watch in uno strumento per sapere quando un deploy è completato. Ha un'insidia che causa problemi a molti: il confronto riguarda l'intero output, quindi qualsiasi orologio o PID (identificatore del processo) presente nell'output cambia già al primo aggiornamento e watch termina immediatamente. systemctl status myapp stampa il tempo trascorso e l'utilizzo della memoria, quindi usare -g con questo comando non serve. Riduci il comando al solo dato stabile che stai aspettando. È proprio questo che fornisce systemctl is-active.

Le versioni più recenti di procps-ng aggiungono il test opposto, --equexit <cycles>, che termina dopo che l'output è rimasto invariato per quel numero di cicli. Serve a sapere quando l'attività si è arrestata. Verifica watch --help, perché le build precedenti non includono questa opzione.

Perché watch ignora la pipe e il glob?

Questo errore si verifica praticamente sempre almeno una volta. La causa è nella shell, non in watch.

watch docker compose ps | grep web

La shell interattiva legge l'intera riga prima di eseguire qualsiasi comando e la divide in corrispondenza della pipe. Avvia watch docker compose ps e collega l'output visualizzato direttamente da watch a grep. A questo punto watch non scrive più su un terminale, quindi la visualizzazione è danneggiata o vuota, mentre grep filtra l'output dei ridisegni invece dell'elenco dei container.

Racchiudi l'intera pipeline tra virgolette, in modo che venga passata come un unico argomento.

watch 'docker compose ps | grep web'

watch passa questa stringa a sh -c, che esegue la pipeline una volta per ciclo. La stessa regola vale per i glob, ma il sintomo è meno evidente.

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

La prima riga espande il glob una sola volta, nella shell, quando premi Invio. watch esegue quindi a ogni ciclo un elenco congelato di nomi di file; perciò un file di log creato un minuto dopo non viene mai visualizzato. La seconda riga passa il glob a watch, che lo espande all'interno di sh a ogni ciclo. I nuovi file vengono quindi visualizzati automaticamente.

Le virgolette stabiliscono anche quando valutare una variabile o una sostituzione di comando. watch "echo $(date)" esegue date una volta, nella shell, quindi visualizza per sempre quella stringa fissa. watch 'echo $(date)' esegue date a ogni ciclo. Le virgolette singole rimandano la valutazione. Le virgolette doppie la eseguono subito.

Questa sh -c comporta altre due conseguenze:

• Alias e funzioni della shell non sono disponibili al suo interno. watch ll ha esito negativo con sh: 1: ll: not found, perché sh -c non legge il tuo .bashrc. Scrivi il comando completo oppure indica il percorso completo di un binario presente solo nel tuo PATH interattivo.
• È utile acquisire anche lo standard error. Inserisci 2>&1 tra le virgolette quando vuoi visualizzare i messaggi di errore nel riquadro, invece di distribuirli al suo esterno.

Quando le virgolette diventano difficili da gestire, -x (--exec) esegue direttamente il comando anziché tramite sh -c. Gli argomenti contenenti spazi diventano più semplici, mentre pipe e glob smettono completamente di funzionare, perché non rimane alcuna shell a interpretarli.

La stessa logica vale per i privilegi, perché watch è un processo normale. watch 'sudo ss -tulpn' visualizza una richiesta di password che non puoi vedere né compilare. Esegui invece sudo watch 'ss -tulpn' e ricorda che, in questo caso, l'intero ciclo viene eseguito come root finché non premi Ctrl+C.

Quattro elementi da monitorare su un VPS

Un disco che si sta riempiendo

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

df chiede al kernel dati che sono già disponibili, quindi è abbastanza economico da poter essere ripetuto continuamente. du -sh /var/log invece non lo è, perché attraversa tutti i file dell'albero a ogni ciclo. Usato con watch, legge continuamente il disco e rallenta la macchina che stai cercando di diagnosticare. Esegui du una sola volta oppure usa ncdu, quindi lascia df sotto monitoraggio per verificare se il valore continua ad aumentare.

Un container che continua a riavviarsi

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

La colonna dello stato mostra da quanto tempo ogni container è attivo. Un container che entra in un ciclo di crash continua a reimpostarsi su "Up 2 seconds" e -d lo rende evidente a colpo d'occhio. Cambia prima directory, perché watch eredita la directory di lavoro della shell che lo ha avviato e docker compose richiede la directory del progetto. watch indica che è in corso un riavvio. docker compose logs -f web ne indica il motivo. Dopo aver individuato la causa, codifica la soluzione in un healthcheck Compose che riavvia il container automaticamente, così nessuno deve restare a fissare lo schermo.

Il completamento del rinnovo di un certificato

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

Il comando stampa una riga, notAfter=Nov 7 09:14:22 2026 GMT, e nient'altro, quindi -g si attiva esattamente quando il file viene sostituito da quello rinnovato. I file in /etc/letsencrypt/live sono leggibili solo da root, motivo per cui questo comando viene eseguito in una shell root. Tieni presente che monitora il certificato presente sul disco. Un web server in esecuzione mantiene in memoria il vecchio certificato finché non ricarica la configurazione; verifica quindi quale certificato viene realmente servito con echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate e non eseguire quel comando ogni due secondi contro un host pubblico. Il rinnovo viene gestito da un servizio e un timer systemd, mentre systemctl list-timers mostra quando verrà eseguito il prossimo avvio.

L'elaborazione di una coda

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

Stampa una riga di riepilogo come -- 24 Kbytes in 6 Requests. oppure Mail queue is empty quando l'elaborazione è terminata. Lo stesso approccio funziona per qualsiasi coda di cui sia possibile contare gli elementi: watch -n 5 'find /srv/queue/incoming -type f | wc -l'.

In questo caso watch raggiunge il proprio limite. Confronta un frame con quello precedente e non può verificare una condizione, quindi non può mai dirti "il conteggio ha raggiunto zero". Un semplice ciclo della shell può farlo, usando la sostituzione di comando per acquisire il conteggio a ogni iterazione:

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

Quando il comando watch non è lo strumento corretto

watch riesegue il comando senza conservare informazioni sull'esecuzione precedente e senza sapere che cosa faccia quel comando. Questo va bene per df. In quattro situazioni è invece inadatto.

• Log. watch ridisegna un riquadro fisso, quindi le righe che compaiono e scorrono fuori dal riquadro tra due cicli vengono perse. Usa journalctl -fu nginx o tail -f, che mostrano in streaming le nuove righe man mano che vengono scritte.
• Comandi costosi. du -sh / o una query eseguita su un database sotto carico diventa un carico permanente in background a qualsiasi intervallo, perché watch continua ad avviare il comando.
• Qualsiasi operazione con effetti collaterali. Un comando che scrive, invia richieste, riavvia o installa qualcosa lo farà di nuovo a ogni ciclo. Un curl verso un'API ogni due secondi equivale a 43,200 richieste al giorno: è il modo in cui una chiave API gratuita viene sospesa.
• Controlli di lunga durata. watch viene eseguito nel terminale e termina con la sessione. Non invia avvisi e non conserva la cronologia dopo la chiusura del laptop. In questo caso serve un monitor di stato reale come Uptime Kuma oppure un controllo pianificato che resti in esecuzione sul server.

Il limite corretto è temporale. watch serve per i dieci minuti in cui aspetti che si verifichi una condizione specifica. Tutto ciò che deve continuare a essere controllato domani appartiene a un timer pianificato o a un monitor reale.

Esegui watch all'interno di tmux quando usi SSH

Con SSH, watch è affidabile quanto la connessione. Quando il collegamento cade, la shell riceve SIGHUP e termina anche watch. tmux risolve il problema e rende watch realmente utile su un server remoto.

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

Premi Ctrl+b, quindi d per scollegarti. Il ciclo continua a essere eseguito sul server. Riconnettiti in seguito con tmux attach -t ops: l'output viene ancora aggiornato e l'orologio nell'intestazione lo dimostra. Dividi la finestra per mantenere watch su un lato e journalctl -f sull'altro. Questo è il principio alla base di un ambiente di lavoro terminale basato su tmux. Quando la stessa verifica riguarda più server contemporaneamente, usa uno strumento progettato per gestire più server Linux invece di creare molte finestre watch.

Le schermate riportate sono solo illustrative. La disposizione delle colonne e le stringhe delle versioni variano tra le distribuzioni e le release di procps-ng. Esegui quindi man watch sul tuo sistema per verificare i flag effettivamente disponibili nella tua build.

FAQ

Perché watch ignora la pipe in watch mycmd | grep foo?

La shell divide la riga in corrispondenza della pipe prima ancora che watch venga avviato. In questo modo invia a grep la visualizzazione prodotta da watch, mentre l’output del comando non viene mai filtrato. Racchiudi l’intera pipeline tra virgolette: watch 'mycmd | grep foo'. watch passa questo singolo argomento a sh -c, che esegue la pipeline una volta per ciclo. La stessa regola si applica ai glob e alla sostituzione di comando.

Quale intervallo devo usare con watch?

Sceglilo in base alla velocità con cui cambia il valore e al costo di una singola esecuzione. Mezzo secondo è adatto ai contatori rapidi, mentre 0.1 secondi è l’intervallo minimo accettato da watch. Per dischi e certificati sono adatti intervalli da trenta a sessanta secondi. Il tempo di esecuzione del comando si aggiunge all’intervallo, a meno che tu non passi -p. Di conseguenza, un comando lento con -n 1 viene eseguito senza pause, una volta subito dopo l’altra.

watch può seguire un file di log?

No. watch ridisegna una schermata e non conserva lo storico. Una riga che compare e scorre fuori dalla schermata tra due cicli viene quindi persa definitivamente. journalctl -fu <unit> e tail -f trasmettono le nuove righe man mano che arrivano, come richiesto dai log. Usa watch per i valori che rappresentano uno stato corrente, ad esempio la percentuale di spazio su disco o la lunghezza di una coda.

Come posso fare in modo che watch si arresti quando si verifica l'evento atteso?

Usa -g (--chgexit) e specifica un comando il cui output rimanga identico fino al verificarsi dell'evento. Un output che contiene un orologio o un PID cambia al primo aggiornamento e causa l'uscita immediata. Per questo systemctl is-active myapp funziona mentre systemctl status myapp no. Per una condizione reale, ad esempio un conteggio che raggiunge zero, usa un ciclo until della shell, perché watch può rilevare soltanto che l’output è cambiato.

Perché watch segnala command not found per qualcosa che nella mia shell funziona?

watch passa il comando a sh -c. Questa shell non legge .bashrc, quindi alias e funzioni della shell non sono disponibili. Il messaggio è in genere sh: 1: ll: not found. Scrivi il comando reale oppure usa il percorso completo per un binario che si trova solo nel tuo PATH interattivo.