Awesome RepoAugust 19, 20267 min read

RustFS: S3-Compatible Object Storage Faster than MinIO

RustFS is an S3-compatible object storage that's 2.3x faster than MinIO. Built with Rust for maximum performance.

RustFS: S3-Compatible Object Storage Faster than MinIO

rustfs Image: GitHub

If you've been using MinIO as object storage in your homelab or production server, you probably already know how solid it is. But have you ever wondered: what if there was something faster than MinIO, yet still S3-compatible and open-source? Enter — RustFS.

RustFS is an object storage project built in Rust that's been making waves in the self-hoster and cloud-native developer community. With 31K+ stars on GitHub, RustFS isn't just a passing trend — it's a serious contender worth considering for your object storage needs.

In this article, we'll take a deep dive into RustFS: what it is, why it matters, key features, installation methods, usage examples including migration from MinIO, and how it stacks up against MinIO and Ceph. Let's get started!

What Is RustFS?
Why Is RustFS Interesting?
Key Features of RustFS
Installing RustFS
How to Use RustFS
Migrating from MinIO to RustFS
Comparison: RustFS vs MinIO vs Ceph
Use Cases for Homelab and Production
Conclusion

What Is RustFS?

RustFS is an open-source object storage system compatible with the Amazon S3 API. The project is written in Rust, a language known for its high performance, memory safety, and efficient resource consumption.

In simple terms, think of RustFS as "MinIO written in Rust" — an object storage system that stores and retrieves data using the S3 protocol, but built on a more modern language foundation with better performance.

Key facts about RustFS:

GitHub Stars: 31K+ (indicating widespread adoption)
License: Apache-2.0 (truly open-source, production-ready)
Language: Rust
Homepage: rustfs.com
GitHub: github.com/rustfs/rustfs
Performance Claim: 2.3x faster than MinIO for 4KB object payloads

RustFS is designed for AI-native, cloud-native, and big data workloads. So if you need a storage backend for AI training data, log analytics, or just solid backup storage — RustFS deserves a spot on your radar.

Why Is RustFS Interesting?

🚀 2.3x Faster Than MinIO

This is the headline feature of RustFS. Based on published benchmarks, RustFS outperforms MinIO by up to 2.3x for 4KB objects. Why 4KB? Because many modern applications (including AI/ML workloads) deal with a large number of small files.

For larger objects, RustFS still maintains a performance edge, though the margin is smaller. Why? Because Rust is inherently more efficient at:

Memory management — Rust has no garbage collector, so there are no GC pauses disrupting throughput
Concurrency — Rust's async runtimes (like Tokio) are highly efficient for I/O-bound workloads
Zero-cost abstractions — high-level Rust features add no runtime overhead

🔌 Fully S3-Compatible

One of the biggest concerns when migrating to a new object storage is API compatibility. RustFS addresses this by providing an API that's 100% compatible with S3. This means:

Existing tools like aws cli, mc (MinIO Client), rclone, and even s3cmd continue to work
S3 libraries in Python (boto3), Go (aws-sdk-go), and Node.js (aws-sdk) all function normally
Applications already using S3 endpoints just need to swap the URL

⚡ Rust Performance

Rust offers significant advantages over Go (which MinIO is built with):

Aspect	Go (MinIO)	Rust (RustFS)
GC Pause	Yes, occasional	None
Memory Usage	Higher	More efficient
Startup Time	Fast	Very fast
CPU Efficiency	Good	Excellent
Binary Size	Medium	Smaller

🏗️ Simple Architecture

RustFS is built with simplicity first. No heavy dependencies, no external database needed for metadata, and it can run as a single binary. Same deployment simplicity as MinIO, but with extra performance.

Key Features of RustFS

1. Full S3 API

# All S3 operations are supported
# PUT object
aws s3 cp file.txt s3://my-bucket/file.txt --endpoint-url http://localhost:9000
 
# GET object
aws s3 cp s3://my-bucket/file.txt ./file.txt --endpoint-url http://localhost:9000
 
# LIST objects
aws s3 ls s3://my-bucket/ --endpoint-url http://localhost:9000
 
