¿Qué es Rclone?

Rclone es una herramienta de línea de comandos de código abierto que permite gestionar archivos en más de 70 servicios de almacenamiento en la nube. A menudo llamado "rsync para la nube", ofrece funciones avanzadas de sincronización, transferencia, cifrado y montaje de sistemas de archivos remotos.

Arquitectura Interna

Rclone funciona con una arquitectura modular compuesta por varias capas. En el núcleo se encuentra el Rclone Core que gestiona las operaciones básicas. Encima, interactúan tres capas principales: la Capa VFS para montaje y caché, la Capa Crypt para cifrado en el lado del cliente, y la Capa Chunker para dividir archivos grandes.

Estas capas se comunican con una Abstracción de Backend que unifica el acceso a los diferentes proveedores: S3/R2, Google Drive, SFTP, Backblaze B2, WebDAV, entre otros.

Requisitos del Sistema

Componente	Mínimo	Recomendado
RAM	512 MB	2 GB+
CPU	1 vCPU	2+ vCPU
Almacenamiento	100 MB	1 GB (caché)
Kernel	3.10+	5.4+ (FUSE3)
SO	Ubuntu 18.04+	Ubuntu 22.04/24.04

Instalación Avanzada

Método 1: Instalación mediante Script Oficial (Recomendado)

# Instalación con verificación de firma
curl -fsSL https://rclone.org/install.sh | sudo bash

# Verificación de la instalación
rclone version

Método 2: Instalación Manual (Control Total)

# Definir la versión deseada
RCLONE_VERSION="v1.68.2"
ARCH="amd64"  # o arm64 para ARM

# Descarga y extracción
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}

# Instalación binaria
sudo cp rclone /usr/local/bin/
sudo chmod 755 /usr/local/bin/rclone

# Instalación de páginas man
sudo mkdir -p /usr/local/share/man/man1
sudo cp rclone.1 /usr/local/share/man/man1/
sudo mandb

# Instalación de autocompletado (Bash)
rclone completion bash | sudo tee /etc/bash_completion.d/rclone > /dev/null

# Instalación de autocompletado (Zsh)
rclone completion zsh | sudo tee /usr/local/share/zsh/site-functions/_rclone > /dev/null

Método 3: Compilación desde las Fuentes

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

# Clonar y compilar
git clone https://github.com/rclone/rclone.git
cd rclone
go build -ldflags "-s -w" -o rclone

# Instalación
sudo mv rclone /usr/local/bin/

Instalación de Dependencias FUSE

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

# Activar FUSE para usuarios no root
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

Configuración Multi-Provider

Estructura del Archivo de Configuración

El archivo de configuración por defecto se encuentra en ~/.config/rclone/rclone.conf. Su estructura INI admite múltiples remotos.

# ~/.config/rclone/rclone.conf

[gdrive]
type = drive
client_id = TU_ID_DE_CLIENTE.apps.googleusercontent.com
client_secret = TU_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 = TU_R2_ACCESS_KEY
secret_access_key = TU_R2_SECRET_KEY
endpoint = https://TU_ACCOUNT_ID.r2.cloudflarestorage.com
acl = private

[b2]
type = b2
account = TU_APPLICATION_KEY_ID
key = TU_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

Configuración Interactiva

# Iniciar el asistente de configuración
rclone config

# Comandos del menú interactivo
# n) Nuevo remoto
# d) Eliminar remoto
# r) Renombrar remoto
# c) Copiar remoto
# s) Establecer contraseña de configuración
# q) Salir de la configuración

Configuración Google Drive (VPS sin Interfaz Gráfica)

Para configurar Google Drive en un VPS sin interfaz gráfica:

# En tu máquina local con navegador
rclone authorize "drive"

# Copiar el token generado, luego en el VPS
rclone config

# Seleccionar: n (nuevo remoto)
# Nombre: gdrive
# Almacenamiento: drive
# client_id: (dejar vacío o usar el tuyo)
# client_secret: (dejar vacío o usar el tuyo)
# scope: drive
# service_account_file: (dejar vacío)
# Editar configuración avanzada: n
# Usar configuración automática: n
# Pegar el token obtenido en la máquina local

