Vagrant ile Çok Düğümlü Kubernetes Kümesi Kurulumu

Dağıtık sistemlerin geleceği Kubernetes ile karmaşık uygulamaları yönetmek artık daha kolay! Vagrant kullanarak kendi yerel çok düğümlü Kubernetes kümenizi adım adım nasıl kuracağınızı öğrenin. Bu kapsamlı rehber, sanal ortamda güçlü bir geliştirme altyapısı oluşturmanıza yardımcı olacak.

Günümüzün hızla değişen teknoloji dünyasında, uygulamaların esnek, ölçeklenebilir ve güvenilir olması her zamankinden daha kritik. Mikroservis mimarileri ve konteynerleşme, bu gereksinimleri karşılamak için standart haline gelmiş durumda. İşte tam bu noktada, konteynerleştirilmiş iş yüklerini otomatize etmek, dağıtmak ve yönetmek için tasarlanmış açık kaynaklı bir sistem olan Kubernetes devreye giriyor. Ancak Kubernetes’i gerçek bir ortamda denemek, öğrenmek veya geliştirmek çoğu zaman zorlu ve kaynak yoğun bir süreç olabilir. Bulut sağlayıcıları üzerinde bir küme kurmak maliyetli olabilirken, yerel bir ortamda çok düğümlü bir küme oluşturmak da karmaşık ağ ve sanallaştırma bilgisi gerektirebilir. Peki, bu zorlukları aşarak, hem uygun maliyetli hem de pratik bir şekilde kendi çok düğümlü Kubernetes kümenizi nasıl kurabilirsiniz?

Bu makale, bu sorunun cevabını Vagrant ile veriyor. Vagrant, sanal makine ortamlarını kolayca oluşturmanızı ve yönetmenizi sağlayan bir araçtır. Geliştiricilerin “makinemde çalışıyor” sorununu ortadan kaldırmayı hedefler ve her ekip üyesi için aynı geliştirme ortamını garantiler. Vagrant’ın gücünü Kubernetes ile birleştirdiğimizde, kendi yerel makinenizde gerçek bir çok düğümlü Kubernetes kümesi simüle edebiliriz. Bu, yalnızca bir eğitim aracı olmakla kalmaz, aynı zamanda üretim ortamına deploy edeceğiniz uygulamaları yerel olarak test etmenizi, CI/CD pipeline’larını geliştirmenizi ve dağıtık sistem mimarilerini derinlemesine anlamanızı sağlayan paha biçilmez bir geliştirme ortamı sunar.

Özellikle DevOps mühendisleri, yazılım geliştiriciler ve sistem yöneticileri için, bu kurulum yöntemi birçok avantaj sağlar. Öncelikle, bulut tabanlı bir küme kullanmanın getirdiği maliyetlerden kaçınmış olursunuz. İkinci olarak, internet bağlantısına bağımlı kalmadan istediğiniz zaman ve istediğiniz yerde kümenizle çalışabilirsiniz. Üçüncüsü, üretim ortamına benzer bir ortamda uygulama geliştirme ve test etme imkanı, potansiyel sorunları erken aşamada tespit etmenize yardımcı olur. Bu rehberde, adım adım ilerleyerek, Vagrant ve VirtualBox kullanarak temel bir Kubernetes kümesinin nasıl oluşturulacağını, yapılandırılacağını ve yönetileceğini öğreneceksiniz. Hazırsanız, konteyner orkestrasyonunun büyülü dünyasına Vagrant ile birlikte dalalım!

Temel Kavramlara Giriş: Vagrant ve Kubernetes Nedir?

Başlamadan önce, bu rehberde kullanacağımız iki ana teknoloji olan Vagrant ve Kubernetes’in temel prensiplerini anlamak önemlidir. Bu bilgiler, yapacağımız adımların ardındaki mantığı kavramanıza yardımcı olacak ve olası sorun giderme süreçlerinde size yol gösterecektir.

Vagrant Nedir ve Neden Kullanılır?

Vagrant, HashiCorp tarafından geliştirilen, sanal ortamları tek tip bir iş akışıyla oluşturmak ve yönetmek için kullanılan bir açık kaynaklı araçtır. Temel amacı, geliştiricilerin farklı işletim sistemleri ve altyapılar arasında tutarlı geliştirme ortamları kurmasını sağlamaktır. Vagrant, VirtualBox, VMWare, Hyper-V gibi çeşitli sanallaştırma sağlayıcılarıyla entegre olabilir. Biz bu rehberde ücretsiz ve açık kaynaklı olması nedeniyle VirtualBox’ı kullanacağız.

Vagrant’ın sağladığı temel faydalar şunlardır:

Tutarlılık: Ekip üyeleri arasında aynı geliştirme ortamının kullanılmasını sağlar, “benim makinemde çalışıyor” sorununu ortadan kaldırır.
Kolaylık: Bir Vagrantfile kullanarak sanal makineleri (VM’leri) kolayca tanımlar ve tek bir komutla (vagrant up) başlatır.
Taşınabilirlik: Oluşturulan sanal ortamlar, Vagrantfile sayesinde farklı makinelerde kolayca yeniden üretilebilir.
Otomasyon: Sanal makine kurulumunu, paket yüklemeyi, ağ yapılandırmasını ve diğer sistem ayarlarını otomatikleştirir.