# DELETE object
aws s3 rm s3://my-bucket/file.txt --endpoint-url http://localhost:9000
 
# Multipart upload — fully supported
aws s3 cp largefile.bin s3://my-bucket/largefile.bin \
  --endpoint-url http://localhost:9000 \
  --part-size 64MB

2. Erasure Coding

RustFS supports erasure coding for data redundancy, similar to MinIO. This ensures data can still be recovered even if some drives fail.

# Example: RustFS with 4 drives, tolerating 2 drive failures
# Data is automatically striped and encoded
rustfs server /data/disk1 /data/disk2 /data/disk3 /data/disk4

3. Encryption

Data at rest and in transit can be encrypted with RustFS:

# rustfs config
encryption:
  enabled: true
  algorithm: AES-256-GCM
  key_management: vault  # or local keystore

4. Bucket Versioning

# Enable versioning on a bucket
aws s3api put-bucket-versioning \
  --bucket my-bucket \
  --versioning-configuration Status=Enabled \
  --endpoint-url http://localhost:9000

5. Lifecycle Management

{
  "Rules": [
    {
      "ID": "auto-archive",
      "Status": "Enabled",
      "Filter": { "Prefix": "logs/" },
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "GLACIER"
        }
      ],
      "Expiration": { "Days": 365 }
    }
  ]
}

6. Web Console

RustFS provides a web console for managing buckets and objects through a browser, similar to the MinIO Console.

7. Multi-Tenancy and IAM

# Create a user policy for restricted access
cat > policy-readonly.json << 'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::my-bucket",
        "arn:aws:s3:::my-bucket/*"
      ]
    }
  ]
}
EOF
 
rustfs admin policy create myuser readonly policy-readonly.json

8. Replication

# Set up bucket replication from cluster A to cluster B
aws s3api put-bucket-replication \
  --bucket source-bucket \
  --replication-configuration '{
    "Rules": [{
      "Status": "Enabled",
      "Destination": {
        "Bucket": "arn:aws:s3:::dest-bucket",
        "StorageClass": "STANDARD"
      },
      "Filter": { "Prefix": "" }
    }]
  }' \
  --endpoint-url http://cluster-a:9000

Installing RustFS

Method 1: Docker (Easiest)

This is the simplest way to try RustFS. Great for testing and also production with Docker Swarm or Kubernetes.

# Pull the RustFS image
docker pull rustfs/rustfs:latest
 
# Run RustFS in single-node mode
docker run -d \
  --name rustfs \
  -p 9000:9000 \
  -p 9001:9001 \
  -v /data/rustfs:/data \
  -e RUSTFS_ROOT_USER=minioadmin \
  -e RUSTFS_ROOT_PASSWORD=minioadmin \
  rustfs/rustfs:latest server /data
 
# Check if it's running
curl http://localhost:9000/minio/health/live

Method 2: Docker Compose

For a cleaner setup, use Docker Compose:

# docker-compose.yml
version: '3.8'
 
services:
  rustfs:
    image: rustfs/rustfs:latest
    container_name: rustfs
    restart: unless-stopped
    ports:
      - "9000:9000"   # API port
      - "9001:9001"   # Console port
    volumes:
      - rustfs-data:/data
    environment:
      RUSTFS_ROOT_USER: minioadmin
      RUSTFS_ROOT_PASSWORD: your-secure-password-here
    command: server /data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 10s
      retries: 3
 
volumes:
  rustfs-data:
    driver: local

# Start it up
docker compose up -d
 
# Check status
docker compose ps
docker compose logs -f rustfs

Method 3: Direct Binary

# Download the latest binary from GitHub releases
# Adjust the URL for your architecture (amd64/arm64)
wget https://github.com/rustfs/rustfs/releases/latest/download/rustfs-linux-amd64
 
chmod +x rustfs-linux-amd64
sudo mv rustfs-linux-amd64 /usr/local/bin/rustfs
 
# Create a directory for data
sudo mkdir -p /opt/rustfs/data
 
# Start RustFS
rustfs server /opt/rustfs/data
 
