• Context & Motivation:

  • Following the MinIO company's decision to shift away from maintaining the open-source release, developers and demo creators needed alternative local S3 emulators.
  • The author's criteria focused strictly on single-node, local testing/demo environments: ready-to-use Docker images, S3 compatibility, open-source licensing (per OSI), simple configuration, and active community/backing.
  • Testing baseline used a minimal Docker Compose setup: DuckDB reading and writing Apache Iceberg data backed by local S3 storage.

• Evaluated Solutions:

  • S3Proxy:
    • Lightweight, highly compatible, and very easy to set up (👍👍).
    • Noted downside: Depends on Apache jclouds, which was retired to the Apache Attic in mid-2025.
  • RustFS:
    • Easy setup with an included GUI and strong S3 compliance (👍👍).
    • Drawbacks: Currently in alpha release and recently experienced a notable security vulnerability.
  • SeaweedFS:
    • Mature open-source project with solid S3 compatibility and a built-in UI (👍).
    • Slight initial hurdle regarding auth config files in Docker Compose, though the maintainer promptly pushed changes to streamline single-node setup.
  • Zenko CloudServer:
    • Formerly known as S3 Server (by Scality); straightforward replacement (👍).
    • Downsides include confusing branding across Scality/Zenko/CloudServer and outdated Docker Hub images referenced in documentation.
  • Garage:
    • Lightweight distributed-focused object store with an AGPL license.
    • Steep setup curve for simple single-node demos due to custom initialization, mandatory key ID format constraints, and external TOML configuration requirements (😬).
  • Apache Ozone & Ceph Object Gateway:
    • Deemed too heavyweight and complex for lightweight single-node demo stacks (Ozone required at least four nodes; Ceph required extensive setup).

• Author's Takeaway:

  • Recommended choices for local demos: SeaweedFS and S3Proxy (with RustFS as a potential future candidate once matured).
  • Reminded users to weigh project governance (foundation vs. single maintainer) and bus factor when selecting tools.

Hacker News Discussion

• MinIO Fork (pgsty/silo):
  • A prominent fork created by Ruohang Feng (originally pgsty/minio, renamed to pgsty/silo) was highlighted by multiple commenters as the most seamless drop-in replacement that requires zero config or code changes for existing MinIO users.
• VersityGW as a Popular Alternative:
  • Several users strongly recommended versitygw for homelabs and local testing, highlighting its stability and ability to map S3 buckets directly to standard POSIX directories without complex overhead.
• Garage Experience & Caveats:
  • Commenters noted that Garage v2.3.0 added a --single-node --default-bucket flag that significantly simplifies single-node setups compared to earlier versions.
  • However, technical drawbacks were emphasized: Garage relies on eventual consistency and lacks strict conditional PUT semantics, making it unsuitable for workloads like Apache Iceberg or Litestream-style lock guarantees.
• SeaweedFS Community Input:
  • The SeaweedFS maintainer actively participated in the thread, clarifying performance benchmarks, welcoming issue reports for concurrency or documentation gaps, and pointing to updated documentation and broad S3 feature coverage.
• Other Noteworthy Mentions:
  • HS5: A lightweight object store designed specifically for local S3 simulation with integrated DuckDB support and strict ETag / conditional request compliance.
  • Filestash S3 Gateway: Mentioned as a flexible proxy translating S3 requests across diverse backend storages (SFTP, SMB, NFS).
  • Incus: Noted that the LXD successor project recently adopted its own native S3 service to drop MinIO dependencies.

Vgl [[S3 API How Amazon’s Storage Protocol Became the Industry Standard]]

https://web.archive.org/web/20260129054431/https://medium.com/@aurennmalik/s3-api-how-amazons-storage-protocol-became-the-industry-standard-95f9d817eddf

On the s3 API, simple storage service. A proprietary protocol by Amazon, that is now mostly the standard for cloud storage services, used by other vendors

Access AWS S3 from your VPC using Gateway Endpoints, not a bucket policy.

In essence, this article is about:

1) Training a sample model and uploading it to an S3 bucket:

```python from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression import joblib

Load the Iris dataset

iris = load_iris() X, y = iris.data, iris.target

Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Train the logistic regression model

model = LogisticRegression(max_iter=200) model.fit(X_train, y_train)

Save the trained model to a file

joblib.dump(model, 'model.pkl') ```

1. Creating a sample Zappa config, because AWS Lambda doesn’t natively support Flask, we need to use Zappa, a tool that helps deploy WSGI applications (like Flask) to AWS Lambda:

```json { "dev": { "app_function": "app.app", "exclude": [ "boto3", "dateutil", "botocore", "s3transfer", "concurrent" ], "profile_name": null, "project_name": "flask-test-app", "runtime": "python3.10", "s3_bucket": "zappa-31096o41b" },

"production": {
    "app_function": "app.app",
    "exclude": [
        "boto3",
        "dateutil",
        "botocore",
        "s3transfer",
        "concurrent"
    ],
    "profile_name": null,
    "project_name": "flask-test-app",
    "runtime": "python3.10",
    "s3_bucket": "zappa-31096o41b"
}

} ```

1. Writing a sample Flask app:

```python import boto3 import joblib import os

Initialize the Flask app

app = Flask(name)

S3 client to download the model

s3 = boto3.client('s3')

Download the model from S3 when the app starts

s3.download_file('your-s3-bucket-name', 'model.pkl', '/tmp/model.pkl') model = joblib.load('/tmp/model.pkl')

@app.route('/predict', methods=['POST']) def predict(): # Get the data from the POST request data = request.get_json(force=True)

# Convert the data into a numpy array
input_data = np.array(data['input']).reshape(1, -1)

# Make a prediction using the model
prediction = model.predict(input_data)

# Return the prediction as a JSON response
return jsonify({'prediction': int(prediction[0])})

if name == 'main': app.run(debug=True) ```

1. Deploying this app to production (to AWS):

bash zappa deploy production

and later eventually updating it:

bash zappa update production

1. We should get a URL like this:

https://xyz123.execute-api.us-east-1.amazonaws.com/production

which we can query:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' https://xyz123.execute-api.us-east-1.amazonaws.com/production/predict

The author was charged over $1300 after two days of using an S3 bucket, because some OS tool stored a default bucket name in the config, which was the same as his bucket name.

Luckily, after everything AWS made an exception and he did not have to pay the bill.

dynamodb import

Deleting buckets on S3 is not free. If you use either Web Console or AWS CLI, it will execute the LIST call per 1000 objects

s3 perfomance use columnar formats

https://aws.amazon.com/glacier/faqs/

3 types of retrieval

expecited 1~5minutes

Request Pays

event notification of s3 might take minutes

BTW,

cloud watch does not support s3, but cloud trail does

How to enable s3 in Gnome Desktop

consumers keep track of what's written and where it left off by looking at kafka consumer offsets rather than checking S3 since S3 is an eventually consistent system.

data loss in S3 is being mitigated.

S3Object is a pointer to the data object.

Provides an InputStream to read the data.

Need to look at S3

Not really. Art has always been about reacting (in some part) to the works that have come before it.