MinIO’ya Dosya Yükleme İçin En İyi Go Kütüphaneleri

Go programlama dili ile MinIO gibi S3 uyumlu depolama çözümlerine dosya yüklemek, modern uygulamaların vazgeçilmez bir parçası haline geldi. Ancak doğru kütüphaneyi seçmek ve karmaşık API’ler arasında kaybolmadan işlemi tamamlamak bazen zorlayıcı olabilir. Bu makale, Go ile MinIO’ya dosya yükleme süreçlerini basitleştiren en iyi 5 kütüphaneyi inceleyerek, geliştiricilerin “zihinlerini kaybetmeden” verimli çözümler üretmelerine yardımcı olmayı amaçlıyor. İster basit bir resim yükleme ister devasa veri aktarımları olsun, doğru araçlarla bu süreci kolaylaştırabiliriz.

MinIO, açık kaynaklı, yüksek performanslı ve dağıtık bir obje depolama sunucusudur. Amazon S3 API’si ile tamamen uyumlu olması sayesinde, geliştiriciler mevcut S3 bilgileriyle kolayca MinIO üzerinde çalışabilirler. Go (Golang) ise, Google tarafından geliştirilen, derlenmiş, eşzamanlı, çöp toplama özellikli bir programlama dilidir. Performans, güvenilirlik ve basitlik odaklı tasarımıyla, özellikle ağ tabanlı hizmetler ve dağıtık sistemler için idealdir. Go’nun sade ve etkili eşzamanlılık modeli (goroutine’ler ve kanallar) ile MinIO’nun yüksek I/O kapasitesi ve paralel işlem yeteneği, dosya yükleme gibi yoğun I/O operasyonlarında mükemmel bir ikili oluşturur. MinIO’nun kendisinin de Go ile yazılmış olması, dilin bu tür altyapı projeleri için ne kadar uygun olduğunun bir göstergesidir.

Modern bulut tabanlı uygulamalarda, dosya depolama gereksinimi hemen her projede karşımıza çıkar. Kullanıcıların profil resimleri, belgeler, videolar, yedekler veya log dosyaları… Bu verilerin güvenli, hızlı ve ölçeklenebilir bir şekilde depolanması kritik öneme sahiptir. MinIO, bu ihtiyacı karşılayan güçlü bir çözüm sunarken, Go da bu çözümle etkileşim kurmak için performanslı ve kolayca yönetilebilir kod yazmamızı sağlar. Ancak, bir dosyanın diskten okunup, ağ üzerinden MinIO sunucusuna gönderilmesi ve orada doğru bir şekilde depolanması, sadece birkaç satır koddan ibaret değildir. Hata yönetimi, büyük dosyalar için parçalı yükleme (multipart upload), ilerleme takibi, güvenlik (imzalı URL’ler), metadata yönetimi ve ağ kesintilerine karşı dayanıklılık gibi konuları ele almak gerekir. İşte tam bu noktada, işimizi kolaylaştıran, bu karmaşıklıkları soyutlayan ve bize sadece “dosyayı yükle” demeyi bırakan kütüphanelere ihtiyaç duyarız. Bu kütüphaneler sayesinde, geliştiriciler uygulamanın çekirdek mantığına odaklanabilirken, dosya depolama katmanı sağlam ve verimli bir şekilde çalışır.

MinIO Dosya Yükleme Dünyasına Dalış: Hangi Kütüphaneler Can Kurtarır?

MinIO’ya dosya yükleme konusunda Go ekosistemi, geliştiricilere zengin seçenekler sunar. Doğru kütüphaneyi seçmek, projenizin gereksinimlerine, performans beklentilerine ve geliştirici deneyimine bağlıdır. İşte bu alandaki en popüler ve etkili 5 Go kütüphanesi:

1. github.com/minio/minio-go/v7: MinIO’nun Kendi Resmi Çözümü

MinIO’nun resmi Go istemci kütüphanesi olan minio-go/v7, MinIO sunucusuyla etkileşim kurmak için en doğal ve kapsamlı çözümdür. Aktif olarak geliştirilen ve bakımı yapılan bu kütüphane, MinIO’nun tüm özelliklerini doğrudan Go uygulamalarınıza taşır. MinIO’nun kendi ekibi tarafından geliştirildiği için, MinIO sunucusundaki en son özellik ve optimizasyonlara en hızlı şekilde erişmenizi sağlar. Hem basit dosya yüklemeleri hem de büyük dosyalar için parçalı yükleme (multipart upload) gibi gelişmiş senaryoları sorunsuz bir şekilde destekler.

