Otto ore per un backup: come un disco SMR, rdiff-backup e Hugo si frenavano a vicenda

Il mio PC di backup ultimamente girava per più di otto ore, anche se quasi nessun dato era cambiato. La pista portava a un disco rigido con le tegole, a uno strumento che scrive ogni file sul disco singolarmente e a un blog che riscrive 70.000 file a ogni build.

Fumetto: nel corridoio del data center, sulla scrivania, un disco rigido sudato con un piccolo tetto di tegole e una clessidra, sotto un mucchio di fogli sparsi; l'uomo, sorridendo, gli porge un pacco legato con lo spago con la scritta «TAR», e il disco sorride

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski

In breve: Il mio PC di backup ultimamente ha impiegato otto ore e 18 minuti per un’esecuzione, con dati quasi invariati. Non c’era una sola causa, ma tre che si rafforzavano: un disco rigido SMR, che crolla con molte piccole scritture; rdiff-backup, che costringe ogni file sul disco singolarmente; e il mio blog Hugo, che a ogni build riscrive tutti i suoi circa 70.000 file. Ora salvo il blog come un unico archivio tar.gz (38 secondi invece di fino a quattro ore), rdiff-backup gira con --no-fsync, e ciò che si può rigenerare resta fuori.

Indice

🐢 Il sintomo: otto ore per quasi niente

Il mio PC di backup è un vecchio computer che accendo quando è ora di fare il backup: preleva tutto e poi si spegne da solo. Salva quattro cose una dopo l’altra: Nextcloud, il blog, le cartelle condivise del NAS e la mia home sul computer di lavoro. Lo strumento per tutto: rdiff-backup. Mantiene uno specchio aggiornato e, per ogni file modificato, mette accanto un file «increment» con lo stato precedente; così si può recuperare qualsiasi versione passata.

Per molto tempo è stato veloce. Poi le statistiche erano queste:

EsecuzioneNextcloudBlogNASHomeTotale
12/1115 min0 min1 min39 min56 min
17/1155 min169 min6 min167 min6 h 37 min
19/114 min110 min186 min198 min8 h 18 min

Stessi dati, stesso hardware: a volte poco meno di un’ora, a volte più di otto. Nessuna esecuzione ha richiesto molto più spazio. Non era la quantità, era qualcos’altro.

🏠 Scoperta 1: il disco rigido ha un tetto di tegole

Primo sguardo all’hardware: il disco di backup è un Seagate Barracuda da 8 TB. Questo modello usa la tecnologia SMR (Shingled Magnetic Recording): le tracce si sovrappongono come tegole. Così sul piatto entrano più dati, ma c’è un inconveniente: chi modifica una traccia sovrascrive anche quella vicina che le sta per metà sopra; il disco deve quindi leggere e riscrivere intere zone (bande).

Per non farlo notare nell’uso quotidiano, il disco ha una piccola area buffer scritta in modo convenzionale. I nuovi dati finiscono prima lì, e il disco li sposta nelle bande a tegole nei momenti di calma. I file grandi in un pezzo solo non sono un problema. Molte piccole scritture, invece, riempiono presto il buffer, e allora le prestazioni in scrittura crollano da oltre 100 MB/s a una frazione, perché il disco riceve e riordina contemporaneamente.

Su un disco per film o foto non lo si nota mai. Su un backup fatto di centinaia di migliaia di piccoli file lo si nota moltissimo.

💾 Scoperta 2: rdiff-backup scrive ogni file singolarmente

Secondo sguardo: come scrive rdiff-backup. Per ogni file che crea o sostituisce chiama fsync, che obbliga il sistema operativo a scrivere subito il file fisicamente sul disco invece di raccoglierlo in memoria. L’intenzione è buona: se il computer si blocca a metà esecuzione, ogni file già salvato è davvero sul disco.

Su un disco SMR, però, è il caso peggiore: ogni file è una piccola scrittura sincrona. Nelle esecuzioni ho misurato circa 10–15 file al secondo. Con qualche centinaio di file modificati non importa. Con 200.000 sono quattro ore.

🔁 Scoperta 3: Hugo riscrive tutto a ogni build

E da dove arrivano 200.000 file modificati se cambio un solo articolo? Dal passaggio a Hugo. Da allora il mio blog è una raccolta di file statici: circa 150 articoli in 8 lingue, più pagine dei tag, categorie, paginazione, feed, indice di ricerca e immagini in più dimensioni, in tutto circa 70.000 file.

Hugo ricostruisce l’intero sito a ogni deploy e lo rimette a posto completamente, comprese le pagine che non sono cambiate affatto. Per rdiff-backup, dopo ogni deploy quasi ogni file è cambiato: nuova copia nello specchio più un file increment con lo stato precedente. A seconda di quanti deploy c’erano stati dall’ultima esecuzione, erano da 59.000 a 214.000 nuovi file per esecuzione. A 10–15 file al secondo: da 110 a 234 minuti solo per il blog.

Con WordPress non era un problema: tutto stava in un database e il backup era un unico dump.

🧩 Lo stesso schema in altri due punti

