MinIO is archived. Here's what to do
The open-source server is archived. Copy your buckets and keys somewhere maintained.
MinIO was the default answer to "self-host S3" for years, and many
templates still use it. Its open-source server is now archived: MinIO,
Inc. stopped publishing binaries and images in October 2025, stopped
maintaining the code in early 2026, and made the repository read-only in
April 2026. A MinIO you already run keeps working, but nothing fixes it
any more, and a fresh docker pull minio/minio fails.
This page shows what happened, what it means for you, and how to copy your buckets, keys, and policies to a maintained S3 server on an exe.dev VM: a persistent VM with a real disk, private behind exe.dev login until you share it, with Shelley on board to run the copy and keep the new server updated. To choose the new server, start at Self-hosted S3 storage.
What you get#
What's running, and where
https://my-rustfs.exe.xyz:9000/
the new S3 API, for clients with a VM token; apps on the VM use localhost
ssh my-rustfs.exe.xyz
where you run the copy
What happened#
MinIO, Inc. took MinIO private: over 2025 it moved the admin console and single sign-on into AIStor, its proprietary product, and stopped shipping open-source builds, then in 2026 it stopped maintaining the open-source code and archived the repository. Development, security fixes included, now happens only in AIStor, which you license from MinIO.
What "archived" means for you#
- The code still exists. It's AGPLv3, and you can still build any release from source (we did, below). The archive stays public.
- No fixes. Two high-severity
advisories let anyone who knows a valid
access key (
minioadminby default) write objects to any bucket without the secret key. They affect the last community release and every commit after it, and the only patched version is AIStor. - No images, no binaries. As of November 19, 2026,
docker pull minio/miniofails (the Docker Hub repository is gone),quay.io/minio/miniorefuses anonymous pulls, and dl.min.io answers410 Gone. Templates that still sayimage: minio/miniodon't start any more. GitHub keeps old release files up to RELEASE.2025-09-07T16-13-09Z, which predates the last security fix. - MinIO's own path is AIStor, a commercial product. Its Free tier is a single-node license that MinIO says upgrades an open-source deployment in place (pricing, upgrade guide). That's a reasonable choice if you want to stay with MinIO; this page covers the open-source route.
Where to go#
Three maintained, open-source S3 servers run well on one exe.dev VM. The comparison is on the S3 storage page; in short:
- RustFS (Apache-2.0) is the closest to MinIO:
one container, a console, MinIO's admin API, so
mc adminworks and your users and policies import as they are. The usual choice when leaving MinIO. - Garage (AGPL-3.0) is small and frugal, built to spread copies over a few cheap machines, and serves buckets as websites. No versioning, object lock, or bucket policies.
- SeaweedFS (Apache-2.0) is a distributed file system with S3 on top, good with millions of small files.
Whichever you choose, the exe.dev parts are the same: apps on the VM use
localhost, other clients reach S3 with a VM
token, public files need
the public port,
and one VM is one node.
Move your data#
The copy runs on the new VM. It reads the old MinIO with a read-only key,
writes to the new server over localhost, and leaves MinIO untouched, so
you can run it as often as you like and switch over when the counts
match. We ran every step below, in order, from MinIO RELEASE.2025-10-15T17-29-55Z
to RustFS 1.0.6, Garage v2.5.0, and SeaweedFS 4.54 on an exe.dev VM, with
rclone 1.76.0 and mc RELEASE.2025-08-13T08-35-41Z: 327 objects in two
buckets, a 120 MB multipart file, names with spaces and accents, and
custom metadata.
1. Set up the new server#
Follow RustFS, Garage, or
SeaweedFS to its first working bucket, with its
admin key at hand. Size the disk for everything in MinIO plus room to
grow: mc du old (step 2) gives the total. The steps here use RustFS on
localhost:9000; the Garage and SeaweedFS differences are noted.
2. Take stock of the old MinIO#
On the new VM, install MinIO's last mc from its GitHub release, which
still works against any S3 server, and rclone:
V=RELEASE.2025-08-13T08-35-41Z
cd /tmp && curl -fsSLO https://github.com/minio/mc/releases/download/$V/mc.linux-amd64.$V
echo "$(curl -fsSL https://github.com/minio/mc/releases/download/$V/mc.linux-amd64.$V.sha256sum | cut -d' ' -f1) mc.linux-amd64.$V" | sha256sum -c
sudo install -m 755 mc.linux-amd64.$V /usr/local/bin/mc
curl -fsSL https://rclone.org/install.sh | sudo bash
Point mc at the old server with its root credentials (mc prompts for
the secret, so it stays out of your shell history), then list what's
there:
mc alias set old https://minio.example.com minioadmin
mc du old --depth 2
mc admin user list old
mc admin policy entities old
for b in $(mc ls old --json | jq -r .key | tr -d /); do
echo "== $b"; mc anonymous get old/$b; mc version info old/$b; mc ilm rule ls old/$b
done
mkdir -p ~/minio-export && cd ~/minio-export
mc admin cluster iam export old && mc admin cluster bucket export old
chmod 600 *.zip
mc ilm rule ls reports an error for a bucket without lifecycle rules;
that's expected. old-iam-info.zip holds every user, service account, and policy,
including their secret keys in plain text: keep it on the VM, and
delete it when you're done. old-bucket-metadata.zip holds each bucket's
policy, versioning, lifecycle, and other settings, for reference.
If MinIO isn't reachable from the internet, run this on a machine that
can reach it, so the new VM sees it at localhost:19000 (exe.dev's SSH
allows the reverse tunnel; we tested it):
ssh -N -R 19000:localhost:9000 my-rustfs.exe.xyz
Then use http://localhost:19000 as the old endpoint on the VM.
3. A read-only key for the copy#
MinIO's built-in readonly policy can't list buckets, so rclone fails
with AccessDenied on ListObjectsV2. Make a policy that can, and a user
for the copy:
cat > /tmp/migrate-read.json <<'EOF'
{"Version": "2012-10-17", "Statement": [{"Effect": "Allow",
"Action": ["s3:ListAllMyBuckets", "s3:GetBucketLocation", "s3:ListBucket", "s3:GetObject", "s3:GetObjectTagging"],
"Resource": ["arn:aws:s3:::*"]}]}
EOF
mc admin policy create old migrate-read /tmp/migrate-read.json
MIGRATE_SECRET=$(openssl rand -hex 24)
mc admin user add old migrator "$MIGRATE_SECRET"
mc admin policy attach old migrate-read --user migrator
Give rclone both ends. new is the new server's admin key (in RustFS's
env file, Garage's garage key create output, or SeaweedFS's env file):
rclone config create old s3 provider=Minio endpoint=https://minio.example.com \
access_key_id=migrator secret_access_key="$MIGRATE_SECRET"
rclone config create new s3 provider=Other endpoint=http://localhost:9000 \
access_key_id=<new admin key> secret_access_key=<new admin secret>
rclone lsd old: && rclone lsd new:
For Garage, add region=garage and use port 3900; for SeaweedFS, use
provider=SeaweedFS and port 8333.
4. Copy every bucket#
for b in $(rclone lsf --dirs-only old: | tr -d /); do
rclone mkdir "new:$b"
rclone sync "old:$b" "new:$b" --metadata --checksum --transfers 8 --progress
done
--metadata keeps content types, Cache-Control, and custom metadata
(checked on all three servers). Run the loop again at any time; it only
copies what changed. rclone streams through the VM, so a large store takes
as long as the old server's upload bandwidth allows.
Note
Garage: create each bucket with
garage bucket create <name>andgarage bucket allow --read --write --owner <name> --key <admin key>instead ofrclone mkdir. A bucket created over S3 is private to the key that made it, and other keys can't be given access to it. SeaweedFS: set the volume size first, as its page does, or the second or third bucket fails withNo writable volumes; rclone then retries for a long time.
mc mirror --preserve old/<bucket> new/<bucket> does the same job (with
mc alias set new http://localhost:9000 <new admin key>); we tested it
too. We use rclone because it's maintained and its check step below
compares checksums.
5. Check the counts#
for b in $(rclone lsf --dirs-only old: | tr -d /); do
echo "$b: $(rclone size "old:$b" --json) -> $(rclone size "new:$b" --json)"
rclone check "old:$b" "new:$b" --one-way
done
Each bucket should show the same count and bytes on both sides and
0 differences found. In our test, all 302 and 25 objects matched on
each of the three servers.
6. Keys and policies#
Give each app the same access key and secret it had, so the only change is the endpoint.
-
RustFS imports MinIO's export directly; users, service accounts, and policies came across with their secrets:
mc alias set new http://localhost:9000 <new admin key> mc admin cluster iam import new ~/minio-export/old-iam-info.zip -
Garage has keys with per-bucket permissions instead of policies. Import each app's key and allow it on its buckets:
garage key import --yes <access key> <secret key> garage bucket allow --read --write app-uploads --key <access key> -
SeaweedFS: make a user with a role on its bucket, then give it the old key:
weed shell <<'EOF' s3.user.provision -name webapp -bucket app-uploads -role readwrite s3.accesskey.create -user webapp -access_key <access key> -secret_key <secret key> EOF(
s3.user.provisionalso prints a new key of its own; ignore it or delete it withs3.accesskey.delete.)
The secrets for each user and service account are in
iam-assets/users.json and iam-assets/svcaccts.json inside
old-iam-info.zip. We checked each app key on each server: it could read
and write its own bucket and was refused on another.
7. Bucket settings#
rclone copies objects, not settings. From the stock-taking in step 2:
- Public buckets (
mc anonymous getsaiddownload):mc anonymous set download new/<bucket>on RustFS and SeaweedFS; for Garage, serve the bucket as a website. Anonymous reads need the VM's public port. - Versioning and lifecycle rules: recreate them with
mc version enableandmc ilm rule addon RustFS, orweed shellon SeaweedFS. Garage has neither. Only current versions were copied. - Replication, event notifications, object lock, and tiering: set up again by hand if you used them, and test them; they're the least compatible part of S3.
8. Switch over#
- Stop the apps writing to MinIO (or make them read-only).
- Run the copy loop and the check once more.
- Change each app's endpoint to
http://localhost:9000if it runs on the new VM, or to the new server's address otherwise (how clients connect). Garage also needs regiongarage. Apps that sign with virtual-host-style URLs need path-style turned on. - Keep MinIO running, unchanged, for a week or so, then shut it down,
delete
~/minio-export, and remove themigratoruser on the new server too if the IAM import brought it along (mc admin user remove new migrator).
To keep the new store safe, copy its buckets somewhere else too: see disk and backups.
If you must keep MinIO for now#
Warning
MinIO's open-source server gets no security fixes. Its last release has known high-severity holes, including writes to any bucket with just an access key. Keep it private, keep the time short, and move.
If an app can't move yet, run the last release, built from source, where only you can reach it.
Pin the last release. There are no binaries for it, so build it (about 4 minutes on a 2-CPU VM; the Go module proxy keeps the source):
go install github.com/minio/minio@RELEASE.2025-10-15T17-29-55Z
The binary lands in ~/go/bin/minio and reports its version as
DEVELOPMENT.GOGET; the tag in the command is the version. Pin that tag,
not @latest, so a rebuild doesn't pick up anything new.
Keep it off the internet. Listen on 127.0.0.1, never make its port
the VM's public port, and reach it from elsewhere with an SSH tunnel or a
VM token through the private
proxy. Change
minioadmin, and give each app its own key.
Block the unpatched upload path. The advisories' workaround is to refuse requests that use the unsigned-trailer upload. Put nginx (already on exe.dev VMs) in front, with MinIO moved to port 9010:
# /etc/nginx/sites-enabled/minio
server {
listen 9000;
client_max_body_size 0;
proxy_request_buffering off;
location / {
if ($http_x_amz_content_sha256 = "STREAMING-UNSIGNED-PAYLOAD-TRAILER") { return 403; }
proxy_pass http://127.0.0.1:9010;
proxy_set_header Host $http_host;
proxy_http_version 1.1;
proxy_set_header Connection "";
}
}
Start MinIO with --address 127.0.0.1:9010, then
sudo systemctl enable --now nginx && sudo systemctl reload nginx. In
our test, rclone, mc, and boto3 uploads (including multipart) still
worked over http://localhost:9000, and a request with the unsigned
trailer got 403. Over HTTPS, recent AWS SDKs and the AWS CLI use that
trailer by default, so through the exe.dev proxy boto3 got 403 until we
set request_checksum_calculation=when_required (or the environment
variable AWS_REQUEST_CHECKSUM_CALCULATION=when_required).
Troubleshooting#
AccessDeniedonListObjectsV2during the copy: the MinIO key has the built-inreadonlypolicy, which can't list. Use themigrate-readpolicy from step 3.pull access denied for minio/minio: the image no longer exists. Move to another server, or build the last release as above.- SeaweedFS:
No writable volumesor HTTP 500 on upload: the volume settings; see the SeaweedFS page. Stop rclone first, since it keeps retrying. - Garage:
NoSuchBucketfromgarage bucket allow: the bucket was created over S3 and has no global name. Create buckets withgarage bucket createbefore copying. - Garage:
AuthorizationHeaderMalformedor signature errors: the region must begarage. mc admin cluster iam importfails on Garage or SeaweedFS: only RustFS speaks MinIO's admin API. Recreate keys as in step 6.- Counts differ after the copy: apps were still writing to MinIO, or a bucket has objects only as old versions. Stop the writes and run the loop and the check again.
Frequently asked questions#
Is MinIO still open source?
The code is: github.com/minio/minio is still public under the AGPLv3, and you may build, run, and fork it. But it is archived and read-only, MinIO no longer publishes binaries or images for it, and known security holes in its last release have no open-source fix. MinIO's maintained server is AIStor, a commercial product.
Why does `docker pull minio/minio` fail?
The image is gone. As of November 2026, minio/minio on Docker Hub returns "repository does not exist", quay.io/minio/minio refuses anonymous pulls, and dl.min.io answers "410 Gone". Compose files and one-click templates that still name minio/minio no longer start.
What should I use instead of MinIO?
For one exe.dev VM, RustFS: it works most like MinIO, takes MinIO's mc admin commands, and can import MinIO's users and policies. Garage is small and frugal and can serve a bucket as a website; SeaweedFS suits millions of small files. S3 storage compares them.
Can my apps keep their access keys?
Yes, on all three, in our test. RustFS imports MinIO's IAM export (mc admin cluster iam import); Garage takes a key you give it (garage key import); SeaweedFS adds one with s3.accesskey.create. Apps then change only the endpoint, plus the region garage for Garage.
Does rclone copy old object versions?
No. rclone sync copies the current version of each object, with its content type and metadata. Versioning, lifecycle rules, replication, and event notifications are bucket settings you recreate on the new server, where it supports them.
What is AIStor Free?
MinIO's own suggestion for community users: a proprietary build of AIStor, free with a license key, for a single node, and not to be redistributed. MinIO says existing open-source deployments can upgrade to it in place. We haven't tested it, since it needs a sign-up.
Published Nov 19, 2026 · Updated Nov 19, 2026 · tested end to end Nov 19, 2026 · Markdown · manifest.json · Something wrong? Tell us