rclone é o “rsync para armazenamento em nuvem”: um binário único, escrito em Go, que copia, sincroniza, verifica, criptografa, monta e serve arquivos em mais de 70 serviços de armazenamento — Amazon S3, MinIO, Backblaze B2, Cloudflare R2, Google Drive, OneDrive, SFTP, WebDAV, SMB e dezenas de outros. A versão estável em setembro de 2026 é a 1.75.1 (04/09). Este guia vai da instalação ao backup criptografado agendado com systemd, passando por mount, serve e a nova GUI web.
Se você já usa rsync entre servidores, o rclone é a mesma ideia com um detalhe que muda tudo: o outro lado não precisa ser uma máquina com SSH. Pode ser um bucket, um drive pessoal ou outro provedor de nuvem — e a cópia entre duas nuvens acontece sem gravar nada no seu disco. Código em github.com/rclone/rclone, documentação em rclone.org/docs.
O que é o rclone
O projeto foi criado por Nick Craig-Wood e está no GitHub desde março de 2014. Licença MIT, cerca de 60 mil estrelas, binário estático sem dependências: baixou, rodou. O mesmo executável roda em Linux, macOS, Windows e BSDs, em amd64, arm64 e outras arquiteturas.
O conceito central é o remote: um nome que você cadastra (meus3:, gdrive:, cofre:) e que aponta para um backend com suas credenciais. Todo comando aceita caminho local ou remote:caminho, nos dois 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 lsAlém dos backends “de verdade”, existem os virtuais, que embrulham outro remote: crypt (criptografia), union (junta vários remotes em um), chunker (quebra arquivos grandes), compress, hasher, combine e alias. É isso que permite, por exemplo, um backup criptografado em cima de qualquer provedor.
Arquitetura: onde o rclone se encaixa
O rclone fica entre as origens (disco local, NAS, outra nuvem) e os destinos. Por dentro, cada operação passa pelos comandos, pelos filtros e limites, opcionalmente pela camada de criptografia, e chega aos clientes de API de cada backend, que cuidam de checksum, retentativas e transferências paralelas. As credenciais moram no rclone.conf. Por fora, você consome o rclone de três jeitos: agendado (systemd/cron), montado como sistema de arquivos (FUSE) ou servindo o remote por HTTP, WebDAV, SFTP, S3 ou NFS.
Instalação
Os repositórios das distros andam atrasados: Ubuntu 24.04 e Debian 13 empacotam a 1.60.1, sem bisync estável, sem gui, sem archive e sem anos de correções. Use o script oficial, que baixa a última versão estável e instala em /usr/bin/rclone com a man page:
sudo -v ; curl https://rclone.org/install.sh | sudo bash
rclone versionPrefere não passar script por pipe para o bash? Baixe o zip e instale na mão:
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, instale também o FUSE 3:
sudo apt install fuse3Atualizar depois é um comando: sudo rclone selfupdate. Há ainda imagem Docker oficial (rclone/rclone) e snap, este mantido pela comunidade e com as limitações de confinamento do snap.
Configurando o primeiro remote
O jeito interativo é rclone config: um assistente pergunta o tipo de backend e as credenciais e grava tudo em ~/.config/rclone/rclone.conf. Para scripts e automação, o rclone config create faz o mesmo em uma linha. Exemplo com um MinIO (ou qualquer S3 compatível):
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 bucketO resultado é um bloco INI simples no arquivo de configuração:
[meus3]
type = s3
provider = Minio
access_key_id = MINHA_CHAVE
secret_access_key = MEU_SEGREDO
endpoint = https://minio.exemplo.com.brPara AWS troque provider=AWS e informe region; para Cloudflare R2, Wasabi, Hetzner, Magalu Cloud e outros, o provider tem valor próprio — a lista completa sai de rclone help backend s3. Se você ainda não tem um S3 próprio, o post sobre o OpenObserve com S3, GCS e MinIO mostra esse lado.
Backends com OAuth querem abrir um navegador para você autorizar. Num servidor headless, responda n quando o rclone config perguntar se pode usar o navegador. Ele vai pedir um token; gere-o em qualquer máquina com navegador e o mesmo 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 nem de copiar o rclone.conf inteiro entre máquinas.
copy, sync, move e bisync: escolha o verbo certo
É aqui que o rclone perdoa pouco. Os quatro comandos parecem parecidos e fazem coisas bem diferentes com o destino:
| Comando | O que faz | Apaga no destino? |
|---|---|---|
copy |
Copia o que é novo ou mudou; ignora arquivos idênticos | Nunca |
sync |
Deixa o destino idêntico à origem | Sim, tudo que não existe na origem |
move |
Copia e apaga da origem | Não (apaga na origem) |
bisync |
Sincronização nos dois sentidos, com detecção de conflito | Sim, nos dois lados |
O erro clássico é inverter origem e destino num sync: o rclone obedece e apaga o lado que você queria preservar. Por isso, antes de todo sync novo:
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 saiu oficialmente do beta na 1.71. Na primeira execução ele precisa de --resync para montar o estado inicial dos dois lados; depois, rode sem a flag:
rclone bisync ~/Documentos gdrive:Documentos --resync # só na primeira vez
rclone bisync ~/Documentos gdrive:Documentos # as próximasPara backup, prefira sync ou copy num sentido só. bisync é para pastas que você edita dos dois lados, como um Dropbox caseiro.
Filtros: o que entra e o que fica de fora
Para excluir um padrão rápido, use --exclude. Para regras de verdade, um arquivo de filtros, lido de cima para baixo — a primeira regra que casa 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-runOutros filtros úteis no dia a dia: --max-age 7d (só o que mudou na última semana), --min-size 1M, --exclude-if-present .nobackup (pula diretórios que contêm esse arquivo) e rclone lsf -R origem --filter-from filtros.txt, que lista exatamente o que o filtro deixa passar sem transferir nada.
Criptografia com o remote crypt
O crypt é um remote que embrulha outro. Tudo que você grava em cofre: sai criptografado no remote de baixo, com conteúdo cifrado por XSalsa20 + Poly1305 (o SecretBox da NaCl) e, opcionalmente, nomes de arquivos e diretórios também cifrados. O provedor vê só blobs com nomes aleatórios.
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 embaralhadosNo lado do bucket, o resultado é assim:
5e4j7s0dqn1dn7tpog50ss59t4/ees62i2pgm1tg01hd2euclo548
64m5qfpup4djr71a5er0jmd3p4
cj3kojq3km80ciulanc65ichm4Três cuidados:
- A senha é o backup. Perdeu a senha (e o salt, se usou
password2), perdeu os dados. Guarde-a num cofre de senhas, como o Vaultwarden, fora do servidor que faz o backup. - O tamanho dos arquivos não é escondido — dá para calcular o tamanho original com margem de 16 bytes — nem a estrutura de diretórios e datas de modificação.
- Para verificar um remote criptografado, use
rclone cryptcheck /srv/dados cofre:srv: ele compara os checksums sem baixar os arquivos.
Protegendo o rclone.conf
Senhas gravadas pelo rclone no rclone.conf ficam ofuscadas, não criptografadas: o rclone obscure usa AES-CTR com uma chave fixa, conhecida por qualquer versão do rclone. Serve só contra olhadas de relance. Quem lê o arquivo lê suas chaves de S3 e a senha do crypt. Criptografe a configuração inteira:
rclone config encryption set # define a senha do arquivo
rclone config encryption check # confirma que está cifrado
chmod 600 ~/.config/rclone/rclone.confCom o arquivo cifrado, cada execução pede a senha. Para automação, passe-a pela variável RCLONE_CONFIG_PASS (carregada de um arquivo com modo 600) ou por --password-command, que executa um comando e lê a senha da saída — útil com pass, secret-tool ou um cofre externo.
Backup agendado com systemd timer
Juntando tudo: um backup noturno de /srv para o remote criptografado, com versões antigas preservadas e uma trava contra apagão acidental. Primeiro, o 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/rcloneO que cada flag protege:
--backup-dir: arquivo que osyncapagaria ou sobrescreveria vai parasrv-versoes/AAAA-MM-DD/em vez de sumir. É o seu “lixo” com data.--max-delete 500: ao atingir 500 exclusões o sync para de apagar e termina com erro. Um disco de origem vazio por falha de montagem não vira um bucket vazio — e o que chegou a ser apagado ainda está no--backup-dir.--log-filee--stats-one-line: histórico legível para auditoria.
O serviço roda como root e lê a configuração de /etc/rclone. Copie para lá o rclone.conf já cifrado e ponha a senha dele num arquivo de ambiente só 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/nullAgora o service e o 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 roda o backup perdido se a máquina estava desligada às 02:30. O básico de units e timers está em Dominando o systemd. Para bancos de dados, não copie os arquivos do datadir em uso: gere o dump antes (o Databasus faz isso com restore testado) e deixe o rclone levar o dump para fora do servidor.
E backup que nunca foi restaurado é esperança, não backup. Teste de tempos em tempos:
rclone check /srv cofre:srv --filter-from /etc/rclone/filtros.txt --one-way
rclone copy cofre:srv/etc/nginx /tmp/restore-teste -PMontando a nuvem como diretório: rclone mount
O rclone mount expõe qualquer remote como sistema de arquivos via FUSE. Programas que só entendem caminho local passam a ler e gravar no 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 quanto o rclone guarda em disco local. Sem cache (off), muitos programas falham porque o objeto remoto não aceita escrita aleatória. writes já resolve a maioria dos casos; full cacheia também a leitura e é o que se comporta mais como um disco. Uma pegadinha: a escrita sobe para a nuvem alguns segundos depois de o arquivo ser fechado (--vfs-write-back, padrão 5 s). Desmontar no meio disso deixa o upload pendente no cache local — espere o log confirmar antes de desmontar ou desligar.
Para montar no boot, use um service do systemd com Type=notify e sem --daemon, ou uma linha no /etc/fstab com o tipo rclone (a man page do rclone mount traz os dois exemplos). Para outros usuários enxergarem a montagem, habilite user_allow_other em /etc/fuse.conf e passe --allow-other.
Servindo arquivos: serve e a nova GUI
O caminho inverso: o rclone vira servidor e expõe um remote por protocolo padrão. rclone serve fala HTTP, WebDAV, FTP, SFTP, S3, NFS, DLNA, API REST do restic e o plugin de volumes do 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:8000O padrão é escutar só em 127.0.0.1. Abriu para a rede, ponha TLS (--cert e --key) ou um proxy reverso na frente.
Desde a 1.74 o binário traz uma interface web embutida. O comando sobe a API de controle remoto e a GUI em portas locais, gera credenciais e abre o navegador já autenticado:
rclone gui # desktop
rclone gui --no-open-browser --addr localhost:5580
# num servidor: ssh -L 5580:localhost:5580 usuario@servidorPara quem quer navegar nos arquivos com uma interface web completa, multiusuário, o Filestash e o FileBrowser Quantum são outra categoria de ferramenta — e podem servir um diretório montado pelo rclone.
Desempenho e limites de banda
Os padrões são conservadores: 4 transferências e 8 verificadores em paralelo. Para muitos arquivos pequenos em object storage, subir os dois ajuda bastante:
rclone sync /srv meus3:backups/srv \
--transfers 16 --checkers 32 \
--fast-list \
-P--fast-list: lista o bucket recursivamente em menos chamadas de API. Gasta mais memória, economiza tempo e requisições (que muitos provedores cobram).--checksum: compara por hash em vez de data e tamanho, quando os dois lados suportam.--bwlimit: aceita valor fixo ou uma tabela de horários, para não derrubar o link no expediente:
rclone sync /srv meus3:backups/srv --bwlimit "08:00,2M 19:00,20M 23:00,off"Para diagnóstico, rclone ncdu meus3: mostra o uso de espaço num navegador de terminal, e rclone about meus3: exibe a cota nos backends que a informam.
rclone, rsync ou restic?
- rsync: entre máquinas Linux por SSH, com delta de blocos dentro do arquivo. Nisso ele continua melhor: o rclone transfere o arquivo inteiro quando algo muda.
- rclone: quando o destino é nuvem, bucket ou drive; cópia entre nuvens; espelho legível arquivo a arquivo; montar ou servir um remote.
- restic (ou Borg): backup com deduplicação, snapshots e retenção por política. Não substituem o rclone, combinam com ele: o restic usa o rclone como backend (
restic -r rclone:meus3:restic) e herda os mais de 70 destinos.
Uma regra simples: espelho e transporte, rclone; histórico de versões com deduplicação, restic por cima do rclone.
Comandos de bolso
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 remoteFechando
O rclone faz uma coisa só — mover arquivos entre lugares — e faz com uma cobertura de backends que nenhuma outra ferramenta livre tem. Para um backup fora do servidor, quatro peças resolvem: um remote de object storage, um crypt em cima dele, um rclone.conf cifrado e um timer do systemd com --backup-dir e --max-delete. Comece sempre com --dry-run e teste o restore antes de precisar dele.
Continue na parte 2: veja como fazer uma migração do Amazon S3 para Google Cloud Storage ou OCI com rclone, com cópia inicial, deltas, verificação e plano de retorno.