rclone es el “rsync para almacenamiento en la nube”: un binario único, escrito en Go, que copia, sincroniza, verifica, cifra, monta y sirve archivos en más de 70 servicios de almacenamiento: Amazon S3, MinIO, Backblaze B2, Cloudflare R2, Google Drive, OneDrive, SFTP, WebDAV, SMB y decenas más. La versión estable en septiembre de 2026 es la 1.75.1 (04/09). Esta guía va desde la instalación hasta la copia de seguridad cifrada programada con systemd, pasando por mount, serve y la nueva GUI web.
Si ya usas rsync entre servidores, rclone es la misma idea con un detalle que lo cambia todo: el otro lado no tiene por qué ser una máquina con SSH. Puede ser un bucket, un drive personal u otro proveedor de nube, y la copia entre dos nubes ocurre sin escribir nada en tu disco. Código en github.com/rclone/rclone, documentación en rclone.org/docs.
Qué es rclone
El proyecto fue creado por Nick Craig-Wood y está en GitHub desde marzo de 2014. Licencia MIT, cerca de 60 mil estrellas, binario estático sin dependencias: lo descargas, lo ejecutas. El mismo binario se ejecuta en Linux, macOS, Windows y BSDs, en amd64, arm64 y otras arquitecturas.
El concepto central es el remote: un nombre que registras (meus3:, gdrive:, cofre:) y que apunta a un backend con tus credenciales. Todo comando acepta una ruta local o remote:caminho, en ambos lados:
rclone copy /srv/dados meus3:backups/srv # local → nuvem
rclone copy gdrive:Fotos meus3:fotos # nuvem → nuvem
rclone ls meus3:backups # listar como se fosse lsAdemás de los backends “reales”, existen los virtuales, que envuelven otro remote: crypt (cifrado), union (combina varios remotes en uno), chunker (divide archivos grandes), compress, hasher, combine e alias. Esto es lo que permite, por ejemplo, una copia de seguridad cifrada sobre cualquier proveedor.
Arquitectura: dónde encaja rclone
rclone se sitúa entre los orígenes (disco local, NAS, otra nube) y los destinos. Por dentro, cada operación pasa por los comandos, los filtros y límites, opcionalmente por la capa de cifrado, y llega a los clientes de API de cada backend, que se encargan del checksum, los reintentos y las transferencias paralelas. Las credenciales residen en el rclone.conf. Por fuera, consumes rclone de tres maneras: programado (systemd/cron), montado como sistema de archivos (FUSE) o sirviendo el remote mediante HTTP, WebDAV, SFTP, S3 o NFS.
Instalación
Los repositorios de las distros van atrasados: Ubuntu 24.04 y Debian 13 empaquetan la 1.60.1, sin bisync estable, sin gui, sin archive y sin años de correcciones. Usa el script oficial, que descarga la última versión estable e instala en /usr/bin/rclone con la página de manual:
sudo -v ; curl https://rclone.org/install.sh | sudo bash
rclone version¿Prefieres no pasar el script por pipe a bash? Descarga el zip e instálalo a mano:
VER=v1.75.1
curl -LO https://downloads.rclone.org/$VER/rclone-$VER-linux-amd64.zip
unzip rclone-$VER-linux-amd64.zip
sudo install -m 755 rclone-$VER-linux-amd64/rclone /usr/bin/rclone
sudo mkdir -p /usr/local/share/man/man1
sudo install -m 644 rclone-$VER-linux-amd64/rclone.1 /usr/local/share/man/man1/Para usar rclone mount, instala también FUSE 3:
sudo apt install fuse3Actualizar después es un comando: sudo rclone selfupdate. También hay una imagen Docker oficial (rclone/rclone) y snap, este último mantenido por la comunidad y con las limitaciones de confinamiento de snap.
Configurando el primer remoto
La forma interactiva es rclone config: un asistente pregunta el tipo de backend y las credenciales y lo guarda todo en ~/.config/rclone/rclone.conf. Para scripts y automatización, el rclone config create hace lo mismo en una sola línea. Ejemplo con un MinIO (o cualquier compatible con S3):
rclone config create meus3 s3 \
provider=Minio \
access_key_id=MINHA_CHAVE \
secret_access_key=MEU_SEGREDO \
endpoint=https://minio.exemplo.com.br
rclone lsd meus3: # lista os buckets
rclone mkdir meus3:backups # cria um bucketEl resultado es un bloque INI simple en el archivo de configuración:
[meus3]
type = s3
provider = Minio
access_key_id = MINHA_CHAVE
secret_access_key = MEU_SEGREDO
endpoint = https://minio.exemplo.com.brPara AWS cambie provider=AWS e informe region; para Cloudflare R2, Wasabi, Hetzner, Magalu Cloud y otros, el provider tiene su propio valor — la lista completa sale de rclone help backend s3. Si aún no tienes un S3 propio, la entrada sobre OpenObserve con S3, GCS y MinIO muestra esa parte.
Los backends con OAuth quieren abrir un navegador para que los autorices. En un servidor headless, responde n cuando el rclone config pregunte si puede usar el navegador. Te pedirá un token; genéralo en cualquier máquina con navegador y el mismo rclone instalado:
# no desktop, com navegador
rclone authorize "drive"
# autorize na página que abre e copie o bloco que o comando imprime
# de volta ao servidor, cole o bloco no prompt do rclone configNada de túnel ni de copiar el rclone.conf entero entre máquinas.
copy, sync, move y bisync: elige el verbo adecuado
Es aquí donde rclone perdona poco. Los cuatro comandos parecen parecidos y hacen cosas bastante diferentes con el destino:
| Comando | Qué hace | ¿Borra en el destino? |
|---|---|---|
copy |
Copia lo nuevo o lo que cambió; ignora archivos idénticos | Nunca |
sync |
Deja el destino idéntico al origen | Sí, todo lo que no existe en el origen |
move |
Copia y borra del origen | No (borra en el origen) |
bisync |
Sincronización en ambos sentidos, con detección de conflictos | Sí, en ambos lados |
El error clásico es invertir origen y destino en un sync: rclone obedece y borra el lado que querías preservar. Por eso, antes de cada sync nuevo:
rclone sync /srv/dados meus3:backups/srv --dry-run # mostra o que faria
rclone sync /srv/dados meus3:backups/srv -i # pergunta arquivo a arquivo
rclone sync /srv/dados meus3:backups/srv -P # executa com progressoO bisync salió oficialmente de la beta en 1.71. En la primera ejecución necesita --resync para montar el estado inicial de ambos lados; después, ejecútelo sin la opción:
rclone bisync ~/Documentos gdrive:Documentos --resync # só na primeira vez
rclone bisync ~/Documentos gdrive:Documentos # as próximasPara copia de seguridad, prefiera sync o copy en una sola dirección. bisync es para carpetas que se editan en ambos lados, como un Dropbox casero.
Filtros: qué entra y qué se queda fuera
Para eliminar un patrón rápido, use --exclude. Para reglas definitivas, un archivo de filtros, leído de arriba a abajo — la primera regla que coincida decide:
sudo mkdir -p /etc/rclone
sudo tee /etc/rclone/filtros.txt >/dev/null <<'EOF'
- node_modules/**
- .cache/**
- *.tmp
- *.swp
+ **
EOF
rclone sync /srv meus3:backups/srv --filter-from /etc/rclone/filtros.txt --dry-runOtros filtros útiles en el día a día: --max-age 7d (solo lo que cambió en la última semana), --min-size 1M, --exclude-if-present .nobackup (salta directorios que contienen ese archivo) y rclone lsf -R origem --filter-from filtros.txt, que lista exactamente lo que el filtro deja pasar sin transferir nada.
Cifrado con el remote crypt
O crypt es un remote que envuelve a otro. Todo lo que escribe en cofre: sale cifrado en el remoto de abajo, con contenido cifrado por XSalsa20 + Poly1305 (el SecretBox de NaCl) y, opcionalmente, nombres de archivos y directorios también cifrados. El proveedor solo ve blobs con nombres aleatorios.
rclone config create cofre crypt \
remote=meus3:backups-cifrados \
password=$(rclone obscure 'uma-senha-longa-e-aleatoria') \
filename_encryption=standard \
directory_name_encryption=true
rclone copy /srv/dados cofre:srv
rclone ls cofre:srv # nomes em claro, via rclone
rclone ls meus3:backups-cifrados # o que o provedor vê: nomes embaralhadosEn el lado del bucket, el resultado es así:
5e4j7s0dqn1dn7tpog50ss59t4/ees62i2pgm1tg01hd2euclo548
64m5qfpup4djr71a5er0jmd3p4
cj3kojq3km80ciulanc65ichm4Tres precauciones:
- La contraseña es la copia de seguridad. Perdió la contraseña (y el salt, si usó
password2), perdió los datos. Guárdela en una caja fuerte de contraseñas, como el Vaultwarden, fuera del servidor que realiza la copia de seguridad. - El tamaño de los archivos no se oculta — se puede calcular el tamaño original con un margen de 16 bytes — ni la estructura de directorios y fechas de modificación.
- Para verificar un remoto cifrado, use
rclone cryptcheck /srv/dados cofre:srv: compara los checksums sin descargar los archivos.
Protegiendo rclone.conf
Las contraseñas guardadas por rclone en rclone.conf quedan ofuscadas, no cifradas: el rclone obscure usa AES-CTR con una clave fija, conocida por cualquier versión de rclone. Solo sirve contra miradas de reojo. Quien lee el archivo lee sus claves de S3 y la contraseña de crypt. Cifre toda la configuración:
rclone config encryption set # define a senha do arquivo
rclone config encryption check # confirma que está cifrado
chmod 600 ~/.config/rclone/rclone.confCon el archivo cifrado, cada ejecución pide la contraseña. Para automatización, pásela mediante la variable RCLONE_CONFIG_PASS (cargada de un archivo con modo 600) o mediante --password-command, que ejecuta un comando y lee la contraseña de la salida — útil con pass, secret-tool o una caja fuerte externa.
Backup programado con temporizador de systemd
Reuniendo todo: una copia de seguridad nocturna de /srv al remoto cifrado, con versiones antiguas conservadas y un seguro contra borrado accidental. Primero, el script:
sudo tee /usr/local/bin/rclone-backup.sh >/dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
DIA=$(date +%F)
exec /usr/bin/rclone sync /srv cofre:srv \
--filter-from /etc/rclone/filtros.txt \
--backup-dir "cofre:srv-versoes/$DIA" \
--max-delete 500 \
--transfers 8 \
--log-file /var/log/rclone/backup.log \
--log-level INFO \
--stats 5m --stats-one-line
EOF
sudo chmod 755 /usr/local/bin/rclone-backup.sh
sudo mkdir -p /var/log/rcloneQué protege cada flag:
--backup-dir`: archivo que elsyncborraría o sobrescribiría va asrv-versoes/AAAA-MM-DD/en lugar de desaparecer. Es tu “papelera” con fecha.--max-delete 500: al alcanzar 500 eliminaciones, la sincronización deja de borrar y termina con error. Un disco de origen vacío por fallo de montaje no se convierte en un bucket vacío — y lo que llegó a borrarse todavía está en--backup-dir.--log-filee--stats-one-line: histórico legible para auditoría.
El servicio se ejecuta como root y lee la configuración de /etc/rclone. Copie allí el rclone.conf ya cifrado y ponga su contraseña en un archivo de entorno solo para root:
sudo install -m 600 ~/.config/rclone/rclone.conf /etc/rclone/rclone.conf
sudo install -m 600 /dev/null /etc/rclone/backup.env
echo 'RCLONE_CONFIG_PASS=senha-do-arquivo-de-config' | sudo tee /etc/rclone/backup.env >/dev/nullAhora el service y el timer:
# /etc/systemd/system/rclone-backup.service
[Unit]
Description=Backup de /srv para a nuvem com rclone
Wants=network-online.target
After=network-online.target
[Service]
Type=oneshot
EnvironmentFile=/etc/rclone/backup.env
Environment=RCLONE_CONFIG=/etc/rclone/rclone.conf
ExecStart=/usr/local/bin/rclone-backup.sh
Nice=10
IOSchedulingClass=idle# /etc/systemd/system/rclone-backup.timer
[Unit]
Description=Backup noturno com rclone
[Timer]
OnCalendar=*-*-* 02:30:00
RandomizedDelaySec=15m
Persistent=true
[Install]
WantedBy=timers.targetsudo systemctl daemon-reload
sudo systemctl enable --now rclone-backup.timer
sudo systemctl start rclone-backup.service # primeiro teste, na hora
systemctl list-timers rclone-backup.timer
journalctl -u rclone-backup.service -n 50Persistent=true ejecuta el backup perdido si la máquina estaba apagada a las 02:30. Lo básico de units y timers está en Dominando systemd. Para bases de datos, no copies los archivos del datadir en uso: genera el dump antes (el Databasus lo hace con restore probado) y deja que rclone lleve el dump fuera del servidor.
Y backup que nunca se ha restaurado es esperanza, no backup. Prueba de vez en cuando:
rclone check /srv cofre:srv --filter-from /etc/rclone/filtros.txt --one-way
rclone copy cofre:srv/etc/nginx /tmp/restore-teste -PMontando la nube como directorio: rclone mount
O rclone mount expone cualquier remote como sistema de archivos mediante FUSE. Los programas que solo entienden ruta local pasan a leer y escribir en el bucket:
mkdir -p ~/nuvem
rclone mount cofre: ~/nuvem \
--vfs-cache-mode full \
--vfs-cache-max-size 20G \
--daemon
ls ~/nuvem
fusermount3 -u ~/nuvem # desmontarO --vfs-cache-mode define cuánto guarda rclone en disco local. Sin caché (off), muchos programas fallan porque el objeto remoto no acepta escritura aleatoria. writes ya resuelve la mayoría de los casos; full también cachea la lectura y es lo que más se comporta como un disco. Una pega: la escritura sube a la nube unos segundos después de cerrarse el archivo (--vfs-write-back, por defecto 5 s). Desmontar en mitad de eso deja la subida pendiente en la caché local — espera a que el log lo confirme antes de desmontar o apagar.
Para montar en el arranque, usa un service de systemd con Type=notify y sin --daemon, o una línea en /etc/fstab con el tipo rclone (la página de manual de rclone mount incluye ambos ejemplos). Para que otros usuarios vean el montaje, habilite user_allow_other en /etc/fuse.conf y pase --allow-other.
Sirviendo archivos: serve y la nueva GUI
El camino inverso: rclone se convierte en servidor y expone un remoto mediante un protocolo estándar. rclone serve habla HTTP, WebDAV, FTP, SFTP, S3, NFS, DLNA, la API REST de restic y el plugin de volúmenes de Docker:
# WebDAV com autenticação, para montar no gerenciador de arquivos
rclone serve webdav cofre:compartilhado --addr :8080 --user nilton --pass 'troque-isto'
# um S3 compatível na frente de qualquer backend (até de um Google Drive)
rclone serve s3 gdrive:dados --addr :9000 --auth-key CHAVE,SEGREDO
# repositório do restic direto num remote
rclone serve restic meus3:restic --addr 127.0.0.1:8000El valor por defecto es escuchar solo en 127.0.0.1. Si lo expone a la red, añada TLS (--cert e --key) o coloque un proxy inverso delante.
Desde 1.74 el binario incluye una interfaz web integrada. El comando levanta la API de control remoto y la GUI en puertos locales, genera credenciales y abre el navegador ya autenticado:
rclone gui # desktop
rclone gui --no-open-browser --addr localhost:5580
# num servidor: ssh -L 5580:localhost:5580 usuario@servidorPara quien quiere navegar por los archivos con una interfaz web completa, multiusuario, el Filestash y el FileBrowser Quantum son otra categoría de herramienta — y pueden servir un directorio montado por rclone.
Rendimiento y límites de ancho de banda
Los valores predeterminados son conservadores: 4 transferencias y 8 verificadores en paralelo. Para muchos archivos pequeños en object storage, subir ambos ayuda bastante:
rclone sync /srv meus3:backups/srv \
--transfers 16 --checkers 32 \
--fast-list \
-P--fast-list: lista el bucket de forma recursiva con menos llamadas a la API. Gasta más memoria, ahorra tiempo y solicitudes (que muchos proveedores cobran).--checksum: compara por hash en lugar de por fecha y tamaño, cuando ambos lados lo soportan.--bwlimit: acepta un valor fijo o una tabla de horarios, para no tirar el enlace durante la jornada laboral:
rclone sync /srv meus3:backups/srv --bwlimit "08:00,2M 19:00,20M 23:00,off"Para diagnóstico, rclone ncdu meus3: muestra el uso de espacio en un navegador de terminal, y rclone about meus3: muestra la cuota en los backends que la informan.
¿rclone, rsync o restic?
- rsync: entre máquinas Linux por SSH, con delta de bloques dentro del archivo. En eso sigue siendo mejor: rclone transfiere el archivo entero cuando algo cambia.
- rclone: cuando el destino es la nube, bucket o drive; copia entre nubes; espejo legible archivo a archivo; montar o servir un remote.
- restic (o Borg): backup con deduplicación, snapshots y retención por política. No reemplazan al rclone, se combinan con él: restic usa rclone como backend (
restic -r rclone:meus3:restic) y hereda más de 70 destinos.
Una regla sencilla: espejo y transporte, rclone; historial de versiones con deduplicación, restic por encima de rclone.
Comandos de bolsillo
rclone listremotes # remotes configurados
rclone lsd remote: # diretórios/buckets
rclone lsf -R remote:caminho # lista para scripts
rclone tree remote:caminho # árvore
rclone size remote:caminho # total de objetos e bytes
rclone copyto arq.txt remote:dir/novo.txt # copiar com outro nome
rclone cat remote:dir/arq.txt # conteúdo na saída padrão
rclone check origem remote:destino # conferir sem transferir
rclone dedupe remote: # duplicados (comum no Google Drive)
rclone purge remote:dir # apaga diretório e conteúdo (cuidado)
rclone archive list remote:pacote.zip # conteúdo de um zip/tar no remoteCerrando
rclone hace una sola cosa — mover archivos entre lugares — y lo hace con una cobertura de backends que ninguna otra herramienta libre tiene. Para un backup fuera del servidor, cuatro piezas lo resuelven: un remote de object storage, un crypt sobre él, un rclone.conf cifrado y un timer de systemd con --backup-dir e --max-delete. Empiece siempre con --dry-run y pruebe el restore antes de necesitarlo.
Continúe en la parte 2: vea cómo hacer una migración de Amazon S3 a Google Cloud Storage u OCI con rclone, con copia inicial, deltas, verificación y plan de retorno.