Özetle, Vagrant, karmaşık altyapı senaryolarını, örneğin çok düğümlü bir Kubernetes kümesini, yerel makinenizde kolayca simüle etmenizi sağlayan güçlü bir otomasyon aracıdır.

Kubernetes Nedir ve Temel Bileşenleri Nelerdir?

Kubernetes (genellikle K8s olarak kısaltılır), Google tarafından geliştirilen ve şu anda Cloud Native Computing Foundation (CNCF) tarafından sürdürülen açık kaynaklı bir konteyner orkestrasyon platformudur. Amacı, konteynerleştirilmiş uygulamaların dağıtımını, ölçeklendirilmesini ve yönetimini otomatikleştirmektir. Docker gibi konteyner teknolojileriyle birlikte çalışarak, uygulamalarınızı farklı ortamlar arasında taşınabilir hale getirir.

Bir Kubernetes kümesi, uygulamanızı çalıştıran bir grup düğümden (makineden) oluşur. Bu düğümler iki ana kategoriye ayrılır:

Kontrol Düzlemi (Control Plane / Master Node): Kümenin beynidir. Tüm kararları alır ve kümenin durumunu yönetir. Temel bileşenleri:
- kube-apiserver: Kubernetes API’sini ortaya çıkarır. Küme ile etkileşim kurmak için ana arayüzdür.
- etcd: Küme verilerinin depolandığı, yüksek düzeyde kullanılabilir bir anahtar-değer deposudur.
- kube-scheduler: Yeni oluşturulan Pod’ları hangi düğümlere yerleştireceğine karar verir.
- kube-controller-manager: Çeşitli kontrolörleri çalıştırır (örneğin, düğüm kontrolörü, çoğaltma kontrolörü).
Çalışan Düğümler (Worker Nodes): Kontrol düzlemi tarafından atanan görevleri çalıştıran makinelerdir. Her çalışan düğümde şu bileşenler bulunur:
- kubelet: Her düğümde çalışan bir aracıdır. Kontrol düzleminden gelen talimatları alır ve konteynerleri çalıştırır, Pod’ların durumunu denetler.
- kube-proxy: Küme içindeki ağ kurallarını yönetir ve Pod’lara ağ proxy’si sağlar.
- Konteyner Çalışma Zamanı (Container Runtime): Konteynerleri çalıştıran yazılım (örneğin Docker, containerd, CRI-O).

Bu bileşenlerin uyumlu çalışması sayesinde Kubernetes, uygulamalarınızın yüksek oranda kullanılabilir, ölçeklenebilir ve yönetilebilir olmasını sağlar.

Ön Hazırlık: Sistem Gereksinimleri ve Kurulum Adımları

Çok düğümlü Kubernetes kümemizi Vagrant ile kurmaya başlamadan önce, yerel geliştirme ortamımızın hazır olduğundan emin olmalıyız. Bu bölüm, gerekli yazılımların kurulumu ve sistem gereksinimleri hakkında bilgi verecektir. Başarılı bir kurulum için bu adımları dikkatlice takip etmek önemlidir.

Gerekli Yazılımlar ve Sistem Gereksinimleri

Bu rehber için aşağıdaki yazılımlara ihtiyacımız olacak:

İşletim Sistemi: Linux (Ubuntu, Fedora, CentOS), macOS veya Windows. Bu makaledeki adımlar genel olarak platformdan bağımsız olsa da, shell komutları Linux/macOS ortamlarına daha uygun olacaktır. Windows kullanıcıları WSL2 (Windows Subsystem for Linux 2) ile benzer bir deneyim elde edebilir.
VirtualBox: Sanal makineleri barındırmak için bir sanallaştırma yazılımıdır. Ücretsiz ve açık kaynaklıdır.
Vagrant: Sanal makineleri otomatik olarak yapılandırmak için kullandığımız araçtır.
Git: Depomuzdaki dosyaları kopyalamak için gereklidir (isteğe bağlı, dosyaları manuel indirebilirsiniz).
İnternet Bağlantısı: Vagrant box’larını ve diğer paketleri indirmek için gereklidir.

Donanım Gereksinimleri:

RAM: En az 8 GB RAM (16 GB önerilir). Her sanal makine için belirli bir miktar RAM ayrılacaktır.
CPU: Çok çekirdekli işlemci (en az 2 çekirdek, 4+ önerilir). Sanal makineler işlemci çekirdeklerini paylaşacaktır.
Disk Alanı: En az 40 GB boş disk alanı (60 GB+ önerilir). Sanal diskler ve işletim sistemi kurulumları için yer gereklidir.

Uzman İpucu: Sistem kaynakları ne kadar yüksek olursa, Kubernetes kümeniz o kadar hızlı ve verimli çalışacaktır. Özellikle RAM, VM performansında kritik bir rol oynar.

