rclone: copia, sincroniza y migra archivos entre nubes

Qué es rclone, y para qué es bueno

rclone es un programa de línea de comandos gratuito y de código abierto para copiar, sincronizar y mover archivos entre tu disco y el almacenamiento en la nube, o entre dos nubes. A menudo se le llama "rsync para el almacenamiento en la nube": un único binario, escrito en Go, que habla con más de 70 backends de almacenamiento, incluidos Amazon S3 y todos los servicios compatibles con S3, Google Drive, OneDrive, Dropbox, Azure Blob, Backblaze B2, SFTP y WebDAV.

La idea que lo hace útil es el remote. Describes cada cuenta de almacenamiento una vez, le das un nombre corto como s3old o gdrive, y desde ese momento todos los comandos funcionan igual contra cualquiera de ellas: rclone copy ./backups s3old:my-bucket/backups se lee exactamente igual que rclone copy gdrive:Photos ./photos. Una ruta es remote:ruta, y en el almacenamiento de objetos la primera parte de la ruta es el bucket.

En la práctica, rclone se usa para cuatro tareas: copias de seguridad nocturnas al almacenamiento de objetos, migraciones puntuales de un proveedor a otro, extraer archivos de Google Drive u otras nubes de consumo, y montar un bucket como si fuera una carpeta local. Compara los archivos antes de transferirlos, así que una segunda ejecución solo envía lo que cambió, reintenta las operaciones que fallan, y puede cifrar todo en el cliente antes de que salga de la máquina.

Lo que no es: un cliente de sincronización bidireccional como la app de Dropbox (existe el comando más reciente bisync, pero es una herramienta deliberada, no un servicio en segundo plano), ni un programa de copia de seguridad con snapshots deduplicados. Para copias de seguridad versionadas y deduplicadas, herramientas como restic usan rclone como transporte por debajo.

Instalar rclone en Linux, macOS y Windows

rclone es un único ejecutable sin dependencias, así que instalarlo es sobre todo cuestión de de dónde viene el binario. Los paquetes de la distro (apt install rclone) suelen ir varias versiones por detrás; para cualquier cosa que hable con las API actuales de la nube, prefiere la build oficial.

Linux y macOS: el script de instalación del proyecto descarga la última versión para tu plataforma y la coloca en /usr/bin (o /usr/local/bin en macOS). En macOS, Homebrew también funciona, pero su build no puede ejecutar rclone mount; si necesitas montar, usa el binario oficial junto con macFUSE.

Windows: winget install Rclone.Rclone es la forma más rápida; Scoop y Chocolatey también lo tienen. Sin un gestor de paquetes, descarga el zip de rclone.org/downloads, descomprime rclone.exe en una carpeta como C:\rclone, y añade esa carpeta a tu PATH. Ejecútalo desde PowerShell o cmd; no tiene instalador ni interfaz gráfica propia. Para usar rclone mount en Windows también necesitas WinFsp.

Comprueba el resultado con rclone version. Un binario instalado desde la build oficial puede actualizarse después con rclone selfupdate; uno empaquetado debería actualizarse mediante su gestor de paquetes.

# Linux / macOS: official install script
sudo -v ; curl https://rclone.org/install.sh | sudo bash

# macOS with Homebrew (no rclone mount support)
brew install rclone

# Windows (PowerShell)
winget install Rclone.Rclone

# everywhere
rclone version

rclone config y el concepto de remote

rclone config inicia un asistente interactivo: n para un remote nuevo, un nombre, el tipo de almacenamiento, y después las preguntas que necesite ese tipo (claves, endpoint, región, o un inicio de sesión en el navegador para Google Drive y otros servicios OAuth). Las respuestas se escriben en un archivo INI sencillo, rclone.conf. rclone config file imprime dónde está: normalmente ~/.config/rclone/rclone.conf en Linux y macOS, y %APPDATA%\rclone\rclone.conf en Windows.

