Best Self-Hosted Object Storage 2026: SeaweedFS vs MinIO vs Garage (Docker Setup)

Why Self-Host Object Storage?

Object storage has become the backbone of modern infrastructure. Whether you’re backing up servers with restic, syncing files via rclone, or serving media for a web app, the S3 API is the universal standard. But relying on AWS S3 or Cloudflare R2 means ongoing costs, vendor lock-in, and your data living on someone else’s hardware.

Self-hosted object storage gives you:

• Zero egress fees — download as much as you want, for free
• Full data sovereignty — your files never leave your server
• S3 API compatibility — works with any tool that supports S3
• Predictable costs — pay once for hardware, not per-GB per-month

In 2026, three solutions dominate the self-hosted object storage space: SeaweedFS, MinIO, and Garage. Each takes a fundamentally different approach. Let’s compare them side by side.

Quick Comparison Table

1. SeaweedFS — The All-in-One Storage Engine

Best for: Homelabs and teams that need object + file storage in one system

Key Features

SeaweedFS started as a key-value store inspired by Facebook’s Haystack paper and evolved into a full-featured distributed storage system. Its architecture separates concerns into three services:

• Master Server — manages volume topology and file-to-volume mapping (like a Namenode)
• Volume Server — stores actual data blocks on disk with automatic compaction
• Filer — provides POSIX-like directory structure and metadata on top of volumes
• S3 Gateway — exposes the entire system via S3-compatible API

What makes SeaweedFS unique is its Filer + Volume dual architecture. You get both a traditional hierarchical filesystem (via Filer mount) AND S3 object storage simultaneously from the same backend.

docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

# docker-compose.yml — SeaweedFS Full Stack
version: '3.8'

services:
  master:
    image: chrislusf/seaweedfs:latest
    container_name: weed-master
    command: >
      master -mdir /data/master
      -ip.bind 0.0.0.0
      -defaultReplication=001
    volumes:
      - ./data/master:/data/master
    ports:
      - "9333:9333"
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:9333/"]
      interval: 30s
      timeout: 5s
      retries: 3
    restart: unless-stopped

  volume:
    image: chrislusf/seaweedfs:latest
    container_name: weed-volume
    command: >
      volume -mserver="master:9333"
      -dir /data/volume
      -port 8080
      -max=7
      -ip.bind 0.0.0.0
    volumes:
      - ./data/volume:/data/volume
    ports:
      - "8080:8080"
    depends_on:
      master:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/status"]
      interval: 30s
      timeout: 5s
      retries: 3
    restart: unless-stopped

  filer:
    image: chrislusf/seaweedfs:latest
    container_name: weed-filer
    command: >
      filer -master="master:9333"
      -defaultStoreReplication=001
      -ip.bind 0.0.0.0
    volumes:
      - ./data/filer:/data/filer
    ports:
      - "8888:8888"
      - "8880:8880"
    depends_on:
      master:
        condition: service_healthy
    restart: unless-stopped

  s3:
    image: chrislusf/seaweedfs:latest
    container_name: weed-s3
    command: >
      s3 -filer="filer:8888"
      -ip.bind 0.0.0.0
    environment:
      - WEED_S3_ADMIN_USER=admin
      - WEED_S3_ADMIN_PASSWORD=changeme_2026
    ports:
      - "8333:8333"
    depends_on:
      - master
      - filer
      - volume
    restart: unless-stopped

# Access:
#   S3 Endpoint: http://<host-ip>:8333
#   Filer Web UI: http://<host-ip>:8880
#   Volume Status: http://<host-ip>:8080/status

Pros: Apache 2.0 license, excellent small-file performance, dual object+file API, FUSE mount, lightweight Cons: More complex architecture, no built-in IAM for S3 gateway, learning curve for topology

2. MinIO — The Enterprise S3 Standard

Best for: Production environments that need the most complete S3 API compatibility

Key Features

MinIO is the most widely known self-hosted S3 solution and for good reason. It offers the most complete S3 API implementation outside of AWS itself, including:

• Full IAM support with fine-grained policies
• Server-side encryption (SSE-S3, SSE-KMS, SSE-C)
• Object lifecycle management with automatic tiering
• Site replication for multi-datacenter setups
• Built-in erasure coding and bitrot protection
• Console UI for management and monitoring
• Kubernetes Operator for cloud-native deployments