Kurulum Adımları:

Şimdi yukarıda bahsedilen yazılımları sırasıyla kuralım:

1. VirtualBox Kurulumu

VirtualBox’ı resmi web sitesinden işletim sisteminize uygun sürümünü indirerek kurun. Kurulum adımları genellikle basittir ve varsayılan seçenekleri kabul ederek ilerleyebilirsiniz. Kurulumdan sonra, sisteminizi yeniden başlatmanız gerekebilir.

2. Vagrant Kurulumu

Vagrant’ı resmi web sitesinden işletim sisteminize uygun sürümünü indirerek kurun. Tıpkı VirtualBox gibi, Vagrant’ın kurulumu da genellikle bir yükleyici aracılığıyla basitçe tamamlanır. Kurulumdan sonra bir terminal açın ve aşağıdaki komutu çalıştırarak Vagrant’ın doğru şekilde kurulduğunu doğrulayın:


vagrant --version

Bu komut, Vagrant'ın kurulu sürümünü göstermelidir. Eğer komut bulunamazsa, sisteminizin PATH değişkenini kontrol etmeniz veya Vagrant yükleyicisini tekrar çalıştırmanız gerekebilir.

3. Git Kurulumu (İsteğe Bağlı ama Önerilir)

Git, genellikle birçok sistemde zaten yüklüdür. Yüklü olup olmadığını kontrol etmek için:


git --version

Eğer yüklü değilse, işletim sisteminize göre aşağıdaki komutları kullanabilirsiniz:

Ubuntu/Debian: sudo apt update && sudo apt install git -y
CentOS/RHEL: sudo yum install git -y
macOS: brew install git (Homebrew yüklü değilse brew.sh adresinden kurun)
Windows: Git for Windows adresinden indirin ve kurun.

Bu ön hazırlık adımlarını tamamladıktan sonra, artık Vagrant ve VirtualBox'ın gücünü birleştirerek kendi çok düğümlü Kubernetes kümenizi oluşturmaya hazırsınız. Bir sonraki bölümde, Vagrantfile'ı nasıl yapılandıracağımızı ve küme bileşenlerini nasıl kuracağımızı adım adım inceleyeceğiz.

Uygulamalı Kısım: Vagrant ile Çok Düğümlü Kubernetes Kümesi Nasıl Kurulur?

Şimdi makalemizin en heyecanlı kısmına geldik: Vagrant ile çok düğümlü Kubernetes kümemizi adım adım kuracağız. Bu bölümde, bir Vagrantfile'ı nasıl oluşturacağımızı ve hem master hem de worker düğümleri için gerekli yapılandırma betiklerini nasıl yazacağımızı öğreneceksiniz. Bu kurulumda Ubuntu 20.04 işletim sistemi tabanlı sanal makineler kullanacağız ve Kubernetes'i kubeadm aracıyla bootstrap edeceğiz.

1. Çalışma Dizini Oluşturma

Öncelikle, tüm proje dosyalarımızı içerecek bir dizin oluşturalım ve bu dizine geçiş yapalım:


mkdir kubernetes-vagrant
cd kubernetes-vagrant

2. Vagrantfile Oluşturma

Bu dizin içinde, Vagrant'ın sanal makinelerimizi nasıl oluşturacağını ve yapılandıracağını belirten bir Vagrantfile oluşturacağız. Bu dosya, kümemizin topolojisini, her bir düğümün kaynaklarını (RAM, CPU) ve ağ ayarlarını tanımlayacak. İçine aşağıdaki kodu yapıştırın:


# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  # Sanal makineler için temel box (Ubuntu 20.04)
  config.vm.box = "ubuntu/focal64"
  config.vm.box_check_update = false

  # Ağ ayarları için özel IP aralığı
  # ÖNEMLİ: Bu IP'lerin yerel ağınızda çakışmadığından emin olun.
  private_ip_prefix = "172.16.16"

  # Master düğüm tanımı
  config.vm.define "k8s-master" do |master|
    master.vm.hostname = "k8s-master"
    master.vm.network "private_network", ip: "#{private_ip_prefix}.100"
    master.vm.provider "virtualbox" do |vb|
      vb.memory = "2048" # 2 GB RAM
      vb.cpus = "2"    # 2 CPU çekirdeği
    end
    master.vm.provision "shell", path: "scripts/master_provision.sh", privileged: true
  end

  # Worker düğümler tanımı
  (1..2).each do |i|
    config.vm.define "k8s-worker-#{i}" do |worker|
      worker.vm.hostname = "k8s-worker-#{i}"
      worker.vm.network "private_network", ip: "#{private_ip_prefix}.10#{i}"
      worker.vm.provider "virtualbox" do |vb|
        vb.memory = "1024" # 1 GB RAM
        vb.cpus = "1"    # 1 CPU çekirdeği
      end
      worker.vm.provision "shell", path: "scripts/worker_provision.sh", privileged: true
    end
  end

  # Tüm sanal makineler için ortak ayarlar
  config.vm.synced_folder ".", "/vagrant", disabled: true # Paylaşılan klasörü devre dışı bırak
  config.ssh.insert_key = false # SSH anahtarının otomatik eklenmesini devre dışı bırak
