rsync: esempi di sincronizzazione file e backup in Linux

rsync è lo strumento standard di Linux per copiare e sincronizzare i file: in locale, tra dischi diversi e tra server via SSH. La sua differenza principale rispetto a cp e scp è che trasferisce solo ciò che è cambiato, perciò risincronizzare una grande cartella richiede pochi secondi. Qui trovi esempi rsync per i compiti più comuni: copiare un progetto su un server, creare lo specchio di una cartella, usare le esclusioni, fare backup con snapshot ed eseguire tutto a orari fissi.

Sintassi e opzioni più importanti

La forma generale del comando:

rsync [opzioni] SORGENTE... DESTINAZIONE

Sorgente e destinazione possono essere percorsi locali oppure remoti nella forma utente@host:/percorso. Uno dei due lati deve essere necessariamente locale: rsync non copia direttamente tra due macchine remote.

In pratica nove casi su dieci bastano rsync -avh in locale e rsync -avzh in rete.

Lo slash finale nel percorso: la trappola principale

L'errore più comune di chi inizia riguarda lo slash finale della sorgente. Da esso dipende se si copia la cartella stessa oppure solo il suo contenuto.

# Copia la CARTELLA project dentro /backup → risultato /backup/project/...
rsync -av project /backup/

# Copia il CONTENUTO di project in /backup → i file finiscono direttamente in /backup/
rsync -av project/ /backup/

Da ricordare: lo slash finale della sorgente significa «il contenuto di questa cartella». Sulla destinazione lo slash non ha effetto. Se hai dubbi, aggiungi -n e controlla quali percorsi rsync intende creare.

Copia in locale

Copiare una cartella su un disco esterno con l'avanzamento:

rsync -avhP ~/photos/ /mnt/usb/photos/

Ripetere lo stesso comando non ricopia tutto da capo: rsync confronta dimensione e data di modifica dei file e trasferisce solo quelli nuovi o cambiati. In fondo l'output mostra quanti dati sono davvero partiti:

