> 2026-03-02: Ruohang Feng has forked MinIO to pgsty/minio and is promising to maintain a stable, CVE-patched, distribution.

This is what I went with.

I use it in end to end tests as an S3 simulator that starts and stops instantly and reads & writes to a local directory, - as you'd expect it's great in that role. No complaints. Given the fork's maintainer puts their real name on it & stakes their reputation, you'd assume it can be trusted - but my use case is simpler than most.

Garage added an automatic configuration feature in v2.3.0 that makes it easier to set up single nodes:

  garage server --single-node --default-bucket

https://garagehq.deuxfleurs.fr/documentation/quick-start/

A notable mention should also be Versity GW, https://github.com/versity/versitygw/

Running Sentry on prem, I had to swap out their default SeaweedFS setup for Garage because the former kept failing under concurrent writes. I tried digging around for a bit, but found that the swap was easier and faster, Garage has also worked great for single node use cases (e.g. tested up to around 10 TB of data). I still think that SeaweedFS is a cool project, might have been a config issue or something, wasn’t worth tweaking.

The setup for Garage sucks, especially cause their Docker image doesn’t automatically create keys or buckets and permissions for you like for example various RDBMS images do. Doing that the first time manually was annoying, but their docs are pretty nice and an AI agent can build you your own Docker image with custom init in about 15 minutes.

Worst with it I’ve had were issues with hooking up WinSCP to it directly to browse saved satellite data, initial connections would hang for some reason, not sure what the problem was either.

Also used Zenko but kinda got the feeling that the project wasn’t as healthy and straight up felt abandoned (e.g. the outdated container images and such), though there is some activity.

My https://github.com/uroni/hs5 is designed for this use case.

One notable thing is that compared to MinIO (and others) it does not store the objects as individual files. I also have DuckDB directly integrated.

The readme has a comparison to Garage, seaweedfs, RustFS and Ceph.

A weird target, the author has.

The title is 'for single node local S3' but what they actually mean is 'for minio-compatibility', which is an entirely different question.

When I abandoned minio a year or so ago, I also surveyed the options, and settled on Garage. It lacked the GUI, but felt about the same complexity as minio. Perhaps a smidge more complexity, as I moved to 3-node and 5-node separate instances of garage, running as containers under Nomad.

I don't recall it being onerous, but I was looking for some basic S3-alike capabilities, not just minio-alike.