Como es un archivo de texto normal, también puedes escribir los remotes a mano, copiar el archivo a un servidor, o guardarlo en tus herramientas de secretos. Trátalo como un secreto: contiene claves de acceso y tokens OAuth. Los secretos que rclone escribe por sí mismo solo están ofuscados, no cifrados; rclone config ofrece una contraseña de configuración si el archivo tiene que estar en una máquina compartida.

Cada [sección] es un remote. Luego lo referencias como nombre: seguido de una ruta. Con el almacenamiento de objetos, nombre: sola significa la cuenta, nombre:bucket un bucket y nombre:bucket/prefijo una "carpeta" dentro de él. rclone lsd nombre: es la prueba más rápida de que las claves y el endpoint funcionan.

El archivo no es la única vía. Cada opción puede venir de una variable de entorno llamada RCLONE_CONFIG_<REMOTE>_<OPTION>, lo que viene bien en contenedores y CI, donde prefieres inyectar secretos en lugar de distribuir un archivo de configuración.

Dos remotes en rclone.conf: AWS S3 y Google Drive

[s3old]
type = s3
provider = AWS
access_key_id = AKIA...
secret_access_key = ...
region = eu-central-1

[gdrive]
type = drive
scope = drive.readonly
token = {"access_token":"...","expiry":"..."}

# the same S3 remote from environment variables instead
# RCLONE_CONFIG_S3OLD_TYPE=s3
# RCLONE_CONFIG_S3OLD_PROVIDER=AWS
# RCLONE_CONFIG_S3OLD_ACCESS_KEY_ID=AKIA...

Los comandos principales, y copy frente a sync

rclone copy copia archivos del origen al destino y se salta los que ya son idénticos ahí. Nunca borra nada en el destino, lo que lo convierte en la opción segura por defecto.

rclone sync hace que el destino sea idéntico al origen, y eso incluye borrar los archivos del destino que no están en el origen. Apúntalo a la carpeta equivocada, o intercambia origen y destino, y borrará datos, y el almacenamiento de objetos no tiene papelera de reciclaje salvo que el versionado esté activado. Ejecuta siempre un comando sync nuevo primero con --dry-run, lee lo que borraría, y solo entonces ejecútalo de verdad. --max-delete 100 es un buen cinturón de seguridad para los trabajos programados: la ejecución se detiene en lugar de borrar más de esa cantidad.

rclone move copia y luego borra cada archivo del origen en cuanto llega; añade --delete-empty-src-dirs para limpiar también las carpetas. rclone check compara el origen y el destino e informa de las diferencias sin cambiar nada (más sobre esto más abajo).

Para mirar alrededor: rclone lsd remote: lista buckets o directorios, rclone ls remote:bucket lista cada objeto con su tamaño, rclone lsf da una lista fácil de usar en scripts, y rclone size remote:bucket imprime el número de objetos y los bytes totales, que es el primer número que hay que comparar tras una migración. rclone tree y rclone ncdu ayudan cuando necesitas ver dónde se va el espacio.

Hay un comportamiento con el que casi todo el mundo tropieza: igual que rsync con una barra final, rclone copia el contenido del directorio de origen, no el directorio mismo. rclone copy ./photos remote:bucket pone los archivos en la raíz del bucket; escribe remote:bucket/photos si quieres la carpeta. Para copiar o renombrar un solo archivo, usa copyto o moveto.

rclone lsd s3old:                       # buckets this key can see
rclone ls s3old:media/2026/             # objects and sizes
rclone size s3old:media                 # count + total bytes

rclone copy ./site s3old:media/site -P  # upload, never deletes
rclone sync ./site s3old:media/site --dry-run   # preview first
rclone sync ./site s3old:media/site -P  # then for real

rclone move ./outbox s3old:media/inbox --delete-empty-src-dirs
rclone copyto ./logo.png s3old:media/img/logo-v2.png

Flags que importan: dry runs, velocidad y ancho de banda

--dry-run (-n) muestra qué se copiaría o borraría sin tocar nada. --interactive (-i) pregunta antes de cada acción destructiva, útil para una limpieza puntual.

