Was ist Rclone?

Rclone ist ein Open-Source-Befehlszeilentool zur Verwaltung von Dateien auf über 70 Cloud-Speicherdiensten. Oft als "rsync für die Cloud" bezeichnet, bietet es erweiterte Funktionen für Synchronisierung, Übertragung, Verschlüsselung und Einbindung entfernter Dateisysteme.

Interne Architektur

Rclone arbeitet nach einem modularen Aufbau mit mehreren Schichten. Im Kern befindet sich der Rclone Core, der grundlegende Operationen verwaltet. Darüber interagieren drei Hauptebenen: die VFS-Schicht für Einbindung und Cache, die Crypt-Schicht für die Client-seitige Verschlüsselung und die Chunker-Schicht für die Aufteilung großer Dateien.

Diese Schichten kommunizieren mit einer Backend-Abstraktion, die den Zugriff auf verschiedene Anbieter wie S3/R2, Google Drive, SFTP, Backblaze B2, WebDAV und viele andere vereinheitlicht.

Systemvoraussetzungen

Komponente	Minimum	Empfohlen
RAM	512 MB	2 GB+
CPU	1 vCPU	2+ vCPU
Speicher	100 MB	1 GB (Cache)
Kernel	3.10+	5.4+ (FUSE3)
OS	Ubuntu 18.04+	Ubuntu 22.04/24.04

Erweiterte Installation

Methode 1: Installation über Offizielles Skript (Empfohlen)

# Installation mit Signaturüberprüfung
curl -fsSL https://rclone.org/install.sh | sudo bash

# Installation überprüfen
rclone version

Methode 2: Manuelle Installation (Vollständige Kontrolle)

# Gewünschte Version festlegen
RCLONE_VERSION="v1.68.2"
ARCH="amd64"  # oder arm64 für ARM

# Herunterladen und Entpacken
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}

# Binäre Installation
sudo cp rclone /usr/local/bin/
sudo chmod 755 /usr/local/bin/rclone

# Man-Seiten installieren
sudo mkdir -p /usr/local/share/man/man1
sudo cp rclone.1 /usr/local/share/man/man1/
sudo mandb

# Bash-Autovervollständigung installieren
rclone completion bash | sudo tee /etc/bash_completion.d/rclone > /dev/null

# Zsh-Autovervollständigung installieren
rclone completion zsh | sudo tee /usr/local/share/zsh/site-functions/_rclone > /dev/null

Methode 3: Kompilieren aus den Quellen

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

# Klonen und kompilieren
git clone https://github.com/rclone/rclone.git
cd rclone
go build -ldflags "-s -w" -o rclone

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

Installation der FUSE-Abhängigkeiten

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

# FUSE für nicht-root-Benutzer aktivieren
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

Multi-Provider-Konfiguration

Struktur der Konfigurationsdatei

Die Standardkonfigurationsdatei befindet sich unter ~/.config/rclone/rclone.conf. Ihre INI-Struktur unterstützt mehrere Remotes.

# ~/.config/rclone/rclone.conf

[gdrive]
type = drive
client_id = IHRE_CLIENT_ID.apps.googleusercontent.com
client_secret = IHR_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 = IHR_R2_ACCESS_KEY
secret_access_key = IHR_R2_SECRET_KEY
endpoint = https://IHR_ACCOUNT_ID.r2.cloudflarestorage.com
acl = private

[b2]
type = b2
account = IHR_ANWENDUNGS_SCHLÜSSEL_ID
key = IHR_ANWENDUNGS_SCHLÜSSEL
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

Interaktive Konfiguration

# Konfigurationsassistent starten
rclone config

# Befehle im interaktiven Menü
# n) Neues Remote
# d) Remote löschen
# r) Remote umbenennen
# c) Remote kopieren
# s) Konfigurationspasswort festlegen
# q) Konfiguration beenden

Google Drive-Konfiguration (Headless VPS)

Um Google Drive auf einem VPS ohne grafische Benutzeroberfläche zu konfigurieren:

# Auf Ihrem lokalen Rechner mit Browser
rclone authorize "drive"

# Generierten Token kopieren und dann auf dem VPS
rclone config

# Auswählen: n (neues Remote)
# Name: gdrive
# Speicher: drive
# client_id: (leer lassen oder Ihren eigenen verwenden)
# client_secret: (leer lassen oder Ihren eigenen verwenden)
# scope: drive
# service_account_file: (leer lassen)
# Erweiterte Konfiguration bearbeiten: n
# Automatische Konfiguration verwenden: n
# Den auf dem lokalen Rechner erhaltenen Token einfügen

