uptime: da quanto è acceso e quanto è carico

Il sito rallenta e qualcuno ti chiede: "il server si è riavviato stanotte?". Oppure ti accorgi che una macchina non viene aggiornata da mesi. In una riga sola, uptime risponde a due domande: da quanto tempo il computer è acceso e quanto lavoro sta facendo in questo momento.

Cos'è

uptime fa parte del pacchetto procps, lo stesso di top, free e ps. Il nome viene da up time, il "tempo di attività": il tempo trascorso dall'ultimo avvio. Insieme a questo dato mostra il carico medio (load average), il numero più usato dagli amministratori di sistema per capire a colpo d'occhio se una macchina è in difficoltà.

Cosa fa

Stampa una sola riga con l'ora attuale, da quanto tempo il sistema è acceso, quanti utenti sono collegati e il carico medio degli ultimi 1, 5 e 15 minuti. Con le opzioni mostra il tempo di attività in forma discorsiva oppure la data e l'ora dell'ultimo avvio.

Come si usa

$ uptime [opzioni]

Gli esempi mostrano un server chiamato web01 con 4 processori (core).

Esempio 1: il comando senza opzioni

$ uptime
 09:51:26 up 47 days,  3:12,  2 users,  load average: 0.42, 0.55, 0.61

Le parti, da sinistra a destra:

