apt: installare e aggiornare i programmi

Su Debian, Ubuntu e derivate (Linux Mint, Pop!_OS, Raspberry Pi OS…) i programmi non si scaricano da un sito per poi eseguire un installatore: si chiedono al sistema con apt, che trova il pacchetto, scarica anche tutto ciò di cui ha bisogno, lo installa e lo tiene aggiornato insieme al resto del sistema.

Cos'è

apt (Advanced Package Tool) è il gestore di pacchetti delle distribuzioni della famiglia Debian. Un pacchetto è un archivio (di estensione .deb) che contiene un programma, i suoi file di configurazione e l'elenco delle dipendenze, cioè degli altri pacchetti di cui ha bisogno. I pacchetti si trovano in repository (archivi online) elencati nella configurazione di apt. Il lavoro vero e proprio sui singoli file .deb lo fa dpkg; apt è lo strato superiore, che risolve le dipendenze e scarica i pacchetti. Per le distribuzioni basate su altre famiglie esistono strumenti equivalenti (dnf su Fedora, pacman su Arch).

Cosa fa

Cerca, installa, aggiorna e rimuove pacchetti, scegliendo le versioni giuste, risolvendo le dipendenze e verificando le firme crittografiche dei repository. Tutte le operazioni che modificano il sistema richiedono i privilegi di amministratore, quindi si usa sudo; quelle che cercano o mostrano informazioni no.

Come si usa

$ sudo apt comando [opzioni] [pacchetto...]

Gli esempi usano pacchetti comuni (nginx, curl, htop). Gli output, che dipendono dalla lingua del sistema, sono abbreviati con ....

Esempio 1: aggiornare l'elenco dei pacchetti

$ sudo apt update
...
Lettura elenco dei pacchetti... Fatto
Generazione albero delle dipendenze... Fatto
Lettura informazioni sullo stato... Fatto
12 pacchetti possono essere aggiornati. Eseguire "apt list --upgradable" per visualizzarli.

apt update non aggiorna nessun programma: scarica dai repository l'elenco aggiornato dei pacchetti disponibili e delle loro versioni. È il primo passo da fare prima di installare o di aggiornare, perché senza questo apt ragiona su un elenco vecchio. L'ultima riga dice quanti pacchetti installati hanno una versione più recente.

Esempio 2: vedere cosa si può aggiornare, e aggiornare

$ apt list --upgradable
Elenco in corso... Fatto
nginx/noble-updates 1.24.0-2ubuntu7.2 amd64 [aggiornabile da: 1.24.0-2ubuntu7.1]
openssl/noble-updates,noble-security 3.0.13-0ubuntu3.6 amd64 [aggiornabile da: 3.0.13-0ubuntu3.5]
...
$ sudo apt upgrade
...
Vuoi continuare? [S/n] s

apt upgrade aggiorna tutti i pacchetti installati alla versione più recente, senza mai rimuovere pacchetti e senza installarne di nuovi se non necessario. Prima di procedere mostra cosa farà e chiede conferma ([S/n]: la lettera maiuscola è la risposta predefinita, quindi basta premere Invio). Con apt full-upgrade (o dist-upgrade) invece apt può anche rimuovere o installare pacchetti, se serve a completare l'aggiornamento: succede, per esempio, con i nuovi kernel o con pacchetti che cambiano nome. Va letto con più attenzione l'elenco di ciò che verrà rimosso.

Esempio 3: cercare un pacchetto e leggerne le informazioni

$ apt search "server web"
Ordinamento... Fatto
Ricerca testo... Fatto
nginx/noble-updates 1.24.0-2ubuntu7.2 amd64
  small, powerful, scalable web/proxy server
...
$ apt show nginx
Package: nginx
Version: 1.24.0-2ubuntu7.2
Priority: optional
Section: web
Installed-Size: 1.466 kB
Depends: nginx-core (<< 1.24.0-2ubuntu7.2.1~) | nginx-full (...) ...
Homepage: https://nginx.org
Download-Size: 3.564 B
Description: small, powerful, scalable web/proxy server
...

apt search cerca un termine nei nomi e nelle descrizioni dei pacchetti (le descrizioni sono in genere in inglese; il risultato può essere lungo, quindi spesso lo si passa a less o a grep). apt show mostra i dettagli di un pacchetto: versione, dimensione, sito ufficiale, dipendenze e descrizione. Mostra anche pacchetti non ancora installati, ed è il modo migliore per capire cosa si sta per installare.