sending incremental file list
2026/10/IMG_2041.jpg
          4.12M 100%   38.40MB/s    0:00:00 (xfr#1, to-chk=0/1534)

sent 4.13M bytes  received 9.25K bytes  2.76M bytes/sec
total size is 6.82G  speedup is 1,648.21

Il valore speedup indica quante volte si è trasferito meno rispetto a una copia completa.

rsync via SSH: copia verso il server e ritorno

Per i percorsi remoti rsync usa SSH per impostazione predefinita, quindi non serve configurare nulla in più: basta che funzioni il normale accesso con ssh. È più comodo con le chiavi: così non viene chiesta la password e il comando può andare nel cron.

# Caricare il sito sul server
rsync -avz ./site/ deploy@203.0.113.10:/var/www/site/

# Scaricare i log dal server sul proprio computer
rsync -avz deploy@203.0.113.10:/var/log/nginx/ ./nginx-logs/

# SSH su porta non standard e con una chiave specifica
rsync -avz -e "ssh -p 2222 -i ~/.ssh/deploy_key" ./site/ deploy@203.0.113.10:/var/www/site/

rsync deve essere installato su entrambe le macchine: sul lato remoto viene avviato tramite SSH. Se manca, vedrai rsync: command not found — installa il pacchetto (sudo apt install rsync oppure sudo dnf install rsync).

Se l'host è definito in ~/.ssh/config con un alias, rsync lo riconosce: rsync -avz ./site/ prod:/var/www/site/.

Servono i privilegi root sul server

Quando i file di destinazione appartengono a root ma entri come utente normale, puoi avviare rsync remoto tramite sudo:

rsync -avz --rsync-path="sudo rsync" ./conf/ admin@server:/etc/myapp/

Affinché funzioni, sul server sudo deve eseguire rsync senza password (regola in sudoers), altrimenti il comando resta bloccato in attesa di un input.

Specchio di una cartella: --delete

Per impostazione predefinita rsync aggiunge e aggiorna i file, ma non elimina nulla. Perché la destinazione diventi una copia esatta della sorgente serve --delete:

rsync -avh --delete ~/projects/ /mnt/backup/projects/

È un'opzione potente e pericolosa. Un errore nel percorso (per esempio una sorgente vuota o uno slash dimenticato) cancellerà i dati della destinazione. Perciò la regola è una sola: ogni comando con --delete va eseguito prima con -n.

$ rsync -avhn --delete ~/projects/ /mnt/backup/projects/
sending incremental file list
deleting old-app/README.md
deleting old-app/
app/main.py

sent 1.20K bytes  received 64 bytes  2.53K bytes/sec
total size is 18.4M  speedup is 14,554.39 (DRY RUN)

Le righe deleting mostrano cosa verrà eliminato. Quando sei sicuro che sia tutto corretto, lancia il comando senza -n.

Varianti utili: --delete-after elimina i file dopo il trasferimento (la destinazione resta completa più a lungo), --backup --backup-dir=/mnt/backup/deleted-$(date +%F) non elimina ma sposta i file cancellati o sostituiti in una cartella a parte.

Esclusioni: --exclude e --include

Escludere file temporanei, dipendenze e segreti è una pratica comune nei deploy e nei backup.

# Più modelli
rsync -avz --exclude='.git/' --exclude='node_modules/' --exclude='*.log' ./app/ server:/srv/app/

# Modelli da un file
rsync -avz --exclude-from='.rsyncignore' ./app/ server:/srv/app/

Il file .rsyncignore è un semplice elenco di modelli, uno per riga:

.git/
node_modules/
*.log
.env
tmp/

Come funzionano i modelli:

• Un modello senza slash iniziale (*.log) corrisponde a qualsiasi profondità.
• Un modello con lo slash iniziale (/tmp/) è ancorato alla radice del trasferimento — esclude solo il tmp di primo livello.
• Lo slash finale (cache/) significa «solo cartelle».
• Le regole si verificano in ordine e vale la prima che corrisponde.

Dall'ultimo punto deriva il trucco per «copiare solo ciò che serve»: prima consenti, poi escludi il resto.

# Copiare solo i file .conf mantenendo la struttura delle cartelle
rsync -av --include='*/' --include='*.conf' --exclude='*' /etc/ ./etc-confs/

Qui --include='*/' serve perché rsync entri in tutte le sottocartelle. Aggiungi --prune-empty-dirs (-m) per non creare cartelle vuote.

Backup con rsync

Copia giornaliera semplice

Backup minimo della cartella home su un secondo disco:

rsync -aH --delete --exclude='.cache/' /home/alice/ /mnt/backup/alice/

Il limite di questo approccio è che si conserva una sola versione. Se un file viene danneggiato e il backup si sincronizza prima che qualcuno se ne accorga, la versione precedente è persa.

Snapshot incrementali con --link-dest

L'opzione --link-dest risolve il problema quasi senza costi di spazio. I file non modificati non vengono copiati, ma creati come hard link ai file dello snapshot precedente. Ogni snapshot appare come una copia completa, ma lo spazio occupato è solo quello delle modifiche.

#!/bin/bash
set -euo pipefail

SRC="/home/alice/"
DEST="/mnt/backup/snapshots"
TODAY="$(date +%F)"

mkdir -p "$DEST"
rsync -aH --delete \
  --exclude='.cache/' \
  --link-dest="$DEST/latest" \
  "$SRC" "$DEST/$TODAY"

ln -sfn "$DEST/$TODAY" "$DEST/latest"

Al primo avvio la cartella latest non esiste ancora: rsync mostra un avviso e crea una copia completa, ed è normale. Gli snapshot vecchi si eliminano con un normale rm -rf: i file a cui fanno riferimento altri snapshot non vengono persi.

Per eliminare gli snapshot più vecchi di 30 giorni:

find /mnt/backup/snapshots -maxdepth 1 -type d -name '20*' -mtime +30 -exec rm -rf {} +

Backup di un server su un'altra macchina

Conviene impostare la direzione «dal server di backup verso la macchina di lavoro»: è la macchina di backup a prelevare i dati, e il server di produzione non ha accesso alle copie. Se venisse compromesso, i backup resterebbero integri.

rsync -azH --delete -e "ssh -i /root/.ssh/backup_key" \
  backup@web01:/var/www/ /srv/backups/web01/www/

Attenzione: i database non si copiano così. I file di un DBMS in funzione non sono coerenti durante la copia. Prima crea un dump (mysqldump, pg_dump), poi lascia che rsync trasferisca il file del dump.

Esecuzione periodica con cron

Lo script di backup si aggiunge al cron con crontab -e:

# Ogni giorno alle 03:15, output nel log
15 3 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

Cosa controllare perché il backup da cron funzioni davvero:

• Nello script usa percorsi assoluti: cron ha un PATH minimo e una directory di lavoro diversa.
• La chiave SSH deve essere senza password e l'host deve già essere in known_hosts — altrimenti rsync si blocca in attesa di una conferma sull'autenticità della chiave.
• Lo script controlla il codice di uscita: rsync restituisce 0 in caso di successo, 23 se non tutti i file sono stati trasferiti, 24 se alcuni file sono scomparsi durante la copia.
• Per evitare l'avvio contemporaneo di due copie usa flock: flock -n /tmp/backup.lock /usr/local/bin/backup.sh.

Al posto del cron si può usare un timer systemd: scrive l'output nel journal e i risultati si consultano comodamente con journalctl.

Opzioni utili per trasferimenti grandi

Errori comuni e come risolverli

• Permission denied in scrittura — l'utente non ha i permessi sulla cartella di destinazione. Controlla il proprietario della cartella oppure usa --rsync-path="sudo rsync".
• I file vengono ricopiati ogni volta — la data di modifica non viene conservata. Verifica che ci sia -a o -t; su FAT/exFAT aggiungi --modify-window=2, perché questi file system memorizzano le date con una precisione di due secondi.
• Errori chown o chgrp durante la copia su chiavetta o cartella di rete — il file system non supporta i proprietari. Sostituisci -a con -rlt.
• Comparsa di una cartella annidata /backup/project/project — lo slash finale della sorgente è stato sbagliato.
• connection unexpectedly closed — problema di SSH oppure rsync non installato sul lato remoto. Verifica l'accesso con un normale ssh e la presenza di rsync sul server.

Conclusioni

Nel lavoro di ogni giorno bastano pochi comandi: rsync -avz src/ host:/dst/ per copiare via SSH, --delete insieme a una prova con -n per lo specchio, --exclude per ciò che non serve e --link-dest per i backup con snapshot. Fai attenzione allo slash finale della sorgente e rsync diventa il modo più affidabile per spostare file tra macchine. Sincronizzazione e backup sono trattati in pratica nel corso di Linux.