end

Bu Vagrantfile, bir master ve iki worker düğüm olmak üzere toplam üç sanal makine oluşturacaktır. Her düğüme statik bir özel IP adresi atanır ve kaynakları (RAM, CPU) belirtilir. Ayrıca, her düğüm başlatıldığında belirli bir provisioning (hazırlık) betiğini çalıştırır.

3. Provisioning Betikleri Oluşturma

Şimdi, sanal makinelerin içine Kubernetes bileşenlerini kuracak ve yapılandıracak betikleri yazalım. Bunun için scripts adında bir dizin oluşturalım:


mkdir scripts

3.1. Master Düğüm Yapılandırması: Kontrol Düzlemini Hazırlama

scripts/master_provision.sh adında bir dosya oluşturun ve içine aşağıdaki kodu yapıştırın. Bu betik, Kubernetes kontrol düzlemini (master) kurar, Flannel CNI'yi dağıtır ve kubeconfig dosyasını hazırlar.


#!/bin/bash

# Ortak Kubernetes kurulum adımları
echo "Ortak Kubernetes kurulum adımları başlatılıyor..."
sudo apt update -y
sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release

# Google Kubernetes GPG anahtarını ekle
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-archive-keyring.gpg

# Kubernetes apt deposunu ekle
echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list > /dev/null

sudo apt update -y
# Kubernetes bileşenlerini kur (kubelet, kubeadm, kubectl)
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Containerd kurulumu
echo "Containerd kurulumu başlatılıyor..."
sudo apt install -y containerd
sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd

# Swap'ı kapat
echo "Swap kapatılıyor..."
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# Kernel modülleri ve sysctl ayarları
echo "Kernel modülleri ve sysctl ayarları yapılıyor..."
sudo modprobe overlay
sudo modprobe br_netfilter
sudo tee /etc/modules-load.d/containerd.conf < /vagrant/join-command.sh
chmod +x /vagrant/join-command.sh

echo "Kubernetes Master düğümü başarıyla kuruldu ve yapılandırıldı!"

3.2. Worker Düğüm Yapılandırması: Uygulamaları Çalıştırma Katmanı

scripts/worker_provision.sh adında bir dosya oluşturun ve içine aşağıdaki kodu yapıştırın. Bu betik, worker düğümleri Kubernetes kümesine katılacak şekilde yapılandırır.

#!/bin/bash # Ortak Kubernetes kurulum adımları (Master betiğindekiyle aynı) echo "Ortak Kubernetes kurulum adımları başlatılıyor..." sudo apt update -y sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-archive-keyring.gpg echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list > /dev/null sudo apt update -y sudo apt install -y kubelet kubeadm kubectl sudo apt-mark hold kubelet kubeadm kubectl echo "Containerd kurulumu başlatılıyor..." sudo apt install -y containerd sudo mkdir -p /etc/containerd sudo containerd config default | sudo tee /etc/containerd/config.toml sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml sudo systemctl restart containerd sudo systemctl enable containerd echo "Swap kapatılıyor..." sudo swapoff -a sudo sed -i '/ swap / s/^/#/' /etc/fstab echo "Kernel modülleri ve sysctl ayarları yapılıyor..." sudo modprobe overlay sudo modprobe br_netfilter sudo tee /etc/modules-load.d/containerd.conf <

Uzman İpucu: Provisioning betiklerinde yapılan tüm değişiklikler, vagrant reload --provision komutuyla sanal makinelerinizi yeniden başlatıp betikleri tekrar çalıştırmanızı sağlar. Bu, hata ayıklama ve iterasyon için çok kullanışlıdır.

4. Küreyi Başlatma

Tüm Vagrantfile ve provisioning betiklerimiz hazır olduğuna göre, artık tek bir komutla Kubernetes kümemizi başlatabiliriz:


vagrant up

Bu komut, master ve iki worker düğümünü VirtualBox üzerinde oluşturacak, Ubuntu işletim sistemini kuracak ve ardından provisioning betiklerini çalıştıracaktır. Bu işlem, internet bağlantınızın hızına ve makinenizin performansına bağlı olarak biraz zaman alabilir (genellikle 15-30 dakika). Komut satırında ilerlemeyi takip edebilirsiniz.

Kurulum tamamlandığında, master düğümden kubeadm join komutunun çıktısı kubernetes-vagrant dizininizin içine join-command.sh olarak kaydedilecektir. Worker düğümler, bu dosyayı master'dan otomatik olarak alıp küreye katılmak için kullanacaktır. Tüm sanal makineler başlatılıp yapılandırıldığında, kümemiz kullanıma hazır hale gelecektir.

Küme Testi ve Temel Yönetim: Uygulama Dağıtımı ve İzleme