MinIO’s biggest caveat in 2026: the SSPL license for commercial use. While personal and internal use remains under AGPLv3, any company offering MinIO as a managed service must comply with SSPL terms. For homelabbers and most self-hosters, this is a non-issue.

Docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# docker-compose.yml — MinIO Standalone
version: '3.8'

services:
  minio:
    image: minio/minio:latest
    container_name: minio
    command: server /data --console-address ":9001" --address ":9000"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin_secure_2026
    volumes:
      - ./data/minio:/data
      - ./config/minio:/root/.minio
    ports:
      - "9000:9000"  # S3 API
      - "9001:9001"  # Web Console
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

  # Optional: MinIO Client for bucket setup
  mc-setup:
    image: minio/mc:latest
    container_name: mc-setup
    depends_on:
      minio:
        condition: service_healthy
    entrypoint: >
      /bin/sh -c "
      mc alias set local http://minio:9000 minioadmin minioadmin_secure_2026;
      mc mb local/backups --ignore-existing;
      mc mb local/media --ignore-existing;
      mc mb local/app-data --ignore-existing;
      mc anonymous set download local/media;
      exit 0;
      "
    restart: "no"

Pros: Most complete S3 API, excellent documentation, active enterprise backing, Console UI, erasure coding Cons: AGPLv3/SSPL licensing, heavier resource usage (~512MB idle), less suited for geo-distributed setups

3. Garage — The Lightweight Geo-Distributed Option

Best for: Multi-location homelabs and privacy-focused users who want Rust performance

Key Features

Garage is the newcomer written in Rust, designed from the ground up for geo-distributed deployments across unreliable networks. Its key differentiators:

• Ultra-lightweight — runs on as little as 128MB RAM
• Tolerance for high-latency links — designed for nodes spread across locations
• Simple configuration — a single TOML config file, no complex topology management
• S3-compatible API — works with rclone, restic, and most S3 tools
• AGPLv3 licensed — truly open source, no SSPL concerns
• Rust performance — memory-safe, low overhead, fast

Garage trades some advanced features (no IAM, no lifecycle rules yet) for simplicity and resilience. It’s the ideal choice if you have a Raspberry Pi in one city and a VPS in another and want them to form a single storage cluster.

Docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# docker-compose.yml — Garage Single Node
version: '3.8'

services:
  garage:
    image: dxflrs/garage:latest
    container_name: garage
    volumes:
      - ./data/garage:/var/lib/garage
      - ./config/garage.toml:/etc/garage.toml:ro
    ports:
      - "3900:3900"   # S3 API
      - "3901:3901"   # RPC (cluster communication)
      - "3902:3902"   # Gossip (peer discovery)
    environment:
      - GARAGE_CONFIG=/etc/garage.toml
    restart: unless-stopped

garage.toml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Single-node configuration
metadata_dir = "/var/lib/garage/meta"
data_dir = "/var/lib/garage/data"
db_engine = "lmdb"

[s3_api]
s3_region = "garage"
api_listen_addr = "0.0.0.0:3900"

[rpc]
bind_addr = "0.0.0.0:3901"
advertise_addr = "0.0.0.0:3901"

[replication]
# For single node: replication factor 1
replication_factor = 1

Initialize the cluster and create a bucket:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# After starting the container
docker exec garage garage bucket create backups
docker exec garage bucket policy backups '{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {"AWS": ["*"]},
      "Action": ["s3:GetObject"],
      "Resource": ["arn:aws:s3:::backups/*"]
    }
  ]
}'

Pros: Smallest footprint, Rust reliability, geo-distributed by design, simple config, true open source Cons: Fewer features (no IAM, no lifecycle), smaller community, no web UI, early-stage compared to MinIO

Performance & Resource Comparison

Resource Usage (Single Node, Idle)

Throughput Benchmarks (1 GbE, 1M small files)

SeaweedFS excels at small file workloads thanks to its Haystack-inspired volume design. MinIO leads on large file throughput with its optimized erasure coding. Garage holds its own despite being the newest and smallest.

Scaling Characteristics

