Skip to content

Self-hosted S3 storage

Your own S3 bucket on a real disk. RustFS, Garage or SeaweedFS, tested.

Deploy on exe.dev

Shelley handles the setup. About 5 minutes.

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

Object storage is where apps keep uploads, backups, build artifacts and anything else that is a file rather than a row. Running your own means an S3-compatible server: every S3 client, SDK and tool works with it, and you point them at your own endpoint instead of Amazon's. On exe.dev it gets a persistent VM with a real disk, HTTPS on every port, and the exe.dev login in front of everything until you choose otherwise. Apps on the same VM talk to it over localhost. Nothing pays per request or per gigabyte downloaded.

For years the answer to "self-host S3" was MinIO. MinIO has stopped maintaining its open-source server and archived the repository in April 2026, so this page compares the three projects that took its place, RustFS, Garage and SeaweedFS, and sets up the one that suits a single VM best. If you run MinIO today, MinIO shows how to move to any of the three.

What you get#

  • RustFS 1.0.6 in Docker Compose, its data in ~/rustfs/data, back after a reboot.
  • Root keys in ~/rustfs/.env (mode 600), and the console at port 9001, private behind exe.dev login.
  • A bucket called app and an app key that can use only that bucket, in ~/rustfs/app.env (mode 600).
  • An object uploaded and read back with the app key, and a second bucket refused to it.
What's running, and where
Private https://my-s3-storage.exe.xyz:9001/rustfs/console/ The RustFS console, behind exe.dev login and RustFS's own
Private https://my-s3-storage.exe.xyz:9000/ The S3 API for clients that send an exe.dev VM token
Private http://localhost:9000/ The S3 API for apps on the VM, and for your computer over an SSH tunnel
my-s3-storage.exe.xyz exe.dev VM
RustFS 1.0.6 rustfs/rustfs in Docker Compose, one node, one disk :9000~/rustfs/data
RustFS console Buckets, keys and policies in the browser, behind exe.dev login :9001
rc 0.1.38 RustFS's command-line client, for buckets, users and policies

Deploy with Shelley#

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

Prefer a terminal?
curl -fsSL \
  https://exe-staging.dev/deploy/s3-storage/prompt.txt \
  | ssh exe.dev new --prompt=/dev/stdin
What Shelley is told
Set up S3 storage on this VM by following the exe.dev recipe at https://exe-staging.dev/deploy/s3-storage.md?via=deploy from top to bottom.

The recipe's example VM name is my-s3-storage. This VM's name is the output of `hostname`: use it wherever the recipe writes my-s3-storage. 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 in Docker Compose, its data in ~/rustfs/data, back after a reboot.
- Root keys in ~/rustfs/.env (mode 600), and the console at port 9001, private behind exe.dev login.
- A bucket called app and an app key that can use only that bucket, in ~/rustfs/app.env (mode 600).
- An object uploaded and read back with the app key, and a second bucket refused to it.

Read the whole recipe, including the closed details, and follow
"Install by hand" from top to bottom. The walkthrough sections are for
the owner afterwards: don't make the VM public, create VM tokens, set up
Tailscale or copy buckets elsewhere during setup. Never overwrite an
existing ~/rustfs/.env or ~/rustfs/app.env. Leave the VM private. Don't
paste keys into the chat; say they are in ~/rustfs/.env and
~/rustfs/app.env, and give the owner the console URL.

Finish with the URLs I should open.

Also at /deploy/s3-storage/prompt.txt. The recipe it follows is /deploy/s3-storage.md.

Choose one#

We ran all three on one exe.dev VM, side by side, with the same tests: the AWS CLI 2.41 with its default checksums, boto3, rclone, 200 MB and 1 GB multipart uploads, presigned URLs, versioning, object lock, and lifecycle rules. Where a row says no, the server answered NotImplemented.

RustFS Garage SeaweedFS
License Apache-2.0 AGPL-3.0 Apache-2.0
Written in Rust Rust Go
Around since 2025; 1.0 in September 2026 2020; 1.0 in April 2024 2015 or earlier
Version tested 1.0.6 v2.5.0 4.54
On one VM One container, settings in env vars One container and a garage.toml; --single-node sets up the rest One container; tune volume sizes on small disks
On several VMs Erasure coding, 4 servers or more Copies in different places (3 recommended); no erasure coding Copies per bucket, erasure coding for older data
Web console Built in None in v2.5 (CLI and admin API) weed admin, plus status pages
Versioning Yes No Yes
Object lock Yes No Yes
Presigned URLs Yes Yes Yes
Lifecycle rules Expiry, and moving to another tier Expiry, and clearing failed uploads Expiry
Bucket policies Yes No; per-key bucket permissions Yes
Static websites No Yes No
Memory after our tests about 150 MB about 50 MB about 240 MB