Kümemizi Vagrant aracılığıyla başarıyla başlattıktan sonra, her şeyin beklendiği gibi çalıştığından emin olmak için bazı temel testler yapmamız gerekiyor. Bu bölümde, kümemizin durumunu nasıl kontrol edeceğimizi, basit bir uygulama dağıtarak nasıl test edeceğimizi ve temel Kubernetes yönetim komutlarını inceleyeceğiz.

1. Kubernetes Kümesini Kontrol Etme

Öncelikle, SSH aracılığıyla master düğüme bağlanalım. Bu, Kubernetes kümesiyle etkileşim kurmak için ana yerimiz olacaktır, çünkü kubectl komutu master düğümde yapılandırılmıştır:


vagrant ssh k8s-master

Master düğümün içine girdikten sonra, kümemizin düğümlerini kontrol edebiliriz:


kubectl get nodes

Bu komutun çıktısı, master ve iki worker düğümünüzü "Ready" (Hazır) durumunda göstermelidir. Eğer herhangi bir düğüm "NotReady" durumundaysa, provisioning betiklerinde bir sorun veya ağ yapılandırmasında bir problem olabilir. Genellikle, kısa bir süre beklemek ve komutu tekrar çalıştırmak sorunu çözebilir, çünkü bileşenlerin tamamen başlatılması biraz zaman alabilir.


NAME         STATUS   ROLES           AGE     VERSION
k8s-master   Ready    control-plane   5m      v1.27.3
k8s-worker-1 Ready              4m      v1.27.3
k8s-worker-2 Ready              4m      v1.27.3

Ayrıca, kümenin içindeki tüm pod'ların durumunu kontrol etmek için aşağıdaki komutu kullanabiliriz:


kubectl get pods --all-namespaces

Bu komut, sistem pod'larını (kube-system namespace'inde çalışanlar) ve Flannel gibi CNI pod'larını göstermelidir. Hepsinin "Running" (Çalışıyor) durumunda olması gerekir.

2. Basit Bir Uygulama Dağıtımı

Kümemizin çalıştığını doğruladıktan sonra, üzerine basit bir Nginx web sunucusu dağıtarak tam işlevselliğini test edelim. Nginx dağıtımı için bir YAML dosyası oluşturalım. Master düğümde, nginx-deployment.yaml adında bir dosya oluşturun ve içine aşağıdaki içeriği yapıştırın:


# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort

Bu YAML dosyası, iki adet Nginx pod'u çalıştıran bir Deployment ve bu pod'ları dışarıya açan bir NodePort Service tanımlar. Dağıtımı uygulamak için:


kubectl apply -f nginx-deployment.yaml

Dağıtımın durumunu kontrol edelim:


kubectl get deployments
kubectl get pods -o wide
kubectl get service nginx-service

kubectl get service nginx-service komutunun çıktısı, Nginx servisinin bir NodePort üzerinde çalıştığını gösterecektir. Örneğin, çıktıda NodePort: 3XXXX/TCP gibi bir değer göreceksiniz. Bu, Nginx uygulamanıza herhangi bir worker düğümün IP adresi ve bu port numarası üzerinden erişebileceğiniz anlamına gelir.

Master düğümden çıkın (exit yazarak) ve yerel makinenizden bir worker düğümün IP adresini (örneğin, 172.16.16.101) ve NodePort değerini kullanarak tarayıcınızdan veya curl ile erişmeyi deneyin:


# Yerel makinenizden (master düğümün dışından)
curl 172.16.16.101:3XXXX # Buradaki 3XXXX, kubectl get service çıktısındaki NodePort değeridir.

Eğer Nginx'in varsayılan "Welcome to nginx!" sayfasını görüyorsanız, Kubernetes kümeniz başarıyla çalışıyor ve uygulamaları dağıtabilir durumdasınız demektir! Bu, hem geliştirme hem de öğrenme süreçleriniz için harika bir başlangıç noktasıdır.

İleri Düzey İpuçları ve En İyi Uygulamalar: Performans ve Geliştirme

Vagrant ile temel bir Kubernetes kümesi kurmayı öğrendik. Ancak, bu kurulumu daha verimli hale getirmek, geliştirme deneyiminizi zenginleştirmek ve gerçek dünya senaryolarına daha uygun hale getirmek için bazı ileri düzey ipuçları ve en iyi uygulamalar mevcuttur. Bu bölümde, Vagrantfile'ı özelleştirmekten, ağ yapılandırmasını optimize etmeye ve hata ayıklama tekniklerine kadar çeşitli konuları ele alacağız.

1. Vagrantfile'ı Özelleştirme: Kaynak Optimizasyonu

Yukarıdaki örnekte her düğüme belirli miktarda RAM ve CPU atadık. Ancak, projenizin veya makinenizin ihtiyaçlarına göre bu değerleri ayarlayabilirsiniz. Örneğin, daha fazla worker düğümle çalışıyorsanız veya daha fazla bellek tüketen uygulamalar çalıştırıyorsanız, ilgili düğümlerin kaynaklarını artırmanız gerekebilir:


# Vagrantfile içindeki bir örnek
master.vm.provider "virtualbox" do |vb|
  vb.memory = "4096" # 4 GB RAM
  vb.cpus = "4"    # 4 CPU çekirdeği
