Skip to content

Self-host RustFS

S3-compatible object storage on your own disk, with a console only you can open.

Deploy on exe.dev

Shelley handles the setup. About 10 minutes.

Prefer a terminal?
curl -fsSL https://exe.dev/deploy/rustfs/prompt.txt | ssh exe.dev new --prompt=/dev/stdin

RustFS is an S3-compatible object store written in Rust, under the Apache license: point any S3 client or SDK at it and it behaves like a bucket on Amazon S3. Here it runs on an exe.dev VM's own disk, so files survive restarts and reboots, and both the console and the S3 API stay behind exe.dev's login until you decide otherwise. Apps on the VM use it over localhost; your laptop and scripts get in with a VM token or an SSH tunnel. Shelley, the agent on the VM, sets it all up and can later make app keys, apply updates, or restore a file for you. For how it compares with Garage and SeaweedFS, see self-hosted S3 storage.

The RustFS console listing buckets, with a storage usage chart and a sidebar of admin pages
The RustFS console at port 9001, after exe.dev's login and RustFS's own.

What you get#

  • RustFS 1.0.6 on the VM's disk, with its own root keys, started at boot.
  • The S3 API at http://localhost:9000 on the VM and, with a VM token, at https://my-rustfs.exe.xyz:9000/.
  • The RustFS console at https://my-rustfs.exe.xyz:9001/, behind exe.dev login.
  • An app bucket and a key that can use only that bucket, in ~/rustfs/app.env.
  • Nightly backups of every bucket, user, and policy to a bucket off the VM, one restored and checked.
What's running, and where
Private https://my-rustfs.exe.xyz:9001/ the RustFS console, signed in with the root keys
Private https://my-rustfs.exe.xyz:9000/ the S3 API, for clients that send a VM token
my-rustfs.exe.xyz exe.dev VM
RustFS 1.0.6 rustfs/rustfs in Docker Compose, one node on one disk :9000~/rustfs/data
RustFS console Buckets, users, and policies, behind exe.dev login :9001
rc and rclone RustFS's admin CLI and rclone, for app keys, backups, and moves
Nightly backups Every bucket, user, and policy, to your bucket at another provider

Deploy with Shelley#

Click Deploy and Shelley will set up RustFS on a new VM, then check that it works. No config-file wrangling required.

Have these ready; Shelley asks for them:

  • OFFSITE_BUCKET: an empty bucket at another provider for the nightly backups (get one), or none to keep them on the VM for now
  • OFFSITE_ENDPOINT: R2: https://<ACCOUNT_ID>.r2.cloudflarestorage.com; Backblaze B2: https://s3.<region>.backblazeb2.com; another RustFS: https://<vm>.exe.xyz; Amazon S3: leave empty
  • OFFSITE_REGION: auto for R2, the bucket's region for B2 and Amazon S3, us-east-1 for RustFS
  • OFFSITE_ACCESS_KEY_ID: a key that can read and write that bucket, and nothing else
  • OFFSITE_SECRET_ACCESS_KEY: the key's secret
Prefer a terminal?
curl -fsSL \
  https://exe.dev/deploy/rustfs/prompt.txt \
  | ssh exe.dev new --prompt=/dev/stdin

When it's done, run this on your computer (only you can):

ssh exe.dev ssh-key generate-api-key --vm=my-rustfs --label=s3 --exp=90d
ssh -N -L 9000:localhost:9000 my-rustfs.exe.xyz
What Shelley is told
OFFSITE_BUCKET=<fill-this-in>
OFFSITE_ENDPOINT=<fill-this-in>
OFFSITE_REGION=<fill-this-in>
OFFSITE_ACCESS_KEY_ID=<fill-this-in>
OFFSITE_SECRET_ACCESS_KEY=<fill-this-in>

Set up RustFS on this VM by following the exe.dev recipe at https://exe.dev/deploy/rustfs.md?via=deploy from top to bottom.

