Self-hosted S3 storage
Your own S3 bucket on a real disk. RustFS, Garage or SeaweedFS, tested.
Shelley handles the setup. About 5 minutes.
Prefer a terminal?
curl -fsSL https://exe.dev/deploy/s3-storage/prompt.txt | ssh exe.dev new --prompt=/dev/stdinObject 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
https://my-s3-storage.exe.xyz:9001/rustfs/console/
The RustFS console, behind exe.dev login and RustFS's own
https://my-s3-storage.exe.xyz:9000/
The S3 API for clients that send an exe.dev VM token
http://localhost:9000/
The S3 API for apps on the VM, and for your computer over an SSH tunnel
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.dev/deploy/s3-storage/prompt.txt \
| ssh exe.dev new --prompt=/dev/stdinWhat Shelley is told
Set up S3 storage on this VM by following the exe.dev recipe at https://exe.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
mcand 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, nothttp://app.localhost:9000/key. Most SDKs pick this for custom endpoints; where there's an option, it's calledforcePathStyle,force_path_styleoraddressing_style: path. - The region:
us-east-1works for RustFS and SeaweedFS. Garage insists on the region in itsgarage.toml, usuallygarage.
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:GetObjectonly, 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-1andforce-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:3withREGISTRY_STORAGE=s3,REGISTRY_STORAGE_S3_REGIONENDPOINT=http://localhost:9000andREGISTRY_STORAGE_S3_FORCEPATHSTYLE=truepushed 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:9000through a tunnel,https://my-s3-storage.exe.xyz:9000with a token), and path-style addressing. With a VM token, add the header after signing.401 Unauthorizedfrom 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, usebefore-send.s3, notbefore-sign.s3.AccessDeniedfor the app key: its policy covers theappbucket only. Check withrc admin policy info local app-rw.AuthorizationHeaderMalformedwith Garage: set the region to the one ingarage.toml, usuallygarage.No writable volumes and no free volumes leftwith 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 refusedtohttps://my-s3-storage.exe.xyzfrom the VM itself: a VM can't reach its own exe.xyz address. On the VM, usehttp://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