Skip to content

MinIO is archived. Here's what to do

The open-source server is archived. Copy your buckets and keys somewhere maintained.

  • Migration
  • 30 minutes, plus copying
  • Tested Nov 19, 2026

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
Private https://my-rustfs.exe.xyz:9000/ the new S3 API, for clients with a VM token; apps on the VM use localhost
Private ssh my-rustfs.exe.xyz where you run the copy
my-rustfs.exe.xyz exe.dev VM
Your old MinIO Wherever it runs now; read with a read-only key during the copy
RustFS, Garage, or SeaweedFS The new S3 server, set up on its own page the new server's data directory
rclone 1.76 Copies every bucket, then checks both sides
mc RELEASE.2025-08-13T08-35-41Z MinIO's last client, to list and export users, policies, and bucket settings

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 (minioadmin by 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/minio fails (the Docker Hub repository is gone), quay.io/minio/minio refuses anonymous pulls, and dl.min.io answers 410 Gone. Templates that still say image: minio/minio don'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 admin works 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> and garage bucket allow --read --write --owner <name> --key <admin key> instead of rclone 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 with No 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.provision also prints a new key of its own; ignore it or delete it with s3.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 get said download): 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 enable and mc ilm rule add on RustFS, or weed shell on 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#

  1. Stop the apps writing to MinIO (or make them read-only).
  2. Run the copy loop and the check once more.
  3. Change each app's endpoint to http://localhost:9000 if it runs on the new VM, or to the new server's address otherwise (how clients connect). Garage also needs region garage. Apps that sign with virtual-host-style URLs need path-style turned on.
  4. Keep MinIO running, unchanged, for a week or so, then shut it down, delete ~/minio-export, and remove the migrator user 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#

  • AccessDenied on ListObjectsV2 during the copy: the MinIO key has the built-in readonly policy, which can't list. Use the migrate-read policy 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 volumes or HTTP 500 on upload: the volume settings; see the SeaweedFS page. Stop rclone first, since it keeps retrying.
  • Garage: NoSuchBucket from garage bucket allow: the bucket was created over S3 and has no global name. Create buckets with garage bucket create before copying.
  • Garage: AuthorizationHeaderMalformed or signature errors: the region must be garage.
  • mc admin cluster iam import fails 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