Backups that actually restore: rclone to Backblaze B2 or Wasabi with restore testing
Ubuntu 24.04 guide: rclone, B2 or Wasabi remote, cron script, and the restore test most skip: verified recovery with checksum validation.
UptimeMag editorial team · 21 November 2026 · 5 min read

Anyone running servers knows this: a backup that has never been restored is not a backup, it's a gamble. This guide covers the entire workflow on Ubuntu 24.04—rclone installation, remote configuration to Backblaze B2 or Wasabi, incremental scripting via cron—and especially the step almost everyone skips: restore testing with checksum verification, in a separate directory, before the backup actually matters.
Installing rclone
On Ubuntu 24.04 the simplest approach is using the official script:
sudo -v
curl https://rclone.org/install.sh | sudo bash
Alternatively, the rclone package is available in Ubuntu repositories but often in an older version: for B2 and S3 backends, it's worth staying on the version updated from the official site.
Configuring the remote to Backblaze B2
Launch the interactive configuration:
rclone config
Create a new remote of type b2, entering the Account ID (or Application Key ID) and Application Key. According to the official rclone documentation, the B2 backend requires an Application Key generated from the Backblaze console, with the applicationKeyId used as the account and the key itself as the key. Once configured, use the remote like this:
rclone mkdir b2remote:bucket-name
rclone sync --interactive /var/backup b2remote:bucket-name
One detail that changes behaviour in case of accidental deletion: B2's default behaviour is to retain old versions of files, so when rclone uploads a new version it creates a new version. Those wanting permanent deletion must use the --b2-hard-delete flag; otherwise deleted files remain recoverable as hidden versions—useful against ransomware that deletes backups, but worth keeping in mind for storage costs.
For performance, official documentation notes that the default value of --transfers 4 is far too low for Backblaze B2, and testing shows an optimal value around --transfers 32.
Configuring the remote to Wasabi
Wasabi is S3-compatible, so in rclone config you select the s3 type and choose Wasabi as the provider, specifying endpoint, access key and secret key created from the Wasabi console. The sync syntax is identical to what we saw for B2:
rclone sync --interactive /var/backup wasabiremote:bucket-name
Real costs: B2 versus Wasabi
Both prices should be read from the official price lists, not summaries floating around:
| Provider | Storage price | Egress | Minimum duration | Minimum bill |
|---|---|---|---|---|
| Backblaze B2 | 6.95 $/TB/month | free up to 3× average storage, then 0.01 $/GB | none | none |
| Wasabi (Pay as You Go) | 7.99 $/TB/month | free | 90 days | 1 TB active storage per account |
According to Backblaze's official price list: B2 Cloud Storage starts at 6.95 $ per TB per month, billed monthly or annually by capacity, with no minimum charges for file size or storage duration, and free egress up to 3 times average storage.
According to Wasabi's official price list, comparing Pay as You Go to Reserved Capacity Storage shows the per-TB price is 7.99 $/month, based on actual daily usage, with a minimum storage duration of 90 days and a monthly minimum tied to 1 TB of active storage per account, while egress and API are free in both plans.
In practical terms: on B2, a small backup (a few tens of GB) costs almost nothing and there's no penalty if you delete it after a week. On Wasabi, even with 50 GB of data, you pay at minimum the equivalent of 1 TB for at least 90 days—a clause that the marketing page doesn't highlight but that the official FAQ confirms.
Incremental backup script with cron
An "incremental" backup with rclone is basically a repeated sync: only new or modified files are transferred, thanks to size and hash checking. Minimal script, to be saved for example at /usr/local/bin/backup-b2.sh:
#!/bin/bash
set -euo pipefail
SRC="/var/www"
DEST="b2remote:bucket-name/www"
LOG="/var/log/backup-b2.log"
echo "=== Backup started: $(date -Iseconds) ===" >> "$LOG"
rclone sync "$SRC" "$DEST" \
--transfers 16 \
--checkers 8 \
--log-file="$LOG" \
--log-level INFO \
--stats 1m
echo "=== Backup completed: $(date -Iseconds) ===" >> "$LOG"
Made executable with chmod +x /usr/local/bin/backup-b2.sh, it's scheduled in crontab (crontab -e):
0 2 * * * /usr/local/bin/backup-b2.sh
Runs the backup every night at 02:00. The --transfers 16 flag is a conservative compromise against the 32 recommended by Backblaze for fast connections; on a VPS with limited bandwidth, lower values reduce the risk of saturating the network during backup hours.
The part almost everyone skips: restore testing
A backup that has never been restored is a hypothesis, not a fact. Testing must be done in a separate directory, never overwriting live data:
mkdir -p /tmp/restore-test
rclone copy b2remote:bucket-name/www /tmp/restore-test \
--transfers 16 \
--log-file=/var/log/restore-test.log
At this point it's not enough to check that the files are there: you need to verify they're identical byte-for-byte. The right command is rclone check, which according to official documentation compares sizes and hashes (MD5 or SHA1) between source and destination and reports differences without modifying either:
rclone check /var/www b2remote:bucket-name/www \
--combined /var/log/restore-check.log
The output file uses precise syntax: a line starting with = indicates an identical file on both sides, - a file missing from the source, + a file missing from the destination, * a file present on both but different, ! a read or hashing error. If the log contains lines with * or !, the backup is not reliable: investigate immediately, not when you actually need it.
For those wanting the strictest possible check, the --download flag forces rclone to download data from both sides and compare them byte-for-byte, instead of relying only on already-calculated hashes—slower, but useful for a periodic full validation test, say once a month.
Schedule the test as well, not just the backup
The verification script should be scheduled separately from the backup, with a delay of a few hours to give the overnight sync time to complete:
0 5 * * 0 /usr/local/bin/restore-check.sh
Runs the restore test every Sunday at 05:00. The content of restore-check.sh mirrors the copy and verification script shown above, with the addition of an exit code check: if rclone check exits with a non-zero code, the script must notify (email, webhook, monitoring system) that the backup has failed verification—don't just write it to the log and hope someone reads it.
In summary
B2 costs less, has no minimum duration and keeps old file versions for extra protection against deletion; Wasabi costs slightly more but eliminates egress without thresholds and has strict minimum duration conditions. In either case, a backup is only as good as its last successful restore test: without scheduled rclone check, you're just paying for the illusion of being covered.
Written with the help of artificial intelligence and checked by the editors (EU AI Act, art. 50).