Rclone: Guida esperta per la sincronizzazione cloud su VPS Linux

Che cos'è Rclone?

Rclone è uno strumento da riga di comando open-source che consente di gestire file su oltre 70 servizi di archiviazione cloud. Spesso definito "rsync per il cloud", offre funzionalità avanzate di sincronizzazione, trasferimento, crittografia e montaggio di file system remoti.

Architettura Interna

Rclone funziona secondo un'architettura modulare composta da diversi strati. Al centro si trova il Rclone Core che gestisce le operazioni di base. Sopra, tre strati principali interagiscono: il VFS Layer per il montaggio e la cache, il Crypt Layer per la crittografia lato client e il Chunker Layer per il frazionamento di file di grandi dimensioni.

Questi strati comunicano con un Backend Abstraction che uniforma l'accesso ai diversi provider: S3/R2, Google Drive, SFTP, Backblaze B2, WebDAV e molti altri.

Requisiti di Sistema

Componente	Minimo	Consigliato
RAM	512 MB	2 GB+
CPU	1 vCPU	2+ vCPU
Archiviazione	100 MB	1 GB (cache)
Kernel	3.10+	5.4+ (FUSE3)
OS	Ubuntu 18.04+	Ubuntu 22.04/24.04

---

Installazione Avanzata

Metodo 1: Installazione tramite Script Ufficiale (Consigliato)

# Installazione con verifica della firma
curl -fsSL https://rclone.org/install.sh | sudo bash

# Verifica dell'installazione
rclone version

Metodo 2: Installazione Manuale (Controllo Totale)

# Definire la versione desiderata
RCLONE_VERSION="v1.68.2"
ARCH="amd64"  # o arm64 per ARM

# Download ed estrazione
cd /tmp
curl -LO "https://downloads.rclone.org/${RCLONE_VERSION}/rclone-${RCLONE_VERSION}-linux-${ARCH}.zip"
unzip rclone-${RCLONE_VERSION}-linux-${ARCH}.zip
cd rclone-${RCLONE_VERSION}-linux-${ARCH}

# Installazione binaria
sudo cp rclone /usr/local/bin/
sudo chmod 755 /usr/local/bin/rclone

# Installazione delle pagine man
sudo mkdir -p /usr/local/share/man/man1
sudo cp rclone.1 /usr/local/share/man/man1/
sudo mandb

# Installazione autocompletamento (Bash)
rclone completion bash | sudo tee /etc/bash_completion.d/rclone > /dev/null

# Installazione autocompletamento (Zsh)
rclone completion zsh | sudo tee /usr/local/share/zsh/site-functions/_rclone > /dev/null

Metodo 3: Compilazione dai Sorgenti

# Requisiti Go 1.21+
sudo apt update && sudo apt install -y golang-go git

# Clonazione e compilazione
git clone https://github.com/rclone/rclone.git
cd rclone
go build -ldflags "-s -w" -o rclone

# Installazione
sudo mv rclone /usr/local/bin/

Installazione delle Dipendenze FUSE

# Ubuntu/Debian
sudo apt update
sudo apt install -y fuse3 libfuse3-dev

# Abilitare FUSE per gli utenti non root
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

---

Configurazione Multi-Provider

Struttura del File di Configurazione

Il file di configurazione predefinito si trova in ~/.config/rclone/rclone.conf. La sua struttura INI supporta più remoti.

# ~/.config/rclone/rclone.conf

[gdrive]
type = drive
client_id = YOUR_CLIENT_ID.apps.googleusercontent.com
client_secret = YOUR_CLIENT_SECRET
scope = drive
token = {"access_token":"...","token_type":"Bearer","refresh_token":"...","expiry":"..."}
team_drive = 

[s3-aws]
type = s3
provider = AWS
access_key_id = AKIAIOSFODNN7EXAMPLE
secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
region = eu-west-1
acl = private
storage_class = STANDARD_IA

