# MinIO Installation Recommendation for Calypso Appliance

## Executive Summary

**Rekomendasi: Native Installation** ✅

Untuk Calypso appliance, **native installation** MinIO lebih sesuai daripada Docker karena:
1. Konsistensi dengan komponen lain (semua native)
2. Performa lebih baik (tanpa overhead container)
3. Integrasi lebih mudah dengan ZFS dan systemd
4. Sesuai dengan filosofi appliance (minimal dependencies)

---

## Analisis Arsitektur Calypso

### Komponen yang Sudah Terinstall (Semuanya Native)

| Komponen | Installation Method | Service Management |
|----------|-------------------|-------------------|
| **ZFS** | Native (kernel modules) | systemd (zfs-zed.service) |
| **SCST** | Native (kernel modules) | systemd (scst.service) |
| **NFS** | Native (nfs-kernel-server) | systemd (nfs-server.service) |
| **SMB** | Native (Samba) | systemd (smbd.service, nmbd.service) |
| **ClamAV** | Native (clamav-daemon) | systemd (clamav-daemon.service) |
| **MHVTL** | Native (kernel modules) | systemd (mhvtl.target) |
| **Bacula** | Native (bacula packages) | systemd (bacula-*.service) |
| **PostgreSQL** | Native (postgresql-16) | systemd (postgresql.service) |
| **Calypso API** | Native (Go binary) | systemd (calypso-api.service) |

**Kesimpulan:** Semua komponen menggunakan native installation dan dikelola melalui systemd.

---

## Perbandingan: Native vs Docker

### Native Installation ✅ **RECOMMENDED**

**Pros:**
- ✅ **Konsistensi**: Semua komponen lain native, MinIO juga native
- ✅ **Performa**: Tidak ada overhead container, akses langsung ke ZFS
- ✅ **Integrasi**: Lebih mudah integrasi dengan ZFS datasets sebagai storage backend
- ✅ **Monitoring**: Logs langsung ke journald, metrics mudah diakses
- ✅ **Resource**: Lebih efisien (tidak perlu Docker daemon)
- ✅ **Security**: Sesuai dengan security model appliance (systemd security hardening)
- ✅ **Management**: Dikelola melalui systemd seperti komponen lain
- ✅ **Dependencies**: MinIO binary standalone, tidak perlu Docker runtime

**Cons:**
- ⚠️ Update: Perlu download binary baru dan restart service
- ⚠️ Dependencies: Perlu manage MinIO binary sendiri

**Mitigation:**
- Update bisa diotomasi dengan script
- MinIO binary bisa disimpan di `/opt/calypso/bin/` seperti komponen lain

### Docker Installation ❌ **NOT RECOMMENDED**

**Pros:**
- ✅ Isolasi yang lebih baik
- ✅ Update lebih mudah (pull image baru)
- ✅ Tidak perlu manage dependencies

**Cons:**
- ❌ **Inkonsistensi**: Semua komponen lain native, Docker akan jadi exception
- ❌ **Overhead**: Docker daemon memakan resource (~50-100MB RAM)
- ❌ **Kompleksitas**: Tambahan layer management (Docker + systemd)
- ❌ **Integrasi**: Lebih sulit integrasi dengan ZFS (perlu volume mapping)
- ❌ **Performance**: Overhead container, terutama untuk I/O intensive workload
- ❌ **Security**: Tambahan attack surface (Docker daemon)
- ❌ **Monitoring**: Logs perlu di-forward dari container ke journald
- ❌ **Dependencies**: Perlu install Docker (tidak sesuai filosofi minimal dependencies)

---

## Rekomendasi Implementasi

### Native Installation Setup

#### 1. Binary Location
```
/opt/calypso/bin/minio
```

#### 2. Configuration Location
```
/opt/calypso/conf/minio/
  ├── config.json
  └── minio.env
```

#### 3. Data Location (ZFS Dataset)
```
/opt/calypso/data/pool/<pool-name>/object/
```