Esempio 4: installare un programma

$ sudo apt install htop
Lettura elenco dei pacchetti... Fatto
Generazione albero delle dipendenze... Fatto
Lettura informazioni sullo stato... Fatto
I seguenti pacchetti NUOVI saranno installati:
  htop
0 aggiornati, 1 installati, 0 da rimuovere e 12 non aggiornati.
Verranno scaricati 171 kB di archivi.
Dopo questa operazione, verranno occupati 441 kB di spazio su disco.
Vuoi continuare? [S/n] s
...
$ sudo apt install curl rsync tmux
$ sudo apt install --no-install-recommends nginx

Dopo il nome si possono indicare più pacchetti insieme. apt mostra l'elenco di ciò che installerà (compresi i pacchetti aggiuntivi necessari come dipendenze), la dimensione da scaricare e lo spazio che occuperà, e solo dopo la conferma procede. Per default installa anche i pacchetti "raccomandati"; con --no-install-recommends si installa solo lo stretto necessario, scelta frequente sui server. Reinstallando un pacchetto già presente apt lo aggiorna all'ultima versione, e apt install --reinstall pacchetto ne forza la reinstallazione.

Esempio 5: simulare prima di fare davvero

$ sudo apt install -s nginx
Inst nginx-common (1.24.0-2ubuntu7.2 Ubuntu:24.04/noble-updates [all])
Inst nginx (1.24.0-2ubuntu7.2 Ubuntu:24.04/noble-updates [amd64])
Conf nginx-common (1.24.0-2ubuntu7.2 Ubuntu:24.04/noble-updates [all])
Conf nginx (1.24.0-2ubuntu7.2 Ubuntu:24.04/noble-updates [amd64])
$ apt -s full-upgrade | grep -E '^(Inst|Remv)'

Con -s (--simulate, o --dry-run) apt mostra cosa farebbe, senza fare niente: Inst sono i pacchetti che verrebbero installati o aggiornati, Remv quelli che verrebbero rimossi, Conf la configurazione. Con grep si isolano rapidamente le righe che interessano. Una buona abitudine prima di un full-upgrade su un server importante.

Esempio 6: rimuovere programmi

$ sudo apt remove htop
$ sudo apt purge htop
$ sudo apt autoremove
I seguenti pacchetti saranno RIMOSSI:
  libnl-route-3-200 linux-headers-6.8.0-31 ...
$ sudo apt autoremove --purge

apt remove toglie il programma ma lascia i file di configurazione (così, reinstallandolo, ritrovi le tue impostazioni); apt purge elimina anche quelli. apt autoremove toglie i pacchetti installati solo come dipendenza di qualcosa che non c'è più: libera spazio, ma va guardato bene l'elenco (vedi più avanti). Con --purge insieme ad autoremove si eliminano anche le loro configurazioni.

Esempio 7: sapere cosa è installato

$ apt list --installed | grep nginx
nginx/noble-updates,now 1.24.0-2ubuntu7.2 amd64 [installato]
nginx-common/noble-updates,now 1.24.0-2ubuntu7.2 all [installato, automatico]
$ dpkg -l | grep nginx
ii  nginx         1.24.0-2ubuntu7.2   amd64   small, powerful, scalable web/proxy server
$ dpkg -s nginx | grep -E '^(Status|Version)'
Status: install ok installed
Version: 1.24.0-2ubuntu7.2
$ apt policy nginx
nginx:
  Installato: 1.24.0-2ubuntu7.2
  Candidato: 1.24.0-2ubuntu7.2
  Tabella versione:
 *** 1.24.0-2ubuntu7.2 500
        500 http://archive.ubuntu.com/ubuntu noble-updates/main amd64 Packages

apt list --installed e dpkg -l elencano i pacchetti installati (in dpkg -l la sigla ii significa "installato correttamente"). dpkg -s dà lo stato di uno solo. apt policy mostra la versione installata, quella candidata (la più recente disponibile) e il repository da cui proviene: è il modo migliore per capire perché apt propone o non propone una certa versione. La dicitura [installato, automatico] indica che il pacchetto è stato installato come dipendenza e non su richiesta.

Esempio 8: a quale pacchetto appartiene un file?