end

worker.vm.provider "virtualbox" do |vb|
  vb.memory = "2048" # 2 GB RAM
  vb.cpus = "2"    # 2 CPU çekirdeği
end

Uzman İpucu: Sanal makinelere çok fazla kaynak atamak, host makinenizin performansını düşürebilir. Dengeli bir yaklaşım benimseyerek, hem VM'lerin yeterli kaynağa sahip olmasını sağlayın hem de host makinenizin günlük görevleri için yeterli kaynağı kalmasını sağlayın.

2. Ağ Yapılandırması ve Yük Dengeleme

Varsayılan kurulumumuzda, NodePort servisleri ile uygulamalara erişiyorduk. Ancak üretim ortamlarında genellikle bir LoadBalancer (Yük Dengeleyici) kullanılır. Vagrant ortamında gerçek bir donanım yük dengeleyiciye sahip olmasak da, MetalLB gibi yazılımsal yük dengeleyicilerle Kubernetes servisleri için gerçek LoadBalancer tipi IP adresleri edinebiliriz. MetalLB kurulumu, kümenizin servislerini daha tutarlı ve kolay erişilebilir hale getirir.


# Master düğümde SSH ile bağlanıp çalıştırılabilir.
# MetalLB kurulumu için IP adresi aralığını kendi özel ağınıza göre ayarlayın
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/main/config/manifests/metallb.yaml
# Daha sonra bir ConfigMap oluşturarak MetalLB için IP aralığını belirtmeniz gerekir.
# Örneğin:
# apiVersion: v1
# kind: ConfigMap
# metadata:
#   namespace: metallb-system
#   name: config
# data:
#   config: |
#     address-pools:
#     - name: default
#       protocol: layer2
#       addresses:
#       - 172.16.16.200-172.16.16.210 # Vagrant kümenizin IP aralığına uygun

Bu, NodePort yerine LoadBalancer tipi servisler tanımlamanıza ve bu servislerin belirlenen IP aralığından bir IP adresi almasını sağlar.

3. Kalıcı Depolama (Persistent Storage) Çözümleri

Vagrant kümeniz üzerinde stateful uygulamalar çalıştırmayı planlıyorsanız, kalıcı depolama çözümleri entegre etmeniz gerekecektir. Dinamik depolama sağlamak için NFS veya Longhorn gibi çözümler popülerdir. Örneğin, NFS Server'ı master düğüme kurup, worker düğümlerin NFS istemcisi olarak bağlanmasını sağlayabilir ve Kubernetes içinde NFS Provisioner kullanarak PersistentVolume'ları dinamik olarak sağlayabilirsiniz.

4. Hata Ayıklama ve Sorun Giderme

Kurulum veya uygulama dağıtımı sırasında sorunlarla karşılaşmak doğaldır. İşte bazı hata ayıklama ipuçları:

Günlükleri Kontrol Edin: vagrant ssh k8s-master komutuyla master düğüme bağlanın ve sudo journalctl -u kubelet veya sudo journalctl -u containerd komutlarıyla ilgili servislerin günlüklerini kontrol edin.
Kubernetes Olayları: kubectl get events --all-namespaces komutu, küme içindeki olayları listeler ve sorunların kaynağını anlamanıza yardımcı olabilir.
Pod Açıklamaları: Bir pod sorun yaşıyorsa, kubectl describe pod komutuyla detaylı bilgilere (olaylar, konteyner durumları) ulaşabilirsiniz.
Ağ Bağlantısı: Düğümler arası ağ bağlantısını ping veya curl ile test edin. Güvenlik duvarı (ufw) ayarlarının kapalı veya doğru yapılandırılmış olduğundan emin olun.

5. Mobil Uyumlu HTML Geliştirme Notu

Her ne kadar bu makale sunumu sadece içeriği sağlasa da, genel olarak web tabanlı Kubernetes dashboard'ları veya kendi geliştirdiğiniz yönetim arayüzleri için mobil uyumluluk önemlidir. CSS media query'ler, farklı ekran boyutlarına ve cihazlara göre arayüzünüzü adapte etmenizi sağlar. İşte temel bir media query örneği:

Bu örnek, 768 pikselden küçük ekranlarda farklı stil kuralları uygulayarak mobil cihazlara uyum sağlar. Bu tür yaklaşımlar, Kubernetes'i yönetmek veya izlemek için geliştireceğiniz arayüzlerin kullanılabilirliğini artırır.

Bu ileri düzey ipuçları ve en iyi uygulamalar, Vagrant ile kurduğunuz Kubernetes kümesini sadece bir öğrenme aracı olmaktan çıkarıp, daha sağlam ve gerçekçi bir geliştirme ortamı haline getirmenize yardımcı olacaktır.

Gerçek Dünya Senaryoları: Kubernetes'in Gücünü Keşfedin