Feature rows follow each project's own list (RustFS's feature table, Garage's S3 compatibility status, SeaweedFS's S3 API list). We checked versioning, object lock (a locked object refused deletion), presigned URLs, lifecycle rules and bucket policies on each server, and the test results matched those lists.

  • RustFS is the closest thing to MinIO: the same single-container setup, a similar console, the same admin API, so mc and tools built for MinIO work against it. It covers the most of S3. It is also the youngest, out of beta only since September 2026, and has published a steady stream of security fixes, so update it. The default here, and what the Deploy button sets up.
  • Garage is small, steady and frugal, built by a nonprofit to spread copies across a few cheap machines in different places. It skips versioning, object lock and bucket policies on purpose, which is fine for app uploads, Litestream and backups that keep their own history. It can serve a bucket as a public website while the S3 API stays private.
  • SeaweedFS is a whole distributed file system with S3 on top: billions of small files, a filer with WebDAV and FUSE mounts, Iceberg tables. It has the most knobs; on a small disk, set its volume size, or new buckets fail with No free volumes left. Our Langfuse page uses it.

Whichever you pick, the rest of this page applies: where clients connect from, public files, the console, the disk and backups work the same way.

Open the console#

When Shelley finishes, open https://my-s3-storage.exe.xyz:9001/rustfs/console/. exe.dev asks you to log in, then RustFS asks for its own keys. They're on the VM:

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

Sign in with RUSTFS_ACCESS_KEY and RUSTFS_SECRET_KEY. You'll see the app bucket with a hello.txt in it. From the console you can create buckets, upload and download files, turn on versioning, add lifecycle rules, and create more users and access keys.

These are the root keys: they can do anything, including delete every bucket. Use them for the console and admin work, never in an app.

Connect an app on this VM#

Shelley made a bucket called app and a key that can read, write and delete objects in that bucket and nothing else. Its settings are in ~/rustfs/app.env, readable only by you:

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

The AWS SDKs and CLI read AWS_ENDPOINT_URL and the keys from the environment as they are, so for most apps that's the whole configuration. Two settings trip people up:

  • Path-style addressing. Use http://localhost:9000/app/key, not http://app.localhost:9000/key. Most SDKs pick this for custom endpoints; where there's an option, it's called forcePathStyle, force_path_style or addressing_style: path.
  • The region: us-east-1 works for RustFS and SeaweedFS. Garage insists on the region in its garage.toml, usually garage.

On the VM, rc is RustFS's command-line client, signed in with the root keys as local. Another bucket and key for a second app, here blog, with its settings in ~/rustfs/blog.env:

name=blog
secret=$(openssl rand -hex 20)
rc bucket create local/$name
sed "s/:::app/:::$name/" ~/rustfs/app-policy.json > ~/rustfs/$name-policy.json
rc admin policy create local $name-rw ~/rustfs/$name-policy.json
rc admin user add local $name "$secret"
rc admin policy attach local $name-rw --user $name
(umask 077; sed -e "s/=app\$/=$name/" -e "s/^AWS_SECRET_ACCESS_KEY=.*/AWS_SECRET_ACCESS_KEY=$secret/" \
  ~/rustfs/app.env > ~/rustfs/$name.env)

The blog key can use the blog bucket and gets AccessDenied everywhere else.

Apps in Docker containers can't use localhost: start them with --add-host=host.docker.internal:host-gateway (in Compose, extra_hosts: ["host.docker.internal:host-gateway"]) and use http://host.docker.internal:9000.

Where clients connect from#

S3 clients sign every request with the key's secret (AWS Signature Version 4) and put the signature in the Authorization header. A browser login can't add that, and S3 clients can't click through the exe.dev login. So there are four ways in, from safest to most open:

Client How it connects Through exe.dev login?
Apps on the same VM http://localhost:9000 Never leaves the VM
You, from your computer SSH tunnel, then http://localhost:9000 SSH key
Scripts and tools anywhere https://my-s3-storage.exe.xyz:9000 plus a VM token header VM token
Apps on other VMs Tailscale, or exe.dev's VM-to-VM integration with a small relay Tailscale or the integration
Browsers, public files The public port No: S3 keys and signatures only

From your computer#

exe.dev's SSH forwards ports. On your computer, open a tunnel and leave it running:

ssh -N -L 9000:localhost:9000 my-s3-storage.exe.xyz

Then use http://localhost:9000 with any client: the AWS CLI, rclone, Cyberduck, your app in development. This works with every client because nothing in between touches the request.

With a VM token#

exe.dev's VM tokens let a program through the login. The proxy takes the token from an X-Exedev-Authorization header and removes it, and leaves everything S3 cares about alone: the host name with its port, the path, and the Authorization header with the S3 signature. We sent 200 MB multipart uploads with streaming checksums through it to all three servers. Without a token, the proxy answers 401. On your computer, make a token for this VM:

ssh exe.dev ssh-key generate-api-key --vm=my-s3-storage --label=s3 --exp=90d

Add --ips=203.0.113.7/32 to accept it only from one address. The client has to add the header after signing, because the proxy removes it and a signed header that's missing breaks the signature. Clients that can:

  • rclone: --header "X-Exedev-Authorization: Bearer $EXE_TOKEN".
  • mc (MinIO's client): -H "X-Exedev-Authorization: Bearer $EXE_TOKEN".
  • boto3 and the AWS CLI: an event handler on before-send.s3, as below.
import os, boto3

s3 = boto3.client("s3", endpoint_url="https://my-s3-storage.exe.xyz:9000")
s3.meta.events.register(
    "before-send.s3",
    lambda request, **_: request.headers.__setitem__(
        "X-Exedev-Authorization", "Bearer " + os.environ["EXE_TOKEN"]))
print(s3.list_objects_v2(Bucket="app").get("KeyCount"))

The AWS CLI needs that handler as a plugin, and only uses it with preferred_transfer_client = classic; the RustFS page has the files. Apps that only take an endpoint and keys can't send the header; for them, see From another VM or use the public port.

From another VM#

exe.dev VMs don't share a private network. For apps that only take an endpoint and keys, such as Litestream, a container registry or Supabase storage, put both VMs on your Tailscale network; it's preinstalled. On both VMs:

sudo systemctl enable --now tailscaled
sudo tailscale up --hostname=$(hostname)

Open the login URL it prints (or join without one through exe.dev's Tailscale integration). The other VM then uses http://my-s3-storage:9000. RustFS listens on every interface, so nothing else changes, and the S3 traffic goes straight between the two VMs, encrypted by Tailscale, with no exe.dev login in the way.

No Tailscale? exe.dev's VM-to-VM integration works too, with one trick. It lets the other VM in without any key on it, but it changes the host name on the way: the client sends to s3-from-app.int.exe.xyz, and RustFS sees my-s3-storage.exe.xyz:9000. S3 signatures cover the host name, so a client that signs for the address it sends to gets SignatureDoesNotMatch. The fix is a small nginx on the other VM that takes requests for the storage VM's name and passes them on, so the client signs for the name RustFS sees. On your computer, with the other VM called my-app:

ssh exe.dev integrations add http-proxy --name s3-from-app \
  --target https://my-s3-storage.exe.xyz:9000/ --peer --attach vm:my-app

Then on my-app:

sudo apt-get install -y nginx
echo '127.0.0.1 my-s3-storage.exe.xyz' | sudo tee -a /etc/hosts
sudo tee /etc/nginx/conf.d/s3.conf >/dev/null <<'EOF'
server {
  listen 127.0.0.1:9000;
  client_max_body_size 0;
  proxy_request_buffering off;
  proxy_buffering off;
  location / {
    proxy_pass https://s3-from-app.int.exe.xyz;
    proxy_set_header Host s3-from-app.int.exe.xyz;
    proxy_ssl_server_name on;
    proxy_http_version 1.1;
  }
}
EOF
sudo systemctl restart nginx

Apps on my-app then use http://my-s3-storage.exe.xyz:9000 with their S3 keys and nothing else. The plain HTTP never leaves the VM; nginx talks HTTPS to exe.dev. We listed, uploaded, downloaded and sent a 40 MB multipart upload this way with boto3 and rclone. Keep the port at 9000: RustFS sees my-s3-storage.exe.xyz:9000, so the client has to sign for that exact name and port.

Presigned URLs and public files#

A presigned URL carries its signature in the query string, so anyone with the link can download (or upload) that one object until it expires. A browser opening it has no exe.dev login and no way to add a token, so on a private port it gets 401. The same goes for public buckets, images on a website, and anything else people should fetch without signing in.

For those, make the S3 port the VM's public port. On your computer:

ssh exe.dev share port my-s3-storage 9000
ssh exe.dev share set-public my-s3-storage

Now https://my-s3-storage.exe.xyz/ (and :9000) reach RustFS with no exe.dev login, and every other port, including the console on 9001, stays private. Sign URLs for that address, so the host in the signature matches. Signing happens offline, so this works on the VM, where boto3 is a uv run away:

set -a; . ~/rustfs/app.env; set +a
uv run -q --with boto3 python3 - "https://$(hostname).exe.xyz" app hello.txt <<'EOF'
import sys, boto3
from botocore.config import Config
endpoint, bucket, key = sys.argv[1:]
s3 = boto3.client("s3", endpoint_url=endpoint, config=Config(signature_version="s3v4"))
print(s3.generate_presigned_url("get_object", Params={"Bucket": bucket, "Key": key}, ExpiresIn=3600))
EOF

Open the URL it prints in a private browser window: you get hello from my-s3-storage with no login. Change one character of it and RustFS answers 403. In your app, do the same with your SDK's presign call and the public endpoint.

On the public port, your S3 keys are the only lock. That's how S3 works everywhere, but it changes what matters:

  • Give each app its own key, limited to its bucket, as above. Keep the root keys for the console.
  • Never make port 9001 public: RustFS serves its API there too.
  • For a bucket anyone can read, allow s3:GetObject only, so nobody can list it; the RustFS page has the policy.
  • A VM has one public port. If a web app already uses it, put the storage on a VM of its own.
  • For a few public files only, Garage can make its website port public and keep the S3 API private; see Host a static website.

Back to private with ssh exe.dev share set-private my-s3-storage.

Keep the console private#

Every port from 3000 to 9999 is behind the exe.dev login, and only one port can be public, so the console stays private without any work. To let a teammate in, share the VM with them (ssh exe.dev share add my-s3-storage teammate@example.com) and give them a RustFS user of their own from the console, rather than the root keys. A share opens every private port to them, so the RustFS keys are what limits what they can do.

Garage has no console in v2.5; you manage it with the garage command over SSH. SeaweedFS's weed admin listens on 12535 by default; run it on a port from 3000 to 9999 to reach it through exe.dev. The product pages cover both.

Disk and backups#

Everything lives on the VM's disk, in ~/rustfs/data. A new VM has about 20 GB free. Check it on the VM with df -h / and du -sh ~/rustfs/data. When it fills up, uploads fail. Grow the disk from your computer (disks only grow):

ssh exe.dev resize my-s3-storage --disk=200GB

then on the VM sudo resize2fs "$(findmnt -no SOURCE /)". There's no erasure coding on one disk, so 100 GB of objects takes about 100 GB.

A backup of your storage has to live somewhere else. Two things that don't count:

  • A bucket on the same VM. It goes when the VM goes.
  • exe.dev's VM backups. They copy the whole disk, which is good, but into an Amazon S3 bucket of yours. That's fine as long as it's not the storage you're backing up.

The simplest copy is rclone on a timer, from every bucket to a second S3 provider or a second VM. On the VM, with the destination's keys:

sudo -v; curl -fsSL https://rclone.org/install.sh | sudo bash
. ~/rustfs/.env
rclone config create here s3 provider=Minio endpoint=http://localhost:9000 \
  access_key_id=$RUSTFS_ACCESS_KEY secret_access_key=$RUSTFS_SECRET_KEY >/dev/null
rclone config create offsite s3 provider=Other endpoint=https://<endpoint> \
  access_key_id=<key> secret_access_key=<secret> region=<region> >/dev/null
for b in $(rclone lsf here: | tr -d /); do rclone sync here:$b offsite:<bucket>/$b; done

To restore, swap the two sides. The RustFS page turns this into a nightly backup to an off-VM bucket, users and policies included, and helps you get a bucket for it. On Amazon S3, exe.dev's AWS integration gives the VM short-lived credentials instead of keys on disk.

One VM is one node#

One VM is one server with one disk. exe.dev replicates that disk, so a failed drive doesn't lose data, but the storage itself keeps one copy: no erasure coding, no replica on another machine, and the store is down while the VM restarts. For most apps, uploads, Litestream and backups, that's plenty, with a copy elsewhere.

Need it to survive losing a whole VM? That takes several VMs and networking between them, Tailscale in practice:

  • Garage is built for it: three VMs, ideally in different regions, each keeping a full copy.
  • SeaweedFS replicates per bucket and adds erasure coding for older data.
  • RustFS needs four servers or more for erasure coding, and a single-disk setup like this one can't be grown into a cluster later.

We haven't tested a cluster on exe.dev.

Use it from other pages#

Many of our pages need S3. With the storage on the same VM, use http://localhost:9000 (or http://host.docker.internal:9000 from a container) and a key of its own; on another VM, use Tailscale as above.

  • SQLite with Litestream: replicate the database to a bucket. Put the storage on another VM; a replica on the same disk isn't a backup. We restored a database from RustFS with Litestream 0.5.18 using type: s3, endpoint:, region: us-east-1 and force-path-style: true.
  • Supabase: keep Storage's files in a bucket instead of on the VM's disk; see Store files in S3.
  • Langfuse already runs SeaweedFS for its event blobs; to use this storage instead, point its LANGFUSE_S3_* settings here.
  • A Docker registry: registry:3 with REGISTRY_STORAGE=s3, REGISTRY_STORAGE_S3_REGIONENDPOINT=http://localhost:9000 and REGISTRY_STORAGE_S3_FORCEPATHSTYLE=true pushed and pulled an image through RustFS in our test.
  • Your app's uploads: the AWS SDK with app.env, path-style on. For browser uploads and downloads, use presigned URLs on the public port.

The nuts and bolts#

Happy clicking Deploy? You can stop here. These are the steps Shelley follows. The RustFS page has the rest: nightly backups, updates, moving from MinIO, and troubleshooting.

Install by hand

Create the VM#

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

ssh exe.dev new --name=my-s3-storage
ssh my-s3-storage.exe.xyz

The rest runs on the VM. For more than about 15 GB of objects, give it a bigger disk first, as in Disk and backups.

Start RustFS#

The root keys go in ~/rustfs/.env, readable only by you. The container runs as user 10001, so it gets the data and log directories. exeuntu starts Docker on demand; enabling it brings RustFS back after a reboot.

sudo systemctl enable --now docker.service
mkdir -p ~/rustfs/data ~/rustfs/logs && cd ~/rustfs
sudo chown -R 10001:10001 data logs
[ -e .env ] || (umask 077; cat > .env <<EOF
RUSTFS_ACCESS_KEY=admin-$(openssl rand -hex 6)
RUSTFS_SECRET_KEY=$(openssl rand -hex 24)
EOF
)
cat > 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
docker compose up -d
timeout 60 sh -c 'until curl -fsS localhost:9000/health; do sleep 2; done'; echo

Expect "status":"ok" and "version":"1.0.6".

Install rc#

rc is RustFS's command-line client. Install its package, checked against the release's checksums, and sign it in with the root keys:

v=0.1.38
cd /tmp
curl -fsSLO https://github.com/rustfs/cli/releases/download/v$v/rustfs-cli_${v}_amd64.deb
curl -fsSL https://github.com/rustfs/cli/releases/download/v$v/SHA256SUMS |
  grep " rustfs-cli_${v}_amd64.deb\$" | sha256sum -c
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y ./rustfs-cli_${v}_amd64.deb
. ~/rustfs/.env
rc alias set local http://localhost:9000 "$RUSTFS_ACCESS_KEY" "$RUSTFS_SECRET_KEY"

Expect rustfs-cli_0.1.38_amd64.deb: OK and Alias 'local' configured successfully.

Make a bucket and a key for your app#

A policy that allows one bucket, app, and nothing else, then a user with that policy. Its secret is written to ~/rustfs/app.env first:

cd ~/rustfs
cat > app-policy.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {"Effect": "Allow", "Action": ["s3:ListBucket", "s3:GetBucketLocation"], "Resource": ["arn:aws:s3:::app"]},
    {"Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject", "s3:AbortMultipartUpload", "s3:ListMultipartUploadParts"], "Resource": ["arn:aws:s3:::app/*"]}
  ]
}
EOF
[ -e app.env ] || (umask 077; cat > app.env <<EOF
AWS_ENDPOINT_URL=http://localhost:9000
AWS_ACCESS_KEY_ID=app
AWS_SECRET_ACCESS_KEY=$(openssl rand -hex 20)
AWS_REGION=us-east-1
S3_BUCKET=app
EOF
)
. ./app.env
rc bucket create local/app
rc admin policy create local app-rw app-policy.json
rc admin user add local app "$AWS_SECRET_ACCESS_KEY"
rc admin policy attach local app-rw --user app