--progress (-P) muestra el rendimiento en vivo, los recuentos y el ETA. Para trabajos que corren sin supervisión, usa en su lugar --log-file rclone.log --log-level INFO, para poder leer después qué pasó.

--transfers (4 por defecto) es cuántos archivos se mueven en paralelo, y --checkers (8 por defecto) cuántas comparaciones corren en paralelo. El almacenamiento de objetos es lento por petición y rápido en conjunto, así que muchos archivos pequeños se benefician de --transfers 16 a 32 y --checkers 32 o más. Sube estos valores poco a poco: los proveedores limitan la tasa, y demasiadas peticiones en paralelo se convierten en reintentos.

--bwlimit limita el ancho de banda, por ejemplo --bwlimit 20M (bytes por segundo, es decir 20 MiB/s), o un horario como --bwlimit "08:00,10M 19:00,off" que limita en horario de oficina y va libre por la noche.

--s3-chunk-size (5 MiB por defecto) fija el tamaño de parte de las subidas multiparte, y --s3-upload-concurrency (4 por defecto) cuántas partes de un mismo archivo se suben a la vez. Para archivos grandes en un enlace rápido, --s3-chunk-size 64M reduce bastante el número de peticiones. El uso de memoria crece con transfers × upload-concurrency × chunk-size, así que un chunk de 64 MiB con 16 transfers puede ocupar varios gigabytes de RAM. S3 permite como máximo 10.000 partes por objeto; rclone sube el tamaño del chunk por sí mismo cuando conoce el tamaño de un archivo, pero no en las subidas en streaming (rcat).

Para buckets con millones de objetos, --fast-list lista todo el bucket con menos peticiones a costa de memoria, y --checksum o --size-only evitan que rclone lea la fecha de modificación de cada objeto, que en S3 cuesta una petición extra por objeto.

rclone copy /srv/backups s3old:backups/db \
  --transfers 16 --checkers 32 \
  --s3-chunk-size 64M --s3-upload-concurrency 4 \
  --bwlimit "08:00,20M 20:00,off" \
  --log-file /var/log/rclone-backup.log --log-level INFO

Configurar un remote compatible con S3, con CDN.com.tr como ejemplo

Cualquier servicio que implemente la API de S3 usa el tipo s3 de rclone. Los campos que cambian de un proveedor a otro son provider, endpoint y, a veces, region. Usa el proveedor con nombre cuando rclone tenga uno (AWS, Cloudflare, Minio, Wasabi y otros); eso activa las peculiaridades de ese servicio. Para un servicio que rclone no tiene listado, usa provider = Other.

El object storage de CDN.com.tr es compatible con S3, y rclone es uno de los clientes que funcionan con él tal cual. El endpoint es https://s3.cdn.com.tr; las herramientas que piden una región pueden dejarse en el valor por defecto, y el servicio espera direccionamiento con estilo de ruta (path-style), que es el valor por defecto de rclone para provider = Other. Los buckets y las claves de acceso se crean en el panel (la pestaña Access Keys) o con cdnctl. La clave secreta se muestra solo una vez, al crearla, así que cópiala directamente en la configuración de rclone o en tu gestor de secretos.

Lo mejor es limitar el alcance de las claves al bucket al que sirven. Una clave así no puede crear buckets, así que dile a rclone que no lo intente: no_check_bucket = true se salta la comprobación de creación de bucket que rclone hace por defecto antes de subir. Por el mismo motivo, prueba una clave con alcance a un bucket con rclone lsd cdntr:my-bucket en lugar de listar toda la cuenta.

cdnctl se encarga aquí del plano de control: buckets, claves y asociaciones a las aplicaciones en contenedor. Leer y escribir los propios objetos es trabajo de un cliente S3 como rclone. (El comando aparte cdnctl cp sube a CDN file storage, que es un producto distinto; consulta almacenamiento de archivos del CDN.)

rclone.conf: un remote de object storage de CDN.com.tr