# Output:
# API:  http://localhost:9000
# Console: http://localhost:9001
# Root User: minioadmin
# Root Password: minioadmin

Method 4: Multi-Node Cluster

For production, you'll want a cluster. RustFS supports distributed setups:

# Node 1 (rustfs1)
rustfs server http://rustfs{1...4}.example.com/data/disk{1...4}
 
# Node 2 (rustfs2)
rustfs server http://rustfs{1...4}.example.com/data/disk{1...4}
 
# Node 3 (rustfs3)
rustfs server http://rustfs{1...4}.example.com/data/disk{1...4}
 
# Node 4 (rustfs4)
rustfs server http://rustfs{1...4}.example.com/data/disk{1...4}

Make sure all nodes can reach each other on ports 9000 and 9001.

Method 5: Systemd Service

If you're running RustFS directly on the host (not Docker), create a systemd service:

# /etc/systemd/system/rustfs.service
[Unit]
Description=RustFS Object Storage
After=network.target
 
[Service]
Type=simple
User=rustfs
Group=rustfs
ExecStart=/usr/local/bin/rustfs server /opt/rustfs/data
Restart=always
RestartSec=5
LimitNOFILE=65536
Environment="RUSTFS_ROOT_USER=minioadmin"
Environment="RUSTFS_ROOT_PASSWORD=your-secure-password"
 
[Install]
WantedBy=multi-user.target

# Create the rustfs user
sudo useradd -r -s /bin/false rustfs
sudo mkdir -p /opt/rustfs/data
sudo chown -R rustfs:rustfs /opt/rustfs
 
# Enable and start the service
sudo systemctl daemon-reload
sudo systemctl enable rustfs
sudo systemctl start rustfs
sudo systemctl status rustfs

How to Use RustFS

Client Setup

RustFS works with existing S3 clients. You can use the aws cli or mc (MinIO Client):

Using AWS CLI:

# Install aws cli (if you haven't)
pip install awscli
 
# Configure the endpoint
export AWS_ACCESS_KEY_ID=minioadmin
export AWS_SECRET_ACCESS_KEY=minioadmin
export AWS_DEFAULT_REGION=us-east-1
 
# Create a bucket
aws s3 mb s3://my-bucket --endpoint-url http://localhost:9000
 
# Upload a file
aws s3 cp myfile.txt s3://my-bucket/ --endpoint-url http://localhost:9000
 
# List files
aws s3 ls s3://my-bucket/ --endpoint-url http://localhost:9000
 
# Download a file
aws s3 cp s3://my-bucket/myfile.txt ./downloaded.txt --endpoint-url http://localhost:9000
 
# Sync a folder
aws s3 sync ./local-folder s3://my-bucket/ --endpoint-url http://localhost:9000

Using MinIO Client (mc):

# Install mc
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
 
# Add a RustFS alias
mc alias set rustfs http://localhost:9000 minioadmin minioadmin
 
# Create a bucket
mc mb rustfs/my-bucket
 
# Upload
mc cp myfile.txt rustfs/my-bucket/
 
# List
mc ls rustfs/my-bucket/
 
# Recursive copy
mc cp --recursive ./my-folder/ rustfs/my-bucket/my-folder/

Using Python (boto3)

import boto3
from botocore.client import Config
 
# Connect to RustFS
s3 = boto3.client(
    's3',
    endpoint_url='http://localhost:9000',
    aws_access_key_id='minioadmin',
    aws_secret_access_key='minioadmin',
    config=Config(signature_version='s3v4'),
    region_name='us-east-1'
)
 
# Create a bucket
try:
    s3.create_bucket(Bucket='my-bucket')
    print("Bucket created successfully!")
except Exception as e:
    print(f"Error: {e}")
 
# Upload a file
s3.upload_file('myfile.txt', 'my-bucket', 'myfile.txt')
print("Upload successful!")
 
# List objects
response = s3.list_objects_v2(Bucket='my-bucket')
for obj in response.get('Contents', []):
    print(f"  {obj['Key']} ({obj['Size']} bytes)")
 
