rclone is a command-line tool for copying, syncing, listing, and managing files across cloud storage providers, including S3-compatible object storage.

How much does Raff Object Storage cost?

Raff Object Storage starts at $7/month with 100 GB storage and 1 TB egress included. Extra storage is billed separately based on usage.

Can rclone work with Raff Object Storage?

Yes. Raff Object Storage is S3-compatible, so rclone can connect using the S3 backend, endpoint, access key, secret key, and bucket name.

What is the difference between rclone copy and rclone sync?

rclone copy uploads new or changed files without deleting destination files. rclone sync makes the destination match the source and can delete remote files.

Should I use rclone or AWS CLI for Raff Object Storage?

Use AWS CLI for standard S3 operations and rclone for sync-heavy workflows, filters, scheduled file backups, migrations, and restore testing.

rclone Sync to Raff Object Storage

Introduction

Sync files to Raff Object Storage with rclone by configuring Raff’s S3-compatible endpoint, creating a secure remote, copying test files, running a safe dry-run sync, and verifying that files can be restored. This tutorial shows you how to use rclone on a Raff Technologies Ubuntu 24.04 VM to move application files, backups, logs, exports, and static assets into object storage.

rclone is a command-line file transfer tool that copies, syncs, lists, checks, and manages files across cloud storage systems. Raff Object Storage is S3-compatible object storage, which means rclone can connect to it using the S3 backend, the endpoint s3.raffusercloud.com, and your Raff S3 access credentials. This makes rclone useful when you want repeatable file synchronization instead of one-off uploads.

In this tutorial, you will install rclone, configure a Raff Object Storage remote, create a bucket, upload files, compare copy and sync, use --dry-run safely, restore files into a test directory, add exclusions, and schedule a daily sync job with systemd.

Warning

rclone sync can delete files from the destination if they no longer exist in the source. Always run rclone sync --dry-run first when working with production data.

Step 1 — Install rclone on Ubuntu 24.04

Start by installing rclone from Ubuntu’s package repository. This is the simplest installation method and works well for S3-compatible object storage workflows.

Bash

sudo apt update
sudo apt install -y rclone

Verify the installed version:

Bash

rclone version

Expected output will look similar to this:

Text

rclone v1.x.x
* os/version: ubuntu 24.04
* os/kernel: 6.x.x
* os/type: linux
* os/arch: amd64

The exact version can differ depending on package updates. What matters is that the rclone command runs successfully.

If you need the newest upstream rclone release later, you can install from the official rclone install script. For this tutorial, the Ubuntu package is enough.

Step 2 — Prepare Your Raff Object Storage Credentials

Before configuring rclone, collect your Raff Object Storage details from the Raff dashboard.

You need:

S3 endpoint: https://s3.raffusercloud.com
S3 access key
S3 secret key
Bucket name, or permission to create a bucket
Region value: us-east-1

If you have not created object storage credentials yet:

Log in to the Raff dashboard.
Open Object Storage.
Create or select a bucket.
Generate or copy your S3 access key and secret key.
Keep the secret key private.

Warning

Treat S3 keys like passwords. Do not commit them to Git, paste them into tickets, or store them in application code.

For this tutorial, replace the example bucket name with your own:

Text

my-project-files

Use lowercase letters, numbers, and hyphens for bucket names. Avoid spaces, underscores, and uppercase characters.

Step 3 — Create a Root-Owned rclone Config File

Because the tutorial later schedules rclone with systemd, store the rclone configuration in /etc/rclone/raff-rclone.conf. This makes the config path explicit and avoids confusion between your user’s config and root’s config.

Create the config directory:

Bash

sudo install -d -m 700 /etc/rclone
sudo touch /etc/rclone/raff-rclone.conf
sudo chmod 600 /etc/rclone/raff-rclone.conf

Read your credentials into temporary shell variables:

Bash

read -rp "Raff S3 access key: " RAFF_ACCESS_KEY_ID
read -rsp "Raff S3 secret key: " RAFF_SECRET_ACCESS_KEY
echo

Now create an rclone remote named raffs3:

Bash