Bu kütüphaneyi kullanmak, özellikle MinIO’ya özgü özelliklerden tam anlamıyla yararlanmak isteyen projeler için idealdir. S3 uyumluluğunun ötesinde, MinIO’nun spesifik yeteneklerini (örneğin, sunucu taraflı şifreleme, objelerin kopyalanması, yaşam döngüsü kuralları vb.) doğrudan Go kodunuzdan yönetmenize olanak tanır. Kurulumu basit, API’si anlaşılırdır ve zengin dokümantasyonu sayesinde hızlıca adapte olabilirsiniz.

Temel Yükleme Örneği:

package main

import (
	"context"
	"log"
	"os"
	"strings"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false // MinIO'nuzu HTTPS ile kurduysanız true yapın

	// MinIO istemcisini başlat
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Fatalln(err)
	}

	bucketName := "mybucket"
	objectName := "my-file.txt"
	filePath := "./example.txt" // Yüklenecek dosya

	// Kovayı (bucket) kontrol et, yoksa oluştur
	found, err := minioClient.BucketExists(context.Background(), bucketName)
	if err != nil {
		log.Fatalln(err)
	}
	if !found {
		err = minioClient.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{})
		if err != nil {
			log.Fatalln(err)
		}
		log.Printf("Kova '%s' oluşturuldu.\n", bucketName)
	} else {
		log.Printf("Kova '%s' zaten mevcut.\n", bucketName)
	}

	// Yüklenecek dosyanın içeriğini al
	file, err := os.Open(filePath)
	if err != nil {
		log.Fatalln(err)
	}
	defer file.Close()

	fileStat, err := file.Stat()
	if err != nil {
		log.Fatalln(err)
	}

	// Dosyayı MinIO'ya yükle
	uploadInfo, err := minioClient.PutObject(context.Background(), bucketName, objectName, file, fileStat.Size(), minio.PutObjectOptions{ContentType: "application/octet-stream"})
	if err != nil {
		log.Fatalln(err)
	}

	log.Printf("Dosya başarıyla yüklendi: %s. Boyut: %d byte.\n", objectName, uploadInfo.Size)
}

Yukarıdaki örnek, basit bir dosya yükleme işlemini göstermektedir. Önce MinIO istemcisi oluşturulur, ardından hedef kova kontrol edilir ve eğer yoksa oluşturulur. Son olarak, yerel diskteki bir dosya okunarak MinIO'ya yüklenir. PutObjectOptions ile Content-Type gibi metadata da eklenebilir. Bu sayede dosyanın ne tür bir içerik olduğu MinIO tarafında belirtilmiş olur.

2. github.com/aws/aws-sdk-go-v2/service/s3: S3 Uyumluluğunun Gücü

MinIO'nun Amazon S3 API'si ile uyumlu olması, AWS'nin resmi Go SDK'sını, yani aws-sdk-go-v2/service/s3'ü MinIO ile kullanabileceğiniz anlamına gelir. Bu kütüphane, S3 uyumlu tüm depolama çözümleriyle çalışabilme esnekliği sunar. Eğer uygulamanızın gelecekte AWS S3'e veya diğer S3 uyumlu bir sağlayıcıya geçme ihtimali varsa, bu SDK'yı kullanmak harika bir seçenektir. AWS SDK, endüstri standardı bir yaklaşımdır ve geniş bir topluluk desteğine sahiptir.

AWS SDK'nın v2 sürümü, v1'e göre daha modüler, daha güvenli ve daha tutarlı bir API sunar. Yükleme işlemleri için PutObject veya büyük dosyalar için UploadManager gibi yüksek seviyeli soyutlamalar sağlar. UploadManager, özellikle büyük dosyaların parçalı yüklenmesini, eşzamanlılığı ve yeniden deneme mekanizmalarını otomatik olarak yöneterek geliştiricinin işini büyük ölçüde kolaylaştırır. Performans ve dayanıklılık açısından oldukça optimize edilmiştir.

