Come sincronizzare file tra due VPS: guida pratica con esempi

Sincronizzare file tra due VPS è una delle operazioni più comuni in ambito sysadmin: migrazioni, replica di contenuti, backup incrementali, distribuzione di file statici, allineamento di directory applicative. La scelta dello strumento giusto dipende da un punto semplice: devi copiare una volta sola, mantenere due server allineati nel tempo, oppure fare una sincronizzazione quasi in tempo reale?

In pratica, la soluzione più solida per la maggior parte dei casi è rsync via SSH: è veloce, affidabile, incrementale e permette controllo fine su permessi, esclusioni e test prima della copia definitiva. Se invece servono scenari più strutturati, esistono alternative come Syncthing, lsyncd o meccanismi di replica nativi del servizio che stai usando.

Questa guida ti porta dal caso più semplice a quello più robusto, con esempi concreti e controlli di verifica. L’obiettivo non è “copiare e sperare”, ma costruire una procedura ripetibile e sicura.

Quando usare rsync, quando no

Usa rsync se devi:

• trasferire file tra due VPS in modo manuale o pianificato;
• sincronizzare siti web, directory di upload, backup o asset statici;
• fare copie incrementali risparmiando banda;
• verificare prima cosa cambierà con una simulazione.

Valuta altro se devi:

• replicare file continuamente tra più nodi con latenza bassa;
• sincronizzare bidirezionalmente cartelle usate da più utenti;
• gestire conflitti in modo automatico;
• replicare database: per quelli serve un sistema dedicato, non rsync.

Regola pratica: rsync è perfetto per file e directory; non sostituisce la replica applicativa o database.

Prerequisiti minimi

Prima di iniziare, verifica questi punti:

• accesso SSH a entrambe le VPS;
• utente con permessi sufficienti sulla sorgente e sulla destinazione;
• spazio disco disponibile sul server di destinazione;
• porte e firewall aperti per SSH, di solito la 22 o una porta personalizzata;
• backup recente, se stai sovrascrivendo dati già presenti.

Se usi ambienti comuni come Ubuntu, Debian, AlmaLinux o Rocky, rsync e SSH sono normalmente già disponibili o installabili con pochi comandi.

Scenario base: sincronizzazione manuale con rsync

Il caso più classico è questo: hai una cartella su VPS A e vuoi sincronizzarla su VPS B. Il comando base è il seguente:

rsync -avz --progress -e ssh /percorso/sorgente/ utente@IP_DESTINAZIONE:/percorso/destinazione/

Significato delle opzioni principali:

• -a: modalità archivio, preserva permessi, timestamp e struttura;
• -v: output dettagliato;
• -z: comprime durante il trasferimento;
• --progress: mostra l’avanzamento;
• -e ssh: usa SSH come trasporto sicuro.

Esempio reale:

rsync -avz --progress -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

Se la directory di destinazione esiste già, rsync aggiornerà solo i file modificati. Se non esiste, la creerà in molti casi, purché il percorso padre sia valido e scrivibile.

Verifica prima di copiare davvero

Il controllo più utile è la simulazione. Ti dice cosa verrebbe copiato senza fare modifiche:

rsync -avzn --delete -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

Qui -n significa dry-run. È la prova da fare sempre prima di un sync importante, soprattutto se usi --delete. L’esito atteso è un elenco dei file che verrebbero trasferiti o rimossi, senza alterare nulla.

Se il risultato ti convince, togli -n e ripeti il comando reale.

Sincronizzare mantenendo la destinazione identica alla sorgente

Se vuoi che la destinazione rispecchi esattamente la sorgente, puoi usare --delete. È potente, ma va usato con attenzione, perché elimina dalla destinazione i file che non esistono più nella sorgente.

rsync -avz --delete --progress -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

Questo è il caso tipico per un sito web statico, una directory di deploy o un mirror controllato. Prima di eseguirlo in produzione, fai sempre un dry-run.

Se non sei sicuro, non usare subito --delete. Prima verifica la lista dei file con -n.

Escludere file e cartelle

Spesso non vuoi sincronizzare tutto. Ad esempio, puoi escludere cache, log, file temporanei o directory generate dall’applicazione.

rsync -avz --progress --exclude='cache/' --exclude='logs/' -e ssh /var/www/app/ root@192.0.2.10:/var/www/app/

