Rclone desde cero para dominar copias, cifrado y automatización en la nube

Rclone se ha convertido en la navaja suiza del almacenamiento en la nube para cualquiera que quiera dejar de pelearse con clientes oficiales mediocres, scripts caseros y limitaciones absurdas de cada proveedor. Con un único binario y una sintaxis muy parecida a rsync, puedes gestionar copias, sincronizaciones, montajes y cifrado sobre más de 70 servicios: Google Drive, OneDrive, Dropbox, S3, Backblaze B2, Wasabi, pCloud, MEGA, Proton Drive, Nextcloud, WebDAV, SFTP… y un largo etcétera.

La gracia de Rclone es que no se limita a “copiar archivos a la nube”: entiende cada backend, exprime APIs para conseguir más velocidad, permite cifrado transparente, montaje vía FUSE, programación de backups y operaciones entre nubes sin pasar por tu disco. Desde un portátil con macOS, una Raspberry Pi con un disco pequeño, hasta un servidor de producción con varios teras, puedes montar una estrategia de respaldo robusta, cifrada y automatizada si conoces bien sus piezas.

Qué es Rclone y por qué interesa más que rsync para la nube

Rclone es una herramienta de línea de comandos y código abierto pensada específicamente para tratar con almacenamiento remoto y cloud. A diferencia de rsync, que está orientado a ficheros locales o remotos vía SSH, Rclone entiende APIs de servicios como Google Drive, S3 o Dropbox, gestiona sus límites, cuotas y peculiaridades, y ofrece comandos de alto nivel para listar, copiar, sincronizar, montar y servir contenido.

Suele describirse como “rsync para la nube”, pero en realidad va bastante más allá: soporta más de 70 proveedores, integra capas de cifrado (backend crypt), un sistema de archivos virtual (VFS) para montajes estables, un módulo chunker para trocear ficheros grandes y una capa de abstracción de backends que hace que la misma orden funcione igual sobre Google Drive, S3, B2 o un SFTP.

Frente a rsync, Rclone brilla en varios puntos: puede aprovechar transferencias multihilo (--multi-thread-streams y parámetros de --transfers / --checkers) y suele alcanzar velocidades varias veces superiores cuando el cuello de botella son las APIs cloud. Además, entiende conceptos como papelera, versiones, cuotas diarias o límites de peticiones, y da flags específicos para exprimir cada proveedor sin romper nada.

A nivel de arquitectura interna, es un único binario que agrupa un núcleo (Rclone Core) y varias capas: VFS para montajes y caché, Crypt para cifrado del lado del cliente, Chunker para fragmentar archivos grandes y un conjunto de backends que implementan la comunicación concreta con cada servicio (S3/R2, Google Drive, B2, WebDAV, SFTP, etc.). Esa modularidad hace que puedas combinar, por ejemplo, un remoto S3 con una capa crypt y, encima, montarlo vía FUSE.

Servicios de almacenamiento soportados y casos típicos

El catálogo de servicios soportados por Rclone es enorme, pero conviene hacerse una idea rápida de los más habituales para organizar bien los backups.

Para usuarios “de a pie” suelen destacar:

Google Drive / Google Photos: para cuentas personales y de empresa, incluidas unidades compartidas (Team Drives).
Microsoft OneDrive y SharePoint: tanto personal como empresarial.
Dropbox, Box, MEGA, pCloud, Proton Drive: muy utilizados para backups personales, fotos, documentos y pequeños repositorios.

En entornos profesionales y de desarrollo lo normal es tirar de almacenamiento de objetos:

Amazon S3 y compatibles (MinIO, Wasabi, Ceph, Oracle, etc.) para buckets de backups, contenido estático y archivado.
Google Cloud Storage, Azure Blob y Cloudflare R2 si ya se está en esos ecosistemas.
Backblaze B2 como alternativa barata para grandes volúmenes de datos fríos.

Para autoalojados y servidores caseros, Rclone encaja muy bien con:

SFTP/FTP contra otros servidores.
WebDAV para Nextcloud / ownCloud.
SMB/CIFS y HTTP cuando hay que integrar NAS y servidores web.

Una idea muy usada es combinar varias nubes con “Union”: creas un remoto union: que agrupa, por ejemplo, gdrive:, onedrive: y dropbox:, y operas como si fuera un solo sistema de archivos gigante. Muy útil para aprovechar cuentas gratuitas o repartir backups entre distintos proveedores.

Requisitos, instalación básica y actualización

Rclone es ligero pero no mágico: en una VPS pequeña o en una Raspberry con poca RAM conviene conocer sus requisitos para no ahogarla con montajes agresivos o muchas transferencias paralelas.

A nivel de hardware y sistema, como referencia razonable:

RAM mínima: 512 MB (2 GB o más para montajes con caché VFS agresiva).
CPU: 1 vCPU basta, pero con 2+ notarás mejor las transferencias paralelas.
Almacenamiento: el binario ocupa poco, pero la caché puede necesitar 1 GB o más según los parámetros.
Kernel: a partir de 3.10 funciona; con kernels modernos (5.4+) y FUSE3 los montajes van más finos.

En cuanto a instalación, tienes varias vías dependiendo de lo que prefieras: comodidad, control de versiones o reproducibilidad.

Script oficial (Linux, recomendado para ir al día):

curl -fsSL https://rclone.org/install.sh | sudo bash
rclone version

Instalación manual con paquete .deb en Debian/Ubuntu:

wget https://downloads.rclone.org/v1.71.0/rclone-v1.71.0-linux-amd64.deb
sudo dpkg -i rclone-v1.71.0-linux-amd64.deb
sudo apt -f install   # si pide dependencias

En macOS, lo más cómodo es Homebrew:

brew install rclone
rclone version --check

En Windows puedes optar por instalador, winget o Chocolatey:

Descargando el ZIP y dejando rclone.exe en C:\rclone\ y añadiéndolo al Path.
Con winget:
winget install Rclone.Rclone
Con Chocolatey:
choco install rclone choco install winfsp (para montar unidades)

En todos los casos, actualizar es tan simple como ejecutar:

rclone selfupdate

Primeros pasos: concepto de “remoto” y configuración interactiva

La unidad básica en Rclone es el “remote”: una entrada de configuración que describe cómo conectarse a un servicio concreto. Por ejemplo, gdrive: para Google Drive personal, s3-backup: para un bucket S3 o nombre_en: para una carpeta cifrada.

Todo se gestiona desde el asistente rclone config, que guarda la configuración por defecto en ~/.config/rclone/rclone.conf en formato INI. Ese archivo es oro: copia de seguridad obligatoria (y mejor aún, cifrarlo).

Ejemplo rápido: crear un remote de Google Drive en un equipo con navegador:

rclone config
# n) New remote
# name> gdrive
# Storage> drive
# client_id>      (vacío para usar el cliente por defecto de rclone)
# client_secret> (vacío)
# scope> 1       (acceso completo)
# service_account_file>  (vacío)
# Edit advanced config? n
# Use auto config? y   (abre el navegador, inicias sesión y aceptas permisos)

En un servidor sin entorno gráfico la película cambia un poco. Cuando pregunte si quieres usar configuración automática, eliges n, te mostrará un comando del tipo:

rclone authorize "drive"

Ese comando lo ejecutas en tu equipo de escritorio, donde sí tienes navegador, autorizas la cuenta y copias el token JSON resultante para pegarlo en el servidor cuando te lo pida (config_token> {...}). Con eso tienes un remote funcional aunque el servidor sea headless.

Un caso real: unidad compartida de Google Drive ilimitada y cifrada

Durante un tiempo circularon enlaces para crear unidades compartidas “ilimitadas” en Google Drive asociadas a universidades y similares. Quien aprovechó el truco suele usarlas como “pozo” donde mandar grandes volúmenes de datos multimedia desde su servidor o Raspberry.

El flujo típico para usar una de esas unidades con Rclone es:

Obtener el ID de la unidad compartida entrando por el navegador y copiando el último tramo de la URL (algo como 0AKXXD2qTbW50Uk9PVA).
Crear un remote de Google Drive normal (Storage> drive) y, en el campo root_folder_id>, pegar ese identificador.
Cuando Rclone pregunte si debe tratarlo como Team Drive, responder que sí y escoger la unidad en cuestión.

Una vez tienes acceso a esa unidad, el siguiente paso lógico es cifrarla, porque no sabes realmente quién más puede ver esos datos en el otro extremo. Aquí entra el backend crypt.

Crear una capa cifrada sobre esa unidad compartida sería algo así:

De nuevo rclone config → New remote → nombre por ejemplo nombre_en.
Elegir Storage> crypt.
En remote> poner nombre: o nombre:carpeta/, que es el remote anterior (el de Drive) apuntando a una carpeta.
Escoger filename_encryption = standard y directory_name_encryption = true para que nombres de ficheros y directorios también vayan ofuscados.
Generar una o dos contraseñas (password y salt) fuertes, ya sea manualmente o con el generador integrado.

A partir de ahí, todo lo que subas a nombre_en: estará cifrado y en la web de Google Drive verás nombres raros e ilegibles. Solo Rclone con esas claves puede traducirlos de vuelta.

Comandos básicos: listar, copiar, sincronizar y eliminar

La sintaxis general de Rclone es bastante coherente: rclone <subcomando> origen destino [flags]. El truco está en interiorizar unos pocos comandos y unas cuantas opciones clave.

Para explorar remotos y contenidos tienes:

rclone listremotes: muestra todos los remotos configurados.
rclone ls remote:: lista archivos con tamaño.
rclone lsd remote:: solo directorios/buckets.
rclone tree remote: o rclone tree remote:carpeta -d para ver la estructura en forma de árbol.
rclone ncdu remote:: interfaz tipo ncdu para ver tamaño de todo sin perderte.

Copiar sin borrar nada en destino se hace con copy:

# Local → nube
rclone copy /home/usuario/fotos drive:fotos/verano -P

# Nube → local
rclone copy gdrive:Documentos/ ~/Documentos/ -P

# Nube → nube (server-side cuando el backend lo permite)
rclone copy gdrive:proyecto/ s3-backup:proyecto/ -P

Sincronizar (hacer espejo) se hace con sync, y aquí hay que ir con cuidado, porque elimina del destino lo que ya no está en origen:

# Sincronización unidireccional
rclone sync /srv/data onedrive:data -P

# Simulación sin tocar nada
rclone sync /srv/data onedrive:data --dry-run

Para operaciones de limpieza hay varias órdenes útiles:

rclone delete remote:carpeta: borra archivos de una ruta, deja directorios.
rclone purge remote:carpeta: borra ruta y todo su contenido.
rclone rmdirs remote: --leave-root: borra directorios vacíos.
rclone cleanup drive:: vacía la papelera (por ejemplo, en Google Drive).

Los flags transversales más importantes que usarás todo el rato son:

-P o --progress para ver el avance.
-v, -vv y --log-level para subir verbosidad.
--transfers N y --checkers N para controlar el paralelismo.
--bwlimit para limitar el ancho de banda, incluso por tramos horarios ("08:00,1M 18:00,off").
--include, --exclude y --filter-from para afinar qué se copia.

Montar la nube como si fuera un disco más (FUSE / VFS)

Una de las funciones estrella de Rclone es el montaje de remotos como sistemas de archivos. Es tremendamente útil para Plex/Jellyfin, para trabajar directamente con documentos que tienes en Drive o para exponer un bucket de S3 a una aplicación que no sabe hablar S3.

En Linux necesitas FUSE3 instalado y permitir allow_other en /etc/fuse.conf para que otros usuarios puedan acceder al montaje. En Windows se apoya en WinFsp.

Ejemplo de montaje en Linux:

mkdir -p /mnt/gdrive
rclone mount gdrive: /mnt/gdrive \
  --daemon \
  --allow-other \
  --vfs-cache-mode full \
  --vfs-cache-max-size 20G \
  --dir-cache-time 48h \
  --log-file /var/log/rclone/gdrive.log \
  --log-level INFO

El parámetro --vfs-cache-mode marca la diferencia de comportamiento:

off: sin caché; solo para lecturas sencillas.
minimal: lo justo para que la cosa funcione.
writes: cachea escrituras hasta que se suben.
full: cachea lecturas y escrituras; ideal para multimedia, ofimática, etc., a costa de más disco.

Si quieres que el montaje sobreviva a reinicios, lo normal es crear un servicio systemd específico. Un patrón muy usado es un servicio parametrizado rclone-remote@.service que monta cualquier remoto en /cloud/<nombre> y luego activarlo con:

sudo systemctl enable --now rclone-gdrive.service

En Windows, montar OneDrive o Drive como letra X:

rclone mount onedrive: X: --vfs-cache-mode full

Cifrado avanzado con el backend crypt y seguridad de la configuración

Si algo conviene tomarse en serio con Rclone es la seguridad: el archivo rclone.conf contiene tokens OAuth, claves de acceso S3, contraseñas cifradas… y cualquiera que lo copie puede, en la práctica, acceder a tus nubes.

El backend crypt permite cifrar archivos, nombres de fichero y nombres de directorio de forma transparente. Al configurarlo, eliges:

remote: el backend subyacente (por ejemplo gdrive:encrypted).
filename_encryption: off, standard u obfuscate.
directory_name_encryption: true/false.
password y password2 (salt opcional).

La configuración resultante se ve así (resumida):

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

Rclone también permite cifrar su propio archivo de configuración, de modo que aunque alguien lo robe, no pueda leer los secretos sin la contraseña maestra:

rclone config password
# te pedirá una contraseña y a partir de ese momento
# Rclone te la pedirá en cada ejecución

Para automatizar scripts sin tener que teclear la contraseña en cron o systemd, puedes usar la variable de entorno RCLONE_CONFIG_PASS o un pequeño script que la exporte leyendo de un fichero protegido (propietario root, permisos 600) o de un gestor de secretos:

export RCLONE_CONFIG_PASS="contraseña_muy_larga"
rclone lsd gdrive: --ask-password=false

Optimización de rendimiento: archivos grandes, muchos archivos pequeños y límites

Por defecto Rclone funciona razonablemente bien, pero con unos pocos ajustes se puede exprimir mucho más, sobre todo al mover teras de datos o millones de ficheros pequeños.

Para archivos grandes (imágenes de VM, backups comprimidos, vídeos largos) interesa subir el tamaño de los fragmentos y el paralelismo:

rclone copy backup.tar.gz gdrive:backups \
  --drive-chunk-size=256M \
  --transfers=8 \
  --progress

Para muchos archivos pequeños (fotos, logs, sitios estáticos) importa más la cantidad de checkers y transfers y usar --fast-list si la RAM lo permite:

rclone copy fotos/ onedrive:fotos/ \
  --transfers=32 \
  --checkers=16 \
  --fast-list \
  --progress

Cuando hay que respetar límites de ancho de banda o de API (como el famoso tope de 750 GB/día de subida a Google Drive o límites de peticiones por segundo), tienes herramientas como:

--bwlimit "08:00,1M 18:00,off" para ir despacio en horario laboral y abrir el grifo por la noche.
--tpslimit y --tpslimit-burst para contener los errores 403 de “rate limit exceeded”.

Automatizar copias de seguridad: cron, systemd y scripts completos

Hacer un rclone copy a mano está bien para pruebas, pero lo interesante es dejar programadas copias recurrentes, con logs, rotación de versiones y notificaciones cuando algo falla.

En Linux, lo más sencillo es tirar de cron. Por ejemplo, para ejecutar cada noche a las 2:00 una sincronización de documentos a Google Drive:

crontab -e

