IT

Linux e rete

Sincronizzare i file con rclone

Sincronizza i tuoi file con rclone verso uno storage S3 o un server SFTP: cifratura lato client, archivi, pianificazione systemd e test di ripristino.

7 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

I tuoi valori

Inseriscili una volta: i comandi della guida si aggiornano.

Questa guida ti spiega come usare rclone per inviare i file del tuo VPS o server dedicato verso uno storage compatibile S3 o un altro servizio, come un server SFTP. I dati saranno cifrati prima della partenza, la sincronizzazione sarà pianificata e verificherai di saperli recuperare.

Prerequisiti

  • Un server con Debian 12 o 13, oppure Ubuntu 22.04 o 24.04, con accesso sudo
  • Un bucket S3 con una chiave di accesso e una chiave segreta, oppure un server SFTP
  • Un orologio di sistema allineato: consulta la nostra guida Configurare NTP
  • Un posto fuori dal server in cui conservare la configurazione di rclone e le password

Non c'è alcuna porta in ingresso da aprire. Il server deve poter uscire verso la porta 443 per S3, oppure verso la porta SSH del server remoto per SFTP.

Installare rclone

Il progetto sconsiglia i pacchetti delle distribuzioni, spesso vecchi. Installa il pacchetto ufficiale. Al momento della stesura, la versione attuale è 1.76.0: consulta la pagina di download e adatta RCLONE_VERSION se necessario.

Terminale
RCLONE_VERSION="v1.76.0"
ARCH="$(dpkg --print-architecture)"
FILE="rclone-${RCLONE_VERSION}-linux-${ARCH}.deb"
cd /tmp
curl -fsSLO "https://downloads.rclone.org/${RCLONE_VERSION}/${FILE}"
curl -fsSLO "https://downloads.rclone.org/${RCLONE_VERSION}/SHA256SUMS"
sha256sum --check --ignore-missing SHA256SUMS
sudo apt install -y "./${FILE}"
rclone version

La verifica deve mostrare OK per il pacchetto. Un avviso su righe formattate male è normale, perché il file contiene anche la propria firma.

Configurare lo storage S3

Gli esempi usano l'Object Storage HostMyServers, compatibile S3, il cui endpoint pubblicato su quella pagina è https://s3.lyn.io.hostmyservers.net. Il bucket si chiama mes-sauvegardes: adatta questo nome.

  1. Crea il file di configurazione, leggibile solo da root:

    Terminale
    sudo install -d -m 700 /root/.config /root/.config/rclone
    sudo install -m 600 /dev/null /root/.config/rclone/rclone.conf
    sudo nano /root/.config/rclone/rclone.conf
  2. Aggiungi questo blocco:

    Configurazione
    [hms-s3]
    type = s3
    provider = Other
    access_key_id = TUA_CHIAVE_DI_ACCESSO
    secret_access_key = TUA_CHIAVE_SEGRETA
    endpoint = https://s3.lyn.io.hostmyservers.net
    acl = private

    Per un altro provider compatibile S3, cambia endpoint e aggiungi region = TUA_REGIONE se lo richiede.

  3. Testa l'accesso e crea il bucket se non esiste ancora:

    Terminale
    sudo rclone lsd hms-s3:
    sudo rclone mkdir hms-s3:mes-sauvegardes

Aggiungere la cifratura

Il tipo crypt cifra il contenuto, oltre ai nomi dei file e delle cartelle, prima dell'invio. Si usa come un livello sopra lo storage.

  1. Genera due segreti e crea lo storage cifrato hms-crypt:

    Terminale
    CRYPT_PASS="$(openssl rand -hex 32)"
    CRYPT_SALT="$(openssl rand -hex 32)"
    sudo rclone config create hms-crypt crypt remote=hms-s3:mes-sauvegardes/crypt filename_encryption=standard directory_name_encryption=true password="$CRYPT_PASS" password2="$CRYPT_SALT" --obscure
    printf 'password: %s\npassword2: %s\n' "$CRYPT_PASS" "$CRYPT_SALT"
    unset CRYPT_PASS CRYPT_SALT
  2. Copia i due valori mostrati nel tuo gestore di password, poi salva anche il file rclone.conf fuori dal server:

    Terminale
    sudo cat /root/.config/rclone/rclone.conf
  3. Verifica che i nomi siano davvero cifrati a distanza:

    Terminale
    echo "rclone test" | sudo tee /tmp/rclone-test.txt > /dev/null
    sudo rclone copy /tmp/rclone-test.txt hms-crypt:test
    sudo rclone ls hms-crypt:test
    sudo rclone ls hms-s3:mes-sauvegardes/crypt
    sudo rclone purge hms-crypt:test

    Il primo elenco mostra rclone-test.txt, il secondo un nome illeggibile.