Per elenchi più lunghi conviene usare un file di esclusione:

rsync -avz --progress --exclude-from=/root/excludes.txt -e ssh /var/www/app/ root@192.0.2.10:/var/www/app/

Nel file /root/excludes.txt puoi inserire, una riga per volta:

cache/

logs/

tmp/

Questa soluzione è più ordinata e facile da mantenere nel tempo.

Sincronizzazione con chiavi SSH, senza password

Per automatizzare il processo, conviene usare una chiave SSH. Su VPS sorgente:

ssh-keygen -t ed25519

Premi invio per accettare il percorso predefinito. Poi copia la chiave pubblica sulla VPS di destinazione:

ssh-copy-id root@192.0.2.10

Dopo il primo accesso, verifica che l’autenticazione senza password funzioni:

ssh root@192.0.2.10

Se entri senza chiedere password, rsync potrà essere automatizzato in script e cron. Questo è il metodo più pratico per sincronizzazioni ricorrenti.

Sincronizzazione automatica con cron

Se devi ripetere l’operazione ogni notte o ogni ora, puoi usare cron sulla VPS sorgente. Esempio di script:

#!/bin/bash
rsync -avz --delete -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

Salvalo ad esempio in /usr/local/bin/sync-web.sh, rendilo eseguibile e poi pianificalo:

chmod +x /usr/local/bin/sync-web.sh

crontab -e

Aggiungi una riga come questa:

0 2 * * * /usr/local/bin/sync-web.sh > /var/log/sync-web.log 2>&1

Questo avvia la sincronizzazione ogni notte alle 02:00 e salva il log. Dopo il primo run, controlla il file di log per verificare che non ci siano errori di permessi o connessione.

Trasferire solo file nuovi o modificati

Rsync lavora già in modo incrementale, ma puoi raffinare il comportamento in base al caso. Se vuoi copiare solo i file più recenti, puoi usare opzioni come --update per evitare di sovrascrivere file più nuovi sulla destinazione:

rsync -avz --update -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

Questa opzione è utile quando la destinazione può ricevere modifiche manuali o automatiche che non vuoi perdere. Attenzione però: in ambienti standardizzati, di solito è meglio mantenere una sola sorgente di verità.

Preservare permessi, owner e gruppi

Con -a rsync preserva gran parte dei metadati. Tuttavia, se copi tra sistemi diversi o con utenti differenti, potrebbero emergere limiti legati a UID, GID o politiche di sicurezza.

Se devi preservare proprietà e hai i permessi adeguati, il comando standard resta questo:

rsync -avz -e ssh /data/ root@192.0.2.10:/data/

Se invece vuoi applicare un owner specifico sulla destinazione, valuta con attenzione l’uso di --chown solo in contesti compatibili e dopo test preliminari. In molti casi è preferibile correggere i permessi con un passaggio separato e controllato.

Sincronizzare tramite porta SSH diversa

Se la VPS usa SSH su una porta non standard, puoi indicarla così:

rsync -avz -e 'ssh -p 2222' /var/www/html/ root@192.0.2.10:/var/www/html/

Questo è utile quando il server è hardenizzato o quando la porta 22 è stata spostata per ridurre il rumore degli attacchi automatici. Verifica sempre che il firewall consenta la porta scelta.

Controlli di integrità dopo la sincronizzazione

La copia riuscita non basta: devi verificare che i file siano davvero allineati. I controlli minimi sono questi:

• confronto dimensione e numero file;
• verifica di accesso ai contenuti dal server di destinazione;
• controllo dei log di rsync;
• se serve, confronto con checksum su campioni critici.

Per un controllo rapido, puoi rieseguire un dry-run: se rsync non mostra differenze, la sincronizzazione è coerente.

rsync -avzn -e ssh /var/www/html/ root@192.0.2.10:/var/www/html/

L’esito atteso è nessun file elencato, o solo differenze attese e giustificate.

Alternative a rsync

Ci sono casi in cui rsync non è la scelta migliore. Ecco le alternative più utili:

• Syncthing: sincronizzazione continua e bidirezionale, utile per cartelle condivise;
• lsyncd: monitora eventi del filesystem e lancia rsync automaticamente;
• scp: semplice, ma meno efficiente e senza vero delta transfer;
• tar + ssh: valido per trasferimenti singoli e archiviazione;
• replica nativa: per database, mail server o storage distribuito.

