Giriş

Kubernetes (K8s), konteyner tabanlı uygulamaların otomatik dağıtımı, ölçeklendirilmesi ve yönetimini sağlayan açık kaynaklı bir platformdur. Google tarafından geliştirilen ve sonrasında Cloud Native Computing Foundation’a (CNCF) devredilen Kubernetes, modern mikroservis mimarilerinin vazgeçilmez bir parçası haline gelmiştir.

Günümüzde kurumlar, yüksek erişilebilirlik, ölçeklenebilirlik ve esneklik ihtiyaçlarını karşılamak için Kubernetes’i tercih etmektedir. Dağıtık sistemlerin karmaşıklığını yönetilebilir hale getiren Kubernetes, uygulama dağıtımı ve operasyonlarını otomatikleştirerek DevOps ekiplerinin iş yükünü önemli ölçüde azaltır.

Kubernetes’in genel mimarisi, bir dizi bileşenin koordineli şekilde çalışmasına dayanır. Bu yazıda, Kubernetes’in temel yapı taşları olan kümeler (clusters), podlar (pods) ve nodelar (nodes) hakkında detaylı bilgi sunacak ve bunların birbirleriyle nasıl etkileşime girdiğini inceleyeceğiz.

Kümeler (Clusters)

Kubernetes kümeleri, platformun üzerinde çalıştığı fiziksel veya sanal makinelerin mantıksal bir grubudur. Bir Kubernetes kümesi, birbirine bağlı en az bir kontrol düzlemi (control plane) ve bir veya daha fazla çalışan düğümden (worker node) oluşur.

Kontrol Düzlemi Bileşenleri

Kontrol düzlemi, kümenin beyni olarak düşünülebilir ve aşağıdaki bileşenlerden oluşur:

1. kube-apiserver: Kubernetes API’sini sunar ve küme ile tüm iletişimin geçiş noktasıdır.
2. etcd: Küme yapılandırmasını ve durumunu tutan yüksek erişilebilirlikli anahtar-değer veritabanıdır.
3. kube-scheduler: Yeni oluşturulan podları uygun worker node’lara atamaktan sorumludur.
4. kube-controller-manager: Çeşitli denetleyicileri çalıştırır ve kümenin durumunu istenen duruma getirmeye çalışır.
5. cloud-controller-manager: Bulut sağlayıcıları ile etkileşim kuran bileşendir.

Worker Node Bileşenleri

Worker node’lar, podların çalıştığı makinelerdir ve şu bileşenleri içerir:

1. kubelet: Node üzerinde çalışan ve konteyner runtime’ı ile iletişim kurarak podların çalışmasını sağlayan ajanttır.
2. kube-proxy: Kubernetes servis soyutlamasını gerçekleştiren ağ proxy’sidir.
3. Container Runtime: Konteynerleri çalıştıran Docker, containerd veya CRI-O gibi yazılımlardır.

Kümelerin yönetiminde, kubectl komut satırı aracı yaygın olarak kullanılır. Bu araç, kube-apiserver ile iletişim kurarak küme üzerindeki işlemleri gerçekleştirir.

# Küme bilgilerini görüntüleme
kubectl cluster-info

# Node'ları listeleme
kubectl get nodes

# Tüm namespace'lerdeki kaynakları görüntüleme
kubectl get all --all-namespaces

Podlar (Pods)

Pod, Kubernetes’te en küçük ve temel dağıtım birimidir. Pod, bir veya daha fazla konteyneri ve bu konteynerlerin paylaştığı kaynakları içerir. Aynı pod içindeki konteynerler aynı ağ alanını (network namespace) ve depolama birimlerini paylaşır.

Pod Özellikleri

• Atomik Dağıtım: Bir pod, her zaman tek bir birim olarak dağıtılır ve ölçeklendirilir.
• Paylaşılan Kaynaklar: Pod içindeki konteynerler aynı IP adresini paylaşır ve localhost üzerinden birbirleriyle iletişim kurabilir.
• Ortak Yaşam Döngüsü: Pod içindeki konteynerler birlikte yaşar ve ölür.

Pod Yapılandırması

Podlar genellikle YAML dosyaları kullanılarak tanımlanır:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80
  - name: log-collector
    image: fluentd:latest

Bu örnekte, nginx-pod adlı bir pod içinde bir nginx web sunucusu ve bir log toplayıcı (fluentd) konteyneri tanımlanmıştır.

Pod Yaşam Döngüsü

Podların yaşam döngüsü şu aşamalardan geçer:

1. Pending: Pod oluşturuldu ancak henüz node’a atanmadı veya konteyner imajları çekilmedi.
2. Running: Pod node’a atandı ve tüm konteynerler çalışıyor.
3. Succeeded: Pod’daki tüm konteynerler başarıyla tamamlandı.
4. Failed: Pod’daki en az bir konteyner başarısız oldu.
5. Unknown: Pod’un durumu belirlenemedi.

Podları yönetmek için çeşitli komutlar kullanılır:

# Pod oluşturma
kubectl apply -f pod-definition.yaml

# Podları listeleme
kubectl get pods

# Pod detaylarını görüntüleme
kubectl describe pod nginx-pod

# Pod loglarını görüntüleme
kubectl logs nginx-pod -c nginx

# Pod silme
kubectl delete pod nginx-pod

Nodelar (Nodes)