$ dpkg -S /usr/sbin/nginx
nginx: /usr/sbin/nginx
$ dpkg -S $(which htop)
htop: /usr/bin/htop
$ dpkg -L nginx-common | head -n 4
/.
/etc
/etc/default
/etc/default/nginx
$ sudo apt install apt-file && sudo apt-file update
$ apt-file search bin/dig
dnsutils: /usr/bin/dig

dpkg -S file risponde alla domanda "da quale pacchetto arriva questo file?" (tra le installate), e dpkg -L pacchetto elenca tutti i file che un pacchetto ha installato, utile per sapere dove ha messo configurazioni ed eseguibili. Per cercare in quale pacchetto non ancora installato si trova un comando che manca, si usa apt-file: qui si scopre che dig è nel pacchetto dnsutils.

Esempio 9: installare un file .deb scaricato

$ curl -fLO https://example.org/download/programma_1.2.3_amd64.deb
$ sudo apt install ./programma_1.2.3_amd64.deb
$ sudo dpkg -i programma_1.2.3_amd64.deb
$ sudo apt --fix-broken install

Alcuni programmi si distribuiscono come file .deb da scaricare (per esempio con curl). Il modo giusto di installarli è sudo apt install ./file.deb (con il ./ iniziale, o il percorso, per far capire che è un file e non il nome di un pacchetto): apt installa anche le dipendenze che mancano. Con dpkg -i si installa il solo file, e se mancano dipendenze l'installazione resta a metà: in quel caso apt --fix-broken install (o apt -f install) completa l'operazione o la annulla.

Esempio 10: bloccare un pacchetto a una versione

$ sudo apt-mark hold nginx
$ apt-mark showhold
nginx
$ sudo apt-mark unhold nginx
$ apt-mark showmanual | head -n 5

Con apt-mark hold un pacchetto viene "congelato" e non viene più aggiornato, utile quando un aggiornamento romperebbe qualcosa e va rinviato. showhold elenca i pacchetti bloccati e unhold toglie il blocco. showmanual elenca invece i pacchetti installati su richiesta dell'utente, e non come dipendenza. Un pacchetto bloccato non riceve nemmeno gli aggiornamenti di sicurezza: si tratta di una soluzione temporanea.

Esempio 11: i repository

$ cat /etc/apt/sources.list.d/ubuntu.sources
Types: deb
URIs: http://archive.ubuntu.com/ubuntu
Suites: noble noble-updates noble-backports
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg

$ cat /etc/apt/sources.list
deb http://deb.debian.org/debian bookworm main contrib
deb http://security.debian.org/debian-security bookworm-security main contrib
$ ls /etc/apt/sources.list.d/
$ sudo apt edit-sources

I repository sono elencati nel file /etc/apt/sources.list e nei file della cartella /etc/apt/sources.list.d/. I sistemi più recenti usano un formato a più righe (deb822, file con estensione .sources, come nel primo esempio), quelli più vecchi una riga per repository (deb ..., nel secondo). Le parti importanti sono l'indirizzo, la versione della distribuzione (noble, bookworm) e i componenti (main per il software libero della distribuzione, universe per quello mantenuto dalla comunità, contrib e non-free in Debian per software con vincoli di licenza). Dopo ogni modifica, sudo apt update.

Esempio 12: aggiungere un repository di terze parti

$ sudo install -d -m 0755 /etc/apt/keyrings
$ curl -fsSL https://example.org/repo/chiave.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/esempio.gpg
$ echo "deb [signed-by=/etc/apt/keyrings/esempio.gpg] https://example.org/repo stable main" | sudo tee /etc/apt/sources.list.d/esempio.list
$ sudo apt update
$ sudo add-apt-repository ppa:nome/ppa

