Awesome Repo19 Agustus 20266 menit baca

RustFS: Object Storage S3-Compatible yang Lebih Cepat dari MinIO

RustFS adalah object storage S3-compatible yang 2.3x lebih cepat dari MinIO. Dibangun dengan Rust untuk performa maksimal.

Baca dalam English →

RustFS: Object Storage S3-Compatible yang Lebih Cepat dari MinIO

rustfs Gambar: GitHub

Kalau kamu pakai MinIO sebagai object storage di homelab atau server production, pasti sudah familiar dengan betapa solid-nya MinIO. Tapi, pernah gak sih kepikiran: gimana kalau ada yang lebih cepat dari MinIO, tapi tetap S3-compatible dan open-source? Masuk — RustFS.

RustFS adalah project object storage berbasis Rust yang belakangan ini bikin heboh di komunitas self-hoster dan cloud-native developer. Dengan 31K+ stars di GitHub, RustFS bukan cuma hype sesaat — ini adalah alternatif serius yang layak dipertimbangkan untuk kebutuhan object storage kamu.

Di artikel ini, kita bakal bahas tuntas tentang RustFS: apa itu, kenapa menarik, fitur utama, cara instalasi, cara pakai sampai migrasi dari MinIO, dan perbandingannya sama MinIO serta Ceph. Yuk mulai!

Apa Itu RustFS?

RustFS adalah sistem object storage open-source yang kompatibel dengan Amazon S3 API. Project ini ditulis menggunakan bahasa pemrograman Rust, yang dikenal karena performanya tinggi, keamanan memori yang baik, dan konsumsi resource yang efisien.

Secara sederhana, RustFS bisa kamu anggap sebagai "MinIO written in Rust" — sebuah object storage yang bisa menyimpan dan mengambil data menggunakan protokol S3, tapi dengan fondasi bahasa yang lebih modern dan performa yang lebih optimal.

Beberapa fakta penting tentang RustFS:

GitHub Stars: 31K+ (menunjukkan adopsi yang sangat luas)
License: Apache-2.0 (benar-benar open-source, bisa dipakai di production)
Bahasa: Rust
Homepage: rustfs.com
GitHub: github.com/rustfs/rustfs
Klaim Performa: 2.3x lebih cepat dari MinIO untuk object payload 4KB

RustFS dirancang untuk AI-native, cloud-native, dan big data workloads. Jadi, kalau kamu butuh storage backend untuk training data AI, log analytics, atau hanya butuh backup storage yang solid — RustFS layak masuk radar.

Kenapa RustFS Menarik?

🚀 2.3x Lebih Cepat dari MinIO

Ini adalah headline utama dari RustFS. Berdasarkan benchmark yang dipublikasikan, RustFS mampu mengungguli MinIO hingga 2.3x lipat untuk object dengan ukuran 4KB. Kenapa 4KB? Karena banyak aplikasi modern (termasuk workload AI/ML) banyak yang bekerja dengan file-file kecil dalam jumlah besar.

Untuk object yang lebih besar, RustFS tetap unggul meskipun margin-nya lebih kecil. Kenapa? Karena Rust secara native lebih efisien dalam:

Memory management — Rust tidak punya garbage collector, sehingga tidak ada GC pause yang mengganggu throughput
Concurrency — async runtime di Rust (seperti Tokio) sangat efisien untuk I/O-bound workload
Zero-cost abstraction — fitur high-level Rust tidak menambah overhead di runtime

🔌 S3-Compatible Penuh

Salah satu kekhawatiran terbesar saat migrasi ke object storage baru adalah kompatibilitas API. RustFS menjawab masalah ini dengan menyediakan API yang 100% kompatibel dengan S3. Artinya:

Tool yang sudah ada seperti aws cli, mc (MinIO Client), rclone, bahkan s3cmd tetap bisa dipakai
Library S3 di Python (boto3), Go (aws-sdk-go), Node.js (aws-sdk) tetap berfungsi
Aplikasi yang sudah pakai S3 endpoint tinggal ganti URL saja

⚡ Performa Rust

Rust memberikan keuntungan signifikan dibandingkan Go (yang dipakai MinIO):