[s3-r2]
type = s3
provider = Cloudflare
access_key_id = YOUR_R2_ACCESS_KEY
secret_access_key = YOUR_R2_SECRET_KEY
endpoint = https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com
acl = private

[b2]
type = b2
account = YOUR_APPLICATION_KEY_ID
key = YOUR_APPLICATION_KEY
hard_delete = true

[sftp-backup]
type = sftp
host = backup.example.com
user = backupuser
port = 22
key_file = ~/.ssh/backup_key
shell_type = unix
md5sum_command = md5sum
sha1sum_command = sha1sum

Configurazione Interattiva

# Avviare l'assistente di configurazione
rclone config

# Comandi del menu interattivo
# n) Nuovo remoto
# d) Elimina remoto
# r) Rinomina remoto
# c) Copia remoto
# s) Imposta password di configurazione
# q) Esci dalla configurazione

Configurazione Google Drive (VPS Headless)

Per configurare Google Drive su un VPS senza interfaccia grafica:

# Sulla tua macchina locale con browser
rclone authorize "drive"

# Copia il token generato, poi sul VPS
rclone config

# Selezionare: n (nuovo remoto)
# Nome: gdrive
# Archiviazione: drive
# client_id: (lasciare vuoto o utilizzare il tuo)
# client_secret: (lasciare vuoto o utilizzare il tuo)
# scope: drive
# service_account_file: (lasciare vuoto)
# Modifica configurazione avanzata: n
# Usa configurazione automatica: n
# Incolla il token ottenuto sulla macchina locale

Configurazione con Account di Servizio (Google Workspace)

# Creare la directory per le credenziali
mkdir -p ~/.config/rclone/sa

# Posizionare il file JSON dell'account di servizio
# ~/.config/rclone/sa/service-account.json

[gdrive-sa]
type = drive
scope = drive
service_account_file = /home/user/.config/rclone/sa/service-account.json
team_drive = 0ABCdefGHIjklMNOpqr

Configurazione S3 Compatibile (MinIO, Wasabi, ecc.)

[minio]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://localhost:9000
acl = private

[wasabi]
type = s3
provider = Wasabi
access_key_id = YOUR_WASABI_KEY
secret_access_key = YOUR_WASABI_SECRET
region = eu-central-1
endpoint = s3.eu-central-1.wasabisys.com

---

Comandi Fondamentali

Sintassi Generale

rclone [options] subcommand <source> [<destination>] [flags]

Comandi di Base

Elenco e Navigazione

# Elencare i remoti configurati
rclone listremotes

# Elencare il contenuto di un remoto
rclone ls gdrive:
rclone ls gdrive:Documents/

# Elenco dettagliato con dimensione e data
rclone lsl gdrive:

# Elenco in formato JSON (per scripting)
rclone lsjson gdrive: --recursive

# Visualizzare solo le directory
rclone lsd gdrive:

# Struttura completa
rclone tree gdrive:Projects/ --level 3

# Cercare file
rclone ls gdrive: --include "*.pdf" --recursive

Copia e Spostamento

# Copia locale verso remoto
rclone copy /local/path gdrive:backup/ -P

# Copia remoto verso locale
rclone copy gdrive:Documents/ /local/documents/ -P

# Copia tra due remoti (server-side se supportato)
rclone copy gdrive:source/ s3-aws:destination/ -P

# Spostamento (copia + cancellazione sorgente)
rclone move /local/temp/ gdrive:archive/ -P

# Copia di un singolo file
rclone copyto /local/file.txt gdrive:backup/file.txt

Sincronizzazione

# Sincronizzazione unidirezionale (sorgente → destinazione)
# ATTENZIONE: elimina i file nella destinazione non presenti nella sorgente
rclone sync /local/data/ gdrive:data/ -P

# Sincronizzazione con dry-run (simulazione)
rclone sync /local/data/ gdrive:data/ --dry-run

# Sincronizzazione bidirezionale (sperimentale)
rclone bisync /local/data/ gdrive:data/ --resync