Alcuni programmi si installano da un repository fornito dagli autori. Si scarica la loro chiave di firma e la si salva in /etc/apt/keyrings/, poi si aggiunge una riga in un nuovo file in /etc/apt/sources.list.d/ che indica con signed-by quale chiave vale per quel repository (è il metodo attuale; il vecchio apt-key è obsoleto). Il passaggio con tee serve perché la redirezione con > non eredita i permessi di sudo (vedi l'articolo su tee). Su Ubuntu i PPA (archivi personali) si aggiungono più semplicemente con add-apt-repository. Aggiungere un repository significa dare fiducia a chi lo gestisce: le sue versioni sostituiscono quelle della distribuzione e possono fare qualsiasi cosa sul sistema.

Esempio 13: liberare spazio con la cache

$ du -sh /var/cache/apt/archives
312M	/var/cache/apt/archives
$ sudo apt clean
$ sudo apt autoclean
$ sudo apt autoremove --purge

apt conserva in /var/cache/apt/archives i pacchetti scaricati. apt clean li cancella tutti, apt autoclean solo quelli non più scaricabili (versioni vecchie). Con df e du (vedi l'articolo dedicato) si controlla quanto spazio si libera. Non è pericoloso: i pacchetti, se serve, verranno riscaricati.

Esempio 14: la cronologia delle operazioni

$ less /var/log/apt/history.log
Start-Date: 2026-10-20  04:12:08
Commandline: apt install nginx
Requested-By: enzo (1000)
Install: nginx:amd64 (1.24.0-2ubuntu7.2), nginx-common:amd64 (1.24.0-2ubuntu7.2, automatic)
End-Date: 2026-10-20  04:12:15
$ grep -B2 -A3 "Remove" /var/log/apt/history.log | tail -n 20

Ogni operazione di apt viene registrata in /var/log/apt/history.log, con data, comando, utente e pacchetti coinvolti (i file più vecchi sono compressi in history.log.1.gz e simili, leggibili con zless). È utilissimo per capire "cosa ho installato la settimana scorsa" o cosa è stato rimosso da un aggiornamento che ha rotto qualcosa.

Esempio 15: uso negli script

#!/bin/bash
set -e

PACCHETTI="curl rsync tmux htop"

sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq

for p in $PACCHETTI; do
    if dpkg -s "$p" > /dev/null 2>&1; then
        echo "$p: già installato"
    else
        echo "$p: installo..."
        sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends "$p"
    fi
done

if [ -f /var/run/reboot-required ]; then
    echo "Attenzione: serve un riavvio" >&2
fi

Negli script si preferisce apt-get a apt: ha le stesse funzioni principali, ma un'interfaccia stabile e senza gli avvisi che apt stampa quando non c'è un terminale ("apt does not have a stable CLI interface"). L'opzione -y risponde "sì" alle domande, -qq riduce il rumore e la variabile DEBIAN_FRONTEND=noninteractive evita le finestre di dialogo di configurazione. Con sudo la variabile va scritta dopo sudo perché passi al comando (sudo ripulisce l'ambiente). dpkg -s verifica se un pacchetto è già installato, e il file /var/run/reboot-required compare quando un aggiornamento (come quello del kernel) richiede un riavvio.

Opzioni utili

• update: aggiorna l'elenco dei pacchetti; upgrade / full-upgrade: aggiorna i programmi (il secondo anche rimuovendo o installando pacchetti).
• install / remove / purge / autoremove: installa, rimuove, rimuove con le configurazioni, toglie le dipendenze orfane.
• search / show / policy / list: cerca, mostra i dettagli, mostra versioni e provenienza, elenca (--installed, --upgradable).
• -y (--yes): risponde sì a tutte le domande; -s (--simulate): simula; -q / -qq: meno output.
• --no-install-recommends: installa solo le dipendenze indispensabili.
• --reinstall: reinstalla un pacchetto; -f / --fix-broken: ripara dipendenze rotte; --only-upgrade: aggiorna solo se già installato.
• apt download pacchetto: scarica il .deb nella cartella corrente, senza installarlo.
• apt depends / apt rdepends: dipendenze di un pacchetto / pacchetti che dipendono da esso.
• apt-mark hold / unhold / showhold / showmanual: blocca, sblocca, elenca bloccati e installati a mano.
• apt clean / autoclean: svuotano la cache; apt edit-sources: modifica i repository.
• dpkg -l / -s / -L / -S / -i: elenca, stato, file di un pacchetto, pacchetto di un file, installa un .deb.

Attenzione a

• update e upgrade sono due cose diverse: il primo aggiorna l'elenco, il secondo i programmi. Per aggiornare il sistema servono entrambi, in questo ordine: sudo apt update && sudo apt upgrade.
• Leggi sempre l'elenco prima di confermare, soprattutto con remove, purge, autoremove e full-upgrade: rimuovere un pacchetto può togliere con sé altri pacchetti che ne dipendono, anche importanti (per esempio il desktop). Con -y la domanda salta, e va quindi usato negli script, non alla cieca da terminale.
• purge può cancellare dati: oltre alle configurazioni, in alcuni pacchetti (database come MariaDB o PostgreSQL) può eliminare anche i dati. Prima di rimuovere un database, fai un'esportazione, e non fidarti dell'idea che i dati restino "al sicuro".
• Prima di un aggiornamento importante: su un server esegui prima un backup (con rsync o con le copie del fornitore della VPS) e, se puoi, una simulazione con -s. Gli aggiornamenti di servizi come database, PHP o server web possono richiedere interventi sulla configurazione.
• Non toccare i file di blocco: se compare "Could not get lock /var/lib/dpkg/lock-frontend", un altro processo (un aggiornamento automatico, o un'altra finestra) sta usando apt. Aspetta che finisca, e controlla con ps aux | grep -E 'apt|dpkg'. Cancellare i file di blocco a mano può rovinare il database dei pacchetti: è l'ultima risorsa, e solo se sei sicuro che nessun processo li usi.
• Non interrompere apt a metà: un Ctrl+C durante un'installazione, o un SSH che cade, può lasciare il sistema in uno stato incoerente. Se succede, sudo dpkg --configure -a e poi sudo apt --fix-broken install di solito sistemano. Per le operazioni lunghe su server remoti usa tmux o screen.
• Dopo un aggiornamento, i servizi vanno riavviati: un programma già in esecuzione usa ancora la vecchia versione (e le vecchie librerie) fino al riavvio. Su Ubuntu lo strumento needrestart lo segnala; altrimenti si usa systemctl restart. Per un nuovo kernel serve il riavvio del sistema, segnalato dalla presenza di /var/run/reboot-required.
• Attenzione ai kernel: apt autoremove toglie i vecchi kernel, ma tiene l'ultimo e quello in uso. Se il nuovo kernel non si avvia, ti serve quello vecchio per ripartire: non rimuovere kernel a mano senza sapere quale stai usando (uname -r).
• I repository di terze parti sono un rischio: una chiave e un indirizzo aggiunti a apt permettono a un estraneo di installare software sul tuo sistema, con i permessi di root. Aggiungili solo se ti fidi del progetto e prendi la chiave da una fonte ufficiale. Lo stesso vale per i PPA di Ubuntu. Allo stesso modo, curl ... | sudo bash come "installazione rapida" va evitato: scarica lo script, leggilo, poi eseguilo (vedi l'articolo su curl).
• Versione diversa della distribuzione, repository sbagliati: copiare righe di sources.list da una guida scritta per un'altra versione (bullseye invece di bookworm, o jammy invece di noble) porta a conflitti di pacchetti difficili da riparare. Verifica con lsb_release -a o con cat /etc/os-release la versione che stai usando.
• Non mescolare versioni: installare pacchetti da repository di un'altra versione della distribuzione (per esempio "testing" su una "stable") è il modo più comune di rompere un sistema Debian. Per avere una versione più recente di un programma conviene cercare un repository ufficiale del progetto, i backports o un'installazione separata (come un container).
• Su Ubuntu alcuni pacchetti sono snap: sudo apt install firefox (e altri) installa un pacchetto "ponte" che scarica in realtà uno snap. Per saperlo, apt policy nome o snap list. Sono sistemi di pacchetti diversi, con aggiornamenti e comportamenti propri.
• Aggiornare la distribuzione non si fa con apt upgrade: passare a una nuova versione (da Debian 12 a 13, da Ubuntu 22.04 a 24.04) richiede una procedura apposita (do-release-upgrade su Ubuntu, la modifica dei repository e un full-upgrade per Debian), con un backup e la lettura delle note di rilascio.
• Aggiornamenti automatici di sicurezza: il pacchetto unattended-upgrades (di serie su Ubuntu) applica da solo gli aggiornamenti di sicurezza. È una buona idea per i server, ma ricorda che i servizi interessati possono essere riavviati senza che tu lo sappia; il registro è in /var/log/unattended-upgrades/.
• Bisogna sapere il nome giusto del pacchetto: non sempre coincide con il nome del comando (dig è in dnsutils, ifconfig in net-tools, 7z in p7zip-full). Si cerca con apt search, con apt-file search o con il messaggio "Command 'x' not found, but can be installed with: sudo apt install y" che molte distribuzioni mostrano.
• Altre distribuzioni, altri comandi: apt esiste solo nella famiglia Debian. Su Fedora, RHEL e derivate si usa dnf; su Arch pacman; su openSUSE zypper. Il concetto è lo stesso, cambiano i nomi dei comandi.

Riepilogo