Aspek	Go (MinIO)	Rust (RustFS)
GC Pause	Ya, sesekali	Tidak ada
Memory Usage	Lebih tinggi	Lebih efisien
Startup Time	Cepat	Sangat cepat
CPU Efficiency	Baik	Sangat baik
Binary Size	Medium	Lebih kecil

🏗️ Arsitektur yang Simpel

RustFS dirancang dengan prinsip simplicity first. Tidak ada dependencies berat, tidak perlu external database untuk metadata, dan bisa dijalankan sebagai single binary. Sama seperti MinIO dalam hal kemudahan deployment, tapi dengan performa ekstra.

Fitur Utama RustFS

1. S3 API Lengkap

# Semua operasi S3 didukung
# 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 — didukung penuh
aws s3 cp largefile.bin s3://my-bucket/largefile.bin \
  --endpoint-url http://localhost:9000 \
  --part-size 64MB

2. Erasure Coding

RustFS mendukung erasure coding untuk data redundancy, mirip seperti MinIO. Ini memungkinkan data tetap bisa dipulihkan meskipun beberapa drive mengalami kegagalan.

# Contoh: RustFS dengan 4 drive, toleransi 2 drive gagal
# Data di-strip dan di-encode secara otomatis
rustfs server /data/disk1 /data/disk2 /data/disk3 /data/disk4

3. Encryption

Data di-rest dan di-transit bisa di-encrypt menggunakan RustFS:

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

4. Bucket Versioning

# Aktifkan versioning pada 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 menyediakan web console untuk manajemen bucket dan object melalui browser, mirip dengan MinIO Console.

7. Multi-Tenancy dan IAM

# Buat user policy untuk akses terbatas
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

# Setup bucket replication dari cluster A ke 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

Instalasi RustFS

Metode 1: Docker (Paling Mudah)

Ini adalah cara paling simpel untuk coba RustFS. Cocok untuk testing dan juga production dengan Docker Swarm atau Kubernetes.

# Pull image RustFS
docker pull rustfs/rustfs:latest
 
# Jalankan RustFS single node
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
 
# Cek apakah berjalan
curl http://localhost:9000/minio/health/live

Metode 2: Docker Compose

Untuk setup yang lebih rapi, gunakan 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

# Jalankan
docker compose up -d
 
# Cek status
docker compose ps
docker compose logs -f rustfs

Metode 3: Binary Langsung

# Download binary terbaru dari GitHub releases
# Ganti URL sesuai arch (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
 
# Buat directory untuk data
sudo mkdir -p /opt/rustfs/data
 
# Jalankan RustFS
rustfs server /opt/rustfs/data
 
# Output:
# API:  http://localhost:9000
# Console: http://localhost:9001
# Root User: minioadmin
# Root Password: minioadmin

Metode 4: Multi-Node Cluster

Untuk production, kamu pasti butuh cluster. RustFS mendukung distributed setup:

# 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}

Pastikan semua node bisa saling mengakses port 9000 dan 9001.

Metode 5: Systemd Service

Kalau kamu menjalankan RustFS langsung di host (bukan Docker), buat 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

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

Cara Menggunakan RustFS

Setup Client

RustFS kompatibel dengan S3 client yang ada. Kamu bisa pakai aws cli atau mc (MinIO Client):

Menggunakan AWS CLI:

# Install aws cli (jika belum)
pip install awscli
 
# Configure endpoint
export AWS_ACCESS_KEY_ID=minioadmin
export AWS_SECRET_ACCESS_KEY=minioadmin
export AWS_DEFAULT_REGION=us-east-1
 
# Buat bucket
aws s3 mb s3://my-bucket --endpoint-url http://localhost:9000
 
# Upload 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 file
aws s3 cp s3://my-bucket/myfile.txt ./downloaded.txt --endpoint-url http://localhost:9000
 
# Sync folder
aws s3 sync ./local-folder s3://my-bucket/ --endpoint-url http://localhost:9000

Menggunakan 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
 
# Alias RustFS
mc alias set rustfs http://localhost:9000 minioadmin minioadmin
 
# Buat 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/

Menggunakan Python (boto3)

