MinIO is gone: moving a self-hosted S3 to RustFS on Coolify
βSome context
Since 2024, the images of this blog have lived in a MinIO bucket, deployed with one click on my Coolify instance, behind a small image proxy (next-image-transformation + imgproxy). It worked, I never touched it again, and that was the problem.
Here is what happened to MinIO's community edition while I was not looking:
- May 2025: the admin console is removed from the community build, only an object browser remains.
- October 2025: no more pre-built binaries or Docker images, "source only".
RELEASE.2025-10-15T17-29-55Zis the last tagged release. - December 2025: the repository enters maintenance mode. No features, no PR reviews, security fixes "evaluated case by case".
- April 2026: the repository is archived, read-only.
- September 2026:
minio/minioandminio/mcare deleted from Docker Hub.
My service was still running quay.io/minio/minio:latest. Nothing was broken yet, but the next time Coolify had to pull the image, it would have failed. Worse, a CVE published after the archive (CVE-2026-39414) will never be fixed in the community edition. Time to move.
Full disclosure: big thanks to my friend Claude, who did ~95% of the work here (this post included) :D
βWhy RustFS
Coolify itself removed MinIO from its one-click catalog and added RustFS instead, which made the decision easy. RustFS is an S3-compatible object store written in Rust, with a web console, a maintained CLI (rc), and a 1.0 line since October 2026. I looked at Garage and SeaweedFS too. Both are solid, but neither has a Coolify template or a console, and I wanted the boring option.
One warning: RustFS can read MinIO's on-disk format, but only as a preview feature behind a build flag. I did not mount the old volume. We copied the objects over the S3 API instead, which takes five minutes for a blog.
βOne Coolify stack for storage and images
While I was at it, I replaced the image proxy too. I needed signed URLs and a bridge for Symfony UX Image, which Imagor has and imgproxy does not (that is the subject of the next article). RustFS and Imagor now live in a single Coolify resource, created from a Docker Compose file, so Imagor reads the bucket over the stack's private network:
services:
rustfs:
image: rustfs/rustfs:1.0.6
command: /data
environment:
- SERVICE_FQDN_RUSTFS_9000
- SERVICE_FQDN_RUSTFS_9001
- RUSTFS_ADDRESS=0.0.0.0:9000
- RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001
- RUSTFS_CONSOLE_ENABLE=true
- RUSTFS_ACCESS_KEY=${SERVICE_USER_RUSTFS}
- RUSTFS_SECRET_KEY=${SERVICE_PASSWORD_RUSTFS}
- RUSTFS_REGION=eu-west-3
volumes:
- rustfs-data:/data
healthcheck:
test: ["CMD", "sh", "-c", "curl -f http://127.0.0.1:9000/health && curl -f http://127.0.0.1:9001/rustfs/console/health"]
interval: 5s
timeout: 20s
retries: 10
imagor:
image: ghcr.io/cshum/imagor:1.10.4
depends_on:
rustfs:
condition: service_healthy
environment:
- SERVICE_FQDN_IMAGOR_8000
- IMAGOR_SECRET=${SERVICE_HEX_64_IMAGORSECRET}
- IMAGOR_UNSAFE=false
- IMAGOR_SIGNER_TYPE=sha256
- IMAGOR_SIGNER_TRUNCATE=40
- HTTP_LOADER_DISABLE=1
- AWS_ACCESS_KEY_ID=${IMAGOR_AWS_ACCESS_KEY_ID}
- AWS_SECRET_ACCESS_KEY=${IMAGOR_AWS_SECRET_ACCESS_KEY}
- AWS_REGION=eu-west-3
- S3_ENDPOINT=http://rustfs:9000
- S3_FORCE_PATH_STYLE=1
- S3_LOADER_BUCKET=hugo.alliau.me
- S3_RESULT_STORAGE_BUCKET=imagor-results
- IMAGOR_CACHE_HEADER_TTL=8760h
volumes:
rustfs-data:The SERVICE_* variables are Coolify's magic variables: it generates the credentials and a hex secret for Imagor, and binds each domain to its port. rustfs gets two domains (https://s3.example.com:9000 and https://s3-console.example.com:9001) and imagor one (https://image.kocal.fr:8000). The IMAGOR_AWS_* pair is filled in after the first deploy, once the service account exists.
HTTP_LOADER_DISABLE=1 matters: without it, Imagor is an open proxy that will happily resize any image on the internet for anyone who can sign a URL.
βMigrating the objects
mc, MinIO's client, is gone with the rest. rclone does the same job. We ran it in a container on the Coolify host, so no credentials got copied anywhere: the script reads them from the two containers' environments and attaches the rclone container to both Docker networks.
src=minio-<uuid>; dst=rustfs-<uuid>; bucket=hugo.alliau.me
env_of() { docker inspect "$1" --format '{{range .Config.Env}}{{println .}}{{end}}' | sed -n "s/^$2=//p"; }
net_of() { docker inspect "$1" --format '{{range $k,$v := .NetworkSettings.Networks}}{{println $k}}{{end}}' | head -1; }
ctr=$(docker create --rm --network "$(net_of $src)" \
-e RCLONE_CONFIG_SRC_TYPE=s3 -e RCLONE_CONFIG_SRC_PROVIDER=Minio \
-e RCLONE_CONFIG_SRC_ENDPOINT="http://$src:9000" \
-e RCLONE_CONFIG_SRC_ACCESS_KEY_ID="$(env_of $src MINIO_ROOT_USER)" \
-e RCLONE_CONFIG_SRC_SECRET_ACCESS_KEY="$(env_of $src MINIO_ROOT_PASSWORD)" \
-e RCLONE_CONFIG_DST_TYPE=s3 -e RCLONE_CONFIG_DST_PROVIDER=Other \
-e RCLONE_CONFIG_DST_ENDPOINT="http://$dst:9000" -e RCLONE_CONFIG_DST_REGION=eu-west-3 \
-e RCLONE_CONFIG_DST_ACCESS_KEY_ID="$(env_of $dst RUSTFS_ACCESS_KEY)" \
-e RCLONE_CONFIG_DST_SECRET_ACCESS_KEY="$(env_of $dst RUSTFS_SECRET_KEY)" \
rclone/rclone:1.76 sync "src:$bucket" "dst:$bucket" --checksum --dry-run)
docker network connect "$(net_of $dst)" "$ctr"
docker start -a "$ctr"Run it once with --dry-run, once without, then rclone check src:bucket dst:bucket --one-way. Here: 15 files, 0 differences, and MinIO could be stopped.
βLeast privilege, this time
The old setup used the MinIO root key everywhere, and the bucket was publicly readable. The new one has three identities, created with rc, RustFS's CLI, which also runs fine from a container:
rc admin service-account create rustfs/ site-XXXXXXXX secret --policy-json '{
"Version": "2012-10-17",
"Statement": [
{"Effect": "Allow", "Action": ["s3:ListBucket", "s3:GetBucketLocation"], "Resource": ["arn:aws:s3:::hugo.alliau.me"]},
{"Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], "Resource": ["arn:aws:s3:::hugo.alliau.me/*"]}
]
}'- the root key only ever touches the console;
- the site account can read and write the blog bucket, nothing else;
- the imagor account can read the blog bucket and read/write its own
imagor-resultscache bucket.
The bucket itself is private. One video from a 2021 post is embedded with a raw <video> tag, so that single object is readable anonymously through a bucket policy. Nothing else is: a GET on any other key, or a listing, returns 403. On the edge, Caddy exposes the video under https://image.kocal.fr/raw/<bucket>/<key>, GET and HEAD only.
The S3 API and the console are not public at all. Caddy fronts everything on my side. Both hostnames reuse the snippet I already had for the Coolify dashboard, which only answers to my Tailscale network (<coolify-host> is the machine running Coolify's Traefik):
# Requests not coming from the Tailscale network get a 403.
# 100.64.0.0/10 and fd7a:115c:a1e0::/48 are Tailscale's address ranges;
# 172.17.0.1 is the Docker gateway, which is how tailnet traffic reaches Caddy here.
(tailnet_only) {
@outside_tailnet not remote_ip 100.64.0.0/10 fd7a:115c:a1e0::/48 172.17.0.1/32
respond @outside_tailnet 403
}
# Everything Coolify hosts: hand the request to its Traefik, keeping the Host header.
(coolify_proxy) {
reverse_proxy https://<coolify-host> {
transport http {
tls_insecure_skip_verify
tls_server_name {host}
}
header_up Host {host}
}
}
s3.example.com {
import tailnet_only
import coolify_proxy
}
image.kocal.fr {
# /raw/<bucket>/<key>: the raw object, for the few made public by a bucket policy.
@raw {
path /raw/*
method GET HEAD
}
handle @raw {
uri strip_prefix /raw
reverse_proxy https://<coolify-host> {
transport http {
tls_insecure_skip_verify
tls_server_name s3.example.com
}
header_up Host s3.example.com
@ok status 2xx
handle_response @ok {
header Cache-Control "public, max-age=31536000"
copy_response
}
}
}
# Everything else is Imagor.
handle {
import coolify_proxy
}
}The website and Imagor never go through Caddy to reach the bucket: the site's container is attached to Coolify's predefined network and talks to http://rustfs-<uuid>:9000 directly.
βThings that bit us
- The region has to match everywhere. RustFS defaults to
us-east-1. I wantedRUSTFS_REGION=eu-west-3, which then had to be repeated on Imagor (AWS_REGION) and in the site's S3 client. Amusingly, RustFS did not reject a request signed with the wrong region, so you may not notice a mismatch until another client does. - The Imagor secret travels in a URL. My Symfony app receives it inside a DSN query string, so it must not contain
+,/,=or%. Coolify'sSERVICE_HEX_64_*generator gives you a clean hex string. - The console is not at
/. It answers on/rustfs/console/, while the root of port 9001 returns an S3 403. On the login page, open the server configuration and set the API URL (https://s3.example.com). Otherwise the console tries its own hostname, which is the console port. - Imagor's health endpoint is
/healthcheck, and the image tag is1.10.4, without av. - Caddy's
{uri}placeholder is the original URI, even afteruri strip_prefix. The agent's first/rawblock rewrote to/bucket/raw/...and RustFS answered 403. Cloudflare then cached that error for a year, because theCache-Controlheader applied to errors too. Hence thehandle_response @okabove. rc anonymous set download bucket/keycreates a prefix rule (key/), not an object rule. Userc anonymous set-jsonwith an explicit bucket policy for a single object.
βWhat's next
The storage was the easy half. The interesting part is what the blog does with it: images referenced by object key in Markdown, rendered as signed, responsive <img srcset> through Symfony UX Image, uploaded by drag and drop from the admin editor. That is the next article, and I hope it will make you want to give UX Image a try.