173 lines
4.7 KiB
Plaintext
173 lines
4.7 KiB
Plaintext
# 📚 Dokumentasi Integrasi Minio Storage
|
|
|
|
Modul ini (`internal/interfaces/minio`) berfungsi untuk mengatur koneksi dan inisialisasi ke layanan Object Storage berbasis S3 (seperti Minio, AWS S3, dll) menggunakan SDK `minio-go/v7`.
|
|
|
|
---
|
|
|
|
## 1. Konfigurasi (Environment / YAML)
|
|
|
|
Berdasarkan struct `MinioCfg`, aplikasi mengekspektasikan konfigurasi untuk Minio. Pastikan file konfigurasi Anda (misalnya `config.yaml`) memiliki struktur yang dipetakan sebagai berikut:
|
|
|
|
```yaml
|
|
minio:
|
|
endpoint: "play.min.io" # (Contoh) Jangan gunakan http:// atau https://
|
|
region: "ap-southeast-1" # Region server S3/Minio
|
|
accessKey: "YOUR-ACCESS-KEY" # Access key dari Minio
|
|
secretKey: "YOUR-SECRET-KEY" # Secret key dari Minio
|
|
useSsl: true # true untuk HTTPS, false untuk HTTP
|
|
bucketName:
|
|
- "my-app-bucket" # Daftar bucket yang digunakan
|
|
- "public-assets"
|
|
```
|
|
*(Catatan: Konfigurasi ini akan di-parse menggunakan package `github.com/karincake/apem` sesuai implementasi di `Connect()`)*.
|
|
|
|
---
|
|
|
|
## 2. Cara Inisialisasi di `main.go`
|
|
|
|
Untuk mengaktifkan koneksi ke Minio saat aplikasi berjalan, Anda cukup memanggil fungsi `Connect()` dari package ini pada saat proses bootstrap di file `cmd/api/main.go`.
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"service/internal/interfaces/minio"
|
|
// import lainnya...
|
|
)
|
|
|
|
func main() {
|
|
// 1. Load config umum (seperti DB, dll)
|
|
// ...
|
|
|
|
// 2. Inisialisasi Minio
|
|
minio.Connect()
|
|
|
|
// Jika berhasil, log "Instantiation for object storage service using Minio, status: DONE!!"
|
|
// akan muncul di console dan client minio.I siap digunakan.
|
|
|
|
// ... Lanjutkan inisialisasi server (REST/gRPC)
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 3. Cara Penggunaan (Sinkronisasi, Upload, dan Download)
|
|
|
|
Koneksi klien disimpan secara global dalam variabel pointer `minio.I`. Anda dapat memanggilnya di layer **Repository** atau **Service** Anda untuk melakukan operasi Object Storage.
|
|
|
|
Berikut adalah contoh implementasi metode-metode yang bisa digunakan:
|
|
|
|
### A. Upload File (Sinkronisasi File Lokal ke Minio)
|
|
Gunakan metode `PutObject` untuk mengunggah data/file ke dalam Minio.
|
|
|
|
```go
|
|
package fileservice
|
|
|
|
import (
|
|
"context"
|
|
"mime/multipart"
|
|
"service/internal/interfaces/minio"
|
|
|
|
miniogo "github.com/minio/minio-go/v7"
|
|
)
|
|
|
|
func UploadFile(ctx context.Context, file *multipart.FileHeader, bucketName, objectName string) error {
|
|
src, err := file.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
|
|
// Menggunakan variabel global minio.I
|
|
info, err := minio.I.PutObject(ctx, bucketName, objectName, src, file.Size, miniogo.PutObjectOptions{
|
|
ContentType: file.Header.Get("Content-Type"),
|
|
})
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// info.Size, info.Key bisa digunakan jika ingin dicatat ke database
|
|
_ = info
|
|
return nil
|
|
}
|
|
```
|
|
|
|
### B. Download File dari Minio
|
|
Gunakan metode `GetObject` untuk mengambil file stream dari storage.
|
|
|
|
```go
|
|
package fileservice
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"service/internal/interfaces/minio"
|
|
|
|
miniogo "github.com/minio/minio-go/v7"
|
|
)
|
|
|
|
func DownloadFile(ctx context.Context, bucketName, objectName string) (io.ReadCloser, error) {
|
|
// Mengambil file stream dari minio
|
|
object, err := minio.I.GetObject(ctx, bucketName, objectName, miniogo.GetObjectOptions{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Ingat untuk melakukan object.Close() setelah selesai membaca di sisi HTTP Handler
|
|
return object, nil
|
|
}
|
|
```
|
|
|
|
### C. Menghasilkan Presigned URL (Untuk Download/Akses Publik Sementara)
|
|
Jika file bersifat privat, namun Anda ingin memberikan akses baca ke *frontend* (browser) untuk jangka waktu tertentu.
|
|
|
|
```go
|
|
package fileservice
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
"service/internal/interfaces/minio"
|
|
)
|
|
|
|
func GetFileUrl(ctx context.Context, bucketName, objectName string) (string, error) {
|
|
// URL akan valid selama 24 jam
|
|
expiry := time.Second * 24 * 60 * 60
|
|
|
|
presignedURL, err := minio.I.PresignedGetObject(ctx, bucketName, objectName, expiry, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return presignedURL.String(), nil
|
|
}
|
|
```
|
|
|
|
### D. Memastikan / Membuat Bucket Otomatis
|
|
Sebelum upload, ada baiknya memastikan bucket sudah ada.
|
|
|
|
```go
|
|
package fileservice
|
|
|
|
import (
|
|
"context"
|
|
"service/internal/interfaces/minio"
|
|
|
|
miniogo "github.com/minio/minio-go/v7"
|
|
)
|
|
|
|
func EnsureBucketExists(ctx context.Context, bucketName string) error {
|
|
exists, err := minio.I.BucketExists(ctx, bucketName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !exists {
|
|
err = minio.I.MakeBucket(ctx, bucketName, miniogo.MakeBucketOptions{Region: minio.O.Region})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
``` |