Vagrant ile oluşturduğumuz bu yerel çok düğümlü Kubernetes kümesi, sadece bir eğitim aracı olmanın ötesinde, birçok gerçek dünya senaryosunda büyük değer sunar. Geliştiriciler, DevOps ekipleri ve hatta küçük işletmeler için maliyet etkin ve esnek bir çözüm sağlayabilir. İşte bu tür bir kurulumun kullanılabileceği bazı pratik vaka analizleri:

1. Mikroservis Geliştirme ve Test Ortamı

Vaka Analizi: Bir yazılım geliştirme ekibi, büyük bir monolitik uygulamayı mikroservislere dönüştürmeye karar verdi. Her mikroservis kendi konteynerinde çalışıyor ve bağımsız olarak geliştirilip dağıtılıyor. Ekip üyelerinin her birinin, yerel makinelerinde bu mikroservis mimarisini tamamen simüle edebilmesi gerekiyor. Geliştiriciler, kendi bilgisayarlarında çalışan mini bir Kubernetes kümesinde, yazdıkları her mikroservisi diğerleriyle entegre bir şekilde test etmek istiyor.

Vagrant ve Kubernetes Çözümü: Vagrant ile kurulan çok düğümlü Kubernetes kümesi, her geliştiricinin dizüstü bilgisayarında tam teşekküllü bir mikroservis ortamı sağlar. Geliştiriciler, kendi Vagrantfile'larını kullanarak kümenin boyutunu (örneğin 1 master, 2 worker) ve kaynaklarını ayarlayabilirler. Uygulamaların Kubernetes'e nasıl dağıtılacağını, servis keşfini ve ağ politikasını yerel olarak test edebilirler. Bu sayede, "benim makinemde çalışıyor ama sunucuda çalışmıyor" gibi sorunlar minimuma iner ve geliştirme döngüsü hızlanır. Ayrıca, bu yerel kümede olası konfigürasyon değişikliklerinin üretim ortamına etkileri de önceden gözlemlenebilir.

2. CI/CD Pipeline Geliştirme ve Yerel Doğrulama

Vaka Analizi: Bir DevOps ekibi, konteynerleştirilmiş uygulamaların otomatik derlenmesi, test edilmesi ve Kubernetes kümesine dağıtılması için karmaşık bir CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) pipeline'ı geliştiriyor. Pipeline'ın her aşamasının (örneğin, test çalıştırması, dağıtım manifestlerinin doğrulanması) bir Kubernetes kümesi üzerinde test edilmesi gerekiyor. Ancak, her test için bulut tabanlı bir küme kullanmak hem maliyetli hem de zaman alıcı.

Vagrant ve Kubernetes Çözümü: Vagrant kümesi, CI/CD pipeline'ının yerel olarak geliştirilmesi ve doğrulanması için mükemmel bir platform sunar. DevOps mühendisleri, geliştirdikleri pipeline adımlarını (örneğin Jenkins, GitLab CI veya Argo CD'deki adımlar) yerel Kubernetes kümesinde çalıştırabilirler. Bu, dağıtım manifestlerinin (YAML dosyaları), Helm grafiklerinin veya Kustomize yapılandırmalarının doğruluğunu hızlıca kontrol etmelerini sağlar. Ayrıca, pipeline'ın bir hatayla karşılaştığında hata ayıklama sürecini de basitleştirir, çünkü tüm ortam yerel makinede kontrol edilebilir durumdadır. Bu yöntemle, üretim ortamına çıkmadan önce pipeline'ın kararlılığı ve doğruluğu büyük ölçüde artırılır.

3. Eğitim ve Sandbox Ortamları

Vaka Analizi: Bir üniversite veya kurum, öğrencilerine ve katılımcılarına Kubernetes'i öğretmek istiyor. Her öğrencinin bireysel olarak bir Kubernetes kümesi üzerinde pratik yapabilmesi gerekiyor, ancak herkesin bulut ortamına erişimi veya yeterli bütçesi olmayabilir. Aynı zamanda, karmaşık bir kurulum süreciyle zaman kaybetmek istemiyorlar.