Una volta chiaro il principio, è emerso anche altrove:

  • NAS (186 minuti il 19/11): il giorno prima avevo riordinato le mie cartelle e spostato molti file. Per rdiff-backup un file spostato è un file cancellato più uno nuovo: due scritture per file. Un effetto una tantum; il 20/11 erano di nuovo 54 secondi.
  • Home (fino a 198 minuti): su circa 420.000 file, circa 360.000 sono cose che si possono rigenerare in qualsiasi momento: immagini dei container, cache, ambienti Python, node_modules, il sito compilato, file di lavoro del ripping dei CD. Cambiano di continuo e in caso di emergenza non valgono nulla.

🛠️ Cosa ho cambiato

1. Il blog viene salvato come un unico archivio. Invece di rispecchiare 70.000 singoli file con rdiff-backup, il computer sorgente impacchetta lo stato con tar, lo comprime con gzip -1 e lo invia al PC di backup come un unico flusso di dati. Lì arriva esattamente un file. È il caso ideale per qualsiasi disco, e ancor più per un disco SMR.

ssh sorgente "tar -C /storage --numeric-owner -cf - blog | gzip -1" > blog_2026-11-20_0814.tar.gz.part
tar -tzf blog_2026-11-20_0814.tar.gz.part | wc -l   # prima verificare, poi rinominare

Prima lo script controlla che l’ultimo backup sulla sorgente sia andato a buon fine; dopo, che l’archivio sia leggibile e contenga la home page. Solo allora riceve il nome definitivo. gzip -1 basta: le immagini sono già compresse, un livello più alto costa solo tempo.

Conservazione: tutti gli archivi degli ultimi 30 giorni, più il primo archivio di ogni mese per un anno. È meno fine della cronologia delle versioni di rdiff-backup, ma più che sufficiente per un blog il cui codice sorgente sta comunque in Git. La vecchia cronologia rdiff resta per il periodo precedente.

2. rdiff-backup senza fsync per ogni file. Per Nextcloud, NAS e home, rdiff-backup ora gira con --no-fsync. Alla fine dell’intera esecuzione c’è un unico sync che scrive tutto sul disco. Il rischio è contenuto: se il PC di backup si blocca a metà, quell’esecuzione è incompleta; ma succede anche con fsync, e rdiff-backup ripulisce da solo un’esecuzione interrotta all’avvio successivo (regress).

3. Ciò che si può rigenerare resta fuori. La home ha ora una lista di esclusioni: storage dei container, .cache, .venvs, node_modules, .npm, il sito compilato e le cartelle di lavoro. Tutto si ripristina con un comando.

📊 Il risultato

La prima esecuzione con tutte le modifiche, il 20/11:

Passoprima (19/11)dopo (20/11)
Nextcloud (810.000 file)4 min 26 s2 min 29 s
Blog110 min38 s (un archivio, 888 MB, 113.002 voci)
NAS186 min54 s
Home198 min101 min 22 s
Totale8 h 18 min1 h 45 min

Per la home la prima esecuzione è un caso particolare: rdiff-backup registra una volta come «cancellati» i file appena esclusi, cioè per l’ultima volta centinaia di migliaia di file increment. Dall’esecuzione successiva spariscono del tutto.

💡 Un SSD avrebbe risolto anche questo?

Me lo sono chiesto anch’io. Un SSD (o un disco CMR classico) sarebbe molto più veloce con tanti piccoli file, non c’è dubbio. Ma avrebbe solo attenuato il sintomo: 200.000 file increment per esecuzione per un sito che si può ricostruire da Git in qualsiasi momento sono uno spreco anche su un SSD. Prima ridurre il numero di file, poi pensare all’hardware. Passare a un disco CMR, o a Borg, che raggruppa i file piccoli in grandi blocchi, resta un’opzione per il futuro.

🤝 Com’è andata l’analisi

La ricerca del problema l’ho fatta con Claude Code: ho solo detto «il backup dura otto ore, vedi se puoi ottimizzare qualcosa» aggiungendo qualche idea (archivio compresso, più buffer in RAM, sostituire rdiff-backup, controllare il disco). Claude ha analizzato i tempi dai log delle ultime settimane, ha riconosciuto il modello di disco come SMR, ha contato i file increment per esecuzione e ha trovato il legame con il build di Hugo. Ha scritto gli script e, quando ho detto «rifacciamo da capo», ha interrotto il backup in corso e l’ha riavviato con la nuova versione.

🎯 Conclusione: non la quantità, il numero

  • La durata del backup dipende dal numero di file, non dai gigabyte. 888 MB in un pezzo: 38 secondi. Gli stessi dati come 200.000 file singoli: quattro ore.
  • I dischi SMR sono una cattiva scelta per backup fatti di tanti piccoli file. Guarda la scheda tecnica prima di comprare: «SMR» spesso è solo nelle note in piccolo.
  • I siti statici si salvano come archivio, non file per file. Il codice sorgente è comunque in Git.
  • Ciò che si può rigenerare non va nel backup. Cache e immagini dei container costano tempo e non aiutano in caso di emergenza.
  • Prima misurare, poi comprare. Un disco nuovo avrebbe solo reso il problema più piccolo.

📚 Articoli correlati:

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