sudo rclone config create raffs3 s3 \
  provider Other \
  env_auth false \
  access_key_id "$RAFF_ACCESS_KEY_ID" \
  secret_access_key "$RAFF_SECRET_ACCESS_KEY" \
  region us-east-1 \
  endpoint https://s3.raffusercloud.com \
  acl private \
  --config /etc/rclone/raff-rclone.conf

Clear the temporary shell variables:

Bash

unset RAFF_ACCESS_KEY_ID
unset RAFF_SECRET_ACCESS_KEY

Verify that the remote exists:

Bash

sudo rclone listremotes --config /etc/rclone/raff-rclone.conf

Expected output:

Text

raffs3:

The remote name raffs3 is how you will reference Raff Object Storage in rclone commands.

Step 4 — List Existing Buckets and Create a Test Bucket

List buckets available to your credentials:

Bash

sudo rclone lsd raffs3: --config /etc/rclone/raff-rclone.conf

If your account already has buckets, you will see output similar to this:

Text

          -1 2026-05-04 10:15:00        -1 my-project-files

If the bucket does not exist yet, create it:

Bash

sudo rclone mkdir raffs3:my-project-files --config /etc/rclone/raff-rclone.conf

List buckets again:

Bash

sudo rclone lsd raffs3: --config /etc/rclone/raff-rclone.conf

Expected output:

Text

          -1 2026-05-04 10:16:00        -1 my-project-files

You now have an rclone remote and a Raff Object Storage bucket ready for uploads.

Step 5 — Create Sample Files to Sync

Create a local test directory with a few files. This keeps the first upload safe and easy to inspect.

Bash

mkdir -p ~/raff-rclone-demo/assets
mkdir -p ~/raff-rclone-demo/logs
mkdir -p ~/raff-rclone-demo/cache

echo "Raff Object Storage rclone demo" > ~/raff-rclone-demo/README.txt
echo "body { color: #db4a2b; }" > ~/raff-rclone-demo/assets/app.css
echo "application started" > ~/raff-rclone-demo/logs/app.log
echo "temporary cache file" > ~/raff-rclone-demo/cache/temp.txt

Inspect the directory:

Bash

find ~/raff-rclone-demo -type f -print

Expected output:

Text

/home/ubuntu/raff-rclone-demo/assets/app.css
/home/ubuntu/raff-rclone-demo/logs/app.log
/home/ubuntu/raff-rclone-demo/cache/temp.txt
/home/ubuntu/raff-rclone-demo/README.txt

Your home directory may differ from /home/ubuntu. That is fine.

Step 6 — Upload Files with rclone copy

Use rclone copy for the first upload. The copy command uploads new and changed files but does not delete extra files from the destination.

Bash

sudo rclone copy ~/raff-rclone-demo raffs3:my-project-files/demo \
  --progress \
  --config /etc/rclone/raff-rclone.conf

Expected output will show transfer progress:

Text

Transferred:   	    128 B / 128 B, 100%
Checks:                 0 / 0, -
Transferred:            4 / 4, 100%
Elapsed time:         2.1s

List the uploaded files:

Bash

sudo rclone ls raffs3:my-project-files/demo \
  --config /etc/rclone/raff-rclone.conf

Expected output:

Text

       32 README.txt
       22 assets/app.css
       20 logs/app.log
       21 cache/temp.txt

Use copy when you want to upload or refresh files without deleting anything from object storage.

Step 7 — Test rclone sync with a Dry Run

Now test rclone sync. Unlike copy, sync makes the destination match the source. That means files removed locally can also be removed from object storage.

First, change the local folder:

Bash

echo "new release artifact" > ~/raff-rclone-demo/assets/release.txt
rm -f ~/raff-rclone-demo/cache/temp.txt

Run a dry run:

Bash

sudo rclone sync ~/raff-rclone-demo raffs3:my-project-files/demo \
  --dry-run \
  --progress \
  --config /etc/rclone/raff-rclone.conf

Expected output will show what rclone would do without actually doing it:

Text

NOTICE: assets/release.txt: Skipped copy as --dry-run is set
NOTICE: cache/temp.txt: Skipped delete as --dry-run is set

This is the safest way to check a sync operation. The dry run tells you that rclone would upload assets/release.txt and delete cache/temp.txt from the destination.

If the dry-run output looks correct, run the real sync:

Bash