0 2 * * * /usr/bin/rclone sync /home/user/documents gdrive:backup \
  --log-file=/var/log/rclone-backup.log --log-level=INFO

Cuando quieres algo más serio, con bloqueo, retención y notificaciones, compensa tener un script dedicado. Un esquema típico incluye:

Variables con origen, destino, límites de ancho de banda y días de retención.
Uso de flock o un lockfile para evitar instancias simultáneas.
Uso de --backup-dir y sufijos .bak para versionado.
Limpieza de backups antiguos con --min-age y --rmdirs.
Envío opcional de avisos a Slack/Discord/Email cuando falla.

Si prefieres systemd a cron, puedes definir un rclone-backup.service que ejecute el script y un rclone-backup.timer que marque la cadencia (por ejemplo, a las 2:00 con un pequeño aleatorio para no coincidir siempre).

Interfaces gráficas y uso desde Android

No todo el mundo está cómodo con la línea de comandos, y para ciertas tareas (explorar contenido, comprobar que algo está donde debe) una GUI puede ahorrar tiempo.

Rclone trae una web GUI oficial (experimental, pero funcional) que se levanta con:

rclone rcd --rc-web-gui --rc-user=admin --rc-pass=password
# luego abres http://localhost:5572 en el navegador

Además existen GUIs de terceros como Rclone Browser o forks modernos tipo “Rclone UI”, que permiten arrastrar y soltar, programar tareas desde una ventana y ver el progreso en bonito. En Linux puedes instalarlos desde repositorios o tirar de AppImage; también hay imágenes Docker que exponen la interfaz en un puerto HTTP.

En Android, la jugada consiste en reutilizar tu archivo rclone.conf: muchas apps cliente de Rclone te permiten importarlo (o colocarlo en una carpeta rclone/ en la memoria interna) y, a partir de ahí, accedes a todos los remotos definidos igual que en el servidor. Ideal para ver contenido multimedia cifrado en streaming desde el móvil.

Resolución de problemas frecuentes y diagnóstico

Trabajar con APIs cloud implica convivir con errores de autenticación y límites de servicio. Saber leer el mensaje y tener a mano el flag adecuado ahorra muchos disgustos.

Errores de autenticación (“failed to make oauth client” o tokens caducados) suelen arreglarse con:

rclone config reconnect remote: para renovar credenciales.
En casos extremos, borrar el remote y configurarlo desde cero.

Errores 403 de límite de tasa, sobre todo en Google Drive, se reducen bajando la agresividad:

rclone copy source: dest: \
  --transfers 2 --checkers 4 \
  --tpslimit 2 --tpslimit-burst 0

Si un montaje FUSE devuelve “permiso denegado”, revisa:

Que en /etc/fuse.conf la opción user_allow_other esté descomentada.
Que montas con --allow-other y el usuario adecuado.

Cuando sospechas que faltan archivos tras un sync, lo sano es:

Haber probado antes con --dry-run.
Usar rclone check origen destino --one-way y revisar el informe combinado.
Comprobar patrones de --exclude / --include que puedan haber filtrado más de la cuenta.

Para depurar fino, -vv y los flags --dump headers / --dump bodies muestran las peticiones HTTP que hace Rclone, y rclone backend features remote: o rclone test ayudan a ver qué soporta exactamente cada backend y cómo rinde la conexión.

Al final, Rclone permite montar desde un backup modesto de tu carpeta de Documentos en Dropbox hasta un sistema de replicación multi-nube con cifrado, montajes persistentes y monitorización con Prometheus. La curva de aprendizaje puede intimidar un poco al principio, pero a medida que dominas rclone config, copy, sync, mount y crypt, el resto es ir añadiendo capas: automatización con cron o systemd, filtrado avanzado, logs detallados y pequeños ajustes de rendimiento para adaptarlo a tu red y a tus nubes. Una vez que encajas todas esas piezas, deja de ser “otra herramienta de consola” y se convierte en el pilar silencioso que mantiene tus datos a salvo, cifrados y redundados sin que tengas que pensar en ello todos los días.