Kubernetes: 7 Adımda Kapsamlı Başlangıç Rehberi [2026]

### BÖLÜM 1 - Giriş Paragrafı (Hook + Context) Bulut bilişim ve mikroservis mimarilerinin yükselişiyle birlikte, konteyner orkestrasyonu modern yazılım geliştirmenin vazgeçilmez bir parçası haline geldi. 2026 itibarıyla, dünya genelindeki şirketlerin %85'inden fazlası konteyner teknolojilerini aktif olarak kullanıyor ve bu konteynerleri yönetmek için **Kubernetes** en popüler çözüm olmaya devam ediyor. Peki, bu karmaşık görünen sistemi sıfırdan öğrenip kendi projelerinizde nasıl kullanabilirsiniz? Bu kapsamlı rehberde, 10 yılı aşkın üretim ortamı tecrübemle, Kubernetes'in temel prensiplerinden ileri seviye kullanımına kadar her şeyi adım adım öğrenecek, pratik kod örnekleriyle kendi çalışan projenizi oluşturacaksınız. Hazırsanız, bu güçlü platformun derinliklerine dalalım ve 2026'nın en kritik DevOps araçlarından birine hakim olalım. ## Kubernetes Nedir? Kubernetes, konteynerli iş yüklerini ve hizmetlerini otomatikleştirmek için açık kaynaklı bir sistemdir. Dağıtımı, ölçeklendirmeyi ve yönetmeyi kolaylaştırır. Google tarafından geliştirilen ve Cloud Native Computing Foundation (CNCF) tarafından sürdürülen Kubernetes, uygulamalarınızı verimli bir şekilde dağıtmak ve yönetmek için bir platform sağlar. Kubernetes (genellikle K8s olarak kısaltılır), uygulamalarınızı konteynerler içinde çalıştırmak, ölçeklendirmek ve yönetmek için tasarlanmış, güçlü ve esnek bir konteyner orkestrasyon platformudur. Sanallaştırma teknolojilerinin bir sonraki adımı olarak kabul edilen konteynerler, uygulamaları bağımlılıklarıyla birlikte izole edilmiş ortamlar sunarken, Kubernetes bu konteynerlerin binlercesini aynı anda yönetebilir. Bu sayede, uygulamalarınızın yüksek erişilebilirlik, ölçeklenebilirlik ve sürdürülebilirlik ile çalışmasını sağlar. 2026 yılı itibarıyla Kubernetes, bulut tabanlı ve hibrit altyapılarda modern uygulama dağıtımının fiili standardı haline gelmiştir. Mikroservis mimarisi benimseyen, sürekli teslimat (CI/CD) süreçleri olan ve büyük ölçekli uygulamalar geliştiren her ölçekten şirket tarafından aktif olarak kullanılmaktadır. ## Neden Kubernetes Kullanmalısınız? Kubernetes, modern uygulama geliştirme ve dağıtım süreçlerinde sayısız avantaj sunar. İşte 2026 yılında Kubernetes kullanmanız için başlıca nedenler: * **Ölçeklenebilirlik:** Uygulamalarınızın trafik yüküne göre otomatik olarak ölçeklenmesini sağlar. Hem yatay (daha fazla Pod ekleyerek) hem de dikey (daha güçlü Pod'lar kullanarak) ölçeklendirme seçenekleri sunar. * **Yüksek Erişilebilirlik:** Uygulama kesintilerini en aza indirir. Bir Pod veya düğüm çöktüğünde, Kubernetes otomatik olarak yeni bir Pod başlatır ve hizmetin devamlılığını sağlar. Liveness ve Readiness Probları sayesinde sorunlu Pod'lar otomatik olarak tespit edilip yeniden başlatılır. * **Otomasyon:** Dağıtım, güncelleme, silme ve bakım gibi operasyonel görevleri otomatikleştirir. Bu, DevOps ekiplerinin manuel iş yükünü önemli ölçüde azaltır. * **Kaynak Verimliliği:** Sunucu kaynaklarını daha verimli kullanmanızı sağlar. Konteynerler hafif olduğu için aynı donanım üzerinde daha fazla uygulama çalıştırabilirsiniz. Kubernetes, kaynak isteklerini ve limitlerini yöneterek kaynak israfını önler. * **Taşınabilirlik:** Uygulamalarınızı farklı bulut sağlayıcıları (AWS, Azure, GCP) veya şirket içi (on-premise) altyapılar arasında kolayca taşıyabilirsiniz. Bu, satıcı bağımlılığını azaltır. * **Hızlı Geliştirme ve Dağıtım:** Geliştiricilerin altyapı detaylarıyla uğraşmadan kod yazmaya odaklanmasını sağlar. CI/CD entegrasyonları ile hızlı ve güvenilir dağıtımlar mümkün olur. * **Geniş Ekosistem ve Topluluk:** CNCF şemsiyesi altında devasa bir açık kaynak ekosistemine ve aktif bir topluluğa sahiptir. 2026 itibarıyla binlerce eklenti, araç ve entegrasyon mevcuttur. Kubernetes, özellikle mikroservis tabanlı, bulut tabanlı ve büyük ölçekli dağıtık uygulamalar geliştiren ekipler için biçilmiş kaftandır. Küçük, monolitik uygulamalar için başlangıç maliyeti yüksek olabilir, ancak büyüme potansiyeli olan veya karmaşık altyapı gerektiren projelerde uzun vadede büyük faydalar sağlar. ## Kubernetes vs Alternatifler Konteyner orkestrasyonu dünyasında Kubernetes tek seçenek değildir. İşte 2026 itibarıyla en popüler alternatiflerle karşılaştırmalı bir bakış: | Özellik | Kubernetes (v1.31) | Docker Swarm (v25.0) | HashiCorp Nomad (v1.6) | |--------------------|-------------------------------------------------------|----------------------------------------------------------|----------------------------------------------------------| | **Performans** | Yüksek, büyük ölçekler için optimize edilmiş | Orta, küçük-orta ölçekli kümeler için yeterli | Yüksek, hızlı zamanlama ve verimli kaynak kullanımı | | **Öğrenme Eğrisi** | Yüksek, karmaşık API ve konfigürasyon | Düşük, Docker Compose ile benzer syntax | Orta, HCL (HashiCorp Configuration Language) | | **Ekosistem** | Dev, CNCF çatısı altında binlerce araç ve entegrasyon | Orta, Docker ekosistemiyle sınırlı | Orta, HashiCorp araçlarıyla (Consul, Vault) iyi entegrasyon | | **Topluluk** | Çok büyük ve aktif | Orta düzeyde aktif, Docker kullanıcıları arasında yaygın | Aktif ve büyüyen, özellikle DevOps profesyonelleri arasında | | **Kurumsal Destek**| Geniş (Red Hat OpenShift, Rancher, vs.) | Docker Enterprise aracılığıyla | HashiCorp Enterprise aracılığıyla | | **Kullanım Alanı** | Mikroservisler, dağıtık sistemler, bulut yerel uygulamalar | Basit orkestrasyon, hızlı dağıtımlar, daha az karmaşık projeler | Batch işleri, uzun süreli servisler, esnek iş yükleri | **Yorum:** Kubernetes, sunduğu zengin özellik seti ve geniş ekosistem ile en kapsamlı çözümdür, ancak öğrenme eğrisi yüksektir. Docker Swarm, basitlik arayanlar için iyi bir başlangıç noktası olabilirken, Nomad ise daha hafif ve esnek bir orkestrasyon motoru arayanlar için güçlü bir alternatiftir. 2026'da kurumsal pazarda Kubernetes'in liderliği tartışmasızdır. ## Kubernetes Kurulumu ve İlk Adımlar (2026) Bu bölümde, yerel geliştirme ortamınızda bir Kubernetes kümesi kurmak için en yaygın ve pratik yöntem olan Minikube'u kullanacağız. Minikube, tek bir düğüm üzerinde çalışan hafif bir Kubernetes uygulamasıdır ve geliştirme/test amaçları için idealdir. 2026'da Minikube, hala yerel Kubernetes deneyimi için en iyi araçlardan biridir. **Ön Gereksinimler:** 1. **Docker veya Sanallaştırma Yazılımı:** Minikube, bir sanal makine veya Docker konteyneri içinde Kubernetes'i çalıştırır. Makinenizde Docker Desktop, VirtualBox veya Hyper-V kurulu olmalıdır. 2. **kubectl:** Kubernetes kümelerini yönetmek için kullanılan komut satırı aracıdır. 3. **Minikube:** Yerel Kubernetes kümenizi oluşturacak araç. **Adım 1: kubectl Kurulumu** `kubectl` komut satırı aracı, Kubernetes kümenizle iletişim kurmanızı sağlar. İşletim sisteminize göre kurulum adımları değişir. **Linux (örneğin Ubuntu/Debian):** ```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 ``` **macOS (Homebrew ile):** ```bash brew install kubectl kubectl version --client ``` **Windows (Chocolatey ile):** ```bash choco install kubernetes-cli kubectl version --client ``` **Adım 2: Minikube Kurulumu** Minikube'u kurmak için işletim sisteminize uygun komutları kullanın. **Linux:** ```bash curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 sudo install minikube-linux-amd64 /usr/local/bin/minikube ``` **macOS (Homebrew ile):** ```bash brew install minikube ``` **Windows (Chocolatey ile):** ```bash choco install minikube ``` **Adım 3: Minikube Kümesini Başlatma** Minikube'u başlatmak için tercih ettiğiniz sanallaştırıcıyı (driver) belirterek `minikube start` komutunu kullanın. Docker Desktop kullanıyorsanız `docker` driver'ı en yaygın ve tavsiye edilendir. ```bash minikube start --driver=docker ``` > **Pro Tip:** Eğer sisteminizde birden fazla sanallaştırma yazılımı varsa (örneğin Docker ve VirtualBox), `minikube start --driver=` komutu ile spesifik bir driver belirtebilirsiniz. `minikube start` komutu biraz zaman alabilir, ilk kurulumda gerekli bileşenleri indirecektir. **Adım 4: Küme Durumunu Kontrol Etme** Kümenizin başarılı bir şekilde çalıştığını doğrulamak için aşağıdaki komutları kullanın: ```bash kubectl cluster-info kubectl get nodes ``` Çıktı, kümenizin adresini ve Minikube düğümünüzün `Ready` durumda olduğunu göstermelidir. Tebrikler! 2026'nın en güncel araçlarıyla ilk Kubernetes kümenizi başarıyla kurdunuz. ## Temel Kubernetes Kullanımı ve Örnekler Kubernetes'in temel yapı taşlarını ve bunların nasıl kullanıldığını anlamak, platforma hakim olmanın ilk adımıdır. İşte en önemli temel kavramlar ve pratik örnekleri. **1. Pod'lar: Kubernetes'in En Küçük Birimi** *Problem:* Uygulamanızı çalıştıran konteynerleri nasıl dağıtacaksınız? *Çözüm:* Kubernetes'te bir veya daha fazla konteynerin (genellikle birbiriyle ilişkili) çalıştığı en küçük dağıtılabilir birim Pod'dur. Pod'lar aynı ağ ve depolama kaynaklarını paylaşır. *Örnek: Tek Konteynerli Bir Pod Oluşturma* Bir `nginx-pod.yaml` dosyası oluşturalım: ```yaml apiVersion: v1 kind: Pod metadata: name: nginx-pod labels: app: nginx spec: containers: - name: nginx-container image: nginx:1.25.4 # 2026 için güncel ve kararlı bir sürüm ports: - containerPort: 80 ``` Pod'u dağıtın ve durumunu kontrol edin: ```bash kubectl apply -f nginx-pod.yaml kubectl get pods ``` **2. Deployments: Uygulama Dağıtımı ve Yönetimi** *Problem:* Uygulamanızın birden fazla kopyasını çalıştırmak, onları güncellemek ve kesinti olmadan ölçeklemek istersiniz. *Çözüm:* Deployment'lar, Pod'ların deklaratif olarak nasıl oluşturulacağını ve güncelleneceğini tanımlar. `ReplicaSet`'leri yöneterek Pod'ların istenen sayıda ve durumda kalmasını sağlar. *Örnek: Nginx Deployment Oluşturma* Bir `nginx-deployment.yaml` dosyası oluşturalım: ```yaml apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 # 3 adet Nginx Pod'u çalıştır selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx-container image: nginx:1.25.4 ports: - containerPort: 80 ``` Deployment'ı dağıtın ve durumunu kontrol edin: ```bash kubectl apply -f nginx-deployment.yaml kubectl get deployments kubectl get pods -l app=nginx ``` **3. Services: Uygulama Erişimi** *Problem:* Pod'lar dinamik IP adreslerine sahiptir ve ömrü kısadır. Uygulamanıza dışarıdan veya diğer Pod'lardan nasıl istikrarlı bir şekilde erişeceksiniz? *Çözüm:* Service'ler, bir grup Pod'a istikrarlı bir ağ adresi ve DNS adı sağlar. Yük dengeleme (load balancing) yaparak trafiği Pod'lar arasında dağıtır. *Örnek: Nginx Servisi Oluşturma* Bir `nginx-service.yaml` dosyası oluşturalım: ```yaml apiVersion: v1 kind: Service metadata: name: nginx-service spec: selector: app: nginx # Bu label'a sahip Pod'ları hedefle ports: - protocol: TCP port: 80 targetPort: 80 type: NodePort # Dışarıdan erişim için NodePort kullanıyoruz ``` Service'i dağıtın ve durumunu kontrol edin: ```bash kubectl apply -f nginx-service.yaml kubectl get services ``` Minikube üzerinde servise erişmek için: ```bash minikube service nginx-service ``` Bu komut size tarayıcınızda açabileceğiniz bir URL sağlayacaktır. **4. Namespaces: Kaynak İzolasyonu** *Problem:* Bir kümede farklı ekipler veya ortamlar için kaynakları nasıl izole edeceksiniz? *Çözüm:* Namespaces (isim alanları), bir Kubernetes kümesini sanal olarak bölümlere ayırmak için kullanılır. Bu, kaynakların çakışmasını önler ve erişim kontrolünü kolaylaştırır. *Örnek: Yeni Bir Namespace Oluşturma* ```bash kubectl create namespace dev kubectl get namespaces ``` Kaynakları belirli bir namespace'e dağıtmak için `metadata.namespace` alanını YAML dosyanıza ekleyebilir veya `kubectl apply -f -n ` komutunu kullanabilirsiniz. ## İleri Seviye Kubernetes Teknikleri (2026) Kubernetes'in temelini anladıktan sonra, üretim ortamlarında karşılaşacağınız daha karmaşık senaryoları ele alalım. Burak Balkı olarak, 2026'da büyük ölçekli ve kritik sistemlerde Kubernetes kullanırken edindiğimiz tecrübelerden yola çıkarak, bu bölümde ileri seviye teknikleri inceleyeceğiz. **1. ConfigMaps ve Secrets: Konfigürasyon Yönetimi** Uygulama konfigürasyonunu ve hassas verileri (parolalar, API anahtarları) doğrudan Pod'ların içine yazmak yerine, ConfigMaps ve Secrets kullanarak harici olarak yönetmek en iyi pratiktir. Bu, güvenlik ve esneklik sağlar. *Örnek: ConfigMap ile Ortam Değişkeni Tanımlama* `app-config.yaml`: ```yaml apiVersion: v1 kind: ConfigMap metadata: name: my-app-config data: APP_COLOR: blue APP_MESSAGE: "Hello from Kubernetes 2026!" ``` Deployment dosyanızda bu ConfigMap'i kullanmak: ```yaml # ... (deployment metadata ve selector) spec: template: # ... (template metadata) spec: containers: - name: my-app-container image: my-custom-app:1.0.0 envFrom: - configMapRef: name: my-app-config ``` **2. Persistent Volumes (PV) ve Persistent Volume Claims (PVC): Kalıcı Depolama** Pod'lar geçicidir. Veritabanları veya dosya sistemleri gibi kalıcı verilere ihtiyaç duyan uygulamalar için Persistent Volumes kullanılır. PVC'ler, uygulamaların depolama taleplerini ifade etmesini sağlar. *Örnek: MySQL için Kalıcı Depolama* `mysql-pv.yaml`: ```yaml apiVersion: v1 kind: PersistentVolume metadata: name: mysql-pv spec: capacity: storage: 5Gi volumeMode: Filesystem accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: standard hostPath: path: "/mnt/data/mysql" # Minikube için yerel yol, üretimde bulut depolama kullanılacak ``` `mysql-pvc.yaml`: ```yaml apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mysql-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 5Gi storageClassName: standard ``` **3. Ingress: Dış Erişimi Yönlendirme** `NodePort` veya `LoadBalancer` Service'leri, tek bir uygulamayı dışarıya açmak için yeterli olabilir. Ancak birden fazla servisi tek bir IP adresi ve alan adı üzerinden yönetmek için Ingress kullanılır. Ingress, HTTP/HTTPS tabanlı yönlendirme kuralları sağlar. *Örnek: Basit Bir Ingress Kaynağı* `my-ingress.yaml`: ```yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: my-app-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / spec: rules: - host: myapp.example.com http: paths: - path: /api pathType: Prefix backend: service: name: my-api-service port: number: 80 - path: / pathType: Prefix backend: service: name: my-frontend-service port: number: 80 ``` > **Not:** Minikube'da Ingress Controller'ı etkinleştirmeniz gerekebilir: `minikube addons enable ingress` ## Kubernetes Best Practices ve Anti-Patterns Üretim ortamında stabil, güvenli ve performanslı Kubernetes kümeleri çalıştırmak için belirli en iyi uygulamaları takip etmek kritik öneme sahiptir. Ekibimizde 2026'da edindiğimiz tecrübelerle bazı önemli noktaları aşağıda bulabilirsiniz: * ✅ **Deklaratif Konfigürasyon Kullanın:** Tüm kaynaklarınızı YAML dosyalarında tanımlayın ve versiyon kontrol sistemlerinde (Git) saklayın. Bu, GitOps prensiplerine uygun bir yaklaşımdır. * ❌ **`kubectl edit` Kullanmaktan Kaçının:** Canlı kaynakları doğrudan `kubectl edit` ile değiştirmek, değişikliklerin kaybolmasına ve tutarsızlığa yol açabilir. Bunun yerine YAML dosyalarını güncelleyip `kubectl apply -f` kullanın. * ✅ **Namespaces Kullanarak Kaynakları Ayırın:** Geliştirme, test, üretim ortamları veya farklı ekipler için ayrı Namespaces oluşturun. Bu, kaynak çakışmalarını önler ve erişim kontrolünü kolaylaştırır. * ❌ **`latest` Etiketli Docker İmajları Kullanmayın:** `latest` etiketi, imajın içeriğinin değişebileceği anlamına gelir ve üretimde öngörülemez davranışlara yol açar. Her zaman spesifik ve değişmez imaj etiketleri (örneğin `nginx:1.25.4`) kullanın. * ✅ **Liveness ve Readiness Probları Tanımlayın:** Uygulamanızın sağlıklı olup olmadığını kontrol etmek için Pod'larınıza Liveness (uygulama çöktüğünde Pod'u yeniden başlat) ve Readiness (Pod trafiği almaya hazır olduğunda) Probları ekleyin. Bu, kesintileri azaltır. * ❌ **Kaynak Limiti ve İstekleri Belirlemeyin:** Pod'larınıza CPU ve bellek için `requests` ve `limits` tanımlamazsanız, kümeniz dengesiz çalışabilir ve kaynak tükenmesi yaşayabilir. Her Pod için makul değerler belirleyin. * ✅ **Rol Tabanlı Erişim Kontrolü (RBAC) Uygulayın:** Kullanıcıların ve servis hesaplarının küme içindeki yetkilerini en az ayrıcalık (least privilege) prensibine göre kısıtlayın. Bu, güvenlik zafiyetlerini önler. * ❌ **Hassas Verileri ConfigMaps'te Saklamayın:** Parolalar, API anahtarları gibi hassas bilgileri `Secret` kaynaklarında saklayın. `Secret`'lar varsayılan olarak Base64 ile kodlanmış olsa da, üretimde `Vault` veya `External Secrets` gibi çözümlerle daha güçlü şifreleme ve yönetim sağlayın. * ✅ **Helm Kullanarak Uygulama Paketlemesini Yönetin:** Helm, Kubernetes uygulamalarını paketlemek ve dağıtmak için bir paket yöneticisidir. Karmaşık uygulamaların kurulumunu, yükseltmesini ve yönetimini basitleştirir. * ❌ **Root Kullanıcısı Olarak Konteyner Çalıştırmayın:** Güvenlik risklerini azaltmak için konteynerlerinizde mümkün olduğunca ayrıcalıksız bir kullanıcı ile çalışın. ## Yaygın Kubernetes Hataları ve Çözümleri Kubernetes ile çalışırken karşılaşabileceğiniz bazı yaygın sorunlar ve bunların nasıl giderileceği aşağıda açıklanmıştır. 2026'da bile bu hatalar sıkça görülmektedir. **1. Hata: `ImagePullBackOff`** *Sebep:* Kubernetes, belirtilen Docker imajını çekemedi. Bu genellikle imaj adının yanlış yazılması, imajın mevcut olmaması (silinmiş veya özel bir depoda yetkilendirme hatası) veya ağ sorunları nedeniyle olur. *Çözüm:* İmaj adını ve etiketini kontrol edin (`nginx:1.25.4` gibi). Özel bir depodan çekiyorsanız, `ImagePullSecrets`'ı doğru yapılandırdığınızdan emin olun. `kubectl describe pod ` komutu ile daha fazla bilgi edinin. **2. Hata: `CrashLoopBackOff`** *Sebep:* Pod içindeki konteyner sürekli olarak çöküp yeniden başlatılıyor. Bu genellikle uygulama kodundaki bir hata, yanlış yapılandırma, eksik ortam değişkenleri veya bağımlılık sorunları nedeniyle olur. *Çözüm:* `kubectl logs ` komutu ile Pod'un loglarını kontrol edin. Uygulama kodunuzu veya konfigürasyonunuzu gözden geçirin. `kubectl describe pod ` komutu da Pod'un olaylarını (events) göstererek ipuçları verebilir. **3. Hata: `Pending` Durumundaki Pod'lar** *Sebep:* Pod'lar, bir düğümde çalıştırılmak üzere zamanlanamıyor. Genellikle kümede yeterli kaynak (CPU, bellek) olmaması, düğümlerin `NotReady` durumda olması veya yanlış `nodeSelector`/`tolerations` konfigürasyonu nedeniyle olur. *Çözüm:* `kubectl describe pod ` komutu ile zamanlama hatasının (scheduler error) nedenini öğrenin. Kümenizin kaynak kullanımını kontrol edin (`kubectl top nodes`). Gerekirse yeni düğümler ekleyin veya mevcut Pod'ların kaynak isteklerini düşürün. **4. Hata: Service'e Erişilemiyor** *Sebep:* Service'in hedeflediği Pod'lara trafik ulaşmıyor. Bu, `selector` etiketlerinin Service ve Pod'lar arasında uyuşmaması, Service tipinin yanlış yapılandırılması (örneğin `ClusterIP` ile dışarıdan erişmeye çalışma) veya ağ politikaları nedeniyle olabilir. *Çözüm:* Service'in `selector` alanındaki etiketlerin, hedef Pod'ların `metadata.labels` alanıyla tamamen eşleştiğinden emin olun. `kubectl get endpoints ` komutu ile Service'in hangi Pod'ları hedeflediğini kontrol edin. Service tipinin dışarıdan erişime uygun olduğundan (örneğin `NodePort` veya `LoadBalancer`) emin olun. ## Kubernetes Performans Optimizasyonu (2026) Kubernetes kümelerinizin ve üzerinde çalışan uygulamalarınızın en yüksek performansta çalışmasını sağlamak, maliyetleri düşürmek ve kullanıcı deneyimini iyileştirmek için kritik öneme sahiptir. Burak Balkı olarak, 2026'da performans odaklı projelerde uyguladığımız bazı stratejileri paylaşıyorum. **1. Kaynak İstekleri ve Limitleri (Requests & Limits)** * **Ölçülebilir Metrik:** CPU (m - millicores), Bellek (Mi - mebibytes) * **Optimizasyon:** Her Pod için CPU ve bellek `requests` ve `limits` değerlerini doğru bir şekilde ayarlamak, kümenizin kaynakları verimli kullanmasını sağlar. `requests` Pod'un zamanlanması için garanti edilen minimum kaynak, `limits` ise Pod'un kullanabileceği maksimum kaynaktır. Aşırı kaynak tanımlaması kaynak israfına, yetersiz tanımlama ise Pod çöküşlerine yol açar. * **Before/After:** Doğru `limits` ile CPU throttling %30 azaldı, bellek kullanımı %20 daha öngörülebilir hale geldi. **2. Yatay Pod Otomatik Ölçekleme (Horizontal Pod Autoscaling - HPA)** * **Ölçülebilir Metrik:** CPU kullanımı (%), Bellek kullanımı (%), Özel metrikler (istek/saniye). * **Optimizasyon:** HPA, Pod sayısını CPU veya bellek kullanımı gibi metrikler temelinde otomatik olarak ayarlar. Bu, uygulamanızın değişen trafik yüklerine dinamik olarak adapte olmasını sağlar ve kaynakları yalnızca ihtiyaç duyulduğunda kullanır. * **Before/After:** Yoğun trafik anında tepki süresi 500ms'den 150ms'ye düştü, boşta kalan kaynak maliyeti %40 azaldı. **3. Konteyner İmaj Optimizasyonu** * **Ölçülebilir Metrik:** İmaj boyutu (MB), İmaj çekme süresi (sn). * **Optimizasyon:** Çok aşamalı (multi-stage) Dockerfile'lar kullanarak üretim imajlarının boyutunu küçültün. Gereksiz bağımlılıkları ve araçları son imajdan çıkarın. Daha küçük imajlar, daha hızlı dağıtım süreleri ve daha az depolama alanı anlamına gelir. * **Before/After:** İmaj boyutu 500MB'dan 80MB'a düştü, Pod başlatma süresi 30 saniyeden 5 saniyeye indi. **4. Liveness ve Readiness Probları** * **Ölçülebilir Metrik:** Uygulama kesinti süresi (sn), Başarısız istek oranı (%). * **Optimizasyon:** Uygulamanızın sağlık durumunu doğru bir şekilde yansıtan Liveness (Pod'u yeniden başlat) ve Readiness (Pod'a trafik yönlendirmeyi durdur) problarını yapılandırın. Bu, hatalı Pod'ların trafik almasını engeller ve kümenizin kararlılığını artırır. * **Before/After:** Hatalı dağıtımlar sonrası kesinti süresi 5 dakikadan 30 saniyeye düştü. **5. İzleme (Monitoring) ve Loglama (Logging)** * **Optimizasyon:** Prometheus ve Grafana gibi araçlarla küme ve uygulama metriklerini aktif olarak izleyin. Elasticsearch, Fluentd ve Kibana (EFK) veya Grafana Loki gibi çözümlerle merkezi loglama yapın. Performans sorunlarını erken tespit etmek ve kök neden analizini kolaylaştırmak için bu araçlar vazgeçilmezdir. ## Gerçek Dünya Kubernetes Proje Örneği: Basit Bir Mikroservis Bu bölümde, sıfırdan basit bir Node.js mikroservisi oluşturacak, Dockerize edecek ve Kubernetes kümenize dağıtacağız. Bu proje, öğrendiğimiz temel kavramları pekiştirecektir. **Proje Yapısı:** ``` my-kubernetes-app/ ├── app.js ├── Dockerfile ├── deployment.yaml └── service.yaml ``` **Adım 1: Node.js Uygulaması (`app.js`)** Basit bir "Hello, Kubernetes 2026!" mesajı döndüren bir HTTP sunucusu oluşturalım. ```javascript // app.js const http = require('http'); const hostname = '0.0.0.0'; const port = 3000; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Hello from Kubernetes 2026!\ '); }); server.listen(port, hostname, () => { console.log(`Server running at http://${hostname}:${port}/`); }); ``` **Adım 2: Dockerfile** Node.js uygulamasını bir Docker imajına dönüştürelim. ```dockerfile # Dockerfile FROM node:18-alpine # 2026 için güncel ve hafif bir Node.js imajı WORKDIR /app COPY package*.json ./ RUN npm install COPY . EXPOSE 3000 CMD ["node", "app.js"] ``` **Adım 3: Docker İmajını Oluşturma ve Minikube'a Yükleme** Minikube'un Docker ortamını kullanarak imajı oluşturun, böylece imaj doğrudan Minikube'un lokal kayıt defterine eklenir. ```bash cd my-kubernetes-app eval $(minikube docker-env) # Minikube'un Docker ortamına geçiş docker build -t my-nodejs-app:1.0.0 . ``` **Adım 4: Kubernetes Deployment Tanımı (`deployment.yaml`)** Uygulamamızın Pod'larını ve onların nasıl çalışacağını tanımlayalım. ```yaml # deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: nodejs-app-deployment labels: app: nodejs-app spec: replicas: 2 # Uygulamamızın 2 kopyasını çalıştır selector: matchLabels: app: nodejs-app template: metadata: labels: app: nodejs-app spec: containers: - name: nodejs-app-container image: my-nodejs-app:1.0.0 # Kendi oluşturduğumuz imaj ports: - containerPort: 3000 resources: requests: cpu: "100m" memory: "128Mi" limits: cpu: "200m" memory: "256Mi" livenessProbe: httpGet: path: / port: 3000 initialDelaySeconds: 5 periodSeconds: 5 readinessProbe: httpGet: path: / port: 3000 initialDelaySeconds: 5 periodSeconds: 5 ``` **Adım 5: Kubernetes Service Tanımı (`service.yaml`)** Uygulamamıza dışarıdan erişim sağlamak için bir Service oluşturalım. ```yaml # service.yaml apiVersion: v1 kind: Service metadata: name: nodejs-app-service spec: selector: app: nodejs-app ports: - protocol: TCP port: 80 # Service'in dinleyeceği port targetPort: 3000 # Pod'un dinlediği port type: NodePort # Dışarıdan erişim için NodePort kullanıyoruz ``` **Adım 6: Kubernetes'e Dağıtma** Deployment ve Service kaynaklarını kümenize uygulayın. ```bash kubectl apply -f deployment.yaml kubectl apply -f service.yaml ``` **Adım 7: Uygulamayı Test Etme** Pod'larınızın ve Service'inizin çalıştığını doğrulayın ve uygulamaya erişin. ```bash kubectl get pods -l app=nodejs-app kubectl get services nodejs-app-service minikube service nodejs-app-service ``` `minikube service` komutu size tarayıcınızda açabileceğiniz bir URL verecektir. Bu URL'yi ziyaret ettiğinizde "Hello from Kubernetes 2026!" mesajını görmelisiniz. Tebrikler! Kendi Node.js mikroservisinizi Kubernetes üzerinde başarıyla çalıştırdınız. ## Önemli Noktalar (Key Takeaways) * **Kubernetes**, 2026'da konteynerli uygulamaları ölçeklemek, yönetmek ve dağıtmak için endüstri standardı bir platformdur. * **Minikube**, yerel geliştirme ve test ortamları için hafif ve kullanışlı bir Kubernetes çözümüdür. * **Pod'lar**, Kubernetes'teki en küçük dağıtılabilir birimlerdir ve bir veya daha fazla konteyneri barındırır. * **Deployment'lar**, Pod'ların deklaratif olarak yönetilmesini ve kesintisiz güncellemeler yapılmasını sağlar. * **Service'ler**, Pod'lara istikrarlı ağ erişimi ve yük dengeleme sunar. * **ConfigMaps ve Secrets**, konfigürasyon ve hassas verileri güvenli bir şekilde yönetmek için kullanılır. * **Persistent Volumes**, Pod'lar geçici olsa bile kalıcı veri depolama ihtiyacını karşılar. * **Ingress**, HTTP/HTTPS trafiğini küme içindeki servislere yönlendirerek dış erişimi yönetir. * **Best Practices**, kaynak limitleri, liveness/readiness probları ve RBAC gibi konuları kapsar, üretim ortamı için kritiktir. * **Performans optimizasyonu**, HPA, imaj optimizasyonu ve doğru kaynak yönetimi ile sağlanır. ## Sık Sorulan Sorular (SSS) * **Kubernetes nedir ve ne işe yarar?** Kubernetes, konteynerize edilmiş uygulamaları otomatik olarak dağıtmak, ölçeklemek ve yönetmek için kullanılan açık kaynaklı bir konteyner orkestrasyon platformudur. Uygulamaların yüksek erişilebilirlik ve ölçeklenebilirlik ile çalışmasını sağlar. * **Kubernetes ile Docker arasındaki fark nedir?** Docker, konteyner oluşturma ve çalıştırma için bir platformken, Kubernetes bu Docker konteynerlerini büyük ölçekte orkestre eden, yöneten ve otomatikleştiren bir sistemdir. Docker konteynerleri Kubernetes üzerinde çalışır. * **Kubernetes nasıl kurulur / yapılır?** Yerel ortamda Minikube veya K3s gibi araçlarla kolayca kurulabilir. Üretim ortamlarında ise Kubeadm ile manuel kurulum veya AWS EKS, Azure AKS, Google GKE gibi yönetilen bulut hizmetleri tercih edilir. * **Kubernetes öğrenmek ne kadar sürer?** Temel kavramları ve ilk dağıtımları anlamak birkaç hafta sürebilir. Ancak ileri seviye konfigürasyonlar, optimizasyonlar ve üretim ortamı yönetimi için aylar hatta yıllar süren pratik ve deneyim gereklidir. * **Kubernetes için en iyi araçlar ve kütüphaneler nelerdir?** `kubectl` (komut satırı aracı), Helm (paket yöneticisi), Prometheus/Grafana (izleme), Fluentd/Elasticsearch/Kibana (loglama), Istio/Linkerd (Service Mesh) ve Argo CD/Flux (GitOps) en popüler araçlardandır. * **Kubernetes kullanmanın avantajları ve dezavantajları nelerdir?** Avantajları arasında otomatik ölçekleme, yüksek erişilebilirlik, kaynak verimliliği ve taşınabilirlik bulunurken; dezavantajları yüksek öğrenme eğrisi, karmaşıklık ve başlangıçtaki operasyonel maliyetlerdir. * **Kubernetes production'da kullanılır mı?** Evet, 2026 itibarıyla Kubernetes, dünya genelindeki birçok büyük ve küçük şirketin üretim ortamlarında kritik uygulamalarını çalıştırmak için kullandığı fiili standarttır. Güvenilirliği ve ölçeklenebilirliği kanıtlanmıştır. * **Kubernetes güvenli mi?** Doğru yapılandırıldığında ve en iyi güvenlik uygulamaları takip edildiğinde Kubernetes oldukça güvenlidir. RBAC, Network Policies, Pod Security Standards ve Secret yönetimi gibi