sudo rclone sync ~/raff-rclone-demo raffs3:my-project-files/demo \
  --progress \
  --config /etc/rclone/raff-rclone.conf

List the destination again:

Bash

sudo rclone ls raffs3:my-project-files/demo \
  --config /etc/rclone/raff-rclone.conf

Expected output:

Text

       32 README.txt
       22 assets/app.css
       21 assets/release.txt
       20 logs/app.log

The cache/temp.txt file is gone from object storage because the source folder no longer contains it.

Warning

This delete behavior is why rclone sync --dry-run should become a habit. For one-way uploads that should never delete destination files, use rclone copy instead.

Step 8 — Restore Files from Raff Object Storage

A sync workflow is only useful if you can restore files. Create a clean restore directory:

Bash

rm -rf ~/raff-rclone-restore-test
mkdir -p ~/raff-rclone-restore-test

Copy files from Raff Object Storage back to the VM:

Bash

sudo rclone copy raffs3:my-project-files/demo ~/raff-rclone-restore-test \
  --progress \
  --config /etc/rclone/raff-rclone.conf

Inspect the restored files:

Bash

find ~/raff-rclone-restore-test -type f -print

Expected output:

Text

/home/ubuntu/raff-rclone-restore-test/assets/app.css
/home/ubuntu/raff-rclone-restore-test/assets/release.txt
/home/ubuntu/raff-rclone-restore-test/logs/app.log
/home/ubuntu/raff-rclone-restore-test/README.txt

Compare the restored files with the current source:

Bash

diff -r ~/raff-rclone-demo ~/raff-rclone-restore-test

If the command returns no output, the restored files match the source.

This is the most important verification step. Uploading files is not enough. You need to prove you can retrieve them into a clean directory.

Step 9 — Add Exclusions for Cache and Temporary Files

Most real sync jobs should exclude files that do not belong in object storage. Examples include cache directories, temporary files, dependency folders, local Git history, and runtime sockets.

Create a sample filter file:

Bash