The values at the top of this message are mine:
- OFFSITE_BUCKET: an empty bucket at another provider for the nightly backups ([get one](#get-a-bucket)), or `none` to keep them on the VM for now
- OFFSITE_ENDPOINT: R2: `https://<ACCOUNT_ID>.r2.cloudflarestorage.com`; Backblaze B2: `https://s3.<region>.backblazeb2.com`; another RustFS: `https://<vm>.exe.xyz`; Amazon S3: leave empty
- OFFSITE_REGION: `auto` for R2, the bucket's region for B2 and Amazon S3, `us-east-1` for RustFS
- OFFSITE_ACCESS_KEY_ID: a key that can read and write that bucket, and nothing else
- OFFSITE_SECRET_ACCESS_KEY: the key's secret
Ask me for any that still say <fill-this-in> before you need them.

The recipe's example VM name is my-rustfs. This VM's name is the output of `hostname`: use it wherever the recipe writes my-rustfs. Skip the step that creates the VM; you are on it.

You are done when all of these are true. Check each one yourself:
- RustFS 1.0.6 on the VM's disk, with its own root keys, started at boot.
- The S3 API at `http://localhost:9000` on the VM and, with a VM token, at `https://my-rustfs.exe.xyz:9000/`.
- The RustFS console at `https://my-rustfs.exe.xyz:9001/`, behind exe.dev login.
- An `app` bucket and a key that can use only that bucket, in `~/rustfs/app.env`.
- Nightly backups of every bucket, user, and policy to a bucket off the VM, one restored and checked.

Read the whole recipe, including the closed details. For initial setup,
follow "Install by hand" from top to bottom: Docker, the root keys,
RustFS in Docker Compose, rc and the app bucket, rclone and the backup
timer, and the backup test. The walkthrough sections are for the owner
afterwards: don't make the VM public, change its shared port, move data
from MinIO, or run the Restore or Update instructions during setup.
Write the owner's OFFSITE_* values into ~/rustfs/offsite.env without
printing the secret. If OFFSITE_BUCKET is `none` or the owner has no
bucket yet, skip "Give the backups a bucket", run the "No bucket yet?"
block instead of the one before it, and tell the owner that the backups
stay on the VM until they add a bucket ("Add a bucket later"). If the bucket
already holds a `rustfs/` folder, stop and ask the owner: it may be
another VM's backup, which the nightly sync would overwrite.
Never overwrite an existing ~/rustfs/.env or ~/rustfs/*.env file.
Delete only the scratch bucket and the scratch restore the backup test
creates. Leave the VM private and do not reboot. Don't paste keys into
the chat; say they are in ~/rustfs/.env and ~/rustfs/app.env.

Finish with the URLs I should open and these commands, which only I can run, from my own computer (with this VM's name in them):
  ssh exe.dev ssh-key generate-api-key --vm=my-rustfs --label=s3 --exp=90d
  ssh -N -L 9000:localhost:9000 my-rustfs.exe.xyz

Also at /deploy/rustfs/prompt.txt. The recipe it follows is /deploy/rustfs.md.

Open the console#

When Shelley finishes, open https://my-rustfs.exe.xyz:9001/. exe.dev asks you to sign in first; then RustFS asks for its own keys. They're the root keys, in ~/rustfs/.env on the VM:

ssh my-rustfs.exe.xyz cat rustfs/.env

The console creates buckets, uploads and downloads files, and manages users, policies, versioning, and lifecycle rules. It is private because every port of the VM is: only you, and people you share the VM with, reach it, and they still need RustFS keys. Port 9001 serves the S3 API too, so never make it the public port.

Connect an app on this VM#

Your app's bucket is called app, and its key can use only that bucket. The settings are in ~/rustfs/app.env, readable only by you:

AWS_ENDPOINT_URL=http://localhost:9000
AWS_REGION=us-east-1
AWS_ACCESS_KEY_ID=app
AWS_SECRET_ACCESS_KEY=<secret>
S3_BUCKET=app

Recent AWS SDKs and the aws command read these variables as they are. Other libraries want the same values under their own names: endpoint http://localhost:9000, region us-east-1, and path-style addressing (forcePathStyle: true in JavaScript, use_path_style_endpoint in PHP, force_path_style in Ruby). In Python:

import boto3

s3 = boto3.client("s3")  # reads AWS_ENDPOINT_URL and the keys from the environment
s3.upload_file("report.pdf", "app", "reports/2026/report.pdf")
print(s3.list_objects_v2(Bucket="app")["KeyCount"])

A second app gets a bucket and key of its own. On the VM:

~/rustfs/new-app.sh photos
cat ~/rustfs/photos.env

new-app.sh creates the bucket, a policy allowing only that bucket, and a user with a random secret, and writes photos.env. The nightly backup picks the bucket up.

In a Docker container on the VM? localhost is the container itself. Give the service in your Compose file extra_hosts: ["host.docker.internal:host-gateway"] and use http://host.docker.internal:9000. Self-hosted apps that take an S3 endpoint, such as Supabase or Langfuse, can use it with a key from new-app.sh; we haven't tested those pairings.

Reach it from your computer#

The S3 API is at https://my-rustfs.exe.xyz:9000/, and like the console it's private: exe.dev answers 401 until a request proves it's you. S3 keys can't do that, because S3 clients put their own signature in the Authorization header. There are two ways in; where clients connect from compares them with the public port.

An SSH tunnel#

The simplest, and every S3 client works unchanged. On your computer:

ssh -N -L 9000:localhost:9000 my-rustfs.exe.xyz

While it runs, use the endpoint http://localhost:9000 with any client, and http://localhost:9001 opens the console.

A VM token#

For scripts and machines without your SSH key, make a token for this VM. On your computer:

mkdir -p ~/.config/exedev
ssh exe.dev ssh-key generate-api-key --vm=my-rustfs --label=s3 --exp=90d > ~/.config/exedev/vm-token
chmod 600 ~/.config/exedev/vm-token

The client sends it in an X-Exedev-Authorization: Bearer <token> header, which exe.dev checks and removes before the request reaches RustFS. The header has to be added after the client signs the request, or RustFS rejects the signature. With rclone, which has a flag for it:

rclone config create my-rustfs s3 provider=Other \
  endpoint=https://my-rustfs.exe.xyz:9000 \
  access_key_id=app secret_access_key=<secret>
rclone --header "X-Exedev-Authorization: Bearer $(cat ~/.config/exedev/vm-token)" \
  copy ./photos my-rustfs:app/photos

With boto3, add the header in the before-send event:

from pathlib import Path
import boto3

token = (Path.home() / ".config/exedev/vm-token").read_text().strip()
s3 = boto3.client("s3", endpoint_url="https://my-rustfs.exe.xyz:9000",
                  aws_access_key_id="app", aws_secret_access_key="<secret>",
                  region_name="us-east-1")
def add_token(request, **kwargs):
    request.headers["X-Exedev-Authorization"] = f"Bearer {token}"
s3.meta.events.register("before-send.s3", add_token)

s3.upload_file("backup.tar", "app", "backup.tar")

MinIO's mc takes the header as -H "X-Exedev-Authorization: Bearer $(cat ~/.config/exedev/vm-token)", on mc alias set too, since it checks the keys right away.

The aws command needs a small plugin, exedev_token.py, which adds the header to requests for *.exe.xyz only, and the classic transfer client (the newer one skips plugins). On your computer:

mkdir -p ~/.aws/plugins
curl -fsSL -o ~/.aws/plugins/exedev_token.py https://exe.dev/deploy/rustfs/exedev_token.py
cat >> ~/.aws/config <<EOF

[plugins]
cli_legacy_plugin_path = $HOME/.aws/plugins
exedev_token = exedev_token

[profile my-rustfs]
endpoint_url = https://my-rustfs.exe.xyz:9000
region = us-east-1
s3 =
  preferred_transfer_client = classic
EOF
aws configure set --profile my-rustfs aws_access_key_id app
aws configure set --profile my-rustfs aws_secret_access_key '<secret>'
aws --profile my-rustfs s3 ls s3://app/

If you already have a [plugins] section, add the two lines to it instead. A 300 MB multipart upload passed with all four clients. Through exe.dev's proxy it ran at about 13 MB/s up and 30 MB/s down, so for big one-off moves, copy over the SSH tunnel or run rclone on the VM.

Make the S3 API public#

Presigned URLs opened by a browser, public-read buckets, and apps on other machines that can't add a header (Litestream, most self-hosted apps) need the S3 port to answer without exe.dev's login. On your computer:

ssh exe.dev share port my-rustfs 9000
ssh exe.dev share set-public my-rustfs

Now https://my-rustfs.exe.xyz/ is the S3 API, open to the internet, with RustFS's keys as the only gate. Anyone without a key gets AccessDenied. The console on port 9001 stays private. exe.dev has one public port per VM, so this takes the place of a website on port 8000; presigned URLs and public files covers the trade-offs. Use the endpoint without a port from now on:

url = s3.generate_presigned_url("get_object", Params={"Bucket": "app", "Key": "report.pdf"},
                                ExpiresIn=3600)
# https://my-rustfs.exe.xyz/app/report.pdf?AWSAccessKeyId=app&...

The URL has to be signed for the address the browser will use, so make the client with endpoint_url="https://my-rustfs.exe.xyz", not localhost. To let anyone read one bucket's files without listing them, give it a bucket policy. On the VM:

cat > ~/rustfs/assets-public.json <<'EOF'
{"Version": "2012-10-17",
 "Statement": [{"Effect": "Allow", "Principal": {"AWS": ["*"]},
                "Action": ["s3:GetObject"], "Resource": ["arn:aws:s3:::assets/*"]}]}
EOF
rc bucket anonymous set-json ~/rustfs/assets-public.json local/assets

Now https://my-rustfs.exe.xyz/assets/logo.png opens for anyone, while listing the bucket stays denied. rc bucket anonymous set download local/assets is shorter, but lets anyone list the files too.

To go private again: ssh exe.dev share set-private my-rustfs.

From another exe.dev VM? VMs share no private network. Use the public port with a scoped key, a VM token if the client can add headers, or Tailscale on both VMs with the endpoint http://my-rustfs:9000.

Versioning and object lock#

Turn on versioning for a bucket, and overwritten or deleted files keep their old versions. On the VM:

rc bucket version enable local/app
rc bucket lifecycle rule add local/app --noncurrent-expiry-days 30
rc object list --versions local/app/reports/

The lifecycle rule deletes old versions after 30 days, so they don't fill the disk. Object lock goes further: no one, root included, can delete a locked version until its retention runs out. It has to be chosen when the bucket is made:

rc bucket create local/audit --with-lock
rc bucket lock set local/audit --mode governance --days 30

The nightly backup copies only each file's current version.

Move from MinIO#

MinIO's open-source server and its mc client are archived on GitHub, and its Docker images are no longer published. RustFS speaks the same API, so clients only need a new endpoint and keys. The data folder isn't interchangeable, so copy the buckets. On the RustFS VM, with the old server reachable (its public URL, or an SSH tunnel to it):

rclone config create minio s3 provider=Minio endpoint=https://old-minio.example.com \
  access_key_id=<minio root key> secret_access_key=<minio root secret>
for b in $(rclone lsf --dirs-only minio: | tr -d /); do
  rclone mkdir "rustfs:$b"
  rclone sync "minio:$b" "rustfs:$b" --checksum --transfers 8
  rclone check "minio:$b" "rustfs:$b"
done

Then bring the users and their policies across with MinIO's last mc release, which still works against both servers:

curl -fsSL -o ~/mc https://github.com/minio/mc/releases/download/RELEASE.2025-08-13T08-35-41Z/mc.linux-amd64.RELEASE.2025-08-13T08-35-41Z
chmod +x ~/mc
set -a; . ~/rustfs/.env; set +a
~/mc alias set old https://old-minio.example.com <minio root key> <minio root secret>
~/mc alias set new http://localhost:9000 "$RUSTFS_ACCESS_KEY" "$RUSTFS_SECRET_KEY"
~/mc admin cluster iam export old
~/mc admin cluster iam import new old-iam-info.zip
rm old-iam-info.zip

In our test, MinIO's users kept their secret keys and their policies, so apps only change the endpoint. The zip holds those secrets, which is why it's deleted. Bucket settings (policies, versioning, lifecycle rules) don't travel with the files: set them again. The MinIO page has the timeline, moves to Garage and SeaweedFS, and how to run MinIO safely in the meantime.

Keep an eye on it#

curl -s localhost:9000/health on the VM prints RustFS's version and status, and the console's Running Status page shows the disk and server. To be told when it stops, point Uptime Kuma on the same VM at http://localhost:9000/health/ready. RustFS has no Prometheus endpoint to scrape; it can push OpenTelemetry metrics, traces, and logs to a collector named in RUSTFS_OBS_ENDPOINT (not tested here). Its own log is in ~/rustfs/logs.

Keep your data#

One VM is one disk, so RustFS keeps a single copy of each file. Every night, backup.sh copies every bucket to a bucket at another provider, moves files that changed or disappeared since the night before into changed/<date>, and saves the users and policies in iam/. It keeps 14 days of changes. If the VM goes away, you lose at most the changes since the last run, and the backup takes no space on the VM's disk. Keep that bucket's key somewhere besides the VM, such as your password manager: you need it to restore.

Watch the disk with df -h /. RustFS stops taking uploads when it's full. To grow it, on your computer:

ssh exe.dev resize my-rustfs --disk=100GB

Then on the VM: sudo resize2fs "$(findmnt -no SOURCE /)". RustFS sees the space at once.

Get a bucket#

Any S3-compatible provider works; Shelley asks for these details. Don't use a bucket on this VM: a backup into itself is gone with it. Disk and backups compares the options, including exe.dev's VM backups.

  • Cloudflare R2 has a free tier and no fees for downloads. Create a bucket, then an API token with Object Read & Write on that bucket only. Note the Access Key ID, the Secret Access Key, and the endpoint https://<ACCOUNT_ID>.r2.cloudflarestorage.com; the region is auto.
  • Backblaze B2: create a private bucket and an application key for it. The endpoint is on the bucket's page, and the region is the part after s3. in it.
  • Amazon S3: create a bucket and an IAM user whose policy allows only that bucket. Leave the endpoint empty and give the bucket's region.
  • Another exe.dev VM: run this page on a second VM, make its S3 API public, and make a bucket and key there with ~/rustfs/new-app.sh backups. The endpoint is https://<vm>.exe.xyz and the region us-east-1.

We tested the backup against RustFS on a second VM; R2, B2, and S3 use the same rclone settings but weren't tested here. Use one empty bucket per RustFS VM. No bucket yet? Shelley keeps the backups in ~/rustfs/backups on the VM until you add one; they undo mistakes but don't survive losing the VM, and they double the space your files use.

The nuts and bolts#

Happy clicking Deploy? You can stop here. These are the same setup steps Shelley follows, plus the maintenance commands for later.

Install by hand

Create a VM#

On your computer (pick another name if my-rustfs is taken):

ssh exe.dev new --name=my-rustfs
ssh my-rustfs.exe.xyz

All remaining commands run on the VM, as exedev. A new VM has a 25 GB disk; df -h / shows what's free. Expecting more data than that, grow the disk now.

Start Docker#

Docker is installed on exe.dev's image but only starts on demand. Start it at boot, so RustFS comes back after a restart:

sudo systemctl enable --now docker.service
docker compose version

Make the root keys#

RustFS's built-in keys are rustfsadmin/rustfsadmin; replace them before it first starts. This writes random ones to ~/rustfs/.env, readable only by you, unless the file is already there:

mkdir -p ~/rustfs/data ~/rustfs/logs
cd ~/rustfs
[ -e .env ] || (umask 077; cat > .env <<EOF
RUSTFS_ACCESS_KEY=admin-$(openssl rand -hex 6)
RUSTFS_SECRET_KEY=$(openssl rand -hex 24)
EOF
)
ls -l .env
sudo chown 10001:10001 data logs

The last line hands the data and log folders to the user RustFS runs as inside its container.

Start RustFS#

Write ~/rustfs/compose.yaml. It pins RustFS 1.0.6, keeps data and logs in the folders above, and publishes the S3 API on port 9000 and the console on 9001:

cat > ~/rustfs/compose.yaml <<'EOF'
services:
  rustfs:
    image: rustfs/rustfs:1.0.6
    restart: unless-stopped
    env_file: .env
    environment:
      RUSTFS_VOLUMES: /data
      RUSTFS_ADDRESS: 0.0.0.0:9000
      RUSTFS_CONSOLE_ENABLE: "true"
      RUSTFS_CONSOLE_ADDRESS: 0.0.0.0:9001
      RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS: ""
      RUSTFS_OBS_LOG_DIRECTORY: /logs
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - ./data:/data
      - ./logs:/logs
EOF
cd ~/rustfs && docker compose up -d
sleep 5
curl -s localhost:9000/health; echo
curl -s -o /dev/null -w 'console %{http_code}\n' localhost:9001/rustfs/console/

Expect "status":"ok" with "version":"1.0.6", then console 200. The empty RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS stops other websites' pages from calling the console's API; the image allows any by default. Both ports stay behind exe.dev's login, since the VM is private.

Install rc and rclone#

rc is RustFS's command-line client and admin tool; rclone copies buckets for backups and moves. Install both, pinned and checked:

cd /tmp
curl -fsSLO https://github.com/rustfs/cli/releases/download/v0.1.38/rustfs-cli-linux-amd64-v0.1.38.tar.gz
curl -fsSLO https://github.com/rustfs/cli/releases/download/v0.1.38/rustfs-cli-linux-amd64-v0.1.38.tar.gz.sha256
sha256sum -c rustfs-cli-linux-amd64-v0.1.38.tar.gz.sha256
tar -xzf rustfs-cli-linux-amd64-v0.1.38.tar.gz
sudo install -m 0755 rc /usr/local/bin/rc

curl -fsSLO https://downloads.rclone.org/v1.76.0/rclone-v1.76.0-linux-amd64.zip
curl -fsSL https://downloads.rclone.org/v1.76.0/SHA256SUMS | grep ' rclone-v1.76.0-linux-amd64.zip$' | sha256sum -c
unzip -q -o rclone-v1.76.0-linux-amd64.zip
sudo install -m 0755 rclone-v1.76.0-linux-amd64/rclone /usr/local/bin/rclone
rc --version; rclone version | head -n 1

Give both the root keys. Each saves them in a config file only you can read (~/.config/rc/config.toml, ~/.config/rclone/rclone.conf):

set -a; . ~/rustfs/.env; set +a
rc alias set local http://localhost:9000 "$RUSTFS_ACCESS_KEY" "$RUSTFS_SECRET_KEY"
rclone config create rustfs s3 provider=Other endpoint=http://localhost:9000 \
  access_key_id="$RUSTFS_ACCESS_KEY" secret_access_key="$RUSTFS_SECRET_KEY" >/dev/null
rc admin info cluster local

rc admin info should show one online drive.

Create the app bucket#

new-app.sh makes a bucket, a policy that allows only that bucket, a user with a random secret, and an .env file with the settings. Fetch it, read it, and make the app bucket:

curl -fsSL -o ~/rustfs/new-app.sh https://exe.dev/deploy/rustfs/new-app.sh
chmod +x ~/rustfs/new-app.sh
~/rustfs/new-app.sh app

Check that the new key works in its own bucket and nowhere else:

(set -a; . ~/rustfs/app.env; rc alias set app-check "$AWS_ENDPOINT_URL" "$AWS_ACCESS_KEY_ID" "$AWS_SECRET_ACCESS_KEY")
echo hello | rc pipe app-check/app/hello.txt
rc object show app-check/app/hello.txt
rc bucket create app-check/not-mine || echo "denied, as it should be"
rc object remove app-check/app/hello.txt
rc alias remove app-check

Expect hello, then an Access Denied error and denied, as it should be.

Give the backups a bucket#

The nightly backup goes to a bucket at another provider (Get a bucket lists some). Put its details in a file only you can read. Run this, then fill in your values with nano ~/rustfs/offsite.env:

(umask 077; [ -e ~/rustfs/offsite.env ] || cat > ~/rustfs/offsite.env <<'EOF'
OFFSITE_BUCKET=
OFFSITE_ENDPOINT=
OFFSITE_REGION=
OFFSITE_ACCESS_KEY_ID=
OFFSITE_SECRET_ACCESS_KEY=
EOF
)

Make it an rclone remote called offsite, and check that the bucket answers and has no backup in it yet:

set -a; . ~/rustfs/offsite.env; set +a
rclone config create offsite s3 provider="$([ -n "$OFFSITE_ENDPOINT" ] && echo Other || echo AWS)" \
  endpoint="$OFFSITE_ENDPOINT" region="$OFFSITE_REGION" \
  access_key_id="$OFFSITE_ACCESS_KEY_ID" secret_access_key="$OFFSITE_SECRET_ACCESS_KEY" \
  no_check_bucket=true >/dev/null
echo ok | rclone rcat "offsite:$OFFSITE_BUCKET/rustfs-check.txt"
rclone cat "offsite:$OFFSITE_BUCKET/rustfs-check.txt"
rclone deletefile "offsite:$OFFSITE_BUCKET/rustfs-check.txt"
rclone lsf "offsite:$OFFSITE_BUCKET/rustfs/"

Expect ok and nothing after it. An error means a wrong endpoint, region, or key: fix offsite.env and run it again. If it lists current/ or iam/, the bucket already holds a RustFS backup; use another bucket, or see Restore everything on a new VM.

Set up nightly backups#

backup.sh copies every bucket to BACKUP_DEST, keeps what changed for KEEP_DAYS, and exports the users and policies with rc. BACKUP_DEST is any rclone path; here it is the rustfs/ folder of your bucket:

curl -fsSL -o ~/rustfs/backup.sh https://exe.dev/deploy/rustfs/backup.sh
chmod +x ~/rustfs/backup.sh
[ -e ~/rustfs/backup.env ] || cat > ~/rustfs/backup.env <<EOF
BACKUP_DEST=offsite:$(sed -n 's/^OFFSITE_BUCKET=//p' ~/rustfs/offsite.env)/rustfs
KEEP_DAYS=14
EOF
cat ~/rustfs/backup.env

No bucket yet? Run this instead of the block above. It uses a folder on the VM; add a bucket soon:

curl -fsSL -o ~/rustfs/backup.sh https://exe.dev/deploy/rustfs/backup.sh
chmod +x ~/rustfs/backup.sh
mkdir -p ~/rustfs/backups && chmod 700 ~/rustfs/backups
[ -e ~/rustfs/backup.env ] || printf 'BACKUP_DEST=%s\nKEEP_DAYS=14\n' "$HOME/rustfs/backups" > ~/rustfs/backup.env
cat ~/rustfs/backup.env

Schedule it, then take a first backup:

sudo tee /etc/systemd/system/rustfs-backup.service >/dev/null <<EOF
[Unit]
Description=Back up RustFS buckets, users, and policies
After=docker.service

[Service]
Type=oneshot
User=$USER
ExecStart=$HOME/rustfs/backup.sh
EOF
sudo tee /etc/systemd/system/rustfs-backup.timer >/dev/null <<'EOF'
[Unit]
Description=Back up RustFS every night

[Timer]
OnCalendar=*-*-* 03:30:00
RandomizedDelaySec=30m
Persistent=true

[Install]
WantedBy=timers.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now rustfs-backup.timer
sudo systemctl start rustfs-backup.service
systemctl list-timers rustfs-backup.timer
. ~/rustfs/backup.env; rclone lsf "$BACKUP_DEST" && rclone lsf "$BACKUP_DEST/iam"

Expect a next run time, the folders env/ and iam/ (and current/ once a bucket holds files), and a zip named for today's date and time. For failures: journalctl -u rustfs-backup.service.

Test a backup#

Put a file in the app bucket, back up, then restore the bucket from the backup into a scratch bucket and compare the two:

head -c 20M /dev/urandom > /tmp/restore-test.bin
rclone copy /tmp/restore-test.bin rustfs:app/restore-test/
~/rustfs/backup.sh
. ~/rustfs/backup.env
rclone copy "$BACKUP_DEST/current/app" rustfs:restore-scratch
rclone check rustfs:app rustfs:restore-scratch
(umask 077; rclone copyto "$BACKUP_DEST/iam/$(rclone lsf "$BACKUP_DEST/iam" | sort | tail -n 1)" /tmp/iam-test.zip)
unzip -l /tmp/iam-test.zip | grep -c json

Expect 0 differences found and a count of a few JSON files (users, policies, groups). Remove only the scratch bucket and the test file:

rclone purge rustfs:restore-scratch
rclone delete rustfs:app/restore-test/
rm /tmp/restore-test.bin /tmp/iam-test.zip
rc bucket list local

rc bucket list should show only app. Installation done; continue with Open the console.

Back up and restore

On the VM, ~/rustfs/backup.sh takes an extra backup. In BACKUP_DEST you find:

  • current/<bucket>/: every bucket as plain files, as of the last run.
  • changed/<date>/<bucket>/: files that were replaced or deleted that night, kept for KEEP_DAYS.
  • iam/iam-<date>-<time>.zip: users, their secret keys, groups, and policies.
  • env/: ~/rustfs/.env and the apps' .env files.

The zip and env/ hold every key, so keep backups private.

Undo a mistake#

Deleted or overwrote a file? Copy it back from last night's copy, or from the day it changed. On the VM:

. ~/rustfs/backup.env
rclone lsf -R "$BACKUP_DEST/changed/" | grep q3.pdf
rclone copy "$BACKUP_DEST/current/app/reports/" rustfs:app/reports/ --dry-run
rclone copyto "$BACKUP_DEST/changed/2026-11-18/app/reports/q3.pdf" rustfs:app/reports/q3.pdf

Drop --dry-run once the list looks right. A bucket with versioning on has the old version itself: rc undo local/app/reports/q3.pdf.

Add a bucket later#

Started with backups on the VM? Get a bucket, then on the VM run the two blocks of Give the backups a bucket, point the backup at it, and take a backup:

sed -i "s|^BACKUP_DEST=.*|BACKUP_DEST=offsite:$(sed -n 's/^OFFSITE_BUCKET=//p' ~/rustfs/offsite.env)/rustfs|" ~/rustfs/backup.env
~/rustfs/backup.sh

The first run uploads everything; later runs send only what changed. Once it has run, rm -r ~/rustfs/backups frees the space the local copy took.

Restore everything on a new VM#

Make a new VM and follow Install by hand with these changes, so the new VM gets the old keys before RustFS first starts:

  1. Run Start Docker and the first block of Install rc and rclone, then make the folders, but not the keys:

    mkdir -p ~/rustfs/data ~/rustfs/logs
    sudo chown 10001:10001 ~/rustfs/data ~/rustfs/logs
    
  2. Run both blocks of Give the backups a bucket, with the old bucket. It lists current/, env/, and iam/: that's your backup.

  3. Bring back the root keys and the apps' settings:

    . ~/rustfs/offsite.env
    (umask 077; rclone copy "offsite:$OFFSITE_BUCKET/rustfs/env/" ~/rustfs/ --ignore-existing --include '/*.env')
    ls -la ~/rustfs
    
  4. Run Start RustFS and the second block of Install rc and rclone. Then copy the buckets back and import the users:

    . ~/rustfs/backup.env
    for b in $(rclone lsf --dirs-only "$BACKUP_DEST/current" | tr -d /); do
      rclone mkdir "rustfs:$b"
      rclone copy "$BACKUP_DEST/current/$b" "rustfs:$b" --transfers 8
    done
    z=$(rclone lsf "$BACKUP_DEST/iam" | sort | tail -n 1)
    (umask 077; rclone copyto "$BACKUP_DEST/iam/$z" /tmp/iam.zip)
    rc admin iam import local --file /tmp/iam.zip --yes --conflict overwrite
    rm /tmp/iam.zip
    rc admin user list local
    

    rc admin user list should show your apps' users. If the import failed, fix that first: the next backup saves this server's users as the newest export.

  5. Run Set up nightly backups, skipping the local-folder block. backup.env is already back, so the backup carries on into the same folder.

--conflict overwrite is needed even on a new server, because the export includes RustFS's built-in policies. The users come back with their old secrets, so the apps' .env files still work. Set versioning, lifecycle rules, and bucket policies again: backups don't carry them. Turn off the old VM's backup timer, if it still runs, so the two don't write to the same folder.

Update RustFS

Read the release notes for the versions you're skipping. Take a backup, change the tag in compose.yaml, and restart. On the VM:

~/rustfs/backup.sh
cd ~/rustfs
sed -i 's|rustfs/rustfs:1.0.6|rustfs/rustfs:1.0.7|' compose.yaml
docker compose pull && docker compose up -d
sleep 5; curl -s localhost:9000/health; echo

The health line shows the new version. Uploads fail for the few seconds RustFS restarts; S3 clients retry. Going back is the same with the old tag. Update rc and rclone the same way you installed them, with the new version in the URLs.

Something not working?

On the VM, RustFS's own view usually explains it:

cd ~/rustfs && docker compose ps && docker compose logs --tail 50
curl -s localhost:9000/health; echo
  • 401 Unauthorized from https://my-rustfs.exe.xyz:9000: that's exe.dev, not RustFS. The client didn't send a VM token, or it expired. Test the token with curl -s -o /dev/null -w '%{http_code}\n' -H "X-Exedev-Authorization: Bearer $(cat ~/.config/exedev/vm-token)" https://my-rustfs.exe.xyz:9000/health, which should print 200.
  • aws s3api works but aws s3 cp gets 401: the newer transfer client skips plugins. Set preferred_transfer_client = classic as in A VM token.
  • SignatureDoesNotMatch: the request was signed for another address than the one it reached (a presigned URL made with localhost but opened at my-rustfs.exe.xyz), or the token header was added before signing (boto3's before-sign event instead of before-send).
  • AccessDenied: the key's policy doesn't allow it. App keys from new-app.sh can use only their own bucket; that's on purpose.
  • The container restarts over and over, with Permission denied: the data or log folder isn't owned by RustFS's user. Run sudo chown -R 10001:10001 ~/rustfs/data ~/rustfs/logs.
  • Detected default root credentials in the log: RustFS started without ~/rustfs/.env and uses rustfsadmin. Make the keys as in Make the root keys and docker compose up -d.
  • InvalidBucketName: bucket names are 3 to 63 characters of lowercase letters, digits, dots, and dashes.
  • The console won't sign in: use the root keys from ~/rustfs/.env (or another user's keys), at https://my-rustfs.exe.xyz:9001/.
  • RustFS isn't running after a reboot: docker.service isn't enabled. Run sudo systemctl enable --now docker.service.
  • Disk full: uploads fail. Check df -h / and du -sh ~/rustfs/*, then grow the disk. Backups still on the VM? Move them to a bucket.
  • The backup fails with AccessDenied or 403 from the bucket: the key in ~/rustfs/offsite.env can't write that bucket, or the endpoint or region is wrong. journalctl -u rustfs-backup.service shows the failing call; fix the file and run both blocks of Give the backups a bucket again.

Frequently asked questions#

Is RustFS ready for production?

RustFS 1.0 shipped in September 2026, and 1.0.6 is the version tested here. This page runs one server on one disk, which RustFS's own docs recommend for development, testing, and small, non-critical workloads: there is no second copy of anything until a backup runs. That's why the nightly backups go to a bucket off the VM.

Can I use it as a MinIO replacement?

For clients, yes: the AWS SDKs, aws, rclone, and MinIO's mc all worked against it, including mc admin for users and policies. MinIO's data folder can't be reused, so copy the buckets with rclone and import MinIO's users with mc.

Can a browser open a presigned URL?

Only if the S3 port is public. exe.dev keeps every port behind its login until you make the S3 API public; then presigned URLs and public-read buckets work, and S3 keys are the only gate.

How much can I store?

As much as the VM's disk holds; the backups live elsewhere. Grow the disk any time with ssh exe.dev resize my-rustfs --disk=100GB and resize2fs; see Keep your data.

Can I add more disks or nodes later?

Not to this setup. A single-disk RustFS can't be grown into a multi-disk or multi-node cluster in place, and one exe.dev VM is one node anyway. Grow the disk instead, or copy the buckets to a new deployment with rclone.

Can people sign in to the console with their exe.dev account?

Not instead of RustFS's keys. exe.dev's login sits in front of the console, so only people you share the VM with reach it, and RustFS then asks for its own keys. Give each teammate a RustFS user of their own in the console's Users page.

Is RustFS free?

Yes, under the Apache License 2.0, and so are rc and rclone. You pay for the VM; see exe.dev plans.

Published Nov 19, 2026 · Updated Nov 19, 2026 · tested end to end Nov 19, 2026 · Markdown · manifest.json · Something wrong? Tell us