Configuración con Service Account (Google Workspace)

# Crear el directorio para las credenciales
mkdir -p ~/.config/rclone/sa

# Colocar el archivo JSON del service account
# ~/.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

Configuración S3 Compatible (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 = TU_WASABI_KEY
secret_access_key = TU_WASABI_SECRET
region = eu-central-1
endpoint = s3.eu-central-1.wasabisys.com

Comandos Fundamentales

Sintaxis General

rclone [opciones] subcomando <fuente> [<destino>] [indicadores]

Comandos Básicos

Listado y Navegación

# Listar los remotos configurados
rclone listremotes

# Listar el contenido de un remoto
rclone ls gdrive:
rclone ls gdrive:Documentos/

# Listado detallado con tamaño y fecha
rclone lsl gdrive:

# Listado en formato JSON (para scripting)
rclone lsjson gdrive: --recursive

# Mostrar solo directorios
rclone lsd gdrive:

# Árbol completo
rclone tree gdrive:Proyectos/ --level 3

# Buscar archivos
rclone ls gdrive: --include "*.pdf" --recursive

Copia y Movimiento

# Copia local a remoto
rclone copy /ruta/local gdrive:copia/ -P

# Copia remoto a local
rclone copy gdrive:Documentos/ /local/documentos/ -P

# Copia entre dos remotos (lado del servidor si es compatible)
rclone copy gdrive:origen/ s3-aws:destino/ -P

# Movimiento (copia + eliminación de la fuente)
rclone move /local/temp/ gdrive:archivo/ -P

# Copia de un solo archivo
rclone copyto /ruta/local/archivo.txt gdrive:copia/archivo.txt

Sincronización

# Sincronización unidireccional (fuente → destino)
# ATENCIÓN: elimina los archivos en destino no presentes en fuente
rclone sync /datos/local/ gdrive:datos/ -P

# Sincronización con simulación (dry-run)
rclone sync /datos/local/ gdrive:datos/ --dry-run

# Sincronización bidireccional (experimental)
rclone bisync /datos/local/ gdrive:datos/ --resync

Eliminación

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

# Eliminar un directorio y su contenido
rclone purge gdrive:old-backup/

# Eliminar solo los archivos (mantener la estructura)
rclone delete gdrive:temp/

# Eliminar directorios vacíos
rclone rmdirs gdrive: --leave-root

Flags Esenciales

Flag	Descripción
`-P, --progress`	Muestra el progreso
`-v, --verbose`	Modo detallado
`-n, --dry-run`	Simulación sin modificar
`--transfers N`	Número de transferencias paralelas
`--checkers N`	Número de verificadores paralelos
`--bwlimit RATE`	Límite de ancho de banda
`--exclude PATTERN`	Excluir archivos
`--include PATTERN`	Incluir solo estos archivos
`--min-size SIZE`	Tamaño mínimo
`--max-size SIZE`	Tamaño máximo
`--min-age DURATION`	Edad mínima
`--max-age DURATION`	Edad máxima

Operaciones Avanzadas

Filtrado Avanzado

# Archivo de filtros
cat > /etc/rclone/filters.txt << 'EOF'
# Inclusiones
+ **.pdf
+ **.docx
+ Documents/**

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

# Excluir archivos mayores a 1GB
- *
EOF

# Uso del archivo de filtros
rclone sync /data/ gdrive:backup/ --filter-from /etc/rclone/filters.txt -P

Operaciones Server-Side

# Copia server-side (evita descarga local)
rclone copy gdrive:source/ gdrive:destination/ --drive-server-side-across-configs

# Verificar si server-side está disponible
rclone backend features gdrive:

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

Gestión de Archivos Grandes

# Subida fragmentada para archivos > 5GB (S3)
rclone copy largefile.tar gdrive:backup/ \
  --s3-chunk-size 100M \
  --s3-upload-concurrency 4

# Verificación de integridad
rclone check /local/data/ gdrive:data/ --one-way
rclone hashsum MD5 gdrive:file.zip

Operaciones en Metadatos

# Copiar con preservación de marcas de tiempo
rclone copy /local/ gdrive:backup/ --metadata

# Mostrar metadatos
rclone lsjson gdrive:file.txt --metadata

# Modificar metadatos (backends soportados)
rclone settier gdrive:file.txt ARCHIVE

Montaje FUSE y Caché

Montaje Básico

# Crear punto de montaje
sudo mkdir -p /mnt/gdrive
sudo chown $USER:$USER /mnt/gdrive

# Montaje simple
rclone mount gdrive: /mnt/gdrive --daemon

# Montaje con opciones avanzadas
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

Modos de Caché VFS

Modo	Descripción	Uso
`off`	Sin caché	Solo streaming
`minimal`	Caché de escritura	Subidas
`writes`	Caché de escrituras hasta subida	Edición de archivos
`full`	Caché completo lectura/escritura	Uso intensivo, aplicaciones

Configuración de Caché Avanzada

# Caché con backend dedicado
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

Servicio Systemd para Montaje Persistente

# Crear archivo de servicio
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

# Crear usuario dedicado
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

# Activar y iniciar el servicio
sudo systemctl daemon-reload
sudo systemctl enable rclone-gdrive.service
sudo systemctl start rclone-gdrive.service

# Verificar estado
sudo systemctl status rclone-gdrive.service

Desmontaje

# Desmontaje limpio
fusermount -u /mnt/gdrive

# Desmontaje forzado (si está bloqueado)
fusermount -uz /mnt/gdrive

# A través de systemd
sudo systemctl stop rclone-gdrive.service

Cifrado y Seguridad

Configuración de un Remote Cifrado

El backend crypt proporciona un cifrado transparente del lado del cliente.

# Configuración a través del asistente
rclone config

# Seleccionar: n (nuevo remote)
# Nombre: gdrive-crypt
# Almacenamiento: crypt
# remote: gdrive:encrypted/  (remote subyacente)
# filename_encryption: standard
# directory_name_encryption: true
# password: (generado o elegido)
# password2: (sal, opcional pero recomendado)

Configuración resultante:

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

Modes de Cifrado de Nombres

Modo	Descripción	Ejemplo
`off`	Sin cifrado de nombres	`documento.pdf`
`standard`	Cifrado completo	`q4kp2q8fj3m2...`
`obfuscate`	Obfuscación simple	`yqkpzqFfj3m2...`

Uso del Remote Cifrado

# Las operaciones son transparentes
rclone copy /sensitive/data/ gdrive-crypt: -P

# Los archivos aparecen cifrados en el lado del cloud
rclone ls gdrive:encrypted/
# Salida: cifrada e ilegible

# Pero legibles a través del remote crypt
rclone ls gdrive-crypt:
# Salida: nombres originales

Seguridad de la Configuración

# Encriptar el archivo de configuración
rclone config password

# La configuración ahora utiliza una contraseña
# Definir a través de una variable de entorno
export RCLONE_CONFIG_PASS="tu_contraseña_fuerte"

# O utilizar un administrador de secretos
export RCLONE_CONFIG_PASS=$(cat /run/secrets/rclone_pass)

Variables de Entorno Sensibles

# Configuración a través de variables (evita el archivo de configuración)
export RCLONE_CONFIG_GDRIVE_TYPE=drive
export RCLONE_CONFIG_GDRIVE_TOKEN='{"access_token":"..."}'

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

Automatización y Scripting

Script de Backup Completo

#!/usr/bin/env bash
#
# rclone-backup.sh - Script de respaldo automatizado
# Uso: ./rclone-backup.sh [daily|weekly|monthly]
#

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

# Configuración
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"

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

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

# Funciones
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" "Limpieza realizada, bloqueo liberado"
}

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

acquire_lock() {
    exec 200>"${LOCK_FILE}"
    if ! flock -n 200; then
        log "ERROR" "Otra instancia está en ejecución"
        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" "Iniciando respaldo ${backup_type} hacia ${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}Respaldo ${backup_type} completado exitosamente${NC}"
    else
        log "ERROR" "${RED}Respaldo ${backup_type} fallido (código: ${exit_code})${NC}"
    fi
    
    return $exit_code
}

cleanup_old_backups() {
    log "INFO" "Limpiando respaldos de más de ${RETENTION_DAYS} días"
    
    rclone delete "${REMOTE_DEST}" \
        --config "${CONFIG_FILE}" \
        --min-age "${RETENTION_DAYS}d" \
        --rmdirs \
        --log-file "${LOG_FILE}" \
        --log-level INFO
        
    log "INFO" "Limpieza completada"
}

send_notification() {
    local status="$1"
    local message="$2"
    
    # Ejemplo 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}"
    
    # Inicialización
    mkdir -p "${LOG_DIR}"
    trap cleanup EXIT
    
    log "INFO" "=== Iniciando ${SCRIPT_NAME} (${backup_type}) ==="
    
    check_dependencies
    acquire_lock
    
    # Ejecución
    if perform_backup "${backup_type}"; then
        cleanup_old_backups
        send_notification "ÉXITO" "Respaldo ${backup_type} completado"
    else
        send_notification "FALLO" "Respaldo ${backup_type} fallido"
        exit 1
    fi
    
    log "INFO" "=== Fin ${SCRIPT_NAME} ==="
}

main "$@"

Configuración Cron

# Editar la crontab
crontab -e

# Respaldos automatizados
# Diario a las 2:00
0 2 * * * /usr/local/bin/rclone-backup.sh daily >> /var/log/rclone/cron.log 2>&1

# Semanal los domingos a las 3:00
0 3 * * 0 /usr/local/bin/rclone-backup.sh weekly >> /var/log/rclone/cron.log 2>&1

# Mensual el 1ro de cada mes a las 4:00
0 4 1 * * /usr/local/bin/rclone-backup.sh monthly >> /var/log/rclone/cron.log 2>&1

# Limpieza de caché diaria a las 5:00
0 5 * * * /usr/local/bin/rclone cleanup gdrive: --config /home/user/.config/rclone/rclone.conf

Timer Systemd (Alternativa a Cron)

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

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

# Temporizador
sudo tee /etc/systemd/system/rclone-backup.timer << 'EOF'
[Unit]
Description=Ejecutar Respaldo Rclone Diariamente

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

[Install]
WantedBy=timers.target
EOF

# Activación
sudo systemctl daemon-reload
sudo systemctl enable --now rclone-backup.timer

# Verificación
systemctl list-timers | grep rclone

Optimización de Rendimiento

Ajuste de Transferencias

# Configuración de alto rendimiento
rclone sync /source/ remote:dest/ \
  --transfers 16 \
  --checkers 32 \
  --buffer-size 512M \
  --drive-chunk-size 256M \
  --fast-list \
  --tpslimit 10 \
  --tpslimit-burst 20 \
  -P

Parámetros por Proveedor

Google Drive

# Optimización 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

# Optimización 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

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

Benchmarking

# Prueba de velocidad
rclone test makefile /tmp/rclone_test_file --size 1G

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

# Medir las transferencias
time rclone copy /test/1GB.bin remote:test/ -P --stats 1s

Gestión de Ancho de Banda

# Límite fijo
--bwlimit 10M

# Límite variable según la hora
--bwlimit "08:00,512K 18:00,10M 23:00,off"

# Límite separado para subida/bajada
--bwlimit "10M:5M"  # 10M subida, 5M bajada

Monitoreo y Registro

Configuración de Registros

# Niveaux de log
--log-level DEBUG    # Very verbose
--log-level INFO     # Standard
--log-level NOTICE   # Important only
--log-level ERROR    # Errors only

# Sortie fichier
--log-file /var/log/rclone/operation.log

# Format JSON (pour parsing)
--use-json-log

Estadísticas Detalladas

# Estadísticas periódicas
rclone sync /source/ remote:dest/ \
  --stats 30s \
  --stats-file-name-length 0 \
  --stats-log-level NOTICE \
  --stats-one-line \
  -P

Monitoreo con Prometheus

# Activar métricas
rclone serve restic remote:path/ \
  --rc \
  --rc-addr :5572 \
  --rc-enable-metrics

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

Script de Monitoreo

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

check_remote
check_mount

Configuración de 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

Resolución de Problemas Avanzada

Problemas Comunes y Soluciones

Error 403 - Límite de Tasa (Google Drive)

# Síntoma
ERROR : Failed to copy: googleapi: Error 403: User Rate Limit Exceeded

# Soluciones
# 1. Reducir la paralelización
--transfers 2 --checkers 4

# 2. Agregar retrasos
--tpslimit 2 --tpslimit-burst 0

# 3. Usar su propio Client ID
# En rclone config, definir client_id y client_secret personalizados

Error de Token Expirado

# Regenerar el token
rclone config reconnect gdrive:

# O manualmente
rclone authorize drive

Montaje FUSE - Permiso Denegado

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

# Si está comentado, descomentar
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

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

Archivos Faltantes después de la Sincronización

# Siempre hacer una simulación primero
rclone sync source: dest: --dry-run

# Verificar exclusiones
rclone ls source: --include "*.ext" -v

# Usar check para comparar
rclone check source: dest: --one-way --combined report.txt

Diagnóstico Avanzado

# Modo debug completo
rclone copy source: dest: -vv --dump headers --dump bodies

# Probar la conexión
rclone lsd remote: --timeout 30s

# Verificar la configuración
rclone config show remote

# Listar los backends y features
rclone backend features remote:

# Prueba de rendimiento de red
rclone test bandwidth remote: --time 30s

Recuperación de Errores

# Reanudar una transferencia interrumpida
rclone copy source: dest: \
  --retries 10 \
  --retries-sleep 30s \
  --low-level-retries 20 \
  --ignore-errors

# Procesar archivos con errores por separado
rclone copy source: dest: \
  --error-on-no-transfer \
  2>&1 | tee transfer.log

# Reintentar solo los errores
grep "ERROR" transfer.log | while read line; do
    # Extraer y volver a procesar
done

Casos de Uso en Producción

Backup Completo del Servidor Web

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

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

# Crear el directorio de 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 archivos web
tar -czf "${BACKUP_DIR}/${DATE}/www.tar.gz" -C /var/www .

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

# 4. Subir a la nube
rclone copy "${BACKUP_DIR}/${DATE}" "${REMOTE}/${DATE}/" \
    --transfers 4 \
    --b2-hard-delete \
    -P

# 5. Limpieza local (mantener 7 días)
find "${BACKUP_DIR}" -type d -mtime +7 -exec rm -rf {} +

# 6. Limpieza remota (mantener 30 días)
rclone delete "${REMOTE}" --min-age 30d --rmdirs

Sincronización Multi-Cloud

#!/usr/bin/env bash
# multi-cloud-sync.sh - Replicación en varios proveedores

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

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

Servidor Multimedia con Rclone Mount

# Configuración para 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

Archivado con Versionado

# Sync con conservación de versiones
rclone sync /data/ remote:current/ \
    --backup-dir remote:versions/$(date +%Y%m%d) \
    --suffix .bak \
    --suffix-keep-extension \
    -P

# Restaurar una versión
rclone copy remote:versions/20240115/file.txt.bak /restore/file.txt

Recursos y Referencias

Documentación Oficial

Site oficial: https://rclone.org/
Documentación: https://rclone.org/docs/
Foro: https://forum.rclone.org/
GitHub: https://github.com/rclone/rclone

Comandos Útiles Rápidos

# Verificar espacio utilizado
rclone size remote:path/

# Limpiar archivos temporales
rclone cleanup remote:

# Montar con interfaz web
rclone rcd --rc-web-gui --rc-addr :5572

# Exportar la config (sin secretos)
rclone config dump | jq 'del(..|.token?, .password?, .secret_access_key?)'

Rclone: Guía experta para la sincronización en la nube en VPS Linux