Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
MinIO, yüksek performanslı, dağıtık ve bulut yerel (cloud-native) bir nesne depolama çözümüdür. Amazon S3 API’si ile tam uyumlu olan MinIO, modern veri depolama ihtiyaçlarını karşılamak üzere tasarlanmış açık kaynaklı bir yazılımdır. MinIO, özellikle büyük veri, yapay zeka, makine öğrenimi, veri gölleri (data lakes) ve bulut yerel uygulamalar gibi alanlarda kullanılmak üzere optimize edilmiştir.
Yüksek Performans:
Amazon S3 Uyumluluğu:
Dağıtık ve Ölçeklenebilir Mimari:
Bulut Yerel (Cloud-Native):
Açık Kaynaklı ve Topluluk Destekli:
Güvenlik:
Kolay Kurulum ve Yönetim:
mc
) ile kolayca yönetilebilir.Veri Gölü (Data Lake):
Bulut Yerel Uygulamalar:
Arşivleme ve Yedekleme:
Çoklu Bulut (Multi-Cloud) ve Hibrit Bulut (Hybrid Cloud):
Büyük Veri ve Analitik:
Açık Kaynaklı Olması:
S3 Uyumluluğu:
Yüksek Performans:
Esneklik ve Ölçeklenebilirlik:
Bulut Yerel Uyumluluk:
MinIO, yüksek hızda veri okuma ve yazma işlemleri için optimize edilmiştir. Bu özellik, özellikle büyük veri, makine öğrenimi ve veri analitiği gibi yüksek performans gerektiren iş yükleri için idealdir.
MinIO, Amazon S3 API’si ile tam uyumludur. Bu, MinIO’yu mevcut S3 tabanlı uygulamalar ve araçlarla sorunsuz bir şekilde entegre edilebilir hale getirir.
MinIO, dağıtık bir mimariye sahiptir ve birden fazla sunucu üzerinde çalışabilir. Bu, büyük veri depolama ihtiyaçlarını karşılamak için önemlidir.
MinIO, modern bulut yerel teknolojilerle tam uyumludur. Bu, özellikle Kubernetes ve mikroservis mimarileri için önemlidir.
MinIO, açık kaynaklı bir projedir ve geniş bir topluluk tarafından desteklenir. Bu, MinIO’nun sürekli olarak geliştirilmesini ve iyileştirilmesini sağlar.
MinIO, veri güvenliği için çeşitli özellikler sunar. Bu, özellikle hassas verilerin depolanması ve yönetilmesi için önemlidir.
MinIO, basit ve hızlı bir şekilde kurulabilir. Ayrıca, kullanımı ve yönetimi kolaydır.
mc
): MinIO, komut satırı aracı (mc
) ile kolayca yönetilebilir. Bu araç, bucket yönetimi, dosya yükleme/indirme ve diğer işlemler için kullanılır.MinIO, veri yönetimi için çeşitli özellikler sunar. Bu, verilerin etkin bir şekilde yönetilmesini ve saklanmasını sağlar.
MinIO, çoklu bulut (multi-cloud) ve hibrit bulut (hybrid cloud) stratejileri için idealdir.
MinIO, büyük veri ve analitik araçlarıyla sorunsuz bir şekilde entegre olur.
MinIO, büyük miktarda yapılandırılmamış veriyi depolamak ve yönetmek için ideal bir çözümdür. Veri gölleri, kurumların büyük veri analitiği, makine öğrenimi ve yapay zeka uygulamaları için merkezi bir veri deposu oluşturmasını sağlar.
MinIO, modern bulut yerel uygulamalar için ideal bir depolama çözümüdür. Kubernetes ve mikroservis mimarileriyle tam uyumlu olması, MinIO’yu bulut yerel teknolojilerin vazgeçilmez bir parçası haline getirir.
MinIO, uzun süreli veri arşivleme ve yedekleme çözümleri için kullanılabilir. Veri yaşam döngüsü yönetimi (lifecycle management) özellikleri sayesinde, veriler maliyet etkin bir şekilde saklanabilir.
MinIO, çoklu bulut ve hibrit bulut stratejileri için idealdir. Farklı bulut sağlayıcıları ve şirket içi altyapılar arasında veri taşınabilirliği sağlar.
MinIO, büyük veri ve analitik iş yükleri için güçlü bir depolama çözümüdür. Büyük veri araçlarıyla entegre edilerek veri analitiği süreçlerini destekler.
MinIO, medya ve eğlence sektöründe büyük miktarda veri depolama ve yönetme ihtiyaçlarını karşılamak için kullanılabilir.
MinIO, sağlık ve biyoteknoloji sektöründe büyük miktarda veri depolama ve yönetme ihtiyaçlarını karşılamak için kullanılabilir.
MinIO, finans ve bankacılık sektöründe büyük miktarda veri depolama ve yönetme ihtiyaçlarını karşılamak için kullanılabilir.
MinIO, e-ticaret ve perakende sektöründe büyük miktarda veri depolama ve yönetme ihtiyaçlarını karşılamak için kullanılabilir.
MinIO, IoT cihazlarından gelen büyük miktarda veriyi depolamak ve yönetmek için kullanılabilir.
Linux, MinIO’nun en yaygın kullanıldığı platformlardan biridir. Aşağıda, Linux üzerinde MinIO’nun nasıl kurulacağını adım adım anlatıyorum:
MinIO’nun en son sürümünü resmi web sitesinden veya terminal üzerinden indirebilirsiniz.
wget https://dl.min.io/server/minio/release/linux-amd64/minio
İndirilen binary dosyasını çalıştırılabilir hale getirin:
chmod +x minio
MinIO’yu başlatmak için aşağıdaki komutu kullanın. Bu örnekte, MinIO’nun verileri depolayacağı dizin olarak /data
kullanılmıştır:
./minio server /data
MinIO başlatıldığında, tarayıcı üzerinden erişim için bir URL ve erişim anahtarları (Access Key, Secret Key) gösterilir. Bu bilgileri kullanarak MinIO web arayüzüne erişebilirsiniz.
Windows üzerinde MinIO kurulumu, Linux’a benzer şekilde gerçekleştirilir. İşte adımlar:
MinIO’nun Windows sürümünü resmi web sitesinden veya PowerShell üzerinden indirin:
Invoke-WebRequest -Uri "https://dl.min.io/server/minio/release/windows-amd64/minio.exe" -OutFile "minio.exe"
MinIO’yu başlatmak için PowerShell’de aşağıdaki komutu kullanın. Bu örnekte, veriler C:\data
dizininde depolanacaktır:
.\minio.exe server C:\data
MinIO başlatıldığında, tarayıcı üzerinden erişim için bir URL ve erişim anahtarları (Access Key, Secret Key) gösterilir.
Docker, MinIO’yu hızlı bir şekilde kurup çalıştırmak için harika bir seçenektir. İşte adımlar:
Eğer Docker kurulu değilse, öncelikle Docker’ı kurun: Docker Kurulum Rehberi
Aşağıdaki komutla MinIO container’ını başlatın:
docker run -p 9000:9000 -p 9001:9001 \
--name minio \
-v /mnt/data:/data \
minio/minio server /data --console-address ":9001"
-p 9000:9000
: MinIO API erişimi için port.-p 9001:9001
: MinIO web konsolu için port.-v /mnt/data:/data
: Verilerin depolanacağı dizin.MinIO container’ı başlatıldığında, tarayıcı üzerinden erişim için bir URL ve erişim anahtarları (Access Key, Secret Key) gösterilir.
Kubernetes, MinIO’yu dağıtık ve ölçeklenebilir bir şekilde çalıştırmak için idealdir. İşte adımlar:
MinIO Operator, Kubernetes üzerinde MinIO’yu yönetmek için kullanılır. Operator’ü kurmak için aşağıdaki komutu kullanın:
kubectl apply -f https://github.com/minio/operator/releases/latest/download/minio-operator.yaml
MinIO Tenant, Kubernetes üzerinde çalışan bir MinIO kümesidir. Tenant oluşturmak için örnek bir YAML dosyası kullanın:
apiVersion: minio.min.io/v2
kind: Tenant
metadata:
name: minio-tenant
namespace: minio-operator
spec:
pools:
- servers: 4
volumesPerServer: 4
resources:
requests:
memory: "2Gi"
cpu: "500m"
credentials:
secret:
name: minio-tenant-secret
Bu YAML dosyasını minio-tenant.yaml
olarak kaydedin ve aşağıdaki komutla uygulayın:
kubectl apply -f minio-tenant.yaml
MinIO Tenant oluşturulduğunda, erişim bilgileri Kubernetes secret’ı olarak saklanır. Bu bilgileri almak için aşağıdaki komutu kullanın:
kubectl get secret minio-tenant-secret -o jsonpath="{.data.accesskey}" | base64 --decode
kubectl get secret minio-tenant-secret -o jsonpath="{.data.secretkey}" | base64 --decode
MinIO sunucusu, başlatılırken çeşitli parametreler ve yapılandırma dosyaları ile yapılandırılabilir. İşte temel yapılandırma seçenekleri:
MinIO, verileri depolamak için bir dizin kullanır. Bu dizin, MinIO sunucusunu başlatırken belirtilir:
minio server /data
Bu örnekte, /data
dizini MinIO’nun verileri depolayacağı dizindir. Birden fazla dizin belirterek yüksek kullanılabilirlik sağlanabilir:
minio server /data1 /data2 /data3 /data4
MinIO, varsayılan olarak 9000
portunu kullanır. Farklı bir port belirtmek için --address
parametresini kullanın:
minio server --address :9090 /data
MinIO, varsayılan olarak rastgele erişim anahtarları oluşturur. Bu anahtarları özelleştirmek için ortam değişkenlerini kullanabilirsiniz:
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=password
minio server /data
MinIO, yapılandırma ayarlarını bir yapılandırma dosyası (config.json
) ile de yönetebilir. Bu dosya, MinIO sunucusunun davranışını özelleştirmek için kullanılır.
MinIO yapılandırma dosyası, JSON formatında olmalıdır. Örnek bir yapılandırma dosyası:
{
"version": "1",
"credential": {
"accessKey": "admin",
"secretKey": "password"
},
"region": "us-east-1",
"browser": "on",
"storageclass": {
"standard": "EC:2"
}
}
Yapılandırma dosyasını kullanmak için --config-dir
parametresini kullanın:
minio server --config-dir /etc/minio /data
MinIO, ortam değişkenleri ile de yapılandırılabilir. Bu, özellikle container ortamlarında (Docker, Kubernetes) kullanışlıdır.
MINIO_ROOT_USER
: Root kullanıcı adı.MINIO_ROOT_PASSWORD
: Root kullanıcı şifresi.MINIO_REGION
: MinIO sunucusunun bölgesi.MINIO_BROWSER
: Web tarayıcı arayüzünü etkinleştirme veya devre dışı bırakma (on
veya off
).Örnek:
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=password
export MINIO_REGION=us-east-1
export MINIO_BROWSER=on
minio server /data
MINIO_STORAGE_CLASS_STANDARD
: Standart depolama sınıfı yapılandırması.MINIO_LOG_QUERY_URL
: Log sorguları için URL.MINIO_KMS_MASTER_KEY
: Şifreleme için ana anahtar.Örnek:
export MINIO_STORAGE_CLASS_STANDARD="EC:2"
export MINIO_KMS_MASTER_KEY="my-master-key"
minio server /data
MinIO, güvenli bir şekilde çalıştırılmak üzere çeşitli yapılandırma seçenekleri sunar.
MinIO, TLS/SSL kullanarak güvenli iletişim sağlayabilir. Bunun için sertifika ve özel anahtar dosyalarını belirtmeniz gerekir:
minio server --certs-dir /etc/minio/certs /data
Sertifika ve özel anahtar dosyaları, /etc/minio/certs
dizininde public.crt
ve private.key
olarak bulunmalıdır.
MinIO, bucket ve nesneler için erişim kontrol listeleri (ACL) destekler. Bu, kullanıcıların ve grupların erişim izinlerini yönetmek için kullanılır.
Örnek:
mc policy set download mybucket
MinIO, birden fazla sunucu üzerinde dağıtık modda çalıştırılabilir. Bu, yüksek kullanılabilirlik ve ölçeklenebilirlik sağlar.
Dağıtık modda MinIO’yu başlatmak için birden fazla düğüm (node) belirtmeniz gerekir:
minio server http://node1/data http://node2/data http://node3/data http://node4/data
Her düğüm, aynı veri dizinini paylaşmalıdır.
Dağıtık mod, veri çoğaltma (replication) ve hata toleransı (fault tolerance) sağlar. Bu, bir düğümün arızalanması durumunda veri kaybını önler.
MinIO, performans ve hata izleme için çeşitli loglama ve izleme seçenekleri sunar.
MinIO, varsayılan olarak konsola loglar. Logları bir dosyaya yönlendirmek için:
minio server /data >> /var/log/minio.log 2>&1
MinIO, Prometheus ile entegre edilerek performans metrikleri izlenebilir. Bunun için MinIO’nun Prometheus endpoint’ini kullanın:
http://minio-server:9000/minio/prometheus/metrics
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=password
minio server /data
minio server http://node1/data http://node2/data http://node3/data http://node4/data
minio server --certs-dir /etc/minio/certs /data
mc
Aracının Kurulumumc
aracı, Linux, Windows ve macOS gibi farklı platformlarda kolayca kurulabilir. İşte adım adım kurulum süreci:
mc
binary dosyasını resmi web sitesinden veya terminal üzerinden indirin:
wget https://dl.min.io/client/mc/release/linux-amd64/mc
macOS için:
wget https://dl.min.io/client/mc/release/darwin-amd64/mc
İndirilen binary dosyasını çalıştırılabilir hale getirin:
chmod +x mc
mc
Aracını Sistem Yoluna Eklememc
aracını sistem yoluna ekleyerek herhangi bir dizinden erişilebilir hale getirin:
sudo mv mc /usr/local/bin/
mc
binary dosyasını resmi web sitesinden veya PowerShell üzerinden indirin:
Invoke-WebRequest -Uri "https://dl.min.io/client/mc/release/windows-amd64/mc.exe" -OutFile "mc.exe"
mc
Aracını Sistem Yoluna Eklememc.exe
dosyasını sistem yoluna ekleyerek herhangi bir dizinden erişilebilir hale getirin.
mc
Aracının Temel Kullanımımc
aracı, MinIO sunucusunu yönetmek ve S3 uyumlu depolama çözümleriyle etkileşimde bulunmak için kullanılır. İşte temel komutlar ve kullanım örnekleri:
MinIO sunucusuna bağlanmak için mc alias set
komutunu kullanın:
mc alias set myminio http://localhost:9000 admin password
Bu komut, myminio
adında bir alias oluşturur ve MinIO sunucusuna bağlanır.
Yeni bir bucket oluşturmak için:
mc mb myminio/mybucket
Mevcut bucket’ları listelemek için:
mc ls myminio/
Bir bucket’ı silmek için:
mc rb myminio/mybucket
Yerel bir dosyayı bucket’a yüklemek için:
mc cp myfile.txt myminio/mybucket/
Bucket’tan bir dosyayı indirmek için:
mc cp myminio/mybucket/myfile.txt .
Bucket’taki dosyaları listelemek için:
mc ls myminio/mybucket/
Bucket’tan bir dosyayı silmek için:
mc rm myminio/mybucket/myfile.txt
Bir bucket’ın erişim politikasını ayarlamak için:
mc policy set download myminio/mybucket
Bu komut, mybucket
bucket’ındaki dosyaların herkese açık (public) olarak indirilebilmesini sağlar.
Bir bucket’ın erişim politikasını görüntülemek için:
mc policy get myminio/mybucket
MinIO sunucusu hakkında bilgi almak için:
mc admin info myminio
Yeni bir kullanıcı oluşturmak için:
mc admin user add myminio newuser newpassword
Yeni bir grup oluşturmak ve kullanıcı eklemek için:
mc admin group add myminio newgroup newuser
Yerel bir dizini MinIO bucket’ı ile senkronize etmek için:
mc mirror localdir/ myminio/mybucket/
MinIO’da istemci tarafında şifreleme yapmak için:
mc encrypt set sse-s3 myminio/mybucket
MinIO sunucusunun loglarını görüntülemek için:
mc admin trace myminio
mc
Aracının AvantajlarıAmazon Web Services (AWS), MinIO’yu çalıştırmak için esnek ve ölçeklenebilir bir ortam sunar. İşte adım adım süreç:
t2.medium
veya daha yüksek bir tür seçin. ssh -i your-key.pem ubuntu@ec2-ip-address
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
./minio server /data
9000
ve 9001
portlarını açın.MinIO web arayüzüne erişmek için tarayıcınızda http://ec2-ip-address:9000
adresini kullanın.
Google Cloud Platform (GCP), MinIO’yu çalıştırmak için güçlü bir altyapı sunar. İşte adım adım süreç:
e2-medium
veya daha yüksek bir tür seçin. gcloud compute ssh --zone=your-zone your-instance-name
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
./minio server /data
9000
ve 9001
portlarını açın.MinIO web arayüzüne erişmek için tarayıcınızda http://vm-ip-address:9000
adresini kullanın.
Microsoft Azure, MinIO’yu çalıştırmak için esnek ve güvenilir bir ortam sunar. İşte adım adım süreç:
Standard_B2s
veya daha yüksek bir boyut seçin. ssh -i your-key.pem azureuser@vm-ip-address
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
./minio server /data
9000
ve 9001
portlarını açın.MinIO web arayüzüne erişmek için tarayıcınızda http://vm-ip-address:9000
adresini kullanın.
MinIO’da yeni bir bucket oluşturmak için mc mb
komutunu kullanabilirsiniz. İşte adım adım süreç:
Öncelikle, MinIO sunucusuna bağlanmak için bir alias oluşturun:
mc alias set myminio http://localhost:9000 admin password
Yeni bir bucket oluşturmak için:
mc mb myminio/mybucket
Bu komut, mybucket
adında bir bucket oluşturur.
Mevcut bucket’ları listelemek için mc ls
komutunu kullanın:
mc ls myminio/
Bu komut, MinIO sunucusundaki tüm bucket’ları listeler.
Bir bucket’ı silmek için mc rb
komutunu kullanın:
mc rb myminio/mybucket
Bu komut, mybucket
adlı bucket’ı siler. Bucket’ın boş olması gerekir; aksi takdirde önce içindeki nesneleri silmeniz gerekir.
Bucket politikaları, bucket’lara erişimi kontrol etmek için kullanılır. MinIO, aşağıdaki politikaları destekler:
none
: Erişim yok.download
: Sadece okuma (read-only) erişimi.upload
: Sadece yazma (write-only) erişimi.public
: Hem okuma hem yazma erişimi.Bir bucket’ın erişim politikasını ayarlamak için:
mc policy set download myminio/mybucket
Bu komut, mybucket
bucket’ındaki dosyaların herkese açık (public) olarak indirilebilmesini sağlar.
Bir bucket’ın erişim politikasını görüntülemek için:
mc policy get myminio/mybucket
MinIO, bucket’larda versiyonlama özelliğini destekler. Bu özellik sayesinde, aynı nesnenin farklı versiyonlarını saklayabilirsiniz.
Versiyonlamayı etkinleştirmek için bucket’ı oluştururken veya sonradan yapılandırabilirsiniz:
mc version enable myminio/mybucket
Versiyonlanmış nesneleri listelemek için:
mc ls --versions myminio/mybucket
MinIO, bucket’larda gerçekleşen olaylar (nesne oluşturma, silme, vs.) için bildirimler gönderebilir. Bu bildirimler, Amazon SNS, Kafka, RabbitMQ gibi sistemlere gönderilebilir.
Bildirim yapılandırması için mc event add
komutunu kullanın:
mc event add myminio/mybucket arn:minio:sqs::1:kafka --event put,delete
Bu komut, mybucket
bucket’ındaki nesne oluşturma ve silme olayları için Kafka’ya bildirim gönderir.
MinIO, bucket’larda depolanan nesneleri şifrelemek için sunucu tarafında şifreleme (SSE) özelliğini destekler.
Bucket şifrelemesini etkinleştirmek için:
mc encrypt set sse-s3 myminio/mybucket
Bu komut, mybucket
bucket’ındaki nesneleri SSE-S3 ile şifreler.
MinIO, bucket’lardaki nesnelerin yaşam döngüsünü yönetmek için kurallar tanımlamanıza olanak tanır. Bu kurallar, nesnelerin otomatik olarak arşivlenmesini veya silinmesini sağlar.
Bir yaşam döngüsü kuralı oluşturmak için JSON formatında bir kural dosyası hazırlayın:
{
"Rules": [
{
"ID": "ExpireOldFiles",
"Status": "Enabled",
"Filter": {
"Prefix": "old/"
},
"Expiration": {
"Days": 30
}
}
]
}
Bu kural, old/
öneki ile başlayan nesneleri 30 gün sonra siler.
Kuralı uygulamak için:
mc ilm import myminio/mybucket lifecycle.json
MinIO, bucket’lar arasında çoğaltma (replication) özelliği sunar. Bu özellik, verilerin birden fazla konumda saklanmasını sağlar.
Çoğaltma yapılandırması için:
mc replicate add myminio/mybucket --remote-bucket myminio/backupbucket
Bu komut, mybucket
bucket’ındaki nesneleri backupbucket
bucket’ına çoğaltır.
MinIO’ya nesne yüklemek için mc cp
komutunu kullanabilirsiniz. İşte adım adım süreç:
Yerel bir dosyayı bucket’a yüklemek için:
mc cp myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını mybucket
bucket’ına yükler.
Yerel bir dizindeki tüm dosyaları bucket’a yüklemek için:
mc cp mylocaldir/ myminio/mybucket/
Bu komut, mylocaldir
dizinindeki tüm dosyaları mybucket
bucket’ına yükler.
Bucket’tan nesne indirmek için mc cp
komutunu kullanabilirsiniz. İşte adım adım süreç:
Bucket’tan bir dosyayı indirmek için:
mc cp myminio/mybucket/myfile.txt .
Bu komut, mybucket
bucket’ındaki myfile.txt
dosyasını yerel dizine indirir.
Bucket’tan bir dizindeki tüm dosyaları indirmek için:
mc cp myminio/mybucket/mydir/ .
Bu komut, mybucket
bucket’ındaki mydir
dizinindeki tüm dosyaları yerel dizine indirir.
Bucket’taki nesneleri listelemek için mc ls
komutunu kullanabilirsiniz. İşte adım adım süreç:
Bir bucket’taki tüm nesneleri listelemek için:
mc ls myminio/mybucket/
Bu komut, mybucket
bucket’ındaki tüm nesneleri listeler.
Bir bucket’taki belirli bir dizindeki nesneleri listelemek için:
mc ls myminio/mybucket/mydir/
Bu komut, mybucket
bucket’ındaki mydir
dizinindeki nesneleri listeler.
Bucket’tan nesne silmek için mc rm
komutunu kullanabilirsiniz. İşte adım adım süreç:
Bucket’tan bir nesneyi silmek için:
mc rm myminio/mybucket/myfile.txt
Bu komut, mybucket
bucket’ındaki myfile.txt
dosyasını siler.
Bucket’tan birden fazla nesneyi silmek için:
mc rm myminio/mybucket/mydir/
Bu komut, mybucket
bucket’ındaki mydir
dizinindeki tüm nesneleri siler.
Nesneler, dosya boyutu, oluşturulma tarihi, MIME türü gibi metaverilerle birlikte depolanır. Bu metaverileri görüntülemek ve yönetmek için mc stat
komutunu kullanabilirsiniz.
Bir nesnenin metaverilerini görüntülemek için:
mc stat myminio/mybucket/myfile.txt
Bu komut, myfile.txt
dosyasının metaverilerini görüntüler.
MinIO, nesnelerin farklı versiyonlarını saklamak için versiyonlama özelliğini destekler. Bu özellik sayesinde, aynı nesnenin farklı versiyonlarını saklayabilirsiniz.
Versiyonlanmış nesneleri listelemek için:
mc ls --versions myminio/mybucket/
Bu komut, mybucket
bucket’ındaki tüm versiyonlanmış nesneleri listeler.
Belirli bir versiyonu indirmek için:
mc cp myminio/mybucket/myfile.txt --version-id VERSION_ID .
Bu komut, belirtilen versiyon ID’sine sahip nesneyi indirir.
MinIO, nesneleri şifrelemek için sunucu tarafında şifreleme (SSE) özelliğini destekler. Bu özellik, nesnelerin güvenli bir şekilde depolanmasını sağlar.
Nesne şifrelemesini etkinleştirmek için:
mc encrypt set sse-s3 myminio/mybucket
Bu komut, mybucket
bucket’ındaki nesneleri SSE-S3 ile şifreler.
MinIO, nesneler üzerinde gerçekleşen olaylar (oluşturma, silme, vs.) için bildirimler gönderebilir. Bu bildirimler, Amazon SNS, Kafka, RabbitMQ gibi sistemlere gönderilebilir.
Bildirim yapılandırması için mc event add
komutunu kullanın:
mc event add myminio/mybucket arn:minio:sqs::1:kafka --event put,delete
Bu komut, mybucket
bucket’ındaki nesne oluşturma ve silme olayları için Kafka’ya bildirim gönderir.
MinIO, nesnelerin yaşam döngüsünü yönetmek için kurallar tanımlamanıza olanak tanır. Bu kurallar, nesnelerin otomatik olarak arşivlenmesini veya silinmesini sağlar.
Bir yaşam döngüsü kuralı oluşturmak için JSON formatında bir kural dosyası hazırlayın:
{
"Rules": [
{
"ID": "ExpireOldFiles",
"Status": "Enabled",
"Filter": {
"Prefix": "old/"
},
"Expiration": {
"Days": 30
}
}
]
}
Bu kural, old/
öneki ile başlayan nesneleri 30 gün sonra siler.
Kuralı uygulamak için:
mc ilm import myminio/mybucket lifecycle.json
Bu anahtarlar, MinIO sunucusuna erişim sağlamak ve API isteklerini imzalamak için kullanılır.
MinIO’da Access Key ve Secret Key oluşturmak için mc admin user
komutlarını kullanabilirsiniz. İşte adım adım süreç:
Öncelikle, MinIO sunucusuna bağlanmak için bir alias oluşturun:
mc alias set myminio http://localhost:9000 admin password
Yeni bir kullanıcı oluşturmak ve Access Key ile Secret Key atamak için:
mc admin user add myminio newuser newpassword
Bu komut, newuser
adında bir kullanıcı oluşturur ve newpassword
ile bir Secret Key atar.
Kullanıcının Access Key veya Secret Key’ini güncellemek için mc admin user update
komutunu kullanabilirsiniz.
Kullanıcının Secret Key’ini güncellemek için:
mc admin user update myminio newuser newpassword
Bu komut, newuser
kullanıcısının Secret Key’ini newpassword
olarak günceller.
Kullanıcıyı ve ilişkili Access Key ile Secret Key’i silmek için mc admin user remove
komutunu kullanabilirsiniz.
Kullanıcıyı silmek için:
mc admin user remove myminio newuser
Bu komut, newuser
kullanıcısını ve ilişkili Access Key ile Secret Key’i siler.
Mevcut kullanıcıları ve ilişkili Access Key ile Secret Key’leri listelemek için mc admin user list
komutunu kullanabilirsiniz.
Kullanıcıları listelemek için:
mc admin user list myminio
Bu komut, MinIO sunucusundaki tüm kullanıcıları ve ilişkili Access Key’leri listeler.
Access Key ve Secret Key, MinIO sunucusuna erişim sağlamak ve API isteklerini imzalamak için kullanılır. İşte adım adım süreç:
MinIO sunucusuna bağlanmak için Access Key ve Secret Key kullanın:
mc alias set myminio http://localhost:9000 ACCESS_KEY SECRET_KEY
Bu komut, myminio
adında bir alias oluşturur ve belirtilen Access Key ile Secret Key’i kullanarak MinIO sunucusuna bağlanır.
MinIO sunucusuna bağlandıktan sonra, bucket ve nesne işlemleri gerçekleştirebilirsiniz. Örneğin, bir bucket oluşturmak için:
mc mb myminio/mybucket
Access Key ve Secret Key, MinIO sunucusuna erişim sağlamak için kullanıldığından, güvenliğinin sağlanması kritik öneme sahiptir. İşte güvenlik için dikkat edilmesi gerekenler:
IAM, MinIO’da kullanıcıların ve grupların erişim izinlerini yönetmek için kullanılır. IAM, kullanıcıların hangi bucket’lara ve nesnelere erişebileceğini belirler.
Yeni bir kullanıcı oluşturmak için mc admin user add
komutunu kullanın:
mc admin user add myminio newuser newpassword
Bu komut, newuser
adında bir kullanıcı oluşturur ve newpassword
ile bir Secret Key atar.
Kullanıcıyı silmek için mc admin user remove
komutunu kullanın:
mc admin user remove myminio newuser
Bu komut, newuser
kullanıcısını ve ilişkili Access Key ile Secret Key’i siler.
Mevcut kullanıcıları listelemek için mc admin user list
komutunu kullanın:
mc admin user list myminio
Bu komut, MinIO sunucusundaki tüm kullanıcıları listeler.
Yeni bir grup oluşturmak için mc admin group add
komutunu kullanın:
mc admin group add myminio newgroup newuser
Bu komut, newgroup
adında bir grup oluşturur ve newuser
kullanıcısını bu gruba ekler.
Grubu silmek için mc admin group remove
komutunu kullanın:
mc admin group remove myminio newgroup
Bu komut, newgroup
grubunu siler.
Mevcut grupları listelemek için mc admin group list
komutunu kullanın:
mc admin group list myminio
Bu komut, MinIO sunucusundaki tüm grupları listeler.
Yeni bir politika oluşturmak için JSON formatında bir politika dosyası hazırlayın:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::mybucket/*"
]
}
]
}
Bu politika, mybucket
bucket’ındaki nesneleri okuma (GetObject) izni verir.
Politikayı uygulamak için:
mc admin policy add myminio mypolicy policy.json
Bu komut, mypolicy
adında bir politika oluşturur ve policy.json
dosyasındaki kuralları uygular.
Politikayı bir kullanıcıya veya gruba atamak için:
mc admin policy set myminio mypolicy user=newuser
Bu komut, mypolicy
politikasını newuser
kullanıcısına atar.
Bucket Policies, bucket’lara ve nesnelere erişimi kontrol etmek için kullanılır. Bucket Policies, JSON formatında tanımlanır ve bucket’lar üzerinde uygulanır.
Bir bucket policy oluşturmak için JSON formatında bir politika dosyası hazırlayın:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::mybucket/*"
]
}
]
}
Bu politika, mybucket
bucket’ındaki nesneleri herkese açık (public) olarak okuma (GetObject) izni verir.
Bucket policy’yi uygulamak için mc policy set
komutunu kullanın:
mc policy set policy.json myminio/mybucket
Bu komut, policy.json
dosyasındaki kuralları mybucket
bucket’ına uygular.
Bucket policy’yi görüntülemek için mc policy get
komutunu kullanın:
mc policy get myminio/mybucket
Bu komut, mybucket
bucket’ının mevcut politikasını görüntüler.
MinIO’ya veri yüklemek, yerel dosyaların veya dizinlerin bucket’lara aktarılması işlemidir. Bu işlem, mc cp
komutu ile gerçekleştirilir.
Yerel bir dosyayı bucket’a yüklemek için:
mc cp myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını mybucket
bucket’ına yükler.
Yerel bir dizindeki tüm dosyaları bucket’a yüklemek için:
mc cp mylocaldir/ myminio/mybucket/
Bu komut, mylocaldir
dizinindeki tüm dosyaları mybucket
bucket’ına yükler.
Bir dizin ve alt dizinlerindeki tüm dosyaları bucket’a yüklemek için --recursive
parametresini kullanın:
mc cp --recursive mylocaldir/ myminio/mybucket/
Bu komut, mylocaldir
dizini ve alt dizinlerindeki tüm dosyaları mybucket
bucket’ına yükler.
Büyük dosyaları parçalara ayırarak yüklemek için --part-size
parametresini kullanın:
mc cp --part-size 64M largefile.zip myminio/mybucket/
Bu komut, largefile.zip
dosyasını 64 MB’lık parçalar halinde mybucket
bucket’ına yükler.
MinIO’dan veri indirmek, bucket’lardaki nesnelerin (dosyaların) yerel bir dizine aktarılması işlemidir. Bu işlem, mc cp
komutu ile gerçekleştirilir.
Bucket’tan bir dosyayı indirmek için:
mc cp myminio/mybucket/myfile.txt .
Bu komut, mybucket
bucket’ındaki myfile.txt
dosyasını yerel dizine indirir.
Bucket’tan bir dizindeki tüm dosyaları indirmek için:
mc cp myminio/mybucket/mydir/ .
Bu komut, mybucket
bucket’ındaki mydir
dizinindeki tüm dosyaları yerel dizine indirir.
Bir dizin ve alt dizinlerindeki tüm dosyaları bucket’tan indirmek için --recursive
parametresini kullanın:
mc cp --recursive myminio/mybucket/mydir/ .
Bu komut, mybucket
bucket’ındaki mydir
dizini ve alt dizinlerindeki tüm dosyaları yerel dizine indirir.
Büyük dosyaları parçalara ayırarak indirmek için --part-size
parametresini kullanın:
mc cp --part-size 64M myminio/mybucket/largefile.zip .
Bu komut, largefile.zip
dosyasını 64 MB’lık parçalar halinde yerel dizine indirir.
MinIO, veri yükleme ve indirme işlemlerini paralel olarak gerçekleştirerek performansı artırır. Paralel işlemler için --parallel
parametresini kullanın:
mc cp --parallel 4 mylocaldir/ myminio/mybucket/
Bu komut, mylocaldir
dizinindeki dosyaları 4 paralel işlemle mybucket
bucket’ına yükler.
Veri yükleme ve indirme işlemlerinin hızını sınırlamak için --limit-rate
parametresini kullanın:
mc cp --limit-rate 10M myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını en fazla 10 MB/s hızında mybucket
bucket’ına yükler.
Veri yükleme sırasında dosyalara özel metaveri eklemek için --attr
parametresini kullanın:
mc cp --attr key1=value1,key2=value2 myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını mybucket
bucket’ına yüklerken key1=value1
ve key2=value2
metaverilerini ekler.
MinIO, veri yükleme ve indirme işlemlerinde sunucu tarafında şifreleme (SSE) özelliğini destekler. Bu özellik, verilerin güvenli bir şekilde depolanmasını sağlar.
Veri yükleme sırasında şifreleme etkinleştirmek için:
mc cp --encrypt sse-s3 myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını SSE-S3 ile şifreleyerek mybucket
bucket’ına yükler.
Bucket’lara erişimi kontrol etmek için IAM ve Bucket Policies kullanılır. Bu, yetkisiz erişimi önler ve veri güvenliğini sağlar.
Paralel işlemler, veri yükleme ve indirme hızını artırır. --parallel
parametresi ile paralel işlem sayısını belirleyebilirsiniz.
Büyük dosyaları parçalara ayırarak yükleme ve indirme işlemlerini optimize edebilirsiniz. --part-size
parametresi ile part boyutunu belirleyebilirsiniz.
Ağ ayarlarını optimize ederek veri yükleme ve indirme hızını artırabilirsiniz. Özellikle yüksek gecikmeli ağlarda TCP ayarlarını optimize etmek faydalı olabilir.
Sunucu tarafında şifreleme (SSE), verilerin MinIO sunucusu üzerinde şifrelenmesini sağlar. Bu şifreleme yöntemi, verilerin depolama sırasında güvenliğini artırır.
SSE-S3, MinIO tarafından yönetilen anahtarlarla şifreleme sağlar. Bu yöntem, basit ve etkili bir şifreleme çözümüdür.
Veri yükleme sırasında SSE-S3 şifrelemesini etkinleştirmek için --encrypt
parametresini kullanın:
mc cp --encrypt sse-s3 myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını SSE-S3 ile şifreleyerek mybucket
bucket’ına yükler.
Bir bucket’taki tüm nesneleri SSE-S3 ile şifrelemek için:
mc encrypt set sse-s3 myminio/mybucket
Bu komut, mybucket
bucket’ındaki tüm nesneleri SSE-S3 ile şifreler.
SSE-C, kullanıcı tarafından sağlanan anahtarlarla şifreleme sağlar. Bu yöntem, kullanıcının anahtarlarını yönetmesine olanak tanır.
Veri yükleme sırasında SSE-C şifrelemesini etkinleştirmek için --encrypt
parametresini kullanın:
mc cp --encrypt sse-c --encrypt-key "my-secret-key" myfile.txt myminio/mybucket/
Bu komut, myfile.txt
dosyasını my-secret-key
anahtarı ile SSE-C ile şifreleyerek mybucket
bucket’ına yükler.
Bir bucket’taki tüm nesneleri SSE-C ile şifrelemek için:
mc encrypt set sse-c myminio/mybucket --encrypt-key "my-secret-key"
Bu komut, mybucket
bucket’ındaki tüm nesneleri my-secret-key
anahtarı ile SSE-C ile şifreler.
İstemci tarafında şifreleme, verilerin MinIO sunucusuna yüklenmeden önce istemci tarafında şifrelenmesini sağlar. Bu yöntem, verilerin şifrelenmiş halde sunucuya gönderilmesini ve sadece istemci tarafında çözülebilmesini sağlar.
Simetrik şifreleme, aynı anahtarın hem şifreleme hem de şifre çözme işlemleri için kullanılmasını sağlar.
Asimetrik şifreleme, farklı anahtarların şifreleme ve şifre çözme işlemleri için kullanılmasını sağlar.
İstemci tarafında şifreleme, genellikle uygulama seviyesinde gerçekleştirilir. Örneğin, Python ile istemci tarafında şifreleme yapmak için cryptography
kütüphanesi kullanılabilir.
from cryptography.fernet import Fernet
# Anahtar oluşturma
key = Fernet.generate_key()
cipher_suite = Fernet(key)
# Veriyi şifreleme
data = b"My secret data"
encrypted_data = cipher_suite.encrypt(data)
# Şifrelenmiş veriyi MinIO'ya yükleme
from minio import Minio
client = Minio(
"localhost:9000",
access_key="admin",
secret_key="password",
secure=False
)
client.put_object(
"mybucket",
"myfile.txt",
encrypted_data,
len(encrypted_data)
)
# Şifrelenmiş veriyi indirme ve çözme
encrypted_data = client.get_object("mybucket", "myfile.txt").read()
decrypted_data = cipher_suite.decrypt(encrypted_data)
print(decrypted_data.decode())
Bu örnek, Python ile istemci tarafında şifreleme yaparak verileri MinIO’ya yükler ve indirir.
Veri çoğaltma, bir bucket’taki nesnelerin otomatik olarak bir veya daha fazla hedef bucket’a kopyalanması işlemidir. Bu işlem, verilerin farklı konumlarda saklanmasını ve yüksek kullanılabilirlik sağlanmasını mümkün kılar.
MinIO, iki tür veri çoğaltma yöntemi sunar:
Bucket çoğaltma, bir bucket’taki nesnelerin otomatik olarak bir veya daha fazla hedef bucket’a kopyalanmasını sağlar. Bu yöntem, farklı MinIO sunucuları veya farklı bulut sağlayıcıları arasında veri çoğaltmayı destekler.
Site çoğaltma, birden fazla MinIO kümesi (cluster) arasında veri çoğaltmayı sağlar. Bu yöntem, farklı coğrafi konumlardaki MinIO kümeleri arasında veri senkronizasyonunu destekler.
Bucket çoğaltma, bir bucket’taki nesnelerin otomatik olarak bir veya daha fazla hedef bucket’a kopyalanmasını sağlar. İşte adım adım süreç:
Çoğaltma yapılandırması için JSON formatında bir çoğaltma kuralı dosyası hazırlayın:
{
"Role": "arn:aws:iam::123456789012:role/replication-role",
"Rules": [
{
"ID": "ReplicationRule1",
"Status": "Enabled",
"Priority": 1,
"Filter": {
"Prefix": "documents/"
},
"Destination": {
"Bucket": "arn:aws:s3:::backup-bucket"
},
"DeleteMarkerReplication": {
"Status": "Disabled"
}
}
]
}
Bu kural, documents/
öneki ile başlayan nesneleri backup-bucket
bucket’ına çoğaltır.
Çoğaltma kuralını uygulamak için mc replicate add
komutunu kullanın:
mc replicate add myminio/mybucket --remote-bucket myminio/backupbucket --replication-rule replication-rule.json
Bu komut, mybucket
bucket’ındaki nesneleri backupbucket
bucket’ına çoğaltır.
Çoğaltma durumunu izlemek için mc replicate status
komutunu kullanın:
mc replicate status myminio/mybucket
Bu komut, mybucket
bucket’ının çoğaltma durumunu görüntüler.
Site çoğaltma, birden fazla MinIO kümesi (cluster) arasında veri çoğaltmayı sağlar. İşte adım adım süreç:
Site çoğaltma için birden fazla MinIO kümesi yapılandırın. Örneğin, iki MinIO kümesi:
http://minio1:9000
http://minio2:9000
Site çoğaltma yapılandırması için JSON formatında bir çoğaltma kuralı dosyası hazırlayın:
{
"Role": "arn:aws:iam::123456789012:role/replication-role",
"Rules": [
{
"ID": "SiteReplicationRule1",
"Status": "Enabled",
"Priority": 1,
"Filter": {
"Prefix": "documents/"
},
"Destination": {
"Bucket": "arn:aws:s3:::backup-bucket"
},
"DeleteMarkerReplication": {
"Status": "Disabled"
}
}
]
}
Bu kural, documents/
öneki ile başlayan nesneleri backup-bucket
bucket’ına çoğaltır.
Site çoğaltma kuralını uygulamak için mc replicate add
komutunu kullanın:
mc replicate add myminio/mybucket --remote-bucket myminio/backupbucket --replication-rule site-replication-rule.json
Bu komut, mybucket
bucket’ındaki nesneleri backupbucket
bucket’ına çoğaltır.
Site çoğaltma durumunu izlemek için mc replicate status
komutunu kullanın:
mc replicate status myminio/mybucket
Bu komut, mybucket
bucket’ının site çoğaltma durumunu görüntüler.
Veri yaşam döngüsü yönetimi, verilerin depolama sürecindeki farklı aşamalarını otomatik olarak yönetmek için kullanılan bir dizi kuraldır. Bu kurallar, verilerin belirli bir süre sonra arşivlenmesini, silinmesini veya başka bir depolama sınıfına taşınmasını sağlar.
Veri yaşam döngüsü yönetimi, JSON formatında tanımlanan kurallarla yapılır. Bu kurallar, belirli koşullara göre verilerin nasıl yönetileceğini belirler.
Aşağıda, documents/
öneki ile başlayan nesnelerin 30 gün sonra silinmesini sağlayan bir yaşam döngüsü kuralı örneği bulunmaktadır:
{
"Rules": [
{
"ID": "ExpireOldFiles",
"Status": "Enabled",
"Filter": {
"Prefix": "documents/"
},
"Expiration": {
"Days": 30
}
}
]
}
Yaşam döngüsü kurallarını uygulamak için mc ilm import
komutunu kullanabilirsiniz. İşte adım adım süreç:
Yaşam döngüsü kurallarını içeren bir JSON dosyası oluşturun. Örneğin, lifecycle.json
:
{
"Rules": [
{
"ID": "ExpireOldFiles",
"Status": "Enabled",
"Filter": {
"Prefix": "documents/"
},
"Expiration": {
"Days": 30
}
}
]
}
Yaşam döngüsü kuralını uygulamak için mc ilm import
komutunu kullanın:
mc ilm import myminio/mybucket lifecycle.json
Bu komut, lifecycle.json
dosyasındaki kuralları mybucket
bucket’ına uygular.
Bucket’taki yaşam döngüsü kurallarını görüntülemek için mc ilm list
komutunu kullanın:
mc ilm list myminio/mybucket
Bu komut, mybucket
bucket’ındaki yaşam döngüsü kurallarını listeler.
Bir yaşam döngüsü kuralını silmek için mc ilm remove
komutunu kullanın:
mc ilm remove myminio/mybucket --id ExpireOldFiles
Bu komut, ExpireOldFiles
ID’sine sahip yaşam döngüsü kuralını siler.
Geçiş kuralları, nesnelerin belirli bir süre sonra başka bir depolama sınıfına taşınmasını sağlar. Örneğin, nesneleri 60 gün sonra daha düşük maliyetli bir depolama sınıfına taşımak için:
{
"Rules": [
{
"ID": "TransitionToColdStorage",
"Status": "Enabled",
"Filter": {
"Prefix": "documents/"
},
"Transition": {
"Days": 60,
"StorageClass": "GLACIER"
}
}
]
}
Yaşam döngüsü kurallarını belirli etiketlere sahip nesnelere uygulamak için Filter
bölümünde etiketleri belirtebilirsiniz:
{
"Rules": [
{
"ID": "ExpireTaggedFiles",
"Status": "Enabled",
"Filter": {
"Tag": {
"Key": "environment",
"Value": "test"
}
},
"Expiration": {
"Days": 30
}
}
]
}
Bu kural, environment=test
etiketine sahip nesneleri 30 gün sonra siler.
Amazon S3 (Simple Storage Service), AWS tarafından sunulan bir nesne depolama hizmetidir. S3 API’si, nesne depolama işlemlerini gerçekleştirmek için kullanılan bir dizi RESTful API’dir. MinIO, bu API’lerle tam uyumludur, yani S3 API’sini kullanan uygulamalar ve araçlar MinIO ile de çalışabilir.
MinIO, S3 API’sinin temel özelliklerini destekler. İşte bu özelliklerden bazıları:
PUT /{bucket}
DELETE /{bucket}
GET /
PUT /{bucket}/{object}
GET /{bucket}/{object}
DELETE /{bucket}/{object}
GET /{bucket}?list-type=2
PUT /{bucket}?policy
PUT /{bucket}?iam
GET /{bucket}/{object}?versionId={versionId}
PUT /{bucket}/{object}?x-amz-server-side-encryption
PUT /{bucket}?replication
MinIO, S3 API’sini kullanan uygulamalar ve araçlarla sorunsuz çalışır. İşte bu uyumluluğu kullanarak MinIO ile çalışmanın temel adımları:
MinIO sunucusuna bağlanmak için S3 uyumlu bir istemci kullanın. Örneğin, AWS CLI veya MinIO İstemci Aracı (mc
):
mc alias set myminio http://localhost:9000 admin password
S3 API’sini kullanarak yeni bir bucket oluşturun:
aws --endpoint-url http://localhost:9000 s3 mb s3://mybucket
S3 API’sini kullanarak bir nesne yükleyin:
aws --endpoint-url http://localhost:9000 s3 cp myfile.txt s3://mybucket/
S3 API’sini kullanarak bir nesne indirin:
aws --endpoint-url http://localhost:9000 s3 cp s3://mybucket/myfile.txt .
S3 API’sini kullanarak bucket’taki nesneleri listeleyin:
aws --endpoint-url http://localhost:9000 s3 ls s3://mybucket/
MinIO, S3 SDK’ları ile tam uyumludur. Bu, S3 SDK’larını kullanan uygulamaların MinIO ile çalışmasını sağlar. İşte bazı popüler S3 SDK’ları ve MinIO ile entegrasyon örnekleri:
import boto3
from botocore.client import Config
# MinIO sunucusuna bağlanma
s3 = boto3.client('s3',
endpoint_url='http://localhost:9000',
aws_access_key_id='admin',
aws_secret_access_key='password',
config=Config(signature_version='s3v4'),
region_name='us-east-1')
# Bucket oluşturma
s3.create_bucket(Bucket='mybucket')
# Nesne yükleme
s3.upload_file('myfile.txt', 'mybucket', 'myfile.txt')
# Nesne indirme
s3.download_file('mybucket', 'myfile.txt', 'myfile_downloaded.txt')
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
public class MinIOExample {
public static void main(String[] args) {
// MinIO sunucusuna bağlanma
S3Client s3 = S3Client.builder()
.endpointOverride(URI.create("http://localhost:9000"))
.credentialsProvider(StaticCredentialsProvider.create(
AwsBasicCredentials.create("admin", "password")))
.region(Region.US_EAST_1)
.build();
// Bucket oluşturma
s3.createBucket(CreateBucketRequest.builder().bucket("mybucket").build());
// Nesne yükleme
s3.putObject(PutObjectRequest.builder().bucket("mybucket").key("myfile.txt").build(),
Paths.get("myfile.txt"));
// Nesne indirme
s3.getObject(GetObjectRequest.builder().bucket("mybucket").key("myfile.txt").build(),
Paths.get("myfile_downloaded.txt"));
}
}
MinIO, birçok popüler programlama dili için S3 SDK’ları ile tam uyumludur. İşte bazı popüler S3 SDK’ları ve MinIO ile entegrasyon örnekleri:
Boto3, AWS tarafından sağlanan Python SDK’sıdır. MinIO ile kullanımı oldukça basittir.
import boto3
from botocore.client import Config
# MinIO sunucusuna bağlanma
s3 = boto3.client('s3',
endpoint_url='http://localhost:9000',
aws_access_key_id='admin',
aws_secret_access_key='password',
config=Config(signature_version='s3v4'),
region_name='us-east-1')
# Bucket oluşturma
s3.create_bucket(Bucket='mybucket')
# Nesne yükleme
s3.upload_file('myfile.txt', 'mybucket', 'myfile.txt')
# Nesne indirme
s3.download_file('mybucket', 'myfile.txt', 'myfile_downloaded.txt')
# Nesne listeleme
response = s3.list_objects_v2(Bucket='mybucket')
for obj in response.get('Contents', []):
print(obj['Key'])
AWS SDK for Java, Java uygulamalarından S3 API’sini kullanmak için geliştirilmiştir.
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;
import java.net.URI;
import java.nio.file.Paths;
public class MinIOExample {
public static void main(String[] args) {
// MinIO sunucusuna bağlanma
S3Client s3 = S3Client.builder()
.endpointOverride(URI.create("http://localhost:9000"))
.credentialsProvider(StaticCredentialsProvider.create(
AwsBasicCredentials.create("admin", "password")))
.region(Region.US_EAST_1)
.build();
// Bucket oluşturma
s3.createBucket(CreateBucketRequest.builder().bucket("mybucket").build());
// Nesne yükleme
s3.putObject(PutObjectRequest.builder().bucket("mybucket").key("myfile.txt").build(),
Paths.get("myfile.txt"));
// Nesne indirme
s3.getObject(GetObjectRequest.builder().bucket("mybucket").key("myfile.txt").build(),
Paths.get("myfile_downloaded.txt"));
// Nesne listeleme
ListObjectsV2Response listObjectsResponse = s3.listObjectsV2(ListObjectsV2Request.builder().bucket("mybucket").build());
listObjectsResponse.contents().forEach(obj -> System.out.println(obj.key()));
}
}
AWS SDK for JavaScript, Node.js ve tarayıcı tabanlı uygulamalarda S3 API’sini kullanmak için geliştirilmiştir.
const AWS = require('aws-sdk');
// MinIO sunucusuna bağlanma
const s3 = new AWS.S3({
endpoint: 'http://localhost:9000',
accessKeyId: 'admin',
secretAccessKey: 'password',
s3ForcePathStyle: true,
signatureVersion: 'v4'
});
// Bucket oluşturma
s3.createBucket({ Bucket: 'mybucket' }, function(err, data) {
if (err) console.log(err, err.stack);
else console.log('Bucket created', data);
});
// Nesne yükleme
const fs = require('fs');
const fileStream = fs.createReadStream('myfile.txt');
s3.upload({ Bucket: 'mybucket', Key: 'myfile.txt', Body: fileStream }, function(err, data) {
if (err) console.log(err, err.stack);
else console.log('File uploaded', data);
});
// Nesne indirme
s3.getObject({ Bucket: 'mybucket', Key: 'myfile.txt' }, function(err, data) {
if (err) console.log(err, err.stack);
else fs.writeFileSync('myfile_downloaded.txt', data.Body);
});
// Nesne listeleme
s3.listObjectsV2({ Bucket: 'mybucket' }, function(err, data) {
if (err) console.log(err, err.stack);
else data.Contents.forEach(obj => console.log(obj.Key));
});
AWS SDK for Go, Go dilinde S3 API’sini kullanmak için geliştirilmiştir.
package main
import (
"fmt"
"log"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
)
func main() {
// MinIO sunucusuna bağlanma
sess, err := session.NewSession(&aws.Config{
Endpoint: aws.String("http://localhost:9000"),
Region: aws.String("us-east-1"),
Credentials: credentials.NewStaticCredentials("admin", "password", ""),
S3ForcePathStyle: aws.Bool(true),
})
if err != nil {
log.Fatal(err)
}
s3Client := s3.New(sess)
// Bucket oluşturma
_, err = s3Client.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String("mybucket"),
})
if err != nil {
log.Fatal(err)
}
fmt.Println("Bucket created")
// Nesne yükleme
file, err := os.Open("myfile.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
uploader := s3manager.NewUploader(sess)
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String("mybucket"),
Key: aws.String("myfile.txt"),
Body: file,
})
if err != nil {
log.Fatal(err)
}
fmt.Println("File uploaded")
// Nesne indirme
downloader := s3manager.NewDownloader(sess)
file, err = os.Create("myfile_downloaded.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
_, err = downloader.Download(file, &s3.GetObjectInput{
Bucket: aws.String("mybucket"),
Key: aws.String("myfile.txt"),
})
if err != nil {
log.Fatal(err)
}
fmt.Println("File downloaded")
// Nesne listeleme
resp, err := s3Client.ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: aws.String("mybucket"),
})
if err != nil {
log.Fatal(err)
}
for _, obj := range resp.Contents {
fmt.Println(*obj.Key)
}
}
MinIO, birçok popüler S3 uyumlu aracı destekler. İşte bu araçlardan bazıları ve MinIO ile entegrasyon örnekleri:
AWS CLI, AWS hizmetlerini komut satırından yönetmek için kullanılan bir araçtır. MinIO ile kullanımı oldukça basittir.
# MinIO sunucusuna bağlanma
aws configure set aws_access_key_id admin
aws configure set aws_secret_access_key password
aws configure set default.region us-east-1
aws configure set default.s3.endpoint_url http://localhost:9000
# Bucket oluşturma
aws s3 mb s3://mybucket
# Nesne yükleme
aws s3 cp myfile.txt s3://mybucket/
# Nesne indirme
aws s3 cp s3://mybucket/myfile.txt .
# Nesne listeleme
aws s3 ls s3://mybucket/
s3cmd, S3 uyumlu depolama hizmetleri için komut satırı aracıdır.
# MinIO sunucusuna bağlanma
s3cmd --configure
# Bucket oluşturma
s3cmd mb s3://mybucket
# Nesne yükleme
s3cmd put myfile.txt s3://mybucket/
# Nesne indirme
s3cmd get s3://mybucket/myfile.txt .
# Nesne listeleme
s3cmd ls s3://mybucket/
rclone, bulut depolama hizmetleri arasında dosya senkronizasyonu ve yönetimi için kullanılan bir araçtır.
# MinIO sunucusuna bağlanma
rclone config
# Bucket oluşturma
rclone mkdir minio:mybucket
# Nesne yükleme
rclone copy myfile.txt minio:mybucket/
# Nesne indirme
rclone copy minio:mybucket/myfile.txt .
# Nesne listeleme
rclone ls minio:mybucket/
Cyberduck, bulut depolama hizmetlerine erişim sağlayan bir GUI tabanlı araçtır.
http://localhost:9000
).Bağlantı kurulduktan sonra, Cyberduck üzerinden MinIO’da bucket oluşturabilir, nesne yükleyebilir, indirebilir ve listeleyebilirsiniz.
mc
)MinIO İstemci Aracı (mc
), MinIO sunucusunu yönetmek için özel olarak geliştirilmiş bir komut satırı aracıdır.
# MinIO sunucusuna bağlanma
mc alias set myminio http://localhost:9000 admin password
# Bucket oluşturma
mc mb myminio/mybucket
# Nesne yükleme
mc cp myfile.txt myminio/mybucket/
# Nesne indirme
mc cp myminio/mybucket/myfile.txt .
# Nesne listeleme
mc ls myminio/mybucket/
Kimlik doğrulama, kullanıcıların kimliklerini doğrulama işlemidir. MinIO, kullanıcıların kimliklerini doğrulamak için Access Key ve Secret Key kullanır.
Yetkilendirme, kullanıcıların hangi kaynaklara erişebileceğini ve hangi işlemleri gerçekleştirebileceğini belirleme işlemidir. MinIO, yetkilendirme için IAM (Identity and Access Management) ve Bucket Policies gibi mekanizmalar sunar.
IAM, kullanıcıların ve grupların erişim izinlerini yönetmek için kullanılır. IAM, kullanıcıların hangi bucket’lara ve nesnelere erişebileceğini belirler.
mc admin user add
komutunu kullanın: mc admin user add myminio newuser newpassword
mc admin user remove
komutunu kullanın: mc admin user remove myminio newuser
mc admin user list
komutunu kullanın: mc admin user list myminio
mc admin group add
komutunu kullanın: mc admin group add myminio newgroup newuser
mc admin group remove
komutunu kullanın: mc admin group remove myminio newgroup
mc admin group list
komutunu kullanın: mc admin group list myminio
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::mybucket/*"
]
}
]
}
Bu politika, mybucket
bucket’ındaki nesneleri okuma (GetObject) izni verir.
mc admin policy set myminio mypolicy user=newuser
Bucket Policies, bucket’lara ve nesnelere erişimi kontrol etmek için kullanılır. Bucket Policies, JSON formatında tanımlanır ve bucket’lar üzerinde uygulanır.
Bir bucket policy oluşturmak için JSON formatında bir politika dosyası hazırlayın:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::mybucket/*"
]
}
]
}
Bu politika, mybucket
bucket’ındaki nesneleri herkese açık (public) olarak okuma (GetObject) izni verir.
Bucket policy’yi uygulamak için mc policy set
komutunu kullanın:
mc policy set policy.json myminio/mybucket
Bucket policy’yi görüntülemek için mc policy get
komutunu kullanın:
mc policy get myminio/mybucket
TLS (Transport Layer Security) ve SSL (Secure Sockets Layer), ağ üzerinden iletilen verilerin şifrelenmesini ve güvenli bir şekilde iletilmesini sağlayan protokollerdir. Bu protokoller, verilerin dinlenmesini ve yetkisiz erişimleri önler.
MinIO, TLS/SSL ile güvenli iletişimi destekler. Bu özellik, MinIO sunucusu ile istemciler arasındaki iletişimin şifrelenmesini sağlar. İşte adım adım yapılandırma süreci:
TLS/SSL için bir sertifika ve özel anahtar oluşturmanız gerekir. Bu işlem için OpenSSL kullanabilirsiniz.
openssl req -x509 -newkey rsa:4096 -keyout private.key -out public.crt -days 365 -nodes -subj "/CN=localhost"
Bu komut, 365 gün geçerli bir sertifika (public.crt
) ve özel anahtar (private.key
) oluşturur.
Oluşturulan sertifika ve özel anahtarı MinIO sunucusunun yapılandırma dizinine yerleştirin. Varsayılan olarak, MinIO bu dosyaları /etc/minio/certs
dizininde arar.
sudo mkdir -p /etc/minio/certs
sudo cp private.key /etc/minio/certs/private.key
sudo cp public.crt /etc/minio/certs/public.crt
MinIO’yu TLS/SSL ile başlatmak için --certs-dir
parametresini kullanın:
minio server --certs-dir /etc/minio/certs /data
Bu komut, MinIO sunucusunu belirtilen sertifika ve özel anahtarla başlatır.
İstemcilerin MinIO sunucusuna TLS/SSL ile bağlanması için sertifikayı kullanmaları gerekir. Örneğin, mc
istemci aracı ile bağlanmak için:
mc alias set myminio https://localhost:9000 admin password --api "s3v4" --insecure
--insecure
parametresi, kendi imzalı sertifikalar için kullanılır. Üretim ortamlarında güvenilir bir sertifika yetkilisi (CA) tarafından imzalanmış sertifikalar kullanılmalıdır.
Kendi sertifika yetkiliniz (CA) varsa, MinIO’yu bu CA tarafından imzalanmış sertifikalarla yapılandırabilirsiniz.
CA sertifikasını MinIO sunucusunun yapılandırma dizinine yerleştirin:
sudo cp ca.crt /etc/minio/certs/CAs/
MinIO’yu özel CA sertifikası ile başlatmak için:
minio server --certs-dir /etc/minio/certs /data
TLS/SSL ile istemci tarafında kimlik doğrulama yapmak için, istemcilerin de bir sertifika sunması gerekir. Bu, daha yüksek güvenlik sağlar.
İstemci sertifikası oluşturmak için:
openssl req -newkey rsa:4096 -keyout client.key -out client.csr -nodes -subj "/CN=client"
openssl x509 -req -in client.csr -CA public.crt -CAkey private.key -CAcreateserial -out client.crt -days 365
MinIO’yu istemci kimlik doğrulaması ile başlatmak için:
minio server --certs-dir /etc/minio/certs --client-auth /data
İstemcinin sertifika ile bağlanması için:
mc alias set myminio https://localhost:9000 admin password --api "s3v4" --cert-file client.crt --key-file client.key
Erişim denetim listeleri (ACL), belirli kullanıcıların veya grupların belirli kaynaklara (bucket’lar ve nesneler) erişim izinlerini tanımlayan bir dizi kuraldır. ACL’ler, erişim kontrolünü daha ayrıntılı bir şekilde yönetmek için kullanılır.
MinIO, bucket’lar ve nesneler için ACL’leri destekler. ACL’ler, bucket’lar ve nesneler üzerinde erişim izinlerini tanımlamak için kullanılır.
Bucket ACL’leri, bir bucket’a erişim izinlerini tanımlar. Bu izinler, bucket’ın kendisi ve içindeki nesneler için geçerlidir.
Bir bucket’ın ACL’lerini görüntülemek için mc stat
komutunu kullanın:
mc stat myminio/mybucket
Bu komut, mybucket
bucket’ının ACL’lerini görüntüler.
Bir bucket’ın ACL’lerini ayarlamak için mc policy set
komutunu kullanın:
mc policy set download myminio/mybucket
Bu komut, mybucket
bucket’ındaki nesnelerin herkese açık (public) olarak indirilebilmesini sağlar.
Nesne ACL’leri, bir nesneye erişim izinlerini tanımlar. Bu izinler, belirli bir nesne için geçerlidir.
Bir nesnenin ACL’lerini görüntülemek için mc stat
komutunu kullanın:
mc stat myminio/mybucket/myfile.txt
Bu komut, myfile.txt
nesnesinin ACL’lerini görüntüler.
Bir nesnenin ACL’lerini ayarlamak için mc policy set
komutunu kullanın:
mc policy set download myminio/mybucket/myfile.txt
Bu komut, myfile.txt
nesnesinin herkese açık (public) olarak indirilebilmesini sağlar.
MinIO, aşağıdaki ACL izin türlerini destekler:
none
: Erişim yok.read
: Sadece okuma (read-only) erişimi.write
: Sadece yazma (write-only) erişimi.readwrite
: Hem okuma hem yazma erişimi.public
: Herkese açık (public) erişim.MinIO, paralel işlemleri destekler. Bu özellik, veri aktarım hızını artırır.
Paralel işlem sayısını artırmak için --parallel
parametresini kullanın:
mc cp --parallel 4 mylocaldir/ myminio/mybucket/
Bu komut, mylocaldir
dizinindeki dosyaları 4 paralel işlemle mybucket
bucket’ına yükler.
Büyük dosyaları parçalara ayırarak yükleme ve indirme işlemlerini optimize edebilirsiniz.
Part boyutunu artırmak için --part-size
parametresini kullanın:
mc cp --part-size 64M largefile.zip myminio/mybucket/
Bu komut, largefile.zip
dosyasını 64 MB’lık parçalar halinde mybucket
bucket’ına yükler.
MinIO, önbellekleme özellikleri sunar. Bu özellik, sık erişilen verilerin performansını artırır.
Önbellek boyutunu artırmak için --cache-dir
ve --cache-size
parametrelerini kullanın:
minio server --cache-dir /mnt/cache --cache-size 10GB /data
Bu komut, /mnt/cache
dizininde 10 GB’lık bir önbellek oluşturur.
TCP ayarlarını optimize ederek ağ performansını artırabilirsiniz.
TCP window scaling özelliğini etkinleştirin:
sysctl -w net.ipv4.tcp_window_scaling=1
TCP buffer boyutlarını artırın:
sysctl -w net.core.rmem_max=16777216
sysctl -w net.core.wmem_max=16777216
sysctl -w net.ipv4.tcp_rmem="4096 87380 16777216"
sysctl -w net.ipv4.tcp_wmem="4096 65536 16777216"
Ağ arabirim ayarlarını optimize edin:
ethtool -G eth0 rx 4096 tx 4096
ethtool -K eth0 tso on gso on gro on
Disk I/O ayarlarını optimize edin:
echo deadline > /sys/block/sda/queue/scheduler
echo 1024 > /sys/block/sda/queue/nr_requests
Dosya sistemi ayarlarını optimize edin:
mount -o noatime,nodiratime,barrier=0 /dev/sda1 /data
MinIO, dağıtık modda çalıştırılarak performans artırılabilir. Dağıtık mod, birden fazla sunucu üzerinde çalışmayı ve yüksek kullanılabilirlik sağlamayı mümkün kılar.
Dağıtık modda MinIO’yu başlatmak için birden fazla düğüm (node) belirtin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data
Yüksek kullanılabilirlik için birden fazla MinIO sunucusu kullanın ve veri çoğaltma (replication) özelliklerini etkinleştirin.
MinIO performansını izlemek için mc admin info
komutunu kullanın:
mc admin info myminio
Bu komut, MinIO sunucusunun performans bilgilerini görüntüler.
MinIO loglarını izleyerek performans sorunlarını tespit edin:
tail -f /var/log/minio.log
MinIO, Prometheus ile entegre edilerek performans metrikleri izlenebilir:
http://minio-server:9000/minio/prometheus/metrics
Yüksek kullanılabilirlik, bir sistemin kesintisiz çalışmasını ve hizmet sunmasını sağlamak için tasarlanmış bir özelliktir. Bu özellik, donanım veya yazılım arızalarına karşı sistemin sürekli çalışmasını garanti eder.
Dağıtık mimari, bir sistemin birden fazla sunucu üzerinde çalıştırılmasını ve bu sunucuların birbirleriyle senkronize çalışmasını sağlayan bir yapıdır. MinIO, dağıtık mimari sayesinde yüksek kullanılabilirlik ve ölçeklenebilirlik sağlar.
MinIO, dağıtık mimari sayesinde yüksek kullanılabilirlik sağlar. Bu mimari, birden fazla MinIO sunucusunun bir araya gelerek bir küme (cluster) oluşturmasını ve bu kümenin tek bir sistem gibi çalışmasını sağlar.
MinIO kümesi, en az 4 düğüm (node) ile oluşturulabilir. Bu düğümler, verileri senkronize bir şekilde depolayarak yüksek kullanılabilirlik sağlar.
MinIO kümesi oluşturmak için birden fazla düğüm belirtin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data
Bu komut, 4 düğümlü bir MinIO kümesi oluşturur.
MinIO, veri çoğaltma özelliği sayesinde verilerin birden fazla düğümde saklanmasını sağlar. Bu özellik, veri kaybını önler ve yüksek kullanılabilirlik sağlar.
Veri çoğaltma yapılandırması için JSON formatında bir çoğaltma kuralı dosyası hazırlayın:
{
"Role": "arn:aws:iam::123456789012:role/replication-role",
"Rules": [
{
"ID": "ReplicationRule1",
"Status": "Enabled",
"Priority": 1,
"Filter": {
"Prefix": "documents/"
},
"Destination": {
"Bucket": "arn:aws:s3:::backup-bucket"
},
"DeleteMarkerReplication": {
"Status": "Disabled"
}
}
]
}
Bu kural, documents/
öneki ile başlayan nesneleri backup-bucket
bucket’ına çoğaltır.
Çoğaltma kuralını uygulamak için mc replicate add
komutunu kullanın:
mc replicate add myminio/mybucket --remote-bucket myminio/backupbucket --replication-rule replication-rule.json
Bu komut, mybucket
bucket’ındaki nesneleri backupbucket
bucket’ına çoğaltır.
MinIO, dağıtık mimari sayesinde hata toleransı sağlar. Bir düğümün arızalanması durumunda, diğer düğümler hizmet vermeye devam eder.
MinIO kümesi, en az 4 düğüm ile oluşturulduğunda, bir düğümün arızalanması durumunda sistem çalışmaya devam eder. Bu, hata toleransı sağlar.
4 düğümlü bir MinIO kümesinde, bir düğümün arızalanması durumunda, diğer 3 düğüm hizmet vermeye devam eder. Veri çoğaltma özelliği sayesinde, arızalanan düğümdeki veriler diğer düğümlerde saklanır.
MinIO, dağıtık mimari sayesinde kolayca ölçeklenebilir. İhtiyaçlarınıza göre yeni düğümler ekleyerek sistemin kapasitesini artırabilirsiniz.
MinIO kümesine yeni düğümler eklemek için, yeni düğümleri küme yapılandırmasına ekleyin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data http://node5/data http://node6/data
Bu komut, 6 düğümlü bir MinIO kümesi oluşturur.
Ölçeklenebilirlik, bir sistemin artan iş yüklerini karşılamak için kapasitesini artırma yeteneğidir. MinIO, hem dikey hem de yatay ölçeklenebilirlik özellikleri sunar.
Dikey ölçeklenebilirlik, tek bir MinIO sunucusunun kapasitesini artırmak için kullanılır. Bu yöntem, daha güçlü donanımlar ekleyerek sistemin performansını ve depolama kapasitesini artırmayı içerir.
Yatay ölçeklenebilirlik, birden fazla MinIO sunucusu (düğüm) ekleyerek sistemin kapasitesini artırmak için kullanılır. Bu yöntem, MinIO’nun dağıtık mimarisi sayesinde kolayca uygulanabilir.
MinIO, yatay ölçeklenebilirlik için dağıtık bir mimari sunar. MinIO kümesi, birden fazla düğümden oluşur ve bu düğümler bir araya gelerek tek bir sistem gibi çalışır.
MinIO kümesi oluşturmak için birden fazla düğüm belirtin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data
Bu komut, 4 düğümlü bir MinIO kümesi oluşturur.
MinIO kümesine yeni düğümler eklemek için, yeni düğümleri küme yapılandırmasına ekleyin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data http://node5/data http://node6/data
Bu komut, 6 düğümlü bir MinIO kümesi oluşturur.
Depolama kapasitesini artırmak için yeni düğümler ekleyin:
minio server http://node1/data http://node2/data http://node3/data http://node4/data http://node5/data http://node6/data
Bu komut, 6 düğümlü bir MinIO kümesi oluşturur ve depolama kapasitesini artırır.
Performansı artırmak için yeni düğümler ekleyin ve yük dengeleyici kullanın:
minio server http://node1/data http://node2/data http://node3/data http://node4/data http://node5/data http://node6/data
Bu komut, 6 düğümlü bir MinIO kümesi oluşturur ve performansı artırır.
MinIO, sistemin durumunu ve performansını izlemek için çeşitli araçlar ve metrikler sunar. Bu metrikler, depolama kullanımı, ağ trafiği, istek sayısı, hata oranları gibi bilgileri içerir.
MinIO, yerleşik bir web arayüzü (MinIO Console) sunar. Bu arayüz aracılığıyla:
MinIO Console’a erişmek için:
minio server /data --console-address ":9001"
Bu komut, MinIO sunucusunu başlatır ve konsol arayüzünü http://<sunucu-ip>:9001
adresinde kullanıma sunar.
MinIO, Prometheus ile entegre çalışabilir. Prometheus, MinIO’nun performans metriklerini toplamak ve görselleştirmek için kullanılır. MinIO, Prometheus’un anlayabileceği bir metrik endpoint’i (/minio/v2/metrics/cluster
) sunar.
MinIO’yu Prometheus ile entegre etmek için:
export MINIO_PROMETHEUS_AUTH_TYPE="public"
minio server /data
prometheus.yml
) MinIO metrik endpoint’ini ekleyin: scrape_configs:
- job_name: 'minio'
metrics_path: '/minio/v2/metrics/cluster'
static_configs:
- targets: ['<minio-sunucu-ip>:9000']
Prometheus’tan toplanan metrikleri görselleştirmek için Grafana kullanabilirsiniz. MinIO, Grafana için hazır panolar sunar. Bu panolar, depolama kullanımı, istek sayısı, hata oranları gibi metrikleri görselleştirir.
Grafana’ya MinIO panosu eklemek için:
13502
).MinIO’nun performansını analiz etmek için aşağıdaki metrikler ve yöntemler kullanılabilir:
Bu metrikler, Prometheus ve Grafana gibi araçlarla izlenebilir.
mc
)MinIO, performans testleri için mc
(MinIO Client) aracını sunar. Bu araç, okuma/yazma hızlarını ve gecikme sürelerini ölçmek için kullanılabilir.
Örnek bir performans testi:
mc admin info myminio/
Bu komut, MinIO kümesinin genel durumunu ve performans metriklerini gösterir.
Ayrıca, mc
ile benchmark testi yapabilirsiniz:
mc bench myminio/testbucket
Bu komut, belirtilen bucket üzerinde okuma/yazma testleri gerçekleştirir ve sonuçları raporlar.
MinIO, sistem loglarını ayrıntılı bir şekilde kaydeder. Bu loglar, performans sorunlarını tespit etmek için kullanılabilir. Logları incelemek için:
tail -f /var/log/minio.log
Loglar, hata mesajları, istek detayları ve sistem uyarılarını içerir.
MinIO performansını artırmak için aşağıdaki önerileri uygulayabilirsiniz:
MinIO metriklerini programlı olarak çekmek için Python kullanabilirsiniz. Örneğin, Prometheus metriklerini çekmek için:
import requests
# MinIO metrik endpoint'i
url = "http://<minio-sunucu-ip>:9000/minio/v2/metrics/cluster"
# Metrikleri çek
response = requests.get(url)
if response.status_code == 200:
print(response.text)
else:
print("Metrikler alınamadı. Hata kodu:", response.status_code)
Bu kod, MinIO’nun Prometheus metriklerini alır ve ekrana yazdırır.
MinIO, bulut yerel (cloud-native) teknolojilerle tam uyumlu bir nesne depolama çözümüdür. Kubernetes ile entegrasyonu, MinIO’nun ölçeklenebilir, yüksek erişilebilir ve dinamik bir şekilde yönetilmesini sağlar. Kubernetes üzerinde MinIO’yu çalıştırmak, modern mikroservis mimarileri ve bulut yerel uygulamalar için ideal bir çözümdür. İşte MinIO ve Kubernetes entegrasyonunu derinlemesine inceleyelim:
MinIO’yu Kubernetes üzerinde çalıştırmak için iki ana yöntem vardır:
Helm, Kubernetes üzerinde uygulamaları paketlemek ve dağıtmak için kullanılan bir araçtır. MinIO, resmi bir Helm chart’ı sunar.
Helm’i kurmak için:
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
MinIO Helm repository’sini ekleyin:
helm repo add minio https://charts.min.io/
helm repo update
MinIO’yu Kubernetes üzerinde dağıtmak için:
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
Bu komut, MinIO’yu Kubernetes üzerinde dağıtır ve 100GB depolama alanı ayırır.
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO Operator, Kubernetes üzerinde MinIO kümelerini yönetmek için özel bir operatördür. Operator, MinIO’nun dağıtımını, yönetimini ve ölçeklendirilmesini otomatikleştirir.
MinIO Operator’ü Kubernetes üzerinde kurmak için:
kubectl apply -f https://github.com/minio/operator/releases/latest/download/minio-operator.yaml
MinIO Tenant, Kubernetes üzerinde çalışan bir MinIO kümesidir. Tenant oluşturmak için:
apiVersion: minio.min.io/v2
kind: Tenant
metadata:
name: my-minio-tenant
spec:
image: minio/minio:latest
pools:
- servers: 4
volumesPerServer: 4
resources:
requests:
memory: "512Mi"
volumeClaimTemplate:
metadata:
name: data
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 100Gi
Bu yaml dosyasını minio-tenant.yaml
olarak kaydedin ve uygulayın:
kubectl apply -f minio-tenant.yaml
MinIO Tenant erişim bilgilerini almak için:
kubectl get secret my-minio-tenant -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio-tenant -o jsonpath="{.data.rootPassword}" | base64 --decode
mc
) ile Kubernetes Üzerindeki MinIO’ya ErişimKubernetes üzerinde çalışan MinIO’ya erişmek için mc
(MinIO Client) kullanabilirsiniz. Örneğin:
# MinIO sunucusuna erişim bilgilerini ekleyin
mc alias set myminio http://<minio-service-ip>:9000 <rootUser> <rootPassword>
# Bucket oluşturma
mc mb myminio/mybucket
# Dosya yükleme
mc cp myfile.txt myminio/mybucket
apiVersion: v1
kind: Secret
metadata:
name: minio-credentials
type: Opaque
data:
accessKey: <base64-encoded-rootUser>
secretKey: <base64-encoded-rootPassword>
MinIO, Kubernetes ile tam uyumlu bir bulut yerel nesne depolama çözümüdür. Helm veya Operator kullanarak MinIO’yu Kubernetes üzerinde kolayca dağıtabilir ve yönetebilirsiniz. Bu entegrasyon, yüksek erişilebilirlik, otomatik ölçeklendirme ve dinamik depolama yönetimi gibi avantajlar sunar. Doğru yapılandırma ve en iyi uygulamalarla MinIO’yu Kubernetes üzerinde etkili bir şekilde kullanabilirsiniz.
MinIO Operator, Kubernetes üzerinde MinIO kümelerini (tenant’ları) yönetmek için kullanılan bir Kubernetes operatörüdür. Operator, aşağıdaki işlemleri otomatikleştirir:
MinIO Operator’ü Kubernetes üzerinde kurmak için aşağıdaki adımları izleyin:
MinIO Operator’ü Kubernetes üzerinde dağıtmak için:
kubectl apply -f https://github.com/minio/operator/releases/latest/download/minio-operator.yaml
Bu komut, MinIO Operator’ü ve gerekli Kubernetes kaynaklarını (CRD’ler, RBAC ayarları vb.) kurar.
Operator’ün başarıyla kurulduğunu doğrulamak için:
kubectl get pods -n minio-operator
Bu komut, minio-operator
namespace’inde çalışan pod’ları listeler.
MinIO Operator, Tenant adı verilen MinIO kümelerini yönetir. Tenant, birden fazla MinIO sunucusundan oluşan bir kümedir.
Aşağıdaki örnek YAML dosyası, 4 sunucu ve 4 diskten oluşan bir MinIO tenant’ı tanımlar:
apiVersion: minio.min.io/v2
kind: Tenant
metadata:
name: my-minio-tenant
namespace: minio-tenant
spec:
image: minio/minio:latest
pools:
- servers: 4
volumesPerServer: 4
resources:
requests:
memory: "512Mi"
volumeClaimTemplate:
metadata:
name: data
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 100Gi
YAML dosyasını minio-tenant.yaml
olarak kaydedin ve tenant’ı oluşturun:
kubectl apply -f minio-tenant.yaml
Tenant’ın başarıyla oluşturulduğunu doğrulamak için:
kubectl get tenants -n minio-tenant
MinIO Operator, tenant’ların yönetimini kolaylaştırır. Aşağıdaki işlemleri gerçekleştirebilirsiniz:
Tenant’ı ölçeklendirmek için YAML dosyasını güncelleyin ve uygulayın:
spec:
pools:
- servers: 8 # Sunucu sayısını artırın
volumesPerServer: 4
resources:
requests:
memory: "512Mi"
volumeClaimTemplate:
metadata:
name: data
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 100Gi
Ardından:
kubectl apply -f minio-tenant.yaml
Bir tenant’ı silmek için:
kubectl delete tenant my-minio-tenant -n minio-tenant
MinIO tenant’ına erişmek için root kullanıcı ve şifre bilgilerini almanız gerekir. Bu bilgiler, Kubernetes Secret olarak saklanır.
kubectl get secret my-minio-tenant -n minio-tenant -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio-tenant -n minio-tenant -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO Operator, tenant’ların izlenmesi için Prometheus ve Grafana ile entegrasyon sağlar.
MinIO tenant’ları, Prometheus metriklerini otomatik olarak sunar. Bu metrikleri izlemek için Prometheus’u yapılandırın:
scrape_configs:
- job_name: 'minio-tenant'
metrics_path: '/minio/v2/metrics/cluster'
static_configs:
- targets: ['my-minio-tenant:9000']
Grafana’ya MinIO panosu ekleyerek metrikleri görselleştirin. MinIO’nun resmi Grafana panosunu kullanabilirsiniz (dashboard ID: 13502
).
apiVersion: v1
kind: Secret
metadata:
name: minio-credentials
type: Opaque
data:
accessKey: <base64-encoded-rootUser>
secretKey: <base64-encoded-rootPassword>
MinIO, CI/CD pipeline’larında aşağıdaki amaçlarla kullanılabilir:
MinIO, S3 API’si ile uyumlu olduğu için birçok CI/CD aracıyla kolayca entegre edilebilir. Aşağıda popüler CI/CD araçlarıyla MinIO entegrasyon örneklerini inceleyelim.
Jenkins, CI/CD pipeline’ları için yaygın olarak kullanılan bir araçtır. MinIO, Jenkins pipeline’larında artefakt depolama ve test verileri yönetimi için kullanılabilir.
Jenkins’te MinIO’yu kullanmak için S3 Publisher Plugin veya MinIO Plugin kurun:
Jenkins’te MinIO erişim bilgilerini ekleyin:
Aşağıdaki örnek Jenkins pipeline’ı, derleme sonucu oluşan bir artefaktı MinIO’ya yükler:
pipeline {
agent any
environment {
MINIO_ACCESS_KEY = credentials('minio-access-key')
MINIO_SECRET_KEY = credentials('minio-secret-key')
MINIO_BUCKET = 'my-jenkins-artifacts'
}
stages {
stage('Build') {
steps {
sh 'echo "Building artifact..."'
sh 'echo "Sample artifact" > artifact.txt'
}
}
stage('Upload to MinIO') {
steps {
sh '''
mc alias set myminio http://<minio-server-ip>:9000 $MINIO_ACCESS_KEY $MINIO_SECRET_KEY
mc cp artifact.txt myminio/$MINIO_BUCKET
'''
}
}
}
}
GitLab CI, GitLab ile entegre bir CI/CD çözümüdür. MinIO, GitLab CI pipeline’larında artefakt depolama ve test verileri yönetimi için kullanılabilir.
GitLab’da MinIO erişim bilgilerini CI/CD Variables olarak ekleyin:
MINIO_ACCESS_KEY
ve MINIO_SECRET_KEY
değişkenlerini ekleyin.Aşağıdaki örnek .gitlab-ci.yml
dosyası, derleme sonucu oluşan bir artefaktı MinIO’ya yükler:
stages:
- build
- upload
build:
stage: build
script:
- echo "Building artifact..."
- echo "Sample artifact" > artifact.txt
upload_to_minio:
stage: upload
script:
- apt-get update && apt-get install -y wget
- wget https://dl.min.io/client/mc/release/linux-amd64/mc
- chmod +x mc
- ./mc alias set myminio http://<minio-server-ip>:9000 $MINIO_ACCESS_KEY $MINIO_SECRET_KEY
- ./mc cp artifact.txt myminio/my-gitlab-artifacts
GitHub Actions, GitHub ile entegre bir CI/CD çözümüdür. MinIO, GitHub Actions workflow’larında artefakt depolama ve test verileri yönetimi için kullanılabilir.
GitHub’da MinIO erişim bilgilerini Secrets olarak ekleyin:
MINIO_ACCESS_KEY
ve MINIO_SECRET_KEY
değişkenlerini ekleyin.Aşağıdaki örnek GitHub Actions workflow’u, derleme sonucu oluşan bir artefaktı MinIO’ya yükler:
name: CI/CD Pipeline with MinIO
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Build artifact
run: |
echo "Building artifact..."
echo "Sample artifact" > artifact.txt
- name: Upload to MinIO
run: |
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
./mc alias set myminio http://<minio-server-ip>:9000 ${{ secrets.MINIO_ACCESS_KEY }} ${{ secrets.MINIO_SECRET_KEY }}
./mc cp artifact.txt myminio/my-github-artifacts
MinIO, mikroservis mimarilerinde aşağıdaki amaçlarla kullanılabilir:
MinIO, S3 API’si ile uyumlu olduğu için mikroservislerle kolayca entegre edilebilir. Aşağıda MinIO’nun mikroservis mimarilerinde nasıl kullanılabileceğine dair örnekler ve kod parçaları bulabilirsiniz.
Mikroservisler, MinIO’ya erişmek için MinIO SDK’larını veya S3 uyumlu kütüphaneleri kullanabilir. Aşağıda farklı programlama dilleri için örnekler bulunmaktadır.
Python mikroservisleri, MinIO’ya erişmek için minio
kütüphanesini kullanabilir.
pip install minio
from minio import Minio
from minio.error import S3Error
# MinIO istemcisini oluşturma
client = Minio(
"minio-server:9000",
access_key="minio-access-key",
secret_key="minio-secret-key",
secure=False # HTTPS kullanmıyorsanız False yapın
)
# Bucket oluşturma (eğer yoksa)
bucket_name = "my-microservice-bucket"
if not client.bucket_exists(bucket_name):
client.make_bucket(bucket_name)
# Dosya yükleme
try:
client.fput_object(bucket_name, "myfile.txt", "/path/to/myfile.txt")
print("Dosya başarıyla yüklendi.")
except S3Error as err:
print("Hata:", err)
Node.js mikroservisleri, MinIO’ya erişmek için minio-js
kütüphanesini kullanabilir.
npm install minio
const Minio = require('minio');
// MinIO istemcisini oluşturma
const client = new Minio.Client({
endPoint: 'minio-server',
port: 9000,
useSSL: false, // HTTPS kullanmıyorsanız false yapın
accessKey: 'minio-access-key',
secretKey: 'minio-secret-key'
});
// Bucket oluşturma (eğer yoksa)
const bucketName = 'my-microservice-bucket';
client.bucketExists(bucketName, function(err, exists) {
if (err) return console.log(err);
if (!exists) {
client.makeBucket(bucketName, 'us-east-1', function(err) {
if (err) return console.log(err);
console.log('Bucket oluşturuldu:', bucketName);
});
}
});
// Dosya yükleme
const filePath = '/path/to/myfile.txt';
const objectName = 'myfile.txt';
client.fPutObject(bucketName, objectName, filePath, function(err, etag) {
if (err) return console.log(err);
console.log('Dosya başarıyla yüklendi. ETag:', etag);
});
Go mikroservisleri, MinIO’ya erişmek için minio-go
kütüphanesini kullanabilir.
go get github.com/minio/minio-go/v7
package main
import (
"log"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
func main() {
// MinIO istemcisini oluşturma
client, err := minio.New("minio-server:9000", &minio.Options{
Creds: credentials.NewStaticV4("minio-access-key", "minio-secret-key", ""),
Secure: false, // HTTPS kullanmıyorsanız false yapın
})
if err != nil {
log.Fatalln(err)
}
// Bucket oluşturma (eğer yoksa)
bucketName := "my-microservice-bucket"
exists, err := client.BucketExists(context.Background(), bucketName)
if err != nil {
log.Fatalln(err)
}
if !exists {
err = client.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{})
if err != nil {
log.Fatalln(err)
}
log.Println("Bucket oluşturuldu:", bucketName)
}
// Dosya yükleme
objectName := "myfile.txt"
filePath := "/path/to/myfile.txt"
_, err = client.FPutObject(context.Background(), bucketName, objectName, filePath, minio.PutObjectOptions{})
if err != nil {
log.Fatalln(err)
}
log.Println("Dosya başarıyla yüklendi.")
}
MinIO, büyük veri analitiği iş yüklerinde aşağıdaki amaçlarla kullanılabilir:
MinIO, S3 API’si ile uyumlu olduğu için birçok büyük veri aracıyla kolayca entegre edilebilir. Aşağıda popüler büyük veri araçlarıyla MinIO entegrasyon örneklerini inceleyelim.
Hadoop, büyük veri işleme için yaygın olarak kullanılan bir çerçevedir. MinIO, Hadoop Distributed File System (HDFS) yerine S3 uyumlu bir depolama katmanı olarak kullanılabilir.
Hadoop’u MinIO ile kullanmak için core-site.xml
dosyasını aşağıdaki gibi yapılandırın:
<configuration>
<property>
<name>fs.s3a.endpoint</name>
<value>http://minio-server:9000</value>
</property>
<property>
<name>fs.s3a.access.key</name>
<value>minio-access-key</value>
</property>
<property>
<name>fs.s3a.secret.key</name>
<value>minio-secret-key</value>
</property>
<property>
<name>fs.s3a.path.style.access</name>
<value>true</value>
</property>
</configuration>
Hadoop üzerinden MinIO’ya erişmek için:
hadoop fs -ls s3a://my-bucket/
Apache Spark, büyük veri işleme ve analitiği için kullanılan bir çerçevedir. MinIO, Spark’ın depolama katmanı olarak kullanılabilir.
Spark’ı MinIO ile kullanmak için spark-defaults.conf
dosyasını aşağıdaki gibi yapılandırın:
spark.hadoop.fs.s3a.endpoint http://minio-server:9000
spark.hadoop.fs.s3a.access.key minio-access-key
spark.hadoop.fs.s3a.secret.key minio-secret-key
spark.hadoop.fs.s3a.path.style.access true
Spark üzerinden MinIO’ya erişmek için:
from pyspark.sql import SparkSession
spark = SparkSession.builder \
.appName("MinIO Example") \
.getOrCreate()
# MinIO'dan veri okuma
df = spark.read.csv("s3a://my-bucket/my-data.csv")
df.show()
Presto (veya Trino), büyük veri analitiği için kullanılan dağıtık bir SQL motorudur. MinIO, Presto’nun depolama katmanı olarak kullanılabilir.
Presto’yu MinIO ile kullanmak için catalog/minio.properties
dosyasını aşağıdaki gibi yapılandırın:
connector.name=hive-hadoop2
hive.metastore.uri=thrift://localhost:9083
hive.s3.endpoint=http://minio-server:9000
hive.s3.aws-access-key=minio-access-key
hive.s3.aws-secret-key=minio-secret-key
hive.s3.path-style-access=true
Presto üzerinden MinIO’ya erişmek için:
SELECT * FROM minio.default.my_table;
Aşağıdaki örnek, Spark ile MinIO’da saklanan bir CSV dosyasını okuyup analiz eder:
from pyspark.sql import SparkSession
# Spark oturumu oluşturma
spark = SparkSession.builder \
.appName("MinIO Spark Example") \
.config("spark.hadoop.fs.s3a.endpoint", "http://minio-server:9000") \
.config("spark.hadoop.fs.s3a.access.key", "minio-access-key") \
.config("spark.hadoop.fs.s3a.secret.key", "minio-secret-key") \
.config("spark.hadoop.fs.s3a.path.style.access", "true") \
.getOrCreate()
# MinIO'dan veri okuma
df = spark.read.csv("s3a://my-bucket/my-data.csv", header=True, inferSchema=True)
# Veri analizi
df.show()
df.printSchema()
df.groupBy("column_name").count().show()
MinIO’yu Hadoop ile entegre etmek için aşağıdaki adımları izleyin:
Hadoop’u MinIO ile kullanmak için core-site.xml
dosyasını yapılandırmanız gerekir. Bu dosya, Hadoop’un MinIO’ya nasıl erişeceğini belirler.
core-site.xml
Dosyasını Düzenlemecore-site.xml
dosyasına aşağıdaki özellikleri ekleyin:
<configuration>
<!-- MinIO endpoint'i -->
<property>
<name>fs.s3a.endpoint</name>
<value>http://minio-server:9000</value>
</property>
<!-- MinIO erişim anahtarı -->
<property>
<name>fs.s3a.access.key</name>
<value>minio-access-key</value>
</property>
<!-- MinIO gizli anahtarı -->
<property>
<name>fs.s3a.secret.key</name>
<value>minio-secret-key</value>
</property>
<!-- Path-style erişim -->
<property>
<name>fs.s3a.path.style.access</name>
<value>true</value>
</property>
<!-- S3A bağlantı ayarları -->
<property>
<name>fs.s3a.connection.ssl.enabled</name>
<value>false</value>
</property>
</configuration>
Hadoop’un MinIO’ya erişebilmesi için hadoop-aws
ve aws-java-sdk-bundle
kütüphanelerini ekleyin. Bu kütüphaneler, Hadoop’un S3 API’si ile iletişim kurmasını sağlar.
Kütüphaneleri İndirme:
hadoop-aws
: Hadoop’un S3 entegrasyonu için gerekli kütüphane.aws-java-sdk-bundle
: AWS SDK’sı (MinIO S3 API’si ile uyumlu).Kütüphaneleri Hadoop Classpath’ine Ekleme:
İndirdiğiniz JAR dosyalarını Hadoop’un lib
dizinine kopyalayın:
cp hadoop-aws-<version>.jar $HADOOP_HOME/lib/
cp aws-java-sdk-bundle-<version>.jar $HADOOP_HOME/lib/
Hadoop’u MinIO ile yapılandırdıktan sonra, Hadoop komut satırı araçları veya MapReduce/Spark işleri ile MinIO’ya erişebilirsiniz.
Hadoop komut satırı araçlarını kullanarak MinIO’da bulunan verilere erişebilirsiniz. Örneğin:
hadoop fs -ls s3a://my-bucket/
Bu komut, MinIO’da bulunan my-bucket
adlı bucket’taki dosyaları listeler.
MinIO’ya veri yazmak ve okumak için Hadoop komutlarını kullanabilirsiniz:
# MinIO'ya dosya yükleme
hadoop fs -put localfile.txt s3a://my-bucket/localfile.txt
# MinIO'dan dosya indirme
hadoop fs -get s3a://my-bucket/localfile.txt localfile.txt
Hadoop MapReduce işlerini MinIO’da saklanan veriler üzerinde çalıştırabilirsiniz. Aşağıda basit bir MapReduce örneği bulunmaktadır.
s3a://my-bucket/input/
dizininde bulunan bir metin dosyası.s3a://my-bucket/output/
dizinine yazılacak sonuçlar.MapReduce işini çalıştırmak için:
hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-<version>.jar wordcount s3a://my-bucket/input/ s3a://my-bucket/output/
Apache Spark, Hadoop ekosistemi içinde büyük veri işleme için kullanılan bir çerçevedir. Spark’ı MinIO ile entegre edebilirsiniz.
Spark’ı MinIO ile kullanmak için spark-defaults.conf
dosyasını aşağıdaki gibi yapılandırın:
spark.hadoop.fs.s3a.endpoint http://minio-server:9000
spark.hadoop.fs.s3a.access.key minio-access-key
spark.hadoop.fs.s3a.secret.key minio-secret-key
spark.hadoop.fs.s3a.path.style.access true
spark.hadoop.fs.s3a.connection.ssl.enabled false
Spark üzerinden MinIO’da bulunan bir CSV dosyasını okuyup işlemek için:
from pyspark.sql import SparkSession
# Spark oturumu oluşturma
spark = SparkSession.builder \
.appName("MinIO Spark Example") \
.getOrCreate()
# MinIO'dan veri okuma
df = spark.read.csv("s3a://my-bucket/my-data.csv", header=True, inferSchema=True)
# Veri analizi
df.show()
df.printSchema()
df.groupBy("column_name").count().show()
MinIO’yu Spark ile entegre etmek için aşağıdaki adımları izleyin:
Spark’ı MinIO ile kullanmak için spark-defaults.conf
dosyasını veya Spark oturumu sırasında gerekli yapılandırma parametrelerini ayarlamanız gerekir.
spark-defaults.conf
Dosyasını Düzenlemespark-defaults.conf
dosyasına aşağıdaki özellikleri ekleyin:
# MinIO endpoint'i
spark.hadoop.fs.s3a.endpoint http://minio-server:9000
# MinIO erişim anahtarı
spark.hadoop.fs.s3a.access.key minio-access-key
# MinIO gizli anahtarı
spark.hadoop.fs.s3a.secret.key minio-secret-key
# Path-style erişim
spark.hadoop.fs.s3a.path.style.access true
# SSL kullanımı (HTTPS kullanmıyorsanız false yapın)
spark.hadoop.fs.s3a.connection.ssl.enabled false
Spark’ın MinIO’ya erişebilmesi için hadoop-aws
ve aws-java-sdk-bundle
kütüphanelerini ekleyin. Bu kütüphaneler, Spark’ın S3 API’si ile iletişim kurmasını sağlar.
Kütüphaneleri İndirme:
hadoop-aws
: Hadoop’un S3 entegrasyonu için gerekli kütüphane.aws-java-sdk-bundle
: AWS SDK’sı (MinIO S3 API’si ile uyumlu).Kütüphaneleri Spark Classpath’ine Ekleme:
İndirdiğiniz JAR dosyalarını Spark’ın jars
dizinine kopyalayın:
cp hadoop-aws-<version>.jar $SPARK_HOME/jars/
cp aws-java-sdk-bundle-<version>.jar $SPARK_HOME/jars/
Spark’ı MinIO ile yapılandırdıktan sonra, Spark oturumu sırasında MinIO’da bulunan verilere erişebilirsiniz.
Spark oturumu oluştururken MinIO yapılandırma parametrelerini belirtin:
from pyspark.sql import SparkSession
# Spark oturumu oluşturma
spark = SparkSession.builder \
.appName("MinIO Spark Example") \
.config("spark.hadoop.fs.s3a.endpoint", "http://minio-server:9000") \
.config("spark.hadoop.fs.s3a.access.key", "minio-access-key") \
.config("spark.hadoop.fs.s3a.secret.key", "minio-secret-key") \
.config("spark.hadoop.fs.s3a.path.style.access", "true") \
.config("spark.hadoop.fs.s3a.connection.ssl.enabled", "false") \
.getOrCreate()
MinIO’da bulunan bir CSV dosyasını okuyup Spark DataFrame’e dönüştürün:
# MinIO'dan veri okuma
df = spark.read.csv("s3a://my-bucket/my-data.csv", header=True, inferSchema=True)
# Veriyi görüntüleme
df.show()
df.printSchema()
Spark DataFrame’ini MinIO’ya yazmak için:
# DataFrame'i MinIO'ya yazma
df.write.csv("s3a://my-bucket/output/")
Spark SQL, MinIO’da saklanan veriler üzerinde SQL sorguları çalıştırmak için kullanılabilir.
MinIO’dan okunan veriyi Spark SQL tablosu olarak kaydedin:
# DataFrame'i geçici bir SQL tablosu olarak kaydetme
df.createOrReplaceTempView("my_table")
# SQL sorgusu çalıştırma
result = spark.sql("SELECT * FROM my_table WHERE column_name = 'value'")
result.show()
Spark Streaming, MinIO’da saklanan veriler üzerinde gerçek zamanlı işlemler yapmak için kullanılabilir.
Spark Streaming oturumu oluştururken MinIO yapılandırma parametrelerini belirtin:
from pyspark.streaming import StreamingContext
# Spark Streaming oturumu oluşturma
ssc = StreamingContext(spark.sparkContext, batchDuration=10) # 10 saniyelik batch'ler
MinIO’da bulunan bir dizinden veri akışı okuyun:
# MinIO'dan veri akışı okuma
stream = ssc.textFileStream("s3a://my-bucket/streaming-input/")
# Akış verisi üzerinde işlem yapma
stream.foreachRDD(lambda rdd: rdd.foreach(print))
# Akışı başlatma
ssc.start()
ssc.awaitTermination()
Veri gölü, büyük miktarda ham verinin depolandığı merkezi bir depodur. Bu veriler, yapılandırılmış (SQL tabloları), yarı yapılandırılmış (JSON, XML) ve yapılandırılmamış (loglar, görseller) olabilir. Veri gölleri, veri bilimi, makine öğrenimi ve büyük veri analitiği gibi alanlarda kullanılır.
MinIO, veri gölü mimarisinin temel depolama katmanı olarak kullanılabilir. Aşağıda tipik bir MinIO tabanlı veri gölü mimarisi bulunmaktadır:
MinIO’yu veri gölü olarak kullanmak için aşağıdaki adımları izleyin:
MinIO’yu Kubernetes üzerinde Helm veya Operator ile dağıtabilirsiniz. Örnek olarak Helm ile MinIO kurulumu:
helm repo add minio https://charts.min.io/
helm repo update
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
Veri gölüne veri alımı, batch veya stream işlemleri ile yapılabilir. Örnek olarak, Python ile MinIO’ya veri yükleme:
from minio import Minio
from minio.error import S3Error
# MinIO istemcisini oluşturma
client = Minio(
"minio-server:9000",
access_key="minio-access-key",
secret_key="minio-secret-key",
secure=False # HTTPS kullanmıyorsanız False yapın
)
# Bucket oluşturma (eğer yoksa)
bucket_name = "my-data-lake"
if not client.bucket_exists(bucket_name):
client.make_bucket(bucket_name)
# Dosya yükleme
try:
client.fput_object(bucket_name, "myfile.txt", "/path/to/myfile.txt")
print("Dosya başarıyla yüklendi.")
except S3Error as err:
print("Hata:", err)
MinIO’da saklanan veriler, Hadoop, Spark veya Presto gibi araçlarla işlenebilir ve analiz edilebilir.
from pyspark.sql import SparkSession
# Spark oturumu oluşturma
spark = SparkSession.builder \
.appName("MinIO Data Lake Example") \
.config("spark.hadoop.fs.s3a.endpoint", "http://minio-server:9000") \
.config("spark.hadoop.fs.s3a.access.key", "minio-access-key") \
.config("spark.hadoop.fs.s3a.secret.key", "minio-secret-key") \
.config("spark.hadoop.fs.s3a.path.style.access", "true") \
.config("spark.hadoop.fs.s3a.connection.ssl.enabled", "false") \
.getOrCreate()
# MinIO'dan veri okuma
df = spark.read.csv("s3a://my-data-lake/my-data.csv", header=True, inferSchema=True)
# Veri analizi
df.show()
df.printSchema()
df.groupBy("column_name").count().show()
MinIO, çoklu bulut stratejilerinde aşağıdaki şekillerde kullanılabilir:
MinIO, farklı bulut ortamları arasında veri çoğaltma özelliği sunar. Bu sayede, veriler birden fazla bulut ortamında tutarlı bir şekilde saklanabilir.
MinIO, farklı bulut ortamları arasında veri taşıma işlemlerini kolaylaştırır. Bu, bulut sağlayıcıları arasında geçiş yaparken veya hibrit bulut stratejileri uygularken kullanışlıdır.
MinIO, özel bulut (on-premise) ve genel bulut (public cloud) ortamlarını birleştiren hibrit bulut mimarilerinde kullanılabilir. Bu sayede, kritik veriler özel bulutta saklanırken, genel bulut kaynakları da kullanılabilir.
MinIO’yu çoklu bulut stratejilerinde kullanmak için aşağıdaki adımları izleyin:
MinIO’yu farklı bulut ortamlarında kullanmak için öncelikle MinIO’yu kurmanız ve yapılandırmanız gerekir.
MinIO’yu Kubernetes üzerinde Helm veya Operator ile dağıtabilirsiniz. Örnek olarak Helm ile MinIO kurulumu:
helm repo add minio https://charts.min.io/
helm repo update
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO, farklı bulut ortamları arasında veri çoğaltma özelliği sunar. Bu özellik, verilerin birden fazla bulut ortamında tutarlı bir şekilde saklanmasını sağlar.
MinIO’da çoğaltma yapılandırması için mc
(MinIO Client) aracını kullanabilirsiniz:
mc alias set minio1 http://minio1-server:9000 minio-access-key minio-secret-key
mc alias set minio2 http://minio2-server:9000 minio-access-key minio-secret-key
mc admin replicate add minio1 minio2
MinIO’da çoğaltma politikası oluşturmak için:
mc replicate add minio1/my-bucket --remote-bucket minio2/my-bucket
MinIO, farklı bulut ortamları arasında veri taşıma işlemlerini kolaylaştırır. Bu işlemler için mc
aracını kullanabilirsiniz.
mc alias set minio http://minio-server:9000 minio-access-key minio-secret-key
mc alias set aws https://s3.amazonaws.com aws-access-key aws-secret-key
mc cp aws/my-bucket/my-file.txt minio/my-bucket/
MinIO, özel bulut ve genel bulut ortamlarını birleştiren hibrit bulut mimarilerinde kullanılabilir. Bu sayede, kritik veriler özel bulutta saklanırken, genel bulut kaynakları da kullanılabilir.
MinIO, hibrit bulut mimarilerinde aşağıdaki şekillerde kullanılabilir:
MinIO, özel bulut ve genel bulut ortamlarını birleştirerek tutarlı bir depolama katmanı sunar. Bu sayede, veriler özel bulutta saklanırken, genel bulut kaynakları da kullanılabilir.
MinIO, özel bulut ve genel bulut ortamları arasında veri çoğaltma özelliği sunar. Bu sayede, veriler birden fazla ortamda tutarlı bir şekilde saklanabilir.
MinIO, özel bulut ve genel bulut ortamları arasında veri taşıma işlemlerini kolaylaştırır. Bu, iş yüklerini özel bulut ve genel bulut arasında dağıtırken kullanışlıdır.
MinIO’yu hibrit bulut mimarilerinde kullanmak için aşağıdaki adımları izleyin:
MinIO’yu özel bulut ve genel bulut ortamlarında kullanmak için öncelikle MinIO’yu kurmanız ve yapılandırmanız gerekir.
MinIO’yu Kubernetes üzerinde Helm veya Operator ile dağıtabilirsiniz. Örnek olarak Helm ile MinIO kurulumu:
helm repo add minio https://charts.min.io/
helm repo update
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO, özel bulut ve genel bulut ortamlarını birleştirerek tutarlı bir depolama katmanı sunar. Bu sayede, veriler özel bulutta saklanırken, genel bulut kaynakları da kullanılabilir.
MinIO, özel bulut ve genel bulut ortamları arasında veri çoğaltma özelliği sunar. Bu özellik, verilerin birden fazla ortamda tutarlı bir şekilde saklanmasını sağlar.
MinIO’da çoğaltma yapılandırması için mc
(MinIO Client) aracını kullanabilirsiniz:
mc alias set minio1 http://minio1-server:9000 minio-access-key minio-secret-key
mc alias set minio2 http://minio2-server:9000 minio-access-key minio-secret-key
mc admin replicate add minio1 minio2
MinIO’da çoğaltma politikası oluşturmak için:
mc replicate add minio1/my-bucket --remote-bucket minio2/my-bucket
MinIO, özel bulut ve genel bulut ortamları arasında veri taşıma işlemlerini kolaylaştırır. Bu işlemler için mc
aracını kullanabilirsiniz.
mc alias set minio http://minio-server:9000 minio-access-key minio-secret-key
mc alias set aws https://s3.amazonaws.com aws-access-key aws-secret-key
mc cp minio/my-bucket/my-file.txt aws/my-bucket/
Aşağıdaki örnek, özel bulut ve genel bulut ortamları arasında veri taşıma işlemini gösterir:
from minio import Minio
from minio.error import S3Error
import boto3
# MinIO istemcisini oluşturma
minio_client = Minio(
"minio-server:9000",
access_key="minio-access-key",
secret_key="minio-secret-key",
secure=False # HTTPS kullanmıyorsanız False yapın
)
# AWS S3 istemcisini oluşturma
s3_client = boto3.client(
's3',
aws_access_key_id='aws-access-key',
aws_secret_access_key='aws-secret-key'
)
# MinIO'dan dosya indirme
try:
minio_client.fget_object("my-bucket", "my-file.txt", "/tmp/my-file.txt")
print("Dosya MinIO'dan indirildi.")
except S3Error as err:
print("Hata:", err)
# AWS S3'e dosya yükleme
try:
s3_client.upload_file("/tmp/my-file.txt", "my-bucket", "my-file.txt")
print("Dosya AWS S3'e yüklendi.")
except Exception as err:
print("Hata:", err)
MinIO, felaket kurtarma senaryolarında aşağıdaki özellikleriyle öne çıkar:
MinIO, felaket kurtarma için aşağıdaki stratejileri destekler:
MinIO, farklı bölgelerdeki (region) MinIO kümeleri arasında veri çoğaltma özelliği sunar. Bu sayede, bir bölgedeki felaket durumunda diğer bölgedeki verilere erişim sağlanabilir.
MinIO, özel bulut ve genel bulut ortamları arasında veri çoğaltma özelliği sunar. Bu sayede, hem özel bulut hem de genel bulut ortamlarında veri tutarlılığı sağlanır.
MinIO, verilerin düzenli olarak yedeklenmesini ve hızlı bir şekilde geri yüklenmesini sağlar. Bu, felaket durumunda veri kaybını önler.
MinIO’yu felaket kurtarma senaryolarında kullanmak için aşağıdaki adımları izleyin:
MinIO’yu felaket kurtarma için kullanmak için öncelikle MinIO’yu kurmanız ve yapılandırmanız gerekir.
MinIO’yu Kubernetes üzerinde Helm veya Operator ile dağıtabilirsiniz. Örnek olarak Helm ile MinIO kurulumu:
helm repo add minio https://charts.min.io/
helm repo update
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO, farklı bölgelerdeki MinIO kümeleri arasında veri çoğaltma özelliği sunar. Bu sayede, bir bölgedeki felaket durumunda diğer bölgedeki verilere erişim sağlanabilir.
MinIO’da çoğaltma yapılandırması için mc
(MinIO Client) aracını kullanabilirsiniz:
mc alias set minio1 http://minio1-server:9000 minio-access-key minio-secret-key
mc alias set minio2 http://minio2-server:9000 minio-access-key minio-secret-key
mc admin replicate add minio1 minio2
MinIO’da çoğaltma politikası oluşturmak için:
mc replicate add minio1/my-bucket --remote-bucket minio2/my-bucket
MinIO, özel bulut ve genel bulut ortamları arasında veri çoğaltma özelliği sunar. Bu sayede, hem özel bulut hem de genel bulut ortamlarında veri tutarlılığı sağlanır.
mc alias set minio http://minio-server:9000 minio-access-key minio-secret-key
mc alias set aws https://s3.amazonaws.com aws-access-key aws-secret-key
mc replicate add minio/my-bucket --remote-bucket aws/my-bucket
MinIO, verilerin düzenli olarak yedeklenmesini ve hızlı bir şekilde geri yüklenmesini sağlar. Bu, felaket durumunda veri kaybını önler.
MinIO’da veri yedekleme işlemi için mc
aracını kullanabilirsiniz:
mc cp --recursive minio/my-bucket /backup/location/
MinIO’da veri geri yükleme işlemi için mc
aracını kullanabilirsiniz:
mc cp --recursive /backup/location/ minio/my-bucket
Aşağıdaki örnek, MinIO’da veri yedekleme ve geri yükleme işlemlerini gösterir:
from minio import Minio
from minio.error import S3Error
import os
# MinIO istemcisini oluşturma
minio_client = Minio(
"minio-server:9000",
access_key="minio-access-key",
secret_key="minio-secret-key",
secure=False # HTTPS kullanmıyorsanız False yapın
)
# Yedekleme işlemi
def backup_bucket(bucket_name, backup_location):
try:
objects = minio_client.list_objects(bucket_name, recursive=True)
for obj in objects:
minio_client.fget_object(bucket_name, obj.object_name, os.path.join(backup_location, obj.object_name))
print("Yedekleme tamamlandı.")
except S3Error as err:
print("Hata:", err)
# Geri yükleme işlemi
def restore_bucket(bucket_name, backup_location):
try:
for root, dirs, files in os.walk(backup_location):
for file in files:
file_path = os.path.join(root, file)
object_name = os.path.relpath(file_path, backup_location)
minio_client.fput_object(bucket_name, object_name, file_path)
print("Geri yükleme tamamlandı.")
except S3Error as err:
print("Hata:", err)
# Yedekleme ve geri yükleme işlemlerini çalıştırma
backup_bucket("my-bucket", "/backup/location/")
restore_bucket("my-bucket", "/backup/location/")
MinIO, arşivleme ve yedekleme için aşağıdaki stratejileri destekler:
MinIO, farklı lokasyonlarda veya bulut ortamlarında veri çoğaltma özelliği sunar. Bu sayede, veriler birden fazla ortamda tutarlı bir şekilde saklanabilir.
MinIO, verilerin yaşam döngüsünü yönetmek için kurallar tanımlamanıza olanak tanır. Bu kurallar, verilerin belirli bir süre sonra silinmesini veya daha düşük maliyetli bir depolama katmanına taşınmasını sağlar.
MinIO, verilerin düzenli olarak yedeklenmesini ve hızlı bir şekilde geri yüklenmesini sağlar. Bu, olası veri kayıplarına karşı koruma sağlar.
MinIO’yu arşivleme ve yedekleme senaryolarında kullanmak için aşağıdaki adımları izleyin:
MinIO’yu arşivleme ve yedekleme için kullanmak için öncelikle MinIO’yu kurmanız ve yapılandırmanız gerekir.
MinIO’yu Kubernetes üzerinde Helm veya Operator ile dağıtabilirsiniz. Örnek olarak Helm ile MinIO kurulumu:
helm repo add minio https://charts.min.io/
helm repo update
helm install my-minio minio/minio --set resources.requests.memory=512Mi --set persistence.size=100Gi
MinIO erişim bilgilerini almak için:
kubectl get secret my-minio -o jsonpath="{.data.rootUser}" | base64 --decode
kubectl get secret my-minio -o jsonpath="{.data.rootPassword}" | base64 --decode
MinIO, farklı lokasyonlarda veya bulut ortamlarında veri çoğaltma özelliği sunar. Bu sayede, veriler birden fazla ortamda tutarlı bir şekilde saklanabilir.
MinIO’da çoğaltma yapılandırması için mc
(MinIO Client) aracını kullanabilirsiniz:
mc alias set minio1 http://minio1-server:9000 minio-access-key minio-secret-key
mc alias set minio2 http://minio2-server:9000 minio-access-key minio-secret-key
mc admin replicate add minio1 minio2
MinIO’da çoğaltma politikası oluşturmak için:
mc replicate add minio1/my-bucket --remote-bucket minio2/my-bucket
MinIO, verilerin yaşam döngüsünü yönetmek için kurallar tanımlamanıza olanak tanır. Bu kurallar, verilerin belirli bir süre sonra silinmesini veya daha düşük maliyetli bir depolama katmanına taşınmasını sağlar.
MinIO’da yaşam döngüsü kuralı oluşturmak için mc
aracını kullanabilirsiniz:
mc ilm add my-minio/my-bucket --transition-days 30 --storage-class GLACIER
MinIO’da yaşam döngüsü kurallarını görüntülemek için:
mc ilm list my-minio/my-bucket
MinIO, verilerin düzenli olarak yedeklenmesini ve hızlı bir şekilde geri yüklenmesini sağlar. Bu, olası veri kayıplarına karşı koruma sağlar.
MinIO’da veri yedekleme işlemi için mc
aracını kullanabilirsiniz:
mc cp --recursive minio/my-bucket /backup/location/
MinIO’da veri geri yükleme işlemi için mc
aracını kullanabilirsiniz:
mc cp --recursive /backup/location/ minio/my-bucket
Aşağıdaki örnek, MinIO’da veri yedekleme ve geri yükleme işlemlerini gösterir:
from minio import Minio
from minio.error import S3Error
import os
# MinIO istemcisini oluşturma
minio_client = Minio(
"minio-server:9000",
access_key="minio-access-key",
secret_key="minio-secret-key",
secure=False # HTTPS kullanmıyorsanız False yapın
)
# Yedekleme işlemi
def backup_bucket(bucket_name, backup_location):
try:
objects = minio_client.list_objects(bucket_name, recursive=True)
for obj in objects:
minio_client.fget_object(bucket_name, obj.object_name, os.path.join(backup_location, obj.object_name))
print("Yedekleme tamamlandı.")
except S3Error as err:
print("Hata:", err)
# Geri yükleme işlemi
def restore_bucket(bucket_name, backup_location):
try:
for root, dirs, files in os.walk(backup_location):
for file in files:
file_path = os.path.join(root, file)
object_name = os.path.relpath(file_path, backup_location)
minio_client.fput_object(bucket_name, object_name, file_path)
print("Geri yükleme tamamlandı.")
except S3Error as err:
print("Hata:", err)
# Yedekleme ve geri yükleme işlemlerini çalıştırma
backup_bucket("my-bucket", "/backup/location/")
restore_bucket("my-bucket", "/backup/location/")
Bir sonraki yazıda görüşmek dileğiyle!”