• SeaweedFS: Add volume servers dynamically; master auto-rebalances. Scales to petabytes.
• MinIO: Expand by adding drives to existing erasure sets or deploying new sets. Scales well but requires planning.
• Garage: Simply add a new node to the ring; replication handles the rest. Best for heterogeneous hardware across locations.

How to Connect with rclone

All three tools work with rclone. Here’s a quick config for each:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ~/.config/rclone/rclone.conf

[seaweedfs]
type = s3
provider = Other
endpoint = http://localhost:8333
access_key_id = admin
secret_access_key = changeme_2026
acl = private

[minio]
type = s3
provider = Minio
endpoint = http://localhost:9000
access_key_id = minioadmin
secret_access_key = minioadmin_secure_2026

[garage]
type = s3
provider = Other
endpoint = http://localhost:3900
access_key_id = <your-garage-key>
secret_access_key = <your-garage-secret>
region = garage

Test connectivity:

1
2
3

rclone lsd seaweedfs:
rclone lsd minio:
rclone lsd garage:

Frequently Asked Questions

Can I mount self-hosted object storage as a local drive?

Yes. SeaweedFS has the best FUSE mount support — run weed mount -filer=localhost:8888 -dir=/mnt/weed to mount the entire filesystem locally. For MinIO and Garage, use s3fs-fuse or goofys:

1
2
3

# s3fs approach (works with all three)
s3fs mybucket /mnt/s3 -o url=http://localhost:8333 \
  -o use_path_request_style -o passwd_file=~/.passwd-s3fs

Is MinIO still free for personal use in 2026?

Yes. MinIO remains AGPLv3 for personal, internal, and non-commercial use. The SSPL license only applies if you’re offering MinIO as a managed service to third parties (like a hosting company). For homelab, self-hosting, or internal company use, AGPLv3 applies and it’s completely free.

How do I automate backups from object storage to cold storage?

Use rclone sync with a cron job to replicate to Backblaze B2, Wasabi, or any other provider:

1
2
3
4

# Nightly sync to Backblaze B2
rclone sync minio:backups b2:offsite-backups \
  --log-file=/var/log/rclone-backup.log \
  --transfers=8 --checkers=16

Schedule it via cron (0 2 * * *) for daily offsite replication.

What’s the minimum hardware for a reliable single-node S3 server?

All three run comfortably on a Raspberry Pi 4. For production workloads with active traffic, 2GB+ RAM and SSD storage are recommended.

Which solution works best with nextcloud external storage?

All three work via the External Storage Support app with S3 backend. MinIO has the most reliable integration due to its mature S3 API. SeaweedFS works well but requires the Filer-based S3 gateway (not the raw volume API). Garage works for basic operations but may hit edge cases with Nextcloud’s presigned URL handling.

How do I enable lifecycle rules to auto-expire old files?

MinIO has built-in lifecycle management:

1
2
3

mc ilm add minio/backups \
  --expiry-days 90 \
  --prefix "logs/"

SeaweedFS supports lifecycle via the Filer configuration. Garage does not yet support lifecycle rules natively — use an external script with garage s3 ls and garage s3 rm on a schedule.

How does Garage handle network latency across locations?

This is Garage’s superpower. It uses a custom gossip protocol and asynchronous replication designed for high-latency, low-bandwidth links between nodes. A node with 200ms latency to its peers will still function correctly — reads are served locally, writes replicate asynchronously. MinIO and SeaweedFS both expect low-latency LAN connections between nodes.

Can I migrate from one solution to another?

Yes — use rclone to copy between any S3-compatible backends:

1
2

rclone copy minio:backups seaweedfs:backups \
  --progress --transfers=4

For large migrations, use rclone bisync for two-way sync during the transition period.

Conclusion — Which Should You Choose?

For most homelabbers starting out in 2026, SeaweedFS offers the best balance of features, performance, and licensing. Its dual object+file architecture means you get both an S3 endpoint AND a mountable filesystem from a single stack. If you need enterprise-grade S3 compatibility with the best tooling, MinIO remains the gold standard. And if you’re spanning multiple locations with modest hardware, Garage is the lightweight Rust-built answer.

All three are excellent choices — you can’t go wrong starting with any of them and migrating later if your needs change.