# Download a file
s3.download_file('my-bucket', 'myfile.txt', 'downloaded.txt')
print("Download successful!")
 
# Generate a presigned URL (useful for sharing)
url = s3.generate_presigned_url(
    'get_object',
    Params={'Bucket': 'my-bucket', 'Key': 'myfile.txt'},
    ExpiresIn=3600
)
print(f"Presigned URL: {url}")

Using Golang

package main
 
import (
	"context"
	"fmt"
	"io"
	"log"
	"os"
 
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)
 
func main() {
	// Load config with a custom endpoint
 
	cfg, err := config.LoadDefaultConfig(context.TODO(),
		config.WithRegion("us-east-1"),
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			"minioadmin", "minioadmin", "",
		)),
	)
	if err != nil {
		log.Fatal(err)
	}
 
	// Create an S3 client pointing to RustFS
	client := s3.NewFromConfig(cfg, func(o *s3.Options) {
		o.BaseEndpoint = aws.String("http://localhost:9000")
		o.UsePathStyle = true
	})
 
	// List buckets
	result, err := client.ListBuckets(context.TODO(), &s3.ListBucketsInput{})
	if err != nil {
		log.Fatal(err)
	}
 
	fmt.Println("Buckets:")
	for _, bucket := range result.Buckets {
		fmt.Printf("  %s (created: %s)\n",
			aws.ToString(bucket.Name),
			bucket.CreationDate.Format("2006-01-02"),
		)
	}
 
	// Upload a file
	file, err := os.Open("myfile.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
 
	_, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
		Bucket: aws.String("my-bucket"),
		Key:    aws.String("myfile.txt"),
		Body:   file,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Upload successful!")
}

Using Rclone

Rclone is a popular universal sync tool. RustFS can be used as a remote directly:

# Set up the rclone config
cat >> ~/.config/rclone/rclone.conf << 'EOF'
[rustfs]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://localhost:9000
region = us-east-1
EOF
 
# Sync a local folder to RustFS
rclone sync ./my-folder rustfs:my-bucket/my-folder
 
# Mount RustFS as a filesystem
mkdir -p ~/mnt/rustfs
rclone mount rustfs:my-bucket ~/mnt/rustfs --vfs-cache-mode full &
 
# Copy files directly
cp largefile.bin ~/mnt/rustfs/
 
# Can also mount to Android/TV/external devices via samba

Migrating from MinIO to RustFS

One of RustFS's biggest advantages is full compatibility with the MinIO API. This makes migrating from MinIO to RustFS relatively straightforward.

Strategy 1: Mirror Data with mc

# Set up aliases for MinIO and RustFS
mc alias set minio http://minio-server:9000 minioadmin minioadmin
mc alias set rustfs http://rustfs-server:9000 minioadmin minioadmin
 
# Mirror all buckets from MinIO to RustFS
mc mirror --overwrite minio/ rustfs/
 
# For a specific bucket
mc mirror --overwrite minio/my-bucket rustfs/my-bucket
 
# Monitor progress
mc mirror --overwrite --watch minio/ rustfs/

Strategy 2: Use rclone

# Set up remote config
cat >> ~/.config/rclone/rclone.conf << 'EOF'
[minio]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://minio-server:9000
 
[rustfs]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://rustfs-server:9000
EOF
 
# Sync data from MinIO to RustFS
rclone sync minio: my-bucket rustfs: my-bucket \
  --progress \
  --transfers 16 \
  --checkers 8
 
# Bandwidth limit (optional)
rclone sync minio: rustfs: \
  --bwlimit 50M \
  --progress

Strategy 3: Direct Copy with AWS CLI

