IT

Linux e rete

Backup incrementale con rsync e cron

Fai il backup di un server Linux su un altro con rsync e cron: chiave SSH dedicata e ristretta, snapshot con hard link, rotazione e test di ripristino.

8 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

Questa guida ti spiega come fare ogni notte il backup di un server su un secondo server con rsync e cron. Ogni backup appare come una copia completa e datata, ma i file invariati non vengono memorizzati una seconda volta: sono collegati al backup precedente tramite hard link.

Il server di cui fai il backup usa una chiave SSH dedicata, limitata alla scrittura in una sola cartella. Anche se questo server viene compromesso, questa chiave non permette né di aprire una shell sul server di backup, né di rileggere o eliminare i vecchi backup tramite rsync.

Prerequisiti

  • Due server con Debian 12 o 13, oppure Ubuntu 22.04 o 24.04, con accesso sudo
  • Il server sorgente, di cui fare il backup, chiamato web01 in questa guida
  • Il server di backup, con spazio su disco sufficiente, idealmente in un'altra sede
  • Un file system che supporti gli attributi estesi sul server di backup, come ext4 o XFS

Sostituisci IP_SERVER_BACKUP e IP_SERVER_SORGENTE con gli indirizzi dei tuoi server.

Porta da aprire

Solo il server di backup riceve una connessione: la porta 22/tcp, o la tua porta SSH, deve essere raggiungibile dall'indirizzo del server sorgente. Con UFW, sul server di backup:

Terminale
sudo ufw allow from IP_SERVER_SORGENTE to any port 22 proto tcp

Mantieni la regola che ti permette di amministrare tu stesso questo server. La nostra guida Mettere in sicurezza il tuo server descrive in dettaglio la configurazione di SSH.

Preparare il server di backup

  1. Installa i pacchetti. python3 è necessario allo script rrsync, fornito con rsync:

    Terminale
    sudo apt update
    sudo apt install -y rsync python3 cron
  2. Crea un account dedicato, senza password utilizzabile, e la cartella di destinazione:

    Terminale
    sudo useradd --create-home --home-dir /srv/rsyncbackup --shell /bin/sh rsyncbackup
    sudo install -d -o rsyncbackup -g rsyncbackup -m 700 /srv/rsyncbackup/.ssh /srv/rsyncbackup/web01

Preparare il server sorgente

  1. Installa i pacchetti:

    Terminale
    sudo apt update
    sudo apt install -y rsync cron openssh-client
  2. Crea una chiave riservata al backup. Non ha passphrase, perché cron deve poterla usare da solo: per questo sarà fortemente ristretta al passaggio successivo.

    Terminale
    sudo install -d -m 700 /root/.ssh
    sudo ssh-keygen -t ed25519 -N '' -C 'backup-rsync@web01' -f /root/.ssh/backup_rsync
    sudo cat /root/.ssh/backup_rsync.pub

Restringere la chiave sul server di backup

  1. Apri il file delle chiavi autorizzate:

    Terminale
    sudo nano /srv/rsyncbackup/.ssh/authorized_keys
  2. Aggiungi una sola riga, con la tua chiave pubblica alla fine:

    Testo
    from="IP_SERVER_SORGENTE",restrict,command="/usr/bin/rrsync -wo -no-del /srv/rsyncbackup/web01" ssh-ed25519 AAAA...tua_chiave_pubblica backup-rsync@web01
    Elemento Ruolo
    from= Accetta questa chiave solo dal server sorgente
    restrict Disattiva il terminale e i reindirizzamenti SSH
    command= Impone rrsync al posto di qualsiasi altro comando
    -wo Autorizza la sola scrittura, senza rilettura
    -no-del Rifiuta le opzioni di eliminazione di rsync
  3. Applica i permessi:

    Terminale
    sudo chown rsyncbackup:rsyncbackup /srv/rsyncbackup/.ssh/authorized_keys
    sudo chmod 600 /srv/rsyncbackup/.ssh/authorized_keys
  4. Mostra l'impronta del server per confrontarla al passaggio successivo:

    Terminale
    sudo ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub

Verificare la connessione

Sul server sorgente, registra la chiave del server di backup, poi confronta la sua impronta con la precedente:

Terminale
ssh-keyscan -t ed25519 IP_SERVER_BACKUP | sudo tee -a /root/.ssh/known_hosts
sudo ssh-keygen -lf /root/.ssh/known_hosts