cat > ~/raff-rclone-filter.txt <<'EOF'
* cache/**
* tmp/**
* node_modules/**
* .git/**
* *.tmp
* *.sock
+ **
EOF

Run a dry-run sync with the filter:

Bash

sudo rclone sync ~/raff-rclone-demo raffs3:my-project-files/demo-filtered \
  --filter-from ~/raff-rclone-filter.txt \
  --dry-run \
  --progress \
  --config /etc/rclone/raff-rclone.conf

If the dry run looks correct, run the real filtered sync:

Bash

sudo rclone sync ~/raff-rclone-demo raffs3:my-project-files/demo-filtered \
  --filter-from ~/raff-rclone-filter.txt \
  --progress \
  --config /etc/rclone/raff-rclone.conf

List the filtered destination:

Bash

sudo rclone ls raffs3:my-project-files/demo-filtered \
  --config /etc/rclone/raff-rclone.conf

Expected output:

Text

       32 README.txt
       22 assets/app.css
       21 assets/release.txt
       20 logs/app.log

The cache directory should not appear. Filtering helps prevent object storage from filling with files that are easy to recreate and not useful during restore.

Step 10 — Create a Reusable Sync Script

Now turn the working command into a reusable script. This example syncs /srv/app/uploads to Raff Object Storage, which is a common pattern for application uploads, generated files, or exported reports.

Create a source directory for the example:

Bash

sudo mkdir -p /srv/app/uploads
echo "sample upload" | sudo tee /srv/app/uploads/example.txt > /dev/null

Create the script:

Bash

sudo nano /usr/local/sbin/rclone-raff-object-sync.sh

Add the following content:

Bash

#!/usr/bin/env bash
set -euo pipefail

CONFIG_FILE="/etc/rclone/raff-rclone.conf"
SOURCE_DIR="/srv/app/uploads"
DESTINATION="raffs3:my-project-files/uploads"
LOG_FILE="/var/log/rclone-raff-object-sync.log"

{
  echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting rclone sync"
  echo "Source: ${SOURCE_DIR}"
  echo "Destination: ${DESTINATION}"

  rclone sync "$SOURCE_DIR" "$DESTINATION" \
    --config "$CONFIG_FILE" \
    --filter-from /etc/rclone/raff-sync-filter.txt \
    --transfers 4 \
    --checkers 8 \
    --fast-list \
    --stats 30s \
    --stats-one-line

  echo "Running destination listing check..."
  rclone lsf "$DESTINATION" \
    --config "$CONFIG_FILE" \
    --max-depth 2 | head -n 20

  echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] rclone sync completed successfully"
} 2>&1 | tee -a "$LOG_FILE"

Create the filter file used by the script:

Bash

sudo nano /etc/rclone/raff-sync-filter.txt

Add this content:

Text

* cache/**
* tmp/**
* node_modules/**
* .git/**
* *.tmp
* *.sock
+ **

Lock down the script and filter permissions:

Bash

sudo chown root:root /usr/local/sbin/rclone-raff-object-sync.sh
sudo chmod 750 /usr/local/sbin/rclone-raff-object-sync.sh

sudo chown root:root /etc/rclone/raff-sync-filter.txt
sudo chmod 600 /etc/rclone/raff-sync-filter.txt

Run the script manually:

Bash

sudo /usr/local/sbin/rclone-raff-object-sync.sh

Expected output:

Text

[2026-05-04T12:00:00Z] Starting rclone sync
Source: /srv/app/uploads
Destination: raffs3:my-project-files/uploads
Transferred: ...
Running destination listing check...
example.txt
[2026-05-04T12:00:02Z] rclone sync completed successfully

If this works manually, you can safely schedule it.

Step 11 — Schedule Daily Sync with systemd

Create a systemd service:

Bash

sudo nano /etc/systemd/system/rclone-raff-object-sync.service

Add this content:

Ini

[Unit]
Description=Sync files to Raff Object Storage with rclone
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/rclone-raff-object-sync.sh

Create a systemd timer:

Bash

sudo nano /etc/systemd/system/rclone-raff-object-sync.timer

Add this content:

Ini

[Unit]
Description=Run rclone Raff Object Storage sync daily

[Timer]
OnCalendar=*-*-* 03:15:00
Persistent=true
RandomizedDelaySec=15m
Unit=rclone-raff-object-sync.service

[Install]
WantedBy=timers.target

Reload systemd and enable the timer:

Bash

sudo systemctl daemon-reload
sudo systemctl enable --now rclone-raff-object-sync.timer

Verify the timer:

Bash

systemctl list-timers rclone-raff-object-sync.timer

Expected output:

Text

NEXT                        LEFT     LAST PASSED UNIT                           ACTIVATES
Tue 2026-05-05 03:15:00 UTC 15h      -    -      rclone-raff-object-sync.timer rclone-raff-object-sync.service

Run the service once through systemd:

Bash

sudo systemctl start rclone-raff-object-sync.service

Check recent logs:

Bash

sudo journalctl -u rclone-raff-object-sync.service -n 50 --no-pager

You should see a successful sync log and a small destination listing.

Step 12 — Verify the Scheduled Sync End-to-End

The final step is to verify the whole workflow: local file, scheduled command, object storage destination, and restore path.

Add a new test file:

Bash

echo "scheduled sync verification" | sudo tee /srv/app/uploads/scheduled-test.txt > /dev/null

Run the service:

Bash

sudo systemctl start rclone-raff-object-sync.service

Confirm the file exists in Raff Object Storage:

Bash

sudo rclone ls raffs3:my-project-files/uploads \
  --config /etc/rclone/raff-rclone.conf

Expected output:

Text

       14 example.txt
       28 scheduled-test.txt

Restore the synced files into a clean directory:

Bash

rm -rf ~/rclone-scheduled-restore-test
mkdir -p ~/rclone-scheduled-restore-test

sudo rclone copy raffs3:my-project-files/uploads ~/rclone-scheduled-restore-test \
  --config /etc/rclone/raff-rclone.conf \
  --progress

Inspect the restored files:

Bash

find ~/rclone-scheduled-restore-test -type f -print

Expected output:

Text

/home/ubuntu/rclone-scheduled-restore-test/example.txt
/home/ubuntu/rclone-scheduled-restore-test/scheduled-test.txt

Check the restored file content:

Bash

cat ~/rclone-scheduled-restore-test/scheduled-test.txt

Expected output:

Text

scheduled sync verification

You now have a working rclone sync workflow from a Raff VM to Raff Object Storage, plus a verified restore path.

Step 13 — Roll Back or Remove the Sync Job

If you need to disable the scheduled sync, stop and disable the timer:

Bash

sudo systemctl disable --now rclone-raff-object-sync.timer

To remove the systemd units:

Bash

sudo rm -f /etc/systemd/system/rclone-raff-object-sync.service
sudo rm -f /etc/systemd/system/rclone-raff-object-sync.timer
sudo systemctl daemon-reload

To remove the script and logs:

Bash

sudo rm -f /usr/local/sbin/rclone-raff-object-sync.sh
sudo rm -f /var/log/rclone-raff-object-sync.log

To remove the rclone config and filter:

Bash

sudo rm -f /etc/rclone/raff-rclone.conf
sudo rm -f /etc/rclone/raff-sync-filter.txt

This does not delete files already stored in Raff Object Storage. To remove test data, delete the demo paths carefully:

Bash

sudo rclone purge raffs3:my-project-files/demo \
  --config /etc/rclone/raff-rclone.conf

sudo rclone purge raffs3:my-project-files/demo-filtered \
  --config /etc/rclone/raff-rclone.conf

Warning

rclone purge deletes the target path and everything inside it. Double-check the destination before running purge against production buckets.

Conclusion

You have configured rclone to sync files from an Ubuntu 24.04 Raff VM to Raff Object Storage using the S3-compatible endpoint s3.raffusercloud.com. You created a secure rclone config, uploaded files with copy, tested sync with --dry-run, restored files into a clean directory, added exclusions, and scheduled a daily sync with systemd.

This workflow is useful for application uploads, generated reports, static assets, logs, backup folders, and migration staging. Use rclone copy when you want to upload without deleting destination files. Use rclone sync when you want the destination to exactly match the source, and always test with --dry-run first.

For next steps, read How to Use Raff S3 Object Storage with AWS CLI if you want standard S3 commands, S3-Compatible Object Storage Use Cases for Developers if you want architecture guidance, and Automate Backups with Cron and Rsync on Ubuntu 24.04 if you want a traditional Linux file-backup workflow.

This tutorial was tested on a Raff Ubuntu 24.04 VM using Raff Object Storage as the rclone S3 destination.

Sync Files to Raff Object Storage with rclone (Step-by-Step)

Prerequisites

Introduction

Step 1 — Install rclone on Ubuntu 24.04

Step 2 — Prepare Your Raff Object Storage Credentials

Step 3 — Create a Root-Owned rclone Config File

Step 4 — List Existing Buckets and Create a Test Bucket

Step 5 — Create Sample Files to Sync

Step 6 — Upload Files with rclone copy

Step 7 — Test rclone sync with a Dry Run

Step 8 — Restore Files from Raff Object Storage

Step 9 — Add Exclusions for Cache and Temporary Files

Step 10 — Create a Reusable Sync Script

Step 11 — Schedule Daily Sync with systemd

Step 12 — Verify the Scheduled Sync End-to-End

Step 13 — Roll Back or Remove the Sync Job

Conclusion

Get notified when we publish new tutorials

Frequently Asked Questions

Ready to get started?

Prerequisites

Introduction

Step 1 — Install rclone on Ubuntu 24.04

Step 2 — Prepare Your Raff Object Storage Credentials

Step 3 — Create a Root-Owned rclone Config File

Step 4 — List Existing Buckets and Create a Test Bucket

Step 5 — Create Sample Files to Sync

Step 6 — Upload Files with rclone copy

Step 7 — Test rclone sync with a Dry Run

Step 8 — Restore Files from Raff Object Storage

Step 9 — Add Exclusions for Cache and Temporary Files

Step 10 — Create a Reusable Sync Script

Step 11 — Schedule Daily Sync with systemd

Step 12 — Verify the Scheduled Sync End-to-End

Step 13 — Roll Back or Remove the Sync Job

Conclusion

Get notified when we publish new tutorials

Frequently Asked Questions

What is rclone?

How much does Raff Object Storage cost?

Can rclone work with Raff Object Storage?

What is the difference between rclone copy and rclone sync?

Should I use rclone or AWS CLI for Raff Object Storage?

Ready to get started?