# Export the full bucket list
BUCKETS=$(aws s3 ls --endpoint-url http://minio-server:9000 | awk '{print $3}')
 
for bucket in $BUCKETS; do
    echo "Migrating bucket: $bucket"
 
    # Create the bucket in RustFS
    aws s3 mb "s3://$bucket" --endpoint-url http://rustfs-server:9000
 
    # Copy all data
    aws s3 sync "s3://$bucket" "s3://$bucket" \
        --source-endpoint-url http://minio-server:9000 \
        --endpoint-url http://rustfs-server:9000
 
    echo "Bucket $bucket migrated!"
done
 
echo "Migration complete!"

Strategy 4: Run Both Servers Simultaneously (Zero-Downtime)

For production, you can run MinIO and RustFS side by side during the transition:

# Step 1: Deploy RustFS
docker compose -f rustfs-compose.yml up -d
 
# Step 2: Sync data from MinIO to RustFS (initial sync)
rclone sync minio: rustfs: --progress
 
# Step 3: Run continuous sync (delta)
rclone bisync minio: rustfs: --resync --progress
 
# Step 4: Update DNS/load balancer to point to RustFS
# Step 5: Verify all data is synced
rclone check minio: rustfs: --progress
 
# Step 6: Once confident, stop MinIO
docker compose -f minio-compose.yml down

Migration Tips

Test in staging first — don't migrate directly in production
Back up first — even though RustFS is compatible, always back up important data
Monitor resources — keep an eye on CPU, memory, and disk I/O during migration
Batch migration — for large datasets, break the migration into several batches
Validate checksums — use mc diff or rclone check to verify data integrity

Comparison: RustFS vs MinIO vs Ceph

Full Comparison Table

Feature	RustFS	MinIO	Ceph
Language	Rust	Go	C++ / Python
S3 API	✅ Full	✅ Full	✅ Via RGW
Performance (4KB)	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐
Memory Usage	Low	Medium	High
Ease of Setup	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐
Multi-Protocol	S3	S3	S3, CephFS, RBD
Erasure Coding	✅	✅	✅
Replication	✅	✅	✅
Web Console	✅	✅	✅ (Dashboard)
Binary Size	Small	Medium	Large
License	Apache-2.0	AGPL-3.0	LGPL-2.1
Community	Growing	Mature	Very Mature

RustFS vs MinIO

Advantages of RustFS over MinIO:

Performance — 2.3x faster for small objects (4KB), thanks to Rust
Memory — lower RAM consumption, ideal for resource-constrained servers
License — Apache-2.0 vs AGPL-3.0. Apache-2.0 is more permissive for commercial use
No GC Pause — Rust has no garbage collector, so throughput is more consistent
Binary Size — smaller binary, lighter deployment

Advantages of MinIO over RustFS:

Maturity — MinIO has been around longer, more battle-tested
Ecosystem — more integrations, documentation, and community resources
Features — some features may be more complete in MinIO (such as certain lifecycle policies)
Support — MinIO offers an enterprise version with support

RustFS vs Ceph

Advantages of RustFS over Ceph:

Simplicity — RustFS is far easier to deploy and maintain
Performance — RustFS is faster for S3 workloads
Resources — RustFS requires far fewer resources
Setup Time — Ceph can take hours to set up, while RustFS can be ready in minutes

Advantages of Ceph over RustFS:

Multi-Protocol — Ceph supports S3, CephFS (POSIX), and RBD (block storage)
Scale — Ceph is designed to scale to exabyte-level
Maturity — Ceph is used in many enterprise data centers
Features — more enterprise features like quotas, tiering, etc.

When to Choose What

Scenario	Recommendation
Homelab / Personal	RustFS (simple, lightweight, fast)
Small-Medium Production	RustFS or MinIO
Enterprise with multi-protocol needs	Ceph
AI/ML Training Data	RustFS (better performance for small files)
Backup Storage	RustFS or MinIO
Exabyte-scale	Ceph
Quick prototyping	RustFS

Use Cases for Homelab and Production

🏠 Homelab Use Cases

1. Media Server Storage

# Run RustFS to store movies, music, and photos
docker run -d \
  --name rustfs-media \
  -p 9000:9000 \
  -v /mnt/storage/media:/data \
  -e RUSTFS_ROOT_USER=minioadmin \
  -e RUSTFS_ROOT_PASSWORD=your-password \
  rustfs/rustfs:latest server /data
 
# Connect to Jellyfin/Emby/Plex via S3 plugin
# Or mount directly with rclone
rclone mount rustfs:media /mnt/media --vfs-cache-mode full

2. Backup Target for All Devices

# Backup from PC to RustFS
rclone sync /home/user/documents rustfs:backups/documents --progress
rclone sync /home/user/photos rustfs:backups/photos --progress
 
# Backup from Proxmox VM/LXC
vzdump 100 --storage rustfs-backup
 
# Backup PostgreSQL database
pg_dump mydb | gzip | aws s3 cp - s3://backups/db/mydb-$(date +%Y%m%d).sql.gz \
  --endpoint-url http://rustfs:9000
 
# Backup MongoDB
mongodump --gzip --archive | aws s3 cp - s3://backups/mongodb/archive.gz \
  --endpoint-url http://rustfs:9000

3. Home Assistant Data Store

# Home Assistant configuration for RustFS backend
homeassistant:
  # Use S3-compatible storage for history
  recorder:
    db_url: !secret db_url
  # Backup to RustFS
  backup:
    location: "RustFS"
    storage:
      type: s3
      endpoint: "http://rustfs:9000"
      bucket: "ha-backups"
      access_key: "minioadmin"
      secret_key: "minioadmin"

4. Immich (Photo Management) Backend

# Immich docker-compose with RustFS
services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:latest
    environment:
      MICROSOFT_STORAGE_BASE_URL: "http://rustfs:9000"
      MICROSOFT_STORAGE_BUCKET: "immich-photos"
      MICROSOFT_STORAGE_ACCESS_KEY: "minioadmin"
      MICROSOFT_STORAGE_SECRET_KEY: "minioadmin"
 
  rustfs:
    image: rustfs/rustfs:latest
    volumes:
      - immich-data:/data
    command: server /data

🏭 Production Use Cases

1. CI/CD Artifact Storage

# GitLab CI with RustFS as artifact storage
variables:
  AWS_ACCESS_KEY_ID: minioadmin
  AWS_SECRET_ACCESS_KEY: minioadmin
  S3_ENDPOINT: "https://rustfs.yourcompany.com"
 
build:
  script:
    - npm run build
    - aws s3 sync ./dist s3://artifacts/$CI_PROJECT_NAME/$CI_COMMIT_SHA \
      --endpoint-url $S3_ENDPOINT
  artifacts:
    paths:
      - dist/
    expire_in: 30 days

2. AI/ML Training Data

# PyTorch dataset from RustFS
import torch
from torch.utils.data import Dataset
import boto3
from io import BytesIO
from PIL import Image
 
class RustFSDataset(Dataset):
    def __init__(self, bucket_name, prefix=''):
        self.s3 = boto3.client(
            's3',
            endpoint_url='https://rustfs.yourcompany.com',
            aws_access_key_id='minioadmin',
            aws_secret_access_key='minioadmin'
        )
        self.bucket = bucket_name
        self.prefix = prefix
 
        # List all objects in the bucket
        self.objects = []
        paginator = self.s3.get_paginator('list_objects_v2')
        for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
            for obj in page.get('Contents', []):
                self.objects.append(obj['Key'])
 
    def __len__(self):
        return len(self.objects)
 
    def __getitem__(self, idx):
        key = self.objects[idx]
        response = self.s3.get_object(Bucket=self.bucket, Key=key)
        img = Image.open(BytesIO(response['Body'].read()))
        # Process the image...
        return img
 
# Training loop
dataset = RustFSDataset('training-data', prefix='images/v2/')
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32,
                                          num_workers=4, pin_memory=True)

