IT

Linux e rete

Installare un kernel recente su Debian con i backports

Installa un kernel Linux recente su Debian 13 dai backports ufficiali, avvialo una sola volta per provarlo, poi confermalo o torna al kernel stabile.

8 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

Questa guida spiega come installare un kernel Linux più recente su Debian 13 (Trixie) dai backports ufficiali. Il metodo prevede la possibilità di tornare indietro: il nuovo kernel viene avviato una sola volta per la prova, e quello vecchio resta la scelta predefinita finché non hai confermato il nuovo.

Al momento della stesura, Debian 13 fornisce un kernel 6.12 nei repository stabili e un kernel 7.2 nei backports. Questi numeri cambieranno: fai riferimento a ciò che mostrano i tuoi comandi.

Prerequisiti

  • Debian 13 (Trixie) con GRUB come bootloader
  • Un accesso SSH con i diritti sudo
  • Una finestra di manutenzione, perché il server deve riavviarsi
  • Un backup recente
  • L'accesso alla tua area clienti, per riavviare il VPS e aprire la console VNC

Fase 1: fare il punto della situazione

Terminale
grep '^PRETTY_NAME=' /etc/os-release
uname -r
dpkg --print-architecture
dpkg -l 'linux-image*' | awk '/^ii/ {print $2, $3}'
df -h /boot
ls -l /boot/grub/grub.cfg
sudo grub-probe --target=abstraction /boot/grub
command -v dkms && dkms status

Verifica i punti seguenti:

Controllo Risultato atteso
Sistema Debian GNU/Linux 13 (trixie)
/boot Diverse centinaia di MB liberi
/boot/grub/grub.cfg Il file esiste
grub-probe --target=abstraction Nessun output
dkms status Annota i moduli elencati: dovranno essere compilati per il nuovo kernel

Individua poi il metapacchetto installato e registralo. È questo pacchetto che permette di seguire le future versioni del kernel:

Pacchetto presente Valore da usare
linux-image-amd64 linux-image-amd64
linux-image-cloud-amd64 linux-image-cloud-amd64
linux-image-arm64 linux-image-arm64
linux-image-cloud-arm64 linux-image-cloud-arm64
Terminale
META=linux-image-amd64

Fase 2: eseguire un backup

Crea uno snapshot dalla tua area clienti se la tua offerta lo consente, oppure esegui il backup del VPS con Clonezilla. Tornare al kernel precedente non sostituisce un backup dei tuoi dati.

Fase 3: mantenere il kernel attuale come predefinito

Verifica dove è definito GRUB_DEFAULT:

Terminale
grep -rs '^GRUB_DEFAULT' /etc/default/grub /etc/default/grub.d/

Se l'impostazione si trova in /etc/default/grub, impostala su saved. Se si trova in /etc/default/grub.d/, modifica invece quel file.

Terminale
sudo cp /etc/default/grub /etc/default/grub.bak
sudo sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT=saved/' /etc/default/grub
sudo update-grub
sudo grep -c 'set default="${saved_entry}"' /boot/grub/grub.cfg

L'ultimo comando deve mostrare 1 o un valore superiore.

Il titolo di una voce di GRUB varia in base alla lingua e al sistema. Questa funzione lo ritrova a partire dalla versione del kernel:

Terminale
entree_grub() {
  sudo awk -F"'" -v v="$1" '
    /^submenu / { parent = $2 ">" }
    /^[[:space:]]*menuentry / && index($2, v) { print parent $2; exit }
  ' /boot/grub/grub.cfg
}

Imposta il kernel attuale come scelta predefinita, poi proteggilo da una rimozione automatica:

Terminale
ANCIEN=$(uname -r)
entree_grub "$ANCIEN"
sudo grub-set-default "$(entree_grub "$ANCIEN")"
sudo grub-editenv list
sudo apt-mark manual "linux-image-$ANCIEN"

La riga saved_entry= deve riportare il tuo kernel attuale. Se entree_grub non mostra nulla, fermati qui e controlla /boot/grub/grub.cfg.

