Ubuntu 26.04 / Salvare configurazioni, pacchetti e dati e provare il ripristino

Un backup di Ubuntu richiede un ambito definito, una copia conservata al riparo dallo stesso guasto dell’origine e un ripristino provato. Un elenco di pacchetti o uno snapshot della VM non bastano da soli: qui distinguerai configurazioni, dati e inventari, poi proverai il recupero in una directory separata senza sovrascrivere gli originali.

Stabilire che cosa deve tornare disponibile

Oggetto Che cosa conservare e verificare
Configurazione File modificati sotto /etc, motivi delle modifiche e versioni dei servizi; accesso limitato a certificati e chiavi private
File degli utenti Percorsi reali delle home e delle condivisioni, identificativi UID/GID, permessi, ACL e attributi estesi richiesti
Dati applicativi Dump dei database, volumi, file caricati, versioni dell’app e procedura per ottenere dati coerenti
Pacchetti Elenco APT delle installazioni manuali, versioni complete, inventario Snap e informazioni sui repository
Accesso di recupero Supporti d’installazione, console, chiavi di sblocco e decifratura del backup, responsabilità della custodia

UID e GID sono gli identificativi numerici di utenti e gruppi. Le ACL, liste di controllo degli accessi, possono definire permessi ulteriori rispetto ai normali bit di modalità; gli attributi estesi conservano altri metadati. Se servono ai tuoi dati, verifica separatamente che strumenti e file system li salvino e li ripristinino.

Un semplice tar dei file di un database attivo può mescolare istanti diversi. Usa un dump supportato dall’app oppure una procedura coordinata di arresto o congelamento e identifica gli archivi da recuperare insieme. Prima di agire stabilisci quanto tempo di fermo e quante modifiche perse siano accettabili.

Registrare pacchetti e posizioni delle configurazioni

Questo blocco crea una nuova directory d’inventario nella home dell’utente corrente senza installare o rimuovere pacchetti. L’accesso è limitato perché gli elenchi possono contenere dettagli operativi. Non includono il contenuto dei file di configurazione o dei documenti.

(
set -eu
umask 077
inventory_dir=$(mktemp -d "$HOME/ubuntu-inventory.XXXXXX")
apt-mark showmanual > "$inventory_dir/apt-manual.txt"
dpkg-query -W -f='${binary:Package}\t${Version}\n' > "$inventory_dir/dpkg-versions.tsv"
if command -v snap >/dev/null 2>&1; then
    snap list > "$inventory_dir/snap-list.txt"
fi
cat /etc/os-release > "$inventory_dir/os-release.txt"
printf "%s\n" "$inventory_dir"
)

Conserva il percorso stampato; la variabile della subshell non rimane disponibile al termine. apt-manual.txt elenca i pacchetti marcati come installati manualmente, mentre dpkg-versions.tsv registra nomi e versioni. L’elenco Snap viene creato soltanto se il comando esiste. Un errore arresta il blocco e può lasciare un inventario parziale: non considerarlo completo senza leggere esiti e file.

Prima del recupero verifica quali pacchetti e repository servano davvero e siano supportati nella release di destinazione, anziché reinstallare indiscriminatamente tutto l’elenco. Registra separatamente le definizioni dei repository e le relative chiavi verificate: questo blocco non le esporta. Distingui i file di configurazione dalle identità specifiche della macchina, come machine-id, chiavi host SSH e indirizzi statici. Recuperare lo stesso server e clonarne un altro richiede scelte diverse.

Provare un piccolo ciclo di backup e ripristino

Salva tutto il codice in ~/backup-roundtrip-lab.sh ed esegui bash ~/backup-roundtrip-lab.sh. Servono tar, sha256sum e cmp; non viene usato sudo. Il laboratorio crea soltanto file nuovi in una directory temporanea. Una prova sullo stesso disco verifica il procedimento, ma non sostituisce una copia indipendente.

set -eu
umask 077
lab_dir=$(mktemp -d)
mkdir "$lab_dir/source" "$lab_dir/restored"
printf "original data\n" > "$lab_dir/source/note with spaces.txt"
tar -C "$lab_dir/source" -cpf "$lab_dir/data.tar" .
(
    cd "$lab_dir"
    sha256sum data.tar > data.tar.sha256
    sha256sum -c data.tar.sha256
)
tar -tf "$lab_dir/data.tar"
tar -C "$lab_dir/restored" -xpf "$lab_dir/data.tar"
cmp "$lab_dir/source/note with spaces.txt" "$lab_dir/restored/note with spaces.txt"
printf "Round trip passed: %s\n" "$lab_dir"

Il controllo SHA-256 confronta l’archivio con i byte registrati nel file di checksum; l’elenco tar mostra i nomi inclusi. Solo il successo di cmp, seguito da Round trip passed, conferma il recupero del contenuto di questo file di esempio. Il manuale Ubuntu di sha256sum descrive il controllo con -c.