Temel Yükleme Örneği:

package main

import (
	"context"
	"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/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
)

func main() {
	endpoint := "http://localhost:9000" // MinIO adresiniz
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	region := "us-east-1" // MinIO için herhangi bir bölge olabilir

	// Custom Resolver ile MinIO endpoint'ini ayarla
	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		return aws.Endpoint{
			URL: endpoint,
			// MinIO HTTPS kullanıyorsa Scheme: "https"
			// Veya Path: "/" gibi ek ayarlar
		}, nil
	})

	cfg, err := config.LoadDefaultConfig(context.TODO(),
		config.WithEndpointResolverWithOptions(customResolver),
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
		config.WithRegion(region),
	)
	if err != nil {
		log.Fatalf("AWS SDK yapılandırma hatası: %v", err)
	}

	client := s3.NewFromConfig(cfg)
	uploader := manager.NewUploader(client)

	bucketName := "mybucket"
	objectKey := "my-aws-sdk-file.txt"
	filePath := "./example.txt"

	file, err := os.Open(filePath)
	if err != nil {
		log.Fatalf("Dosya açılamadı: %v", err)
	}
	defer file.Close()

	// Dosyayı MinIO'ya yükle
	_, err = uploader.Upload(context.TODO(), &s3.PutObjectInput{
		Bucket: aws.String(bucketName),
		Key:    aws.String(objectKey),
		Body:   file,
		// ContentType: aws.String("application/octet-stream"), // İsteğe bağlı
	})
	if err != nil {
		log.Fatalf("Dosya yüklenemedi: %v", err)
	}

	log.Printf("Dosya başarıyla yüklendi: %s\n", objectKey)
}

Bu örnek, AWS SDK'nın MinIO ile nasıl kullanılacağını gösterir. config.WithEndpointResolverWithOptions ile MinIO sunucunuzun adresini belirtmeniz kritik öneme sahiptir. manager.NewUploader kullanarak, büyük dosyaların otomatik olarak parçalı yüklenmesi ve yeniden deneme mantığı gibi gelişmiş özellikleri kolayca kullanabilirsiniz.

3. gocloud.dev/blob: Çoklu Bulut Esnekliği İçin Soyutlama

gocloud.dev/blob, Google'ın Go Cloud projesinin bir parçası olarak geliştirilmiş, bulut depolama hizmetleri için satıcıdan bağımsız (vendor-agnostic) bir soyutlama katmanıdır. Bu kütüphane, MinIO, AWS S3, Google Cloud Storage, Azure Blob Storage gibi farklı depolama sağlayıcılarını tek bir birleşik API altında toplar. Uygulamanızın depolama katmanını belirli bir sağlayıcıya kilitlemek istemiyorsanız, gocloud.dev/blob mükemmel bir çözümdür.

Kütüphane, URL tabanlı konfigürasyonlarla çalışır; bu da kodunuzu değiştirmeden farklı sağlayıcılar arasında geçiş yapmanızı inanılmaz derecede kolaylaştırır. Örneğin, yerel geliştirme ortamında MinIO kullanırken, üretimde AWS S3'e geçmek için sadece yapılandırma URL'sini değiştirmeniz yeterli olur. Bu, "çoklu bulut" (multi-cloud) stratejileri uygulayan veya gelecekteki esnekliklerini korumak isteyen projeler için biçilmiş kaftandır. gocloud.dev/blob, dosya yükleme, indirme, silme ve objelerin listelenmesi gibi temel blob depolama işlemlerini tutarlı bir şekilde sunar.

Temel Yükleme Örneği:

package main

import (
	"context"
	"log"
	"os"
	"strings"

	"gocloud.dev/blob"
	_ "gocloud.dev/blob/s3blob" // MinIO için S3 driver'ı gerekli
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/aws" // EndpointResolver için gerekli
)

func main() {
	ctx := context.Background()
	
	// MinIO için custom resolver
	endpoint := "http://localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	region := "us-east-1"

	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		return aws.Endpoint{
			URL: endpoint,
		}, nil
	})

	// AWS SDK yapılandırması (Go Cloud S3 driver'ı bunu kullanır)
	cfg, err := config.LoadDefaultConfig(ctx,
		config.WithEndpointResolverWithOptions(customResolver),
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
		config.WithRegion(region),
	)
	if err != nil {
		log.Fatalf("AWS SDK yapılandırma hatası: %v", err)
	}

	// S3/MinIO için URL şeması: s3://
	// Go Cloud'ın S3 driver'ı için AWS SDK yapılandırmasını bir bağlamda sakla
	ctx = blob.Set 