Se le impronte sono diverse, elimina la riga aggiunta e cerca la causa prima di continuare. Testa poi la chiave:

Terminale
sudo ssh -i /root/.ssh/backup_rsync -o IdentitiesOnly=yes rsyncbackup@IP_SERVER_BACKUP

La risposta attesa è un errore di rrsync che contiene Not invoked via sshd. Dimostra che la chiave è accettata e che non dà una shell.

Creare lo script di backup

Sul server sorgente:

  1. Crea l'elenco delle esclusioni:

    Terminale
    sudo nano /etc/backup-rsync.exclude
    Testo
    /root/.ssh/backup_rsync*
    /root/.ssh/restore_rsync*
    /root/.cache/
    /home/*/.cache/
    /var/www/*/cache/
    *.tmp
  2. Crea lo script, indicando l'indirizzo del server di backup e le cartelle da copiare:

    Terminale
    sudo nano /usr/local/sbin/backup-rsync.sh
    Terminale
    #!/bin/bash
    set -uo pipefail
    
    BACKUP_HOST="IP_SERVER_BACKUP"
    BACKUP_USER="rsyncbackup"
    SSH_PORT=22
    SSH_KEY="/root/.ssh/backup_rsync"
    SOURCES=(/etc /home /root /var/www /var/backups)
    EXCLUDES="/etc/backup-rsync.exclude"
    STATE_DIR="/var/lib/backup-rsync"
    SNAPSHOT="$(date +%Y-%m-%d_%H%M%S)"
    
    exec 9>/run/lock/backup-rsync.lock
    if ! flock -n 9; then
      echo "$(date -Is) backup already running"
      exit 0
    fi
    
    mkdir -p "$STATE_DIR"
    EXISTING=()
    for path in "${SOURCES[@]}"; do
      [ -e "$path" ] && EXISTING+=("$path")
    done
    
    SSH_CMD="ssh -i $SSH_KEY -p $SSH_PORT -o BatchMode=yes -o IdentitiesOnly=yes -o StrictHostKeyChecking=yes -o ConnectTimeout=20"
    OPTIONS=(-aHAX --numeric-ids --relative --timeout=600 --stats
      --exclude-from="$EXCLUDES" -M--fake-super -e "$SSH_CMD")
    
    if [ -s "$STATE_DIR/last" ]; then
      OPTIONS+=("--link-dest=/$(cat "$STATE_DIR/last")")
    fi
    
    echo "$(date -Is) starting $SNAPSHOT"
    rsync "${OPTIONS[@]}" "${EXISTING[@]}" "$BACKUP_USER@$BACKUP_HOST:$SNAPSHOT/"
    status=$?
    
    # Il codice 24 segnala file scomparsi durante la copia.
    if [ "$status" -ne 0 ] && [ "$status" -ne 24 ]; then
      echo "$(date -Is) failed with rsync code $status"
      exit "$status"
    fi
    
    MARKER="$(mktemp)"
    rsync -e "$SSH_CMD" "$MARKER" "$BACKUP_USER@$BACKUP_HOST:$SNAPSHOT/.backup-complete"
    status=$?
    rm -f "$MARKER"
    if [ "$status" -ne 0 ]; then
      echo "$(date -Is) could not write completion marker, rsync code $status"
      exit "$status"
    fi
    
    echo "$SNAPSHOT" > "$STATE_DIR/last"
    echo "$(date -Is) finished $SNAPSHOT"
  3. Rendilo eseguibile e lancia il primo backup. Copia tutto e può richiedere tempo:

    Terminale
    sudo chmod 700 /usr/local/sbin/backup-rsync.sh
    sudo /usr/local/sbin/backup-rsync.sh
  4. Attendi un minuto, poi rilancialo per creare un secondo snapshot:

    Terminale
    sudo /usr/local/sbin/backup-rsync.sh
Opzione Ruolo
-a Conserva l'albero delle cartelle, le date, i permessi e i link simbolici
-H, -A, -X Conservano gli hard link, le ACL e gli attributi estesi
--numeric-ids Conserva gli identificatori numerici di utente e gruppo
--relative Riproduce i percorsi completi nello snapshot
--link-dest Collega i file invariati allo snapshot precedente
-M--fake-super Registra proprietari e permessi negli attributi estesi, senza essere root sulla destinazione

Verificare gli snapshot

