DigitalOcean Üzerinde Kubernetes Yönetimi: Pulumi ile Güçlü Bir Yaklaşım

DigitalOcean Üzerinde Kubernetes Yönetimi: Pulumi ile Güçlü Bir Yaklaşım

Bulut bilişim dünyasında konteynerleştirme ve orkestrasyonu, modern uygulama geliştirme ve dağıtımının temel taşları haline gelmiştir. Kubernetes, bu alanda endüstri standardı olarak kabul edilirken, bulut sağlayıcıları da Kubernetes hizmetlerini kolaylaştırmak için çeşitli çözümler sunmaktadır. DigitalOcean, sunduğu basitlik ve geliştirici odaklı yaklaşımıyla öne çıkan popüler bir bulut platformudur. Bu makalede, DigitalOcean üzerinde Kubernetes kümelerini Pulumi gibi altyapı kodlama (Infrastructure as Code – IaC) aracıyla nasıl etkili bir şekilde yönetebileceğimizi detaylı bir şekilde inceleyeceğiz.

Neden Pulumi ve DigitalOcean Kubernetes?

Pulumi, geliştiricilerin sevdikleri programlama dillerini (TypeScript, Python, Go, C# vb.) kullanarak bulut altyapısını tanımlamalarına ve yönetmelerine olanak tanıyan bir IaC platformudur. Geleneksel IaC araçlarının deklaratif yapısının aksine, Pulumi’nin imperatif programlama yetenekleri, daha karmaşık altyapı mantıklarını, döngüleri, koşullu ifadeleri ve soyutlamaları kolayca uygulamanıza imkan tanır. Bu, özellikle dinamik ve ölçeklenebilir Kubernetes ortamları oluştururken büyük bir avantaj sağlar.

DigitalOcean Kubernetes (DOKS), DigitalOcean’ın yönetilen Kubernetes hizmetidir. Kullanıcıların altyapı yönetimiyle uğraşmadan Kubernetes kümeleri oluşturmalarına ve yönetmelerine olanak tanır. DOKS, basitliği, şeffaf fiyatlandırması ve geliştirici dostu arayüzü ile özellikle küçük ve orta ölçekli işletmeler ile bireysel geliştiriciler arasında popülerdir.

Pulumi ve DOKS’un birleşimi, aşağıdaki avantajları sunar:

* Geliştirici Deneyimi: Pulumi’nin programlama dili tabanlı yaklaşımı, geliştiricilerin tanıdık araçlarla altyapılarını yönetmelerini sağlar.
* Otomasyon ve Tekrarlanabilirlik: IaC prensipleri sayesinde altyapı dağıtımları otomatikleştirilir ve her seferinde aynı sonuçların elde edilmesi garanti edilir.
* Sürüm Kontrolü ve İşbirliği: Altyapı kodunuzu Git gibi sürüm kontrol sistemlerinde saklayarak değişiklikleri izleyebilir, geri alabilir ve ekiple işbirliği yapabilirsiniz.
* Karmaşıklık Yönetimi: Pulumi’nin soyutlama yetenekleri sayesinde tekrarlayan altyapı bileşenlerini yeniden kullanılabilir modüller halinde paketleyerek karmaşıklığı azaltabilirsiniz.
* DigitalOcean Entegrasyonu: Pulumi, DigitalOcean’ın tüm hizmetleri için kapsamlı bir sağlayıcıya sahiptir, bu da DOKS kümeleri oluşturmayı ve yönetmeyi kolaylaştırır.

Başlangıç Adımları

Bu makaledeki örnekleri takip etmek için aşağıdaki ön koşullara sahip olmanız gerekmektedir:

1. Pulumi Hesabı ve CLI: Pulumi hesabı oluşturun ve Pulumi komut satırı arayüzünü (CLI) yükleyin. Kurulum talimatları için Pulumi’nin resmi belgelerine göz atabilirsiniz.
2. DigitalOcean Hesabı ve API Token: Bir DigitalOcean hesabınız olmalı ve bu hesap için bir API token’ı oluşturmalısınız. Bu token, Pulumi’nin DigitalOcean ile etkileşim kurmasını sağlayacaktır.
3. Node.js ve npm/yarn: Örnekler TypeScript ile yazılacaktır, bu nedenle Node.js ve bir paket yöneticisi (npm veya yarn) gereklidir.
4. kubectl: Kubernetes kümenize erişmek için kubectl komut satırı aracı gereklidir.

Pulumi Projesi Oluşturma

İlk olarak, yeni bir Pulumi projesi oluşturacağız. Terminalinizi açın ve aşağıdaki komutu çalıştırın:

pulumi new digitalocean-typescript

Bu komut, DigitalOcean ve TypeScript için önceden yapılandırılmış bir Pulumi projesi oluşturacaktır. Proje dizinine girdikten sonra (genellikle digitalocean-k8s-example gibi bir isim verilir), package.json dosyasında gerekli bağımlılıkları yüklemek için npm install veya yarn install komutunu çalıştırın.

Proje yapısı genellikle şu şekildedir:

.
├── index.ts
├── package.json
├── tsconfig.json
└── Pulumi.yaml

* index.ts: Altyapı kodunuzun ana giriş noktasıdır.
* package.json: Projenizin bağımlılıklarını ve betiklerini tanımlar.
* tsconfig.json: TypeScript derleyicisinin ayarlarını içerir.
* Pulumi.yaml: Pulumi projesinin meta verilerini içerir.

DigitalOcean Kubernetes Kümesi Oluşturma

index.ts dosyasını açın ve DigitalOcean Kubernetes kümenizi tanımlamak için aşağıdaki kodu ekleyin:

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";

// Pulumi yapılandırmasından değişkenleri alın
const config = new pulumi.Config();
const region = config.get("region") || "nyc3"; // Varsayılan olarak New York 3 kullanılır
const nodePoolSize = config.get("nodePoolSize") || "s-2vcpu-4gb"; // Varsayılan droplet boyutu
const nodeCount = parseInt(config.get("nodeCount") || "2", 10); // Varsayılan node sayısı
const clusterName = config.get("clusterName") || "my-doks-cluster"; // Varsayılan küme adı

// DigitalOcean Kubernetes kümesi oluşturma
const cluster = new digitalocean.KubernetesCluster(clusterName, {
    region: region,
    version: "1.27.1-do.0", // Kullanmak istediğiniz Kubernetes sürümünü belirtin
    nodePool: {
        name: "default-pool",
        size: nodePoolSize,
        nodeCount: nodeCount,
        // İsteğe bağlı olarak etiketler ekleyebilirsiniz
        // tags: ["app", "kubernetes"],
    },
    // Auto-scale ayarları (isteğe bağlı)
    // autoScale: true,
    // minNodes: 1,
    // maxNodes: 5,
});

// Küme adını çıktı olarak verin
export const clusterId = cluster.id;
export const clusterEndpoint = cluster.endpoint;
export const clusterKubeconfig = cluster.kubeConfigs[0].rawConfig; // İlk kubeconfig'i al

Açıklamalar:

import as digitalocean from "@pulumi/digitalocean";: DigitalOcean sağlayıcısını içe aktarır.
* const config = new pulumi.Config();: Pulumi yapılandırmasından değişkenleri okumak için kullanılır. Bu, küme adını, bölgeyi, droplet boyutunu ve node sayısını dinamik olarak ayarlamanıza olanak tanır.
* digitalocean.KubernetesCluster: Bu, DigitalOcean’da bir Kubernetes kümesi oluşturmak için kullanılan Pulumi kaynağıdır.
* region: Kümenin dağıtılacağı DigitalOcean bölgesi.
* version: Kullanılacak Kubernetes sürümü. DigitalOcean’ın desteklediği sürümleri kontrol etmeniz önemlidir.
* nodePool: Kümenin iş yüklerini çalıştıracak Droplet’ların grubunu tanımlar.
* name: Node havuzunun adı.
* size: Node’lar için Droplet boyutu. DigitalOcean’ın Droplet boyutları hakkında bilgi için belgelerine bakabilirsiniz.
* nodeCount: Node havuzundaki başlangıç Droplet sayısı.
* export const ...: Bu ifadeler, Pulumi CLI tarafından dağıtım tamamlandıktan sonra çıktı olarak görüntülenecek değerleri tanımlar. kubeconfig çıktısı, kümenize kubectl ile bağlanmak için çok önemlidir.

Yapılandırma Değişkenlerini Ayarlama:

Pulumi yapılandırma değişkenlerini ayarlamak için Pulumi..yaml dosyasını düzenleyebilir veya komut satırından pulumi config set komutunu kullanabilirsiniz. Örneğin, varsayılanları değiştirmek için:

pulumi config set region nyc1
pulumi config set nodePoolSize s-4vcpu-8gb
pulumi config set nodeCount 3
pulumi config set clusterName my-production-cluster

Varsayılan olarak, Pulumi otomatik olarak bir “dev” yığını (stack) oluşturur. Farklı yığınlar oluşturmak ve yönetmek için pulumi stack init komutunu kullanabilirsiniz.

Pulumi ile Küme Dağıtımı

Projenizi dağıtmaya hazır olduğunuzda, terminalinizde proje dizinine gidin ve aşağıdaki komutu çalıştırın:

pulumi up

Pulumi, altyapı değişikliklerini önizleyecek ve onaylamanızı isteyecektir. Onayladıktan sonra, Pulumi DigitalOcean API’si ile etkileşime geçerek Kubernetes kümesini oluşturacaktır. Bu işlem birkaç dakika sürebilir.

Dağıtım tamamlandığında, Pulumi CLI çıktısında tanımladığınız export değişkenlerinin değerlerini göreceksiniz. Özellikle clusterKubeconfig çıktısını dikkatlice kopyalayın.

Kubernetes Kümesine Bağlanma

Dağıtım tamamlandıktan sonra, kümenize kubectl ile bağlanmanız gerekecektir. Kopyaladığınız clusterKubeconfig değerini kullanarak kubectl yapılandırmanızı güncelleyebilirsiniz:

1. Kubeconfig Dosyasına Kaydetme: clusterKubeconfig çıktısını ~/.kube/config dosyanızın ilgili bölümüne ekleyebilir veya ayrı bir dosyaya kaydedebilirsiniz. Örneğin, ~/kube/my-doks-config gibi bir dosyaya kaydedebilirsiniz.

# Eğer çıktıyı bir dosyaya kaydettiyseniz
    mkdir -p ~/.kube
    echo "<KOPYALADIĞINIZ_KUBECONFIG_DEĞERİ>" > ~/.kube/my-doks-config

2. Ortam Değişkeni Ayarlama: kubectl‘in bu yapılandırmayı kullanmasını sağlamak için KUBECONFIG ortam değişkenini ayarlayın:

export KUBECONFIG=~/.kube/my-doks-config

Veya ~/.bashrc, ~/.zshrc gibi shell yapılandırma dosyalarınıza ekleyerek kalıcı hale getirebilirsiniz.

3. Bağlantıyı Doğrulama: Şimdi kubectl ile kümenize erişip erişemediğinizi kontrol edebilirsiniz:

kubectl get nodes

Bu komut, kümenizdeki node’ları listelemelidir.

Pulumi ile Kubernetes Kaynaklarını Yönetme

Pulumi sadece Kubernetes kümeleri oluşturmakla kalmaz, aynı zamanda küme içindeki Kubernetes kaynaklarını (Deployments, Services, ConfigMaps, Secrets vb.) da yönetmenize olanak tanır. Pulumi, Kubernetes sağlayıcısı aracılığıyla kubernetes paketini kullanarak bu kaynakları tanımlamanıza imkan tanır.

Örneğin, kümenize bir Nginx deployment’ı ve bir LoadBalancer servisi dağıtmak için index.ts dosyanızı aşağıdaki gibi güncelleyebilirsiniz:

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
import * as kubernetes from "@pulumi/kubernetes";

// ... (Yukarıdaki DigitalOcean Kubernetes Kümesi Oluşturma Kodu) ...

// Kümeye erişmek için kubeconfig'i kullan
const kubeconfig = cluster.kubeConfigs[0].rawConfig;
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Nginx Deployment oluşturma
const nginxDeployment = new kubernetes.apps.v1.Deployment("nginx-deployment", {
    metadata: {
        name: "nginx",
    },
    spec: {
        selector: { matchLabels: { app: "nginx" } },
        replicas: 2,
        template: {
            metadata: { labels: { app: "nginx" } },
            spec: {
                containers: [{
                    name: "nginx",
                    image: "nginx:latest",
                    ports: [{ containerPort: 80 }],
                }],
            },
        },
    },
}, { provider: k8sProvider }); // K8s sağlayıcısını belirtin

// Nginx Servisi oluşturma (LoadBalancer tipi)
const nginxService = new kubernetes.core.v1.Service("nginx-service", {
    metadata: {
        name: "nginx-service",
    },
    spec: {
        selector: nginxDeployment.spec.template.metadata.labels,
        ports: [{
            port: 80,
            targetPort: 80,
            protocol: "TCP",
        }],
        type: "LoadBalancer", // DigitalOcean Load Balancer oluşturacaktır
    },
}, { provider: k8sProvider }); // K8s sağlayıcısını belirtin

// Servisin dış IP adresini çıktı olarak verin
export const nginxServiceIp = nginxService.status.loadBalancer.ingress[0].ip;

Açıklamalar:

import as kubernetes from "@pulumi/kubernetes";: Pulumi’nin Kubernetes sağlayıcısını içe aktarır.
* const kubeconfig = cluster.kubeConfigs[0].rawConfig;: Daha önce oluşturduğumuz kümenin kubeconfig’ini alır.
* const k8sProvider = new kubernetes.Provider("k8s-provider", { kubeconfig: kubeconfig });: Kubernetes kaynaklarını yönetmek için bir Pulumi sağlayıcısı oluşturur. Bu sağlayıcı, oluşturulan kubernetes kaynaklarının hangi kümede çalışacağını belirtir.
* new kubernetes.apps.v1.Deployment(...): Bir Kubernetes Deployment kaynağı tanımlar. image, replicas ve ports gibi standart Kubernetes API özelliklerini kullanır.
* new kubernetes.core.v1.Service(...): Bir Kubernetes Service kaynağı tanımlar. type: "LoadBalancer" ayarı, DigitalOcean’da otomatik olarak bir Load Balancer oluşturulmasını tetikler.
* { provider: k8sProvider }: Bu argüman, Pulumi’ye bu kaynağın hangi sağlayıcı (ve dolayısıyla hangi küme) tarafından yönetilmesi gerektiğini söyler.

Bu değişiklikleri kaydettikten sonra, tekrar pulumi up komutunu çalıştırın. Pulumi, yeni Nginx Deployment ve Service kaynaklarını kümenize dağıtacaktır. Dağıtım tamamlandıktan sonra nginxServiceIp çıktısını kullanarak Nginx uygulamanıza dışarıdan erişebilirsiniz.

Pulumi ile Altyapı Yönetiminin İleri Seviye Konuları

Modülerlik ve Yeniden Kullanılabilirlik

Pulumi, altyapı kodunuzu daha yönetilebilir ve yeniden kullanılabilir hale getirmek için modülerlik sunar. Kendi özel modüllerinizi oluşturabilir veya Pulumi Kayıt Defteri’ndeki (Registry) mevcut modülleri kullanabilirsiniz. Örneğin, farklı uygulamalar için standart bir veritabanı kümesi veya bir logging altyapısı tanımlayan modüller oluşturabilirsiniz.

Durum Yönetimi (State Management)

Pulumi, altyapınızın durumunu bir “state backend” üzerinde saklar. Varsayılan olarak bu Pulumi’nin bulutudur, ancak S3, Azure Blob Storage veya Google Cloud Storage gibi kendi depolama çözümlerinizi de kullanabilirsiniz. Bu durum dosyası, Pulumi’nin mevcut altyapınızı bilmesini ve değişiklikleri doğru bir şekilde uygulamasını sağlar.

Farklı Ortamlar İçin Altyapı

Pulumi’nin “stack” konsepti, farklı ortamlar (geliştirme, staging, üretim) için altyapı dağıtımlarını izole etmenizi kolaylaştırır. Her ortam için ayrı bir Pulumi..yaml yapılandırma dosyası kullanarak farklı değişkenler (örneğin, farklı droplet boyutları, farklı küme adları) belirleyebilirsiniz.

# Staging yığını oluşturma
pulumi stack init staging
Staging için yapılandırmayı ayarlama
pulumi config set --stack staging region nyc1
pulumi config set --stack staging nodePoolSize s-2vcpu-4gb
pulumi config set --stack staging nodeCount 1
Staging yığınını dağıtma
pulumi up --stack staging

Otomatik Ölçeklendirme ve Yönetilen Hizmetler

DOKS’un sunduğu otomatik ölçeklendirme özelliklerini Pulumi ile yapılandırabilirsiniz. Ayrıca, DigitalOcean’ın Managed Databases (Managed Veritabanları) gibi diğer yönetilen hizmetlerini de Pulumi ile kolayca oluşturabilir ve yönetebilirsiniz.

// Örnek: Managed PostgreSQL veritabanı oluşturma
const pgDatabase = new digitalocean.DatabaseCluster("pg-db-cluster", {
    engine: "postgresql",
    version: "14",
    region: region,
    size: "db-s-1vcpu-2gb",
    nodeCount: 1,
    projectUrn: cluster.urn, // Aynı projeye ait olmasını sağlayabiliriz
});

export const pgDatabaseName = pgDatabase.name;
export const pgDatabaseEndpoint = pgDatabase.uri;

Güvenlik ve En İyi Uygulamalar

* Secret Yönetimi: Hassas bilgileri (API anahtarları, veritabanı şifreleri vb.) Pulumi’nin yerleşik secret yönetimi veya harici secret yönetim araçları (örneğin, HashiCorp Vault) ile yönetin. pulumi config set --secret komutuyla secret’ları şifreleyebilirsiniz.
* RBAC (Role-Based Access Control): Kubernetes kümenizdeki kaynaklara erişimi kontrol etmek için RBAC’yi Pulumi aracılığıyla tanımlayın.
* En Az Ayrıcalık Prensibi: Pulumi’nin DigitalOcean API token’ını kullanırken, token’a yalnızca gerekli izinleri verin.
* Kod İncelemesi ve CI/CD: Altyapı kodunuzu sürüm kontrol sistemlerinde saklayın, kod incelemeleri yapın ve CI/CD pipeline’ları (GitHub Actions, GitLab CI, Jenkins vb.) ile otomatik dağıtım süreçleri kurun.

Sonuç

Pulumi, DigitalOcean üzerinde Kubernetes kümelerini ve diğer altyapı bileşenlerini yönetmek için güçlü, esnek ve geliştirici dostu bir çözüm sunar. Sevdikleri programlama dillerini kullanarak altyapılarını kodlayan ekipler, daha yüksek otomasyon seviyelerine ulaşabilir, tekrarlanabilirliği artırabilir ve karmaşık dağıtım senaryolarını daha etkili bir şekilde yönetebilirler. DigitalOcean’ın basitliği ile Pulumi’nin programatik gücünü birleştirmek, modern bulut uygulamaları için sağlam ve ölçeklenebilir bir temel oluşturmanıza yardımcı olur. Bu makalede ele alınan temel kavramlar ve örnekler, DigitalOcean üzerinde Pulumi ile Kubernetes yolculuğunuza başlamanız için size rehberlik edecektir.