package main

import (
	"bytes"
	"context"
	"image/jpeg"
	"log"
	"os"

	"github.com/disintegration/imaging"
	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false

	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Fatalln(err)
	}

	bucketName := "images"
	originalImagePath := "./original_image.jpg" // Yüklenecek orijinal görsel
	objectNameOriginal := "product-123-original.jpg"
	objectNameThumbnail := "product-123-thumbnail.jpg"

	// Orijinal görseli yükle
	file, err := os.Open(originalImagePath)
	if err != nil {
		log.Fatalln(err)
	}
	defer file.Close()

	fileStat, err := file.Stat()
	if err != nil {
		log.Fatalln(err)
	}

	_, err = minioClient.PutObject(context.Background(), bucketName, objectNameOriginal, file, fileStat.Size(), minio.PutObjectOptions{ContentType: "image/jpeg"})
	if err != nil {
		log.Fatalln("Orijinal görsel yüklenemedi:", err)
	}
	log.Printf("Orijinal görsel başarıyla yüklendi: %s\n", objectNameOriginal)

	// Görseli yeniden boyutlandır (thumbnail oluştur)
	img, err := imaging.Open(originalImagePath)
	if err != nil {
		log.Fatalln("Görsel açılamadı:", err)
	}

	thumbnail := imaging.Resize(img, 100, 0, imaging.Lanczos) // Genişlik 100px, yükseklik otomatik

	// Thumbnail'ı belleğe yaz
	buf := new(bytes.Buffer)
	err = jpeg.Encode(buf, thumbnail, nil)
	if err != nil {
		log.Fatalln("Thumbnail kodlanamadı:", err)
	}

	// Thumbnail'ı MinIO'ya yükle
	_, err = minioClient.PutObject(context.Background(), bucketName, objectNameThumbnail, buf, int64(buf.Len()), minio.PutObjectOptions{ContentType: "image/jpeg"})
	if err != nil {
		log.Fatalln("Thumbnail yüklenemedi:", err)
	}
	log.Printf("Thumbnail başarıyla yüklendi: %s\n", objectNameThumbnail)
}

package main

import (
	"bytes"
	"context"
	"io"
	"log"
	"os"

	"github.com/klauspost/compress/zstd" // Zstd sıkıştırma algoritması
	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false

	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Fatalln(err)
	}

	bucketName := "compressed-data"
	originalFilePath := "./large_log_file.txt" // Sıkıştırılacak dosya
	compressedObjectName := "large_log_file.zst"

	// 1. Orijinal dosyayı aç
	file, err := os.Open(originalFilePath)
	if err != nil {
		log.Fatalln("Orijinal dosya açılamadı:", err)
	}
	defer file.Close()

	// 2. Bir sıkıştırma yazar (writer) oluştur
	var compressedBuf bytes.Buffer
	zw, err := zstd.NewWriter(&compressedBuf)
	if err != nil {
		log.Fatalln("Zstd yazar oluşturulamadı:", err)
	}

	// 3. Dosyanın içeriğini sıkıştırma yazarımıza kopyala
	_, err = io.Copy(zw, file)
	if err != nil {
		log.Fatalln("Dosya sıkıştırılamadı:", err)
	}
	zw.Close() // Sıkıştırma işlemini tamamla

	// 4. Sıkıştırılmış veriyi MinIO'ya yükle
	uploadInfo, err := minioClient.PutObject(context.Background(), bucketName, compressedObjectName, &compressedBuf, int64(compressedBuf.Len()), minio.PutObjectOptions{
		ContentType: "application/zstd", // ContentType'ı sıkıştırma tipine göre ayarla
	})
	if err != nil {
		log.Fatalln("Sıkıştırılmış dosya yüklenemedi:", err)
	}

	log.Printf("Sıkıştırılmış dosya başarıyla yüklendi: %s. Orijinal boyut: %d, Sıkıştırılmış boyut: %d\n", compressedObjectName, file.Size(), uploadInfo.Size)
}