La prova non verifica cifratura, permessi reali degli utenti o avvio dell’app. Non estrarre archivi sconosciuti con privilegi amministrativi: anche un archivio con checksum valido deve avere un’origine fidata. Inizia i ripristini in una posizione isolata e vuota e controlla i nomi dei membri prima dell’estrazione.

Salvare la configurazione Nginx e una cartella utente

L’esempio usa /etc/nginx dopo il laboratorio sui siti Nginx e una cartella di documenti ordinari nella tua home. Identifica il percorso reale e sospendi modifiche, sincronizzazione e scritture dell’app per ottenere una copia coerente. Non sostituire con questa copia di file un dump di database o un backup coordinato dei volumi Docker.

Registra punto di montaggio e UUID del disco di backup separato. UUID identifica il file system, non garantisce da solo un dispositivo fisico indipendente: due partizioni diverse dello stesso disco possono guastarsi insieme. Controlla la corrispondenza con dispositivi, dischi e livelli LVM effettivi, per esempio con lsblk -f e l’inventario dello storage. Il controllo nello script è una protezione aggiuntiva, non l’intera verifica dell’indipendenza.

Salva il codice completo in ~/backup-course-data.sh. Richiede Bash, GNU tar, findmnt di util-linux e realpath/sha256sum di coreutils. I tre argomenti sono la cartella utente, il punto di montaggio del file system di backup e il suo UUID verificato. Adatta bash ~/backup-course-data.sh "$HOME/Documents/course-data" /srv/backup UUID_REALE ai valori locali; il segnaposto non è un UUID da copiare letteralmente.

set -eu
umask 077
if [ "$#" -ne 3 ]; then
    printf 'Usage: bash backup-course-data.sh SOURCE_DIR BACKUP_MOUNT EXPECTED_UUID\n' >&2; exit 2