In ambito hosting, rsync resta spesso il miglior compromesso tra semplicità, controllo e affidabilità.

lsyncd: sincronizzazione quasi in tempo reale

Se vuoi aggiornare una VPS di destinazione ogni volta che cambia un file nella sorgente, lsyncd è una scelta interessante. Funziona monitorando gli eventi del filesystem e lanciando rsync in automatico.

È adatto per directory con molte modifiche ma non per scenari in cui servono conflitti bidirezionali complessi. La configurazione richiede più attenzione rispetto a un singolo comando rsync, ma il risultato è molto comodo per deploy e mirror di contenuti.

Syncthing: quando vuoi una replica più “desktop-like”

Syncthing può essere utile se vuoi sincronizzare cartelle tra due VPS in modo continuo, con interfaccia web e gestione delle coppie di dispositivi. È più vicino a un sistema di sincronizzazione permanente che a un tool da shell.

Va bene per alcuni usi operativi, ma in hosting puro spesso preferisco rsync perché è più lineare, più facile da mettere sotto script e più prevedibile nei controlli. Syncthing ha senso quando vuoi un flusso sempre attivo e accetti la sua logica di rete e pairing.

Errori comuni e come leggerli

Alcuni errori ricorrono spesso:

• Permission denied: l’utente non ha permessi su sorgente o destinazione;
• Connection refused: SSH non ascolta sulla porta indicata o firewall blocca;
• No such file or directory: percorso errato o mount non presente;
• rsync: change_dir: il path sorgente o remoto non è raggiungibile;
• vanished file: il file è cambiato mentre rsync era in esecuzione.

Quando compare un errore, il primo passo è sempre distinguere tra problema di rete, autorizzazione e percorso. Solo dopo si corregge il comando.

Procedura consigliata in produzione

Se devi sincronizzare file tra due VPS in produzione, la sequenza più sicura è questa:

1. fai un backup della destinazione o almeno dei dati critici;
2. esegui un dry-run con -n e, se usi --delete, controlla bene l’elenco;
3. lancia la sincronizzazione reale in una finestra di bassa attività;
4. controlla log, permessi e accesso al sito o servizio;
5. ripeti un dry-run finale per confermare che non restino differenze inattese.

Questa sequenza riduce molto il rischio di perdere file o sovrascrivere contenuti sbagliati.

Esempio completo per un sito web

Scenario: vuoi allineare la directory di un sito da VPS A a VPS B, escludendo cache e log.

rsync -avz --delete --exclude='cache/' --exclude='logs/' --progress -e ssh /var/www/site/ root@192.0.2.10:/var/www/site/

Prima prova:

rsync -avzn --delete --exclude='cache/' --exclude='logs/' -e ssh /var/www/site/ root@192.0.2.10:/var/www/site/

Se la simulazione mostra solo i cambiamenti previsti, esegui il comando reale. Dopo il trasferimento, verifica il sito dal browser e controlla i log del web server o dell’applicazione.

Rollback pratico

Il rollback più semplice è avere un backup o una snapshot prima della sincronizzazione. Se qualcosa va storto, puoi ripristinare la destinazione dalla copia precedente. Per questo motivo, prima di usare --delete o una sincronizzazione massiva, conviene salvare almeno i dati critici della VPS di destinazione.

Se non hai snapshot, il rollback è più difficile: puoi solo ripristinare manualmente i file mancanti dalla sorgente o da un backup separato. Per questo la fase di verifica è molto più importante della fase di copia.

Conclusione operativa

Per la maggior parte dei casi, la risposta giusta è semplice: rsync via SSH, prima in dry-run, poi in reale, con esclusioni mirate e controllo finale. È il metodo più pratico per sincronizzare file tra due VPS senza introdurre complessità inutile. Quando serve automazione continua, puoi passare a cron, lsyncd o Syncthing, ma la logica di partenza resta la stessa: verifica prima, copia dopo, controlla sempre.

Se lavori in produzione, tratta ogni sincronizzazione come una piccola migrazione: backup, test, esecuzione, verifica. È un approccio semplice, ma è quello che riduce davvero gli imprevisti.