#### 4. Systemd Service
```ini
[Unit]
Description=MinIO Object Storage
After=network.target zfs.target
Wants=zfs.target

[Service]
Type=simple
User=calypso
Group=calypso
WorkingDirectory=/opt/calypso
ExecStart=/opt/calypso/bin/minio server /opt/calypso/data/pool/%i/object --config-dir /opt/calypso/conf/minio
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier=minio

# Security
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/calypso/data /opt/calypso/conf/minio /var/log/calypso

# Resource limits
LimitNOFILE=65536
LimitNPROC=4096

[Install]
WantedBy=multi-user.target
```

#### 5. Integration dengan ZFS
- MinIO storage backend menggunakan ZFS dataset
- Dataset dibuat di pool yang sudah ada
- Mount point: `/opt/calypso/data/pool/<pool-name>/object/`
- Manfaatkan ZFS features: compression, snapshots, replication

---

## Arsitektur yang Disarankan

```
┌─────────────────────────────────────┐
│     Calypso Appliance               │
├─────────────────────────────────────┤
│                                     │
│  ┌──────────────────────────────┐  │
│  │   Calypso API (Go)           │  │
│  │   Port: 8080                 │  │
│  └───────────┬──────────────────┘  │
│              │                      │
│  ┌───────────▼──────────────────┐  │
│  │   MinIO (Native Binary)      │  │
│  │   Port: 9000, 9001           │  │
│  │   Storage: ZFS Dataset       │  │
│  └───────────┬──────────────────┘  │
│              │                      │
│  ┌───────────▼──────────────────┐  │
│  │   ZFS Pool                   │  │
│  │   Dataset: object/           │  │
│  └──────────────────────────────┘  │
│                                     │
└─────────────────────────────────────┘
```

---

## Installation Steps (Native)

### 1. Download MinIO Binary
```bash
# Download latest MinIO binary
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /opt/calypso/bin/
sudo chown calypso:calypso /opt/calypso/bin/minio
```

### 2. Create ZFS Dataset for Object Storage
```bash
# Create dataset in existing pool
sudo zfs create <pool-name>/object
sudo zfs set mountpoint=/opt/calypso/data/pool/<pool-name>/object <pool-name>/object
sudo chown -R calypso:calypso /opt/calypso/data/pool/<pool-name>/object
```

### 3. Create Configuration Directory
```bash
sudo mkdir -p /opt/calypso/conf/minio
sudo chown calypso:calypso /opt/calypso/conf/minio
```

### 4. Create Systemd Service
```bash
sudo cp /src/calypso/deploy/systemd/minio.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable minio.service
sudo systemctl start minio.service
```

### 5. Integration dengan Calypso API
- Backend API mengelola MinIO melalui MinIO Admin API atau Go SDK
- Configuration disimpan di database Calypso
- UI untuk manage buckets, policies, users

---

## Kesimpulan

**Native Installation** adalah pilihan terbaik untuk Calypso appliance karena:

1. ✅ **Konsistensi**: Semua komponen lain native
2. ✅ **Performa**: Optimal untuk I/O intensive workload
3. ✅ **Integrasi**: Seamless dengan ZFS dan systemd
4. ✅ **Filosofi**: Sesuai dengan "appliance-first" dan "minimal dependencies"
5. ✅ **Management**: Unified management melalui systemd
6. ✅ **Security**: Sesuai dengan security model appliance

**Docker Installation** tidak direkomendasikan karena:
- ❌ Menambah kompleksitas tanpa benefit yang signifikan
- ❌ Inkonsisten dengan arsitektur yang ada
- ❌ Overhead yang tidak perlu untuk appliance

---

## Next Steps

1. ✅ Implementasi native MinIO installation
2. ✅ Create systemd service file
3. ✅ Integrasi dengan ZFS dataset
4. ✅ Backend API integration
5. ✅ Frontend UI untuk MinIO management

---

## Date
2026-01-09