Cancellazione

# Eliminare un file
rclone deletefile gdrive:path/to/file.txt

# Eliminare una directory e il suo contenuto
rclone purge gdrive:old-backup/

# Eliminare solo i file (mantiene la struttura)
rclone delete gdrive:temp/

# Eliminare i file vuoti
rclone rmdirs gdrive: --leave-root

Flag Essenziali

Flag	Descrizione
-P, --progress	Mostra il progresso
-v, --verbose	Modalità verbosa
-n, --dry-run	Simulazione senza modifica
--transfers N	Numero di trasferimenti paralleli
--checkers N	Numero di verificatori paralleli
--bwlimit RATE	Limite di larghezza di banda
--exclude PATTERN	Escludere file
--include PATTERN	Includere solo questi file
--min-size SIZE	Dimensione minima
--max-size SIZE	Dimensione massima
--min-age DURATION	Età minima
--max-age DURATION	Età massima

---

Operazioni Avanzate

Filtraggio Avanzato

# File di filtri
cat > /etc/rclone/filters.txt << 'EOF'
# Inclusioni
+ **.pdf
+ **.docx
+ Documents/**

# Esclusioni
- *.tmp
- *.log
- .git/**
- node_modules/**
- __pycache__/**
- .DS_Store
- Thumbs.db

# Escludere i file di oltre 1GB
- *
EOF

# Utilizzo del file di filtri
rclone sync /data/ gdrive:backup/ --filter-from /etc/rclone/filters.txt -P

Operazioni Server-Side

# Copia server-side (evita il download locale)
rclone copy gdrive:source/ gdrive:destination/ --drive-server-side-across-configs

# Verificare se il server-side è disponibile
rclone backend features gdrive:

# Deduplicazione (Google Drive)
rclone dedupe gdrive:folder/ --dedupe-mode newest

Gestione dei File di Grandi Dimensioni

# Upload a chunk per file > 5GB (S3)
rclone copy largefile.tar gdrive:backup/ \
  --s3-chunk-size 100M \
  --s3-upload-concurrency 4

# Verifica di integrità
rclone check /local/data/ gdrive:data/ --one-way
rclone hashsum MD5 gdrive:file.zip

Operazioni sulle Metadati

# Copiare con preservazione dei timestamp
rclone copy /local/ gdrive:backup/ --metadata

# Visualizzare i metadati
rclone lsjson gdrive:file.txt --metadata

# Modificare i metadati (backends supportati)
rclone settier gdrive:file.txt ARCHIVE

---

Montaggio FUSE e Cache

Montaggio di Base

# Creare il punto di montaggio
sudo mkdir -p /mnt/gdrive
sudo chown $USER:$USER /mnt/gdrive

# Montaggio semplice
rclone mount gdrive: /mnt/gdrive --daemon

# Montaggio con opzioni avanzate
rclone mount gdrive: /mnt/gdrive \
  --daemon \
  --allow-other \
  --vfs-cache-mode full \
  --vfs-cache-max-size 10G \
  --vfs-cache-max-age 24h \
  --vfs-read-chunk-size 64M \
  --vfs-read-chunk-size-limit 1G \
  --buffer-size 256M \
  --dir-cache-time 72h \
  --poll-interval 15s \
  --log-file /var/log/rclone/gdrive.log \
  --log-level INFO

Modalità di Cache VFS

Modalità	Descrizione	Utilizzo
off	Nessuna cache	Streaming solo
minimal	Cache in scrittura solo	Uploads
writes	Cache le scritture fino all'upload	Modifica di file
full	Cache completa lettura/scrittura	Uso intensivo, applicazioni

Configurazione Cache Avanzata

# Cache con backend dedicato
rclone mount gdrive: /mnt/gdrive \
  --vfs-cache-mode full \
  --cache-dir /var/cache/rclone \
  --vfs-cache-max-size 50G \
  --vfs-cache-max-age 168h \
  --vfs-write-back 5s \
  --vfs-read-ahead 128M \
  --attr-timeout 1h \
  --daemon

Servizio Systemd per Montaggio Persistente

# Creare il file di servizio
sudo tee /etc/systemd/system/rclone-gdrive.service << 'EOF'
[Unit]
Description=Rclone Mount - Google Drive
Documentation=https://rclone.org/docs/
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
User=rclone
Group=rclone
ExecStartPre=/bin/mkdir -p /mnt/gdrive
ExecStart=/usr/local/bin/rclone mount gdrive: /mnt/gdrive \
  --config /home/rclone/.config/rclone/rclone.conf \
  --allow-other \
  --vfs-cache-mode full \
  --vfs-cache-max-size 20G \
  --vfs-cache-max-age 72h \
  --vfs-read-chunk-size 32M \
  --vfs-read-chunk-size-limit 256M \
  --buffer-size 128M \
  --dir-cache-time 48h \
  --poll-interval 30s \
  --log-level INFO \
  --log-file /var/log/rclone/gdrive.log \
  --cache-dir /var/cache/rclone/gdrive
ExecStop=/bin/fusermount -uz /mnt/gdrive
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# Creare l'utente dedicato
sudo useradd -r -s /usr/sbin/nologin rclone
sudo mkdir -p /var/log/rclone /var/cache/rclone
sudo chown rclone:rclone /var/log/rclone /var/cache/rclone

# Abilitare e avviare il servizio
sudo systemctl daemon-reload
sudo systemctl enable rclone-gdrive.service
sudo systemctl start rclone-gdrive.service

# Verificare lo stato
sudo systemctl status rclone-gdrive.service

Smontaggio

# Smontaggio pulito
fusermount -u /mnt/gdrive

# Smontaggio forzato (se bloccato)
fusermount -uz /mnt/gdrive

# Tramite systemd
sudo systemctl stop rclone-gdrive.service

---

Crittografia e Sicurezza

Configurazione di un Remote Crittografato

Il backend crypt fornisce una crittografia lato client trasparente.

# Configurazione tramite assistente
rclone config

# Selezionare: n (nuovo remoto)
# Nome: gdrive-crypt
# Archiviazione: crypt
# remoto: gdrive:encrypted/  (remoto sottostante)
# filename_encryption: standard
# directory_name_encryption: true
# password: (generato o scelto)
# password2: (sale, opzionale ma consigliato)

Configurazione risultante:

[gdrive-crypt]
type = crypt
remote = gdrive:encrypted/
password = ENCRYPTED_PASSWORD_HASH
password2 = ENCRYPTED_SALT_HASH
filename_encryption = standard
directory_name_encryption = true

Modalità di Crittografia dei Nomi

Modalità	Descrizione	Esempio
off	Nessuna crittografia dei nomi	document.pdf
standard	Crittografia completa	q4kp2q8fj3m2...
obfuscate	Offuscamento semplice	yqkpzqFfj3m2...

Utilizzo del Remote Crittografato

# Le operazioni sono trasparenti
rclone copy /sensitive/data/ gdrive-crypt: -P

# I file appaiono crittografati lato cloud
rclone ls gdrive:encrypted/
# Output: crittografato e illeggibile

# Ma leggibili tramite il remote crypt
rclone ls gdrive-crypt:
# Output: nomi originali

Sicurezza della Configurazione

# Crittografare il file di configurazione
rclone config password

# La configurazione utilizza ora una password
# Definire tramite variabile d'ambiente
export RCLONE_CONFIG_PASS="la_tua_password_forte"

# Oppure utilizzare un gestore di segreti
export RCLONE_CONFIG_PASS=$(cat /run/secrets/rclone_pass)

Variabili d'Ambiente Sensibili

# Configurazione tramite variabili (evita il file di configurazione)
export RCLONE_CONFIG_GDRIVE_TYPE=drive
export RCLONE_CONFIG_GDRIVE_TOKEN='{"access_token":"..."}'

# Per S3
export RCLONE_CONFIG_S3_TYPE=s3
export RCLONE_CONFIG_S3_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export RCLONE_CONFIG_S3_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG

---

Automazione e Scripting

Script di Backup Completo

#!/usr/bin/env bash
#
# rclone-backup.sh - Script di backup automatizzato
# Usage: ./rclone-backup.sh [daily|weekly|monthly]
#

set -euo pipefail
IFS=$'\n\t'

# Configurazione
readonly SCRIPT_NAME=$(basename "$0")
readonly LOG_DIR="/var/log/rclone"
readonly LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d-%H%M%S).log"
readonly LOCK_FILE="/var/run/rclone-backup.lock"
readonly CONFIG_FILE="${HOME}/.config/rclone/rclone.conf"

# Parametri
readonly LOCAL_SOURCE="/data"
readonly REMOTE_DEST="gdrive-crypt:backups"
readonly RETENTION_DAYS=30
readonly BANDWIDTH_LIMIT="50M"
readonly MAX_TRANSFERS=4

# Colori
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly NC='\033[0m'

# Funzioni
log() {
    local level="$1"
    shift
    local message="$*"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo -e "${timestamp} [${level}] ${message}" | tee -a "${LOG_FILE}"
}

cleanup() {
    rm -f "${LOCK_FILE}"
    log "INFO" "Pulizia completata, lock rilasciato"
}

check_dependencies() {
    local deps=("rclone" "flock")
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            log "ERROR" "Dipendenza mancante: $dep"
            exit 1
        fi
    done
}

acquire_lock() {
    exec 200>"${LOCK_FILE}"
    if ! flock -n 200; then
        log "ERROR" "Un'altra istanza è in esecuzione"
        exit 1
    fi
}

perform_backup() {
    local backup_type="${1:-daily}"
    local timestamp=$(date +%Y%m%d-%H%M%S)
    local dest_path="${REMOTE_DEST}/${backup_type}/${timestamp}"
    
    log "INFO" "Avvio backup ${backup_type} verso ${dest_path}"
    
    rclone sync "${LOCAL_SOURCE}" "${dest_path}" \
        --config "${CONFIG_FILE}" \
        --transfers "${MAX_TRANSFERS}" \
        --checkers 8 \
        --bwlimit "${BANDWIDTH_LIMIT}" \
        --log-file "${LOG_FILE}" \
        --log-level INFO \
        --stats 1m \
        --stats-log-level NOTICE \
        --exclude-from /etc/rclone/exclude.txt \
        --backup-dir "${REMOTE_DEST}/.versions/${timestamp}" \
        --suffix ".bak" \
        --fast-list \
        --retries 3 \
        --retries-sleep 10s \
        --ignore-errors
        
    local exit_code=$?
    
    if [ $exit_code -eq 0 ]; then
        log "INFO" "${GREEN}Backup ${backup_type} completato con successo${NC}"
    else
        log "ERROR" "${RED}Backup ${backup_type} fallito (codice: ${exit_code})${NC}"
    fi
    
    return $exit_code
}

cleanup_old_backups() {
    log "INFO" "Pulizia dei backup di oltre ${RETENTION_DAYS} giorni"
    
    rclone delete "${REMOTE_DEST}" \
        --config "${CONFIG_FILE}" \
        --min-age "${RETENTION_DAYS}d" \
        --rmdirs \
        --log-file "${LOG_FILE}" \
        --log-level INFO
        
    log "INFO" "Pulizia completata"
}

send_notification() {
    local status="$1"
    local message="$2"
    
    # Esempio con webhook Discord/Slack
    if [ -n "${WEBHOOK_URL:-}" ]; then
        curl -s -X POST "${WEBHOOK_URL}" \
            -H "Content-Type: application/json" \
            -d "{\"content\": \"[Rclone Backup] ${status}: ${message}\"}"
    fi
}

main() {
    local backup_type="${1:-daily}"
    
    # Inizializzazione
    mkdir -p "${LOG_DIR}"
    trap cleanup EXIT
    
    log "INFO" "=== Avvio ${SCRIPT_NAME} (${backup_type}) ==="
    
    check_dependencies
    acquire_lock
    
    # Esecuzione
    if perform_backup "${backup_type}"; then
        cleanup_old_backups
        send_notification "SUCCESS" "Backup ${backup_type} completato"
    else
        send_notification "FAILURE" "Backup ${backup_type} fallito"
        exit 1
    fi
    
    log "INFO" "=== Fine ${SCRIPT_NAME} ==="
}

main "$@"

Configurazione Cron

# Modifica la crontab
crontab -e

# Backup automatizzati
# Giornaliero alle 2:00
0 2 * * * /usr/local/bin/rclone-backup.sh daily >> /var/log/rclone/cron.log 2>&1

# Settimanale la domenica alle 3:00
0 3 * * 0 /usr/local/bin/rclone-backup.sh weekly >> /var/log/rclone/cron.log 2>&1

# Mensile il 1° del mese alle 4:00
0 4 1 * * /usr/local/bin/rclone-backup.sh monthly >> /var/log/rclone/cron.log 2>&1

# Pulizia della cache ogni giorno alle 5:00
0 5 * * * /usr/local/bin/rclone cleanup gdrive: --config /home/user/.config/rclone/rclone.conf

Timer Systemd (Alternativa a Cron)

# Servizio
sudo tee /etc/systemd/system/rclone-backup.service << 'EOF'
[Unit]
Description=Servizio di Backup Rclone
After=network-online.target

[Service]
Type=oneshot
User=rclone
ExecStart=/usr/local/bin/rclone-backup.sh daily
StandardOutput=journal
StandardError=journal
EOF

# Timer
sudo tee /etc/systemd/system/rclone-backup.timer << 'EOF'
[Unit]
Description=Esegui Backup Rclone Giornaliero

[Timer]
OnCalendar=*-*-* 02:00:00
RandomizedDelaySec=300
Persistent=true

[Install]
WantedBy=timers.target
EOF

# Attivazione
sudo systemctl daemon-reload
sudo systemctl enable --now rclone-backup.timer

# Verifica
systemctl list-timers | grep rclone

---

Ottimizzazione delle Prestazioni

Tuning dei Trasferimenti

# Configurazione ad alte prestazioni
rclone sync /source/ remote:dest/ \
  --transfers 16 \
  --checkers 32 \
  --buffer-size 512M \
  --drive-chunk-size 256M \
  --fast-list \
  --tpslimit 10 \
  --tpslimit-burst 20 \
  -P

Parametri per Provider

Google Drive

# Ottimizzazione Google Drive
rclone copy /data/ gdrive:backup/ \
  --drive-chunk-size 256M \
  --drive-upload-cutoff 256M \
  --drive-acknowledge-abuse \
  --drive-keep-revision-forever=false \
  --fast-list \
  -P

Amazon S3

# Ottimizzazione S3
rclone copy /data/ s3:bucket/path/ \
  --s3-chunk-size 100M \
  --s3-upload-cutoff 200M \
  --s3-upload-concurrency 8 \
  --s3-copy-cutoff 4G \
  --fast-list \
  -P

Backblaze B2

# Ottimizzazione B2
rclone copy /data/ b2:bucket/path/ \
  --b2-chunk-size 96M \
  --b2-upload-cutoff 200M \
  --b2-hard-delete \
  --fast-list \
  -P

Benchmarking

# Test di velocità
rclone test makefile /tmp/rclone_test_file --size 1G

# Benchmark completo
rclone test memory remote:path/
rclone test bandwidth remote:path/ --time 30s

# Misurare i trasferimenti
time rclone copy /test/1GB.bin remote:test/ -P --stats 1s

Gestione della Larghezza di Banda

# Limite fisso
--bwlimit 10M

# Limite variabile in base all'ora
--bwlimit "08:00,512K 18:00,10M 23:00,off"

# Limite separato upload/download
--bwlimit "10M:5M"  # 10M up, 5M down

---

Monitoraggio e Logging

Configurazione dei Log

# Livelli di log
--log-level DEBUG    # Molto verboso
--log-level INFO     # Standard
--log-level NOTICE   # Solo importante
--log-level ERROR    # Solo errori

# Uscita su file
--log-file /var/log/rclone/operation.log

# Formato JSON (per parsing)
--use-json-log

Statistiche Dettagliate

# Statistiche periodiche
rclone sync /source/ remote:dest/ \
  --stats 30s \
  --stats-file-name-length 0 \
  --stats-log-level NOTICE \
  --stats-one-line \
  -P

Monitoraggio con Prometheus

# Abilitare le metriche
rclone serve restic remote:path/ \
  --rc \
  --rc-addr :5572 \
  --rc-enable-metrics

# Endpoint Prometheus
curl http://localhost:5572/metrics

Script di Monitoraggio

#!/usr/bin/env bash
# rclone-health-check.sh

REMOTE="gdrive:"
LOG_FILE="/var/log/rclone/health.log"

check_remote() {
    if rclone lsd "${REMOTE}" --max-depth 1 &> /dev/null; then
        echo "$(date '+%Y-%m-%d %H:%M:%S') [OK] ${REMOTE} accessibile" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${REMOTE} inaccessibile" >> "${LOG_FILE}"
        return 1
    fi
}

check_mount() {
    local mount_point="/mnt/gdrive"
    if mountpoint -q "${mount_point}"; then
        echo "$(date '+%Y-%m-%d %H:%M:%S') [OK] ${mount_point} montato" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${mount_point} non montato" >> "${LOG_FILE}"
        return 1
    fi
}

check_remote
check_mount

Configurazione Logrotate

sudo tee /etc/logrotate.d/rclone << 'EOF'
/var/log/rclone/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 rclone rclone
    sharedscripts
    postrotate
        systemctl reload rclone-gdrive.service > /dev/null 2>&1 || true
    endscript
}
EOF

---

Risoluzione dei Problemi Esperti

Problemi Comuni e Soluzioni

Errore 403 - Limite di Velocità (Google Drive)

# Sintomo
ERROR : Failed to copy: googleapi: Error 403: User Rate Limit Exceeded

# Soluzioni
# 1. Ridurre il parallelismo
--transfers 2 --checkers 4

# 2. Aggiungere ritardi
--tpslimit 2 --tpslimit-burst 0

# 3. Utilizzare il proprio Client ID
# In rclone config, impostare client_id e client_secret personalizzati

Errore di Token Scaduto

# Rigenerare il token
rclone config reconnect gdrive:

# O manualmente
rclone authorize drive

Montaggio FUSE - Permesso Negato

# Controllare /etc/fuse.conf
grep user_allow_other /etc/fuse.conf

# Se commentato, decommentare
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

# Utilizzare --allow-other
rclone mount remote: /mnt/point --allow-other

File Mancanti dopo Sync

# Eseguire sempre un dry-run prima
rclone sync source: dest: --dry-run

# Controllare le esclusioni
rclone ls source: --include "*.ext" -v

# Utilizzare check per confrontare
rclone check source: dest: --one-way --combined report.txt

Diagnostica Avanzata

# Modalità debug completa
rclone copy source: dest: -vv --dump headers --dump bodies

# Testare la connessione
rclone lsd remote: --timeout 30s

# Controllare la configurazione
rclone config show remote

# Elencare i backend e le funzionalità
rclone backend features remote:

# Test di prestazione rete
rclone test bandwidth remote: --time 30s

Recupero di Errori

# Riprendere un trasferimento interrotto
rclone copy source: dest: \
  --retries 10 \
  --retries-sleep 30s \
  --low-level-retries 20 \
  --ignore-errors

# Trattare i file in errore separatamente
rclone copy source: dest: \
  --error-on-no-transfer \
  2>&1 | tee transfer.log

# Ripetere solo gli errori
grep "ERROR" transfer.log | while read line; do
    # Estrarre e ritrasmettere
done

---

Casi d'Uso Produzione

Backup Server Web Completo

#!/usr/bin/env bash
# backup-webserver.sh

# Variabili
MYSQL_USER="backup"
MYSQL_PASS="secret"
BACKUP_DIR="/var/backups/web"
REMOTE="b2:webserver-backups"
DATE=$(date +%Y%m%d)

# Creare la directory di backup
mkdir -p "${BACKUP_DIR}/${DATE}"

# 1. Backup MySQL
mysqldump -u${MYSQL_USER} -p${MYSQL_PASS} --all-databases \
    | gzip > "${BACKUP_DIR}/${DATE}/mysql-all.sql.gz"

# 2. Backup file web
tar -czf "${BACKUP_DIR}/${DATE}/www.tar.gz" -C /var/www .

# 3. Backup configurazione
tar -czf "${BACKUP_DIR}/${DATE}/etc.tar.gz" \
    /etc/nginx /etc/php /etc/mysql /etc/letsencrypt

# 4. Caricare su cloud
rclone copy "${BACKUP_DIR}/${DATE}" "${REMOTE}/${DATE}/" \
    --transfers 4 \
    --b2-hard-delete \
    -P

# 5. Pulizia locale (mantenere 7 giorni)
find "${BACKUP_DIR}" -type d -mtime +7 -exec rm -rf {} +

# 6. Pulizia remota (mantenere 30 giorni)
rclone delete "${REMOTE}" --min-age 30d --rmdirs

Sincronizzazione Multi-Cloud

#!/usr/bin/env bash
# multi-cloud-sync.sh - Replicazione su più provider

SOURCES=("gdrive:important" "s3:bucket/important")
DESTINATIONS=("b2:redundancy" "wasabi:redundancy")

for src in "${SOURCES[@]}"; do
    for dst in "${DESTINATIONS[@]}"; do
        echo "Sincronizzazione ${src} -> ${dst}"
        rclone sync "${src}" "${dst}" \
            --transfers 8 \
            --fast-list \
            --checksum \
            -P
    done
done

Media Server con Rclone Mount

# Configurazione per Plex/Jellyfin
rclone mount gdrive:Media /mnt/media \
    --daemon \
    --allow-other \
    --uid $(id -u plex) \
    --gid $(id -g plex) \
    --umask 002 \
    --vfs-cache-mode full \
    --vfs-cache-max-size 100G \
    --vfs-cache-max-age 168h \
    --vfs-read-chunk-size 128M \
    --vfs-read-chunk-size-limit 1G \
    --buffer-size 512M \
    --dir-cache-time 168h \
    --poll-interval 1m \
    --log-file /var/log/rclone/media.log \
    --log-level NOTICE \
    --cache-dir /var/cache/rclone/media

Archiviazione con Versioning

# Sync con conservazione delle versioni
rclone sync /data/ remote:current/ \
    --backup-dir remote:versions/$(date +%Y%m%d) \
    --suffix .bak \
    --suffix-keep-extension \
    -P

# Ripristino di una versione
rclone copy remote:versions/20240115/file.txt.bak /restore/file.txt

---

Risorse e Riferimenti

Documentazione Ufficiale

• Sito ufficiale : https://rclone.org/
• Documentazione : https://rclone.org/docs/
• Forum : https://forum.rclone.org/
• GitHub : https://github.com/rclone/rclone

Comandi Utili Rapidi

# Controllare lo spazio utilizzato
rclone size remote:path/

# Pulire i file temporanei
rclone cleanup remote:

# Montare con interfaccia web
rclone rcd --rc-web-gui --rc-addr :5572

# Esportare la config (senza segreti)
rclone config dump | jq 'del(..|.token?, .password?, .secret_access_key?)'