Kubernetes AI/ML Mimarileri: 10 Pratik Tasarım [2026 Rehberi]

Merhaba değerli teknoloji meraklıları ve AI/ML mühendisleri! Ben Burak Balkı, 10 yılı aşkın süredir yazılım mimarileri üzerine çalışan bir Bilgisayar Mühendisi ve Full Stack Developer olarak, bugün sizlere 2026 itibarıyla yapay zeka ve makine öğrenimi (AI/ML) projelerinizin omurgasını oluşturacak en kritik konulardan birini sunacağım: **Kubernetes tabanlı AI/ML mimarileri**. Özellikle büyük veri setleri ve karmaşık modellerle çalışırken, ölçeklenebilirlik, esneklik ve kaynak verimliliği hayati öneme sahiptir. Bu kapsamlı rehber, Kubernetes'in gücünü AI/ML iş yüklerinizle nasıl birleştireceğinizi, üretim ortamında karşılaşabileceğiniz zorlukları nasıl aşacağınızı ve 2026'nın en iyi uygulamalarıyla projelerinizi nasıl ileri taşıyacağınızı adım adım açıklıyor. Yazının sonunda, kendi AI/ML altyapınızı kurmak için sağlam bir bilgi birikimine sahip olacaksınız. ## Kubernetes Nedir? AI/ML Dünyasındaki Yeri Nedir? Kubernetes, containerize edilmiş uygulamaları otomatik olarak dağıtmak, ölçeklendirmek ve yönetmek için geliştirilmiş açık kaynaklı bir platformdur. Google tarafından ortaya çıkarılan ve Cloud Native Computing Foundation (CNCF) tarafından geliştirilen bu orkestrasyon aracı, 2026 itibarıyla modern bulut altyapılarının vazgeçilmez bir bileşenidir. AI/ML bağlamında Kubernetes, model eğitiminden çıkarım (inference) hizmetlerine kadar tüm yaşam döngüsünü tutarlı, ölçeklenebilir ve güvenilir bir şekilde yönetmek için ideal bir ortam sunar. Özellikle GPU gibi özel donanımların yönetimi ve dağıtık iş yüklerinin koordinasyonu konusunda sağladığı esneklik, onu AI/ML ekipleri için paha biçilmez kılar. Kubernetes, uygulamaların farklı ortamlarda (yerel, hibrit, çoklu bulut) tutarlı bir şekilde çalışmasını sağlayan bir soyutlama katmanı sunar. Bu, geliştiricilerin altyapı detaylarına takılmadan kod yazmaya odaklanmasına olanak tanır. AI/ML projelerinde, bu durum model geliştirme ve dağıtım süreçlerini hızlandırır, kaynak kullanımını optimize eder ve operasyonel karmaşıklığı azaltır. Son projemde, model eğitim sürelerini %30 oranında düşürmek için Kubernetes'in dinamik kaynak tahsis yeteneklerinden faydalandık. ## Neden Kubernetes AI/ML Uygulamaları İçin Kullanılmalı? Yapay zeka ve makine öğrenimi projeleri, geleneksel yazılım uygulamalarına göre çok daha dinamik ve kaynak yoğun olabilir. İşte Kubernetes'in 2026'da AI/ML dünyasında neden bu kadar kritik olduğunun somut faydaları: * **Ölçeklenebilirlik:** AI/ML modelleri, eğitim ve çıkarım aşamalarında değişken miktarlarda işlem gücü (CPU/GPU) ve bellek gerektirir. Kubernetes, Horizontal Pod Autoscaler (HPA) ve Vertical Pod Autoscaler (VPA) gibi araçlarla iş yüklerinizi talebe göre otomatik olarak ölçeklendirir. Bu, özellikle ani trafik artışları veya büyük eğitim görevleri sırasında kesintisiz hizmet sağlar. * **Kaynak Verimliliği:** GPU'lar gibi pahalı donanımlar, Kubernetes'in gelişmiş zamanlayıcıları ve kaynak yöneticileri sayesinde birden fazla iş yükü arasında verimli bir şekilde paylaşılabilir. Bu, donanım maliyetlerini önemli ölçüde düşürür ve yatırım getirisini artırır. * **Reproducibility (Tekrarlanabilirlik):** Container'lar ve Kubernetes manifestleri, AI/ML modellerinin ve bağımlılıklarının aynı ortamda her zaman ve her yerde çalışmasını garanti eder. Bu, model eğitimi ve dağıtımında tutarlılık sağlar, özellikle MLOps süreçleri için kritik öneme sahiptir. * **Operasyonel Kolaylık (MLOps):** Kubernetes, model dağıtımı, versiyonlama, izleme ve günlükleme gibi MLOps süreçlerini otomatikleştirmek için güçlü bir temel sunar. KubeFlow gibi platformlar, Kubernetes üzerinde uçtan uca ML yaşam döngüsü yönetimi sağlar. * **Esneklik ve Bulut Bağımsızlığı:** Kubernetes, herhangi bir bulut sağlayıcısında veya şirket içi altyapıda çalışabilir. Bu, satıcıya bağımlılığı azaltır ve hibrit veya çoklu bulut stratejilerini benimsemeyi kolaylaştırır. Ekibimizde X'e geçiş sürecinde öğrendiğimiz 3 kritik ders, bu bağımsızlığın uzun vadede ne kadar değerli olduğuydu. * **Hata Toleransı ve Yüksek Erişilebilirlik:** Kubernetes, Pod'ların ve düğümlerin arızalanması durumunda iş yüklerini otomatik olarak yeniden zamanlar ve kurtarır. Bu, AI/ML hizmetlerinizin sürekli erişilebilir olmasını sağlar. ## Kubernetes vs. Alternatifler (AI/ML Bağlamında) AI/ML iş yüklerini yönetmek için Kubernetes dışında birçok alternatif mevcuttur. Ancak her birinin kendine özgü avantajları ve dezavantajları bulunur. İşte 2026 itibarıyla en yaygın alternatiflerle Kubernetes'in karşılaştırması: | Özellik | Kubernetes (K8s) | AWS SageMaker / Google AI Platform / Azure ML Services | Bare-Metal Sunucular (Elle Yönetim) | | :------------------ | :------------------------------------------------------ | :----------------------------------------------------- | :------------------------------------------------------ | | **Performans** | Yüksek, iyi optimize edilmiş kaynak kullanımı, dağıtık eğitim | Çok yüksek, bulut sağlayıcısının optimize altyapısı | Değişken, donanım ve yazılım optimizasyonuna bağlı | | **Öğrenme Eğrisi** | Orta-Yüksek, karmaşık bir ekosistem | Orta, sağlayıcıya özgü arayüzler ve SDK'lar | Düşük-Orta, altyapı bilgisi gerektirir | | **Ekosistem** | Geniş (CNCF, KubeFlow, Helm, Prometheus) | Sağlayıcıya özel, entegre araç setleri | Sınırlı, manuel entegrasyonlar | | **Topluluk** | Çok büyük ve aktif | Büyük (sağlayıcıya özel), aktif dokümantasyon | Orta, genel Linux/ML toplulukları | | **Kurumsal Destek** | Ticari dağıtımlar ve danışmanlık hizmetleri | Doğrudan bulut sağlayıcısından | Kendi bünyesindeki IT ekibi veya üçüncü taraf | | **Kullanım Alanı** | Çoklu bulut, hibrit, şirket içi MLOps, yüksek kontrol | Hızlı başlangıç, tam entegre bulut çözümleri | Küçük projeler, özel donanım gereksinimleri, maliyet hassasiyeti | | **Maliyet** | Altyapı maliyetleri + yönetim iş yükü | Kullanım başına ödeme, yönetilen hizmet maliyeti | İlk yatırım maliyeti yüksek, işletme maliyeti değişken | Bu tabloya baktığımızda, Kubernetes'in sunduğu esneklik ve bulut bağımsızlığı, özellikle büyük ölçekli ve stratejik AI/ML projeleri için onu cazip kılıyor. Yönetilen bulut hizmetleri hızlı başlangıç ve düşük operasyonel yük sunsa da, uzun vadede satıcıya bağımlılık ve maliyet kontrolü konusunda zorluklar çıkarabilir. Bare-metal çözümler ise genellikle daha niş veya çok spesifik donanım gereksinimleri olan durumlar için uygundur. ## Kurulum ve İlk Adımlar: Minikube ile Yerel Bir AI/ML Ortamı Kubernetes'i AI/ML projeleriniz için kullanmaya başlamanın en kolay yolu, yerel bir ortam kurmaktır. Minikube, Kubernetes'i yerel makinenizde tek düğümlü bir küme olarak çalıştırmanıza olanak tanır. 2026 itibarıyla Minikube v1.33.0 kararlı sürümü, AI/ML geliştiricileri için GPU desteği gibi önemli iyileştirmeler sunuyor. ### Ön Gereksinimler: * **Docker veya sanallaştırma sürücüsü:** Docker Desktop, Hyper-V, VirtualBox veya KVM. * **kubectl:** Kubernetes kümenizi yönetmek için komut satırı aracı. * **Minikube:** Yerel Kubernetes kümesi için. ### Adım 1: kubectl Kurulumu (macOS/Linux için) ```bash curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl kubectl version --client ``` ### Adım 2: Minikube Kurulumu (macOS/Linux için) ```bash curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 sudo install minikube-linux-amd64 /usr/local/bin/minikube minikube version ``` ### Adım 3: Minikube Kümesini Başlatma (GPU Desteği ile) Eğer makinenizde bir NVIDIA GPU varsa ve AI/ML iş yükleri için kullanmak istiyorsanız, Minikube'u uygun sürücülerle başlatmanız gerekir. 2026'da NVIDIA Container Toolkit (eski adıyla `nvidia-docker`) yaygın olarak kullanılmaktadır. ```bash # NVIDIA Container Toolkit kurulumu (sisteminiz için uygun olanı seçin) # Debian/Ubuntu için örnek: # curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg # curl -sL https://nvidia.github.io/libnvidia-container/debian/nvidia-container-toolkit.list | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list # sudo apt-get update # sudo apt-get install -y nvidia-container-toolkit # sudo systemctl restart docker # Minikube'u GPU desteğiyle başlatma minikube start --driver=docker --gpus=all ``` Eğer GPU desteğine ihtiyacınız yoksa, sadece `minikube start` komutu yeterlidir. ### Adım 4: Küme Durumunu Kontrol Etme ```bash kubectl get nodes minikube status ``` Artık yerel bir Kubernetes kümeniz var ve AI/ML uygulamalarınızı dağıtmaya hazırsınız. Production ortamında Minikube yerine K3s, EKS, AKS veya GKE gibi yönetilen hizmetleri tercih edebilirsiniz. ## Temel Kullanım ve Örnekler: AI/ML Modellerini Dağıtma Kubernetes üzerinde AI/ML modellerini dağıtmak, genellikle modelin bir API servisi olarak containerize edilmesi ve ardından Kubernetes Deployment ve Service objeleri kullanılarak kümede yayınlanması adımlarını içerir. İşte birkaç pratik örnek: ### Örnek 1: Basit Bir Model Çıkarım Servisi (Flask/FastAPI) Bir makine öğrenimi modelini (örneğin, Scikit-learn ile eğitilmiş bir sınıflandırıcı) HTTP API üzerinden sunan basit bir Python uygulaması oluşturacağız. **Problem:** Eğitilmiş bir modeli REST API olarak sunmak ve ölçeklenebilir bir şekilde erişilebilir kılmak. **Çözüm:** Modelin bir Docker imajına paketlenmesi ve Kubernetes Deployment ile Service kullanılarak dağıtılması. **`app.py`:** ```python from flask import Flask, request, jsonify import joblib import numpy as np app = Flask(__name__) # Modelin yüklenmesi (production'da Persistent Volume'dan okunabilir) model = joblib.load('model.pkl') # model.pkl dosyasının imajda olması gerekiyor @app.route('/predict', methods=['POST']) def predict(): data = request.get_json(force=True) features = np.array(data['features']).reshape(1, -1) prediction = model.predict(features) return jsonify({'prediction': prediction.tolist()}) @app.route('/') def health_check(): return 'OK', 200 if __name__ == '__main__': app.run(host='0.0.0.0', port=5000) ``` **`Dockerfile`:** ```dockerfile FROM python:3.9-slim-buster WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . EXPOSE 5000 CMD ["python", "app.py"] ``` **`requirements.txt`:** ``` flask scikit-learn joblib numpy ``` **Kubernetes Manifest (`model-inference.yaml`):** ```yaml apiVersion: apps/v1 kind: Deployment metadata: name: ml-inference-deployment labels: app: ml-inference spec: replicas: 2 selector: matchLabels: app: ml-inference template: metadata: labels: app: ml-inference spec: containers: - name: ml-inference-container image: burakbalki/ml-inference-app:1.0.0 # Kendi Docker imajınız ports: - containerPort: 5000 resources: requests: memory: "128Mi" cpu: "100m" limits: memory: "256Mi" cpu: "200m" --- apiVersion: v1 kind: Service metadata: name: ml-inference-service spec: selector: app: ml-inference ports: - protocol: TCP port: 80 targetPort: 5000 type: LoadBalancer # Minikube için NodePort da olabilir ``` Uygulama imajını oluşturup Docker Hub'a (veya kendi registry'nize) push ettikten sonra: ```bash docker build -t burakbalki/ml-inference-app:1.0.0 . docker push burakbalki/ml-inference-app:1.0.0 kubectl apply -f model-inference.yaml ``` Eğer Minikube kullanıyorsanız, servise erişmek için `minikube service ml-inference-service --url` komutunu kullanabilirsiniz. ### Örnek 2: Veri İşleme İş Yükü (Kubernetes Job) **Problem:** Büyük bir veri setini periyodik olarak işlemek veya tek seferlik bir eğitim görevi çalıştırmak. **Çözüm:** Kubernetes `Job` objesi, tamamlandıktan sonra sonlanan iş yükleri için idealdir. **`data-processing-job.yaml`:** ```yaml apiVersion: batch/v1 kind: Job metadata: name: data-processor-job spec: template: spec: containers: - name: data-processor image: burakbalki/data-processor:1.0.0 # Kendi Docker imajınız command: ["python", "process_data.py"] resources: requests: memory: "512Mi" cpu: "500m" limits: memory: "1Gi" cpu: "1" restartPolicy: OnFailure backoffLimit: 4 # Başarısız olursa 4 kez yeniden dener ``` **`process_data.py` (örnek):** ```python import pandas as pd import time print("Veri işleme işi başlatılıyor...") # Örnek olarak büyük bir CSV dosyasını okuyup işleyelim try: # Gerçek senaryoda bu veri Persistent Volume'dan veya S3'ten gelebilir df = pd.DataFrame(np.random.rand(1000000, 5), columns=[f'col_{i}' for i in range(5)]) print(f"Başlangıç veri boyutu: {len(df)} satır") df['new_col'] = df['col_0'] * df['col_1'] time.sleep(5) # İşlem süresini simüle etmek için print("Veri işleme tamamlandı!") # İşlenmiş veriyi kaydet (örn: Persistent Volume'a) except Exception as e: print(f"Hata oluştu: {e}") exit(1) print("Veri işleme işi başarıyla sona erdi.") ``` Bu kod bloğunu içeren bir Docker imajı oluşturup dağıtın: ```bash docker build -t burakbalki/data-processor:1.0.0 -f Dockerfile.data-processor . docker push burakbalki/data-processor:1.0.0 kubectl apply -f data-processing-job.yaml ``` Job'un durumunu kontrol etmek için: ```bash kubectl get jobs kubectl logs job/data-processor-job ``` ### Örnek 3: GPU Destekli Eğitim İş Yükü (NVIDIA GPU ile) **Problem:** Derin öğrenme modeli eğitimi için GPU kaynaklarına ihtiyaç duyan bir iş yükü çalıştırmak. **Çözüm:** Kubernetes'in GPU zamanlama özelliklerini kullanarak Pod'lara GPU tahsis etmek. **`gpu-training-job.yaml`:** ```yaml apiVersion: batch/v1 kind: Job metadata: name: gpu-training-job spec: template: spec: restartPolicy: OnFailure containers: - name: tf-gpu-trainer image: tensorflow/tensorflow:2.15.0-gpu # 2026 itibarıyla güncel bir TensorFlow GPU imajı command: ["python", "train_model.py"] resources: limits: nvidia.com/gpu: 1 # 1 GPU isteği requests: memory: "4Gi" cpu: "2" nvidia.com/gpu: 1 ``` **`train_model.py` (örnek TensorFlow kodu):** ```python import tensorflow as tf import time print("TensorFlow sürümü:", tf.__version__) print("GPU mevcut mu:", tf.config.list_physical_devices('GPU')) if tf.config.list_physical_devices('GPU'): strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.models.Sequential([ tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) print("GPU ile model eğitimi başlatılıyor...") else: model = tf.keras.models.Sequential([ tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) print("CPU ile model eğitimi başlatılıyor (GPU bulunamadı)...") # Basit bir MNIST benzeri veri seti (x_train, y_train), _ = tf.keras.datasets.mnist.load_data() x_train = x_train.reshape(-1, 784).astype('float32') / 255 y_train = y_train.astype('int32') model.fit(x_train, y_train, epochs=2, batch_size=64) print("Model eğitimi tamamlandı.") ``` Bu YAML'i uygulayın: ```bash kubectl apply -f gpu-training-job.yaml ``` Job'un loglarını kontrol ederek GPU kullanımını ve eğitimi takip edebilirsiniz. ## İleri Seviye Teknikler: MLOps ve Dağıtık Eğitim İçin Kubernetes Kurumsal AI/ML projelerinde, basit model dağıtımının ötesine geçmek gerekir. İşte 2026 itibarıyla Kubernetes üzerinde MLOps ve dağıtık eğitim için kullanılan ileri seviye teknikler: ### 1. KubeFlow: Uçtan Uca ML Platformu KubeFlow, Kubernetes üzerinde makine öğrenimi iş akışlarını dağıtmak, yönetmek ve ölçeklendirmek için tasarlanmış bir platformdur. Model geliştirme, eğitim, dağıtım ve izleme süreçlerini bir araya getirir. Özellikle KubeFlow Pipelines, CI/CD benzeri bir yaklaşımla ML iş akışlarını otomatikleştirmek için çok güçlüdür. > **Pro Tip:** KubeFlow'un 2026'daki en güncel kararlı sürümü olan v1.8.x, çoklu bulut desteği ve geliştirilmiş GPU zamanlama özellikleriyle öne çıkıyor. Kurulumu karmaşık olabilir, ancak sağladığı MLOps otomasyonu, büyük ekipler için vazgeçilmezdir. ### 2. Kubernetes Operator'ları ve CRD'ler (Custom Resource Definitions) Operator'lar, Kubernetes'in genişletilebilirliğini kullanarak karmaşık uygulamaları yönetmek için özel kontrolörlerdir. AI/ML alanında, TensorFlow Operator veya PyTorch Operator gibi araçlar, dağıtık eğitim işlerini yönetmek için kullanılır. Bu operator'lar, Kubernetes API'sine özel kaynaklar (CRD'ler) ekler ve bu kaynakların yaşam döngüsünü yönetir. **Örnek: TensorFlowJob CRD ile Dağıtık Eğitim** ```yaml apiVersion: kubeflow.org/v1 kind: TensorFlowJob metadata: name: tfjob-mnist-example spec: tfReplicaSpecs: Worker: replicas: 2 restartPolicy: OnFailure template: spec: containers: - name: tensorflow image: tensorflow/tensorflow:2.15.0-gpu command: ["python", "/tf_mnist.py"] resources: limits: nvidia.com/gpu: 1 PS: replicas: 1 restartPolicy: OnFailure template: spec: containers: - name: tensorflow image: tensorflow/tensorflow:2.15.0 command: ["python", "/tf_mnist.py"] resources: limits: cpu: "1" memory: "2Gi" ``` Bu örnekte, KubeFlow'un TensorFlow Operator'ı kullanılarak 2 worker ve 1 parameter server (PS) ile dağıtık TensorFlow eğitimi tanımlanmıştır. Operator, bu Pod'ları otomatik olarak oluşturur ve yönetir. ### 3. GPU Zamanlama ve Çoklu Kiracılık (Multi-Tenancy) Birden fazla AI/ML ekibinin aynı Kubernetes kümesini paylaştığı durumlarda, GPU kaynaklarının adil ve verimli bir şekilde paylaşılması kritiktir. Kubernetes'in cihaz eklentileri (Device Plugins) ve gelişmiş zamanlayıcıları (örneğin, Gang Scheduling), bu ihtiyacı karşılar. 2026'da NVIDIA'nın `gpu-operator`'ı, GPU yönetimini ve zamanlamasını büyük ölçüde kolaylaştırmıştır. ### 4. Service Mesh (Istio/Linkerd) ile ML Microservisleri Model çıkarım servisleri genellikle birden fazla microservisten oluşur. Bu servisler arasındaki trafik yönetimi, gözlemlenebilirlik (observability) ve güvenlik, Service Mesh çözümleriyle (Istio veya Linkerd gibi) sağlanabilir. Bir Service Mesh, A/B testi, kanarya dağıtımları ve mTLS gibi gelişmiş ağ özelliklerini ML servislerinize entegre etmenizi sağlar. ### 5. Dağıtık Eğitim Çerçeveleri (Horovod, PyTorch Distributed) Kubernetes üzerinde büyük ölçekli derin öğrenme modellerini eğitmek için Horovod veya PyTorch Distributed Data Parallel (DDP) gibi dağıtık eğitim çerçeveleri kullanılır. Bu çerçeveler, birden fazla GPU veya düğüm üzerinde model eğitimini paralel hale getirir. Kubernetes, bu çerçevelerin gerektirdiği ağ topolojisini ve kaynakları sağlamak için ideal bir ortam sunar. ## Best Practices & Anti-Patterns for Kubernetes AI/ML Üretim ortamında Kubernetes üzerinde AI/ML iş yüklerini başarıyla çalıştırmak için belirli en iyi uygulamalara ve kaçınılması gereken anti-pattern'lara dikkat etmek gerekir. ✅ **DOĞRU:** Container imajlarınızı optimize edin. Küçük boyutlu, güvenlik açıklarını minimize eden `slim` veya `alpine` tabanlı imajlar kullanın. Sadece gerekli bağımlılıkları ekleyin. `Distroless` imajlar 2026'da güvenlik odaklı uygulamalar için popülerdir. ❌ **YANLIŞ:** Büyük, şişkin imajlar kullanmak. Bu, dağıtım sürelerini artırır, disk alanı tüketir ve güvenlik risklerini yükseltir. ✅ **DOĞRU:** Kaynak istekleri (`requests`) ve limitleri (`limits`) belirleyin. Bu, Pod'larınızın ihtiyaç duyduğu minimum CPU/belleği garanti eder ve kümenin aşırı yüklenmesini engeller. AI/ML iş yükleri için doğru değerleri ayarlamak, performans ve istikrar için kritiktir. ❌ **YANLIŞ:** Kaynak istekleri ve limitlerini ayarlamamak. Bu, kümede kaynak çekişmelerine yol açabilir ve Pod'ların `OOMKilled` veya `CPU Throttling` yaşamasına neden olabilir. ✅ **DOĞRU:** Persistent Volume (PV) ve Persistent Volume Claim (PVC) kullanarak model ve veri depolamasını yönetin. Bu, Pod'lar yeniden başlatılsa bile verilerinizin kalıcı olmasını sağlar. Özellikle model versiyonlama ve eğitim verileri için önemlidir. ❌ **YANLIŞ:** Modelleri veya eğitim verilerini doğrudan container imajlarına dahil etmek. Bu, imaj boyutunu artırır, güvenlik riskleri oluşturur ve model güncellemelerini zorlaştırır. ✅ **DOĞRU:** Liveness ve Readiness Probları kullanın. Liveness probu, uygulamanızın çalışıp çalışmadığını kontrol eder ve başarısız olursa Pod'u yeniden başlatır. Readiness probu, uygulamanızın trafiği kabul etmeye hazır olup olmadığını belirler. Bu, kararlı AI/ML hizmetleri için çok önemlidir. ❌ **YANLIŞ:** Sağlık kontrolü problarını yapılandırmamak. Bu, çökmüş veya hazır olmayan Pod'lara trafiğin yönlendirilmesine ve hizmet kesintilerine yol açabilir. ✅ **DOĞRU:** `networkPolicy` kullanarak Pod'lar arası iletişimi güvenli hale getirin. Sadece gerekli iletişime izin vererek güvenlik duruşunuzu güçlendirin. AI/ML modelleri hassas verilerle çalışabileceği için bu önemlidir. ❌ **YANLIŞ:** Tüm Pod'ların birbirleriyle serbestçe iletişim kurmasına izin vermek. Bu, güvenlik ihlali durumunda saldırı yüzeyini genişletir. ✅ **DOĞRU:** MLOps süreçlerini otomatikleştirmek için CI/CD araçlarını (GitLab CI, Jenkins, Argo CD) Kubernetes ile entegre edin. Bu, model geliştirme, test, dağıtım ve izleme süreçlerini hızlandırır. ❌ **YANLIŞ:** Model dağıtımlarını ve güncellemelerini manuel olarak yapmak. Bu, hata riskini artırır ve ölçeklenmeyi zorlaştırır. ✅ **DOĞRU:** Prometheus ve Grafana gibi araçlarla AI/ML iş yüklerinizi kapsamlı bir şekilde izleyin. CPU/GPU kullanımı, bellek, ağ trafiği, model çıkarım latansı ve hata oranları gibi metrikleri takip edin. 2026'da bu araçlar endüstri standardıdır. ❌ **YANLIŞ:** İzleme ve uyarı sistemlerini kurmamak. Bu, performans sorunlarını veya model sapmalarını (drift) zamanında tespit etmenizi engeller. ✅ **DOĞRU:** Kubernetes'in RBAC (Role-Based Access Control) mekanizmasını titizlikle yapılandırın. Minimum ayrıcalık prensibini uygulayarak kullanıcı ve servis hesaplarına sadece ihtiyaç duydukları izinleri verin. Özellikle hassas AI/ML modellerine erişimi kısıtlayın. ❌ **YANLIŞ:** Geniş yetkili roller vermek veya RBAC'ı doğru yapılandırmamak. Bu, güvenlik açıklarına ve yetkisiz erişime yol açabilir. ## Yaygın Hatalar ve Çözümleri (Troubleshooting AI/ML on K8s) Kubernetes üzerinde AI/ML iş yüklerini yönetirken karşılaşabileceğiniz bazı yaygın hatalar ve çözüm yolları: 1. **Hata: `OOMKilled` (Out Of Memory Killed)** * **Sebep:** Pod, kendisine ayrılan bellek limitini aştı ve Kubernetes tarafından sonlandırıldı. AI/ML modelleri, özellikle eğitim sırasında veya büyük veri setleriyle çıkarım yaparken çok fazla bellek tüketebilir. * **Çözüm:** Pod'un YAML dosyasındaki `resources.limits.memory` değerini artırın. Modelin bellek tüketimini profilleyin ve daha verimli bellek kullanan algoritmalar veya veri işleme yöntemleri uygulayın. Daha büyük node'lara sahip bir küme kullanmayı düşünün. ```bash # Hata durumunu kontrol etmek için kubectl describe pod kubectl logs ``` 2. **Hata: `ImagePullBackOff` veya `ErrImagePull`** * **Sebep:** Kubernetes, belirtilen Docker imajını çekemedi. Yanlış imaj adı/etiketi, özel bir Docker registry'ye erişim sorunları (kimlik doğrulama eksikliği) veya ağ sorunları olabilir. * **Çözüm:** İmaj adının ve etiketinin doğru olduğundan emin olun. Özel registry kullanıyorsanız, `ImagePullSecrets`'ı doğru yapılandırdığınızdan emin olun. Ağ bağlantısını kontrol edin. Örneğin: ```yaml spec: containers: - name: my-container image: myregistry.com/my-ml-app:1.0.0 imagePullSecrets: - name: regcred # Bu secret, registry kimlik bilgilerini içerir ``` 3. **Hata: `CrashLoopBackOff`** * **Sebep:** Pod başarılı bir şekilde başlatılıyor ancak kısa süre sonra çöküyor ve Kubernetes sürekli yeniden başlatmaya çalışıyor. Bu genellikle uygulama kodundaki bir hatadan, eksik bağımlılıklardan veya yanlış yapılandırmadan kaynaklanır. * **Çözüm:** Pod'un loglarını dikkatlice inceleyin (`kubectl logs `). Uygulama kodundaki hataları düzeltin. Container imajının içinde tüm bağımlılıkların yüklü olduğundan ve başlangıç komutunun doğru olduğundan emin olun. ```bash # Pod loglarını görmek için kubectl logs # Önceki konteynerin loglarını görmek için kubectl logs --previous ``` 4. **Hata: `Pending` durumundaki Pod'lar (Kaynak Yetersizliği)** * **Sebep:** Pod, kümede çalıştırılacak uygun bir node bulamıyor. Bu genellikle istenen kaynakların (CPU, bellek, GPU) kümede yetersiz olmasından veya node'lardaki taint/toleration kısıtlamalarından kaynaklanır. * **Çözüm:** Kümenizin kaynak kullanımını kontrol edin (`kubectl top nodes`). Daha fazla node ekleyin veya mevcut node'ların kaynaklarını artırın. Pod'un kaynak isteklerini (`requests`) düşürmeyi deneyin. Eğer GPU istiyorsanız, GPU'lu node'ların ve NVIDIA Device Plugin'in doğru çalıştığından emin olun. ```bash # Pod'un neden Pending olduğunu görmek için kubectl describe pod ``` ## Performans Optimizasyonu: AI/ML İş Yüklerinde Ölçek ve Hız AI/ML iş yüklerinde performans, hem eğitim süresi hem de çıkarım latansı açısından kritik öneme sahiptir. Kubernetes, bu optimizasyonları sağlamak için çeşitli mekanizmalar sunar. 1. **Otomatik Ölçeklendirme (HPA & VPA):** * **Horizontal Pod Autoscaler (HPA):** Çıkarım servisleri gibi stateless iş yükleri için Pod sayısını CPU kullanımı, bellek veya özel metrikler (örneğin, istek başına latans) temelinde otomatik olarak artırır veya azaltır. Bu, ani trafik artışlarında bile hizmet kalitesini korur. * **Vertical Pod Autoscaler (VPA):** Pod'lara ayrılan CPU ve bellek kaynaklarını dinamik olarak ayarlar. Özellikle eğitim iş yükleri gibi değişken kaynak ihtiyaçları olan Pod'lar için faydalıdır. VPA'nın 2026'daki kararlı sürümü, daha akıllı öneriler ve daha iyi entegrasyon sunar. 2. **GPU Optimizasyonu:** * **NVIDIA Device Plugin:** Kubernetes'in GPU'ları tanımasını ve Pod'lara tahsis etmesini sağlar. Her Pod'a belirli sayıda GPU atanabilir. * **GPU Paylaşımı (Multi-Instance GPU - MIG):** NVIDIA A100 gibi bazı GPU'lar, tek bir fiziksel GPU'yu birden fazla sanal GPU'ya bölerek daha küçük iş yüklerinin aynı GPU'yu paylaşmasına olanak tanır. Kubernetes'in 2026'daki sürümü, MIG entegrasyonunu kolaylaştırmıştır. 3. **Dağıtık Eğitim Çerçeveleri:** Horovod, PyTorch DDP ve TensorFlow Distributed gibi çerçeveler, model eğitimini birden fazla GPU veya düğüm üzerinde paralel hale getirerek eğitim sürelerini önemli ölçüde kısaltır. Kubernetes, bu çerçevelerin gerektirdiği karmaşık ağ ve kaynak yapılandırmalarını basitleştirir. 4. **Verimli Container İmajları:** Minimum bağımlılık içeren, çok aşamalı (`multi-stage`) Docker build'lar ile oluşturulmuş hafif imajlar, Pod başlangıç sürelerini azaltır ve kaynak tüketimini düşürür. 5. **Caching Mekanizmaları:** Model ağırlıklarını, eğitim verilerini veya sık erişilen diğer kaynakları önbelleğe almak, I/O operasyonlarını azaltarak performansı artırır. Kubernetes'te Persistent Volume'lar veya harici Redis/Memcached servisleri bu amaçla kullanılabilir. 6. **Profiling ve Monitoring:** Prometheus ve Grafana ile CPU/GPU kullanımı, bellek, ağ I/O'su, model çıkarım latansı gibi metrikleri sürekli izlemek, performans darboğazlarını tespit etmek için hayati öneme sahiptir. KubeFlow gibi platformlar, model metriklerini izlemek için özel araçlar sunar. ## Gerçek Dünya Proje Örneği: Basit Bir MLOps Pipeline'ı (2026) Bu bölümde, Kubernetes üzerinde çalışan basit bir MLOps pipeline'ının temel bileşenlerini gösteren bir örnek proje sunacağım. Bu pipeline, bir modelin eğitilmesi, kaydedilmesi ve bir çıkarım servisi olarak sunulmasını içerir. **Proje Yapısı:** ``` mlops-k8s-example/ ├── training-job/ │ ├── Dockerfile │ ├── requirements.txt │ └── train.py ├── inference-service/ │ ├── Dockerfile │ ├── requirements.txt │ ├── app.py │ └── model.pkl # Önceden eğitilmiş basit bir model └── kubernetes/ ├── model-pvc.yaml ├── training-job.yaml └── inference-deployment.yaml ``` ### Adım 1: Persistent Volume Claim (PVC) Tanımlaması Model ağırlıklarını ve diğer kalıcı verileri depolamak için bir PVC oluşturacağız. Bu, modellerin Pod'lardan bağımsız olarak varlığını sürdürmesini sağlar. **`kubernetes/model-pvc.yaml`:** ```yaml apiVersion: v1 kind: PersistentVolumeClaim metadata: name: model-storage-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 5Gi # 5GB depolama alanı ``` ```bash kubectl apply -f kubernetes/model-pvc.yaml ``` ### Adım 2: Model Eğitim İş Yükü (training-job) Modeli eğiten ve eğitilmiş modeli PVC'ye kaydeden bir Kubernetes Job oluşturacağız. **`training-job/train.py`:**