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

Illustrazione: un uomo con una maglietta No Backup, No Mercy che lavora al portatile in un homelab

🌐 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:

  1. estrarre l’archivio
  2. 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 🙂.

Alcuni testi e immagini di questo sito sono creati con l’aiuto dell’IA o generati dall’IA. Dettagli