Node’lar, Kubernetes kümesindeki çalışan makinelerdir. Fiziksel veya sanal sunucular olabilirler ve pod’ların çalıştığı altyapıyı sağlarlar.

Node Bileşenleri

1. Kubelet: Kubernetes kontrol düzlemi ile iletişim kuran ve pod’ların çalışmasını sağlayan temel ajanttır.
2. Kube-proxy: Pod’lar arasında ağ trafiğini yönlendiren ağ proxy’sidir.
3. Container Runtime: Konteynerleri çalıştıran Docker, containerd veya CRI-O gibi yazılımlardır.

Node Durumu

Node’ların durumu, kullanılabilirliklerini ve sağlık durumlarını yansıtır:

• Ready: Node hazır ve pod’ları kabul edebilir.
• NotReady: Node hazır değil, pod’ları kabul edemez.
• SchedulingDisabled: Node üzerine yeni pod’lar planlanamaz.

Node Yönetimi

Node’ları yönetmek için çeşitli komutlar kullanılır:

# Node'ları listeleme
kubectl get nodes

# Node detaylarını görüntüleme
kubectl describe node node-name

# Node'u bakım moduna alma
kubectl drain node-name

# Node'u tamamen devre dışı bırakma
kubectl cordon node-name

# Node'u tekrar etkinleştirme
kubectl uncordon node-name

Pod Dağıtımı ve Node İlişkisi

Kubernetes, pod’ları node’lara dağıtırken çeşitli faktörleri göz önünde bulundurur:

• Kaynak Gereksinimleri: Pod’un CPU, bellek gibi kaynak talepleri.
• Node Seçiciler: Pod’un çalışabileceği node’ları belirten etiketler.
• Taints ve Tolerations: Node’ların belirli pod’ları kabul edip etmeyeceğini belirleyen mekanizmalar.
• Affinity ve Anti-Affinity: Pod’ların birbirine yakın veya uzak konumlandırılmasını sağlayan kurallar.

Örnek Senaryo: Üç Katmanlı Uygulama Dağıtımı

Şimdi, bu kavramları bir araya getirerek basit bir üç katmanlı web uygulamasını Kubernetes’te nasıl dağıtabileceğimizi görelim:

1. Frontend (Web Arayüzü)
2. Backend (API Servisi)
3. Database (Veritabanı)

Adım 1: Namespace Oluşturma

kubectl create namespace three-tier-app

Adım 2: Veritabanı Dağıtımı

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: three-tier-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:13
        env:
        - name: POSTGRES_PASSWORD
          value: "mypassword"
        ports:
        - containerPort: 5432
---
apiVersion: v1
kind: Service
metadata:
  name: postgres
  namespace: three-tier-app
spec:
  selector:
    app: postgres
  ports:
  - port: 5432
    targetPort: 5432
  type: ClusterIP

Adım 3: Backend API Dağıtımı

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  namespace: three-tier-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: backend
        image: mybackend:latest
        env:
        - name: DB_HOST
          value: "postgres"
        - name: DB_PASSWORD
          value: "mypassword"
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: backend
  namespace: three-tier-app
spec:
  selector:
    app: backend
  ports:
  - port: 8080
    targetPort: 8080
  type: ClusterIP

Adım 4: Frontend Dağıtımı

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: three-tier-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: myfrontend:latest
        env:
        - name: API_URL
          value: "http://backend:8080"
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: frontend
  namespace: three-tier-app
spec:
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

Adım 5: Dağıtımı Uygulama

kubectl apply -f postgres.yaml
kubectl apply -f backend.yaml
kubectl apply -f frontend.yaml

Bu senaryoda:

1. Üç ayrı deployment oluşturduk: PostgreSQL veritabanı, backend API ve frontend.
2. Her bir deployment için servisler tanımladık.
3. Veritabanı ve backend için ClusterIP tipi servis, frontend için ise LoadBalancer tipi servis kullandık.
4. Backend pod’ları veritabanına, frontend pod’ları ise backend servisine bağlanabilir.

Bu yapılandırma ile:

• Kubernetes, her bir pod’u uygun node’lara dağıtacaktır.
• ReplicaSet kontrolörleri, belirtilen sayıda pod’un çalışır durumda olmasını sağlayacaktır.
• Servisler, pod’lar arasında istikrarlı iletişim sağlayacaktır.
• LoadBalancer, frontend servisine dış erişim imkanı tanıyacaktır.

Sonuç

Bu yazıda, Kubernetes’in temel yapı taşları olan kümeler, podlar ve nodelar hakkında detaylı bilgi edindik. Kubernetes’in bu temel bileşenleri, modern uygulamaların dağıtımı, ölçeklendirilmesi ve yönetimi için güçlü bir altyapı sunar.

Özetlemek gerekirse:

• Kümeler (Clusters), Kubernetes’in çalıştığı fiziksel veya sanal makinelerin mantıksal bir grubudur.
• Podlar (Pods), Kubernetes’te en küçük dağıtım birimidir ve bir veya daha fazla konteyneri barındırır.
• Nodelar (Nodes), pod’ların çalıştığı fiziksel veya sanal makinelerdir.

İleri Okuma Kaynakları

1. Kubernetes Resmi Dokümantasyonu
2. Kubernetes: Up and Running – Kelsey Hightower, Brendan Burns ve Joe Beda
3. Kubernetes Patterns – Bilgin İbryam ve Roland Huß
4. Kubernetes The Hard Way – Kelsey Hightower