Vagrant ve Kubernetes Çözümü: Vagrantfile sayesinde, her öğrenci veya katılımcı kendi bilgisayarında, tek bir vagrant up komutuyla tamamen işlevsel bir Kubernetes kümesi kurabilir. Bu, Kubernetes kavramlarını (Pod'lar, Deployments, Services, Ingress, Persistent Volumes vb.) uygulamalı olarak öğrenmek için ideal bir sandbox ortamı sağlar. Öğrenciler, küme bileşenlerini kendileri yapılandırabilir, uygulamaları dağıtabilir ve hatta küme arızalarını simüle ederek sorun giderme becerilerini geliştirebilirler. Bu yaklaşım, hem maliyet etkin hem de herkes için erişilebilir bir öğrenme deneyimi sunar, çünkü tüm bağımlılıklar ve yapılandırma Vagrantfile içinde kapsüllenmiştir.

Bu senaryolar, Vagrant ile kurulan yerel Kubernetes kümesinin ne kadar çok yönlü ve güçlü olabileceğini göstermektedir. Geliştiriciden eğitmene kadar geniş bir yelpazede kullanıcılara pratik çözümler sunar.

Sonuç ve Sıkça Sorulan Sorular

Bu makale boyunca, Vagrant ve VirtualBox kullanarak kendi yerel çok düğümlü Kubernetes kümenizi adım adım nasıl kuracağınızı detaylı bir şekilde inceledik. Modern yazılım geliştirme ve dağıtım süreçlerinin temelini oluşturan konteyner orkestrasyonunun ne kadar önemli olduğunu ve bu karmaşık teknolojiyi yerel bir ortamda kolayca nasıl simüle edebileceğimizi keşfettik. Vagrantfile'ın gücünü, provisioning betiklerinin otomasyon yeteneklerini ve Kubernetes'in temel bileşenlerini adım adım ele aldık.

Öncelikle, neden kendi Kubernetes kümenizi oluşturmanız gerektiğini, Vagrant ve Kubernetes'in temel kavramlarını ve ön hazırlık adımlarını öğrendik. Ardından, bir master ve iki worker düğümden oluşan bir küme için Vagrantfile'ı ve gerekli shell betiklerini yazdık. Bu betikler aracılığıyla Kubernetes kontrol düzlemini başlattık, worker düğümlerini küreye dahil ettik ve Flannel CNI'yı dağıttık. Son olarak, kümemizin sağlıklı çalıştığını basit bir Nginx uygulaması dağıtarak doğruladık ve ilerleyen aşamalarda işinize yarayacak ileri düzey ipuçları ve gerçek dünya senaryolarını tartıştık. Bu rehber sayesinde, artık kendi makinelerinizde güçlü bir geliştirme, test ve öğrenme ortamına sahipsiniz.

Bu kurulum, özellikle geliştirme ve test süreçlerinde büyük avantajlar sunar. Geliştiricilerin üretim ortamına benzer bir ortamda çalışmasına olanak tanırken, DevOps ekiplerinin CI/CD pipeline'larını güvenle geliştirmesine yardımcı olur. Kubernetes'e yeni başlayanlar için ise paha biçilmez bir öğrenme sandbox'ı görevi görür. Unutmayın, bu sadece bir başlangıç. Kubernetes'in sunduğu olanaklar çok geniştir ve bu yerel küme, bu olanakları keşfetmek için sağlam bir temel sağlayacaktır. Vagrant'ın sunduğu otomasyon ve tutarlılık, Kubernetes öğrenme ve uygulama yolculuğunuzu çok daha verimli hale getirecektir.

Sıkça Sorulan Sorular

S1: Vagrant kümemi başlattıktan sonra kubectl get nodes komutu düğümleri "NotReady" olarak gösteriyorsa ne yapmalıyım?

C1: Öncelikle biraz bekleyin; bileşenlerin tamamen başlaması zaman alabilir. Sorun devam ederse, master düğüme SSH ile bağlanın ve sudo journalctl -u kubelet ve sudo journalctl -u containerd komutlarıyla servislerin günlüklerini kontrol edin. Ayrıca kubectl get events --all-namespaces komutuyla küme içindeki olayları inceleyin. Ağ sorunları (örneğin güvenlik duvarı) veya eksik bağımlılıklar da bu duruma yol açabilir.

S2: Sanal makinelerime daha fazla RAM veya CPU atayabilir miyim?

C2: Evet, Vagrantfile içindeki vb.memory ve vb.cpus değerlerini istediğiniz gibi ayarlayabilirsiniz. Değişiklik yaptıktan sonra, Vagrantfile'ı kaydedip vagrant reload --provision komutunu çalıştırmanız gerekmektedir. Ancak, host makinenizin toplam kaynaklarını aşmamaya dikkat edin.

S3: Bu kurulumu kullanarak daha fazla worker düğümü ekleyebilir miyim?

C3: Evet, Vagrantfile içindeki worker düğüm tanımı döngüsünü ((1..2).each do |i| ... end) değiştirerek kolayca daha fazla worker düğümü ekleyebilirsiniz. Örneğin, (1..3).each do |i| yaparak üç worker düğümü oluşturabilirsiniz. Her yeni worker düğümü için benzersiz bir IP adresi atandığından emin olun.

S4: Kurulum sırasında internet bağlantısı koparsa ne olur?

C4: İnternet bağlantısı kesilirse, Vagrant box'ları indirme, Kubernetes paketlerini çekme veya Flannel manifestlerini uygulama gibi adımlar başarısız olur. Vagrant işlemi durabilir. Bağlantı geri geldiğinde, vagrant up --provision komutunu tekrar çalıştırarak kurulumu kaldığı yerden devam ettirmeyi deneyebilirsiniz.

S5: Kümemi tamamen kapatmak veya silmek için hangi komutları kullanmalıyım?

C5: Kümedeki tüm sanal makineleri durdurmak için vagrant halt komutunu kullanabilirsiniz. Tamamen silmek ve temiz bir başlangıç yapmak isterseniz, vagrant destroy -f komutu tüm sanal makineleri ve ilişkili sanal diskleri kaldıracaktır. Bu komutu dikkatli kullanın, geri dönüşü yoktur.