fi
source_dir=$(realpath -- "$1")
backup_mount=$(realpath -- "$2")
expected_uuid=$3
case "$source_dir" in
    "$HOME"/*) ;;
    *) printf 'Choose a specific ordinary-data folder inside your home.\n' >&2; exit 1 ;;
esac
test -d "$source_dir"
if [ -z "$expected_uuid" ] || [ "$expected_uuid" = REPLACE_WITH_VERIFIED_UUID ]; then
    printf 'Record the actual backup filesystem UUID first.\n' >&2; exit 1
fi
actual_uuid=$(findmnt -rn --mountpoint "$backup_mount" -o UUID || true)
if [ "$actual_uuid" != "$expected_uuid" ]; then
    printf 'Expected backup filesystem is not mounted; stop.\n' >&2; exit 1
fi
for original in "$source_dir" /etc/nginx; do
    original_uuid=$(findmnt -rn --target "$original" -o UUID)
    if [ -z "$original_uuid" ] || [ "$original_uuid" = "$actual_uuid" ]; then
        printf 'Use a separate verified backup filesystem.\n' >&2; exit 1
    fi
done
case "$backup_mount/" in
    "$source_dir/"*) printf 'Backup must be outside the source tree.\n' >&2; exit 1 ;;
esac
sudo test -d /etc/nginx
df -h "$source_dir" "$backup_mount"
set_dir=$(sudo mktemp -d "$backup_mount/ubuntu-course-backup.XXXXXX")
sudo chmod 0700 "$set_dir"
sudo tar --acls --xattrs --numeric-owner -C / -cpf "$set_dir/nginx.tar" etc/nginx
sudo tar --acls --xattrs --numeric-owner -C "$source_dir" -cpf "$set_dir/user-data.tar" .
sudo sh -c 'cd "$1" && sha256sum nginx.tar user-data.tar > SHA256SUMS && sha256sum -c SHA256SUMS' sh "$set_dir"
printf 'Backup set: %s\n' "$set_dir"

findmnt --mountpoint cerca il montaggio indicato, mentre --target identifica il file system che contiene un percorso. Il manuale Ubuntu di findmnt chiarisce questa distinzione. Se il montaggio manca, l’UUID non coincide o l’origine risulta sullo stesso file system, lo script si ferma prima di creare gli archivi.

Un risultato positivo stampa la directory del nuovo set e due esiti OK. Controlla spazio libero e tutti gli errori: un’interruzione durante tar può lasciare un set incompleto, da non usare come ultimo backup valido. La verifica iniziale non impedisce che un disco si smonti durante la copia; mantieni stabile il montaggio e controlla anche l’esito finale.

La directory 0700 limita l’accesso a root, ma non cifra i dati contro il furto del disco. Prepara cifratura, custodia delle chiavi e conservazione separatamente. Le opzioni ACL e attributi estesi richiedono supporto effettivo: il manuale Ubuntu di GNU tar elenca le opzioni disponibili. Verifica quali attributi siano davvero ripristinati, senza presumere che ogni namespace o metadato speciale sia coperto automaticamente.

Estrarre in una posizione vuota e confrontare

Usa esclusivamente il set fidato che hai appena creato. Salva il blocco in ~/restore-course-data.sh ed esegui bash ~/restore-course-data.sh PERCORSO_SET_BACKUP sostituendo il percorso stampato. Controlla capacità libera e corrispondenza degli UID/GID prima dell’estrazione. Il ripristino avviene in una nuova directory sotto /var/tmp e non sovrascrive /etc/nginx o la cartella utente originale.

set -eu
if [ "$#" -ne 1 ]; then
    printf 'Usage: bash restore-course-data.sh BACKUP_SET_DIRECTORY\n' >&2; exit 2
fi
set_dir=$(realpath -- "$1")
sudo test -f "$set_dir/SHA256SUMS"
sudo sh -c 'cd "$1" && sha256sum -c SHA256SUMS' sh "$set_dir"
restore_dir=$(sudo mktemp -d /var/tmp/ubuntu-course-restore.XXXXXX)
sudo chmod 0700 "$restore_dir"
sudo mkdir "$restore_dir/config" "$restore_dir/data"
sudo tar --acls --xattrs --same-owner -C "$restore_dir/config" -xpf "$set_dir/nginx.tar"
sudo tar --acls --xattrs --same-owner -C "$restore_dir/data" -xpf "$set_dir/user-data.tar"
sudo ls -ldn "$restore_dir/config/etc/nginx" "$restore_dir/data"
printf 'Isolated restore: %s\n' "$restore_dir"

Il controllo dei checksum deve riuscire prima di creare la directory di recupero. Conserva il percorso Isolated restore stampato. I numeri dei proprietari vengono mantenuti nell’estrazione privilegiata; su un altro sistema lo stesso numero potrebbe corrispondere a un utente diverso. Non applicare direttamente questi file a un servizio operativo senza una verifica delle identità e delle versioni.

Sostituisci il segnaposto seguente con il percorso realmente stampato e adatta la cartella di origine. Confronta con una fonte non cambiata dal backup. Esegui e leggi ciascun diff separatamente: nessun output e stato 0 indicano corrispondenza dei contenuti esaminati, stato 1 indica differenze; altri errori richiedono di controllare percorsi e permessi.

restore_dir=/var/tmp/REPLACE_WITH_PRINTED_RESTORE_DIRECTORY
source_dir="$HOME/Documents/course-data"
sudo diff --no-dereference -r /etc/nginx "$restore_dir/config/etc/nginx"
sudo diff --no-dereference -r "$source_dir" "$restore_dir/data"

Se l’origine è cambiata dopo la copia, una differenza non dimostra da sola un archivio danneggiato. --no-dereference evita di seguire i collegamenti simbolici durante il confronto, ma diff non verifica tutti i metadati. Confronta contenuti importanti, proprietari numerici e modalità con ls -ln, e le ACL o gli attributi richiesti con getfacl/getfattr; prepara i pacchetti acl e attr se necessari.

L’estrazione di file non conclude il recupero di un servizio. Su un server separato verifica la configurazione e le funzioni dell’app prima dell’eventuale applicazione reale. Dopo il confronto, pulisci soltanto le directory create da te, dopo averne controllato percorso e contenuto; conserva originali e copie utili finché la verifica non è conclusa.

Preparare conservazione indipendente e rilevamento degli errori

Una directory di destinazione esistente non dimostra che il disco esterno sia collegato. Confronta SOURCE e UUID del montaggio con l’identità registrata e interrompi la scrittura se non coincidono. Scrivere nella directory vuota di un disco non montato può riempire il disco di sistema. Pianifica capacità, possibilità di decifratura e generazioni fuori sede o offline in base al guasto da cui vuoi recuperare.

La guida Ubuntu ai backup con script shell include esempi tar e ripristino in un’altra directory. Automatizza dopo un ripristino manuale riuscito: registra stato di uscita, ultimo successo, generazioni conservate e problemi di spazio, poi prova che l’avviso di errore arrivi al destinatario responsabile.

Un hash accanto a un archivio modificabile non impedisce che entrambi vengano alterati. Quando il rischio lo richiede, usa un registro di verifica indipendente o una conservazione non modificabile. Verifica inoltre che le credenziali di backup e le chiavi di decifratura restino accessibili in caso di perdita del server originale.

Valutare il recupero con dati e servizi funzionanti

Nella destinazione controlla numero di file, contenuti importanti, proprietari e permessi, poi prova lettura e scrittura dell’app e accesso degli utenti. Verifica DNS, certificati, condivisioni e ripresa dei backup secondo il sistema recuperato. Registra durata del recupero e modifiche perse: se superano i limiti accettabili, rivedi frequenza e procedura. Non inizializzare il disco guasto prima di aver messo al sicuro i dati e le prove necessarie.