import boto3
from botocore.client import Config
 
# Koneksi ke 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'
)
 
# Buat bucket
try:
    s3.create_bucket(Bucket='my-bucket')
    print("Bucket berhasil dibuat!")
except Exception as e:
    print(f"Error: {e}")
 
# Upload file
s3.upload_file('myfile.txt', 'my-bucket', 'myfile.txt')
print("Upload berhasil!")
 
# List objects
response = s3.list_objects_v2(Bucket='my-bucket')
for obj in response.get('Contents', []):
    print(f"  {obj['Key']} ({obj['Size']} bytes)")
 
# Download file
s3.download_file('my-bucket', 'myfile.txt', 'downloaded.txt')
print("Download berhasil!")
 
# Generate presigned URL (berguna untuk sharing)
url = s3.generate_presigned_url(
    'get_object',
    Params={'Bucket': 'my-bucket', 'Key': 'myfile.txt'},
    ExpiresIn=3600
)
print(f"Presigned URL: {url}")

Menggunakan 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 dengan 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)
	}
 
	// Buat S3 client yang pointing ke 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 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 berhasil!")
}

Menggunakan Rclone

Rclone adalah tool sync universal yang sangat populer. RustFS bisa langsung dijadikan remote:

# Setup 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 local folder ke RustFS
rclone sync ./my-folder rustfs:my-bucket/my-folder
 
# Mount RustFS sebagai filesystem
mkdir -p ~/mnt/rustfs
rclone mount rustfs:my-bucket ~/mnt/rustfs --vfs-cache-mode full &
 
# Copy file langsung
cp largefile.bin ~/mnt/rustfs/
 
# Bis mount juga ke Android/TV/external devices via samba

Migrasi dari MinIO ke RustFS

Salah satu keunggulan besar RustFS adalah kompatibilitas penuh dengan API MinIO. Ini berarti migrasi dari MinIO ke RustFS relatif mudah.

Strategi 1: Mirror Data dengan mc

# Setup alias untuk MinIO dan RustFS
mc alias set minio http://minio-server:9000 minioadmin minioadmin
mc alias set rustfs http://rustfs-server:9000 minioadmin minioadmin
 
# Mirror semua bucket dari MinIO ke RustFS
mc mirror --overwrite minio/ rustfs/
 
# Untuk bucket tertentu
mc mirror --overwrite minio/my-bucket rustfs/my-bucket
 
# Monitor progress
mc mirror --overwrite --watch minio/ rustfs/

Strategi 2: Gunakan rclone

# Setup 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 dari MinIO ke RustFS
rclone sync minio: my-bucket rustfs: my-bucket \
  --progress \
  --transfers 16 \
  --checkers 8
 
# Bandwidth limit (opsional)
rclone sync minio: rustfs: \
  --bwlimit 50M \
  --progress

Strategi 3: Direct Copy dengan AWS CLI