Expect four lines ending in successfully.

Check it#

Upload and read back a file as the app, and try to make a bucket it isn't allowed to:

cd ~/rustfs && . ./app.env
rc alias set app http://localhost:9000 app "$AWS_SECRET_ACCESS_KEY"
echo "hello from $(hostname)" > /tmp/hello.txt
rc put /tmp/hello.txt app/app/hello.txt
rc object show app/app/hello.txt
rc bucket create app/other || echo "refused, as it should be"
stat -c '%a %n' .env app.env

Expect hello from my-s3-storage, an AccessDenied and refused, as it should be, then 600 for both files. Installation done; continue with Open the console.

Something not working?

On the VM, RustFS's log usually says why: cd ~/rustfs && docker compose logs --tail 50.

  • SignatureDoesNotMatch: the client signed for a different host than the one the request reached. Use the exact endpoint the request goes to (http://localhost:9000 through a tunnel, https://my-s3-storage.exe.xyz:9000 with a token), and path-style addressing. With a VM token, add the header after signing.
  • 401 Unauthorized from a client off the VM: the exe.dev proxy wants a login. Send a VM token, use the SSH tunnel, or make the port public.
  • missing signed header: x-exedev-authorization: the token header was added before signing. In boto3, use before-send.s3, not before-sign.s3.
  • AccessDenied for the app key: its policy covers the app bucket only. Check with rc admin policy info local app-rw.
  • AuthorizationHeaderMalformed with Garage: set the region to the one in garage.toml, usually garage.
  • No writable volumes and no free volumes left with SeaweedFS: each bucket takes volumes of 30 GB by default. Start it with -master.volumeSizeLimitMB=1024 -volume.max=100.
  • RustFS restarts with permission denied: the data or logs directory lost its owner. sudo chown -R 10001:10001 ~/rustfs/data ~/rustfs/logs.
  • Uploads fail and df -h / shows the disk full: resize the VM, as in Disk and backups.
  • Connection refused to https://my-s3-storage.exe.xyz from the VM itself: a VM can't reach its own exe.xyz address. On the VM, use http://localhost:9000; signing a URL for the public address needs no connection, as in Presigned URLs.

Frequently asked questions#

Is MinIO still open source?

Its code is still AGPL-licensed, but nobody maintains it: MinIO put the repository in maintenance mode in December 2025 and archived it in April 2026, and stopped publishing free binaries and images before that. Security fixes now go to its commercial AIStor only. See MinIO for moving off it.

Which should I pick, RustFS, Garage or SeaweedFS?

For one VM, RustFS: one container, a console, and the S3 features most apps ask for, including versioning and object lock. Garage if you want the smallest, longest-running option or a few VMs in different places, and don't need versioning. SeaweedFS for very many files, or if you also want a filer, WebDAV or FUSE mounts. See Choose one.

Can I reach my S3 storage from outside the VM?

Yes. From your computer through an SSH tunnel, from scripts and other VMs with an exe.dev VM token, or from anywhere once you make the S3 port public. See Where clients connect from.

Do presigned URLs work?

Yes, but a browser opening one can't log in to exe.dev, so the S3 port has to be public first. Then the URL's signature is the only thing that lets the request in. See Presigned URLs and public files.

Is a single VM safe for my data?

It's one node: no erasure coding and no second copy inside the storage itself. exe.dev keeps the disk safe from hardware failure, not from a deleted bucket or a lost VM, so copy buckets to a second place. See One VM is one node.

How much does self-hosted S3 cost?

The software is free. You pay for the VM and its disk; see exe.dev pricing. There are no request or download fees.

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