• 09:51:26: l'ora attuale;
• up 47 days, 3:12: il sistema è acceso da 47 giorni, 3 ore e 12 minuti (con meno di un giorno si vedrebbe solo 3:12, e con meno di un'ora 12 min);
• 2 users: le sessioni di utenti collegati in questo momento;
• load average: 0.42, 0.55, 0.61: il carico medio degli ultimi 1, 5 e 15 minuti.

Il testo resta in inglese anche su un sistema in italiano. Cambia solo il separatore dei decimali: con la lingua italiana attiva il carico può comparire come 0,42, 0,55, 0,61, e va tenuto presente se lo si elabora in uno script.

Esempio 2: capire il carico medio

$ uptime
 14:30:02 up 47 days,  7:51,  2 users,  load average: 6.10, 3.85, 1.90
$ nproc
4

Il load average è, in parole semplici, il numero medio di processi che in quel periodo erano in esecuzione o in attesa di poter lavorare. Va confrontato con il numero di processori (nproc): con 4 core, un carico di 4,00 significa che sono tutti occupati; di più significa che alcuni processi aspettano il loro turno. Come si legge l'esempio:

• i tre numeri vanno letti da destra a sinistra: negli ultimi 15 minuti il carico era 1,90 (tranquillo), negli ultimi 5 minuti 3,85 e nell'ultimo minuto 6,10;
• quindi il carico sta salendo e ora supera i 4 core: la macchina è in difficoltà. Se fosse stato il contrario (1.90, 3.85, 6.10) il problema starebbe rientrando;
• regola pratica: un valore sotto il numero di core va bene; vicino a quel numero la macchina è piena; oltre il doppio, le richieste si accodano e tutto rallenta.

Esempio 3: il tempo di attività in forma leggibile

$ uptime -p
up 6 weeks, 5 days, 3 hours, 12 minutes

Con -p (pretty) il tempo di attività è espresso in settimane, giorni, ore e minuti. È comodo da leggere, ma non mostra il carico.

Esempio 4: da quando è acceso

$ uptime -s
2026-09-12 06:39:15

Con -s (since) si ottiene la data e l'ora esatte dell'ultimo avvio. Utile per collegare un problema a un riavvio: "il sito ha smesso di rispondere il 12 settembre alle 6:30" e il server si è riavviato proprio quel giorno.

Esempio 5: chi è collegato, con w

$ w
 09:51:26 up 47 days,  3:12,  2 users,  load average: 0.42, 0.55, 0.61
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
enzo     pts/0    203.0.113.45     09:20    0.00s  0.04s  0.00s w
backup   pts/1    192.168.1.20     08:02    1:15m  0.01s  0.01s -bash

Il comando w mostra la stessa prima riga di uptime, seguita dall'elenco degli utenti collegati: da quale indirizzo (FROM), da quando (LOGIN@), da quanto sono inattivi (IDLE) e cosa stanno facendo (WHAT). Gli indirizzi sono inventati. Per le connessioni da remoto vedi l'articolo su ssh.

Esempio 6: i dati grezzi in /proc

$ cat /proc/uptime
4072320.52 15872310.40
$ cat /proc/loadavg
0.42 0.55 0.61 1/312 28451

Come per free, i dati vengono dal kernel e si leggono in file di testo. In /proc/uptime il primo numero è il tempo di attività in secondi (4072320 secondi sono 47 giorni, 3 ore e 12 minuti) e il secondo è il tempo di inattività sommato di tutti i core. In /proc/loadavg ci sono i tre carichi medi, poi la coppia 1/312 (processi in esecuzione in questo istante e processi totali) e il numero dell'ultimo processo creato.

Esempio 7: la storia dei riavvii

$ who -b
         system boot  2026-09-12 06:39
$ last reboot | head -n 3
reboot   system boot  6.1.0-28-amd64   Sat Sep 12 06:39   still running
reboot   system boot  6.1.0-28-amd64   Tue Aug  4 22:10 - 06:39 (38+08:29)
$ journalctl --list-boots

uptime conosce solo l'ultimo avvio. Per sapere quando è avvenuto e quali erano i precedenti: who -b mostra l'ultimo, last reboot elenca la cronologia con la versione del kernel e la durata di ogni periodo di accensione (38+08:29 significa 38 giorni e 8 ore e 29 minuti), mentre journalctl --list-boots elenca gli avvii registrati dal sistema (vedi l'articolo su systemctl). Per capire perché la macchina si è riavviata, guarda i registri dell'avvio precedente con journalctl -b -1.

Esempio 8: estrarre solo il carico

$ uptime | awk -F'load average: ' '{print $2}'
0.42, 0.55, 0.61
$ cut -d ' ' -f 1 /proc/loadavg
0.42
$ awk '{print $2}' /proc/loadavg
0.55

Per usare il carico in uno script è più affidabile leggere /proc/loadavg (con cut o awk): i campi sono separati da spazi, il separatore decimale è sempre il punto, e non dipende dalla lingua. Il primo campo è il carico dell'ultimo minuto, il secondo degli ultimi 5 minuti e il terzo degli ultimi 15.

Esempio 9: uso negli script

#!/bin/bash
CORE=$(nproc)
CARICO=$(cut -d ' ' -f 1 /proc/loadavg)
LOG="$HOME/carico.log"

if awk -v c="$CARICO" -v n="$CORE" 'BEGIN {exit !(c > n)}'; then
    echo "$(date '+%F %T') carico alto: $CARICO su $CORE core" >> "$LOG"
    ps -eo pid,user,pcpu,comm --sort=-pcpu | head -n 6 >> "$LOG"
fi

Lo script confronta il carico dell'ultimo minuto con il numero di core. Il confronto è fatto con awk perché la shell non sa confrontare numeri con la virgola. Se il carico è superiore, scrive nel registro l'orario e i cinque processi che usano più processore (vedi l'articolo su ps). Programmato con crontab ogni pochi minuti, permette di scoprire cosa succedeva prima di un rallentamento. In alternativa, top mostra le stesse informazioni in tempo reale.

Opzioni utili

• -p: tempo di attività in forma discorsiva (settimane, giorni, ore, minuti).
• -s: data e ora dell'ultimo avvio.
• -V: versione del programma; -h: aiuto.
• w: la stessa riga più l'elenco degli utenti collegati; who -b: ultimo avvio.
• last reboot, journalctl --list-boots: cronologia dei riavvii.
• /proc/uptime, /proc/loadavg: i dati grezzi (si leggono con cat).
• nproc, top, free: numero di core, processi che pesano di più, memoria.

Attenzione a

• Il carico medio non è una percentuale: un valore di 2,00 non vuol dire "200%" né "2%". Va sempre confrontato con il numero di core: 2,00 è un carico bassissimo su 8 core, ma saturo su una macchina con 2.
• Guarda i tre numeri insieme: un solo valore alto non dice se la situazione sta peggiorando o migliorando. È la differenza tra il valore a 1 minuto e quello a 15 che racconta la tendenza.
• Un carico alto non vuol dire per forza "processore sotto sforzo": su Linux il carico comprende anche i processi fermi in attesa del disco o della rete (per esempio con un disco lento o un'unità condivisa che non risponde). Se il carico è alto ma top mostra il processore quasi inattivo, la causa è quasi sempre una lettura o una scrittura lenta: controlla con top (colonna wa) e con df e free.
• Un uptime lungo non è un merito: una macchina accesa da 400 giorni non ha mai applicato gli aggiornamenti del kernel (confronta con uname -r, vedi l'articolo su uname). Un riavvio programmato ogni tanto è una buona abitudine.
• I riavvii cancellano il contatore: dopo un riavvio l'uptime riparte da zero, anche per un guasto o un'interruzione di corrente. Se la macchina sembra "accesa da pochi minuti" senza che tu l'abbia riavviata, indaga con last reboot e journalctl -b -1.
• Nei container i valori sono quelli dell'ospite: dentro un container Docker, uptime e il carico medio riguardano la macchina intera e non il container (come per free).
• "Users" conta le sessioni, non le persone: la stessa persona collegata con tre terminali compare come 3 utenti. Il numero comprende anche le sessioni grafiche.
• I decimali dipendono dalla lingua: con la lingua italiana il carico può essere scritto con la virgola. Negli script usa /proc/loadavg, oppure imposta la lingua per quel comando con LC_ALL=C uptime.
• Non è un sistema di allarme: uptime fotografa un momento. Per essere avvisato in tempo, serve uno script programmato (come quello dell'esempio 9) o un programma di monitoraggio.

Riepilogo