[cdntr]
type = s3
provider = Other
access_key_id = <access key from the panel>
secret_access_key = <secret, shown once at creation>
endpoint = https://s3.cdn.com.tr
no_check_bucket = true

# test it
# rclone lsd cdntr:my-bucket
# rclone copy ./smoke.txt cdntr:my-bucket/ -v

Migrar entre proveedores: R2, B2 o AWS S3 a otro S3

Una migración entre dos servicios S3 son dos remotes y un comando. rclone lista ambos lados, los compara y copia lo que falta, así que puedes ejecutar el mismo comando varias veces: la primera ejecución mueve el grueso, las siguientes solo los cambios, y la ejecución final durante tu cutover es corta.

Los datos pasan por la máquina que ejecuta rclone: descarga del origen y sube al destino. Ejecútalo en un servidor con buen ancho de banda hacia ambos extremos en lugar de en un portátil, y comprueba antes el precio de salida (egress) del proveedor de origen. AWS cobra la transferencia saliente, Backblaze B2 incluye egress gratis hasta un múltiplo de lo que almacenas, y Cloudflare R2 no cobra nada por egress. La copia del lado del servidor solo ocurre dentro de un mismo proveedor.

Ajustes que hacen las migraciones grandes más rápidas y baratas: --fast-list para reducir las peticiones de listado, --checksum para que rclone compare tamaños y hashes en lugar de pedir la fecha de modificación objeto por objeto, y --transfers y --checkers más altos si el origen lo permite. Empieza con copy, no con sync, para que un error no pueda borrar nada; pasa a sync (con --dry-run primero) solo para la última pasada si se borraron objetos en el origen mientras tanto.

Para Backblaze B2 puedes usar el tipo nativo b2 de rclone o el endpoint S3 de B2; ambos funcionan. Las claves de R2 se crean en el panel de Cloudflare, y su endpoint contiene el ID de tu cuenta. Nuestras páginas de comparación explican estos movimientos en detalle: alternativa a Cloudflare R2, alternativa a Backblaze B2 y alternativa a IDrive e2. En el lado de la aplicación, lo único que cambia son el endpoint y las claves.

# rclone.conf (source)
[r2]
type = s3
provider = Cloudflare
access_key_id = ...
secret_access_key = ...
endpoint = https://<ACCOUNT_ID>.r2.cloudflarestorage.com
region = auto

# 1. preview, 2. bulk copy, 3. repeat until the delta is small
rclone copy r2:media cdntr:media --dry-run
rclone copy r2:media cdntr:media \
  --fast-list --checksum --transfers 32 --checkers 64 -P

# cutover: stop writes, final pass, then compare
rclone sync r2:media cdntr:media --fast-list --checksum -P
rclone check r2:media cdntr:media --one-way

Verificar una migración con rclone check

rclone check source: dest: compara ambos lados objeto por objeto e imprime un resumen: cuántos archivos coinciden, cuántos difieren, y cuáles existen solo en un lado. No cambia nada. --one-way solo busca archivos del origen que faltan o son distintos en el destino, que es lo que quieres cuando el destino ya tiene datos extra.

La comparación usa tamaños y, cuando ambos lados comparten un tipo de hash, hashes. En S3 ese hash es MD5, y aquí está la trampa: un objeto subido en varias partes tiene un ETag que no es su MD5. rclone guarda el MD5 real en los metadatos del objeto cuando sube él mismo los archivos multiparte, pero los objetos escritos por otras herramientas a menudo no tienen ninguno, así que para esos check solo puede comparar tamaños y lo dice en su salida ("hashes could not be checked"). Cuando necesites certeza byte a byte, --download lee ambas copias y compara el contenido, al coste de transferirlo todo de nuevo.

Para informes que quieras conservar, escribe las listas en archivos con --combined, --missing-on-dst y --differ. Compara rclone size en ambos lados como comprobación final de cordura, y para un remote cifrado usa rclone cryptcheck, que compara la copia cifrada contra el origen en claro.