3. Log Aggregation Backend

# Fluentd config to send logs to RustFS
<match **>
  @type s3
  s3_bucket "logs"
  s3_region "us-east-1"
  endpoint "http://rustfs:9000"
  path "logs/%Y/%m/%d/"
  buffer_type file
  buffer_path /var/log/fluent/s3
  buffer_chunk_limit 256m
  buffer_total_limit 16g
  flush_interval 60s
  aws_key_id minioadmin
  aws_sec_key minioadmin
</match>

4. Kubernetes Persistent Volume

# CSI Driver for RustFS
apiVersion: v1
kind: PersistentVolume
metadata:
  name: rustfs-pv
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  csi:
    driver: rustfs.csi.k8s.io
    volumeAttributes:
      endpoint: "http://rustfs:9000"
      bucket: "k8s-data"
      accessKey: "minioadmin"
      secretKey: "minioadmin"
 
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: rustfs-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 50Gi
  storageClassName: ""

RustFS in the Community

RustFS has received a warm welcome from the self-hoster and developer community. Some popular tags on GitHub:

ai-native — designed for modern AI workloads
ai-storage — storage backend for AI pipelines
cloud-native — built for cloud and container environments
object-storage — S3-compatible object storage solution
rust — Rust's performance and safety
minio — compatible with the MinIO ecosystem

