Archiviare terabyte di dati personali – il mio workflow nerd con RAR + Bash

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
Negli ultimi decenni ho accumulato qualche terabyte di dati personali.
Per lo più cose come:
- Foto
- Musica
- Documenti
- Video
- Backup sparsi di progetti
Per molto tempo tutto è vissuto in un unico archivio centrale sul mio NAS.
Ha funzionato bene per anni… finché due problemi sono diventati sempre più fastidiosi:
- Tempi di backup
- Requisiti di spazio
Soprattutto quando dovevo reinstallare o sostituire il sistema operativo sottostante del NAS,
ripristinare l’intero dataset poteva richiedere molte ore.
A un certo punto ho capito: la mia strategia per i dati andava ripensata 🤓
Indice
Separare i dati attivi dai dati d’archivio
Il mio setup attuale divide i dati in due categorie.
Dati attivi
Sono i file che uso ogni giorno o ogni settimana.
Restano sul NAS:
- Cassaforte delle password (KeePass)
- Documenti attuali
- Foto recenti
- Fatture per le prossime dichiarazioni dei redditi
- Progetti attivi
Dato che il dataset complessivo è diventato molto più piccolo, ho potuto cambiare l’hardware di storage:
Grazie alla quantità ridotta di dati ho potuto sostituire l’HDD ad alta capacità usato finora con un SSD molto più veloce e di capacità inferiore.
Questo mi dà una reattività molto migliore per i file di tutti i giorni.
Dati d’archivio
Tutto ciò che mi serve raramente è stato spostato su un disco d’archivio esterno.
Esempi:
- Foto vecchie
- Video vecchi
- Progetti conclusi
- Documenti storici
Questo approccio ha diversi vantaggi:
- I backup sono molto più veloci
- Il NAS contiene molti meno file
- I requisiti hardware sono più bassi
- L’archiviazione offline riduce il rischio ransomware
Anche se personalmente considero il rischio piuttosto basso, avere un dataset offline
non fa mai male 🙂.
Perché tanti file piccoli sono lenti su ext4
Mentre ottimizzavo i miei backup ho notato una cosa interessante:
Copiare tanti file piccoli è enormemente più lento che copiarne pochi grandi.
Il comportamento si spiega facilmente non appena si guarda come funziona ext4.
Ogni file richiede un inode
ext4 è un file system basato su inode.
Per ogni singolo file il file system deve:
- trovare un inode libero
- scrivere l’inode
- creare una voce di directory
- allocare i blocchi di dati
- aggiornare i metadati
Esempio:
1 file of 1 GB → 1 inode
100,000 files of 10 KB → 100,000 inodes
Questo produce un’enorme quantità di I/O sui metadati.
Il risultato:
- più seek del disco
- più scritture sul journal
- più operazioni sui metadati
In altre parole: tanti file minuscoli rallentano tutto.
Soluzione: raggruppare i file piccoli in grandi archivi
Per affrontare il problema ho deciso di raggruppare molti piccoli file di immagine in grandi file d’archivio.
Ho chiesto a un’IA di aiutarmi a scrivere un piccolo script Bash che:
- scansiona ricorsivamente le mie directory di foto
- raccoglie le immagini di ogni cartella
- crea un grande file d’archivio
Dettaglio importante:
Nessuna compressione.
Le immagini JPEG sono già compresse, quindi un’ulteriore compressione di solito è inutile e spreca solo cicli di CPU.
Perché ho scelto RAR
Qualcuno chiederà: perché RAR?
Risposta semplice: esperienza di lunga data.
RAR offre alcune funzioni estremamente utili per gli archivi:
Archivi suddivisi
Se un archivio supera un limite di dimensione configurato, crea automaticamente dei volumi:
jpg_archive.part1.rar
jpg_archive.part2.rar
jpg_archive.part3.rar
Questi volumi vanno insieme e si possono estrarre senza interruzioni.
Recovery record
RAR può memorizzare informazioni di recupero all’interno dell’archivio.
Questo può aiutare a recuperare i dati se:
- un settore del disco si guasta
- si verifica bitrot
- un file d’archivio si corrompe in parte
Per gli archivi a lungo termine è una funzione estremamente preziosa.
Il compromesso
Naturalmente questo approccio ha un lato negativo.
Se voglio accedere a una singola foto, devo prima:
- estrarre l’archivio
- aprire l’immagine
Ma, realisticamente:
Quanto spesso mi metto a sfogliare a caso una foto del 2007?
Appunto 🙂.
Strategia di backup
Ovviamente il disco d’archivio esterno non è l’unica copia.
Mantengo più copie:
- un disco di backup locale
- un’altra copia aggiuntiva
- un backup off-site
Questo protegge da:
- guasti hardware
- cancellazioni accidentali
- incendio o furto
- bitrot
Lo script Bash
Qui sotto c’è lo script che ho usato per raggruppare ricorsivamente i file di immagine in archivi RAR.
⚠️ Questo script può cancellare file. Fai prima un backup, provalo su dati di test e adatta i percorsi al tuo ambiente.
#!/bin/bash
# Abort immediately on any error
set -e
# Base directory
BASE_DIR="/media/user3/MASTER/daten/bilder/"
LOG_FILE="$BASE_DIR/jpg_rar_log.txt"
if [[ -z "$BASE_DIR" ]]; then
echo "Please provide the base directory as a parameter."
exit 1
fi
# Check if RAR is installed
if ! command -v rar &> /dev/null; then
echo "RAR is not installed. Please install it and try again."
exit 1
fi
# Initialize logfile
echo "=== JPG RAR Archiving Log $(date) ===" > "$LOG_FILE"
# Recursive directory traversal
find "$BASE_DIR" -type d -print0 | while IFS= read -r -d '' DIR; do
# Skip directory if RAR files already exist
if find "$DIR" -maxdepth 1 -type f -iname "*.rar" -print -quit | grep -q .; then
echo "[SKIP] '$DIR' already contains RAR files."
echo "$(date) | $DIR | SKIPPED | Reason: RAR files present" >> "$LOG_FILE"
continue
fi
# Count JPG files
JPG_COUNT=$(find "$DIR" -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) | wc -l)
if [[ "$JPG_COUNT" -le 5 ]]; then
echo "[SKIP] '$DIR' has only $JPG_COUNT JPGs."
echo "$(date) | $DIR | SKIPPED | Reason: too few JPGs ($JPG_COUNT)" >> "$LOG_FILE"
continue
fi
ARCHIVE_NAME="$DIR/jpg_archive.rar"
echo "[PROCESS] '$DIR' → '$ARCHIVE_NAME' ($JPG_COUNT JPGs)"
# Create archive (null-terminated to support special characters)
if find "$DIR" -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -print0 | \
xargs -0 rar a -m0 -rr10p -v5000m -ep1 "$ARCHIVE_NAME"; then
# Determine archive size in MB
ARCHIVE_SIZE=$(du -m "$ARCHIVE_NAME" | cut -f1)
# Delete original files
find "$DIR" -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -exec rm -f {} +
echo "[DONE] Archive successfully created and originals removed."
echo "$(date) | $DIR | SUCCESS | Archive: $ARCHIVE_NAME | Size: ${ARCHIVE_SIZE}MB | JPGs: $JPG_COUNT" >> "$LOG_FILE"
else
echo "[ERROR] Archiving failed, original files remain."
echo "$(date) | $DIR | ERROR | Archive: $ARCHIVE_NAME | JPGs: $JPG_COUNT" >> "$LOG_FILE"
exit 1
fi
done
echo "Finished! Logfile: $LOG_FILE"
Avvertenza importante
⚠️ Non mi assumo alcuna responsabilità per chi usa questo script.
L’archiviazione automatica può potenzialmente portare a perdita di dati se usata in modo scorretto.
Sempre:
- prova prima sulle copie
- tieni più backup
- verifica i tuoi archivi
Solo allora dovresti prendere in considerazione di eseguire qualcosa del genere sui dati veri.
Prossimo articolo
Dopo aver archiviato la maggior parte dei miei dati, ho creato anche un altro script che
scansiona automaticamente tutti i file RAR e ne verifica l’integrità.
Lo descriverò nel prossimo articolo 🙂.