Sul server di backup:

Terminale
sudo ls -la /srv/rsyncbackup/web01
sudo sh -c 'du -sh /srv/rsyncbackup/web01/*'
sudo sh -c 'stat -c "%h %n" /srv/rsyncbackup/web01/*/etc/hostname'

du conta ogni file condiviso una sola volta: il secondo snapshot deve quindi apparire molto più piccolo del primo. stat deve mostrare un numero di link di almeno 2 per un file invariato. Ogni snapshot completato contiene un file .backup-complete.

Pianificare con cron

Sul server sorgente:

  1. Crea l'attività pianificata:

    Terminale
    sudo nano /etc/cron.d/backup-rsync
    Testo
    SHELL=/bin/bash
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    15 3 * * * root /usr/local/sbin/backup-rsync.sh >> /var/log/backup-rsync.log 2>&1

    Questo file deve appartenere a root e terminare con un ritorno a capo.

  2. Limita la dimensione del log:

    Terminale
    sudo nano /etc/logrotate.d/backup-rsync
    Testo
    /var/log/backup-rsync.log {
        weekly
        rotate 8
        compress
        missingok
        notifempty
    }
  3. Verifica che cron sia attivo, poi controlla il log il giorno dopo:

    Terminale
    sudo systemctl is-active cron
    sudo tail -n 30 /var/log/backup-rsync.log
    sudo cat /var/lib/backup-rsync/last

Eliminare i vecchi snapshot

La rotazione viene eseguita sul server di backup. Il server sorgente non ha quindi alcun modo di cancellare lo storico.

  1. Crea lo script:

    Terminale
    sudo nano /usr/local/bin/backup-rsync-prune
    Terminale
    #!/bin/bash
    set -euo pipefail
    
    ROOT="/srv/rsyncbackup/$1"
    KEEP="${2:-14}"
    cd "$ROOT"
    
    mapfile -t COMPLETE < <(find . -mindepth 2 -maxdepth 2 -type f -name .backup-complete -printf '%h\n' | sed 's|^\./||' | sort)
    COUNT="${#COMPLETE[@]}"
    [ "$COUNT" -gt "$KEEP" ] || exit 0
    
    OLDEST_KEPT="${COMPLETE[COUNT-KEEP]}"
    for dir in 20*/; do
      snapshot="${dir%/}"
      if [[ "$snapshot" < "$OLDEST_KEPT" ]]; then
        rm -rf -- "${ROOT:?}/$snapshot"
      fi
    done

    Mantiene gli ultimi 14 snapshot completati e rimuove tutto ciò che è più vecchio, compresi gli snapshot interrotti. Eliminare uno snapshot non rimuove i file ancora usati da quelli successivi.

  2. Pianificalo:

    Terminale
    sudo chmod 755 /usr/local/bin/backup-rsync-prune
    echo '45 5 * * * rsyncbackup /usr/local/bin/backup-rsync-prune web01 14' | sudo tee /etc/cron.d/backup-rsync-prune
  3. Per essere avvisato di un arresto dei backup, monitora questo controllo, che fallisce se nessuno snapshot è stato completato nelle ultime 26 ore:

    Terminale
    sudo find /srv/rsyncbackup/web01 -mindepth 2 -maxdepth 2 -name .backup-complete -mmin -1560 | grep -q . && echo "OK" || echo "NO RECENT BACKUP"

Testare il ripristino