package main

import (
	"context"
	"log"
	"time"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false

	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Fatalln(err)
	}

	bucketName := "public-uploads"
	objectName := "my-temporary-upload.txt"
	expiry := time.Second * 60 // URL 60 saniye geçerli olacak

	// Yükleme için imzalı URL oluştur
	presignedURL, err := minioClient.PresignedPutObject(context.Background(), bucketName, objectName, expiry)
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("İmzalı yükleme URL'si (60 saniye geçerli): %s\n", presignedURL)

	// Bu URL'yi istemcinize gönderin. İstemci bu URL'ye PUT isteği yaparak dosyayı yükleyebilir.
	// Örnek: curl -X PUT -H "Content-Type: text/plain" --upload-file ./local_file.txt "PRESIGNED_URL_BURAYA"
}

package main

import (
	"context"
	"log"
	"os"
	"time"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

func uploadWithRetries(client *minio.Client, bucket, object string, file *os.File, fileSize int64, retries int) error {
	for i := 0; i < retries; i++ {
		log.Printf("Dosya yükleniyor: %s (Deneme %d/%d)\n", object, i+1, retries)
		
		// Dosya okunmuş olabileceği için başa sar
		file.Seek(0, 0) 

		_, err := client.PutObject(context.Background(), bucket, object, file, fileSize, minio.PutObjectOptions{ContentType: "application/octet-stream"})
		if err == nil {
			log.Printf("Dosya başarıyla yüklendi: %s\n", object)
			return nil
		}
		log.Printf("Yükleme hatası: %v. %d saniye sonra tekrar denenecek.\n", err, 1<

package main

import (
	"context"
	"log"
	"os"
	"path/filepath"
	"sync"
	"time"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

type UploadJob struct {
	FilePath string
	Bucket   string
	Object   string
}

func worker(id int, jobs <-chan UploadJob, results chan<- error, client *minio.Client) {
	for job := range jobs {
		log.Printf("Worker %d: %s yükleniyor...\n", id, job.Object)
		file, err := os.Open(job.FilePath)
		if err != nil {
			results <- err
			continue
		}
		fileStat, err := file.Stat()
		if err != nil {
			file.Close()
			results <- err
			continue
		}

		_, err = client.PutObject(context.Background(), job.Bucket, job.Object, file, fileStat.Size(), minio.PutObjectOptions{ContentType: "application/octet-stream"})
		file.Close() // Her zaman dosyayı kapat

		if err != nil {
			results <- err
			log.Printf("Worker %d: %s yükleme hatası: %v\n", id, job.Object, err)
		} else {
			results <- nil
			log.Printf("Worker %d: %s başarıyla yüklendi.\n", id, job.Object)
		}
	}
}

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false

	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Fatalln(err)
	}

	bucketName := "batch-uploads"
	numWorkers := 3 // Aynı anda kaç dosyanın yükleneceği
	numJobs := 5    // Toplam dosya sayısı

	jobs := make(chan UploadJob, numJobs)
	results := make(chan error, numJobs)

	// İşçi havuzunu başlat
	var wg sync.WaitGroup
	for w := 1; w <= numWorkers; w++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			worker(workerID, jobs, results, minioClient)
		}(w)
	}

	// İşleri gönder
	for j := 1; j <= numJobs; j++ {
		filePath := filepath.Join(".", "files", "file-"+time.Now().Format("20060102150405")+"-"+  strconv.Itoa(j)+".txt")
		// Küçük test dosyaları oluştur
		os.WriteFile(filePath, []byte("Test content for file "+strconv.Itoa(j)), 0644)

		jobs <- UploadJob{
			FilePath: filePath,
			Bucket:   bucketName,
			Object:   "batch-upload-" + strconv.Itoa(j) + ".txt",
		}
	}
	close(jobs) // Tüm işler gönderildiğinde kanalı kapat

	// Tüm işçilerin bitmesini bekle
	wg.Wait()
	close(results)

	// Sonuçları topla
	for i := 0; i < numJobs; i++ {
		err := <-results
		if err != nil {
			log.Printf("İş %d hata ile tamamlandı: %v\n", i+1, err)
		} else {
			log.Printf("İş %d başarıyla tamamlandı.\n", i+1)
		}
	}
}