With 31K+ stars, RustFS has proven there's significant demand for a faster, more efficient object storage alternative.

Conclusion

RustFS is a compelling alternative to MinIO and Ceph as S3-compatible object storage. With 2.3x better performance on small objects, the permissive Apache-2.0 license, and MinIO-like deployment simplicity, RustFS deserves your attention — whether for homelab or production use.

Recommendations:

Try it first — deploy RustFS on your homelab with Docker and feel the difference
Benchmark it — run benchmarks with your specific workload
Migrate — if the results are good, migrate from MinIO using mc mirror or rclone
Monitor — track performance after migration to make sure everything is running smoothly

RustFS is still a relatively young project compared to MinIO and Ceph, but with its rapid community growth and impressive performance, it's one of the projects worth following in 2026.

Links:

🔗 GitHub: github.com/rustfs/rustfs
🌐 Homepage: rustfs.com
📜 License: Apache-2.0

Have you tried RustFS yet? Or are you still loyal to MinIO? Share your experience in the comments below! 💬

Plane: Open-Source Project Management Alternative to Jira & Linear
August 25, 2026 · 8 min read
Coolify: Self-Hosted PaaS Alternative to Vercel & Heroku
August 18, 2026 · 7 min read
Arcane: Modern Docker Management UI for Homelab
August 17, 2026 · 9 min read
DBX: Lightweight 20MB Database Client for 80+ Databases
August 17, 2026 · 8 min read

RustFS: S3-Compatible Object Storage Faster than MinIO

Table of Contents

What Is RustFS?

Why Is RustFS Interesting?

🚀 2.3x Faster Than MinIO

🔌 Fully S3-Compatible

⚡ Rust Performance

🏗️ Simple Architecture

Key Features of RustFS

1. Full S3 API

2. Erasure Coding

3. Encryption

4. Bucket Versioning

5. Lifecycle Management

6. Web Console

7. Multi-Tenancy and IAM

8. Replication

Installing RustFS

Method 1: Docker (Easiest)

Method 2: Docker Compose

Method 3: Direct Binary

Method 4: Multi-Node Cluster

Method 5: Systemd Service

How to Use RustFS

Client Setup

Using Python (boto3)

Using Golang

Using Rclone

Migrating from MinIO to RustFS

Strategy 1: Mirror Data with mc

Strategy 2: Use rclone

Strategy 3: Direct Copy with AWS CLI

Strategy 4: Run Both Servers Simultaneously (Zero-Downtime)

Migration Tips

Comparison: RustFS vs MinIO vs Ceph

Full Comparison Table

RustFS vs MinIO

RustFS vs Ceph

When to Choose What

Use Cases for Homelab and Production

🏠 Homelab Use Cases

1. Media Server Storage

2. Backup Target for All Devices

3. Home Assistant Data Store

4. Immich (Photo Management) Backend

🏭 Production Use Cases

1. CI/CD Artifact Storage

2. AI/ML Training Data

3. Log Aggregation Backend

4. Kubernetes Persistent Volume

RustFS in the Community

Conclusion

More posts

Plane: Open-Source Project Management Alternative to Jira & Linear

Coolify: Self-Hosted PaaS Alternative to Vercel & Heroku

Arcane: Modern Docker Management UI for Homelab

DBX: Lightweight 20MB Database Client for 80+ Databases