Konfiguration mit Service Account (Google Workspace)

# Verzeichnis für die Anmeldeinformationen erstellen
mkdir -p ~/.config/rclone/sa

# JSON-Datei des Service Accounts platzieren
# ~/.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

Konfiguration S3-kompatibel (MinIO, Wasabi, etc.)

[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 = IHR_WASABI_SCHLÜSSEL
secret_access_key = IHR_WASABI_SECRET
region = eu-central-1
endpoint = s3.eu-central-1.wasabisys.com

Grundlegende Befehle

Allgemeine Syntax

rclone [Optionen] Unterbefehl <Quelle> [<Ziel>] [Flags]

Grundbefehle

Auflisten und Navigieren

# Konfigurierte Remotes auflisten
rclone listremotes

# Inhalt eines Remotes auflisten
rclone ls gdrive:
rclone ls gdrive:Dokumente/

# Detaillierte Liste mit Größe und Datum
rclone lsl gdrive:

# JSON-Format (für Skripting)
rclone lsjson gdrive: --recursive

# Nur Verzeichnisse anzeigen
rclone lsd gdrive:

# Vollständige Baumstruktur
rclone tree gdrive:Projekte/ --level 3

# Dateien suchen
rclone ls gdrive: --include "*.pdf" --recursive

Kopieren und Verschieben

# Lokale Datei zu Remote kopieren
rclone copy /lokaler/pfad gdrive:sicherung/ -P

# Remote zu lokaler Kopie
rclone copy gdrive:Dokumente/ /lokale/dokumente/ -P

# Kopieren zwischen zwei Remotes (serverseitig, wenn unterstützt)
rclone copy gdrive:quelle/ s3-aws:ziel/ -P

# Verschieben (Kopieren + Quelle löschen)
rclone move /lokaler/temp/ gdrive:archiv/ -P

# Einzelne Datei kopieren
rclone copyto /lokale/datei.txt gdrive:sicherung/datei.txt

Synchronisierung

# Einweg-Synchronisierung (Quelle → Ziel)
# ACHTUNG: Löscht Dateien im Ziel, die nicht in der Quelle vorhanden sind
rclone sync /lokale/daten/ gdrive:daten/ -P

# Synchronisation mit Dry-Run (Simulation)
rclone sync /lokale/daten/ gdrive:daten/ --dry-run

# Bidirektionale Synchronisation (experimentell)
rclone bisync /lokale/daten/ gdrive:daten/ --resync

Löschen

# Datei löschen
rclone deletefile gdrive:path/to/file.txt

# Verzeichnis und Inhalt löschen
rclone purge gdrive:old-backup/

# Nur Dateien löschen (Struktur beibehalten)
rclone delete gdrive:temp/

# Leere Dateien löschen
rclone rmdirs gdrive: --leave-root

Wesentliche Flags

Flag	Beschreibung
`-P, --progress`	Fortschritt anzeigen
`-v, --verbose`	Verbose Modus
`-n, --dry-run`	Simulation ohne Änderungen
`--transfers N`	Anzahl paralleler Übertragungen
`--checkers N`	Anzahl paralleler Prüfer
`--bwlimit RATE`	Bandbreitenbegrenzung
`--exclude PATTERN`	Dateien ausschließen
`--include PATTERN`	Nur diese Dateien einschließen
`--min-size SIZE`	Minimale Größe
`--max-size SIZE`	Maximale Größe
`--min-age DURATION`	Minimales Alter
`--max-age DURATION`	Maximales Alter

Erweiterte Operationen

Erweiterte Filterung

# Filterdatei
cat > /etc/rclone/filters.txt << 'EOF'
# Einschlüsse
+ **.pdf
+ **.docx
+ Documents/**

# Ausschlüsse
- *.tmp
- *.log
- .git/**
- node_modules/**
- __pycache__/**
- .DS_Store
- Thumbs.db

# Dateien über 1 GB ausschließen
- *
EOF

# Verwendung der Filterdatei
rclone sync /data/ gdrive:backup/ --filter-from /etc/rclone/filters.txt -P

Serverseitige Operationen

# Serverseitige Kopie (lokales Herunterladen vermeiden)
rclone copy gdrive:source/ gdrive:destination/ --drive-server-side-across-configs

# Überprüfen der Verfügbarkeit von serverseitigen Funktionen
rclone backend features gdrive:

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

Verwaltung großer Dateien

# Chunked Upload für Dateien > 5GB (S3)
rclone copy largefile.tar gdrive:backup/ \
  --s3-chunk-size 100M \
  --s3-upload-concurrency 4

# Integritätsprüfung
rclone check /local/data/ gdrive:data/ --one-way
rclone hashsum MD5 gdrive:file.zip

Metadatenoperationen

# Kopieren mit Zeitstempelerhaltung
rclone copy /local/ gdrive:backup/ --metadata

# Metadaten anzeigen
rclone lsjson gdrive:file.txt --metadata

# Metadaten ändern (unterstützte Backends)
rclone settier gdrive:file.txt ARCHIVE

FUSE-Mount und Cache

Grundmontage

# Mountpoint erstellen
sudo mkdir -p /mnt/gdrive
sudo chown $USER:$USER /mnt/gdrive

# Einfaches Mounten
rclone mount gdrive: /mnt/gdrive --daemon

# Mounten mit erweiterten Optionen
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

VFS-Cache-Modi

Modus	Beschreibung	Verwendung
`off`	Kein Cache	Nur Streaming
`minimal`	Nur Schreibcache	Uploads
`writes`	Schreibt Cache bis zum Upload	Dateibearbeitung
`full`	Vollständiger Lese-/Schreibcache	Intensiv genutzt, Anwendungen

Erweiterte Cache-Konfiguration

# Cache mit dediziertem Backend
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

Systemd-Service für persistente Montage

# Service-Datei erstellen
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

# Dedizierten Benutzer erstellen
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

# Service aktivieren und starten
sudo systemctl daemon-reload
sudo systemctl enable rclone-gdrive.service
sudo systemctl start rclone-gdrive.service

# Status überprüfen
sudo systemctl status rclone-gdrive.service

Demontage

# Saubere Demontage
fusermount -u /mnt/gdrive

# Erzwungene Demontage (bei Blockierung)
fusermount -uz /mnt/gdrive

# Über systemd
sudo systemctl stop rclone-gdrive.service

Verschlüsselung und Sicherheit

Konfiguration eines verschlüsselten Remotes

Das Backend crypt bietet transparente clientseitige Verschlüsselung.

# Konfiguration über Assistenten
rclone config

# Auswählen: n (neues Remote)
# Name: gdrive-crypt
# Speicher: crypt
# Remote: gdrive:encrypted/ (unterliegendes Remote)
# filename_encryption: standard
# directory_name_encryption: true
# password: (generiert oder gewählt)
# password2: (Salt, optional aber empfohlen)

Ergebnis der Konfiguration:

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

Verschlüsselungsmodi für Dateinamen

Modus	Beschreibung	Beispiel
`off`	Keine Dateinamensverschlüsselung	`document.pdf`
`standard`	Vollständige Verschlüsselung	`q4kp2q8fj3m2...`
`obfuscate`	Einfache Verschleierung	`yqkpzqFfj3m2...`

Verwendung des verschlüsselten Remotes

# Operationen sind transparent
rclone copy /sensitive/data/ gdrive-crypt: -P

# Dateien erscheinen verschlüsselt in der Cloud
rclone ls gdrive:encrypted/
# Ausgabe: verschlüsselt und unleserlich

# Aber lesbar über das verschlüsselte Remote
rclone ls gdrive-crypt:
# Ausgabe: Originalnamen

Konfigurationssicherheit

# Konfigurieren des Konfigurationsdateipassworts
rclone config password

# Die Konfiguration verwendet nun ein Passwort
# Über Umgebungsvariable festlegen
export RCLONE_CONFIG_PASS="Ihr_starkes_Passwort"

# Oder einen Secrets Manager verwenden
export RCLONE_CONFIG_PASS=$(cat /run/secrets/rclone_pass)

Sensible Umgebungsvariablen

# Konfiguration über Variablen (vermeidet Konfigurationsdatei)
export RCLONE_CONFIG_GDRIVE_TYPE=drive
export RCLONE_CONFIG_GDRIVE_TOKEN='{"access_token":"..."}'

# Für S3
export RCLONE_CONFIG_S3_TYPE=s3
export RCLONE_CONFIG_S3_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export RCLONE_CONFIG_S3_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG

Automatisierung und Skripting

Vollständiges Backup-Skript

#!/usr/bin/env bash
#
# rclone-backup.sh - Automatisiertes Sicherungsskript
# Verwendung: ./rclone-backup.sh [täglich|wöchentlich|monatlich]
#

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

# Konfiguration
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"

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

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

# Funktionen
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" "Reinigung abgeschlossen, Sperre freigegeben"
}

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

acquire_lock() {
    exec 200>"${LOCK_FILE}"
    if ! flock -n 200; then
        log "ERROR" "Eine andere Instanz läuft bereits"
        exit 1
    fi
}

perform_backup() {
    local backup_type="${1:-täglich}"
    local timestamp=$(date +%Y%m%d-%H%M%S)
    local dest_path="${REMOTE_DEST}/${backup_type}/${timestamp}"
    
    log "INFO" "Starte Backup ${backup_type} nach ${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} erfolgreich abgeschlossen${NC}"
    else
        log "ERROR" "${RED}Backup ${backup_type} fehlgeschlagen (Code: ${exit_code})${NC}"
    fi
    
    return $exit_code
}

cleanup_old_backups() {
    log "INFO" "Lösche Backups älter als ${RETENTION_DAYS} Tage"
    
    rclone delete "${REMOTE_DEST}" \
        --config "${CONFIG_FILE}" \
        --min-age "${RETENTION_DAYS}d" \
        --rmdirs \
        --log-file "${LOG_FILE}" \
        --log-level INFO
        
    log "INFO" "Löschen abgeschlossen"
}

send_notification() {
    local status="$1"
    local message="$2"
    
    # Beispiel mit Discord/Slack-Webhook
    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:-täglich}"
    
    # Initialisierung
    mkdir -p "${LOG_DIR}"
    trap cleanup EXIT
    
    log "INFO" "=== Starte ${SCRIPT_NAME} (${backup_type}) ==="
    
    check_dependencies
    acquire_lock
    
    # Ausführung
    if perform_backup "${backup_type}"; then
        cleanup_old_backups
        send_notification "ERFOLG" "Backup ${backup_type} abgeschlossen"
    else
        send_notification "FEHLER" "Backup ${backup_type} fehlgeschlagen"
        exit 1
    fi
    
    log "INFO" "=== Ende ${SCRIPT_NAME} ==="
}

main "$@"

Cron-Konfiguration

# Crontab bearbeiten
crontab -e

# Automatisierte Backups
# Täglich um 2:00 Uhr
0 2 * * * /usr/local/bin/rclone-backup.sh täglich >> /var/log/rclone/cron.log 2>&1

# Wöchentlich sonntags um 3:00 Uhr
0 3 * * 0 /usr/local/bin/rclone-backup.sh wöchentlich >> /var/log/rclone/cron.log 2>&1

# Monatlich am 1. des Monats um 4:00 Uhr
0 4 1 * * /usr/local/bin/rclone-backup.sh monatlich >> /var/log/rclone/cron.log 2>&1

# Cache-Bereinigung täglich um 5:00 Uhr
0 5 * * * /usr/local/bin/rclone cleanup gdrive: --config /home/user/.config/rclone/rclone.conf

Systemd-Timer (Alternative zu Cron)

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

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

# Timer
sudo tee /etc/systemd/system/rclone-backup.timer << 'EOF'
[Unit]
Description=Führe Rclone Backup täglich aus

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

[Install]
WantedBy=timers.target
EOF

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

# Überprüfung
systemctl list-timers | grep rclone

Leistungsoptimierung

Transfer-Tuning

# Hochleistungskonfiguration
rclone sync /quelle/ remote:ziel/ \
  --transfers 16 \
  --checkers 32 \
  --buffer-size 512M \
  --drive-chunk-size 256M \
  --fast-list \
  --tpslimit 10 \
  --tpslimit-burst 20 \
  -P

Provider-spezifische Einstellungen

Google Drive

# Google Drive-Optimierung
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

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

Backblaze B2

# B2-Optimierung
rclone copy /data/ b2:eimer/pfad/ \
  --b2-chunk-size 96M \
  --b2-upload-cutoff 200M \
  --b2-hard-delete \
  --fast-list \
  -P

Benchmarking

# Geschwindigkeitstest
rclone test makefile /tmp/rclone_test_file --size 1G

# Vollständiger Benchmark
rclone test memory remote:path/
rclone test bandwidth remote:path/ --time 30s

# Transfer messen
time rclone copy /test/1GB.bin remote:test/ -P --stats 1s

Bandbreitenmanagement

# Feste Begrenzung
--bwlimit 10M

# Zeitgesteuerte Begrenzung
--bwlimit "08:00,512K 18:00,10M 23:00,off"

# Getrennte Upload-/Download-Begrenzung
--bwlimit "10M:5M"  # 10M up, 5M down

Überwachung und Protokollierung

Log-Konfiguration

# Log Levels
--log-level DEBUG    # Very verbose
--log-level INFO     # Standard
--log-level NOTICE   # Important only
--log-level ERROR    # Errors only

# Output file
--log-file /var/log/rclone/operation.log

# JSON format (for parsing)
--use-json-log

Detaillierte Statistiken

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

Überwachung mit Prometheus

# Metriken aktivieren
rclone serve restic remote:path/ \
  --rc \
  --rc-addr :5572 \
  --rc-enable-metrics

# Prometheus-Endpunkt
curl http://localhost:5572/metrics

Überwachungsskript

#!/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} zugänglich" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${REMOTE} nicht erreichbar" >> "${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} gemountet" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${mount_point} nicht gemountet" >> "${LOG_FILE}"
        return 1
    fi
}

check_remote
check_mount

Logrotate-Konfiguration

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

Expertenfehlerbehebung

Gängige Probleme und Lösungen

Fehler 403 - Rate Limit (Google Drive)

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

# Lösungen
# 1. Reduzieren der Parallelität
--transfers 2 --checkers 4

# 2. Verzögerungen hinzufügen
--tpslimit 2 --tpslimit-burst 0

# 3. Verwenden Sie Ihre eigene Client-ID
# In rclone config, benutzerdefinierte client_id und client_secret setzen

Token abgelaufen Fehler

# Token neu generieren
rclone config reconnect gdrive:

# Oder manuell
rclone authorize drive

FUSE-Montage - Berechtigungsverweigerung

# Überprüfen von /etc/fuse.conf
grep user_allow_other /etc/fuse.conf

# Wenn auskommentiert, aktivieren
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

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

Fehlende Dateien nach Sync

# Immer zuerst eine Trockenübung machen
rclone sync source: dest: --dry-run

# Überprüfen von Ausschlüssen
rclone ls source: --include "*.ext" -v

# Verwenden von check zum Vergleichen
rclone check source: dest: --one-way --combined report.txt

Erweiterte Diagnose

# Vollständiger Debug-Modus
rclone copy source: dest: -vv --dump headers --dump bodies

# Verbindung testen
rclone lsd remote: --timeout 30s

# Konfiguration überprüfen
rclone config show remote

# Backends und Features auflisten
rclone backend features remote:

# Netzwerk-Performance-Test
rclone test bandwidth remote: --time 30s

Fehlerwiederherstellung

# Fortsetzen eines unterbrochenen Transfers
rclone copy source: dest: \
  --retries 10 \
  --retries-sleep 30s \
  --low-level-retries 20 \
  --ignore-errors

# Fehlerhafte Dateien separat behandeln
rclone copy source: dest: \
  --error-on-no-transfer \
  2>&1 | tee transfer.log

# Nur Fehler erneut abspielen
grep "ERROR" transfer.log | while read line; do
    # Extrahieren und erneut verarbeiten
done

Produktionsanwendungsfälle

Vollständiges Webserver-Backup

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

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

# Backup-Verzeichnis erstellen
mkdir -p "${BACKUP_DIR}/${DATE}"

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

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

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

# 4. In die Cloud hochladen
rclone copy "${BACKUP_DIR}/${DATE}" "${REMOTE}/${DATE}/" \
    --transfers 4 \
    --b2-hard-delete \
    -P

# 5. Lokale Bereinigung (7 Tage behalten)
find "${BACKUP_DIR}" -type d -mtime +7 -exec rm -rf {} +

# 6. Remote-Bereinigung (30 Tage behalten)
rclone delete "${REMOTE}" --min-age 30d --rmdirs

Multi-Cloud-Synchronisierung

#!/usr/bin/env bash
# multi-cloud-sync.sh - Replikation auf mehreren Anbietern

QUELLEN=("gdrive:wichtig" "s3:eimer/wichtig")
ZIELE=("b2:redundanz" "wasabi:redundanz")

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

Media-Server mit Rclone Mount

# Konfiguration für 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

Archivierung mit Versionierung

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

# Wiederherstellung einer Version
rclone copy remote:versions/20240115/file.txt.bak /restore/file.txt

Ressourcen und Referenzen

Offizielle Dokumentation

Offizielle Website: https://rclone.org/
Dokumentation: https://rclone.org/docs/
Forum: https://forum.rclone.org/
GitHub: https://github.com/rclone/rclone

Nützliche Schnellbefehle

# Überprüfen des verwendeten Speicherplatzes
rclone size remote:path/

# Bereinigen von temporären Dateien
rclone cleanup remote:

# Mit Webinterface mounten
rclone rcd --rc-web-gui --rc-addr :5572

# Konfiguration exportieren (ohne Geheimnisse)
rclone config dump | jq 'del(..|.token?, .password?, .secret_access_key?)'

Rclone: Expertenleitfaden für die Cloud-Synchronisierung auf VPS Linux