Fase 4: attivare i backports

Terminale
sudo tee /etc/apt/sources.list.d/debian-backports.sources > /dev/null <<'EOF'
Types: deb
URIs: http://deb.debian.org/debian
Suites: trixie-backports
Components: main
Enabled: yes
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg
EOF
sudo apt update
apt policy "$META"

La versione dei backports compare con priorità 100 e contiene ~bpo13. Questa priorità impedisce a Debian di installarli senza una tua richiesta.

Fase 5: installare il kernel

Terminale
sudo apt install -t trixie-backports "$META"

Rileggi l'elenco visualizzato prima di confermare: deve contenere solo il kernel e le sue dipendenze. Se usi moduli DKMS, installa anche gli header corrispondenti, linux-headers-amd64 o linux-headers-cloud-amd64:

Terminale
sudo apt install -t trixie-backports linux-headers-amd64

Aggiorna poi GRUB e individua il nuovo kernel:

Terminale
sudo update-grub
ls /boot/vmlinuz-*
NOUVEAU=$(ls /boot/vmlinuz-* | sed 's#.*/vmlinuz-##' | sort -V | tail -n 1)
echo "$NOUVEAU"

Il nome del kernel non contiene bpo, ad esempio 7.2.12+deb13-amd64. Lo contiene solo la versione del pacchetto.

Fase 6: avviare una sola volta il nuovo kernel

Terminale
entree_grub "$NOUVEAU"
sudo grub-reboot "$(entree_grub "$NOUVEAU")"
sudo grub-editenv list

Devi vedere saved_entry= con il vecchio kernel e next_entry= con il nuovo. Riavvia:

Terminale
sudo systemctl reboot

GRUB consuma next_entry all'avvio. Se il nuovo kernel si blocca, basta quindi un semplice riavvio per tornare a quello vecchio.

Fase 7: verificare il nuovo kernel

Riconnettiti, poi controlla il sistema e i tuoi servizi:

Terminale
uname -r
systemctl --failed
sudo journalctl -b -p err --no-pager | tail -n 30
ip -br address
sudo ss -tulpn
command -v dkms && dkms status

Prova anche le tue applicazioni: sito web, database, container, backup e monitoraggio. Alcuni messaggi possono essere innocui, ma un servizio in errore o un modulo mancante va compreso prima di confermare.

Fase 8: confermare il nuovo kernel

Se tutto funziona, chiedi a GRUB di avviare la prima voce, cioè il kernel più recente:

Terminale
sudo grub-set-default 0
sudo grub-editenv list

Conserva il vecchio kernel per qualche tempo. Resta disponibile nel menu di GRUB in caso di necessità.

Aggiornamenti

Una volta installato, il kernel dei backports riceve gli aggiornamenti con i comandi abituali:

Terminale
sudo apt update
sudo apt upgrade

Questi aggiornamenti possono passare a un nuovo ramo principale del kernel. Le correzioni di sicurezza arrivano in modalità best effort, a volte più tardi che nella versione stabile: la lista debian-backports-announce permette di seguirle.

Tornare al kernel stabile

Se il nuovo kernel non si avvia

  1. Attendi qualche minuto, poi riavvia il VPS con l'icona di riavvio nella pagina della tua istanza.
  2. Riconnettiti via SSH e verifica che uname -r mostri il vecchio kernel.
  3. Se il server resta irraggiungibile, clicca su Accéder à la console VNC (Accedi alla console VNC), poi su NoVNC Console graphique (NoVNC console grafica). Riavvia e, nel menu di GRUB, scegli le opzioni avanzate, poi il vecchio kernel.

Rimuovere il kernel dei backports

1. Avvia prima il vecchio kernel. Se uname -r mostra ancora quello nuovo, elenca i kernel, poi sostituisci la versione in questo esempio. Dopo un riavvio, ridefinisci la funzione entree_grub della fase 3:

Terminale
ls /boot/vmlinuz-*
sudo grub-reboot "$(entree_grub "6.12.117+deb13-amd64")"
sudo systemctl reboot

2. Torna alle versioni stabili. Questo comando cerca, per ogni pacchetto proveniente dai backports, la versione più recente al di fuori dei backports. In questo modo mantiene le correzioni di sicurezza di Debian:

Terminale
A_RETROGRADER=$(for p in $(dpkg-query -W -f='${Package} ${Version}\n' | awk '/~bpo/ {print $1}'); do
  v=$(apt-cache madison "$p" | awk '$3 !~ /~bpo/ {print $3; exit}')
  [ -n "$v" ] && echo "$p=$v"
done)
echo "$A_RETROGRADER"

Rileggi l'elenco. Togli ogni pacchetto che avevi installato volontariamente dai backports e che non ha relazione con il kernel. Poi esegui:

Terminale
sudo apt install --allow-downgrades $A_RETROGRADER

3. Elimina i pacchetti rimanenti:

Terminale
A_SUPPRIMER=$(dpkg-query -W -f='${Package} ${Version}\n' | awk '/~bpo/ {print $1}')
echo "$A_SUPPRIMER"
sudo apt purge $A_SUPPRIMER
sudo apt autoremove --purge

Controlla di nuovo l'elenco prima di confermare. Non deve contenere il kernel mostrato da uname -r. Se lo contiene, o se un avviso segnala la rimozione del kernel in esecuzione, annulla e torna al punto 1.

4. Ripristina GRUB e rimuovi il repository:

Terminale
sudo update-grub
sudo grub-set-default 0
sudo rm /etc/apt/sources.list.d/debian-backports.sources
sudo apt update

5. Controlla il risultato:

Terminale
uname -r
dpkg-query -W -f='${Package} ${Version}\n' | grep -F '~bpo'
apt policy "$META"

Il secondo comando non deve mostrare nulla, a parte i pacchetti che hai scelto di conservare.

Risoluzione dei problemi

The value 'trixie-backports' is invalid for APT::Default-Release

Testo
E: The value 'trixie-backports' is invalid for APT::Default-Release as such a release is not available in the sources

Il repository non è attivo. Controlla /etc/apt/sources.list.d/debian-backports.sources, poi esegui di nuovo sudo apt update.

APT annuncia la rimozione di molti pacchetti

Rispondi n. L'installazione di un kernel non deve rimuovere le tue applicazioni. Controlla i repository con apt policy, completa gli aggiornamenti in sospeso, poi riprova.

No space left on device durante l'installazione

/boot è probabilmente pieno. Consulta df -h /boot e dpkg -l 'linux-image*'. Elimina un vecchio kernel inutile con sudo apt purge, mai quello mostrato da uname -r.

Un modulo DKMS non si compila

Consulta dkms status e verifica che gli header installati corrispondano al kernel. Un modulo esterno può non supportare ancora questa versione del kernel. In questo caso, resta sul kernel stabile o attendi una versione compatibile del modulo.

uname -r mostra ancora il vecchio kernel

Controlla che il nuovo kernel compaia in GRUB e che next_entry contenesse un titolo completo prima del riavvio:

Terminale
sudo update-grub
entree_grub "$NOUVEAU"
sudo grub-editenv list

Il server si riavvia sempre sul nuovo kernel

GRUB potrebbe non essere riuscito a cancellare next_entry, in particolare con LVM o RAID. Dal sistema avviato, elimina la variabile e scegli il kernel desiderato:

Terminale
sudo grub-editenv /boot/grub/grubenv unset next_entry
sudo grub-set-default "$(entree_grub "$(uname -r)")"

Se vuoi tornare al vecchio kernel, indica la sua versione al posto di $(uname -r).

La rete non torna dopo il riavvio

Apri la console VNC, poi consulta ip -br address e sudo journalctl -b -p err. Se il problema dipende dal nuovo kernel, riavvia su quello vecchio e segui la procedura di ritorno.

Riferimenti