rclone size r2:media && rclone size cdntr:media

rclone check r2:media cdntr:media --one-way \
  --combined check-report.txt \
  --missing-on-dst missing.txt --differ differ.txt

# slow but exact: download and compare the bytes
rclone check r2:media cdntr:media --download

Google Drive, cifrado y montaje, brevemente

Google Drive. Elige drive en rclone config, elige un scope (drive.readonly basta para descargar), y aprueba el acceso en el navegador. En un servidor sin navegador, responde n a la configuración automática y ejecuta rclone authorize "drive" en una máquina que sí tenga uno, y luego pega el token de vuelta. El client ID integrado de rclone lo comparten todos los usuarios y sufre límites de tasa; para un uso intenso, crea tu propio cliente OAuth en Google Cloud e introdúcelo durante la configuración. Los archivos de Google Docs no son archivos reales, así que rclone los exporta (a docx, xlsx, etc.) al descargarlos. Google también limita las subidas a unos 750 GB por usuario al día, así que una migración grande *hacia* Drive tarda varios días.

Cifrado. Un remote crypt envuelve a otro remote y cifra el contenido de los archivos, y opcionalmente los nombres, antes de subirlos. Lo creas encima de, por ejemplo, cdntr:backups, y luego escribes a través del remote crypt; el proveedor solo ve texto cifrado. La contraseña y la sal viven en tu rclone.conf: si las pierdes, los datos son irrecuperables, así que haz copia de seguridad de ellas por separado de los datos.

Montaje. rclone mount remote:bucket /mnt/bucket hace que un bucket parezca una carpeta (en Windows, monta en una letra de unidad como X: con WinFsp instalado). Añade --vfs-cache-mode writes o full para que las aplicaciones que reescriben archivos funcionen correctamente. Un montaje está bien para explorar, bibliotecas multimedia y lecturas ocasionales; no es un disco, así que no pongas ahí bases de datos ni nada que necesite bloqueo de archivos.

Descarga de Drive; añade un remote cifrado encima de un bucket

rclone copy gdrive:Projects ./projects -P

# rclone.conf: encrypted backups inside an existing bucket remote
[secure]
type = crypt
remote = cdntr:backups/encrypted
filename_encryption = standard
password = <obscured by rclone config>
password2 = <obscured by rclone config>

rclone copy /srv/backups secure: -P

Programar rclone: cron, systemd y el Programador de tareas

rclone no tiene planificador propio; está pensado para que otro lo ejecute. En Linux, una entrada de cron basta para la mayoría de los trabajos. Envuelve el comando en flock para que una ejecución lenta no se superponga con la siguiente, registra en un archivo, y apunta --config a una ruta explícita, porque cron corre con un HOME distinto y de otro modo no encontraría tus remotes.

Para un sync que borra, añade los cinturones de seguridad: --max-delete para detener una ejecución que borraría muchos más archivos de lo habitual, y --backup-dir para mover los archivos sobrescritos y borrados a una carpeta con fecha en lugar de perderlos. El código de salida de rclone es 0 si tiene éxito y distinto de cero si falla, así que el script envoltorio o la unidad de systemd pueden lanzar una alerta; un trabajo que lleva un mes fallando en silencio es la forma habitual en que fallan las copias de seguridad.

En máquinas con systemd, un service más un timer te da registro en el journal y Persistent=true, que ejecuta un trabajo perdido tras un reinicio. En Windows, crea una tarea del Programador de tareas que ejecute rclone.exe con la ruta completa de configuración y un archivo de log, bajo una cuenta que tenga acceso tanto a los archivos como a la configuración.

# crontab -e  (02:30 every night)
30 2 * * * flock -n /tmp/rclone-backup.lock \
  rclone sync /srv/backups cdntr:backups/nightly \
  --config /home/backup/.config/rclone/rclone.conf \
  --max-delete 200 \
  --backup-dir cdntr:backups/deleted/$(date +\%F) \
  --log-file /var/log/rclone-backup.log --log-level INFO