(How many people set out to build an object storage system with some number of AWS S3 primitives, but primarily try to match a third-party proprietary system's foibles?)

> So, Garage does work, but gosh…it is not just a drop-in replacement in terms of code changes.

I think in terms of actual code that uses local S3, it pretty much was a drop-in replacement. (I have multiple distribution/registry, Grafana Loki / Mimir, influx3 - all backing onto my object storage system, and the config changes there were modest - key+secret, and url - just as you'd expect.)

Filestash (https://github.com/mickael-kerjean/filestash) has a s3 gateway plugin that I made. It proxy the S3 traffic to any downstream storage: SFTP, FTP, another S3, SMB, NFS, IPFS, ...

We ran RustFS in production at a past job.

Was the backend for an archiving service and we found it to work well on baremetal machines and seamlessly integrated with existing services that used the S3 api.

This was on an internal network so YMMV when it comes to running on the open internet especially with the CVE mentioned in the post.

I had previously used seaweedfs, which has more moving parts but seems more feature-rich. It was overkill for a homelab, so I went to garage.

Garage is very stable, but the metadata engine / file MUST live on NVMe. Otherwise it gets slow on small files. It also lacks features like per bucket retention settings and stuff. It really is "just" a S3 bucket.

I wouldnt use Garage for Iceberg, Iceberg relies on conditional PUT working correctly, while Garage is eventually consistent, so they don't provide the correct guarantee.

Is there any "local"/minio-esque object store properly implements the full conditional GET/PUT/DELETE spec, ETag, etc.? I have struggled to find this in the past.

For single-node local S3, I often just use `s3fs` mounting a local directory. MinIO always felt like overkill for simple dev.

Does anyone here have experience using some of the newer S3 family API features like locking with any of the self-hostable options? After reading about celld's Litestream + locking on S3 approach (https://github.com/denoland/celld) I got curious about that style of deployment as a way to consolidate small tools so their state is just centralize S3 buckets, but from a bit of reading support for the features like locking is uneven.

I did try seaweedfs ~half a year ago and I had issues with setting up users through terraform module (if I recall correctly, users endpoint were not correctly responding on delete), and lack of S3 expiry rules (you needed to use seaweedfs configuration or API for that). Other than that, I was pretty happy with it.

Incus (spiritual successor to LXD, after the fork-off by Canonical) has a simple S3 server built-in.

I run Scality S3 (Zenko Cloudserver in the blig) since about 2 years and it is quite capable and frequently updated. Just make sure to point it to the latest Github Registry, not the outdated Docker.com one.

One alternative worth looking at is S2: https://github.com/mojatter/s2

Versity's posix backend was the one that stuck for us, multipart uploads land as real files on disk so you can inspect them with ls when a test fails.

Rustfs, works pretty well for me

I ended up just getting Claude to hack together a compatible-enough S3 thing for my self-hosted Sourcehut releases. It took like 45 minutes and it seems to work well enough (though I haven't done exhaustive tests because "good enough is good enough" for this).

The S3 API is pretty well-documented so getting something compatible with it is trivial for modern AI tools.

Start a ready-to-use SeaweedFS S3 object store:

AWS_ACCESS_KEY_ID=admin AWS_SECRET_ACCESS_KEY=secret S3_BUCKET=my-bucket ./weed mini -dir=./data

That's it.

The S3 endpoint is at http://localhost:8333, my-bucket exists, and admin/secret are valid credentials.

It also starts an Iceberg REST catalog and S3 Table Buckets for Iceberg and Lance tables, with table maintenance jobs.

I'm still disappointed, that there is no S3 CNCF sponsored process. It seems to be such an important part of the cloud native ecosystem, every big use case needs some way to store blobs of data.

But no, I'm also not about to start one or try to make something like SeaweedFS a community supported project that has a chance to be picked up by the CNCF, so I'm part of the problem.

Really happy with my own https://deltaglider.com/

- Filesystem backend - Encrypted S3 backend - Compressed S3 backend (Saving a ton of money here) - Cross backend replication - Full IAM - Full GUI with OIDC auth

The recent RustFS CVE has driven some people away from RustFS, based on comments from the community. For those who had similar past experiences: Do events like this actually affect the long-term popularity and development?

I use JuiceFS https://github.com/juicedata/juicefs if you think the Chinese are worth the trust

I enjoyed the smooth transition from minio to RustFS quite a lot.

I don't think I know anyone running minio anymore. It's sad how they destroyed themselves, but that's the way it goes.

I am using Garage for my local DEV environment.

https://garagehq.deuxfleurs.fr/

I'm pretty happy with Seaweed, running that on prem, rock solid so far. Moved off MinIO when the licensing shenanigans started

Often just spinning up `localstack` works well, even if only for S3. Gives you other AWS services if you ever need them.

Are any of these truly alternatives? MinIO is built for scale and not small projects. Ceph is maybe closest.

I heard good news about SeaweedFS

undefined

or rclone serve

SeaweedFS has a great IAM/STS/policy layer as well. It can support a secretless auth flow similar enough to AWS IRSA with it's OIDC integration

my pick would be s3proxy, been using it for a while, works really well in local dev

Til there are like 50 s3 clones

RustFS is great. Just works.

Just use the damn file system. Why does everyone have to put HTTP between everything?

Crazy how large of a vacuum MinIO left lol

[flagged]

[flagged]

[flagged]

Shout-out to rustfs.

I've dabbled in both Garage and RustFS. Both are good but IMO flawed.

Garage is good but has weird tooling and a terrible searchable term. You'll receive lots of garage doors and electrical gate results when searching for issues with it.

The biggest problem with Garage is the metadata on an sqlite. If you have a single file and that sqlite corrupts then all your data is unaddressable and treated as pile of anonymous blocks. If you have multiple servers you can rebuild the metadata but if you have only one server you REALLY need to make sure that file is backed up.

So if you use S3 as a backup you have to keep a backup of your backup.

RustFS is closer to Minio, but I hate the way they log stuff. They basically use journald as a metric database dumping json formatted lines about library calls and how long they took. Its hard to make sense of those logs. Its the kind of log not meant to be human readable but to render on a dashboard.

Why not just publish these as a prometheus endpoint?

Also high CPU usage for no reason. I also noticed RustFS constantly trashing disk and keeping 10% CPU usage while looping some health check I have no idea how to disable (I've tried RUSTFS_SCANNER_ENABLED=false and others with no results). And of course lots of json metrics on journald.

I personally prefer garage because my backup box sit at my office and I like not needing to listen to HDD sounds all day every day while Rustfs loops its health check.