Con la cifratura standard, limita i nomi dei file a circa 143 caratteri per evitare qualsiasi problema.

Scegliere il comando giusto

Comando Effetto Rischio
rclone copy Copia i file nuovi o modificati, senza eliminare nulla Basso
rclone sync Rende la destinazione identica alla sorgente, eliminazioni comprese Alto
rclone move Copia poi elimina dalla sorgente Alto
rclone check Confronta sorgente e destinazione Nessuno
rclone cryptcheck Confronta file locali con uno storage cifrato Nessuno

Lanciare una prima sincronizzazione

Gli esempi sincronizzano /srv/data. Sostituisci questo percorso con la tua cartella.

  1. Crea l'elenco delle esclusioni:

    Terminale
    sudo nano /etc/rclone-sync.filter
    Testo
    - *.tmp
    - .cache/**
    - node_modules/**
  2. Simula sempre prima di sincronizzare:

    Terminale
    sudo rclone sync /srv/data hms-crypt:current --filter-from /etc/rclone-sync.filter --dry-run --verbose
  3. Se l'elenco ti va bene, lancia l'invio:

    Terminale
    sudo rclone sync /srv/data hms-crypt:current --filter-from /etc/rclone-sync.filter --progress
  4. Verifica il risultato:

    Terminale
    sudo rclone cryptcheck /srv/data hms-crypt:current --one-way --filter-from /etc/rclone-sync.filter

Testare il ripristino

Fai questo test adesso, poi regolarmente. Una copia remota è utile solo se sai rileggerla e decifrarla.

  1. Ripristina tutto in una cartella temporanea e confronta:

    Terminale
    sudo rm -rf /var/tmp/rclone-restore
    sudo rclone copy hms-crypt:current /var/tmp/rclone-restore --progress
    sudo diff -r /srv/data /var/tmp/rclone-restore | head -n 20

    Devono comparire solo i file esclusi o modificati dopo la sincronizzazione.

  2. Esegui anche il ripristino di un solo file, adattandone il percorso:

    Terminale
    sudo rclone copyto hms-crypt:current/dossier/fichier.txt /var/tmp/fichier-restaure.txt
  3. Testa la ripartenza su un'altra macchina: installa rclone, rimetti rclone.conf dalla tua copia esterna in /root/.config/rclone/, poi lancia lo stesso comando rclone copy. Questo test dimostra che la tua copia della configurazione è completa.

  4. Cancella poi i file di test:

    Terminale
    sudo rm -rf /var/tmp/rclone-restore /var/tmp/fichier-restaure.txt

Pianificare la sincronizzazione

Lo script seguente sposta ogni file sostituito o eliminato in una cartella di archivi datata, e mantiene gli ultimi 30.

  1. Crea lo script:

    Terminale
    sudo nano /usr/local/sbin/rclone-sync.sh
    Terminale
    #!/bin/bash
    set -euo pipefail
    
    SOURCE="/srv/data"
    REMOTE="hms-crypt:"
    KEEP_ARCHIVES=30
    STAMP="$(date +%F_%H%M%S)"
    
    rclone sync "$SOURCE" "${REMOTE}current" \
      --backup-dir "${REMOTE}archive/$STAMP" \
      --filter-from /etc/rclone-sync.filter \
      --max-delete 1000 \
      --fast-list \
      --log-level INFO \
      --stats 5m \
      --stats-one-line
    
    { rclone lsf --dirs-only "${REMOTE}archive" 2>/dev/null || true; } |
      sort | head -n -"$KEEP_ARCHIVES" |
      while IFS= read -r dir; do
        rclone purge "${REMOTE}archive/${dir%/}"
      done

    --max-delete 1000 interrompe l'operazione se più di 1 000 file dovessero sparire. Questo limite protegge i tuoi dati se la cartella sorgente è vuota per errore, ad esempio quando un disco non è montato. Adattalo al tuo volume.

  2. Crea il servizio:

    Terminale
    sudo chmod 700 /usr/local/sbin/rclone-sync.sh
    sudo nano /etc/systemd/system/rclone-sync.service
    Configurazione
    [Unit]
    Description=rclone sync
    Wants=network-online.target
    After=network-online.target
    
    [Service]
    Type=oneshot
    Environment=HOME=/root
    Nice=10
    IOSchedulingClass=idle
    ExecStart=/usr/local/sbin/rclone-sync.sh
  3. Crea il timer:

    Terminale
    sudo nano /etc/systemd/system/rclone-sync.timer
    Configurazione
    [Unit]
    Description=Daily rclone sync
    
    [Timer]
    OnCalendar=*-*-* 04:15:00
    RandomizedDelaySec=20min
    Persistent=true
    
    [Install]
    WantedBy=timers.target
  4. Attivalo e lancia un primo passaggio:

    Terminale
    sudo systemctl daemon-reload
    sudo systemctl enable --now rclone-sync.timer
    sudo systemctl start rclone-sync.service
    sudo journalctl -u rclone-sync.service -n 30 --no-pager

Per recuperare una vecchia versione, elenca gli archivi poi copia il file desiderato:

Terminale
sudo rclone lsf hms-crypt:archive
sudo rclone copyto hms-crypt:archive/2026-11-18_041500/dossier/fichier.txt /var/tmp/ancienne-version.txt

Il versioning annunciato sulla pagina dell'offerta HMS può completare questo meccanismo. Le versioni conservate contano allora nel volume fatturato.

Usare un altro servizio: esempio SFTP

rclone supporta molti servizi, elencati nella sua documentazione. Ecco come puntare a un altro server tramite SFTP, qui backup.tuo-dominio.com.

  1. Crea una chiave dedicata, installala sul server remoto e registra la sua impronta:

    Terminale
    sudo install -d -m 700 /root/.ssh
    sudo ssh-keygen -t ed25519 -N '' -C 'rclone' -f /root/.ssh/rclone_sftp
    sudo ssh-copy-id -i /root/.ssh/rclone_sftp.pub TUO_USER@backup.tuo-dominio.com
    sudo ssh -i /root/.ssh/rclone_sftp TUO_USER@backup.tuo-dominio.com true

    Alla prima connessione, confronta l'impronta mostrata con quella del server remoto prima di accettare.

  2. Aggiungi questo blocco a /root/.config/rclone/rclone.conf:

    Configurazione
    [backup-sftp]
    type = sftp
    host = backup.tuo-dominio.com
    user = TUO_USER
    port = 22
    key_file = /root/.ssh/rclone_sftp
    known_hosts_file = /root/.ssh/known_hosts
  3. Testa l'accesso:

    Terminale
    sudo rclone mkdir backup-sftp:rclone
    sudo rclone lsd backup-sftp:
  4. Per cifrare anche questi dati, crea un secondo storage crypt:

    Terminale
    CRYPT_PASS="$(openssl rand -hex 32)"
    CRYPT_SALT="$(openssl rand -hex 32)"
    sudo rclone config create sftp-crypt crypt remote=backup-sftp:rclone/crypt password="$CRYPT_PASS" password2="$CRYPT_SALT" --obscure
    printf 'password: %s\npassword2: %s\n' "$CRYPT_PASS" "$CRYPT_SALT"
    unset CRYPT_PASS CRYPT_SALT

    Conserva questi valori fuori dal server, poi indica REMOTE="sftp-crypt:" nello script per usare questa destinazione.

Aggiornare rclone

Terminale
rclone selfupdate --check
sudo rclone selfupdate --package deb
rclone version

Dopo un aggiornamento, lancia la sincronizzazione a mano e consulta il suo log.

In caso di problemi

didn't find section in config file

Il nome prima dei due punti non corrisponde ad alcun blocco della configurazione, oppure rclone legge un altro file. Con sudo, verifica:

Terminale
sudo rclone config file
sudo rclone listremotes

SignatureDoesNotMatch, InvalidAccessKeyId o AccessDenied

Controlla le due chiavi e l'endpoint mostrato per il tuo servizio. Se l'errore menziona una regione, aggiungi region con il valore fornito dal tuo provider di storage, oppure contatta il supporto dalla tua area clienti.

RequestTimeTooSkewed

L'orologio del server è sfasato. Verificalo con timedatectl, poi segui la nostra guida Configurare NTP.

NoSuchBucket o directory not found

Il bucket o il percorso non esiste. Verifica il suo nome con sudo rclone lsd hms-s3:. Per una cartella sorgente, controlla che esista davvero sul server.

failed to authenticate decrypted block - bad password?

La password crypt non corrisponde ai dati, oppure il file remoto è danneggiato. Ripristina rclone.conf dalla tua copia esterna, senza ricreare lo storage cifrato con nuovi segreti.

--max-delete threshold reached

Il numero di eliminazioni supera il tuo limite, e l'operazione si ferma. Verifica prima che la sorgente sia completa, poi controlla con --dry-run. Alza il limite solo se queste eliminazioni sono realmente volute.

file name too long

Il nome cifrato supera il limite dello storage. Accorcia i nomi interessati, puntando a 143 caratteri al massimo.

Il servizio fallisce senza un messaggio chiaro

Aumenta il livello di dettaglio lanciando lo script a mano con --log-level DEBUG aggiunto al comando rclone sync, poi consulta:

Terminale
sudo systemctl status rclone-sync.service --no-pager
sudo journalctl -u rclone-sync.service -n 100 --no-pager

Riferimenti