# Export semua bucket list
BUCKETS=$(aws s3 ls --endpoint-url http://minio-server:9000 | awk '{print $3}')
 
for bucket in $BUCKETS; do
    echo "Migrating bucket: $bucket"
 
    # Buat bucket di RustFS
    aws s3 mb "s3://$bucket" --endpoint-url http://rustfs-server:9000
 
    # Copy semua 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 selesai!"

Strategi 4: Kedua Server Berjalan Bersamaan (Zero-Downtime)

Untuk production, kamu bisa menjalankan MinIO dan RustFS bersamaan selama masa transisi:

# Step 1: Deploy RustFS
docker compose -f rustfs-compose.yml up -d
 
# Step 2: Sync data dari MinIO ke RustFS (initial sync)
rclone sync minio: rustfs: --progress
 
# Step 3: Jalankan continuous sync (selisih data)
rclone bisync minio: rustfs: --resync --progress
 
# Step 4: Update DNS/load balancer untuk pointing ke RustFS
# Step 5: Verifikasi semua data sudah sinkron
rclone check minio: rustfs: --progress
 
# Step 6: Setelah yakin, stop MinIO
docker compose -f minio-compose.yml down

Tips Migrasi

Test dulu di staging — jangan langsung migrasi di production
Backup dulu — meskipun RustFS kompatibel, selalu backup data penting
Monitor resource — pantas CPU, memory, dan disk I/O selama migrasi
Batch migration — untuk data dalam jumlah besar, pecah menjadi beberapa batch
Validasi checksum — gunakan mc diff atau rclone check untuk memastikan integritas data

Perbandingan: RustFS vs MinIO vs Ceph

Tabel Perbandingan Lengkap

Fitur	RustFS	MinIO	Ceph
Bahasa	Rust	Go	C++ / Python
S3 API	✅ Lengkap	✅ Lengkap	✅ Via RGW
Performa (4KB)	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐
Memory Usage	Rendah	Sedang	Tinggi
Kemudahan Setup	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐
Multi-Protocol	S3	S3	S3, CephFS, RBD
Erasure Coding	✅	✅	✅
Replication	✅	✅	✅
Web Console	✅	✅	✅ (Dashboard)
Bash Size	Kecil	Sedang	Besar
Lisensi	Apache-2.0	AGPL-3.0	LGPL-2.1
Komunitas	Growing	Mature	Very Mature

RustFS vs MinIO

Keunggulan RustFS atas MinIO:

Performa — 2.3x lebih cepat untuk object kecil (4KB), berkat Rust
Memory — konsumsi RAM lebih rendah, cocok untuk server dengan resource terbatas
Lisensi — Apache-2.0 vs AGPL-3.0. Apache-2.0 lebih permisif untuk penggunaan komersial
No GC Pause — Rust tidak punya garbage collector, throughput lebih konsisten
Binary Size — lebih kecil, deployment lebih ringan

Keunggulan MinIO atas RustFS:

Maturity — MinIO sudah ada lebih lama, lebih battle-tested
Ekosistem — lebih banyak integrasi, dokumentasi, dan komunitas
Fitur — beberapa fitur mungkin lebih lengkap di MinIO (seperti beberapa lifecycle policies)
Support — MinIO punya versi enterprise dengan support

RustFS vs Ceph

Keunggulan RustFS atas Ceph:

Simplicity — RustFS jauh lebih mudah di-deploy dan di-maintain
Performance — RustFS lebih cepat untuk S3 workload
Resource — RustFS butuh resource jauh lebih sedikit
Setup Time — Ceph bisa butuh waktu berjam-jam untuk setup, RustFS bisa dalam hitungan menit

Keunggulan Ceph atas RustFS:

Multi-Protocol — Ceph bisa S3, CephFS (POSIX), dan RBD (block storage)
Scale — Ceph dirancang untuk scale ke exabyte-level
Maturity — Ceph sudah dipakai di banyak data center enterprise
Fitur — lebih banyak fitur enterprise seperti quotas, tiering, dsb

Kapan Harus Pilih Apa?

Skenario	Rekomendasi
Homelab / Personal	RustFS (simpel, ringan, cepat)
Small-Medium Production	RustFS atau MinIO
Enterprise dengan multi-protocol	Ceph
AI/ML Training Data	RustFS (performa untuk file kecil)
Backup Storage	RustFS atau MinIO
Exabyte-scale	Ceph
Quick prototyping	RustFS

Use Case untuk Homelab dan Production

🏠 Homelab Use Cases

1. Media Server Storage

# Jalankan RustFS untuk menyimpan film, musik, dan foto
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
 
# Koneksikan ke Jellyfin/Emby/Plex via S3 plugin
# Atau mount langsung dengan rclone
rclone mount rustfs:media /mnt/media --vfs-cache-mode full

2. Backup Target untuk Semua Perangkat

# Backup dari PC ke RustFS
rclone sync /home/user/documents rustfs:backups/documents --progress
rclone sync /home/user/photos rustfs:backups/photos --progress
 
# Backup dari Proxmox VM/LXC
vzdump 100 --storage rustfs-backup
 
# Backup database PostgreSQL
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 untuk RustFS backend
homeassistant:
  # Gunakan S3-compatible storage untuk history
  recorder:
    db_url: !secret db_url
  # Backup ke 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 dengan 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 dengan RustFS sebagai 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 dari 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 semua object di 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()))
        # Proses 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 untuk mengirim log ke 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 untuk 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 di Komunitas

RustFS mendapat sambutan hangat dari komunitas self-hoster dan developer. Beberapa tags populer di GitHub:

ai-native — didesain untuk workload AI modern
ai-storage — storage backend untuk AI pipelines
cloud-native — dibangun untuk lingkungan cloud dan container
object-storage — solusi object storage S3-compatible
rust — performa dan keamanan Rust
minio — kompatibel dengan ekosistem MinIO

Dengan 31K+ stars, RustFS sudah membuktikan bahwa ada demand besar untuk alternatif object storage yang lebih cepat dan efisien.

Kesimpulan

RustFS adalah alternatif yang sangat menarik untuk MinIO dan Ceph sebagai object storage S3-compatible. Dengan performa 2.3x lebih cepat untuk object kecil, lisensi Apache-20 yang permisif, dan kemudahan deployment ala MinIO, RustFS layak masuk radar kamu — baik untuk homelab maupun production.

Rekomendasi:

Coba dulu — deploy RustFS di homelab pakai Docker, rasakan bedanya
Benchmark — jalankan benchmark dengan workload spesifik kamu
Migrate — kalau hasilnya bagus, migrasi dari MinIO pakai mc mirror atau rclone
Monitor — pantau performa setelah migrasi untuk memastikan semuanya oke

RustFS masih tergolong young project dibandingkan MinIO dan Ceph, tapi dengan pertumbuhan komunitas yang pesat dan performa yang mengesankan, ini adalah salah satu project yang wajib di-follow di tahun 2026.

Links:

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

Apakah kamu sudah coba RustFS? Atau masih setia sama MinIO? Ceritakan pengalaman kamu di kolom komentar! 💬

Tulisan lain

Plane: Open-Source Project Management Alternatif Jira & Linear
24 Agustus 2026 · 7 menit baca
Coolify: Self-Hosted PaaS Alternatif Vercel & Heroku
18 Agustus 2026 · 7 menit baca
Arcane: Docker Management UI Modern untuk Homelab
17 Agustus 2026 · 8 menit baca
DBX: Database Client Ringan 20MB untuk 80+ Database
17 Agustus 2026 · 8 menit baca

RustFS: Object Storage S3-Compatible yang Lebih Cepat dari MinIO

Daftar Isi

Apa Itu RustFS?

Kenapa RustFS Menarik?

🚀 2.3x Lebih Cepat dari MinIO

🔌 S3-Compatible Penuh

⚡ Performa Rust

🏗️ Arsitektur yang Simpel

Fitur Utama RustFS

1. S3 API Lengkap

2. Erasure Coding

3. Encryption

4. Bucket Versioning

5. Lifecycle Management

6. Web Console

7. Multi-Tenancy dan IAM

8. Replication

Instalasi RustFS

Metode 1: Docker (Paling Mudah)

Metode 2: Docker Compose

Metode 3: Binary Langsung

Metode 4: Multi-Node Cluster

Metode 5: Systemd Service

Cara Menggunakan RustFS

Setup Client

Menggunakan Python (boto3)

Menggunakan Golang

Menggunakan Rclone

Migrasi dari MinIO ke RustFS

Strategi 1: Mirror Data dengan mc

Strategi 2: Gunakan rclone

Strategi 3: Direct Copy dengan AWS CLI

Strategi 4: Kedua Server Berjalan Bersamaan (Zero-Downtime)

Tips Migrasi

Perbandingan: RustFS vs MinIO vs Ceph

Tabel Perbandingan Lengkap

RustFS vs MinIO

RustFS vs Ceph

Kapan Harus Pilih Apa?

Use Case untuk Homelab dan Production

🏠 Homelab Use Cases

1. Media Server Storage

2. Backup Target untuk Semua Perangkat

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 di Komunitas

Kesimpulan

Tulisan lain

Plane: Open-Source Project Management Alternatif Jira & Linear

Coolify: Self-Hosted PaaS Alternatif Vercel & Heroku

Arcane: Docker Management UI Modern untuk Homelab

DBX: Database Client Ringan 20MB untuk 80+ Database