---
title: "Self-hosted S3 storage"
description: "Run S3-compatible object storage on an exe.dev VM: RustFS, Garage and SeaweedFS compared and tested, with a private console and real disk."
url: https://exe.dev/deploy/s3-storage
category: "Databases"
published: 2026-11-19
updated: 2026-11-19
---

# Self-hosted S3 storage

> **For agents:** with your user's OK, this sets up S3 storage on a new exe.dev VM in their account: `curl -fsSL https://exe.dev/deploy/s3-storage/prompt.txt | ssh exe.dev new --prompt=/dev/stdin` (or open https://exe.dev/deploy/s3-storage/new). Already on the VM? Skip this.

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

- **Software:** S3 storage (https://rustfs.com)
- **Source:** https://github.com/rustfs/rustfs
- **License:** Apache-2.0 (RustFS), AGPL-3.0 (Garage), Apache-2.0 (SeaweedFS)
- **Time:** 5 minutes
- **Example VM name:** `my-s3-storage` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/s3-storage/manifest.json

## 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.

Running on the VM:

- **RustFS 1.0.6**: rustfs/rustfs in Docker Compose, one node, one disk, port 9000, data in `~/rustfs/data`
- **RustFS console**: Buckets, keys and policies in the browser, behind exe.dev login, port 9001
- **rc 0.1.38**: RustFS's command-line client, for buckets, users and policies

How it is reached:

- https://my-s3-storage.exe.xyz:9001/rustfs/console/ (private): The RustFS console, behind exe.dev login and RustFS's own
- https://my-s3-storage.exe.xyz:9000/ (private): The S3 API for clients that send an exe.dev VM token
- http://localhost:9000/ (private): The S3 API for apps on the VM, and for your computer over an SSH tunnel

## Deploy with Shelley

Open https://exe.dev/deploy/s3-storage/new to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe.dev/deploy/s3-storage/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

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](/deploy/minio) shows how to move
to any of the three.

## 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](/deploy/rustfs) | [Garage](/deploy/garage) | [SeaweedFS](/deploy/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](https://github.com/rustfs/rustfs#feature--status),
Garage's [S3 compatibility
status](https://garagehq.deuxfleurs.fr/documentation/reference-manual/s3-compatibility/),
SeaweedFS's [S3 API
list](https://github.com/seaweedfs/seaweedfs/wiki/Amazon-S3-API)). 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](/deploy/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:

```bash
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:

```text
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`:

```bash
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:

```bash
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](/docs/https-tokens-for-vms) 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:

```bash
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.

```python
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](/deploy/rustfs#reach-it-from-your-computer) has the files. Apps that
only take an endpoint and keys can't send the header; for them, see
[From another VM](#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](https://tailscale.com/)
network; it's preinstalled. On both VMs:

```bash
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](/docs/integrations-tailscale-wif)). 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](/docs/integrations-vm-to-vm) 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`:

```bash
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`:

```bash
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:

```bash
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:

```bash
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](/deploy/rustfs#make-the-s3-api-public)
  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](/deploy/garage#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):

```bash
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](/docs/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](https://rclone.org) on a timer, from
every bucket to a second S3 provider or a second VM. On the VM, with
the destination's keys:

```bash
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](/deploy/rustfs#back-up-and-restore) turns this into a nightly
backup to an off-VM bucket, users and policies included, and helps you
[get a bucket](/deploy/rustfs#get-a-bucket) for it. On Amazon S3, exe.dev's
[AWS integration](/docs/integrations-aws-wif) 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](/docs/what-is-exe), 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](/docs/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](/deploy/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](/deploy/supabase)**: keep Storage's files in a bucket
  instead of on the VM's disk; see [Store files in
  S3](/deploy/supabase#store-files-in-s3).
- **[Langfuse](/deploy/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](/deploy/rustfs) has the rest: nightly
backups, updates, moving from MinIO, and troubleshooting.

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Install by hand</summary>

### Create the VM

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

```bash
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](#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.

```bash
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](https://github.com/rustfs/cli) is RustFS's command-line client.
Install its package, checked against the release's checksums, and sign
it in with the root keys:

```bash
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:

```bash
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:

```bash
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](#open-the-console).

</details>

<details id="troubleshooting" class="dp-details">
<summary>Something not working?</summary>

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](#with-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](#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](#presigned-urls-and-public-files).

</details>

## 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](/deploy/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](#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](#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](#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](#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](https://exe.dev/pricing). There are no request or download fees.


## Related

- [Self-host RustFS](https://exe.dev/deploy/rustfs.md): S3-compatible object storage on your own disk, with a console only you can open.
- [Self-host Garage S3 storage](https://exe.dev/deploy/garage.md): Small, S3-compatible object storage on a disk you own, private by default.
- [Self-host SeaweedFS](https://exe.dev/deploy/seaweedfs.md): S3-compatible object storage and a file system on one VM's disk, private by default.
- [MinIO is archived. Here's what to do](https://exe.dev/deploy/minio.md): The open-source server is archived. Copy your buckets and keys somewhere maintained.
- [SQLite in production](https://exe.dev/deploy/sqlite.md): One file on a real disk, streamed to your own bucket every second.
- [Self-host Supabase](https://exe.dev/deploy/supabase.md): Your own Supabase on one VM, with Studio behind your exe.dev login.