Fai questo test subito, poi regolarmente. Poiché la chiave di backup non può leggere i dati, crea una seconda chiave, in sola lettura, riservata al ripristino.

  1. Sul server sorgente, crea questa chiave:

    Terminale
    sudo ssh-keygen -t ed25519 -N '' -C 'restore-rsync@web01' -f /root/.ssh/restore_rsync
    sudo cat /root/.ssh/restore_rsync.pub
  2. Sul server di backup, aggiungi questa riga a /srv/rsyncbackup/.ssh/authorized_keys:

    Testo
    from="IP_SERVER_SORGENTE",restrict,command="/usr/bin/rrsync -ro /srv/rsyncbackup/web01" ssh-ed25519 AAAA...chiave_di_ripristino restore-rsync@web01
  3. Sul server sorgente, elenca gli snapshot:

    Terminale
    BACKUP_HOST="IP_SERVER_BACKUP"
    SSH_RESTORE="ssh -i /root/.ssh/restore_rsync -p 22 -o BatchMode=yes -o IdentitiesOnly=yes"
    sudo rsync --list-only -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:/"
  4. Ripristina /etc in una cartella temporanea, dall'ultimo snapshot completato:

    Terminale
    SNAPSHOT="$(sudo cat /var/lib/backup-rsync/last)"
    sudo mkdir -p /var/tmp/rsync-restore
    sudo rsync -aHAX --numeric-ids -M--fake-super -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:$SNAPSHOT/etc/" /var/tmp/rsync-restore/etc/
  5. Confronta il contenuto, il proprietario e i permessi:

    Terminale
    sudo diff -r /etc /var/tmp/rsync-restore/etc | head -n 20
    sudo stat -c '%U:%G %a %n' /etc/shadow /var/tmp/rsync-restore/etc/shadow

    Devono differire solo i file modificati dopo il backup, e le due righe di stat devono indicare lo stesso proprietario e gli stessi permessi.

  6. Cancella la copia di test, che contiene dati sensibili:

    Terminale
    sudo rm -rf /var/tmp/rsync-restore
  7. Se non hai nessun ripristino da fare, rimuovi la riga della chiave restore-rsync sul server di backup. La aggiungerai di nuovo al bisogno.

Ripristinare dopo un incidente

Scegli dall'elenco uno snapshot che contenga .backup-complete e metti il suo nome in SNAPSHOT. Simula prima l'operazione con --dry-run e verifica l'elenco, perché può sovrascrivere dei file:

Terminale
sudo rsync -aHAX --numeric-ids -M--fake-super --dry-run --itemize-changes -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:$SNAPSHOT/var/www/" /var/www/

Se il risultato ti va bene, rilancia il comando senza --dry-run. Se il server sorgente è perso, prepara il nuovo server, genera una chiave di ripristino, aggiungila sul server di backup con il nuovo indirizzo in from=, poi ripristina le tue cartelle una per una.

Aggiornare

rsync viene aggiornato con il sistema, su entrambi i server:

Terminale
sudo apt update
sudo apt upgrade

Dopo un aggiornamento, controlla il log del backup successivo. Se sostituisci il server di backup, la sua chiave host cambia: aggiorna /root/.ssh/known_hosts sul server sorgente dopo aver verificato la nuova impronta.

In caso di problemi

Permission denied (publickey)

Verifica sul server di backup la chiave pubblica, l'indirizzo in from= e i permessi. Il log SSH indica spesso la causa:

Terminale
sudo ls -ld /srv/rsyncbackup /srv/rsyncbackup/.ssh
sudo ls -l /srv/rsyncbackup/.ssh/authorized_keys
sudo journalctl -u ssh -n 30 --no-pager

La cartella personale non deve essere modificabile dal gruppo o dagli altri utenti.

Host key verification failed.

La chiave del server di backup è assente da /root/.ssh/known_hosts oppure è cambiata. Ripeti il passaggio di verifica, senza disattivare il controllo.

python3: No such file or directory

rrsync non riesce ad avviarsi. Installa python3 sul server di backup.

rrsync rifiuta i percorsi che contengono ... Il percorso di --link-dest deve iniziare con /, come nello script: è allora relativo alla cartella autorizzata.

reading from write-only server is not allowed

Stai cercando di leggere con la chiave di backup. Usa la chiave di ripristino restore_rsync.

Another instance of rrsync is already accessing this directory.

Un backup è già in corso, oppure una vecchia connessione non è terminata. Verifica con pgrep -a rsync su entrambi i server.

Codice 23: some files/attrs were not transferred

Alcuni file non hanno potuto essere copiati. Il log li indica, subito prima di questo messaggio. Lo script considera questo snapshot fallito: correggi la causa e rilancialo.

Operation not supported (95) sugli attributi

Il file system del server di backup non supporta gli attributi estesi usati da --fake-super. Colloca i backup su un volume ext4 o XFS.

Codice 255 o 12

La connessione SSH è fallita o è stata interrotta. Rilancia il test di connessione e verifica la rete, il firewall e lo spazio su disco con la nostra guida Verificare lo spazio su disco.

Tutti i file vengono ricopiati a ogni passaggio

Verifica /var/lib/backup-rsync/last: deve contenere il nome di uno snapshot esistente. Controlla anche che questo snapshot contenga davvero i file attesi e che il file system di destinazione supporti gli hard link.

Riferimenti