---
title: "MinIO is archived. Here's what to do"
description: "MinIO's open-source server is archived: no fixes, no images. See what happened, then copy your buckets and keys to RustFS, Garage, or SeaweedFS on an exe.dev VM."
url: https://exe-staging.dev/deploy/minio
category: "Migration"
published: 2026-11-19
updated: 2026-11-19
---

# MinIO is archived. Here's what to do

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

- **Software:** MinIO (https://www.min.io)
- **Source:** https://github.com/minio/minio
- **License:** AGPL-3.0 (archived)
- **Time:** 30 minutes, plus copying
- **Machine-readable:** https://exe-staging.dev/deploy/minio/manifest.json

## What you get

Running on the 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, data in `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

How it is reached:

- https://my-rustfs.exe.xyz:9000/ (private): the new S3 API, for clients with a VM token; apps on the VM use localhost
- ssh my-rustfs.exe.xyz (private): where you run the copy

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](/deploy/s3-storage).

## What happened

MinIO, Inc. took MinIO private: over 2025 it [moved the admin console and
single sign-on into AIStor](https://github.com/minio/minio/releases/tag/RELEASE.2025-05-24T17-08-30Z),
its proprietary product, and [stopped shipping open-source
builds](https://github.com/minio/minio/commit/9e49d5e7a6), then in 2026 it
[stopped maintaining](https://github.com/minio/minio/commit/7aac2a2c5b)
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](https://github.com/advisories/GHSA-9c4q-hq6p-c237)
  [advisories](https://github.com/advisories/GHSA-hv4r-mvr4-25vw) 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](https://dl.min.io/server/minio/release/) 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](https://www.min.io/pricing),
  [upgrade guide](https://docs.min.io/aistor/upgrade-aistor-server/open-source-minio/)).
  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](/deploy/s3-storage#choose-one) is on the S3 storage page;
in short:

- **[RustFS](/deploy/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](/deploy/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](/deploy/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](/deploy/s3-storage#where-clients-connect-from), public files need
the [public port](/deploy/s3-storage#presigned-urls-and-public-files),
and one VM is [one node](/deploy/s3-storage#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](/deploy/rustfs), [Garage](/deploy/garage), or
[SeaweedFS](/deploy/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:

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

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

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

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

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

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

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

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

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

  ```bash
  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](/deploy/garage#host-a-static-website).
  Anonymous reads need the VM's [public
  port](/deploy/s3-storage#presigned-urls-and-public-files).
- **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](/deploy/s3-storage#where-clients-connect-from)). 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](/deploy/s3-storage#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):

```bash
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](/deploy/s3-storage#where-clients-connect-from). 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:

```nginx
# /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](/deploy/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](/deploy/rustfs): it works most like MinIO, takes MinIO's `mc admin` commands, and can import MinIO's users and policies. [Garage](/deploy/garage) is small and frugal and can serve a bucket as a website; [SeaweedFS](/deploy/seaweedfs) suits millions of small files. [S3 storage](/deploy/s3-storage#choose-one) 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.


## Related

- [Self-hosted S3 storage](https://exe-staging.dev/deploy/s3-storage.md): Your own S3 bucket on a real disk. RustFS, Garage or SeaweedFS, tested.
- [Self-host RustFS](https://exe-staging.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-staging.dev/deploy/garage.md): Small, S3-compatible object storage on a disk you own, private by default.
- [Self-host SeaweedFS](https://exe-staging.dev/deploy/seaweedfs.md): S3-compatible object storage and a file system on one VM's disk, private by default.
- [Migrate a DigitalOcean Droplet to exe.dev](https://exe-staging.dev/deploy/migrate-digitalocean-droplet.md): Same server, new home. Rehearsed while the droplet keeps serving.
- [Deploy a Docker Compose app from GitHub](https://exe-staging.dev/deploy/docker-compose.md): Your compose.yaml on a VM of its own. git push to deploy.
