DigitalOcean Kubernetes’e CircleCI ile Otomatik Dağıtımlar Nasıl Yapılır?

DigitalOcean Kubernetes’e CircleCI ile Otomatik Dağıtımlar Nasıl Yapılır?

Giriş

Modern yazılım geliştirme süreçlerinde hız, güvenilirlik ve tutarlılık, rekabetçi kalabilmek için vazgeçilmez unsurlardır. Sürekli Entegrasyon (Continuous Integration – CI) ve Sürekli Dağıtım (Continuous Deployment – CD) bu hedeflere ulaşmada kilit rol oynar. CI/CD süreçleri, kod değişikliklerinin otomatik olarak test edilmesini, derlenmesini ve dağıtılmasını sağlayarak manuel hataları azaltır, geliştirme döngülerini hızlandırır ve ekiplerin daha sık ve güvenli bir şekilde üretim ortamına geçiş yapmasına olanak tanır.

Bu makalede, bulut tabanlı bir Kubernetes hizmeti olan DigitalOcean Kubernetes (DOKS) üzerine, popüler bir CI/CD platformu olan CircleCI kullanarak otomatik dağıtımlar yapmayı adım adım inceleyeceğiz. Bir uygulamanın Docker imajının oluşturulmasından, bir container registry’ye gönderilmesine ve son olarak Kubernetes kümesine dağıtılmasına kadar tüm süreci otomatikleştireceğiz. Bu rehber, hem CI/CD kavramlarına yeni başlayanlar hem de mevcut süreçlerini DigitalOcean Kubernetes ve CircleCI ile optimize etmek isteyen deneyimli geliştiriciler için faydalı olacaktır.

Temel Kavramlar

Otomatik dağıtım sürecine başlamadan önce, kullanacağımız temel teknolojileri ve kavramları anlamak önemlidir.

Sürekli Entegrasyon (CI) ve Sürekli Dağıtım (CD)

* Sürekli Entegrasyon (CI): Geliştiricilerin kod değişikliklerini sık sık (genellikle günde birkaç kez) paylaşılan bir ana depoya birleştirdiği bir yazılım geliştirme uygulamasıdır. Her bir birleştirme, otomatik bir derleme ve test sürecini tetikler. Bu, sorunların erken tespit edilmesini ve çözülmesini sağlar.
* Sürekli Dağıtım (CD): CI’nın bir uzantısıdır. Başarılı bir şekilde test edilmiş ve derlenmiş her kod değişikliğinin otomatik olarak üretim ortamına dağıtılmasını ifade eder. Sürekli Teslimat (Continuous Delivery) ise, üretim ortamına dağıtımın otomatikleştirildiği ancak manuel bir onayın gerektiği bir adımdır. Bu makalede, tam otomatik dağıtımı (Continuous Deployment) hedefleyeceğiz.

Kubernetes (K8s)

Kubernetes, container’lı uygulamaların dağıtımını, ölçeklendirmesini ve yönetimini otomatikleştiren açık kaynaklı bir container orkestrasyon platformudur. Uygulamaları küçük, bağımsız birimler olan container’lara paketleyerek, farklı ortamlarda tutarlı bir şekilde çalışmalarını sağlar.

DigitalOcean Kubernetes (DOKS)

DigitalOcean Kubernetes, DigitalOcean’ın yönetilen Kubernetes hizmetidir. Geliştiricilerin kendi Kubernetes kümelerini kurma ve yönetme karmaşıklığını ortadan kaldırarak, uygulamalarını hızla dağıtmalarına ve ölçeklendirmelerine olanak tanır. DOKS, Kubernetes’in tüm güçlü özelliklerini DigitalOcean’ın kullanım kolaylığı ve uygun fiyatlandırmasıyla birleştirir.

CircleCI

CircleCI, bulut tabanlı bir CI/CD platformudur. Kod depolarınızla entegre olarak, kod değişiklikleri algılandığında otomatik derleme, test ve dağıtım süreçlerini tetikler. Geniş entegrasyon yelpazesi, esnek yapılandırma seçenekleri ve güçlü otomasyon yetenekleri ile öne çıkar.

Docker

Docker, uygulamaları ve bağımlılıklarını izole edilmiş birimler olan container’lara paketlemeyi sağlayan bir platformdur. Bu container’lar, farklı ortamlarda tutarlı bir şekilde çalışabilir, bu da “bir kez yaz, her yerde çalıştır” prensibini mümkün kılar.

Git

Git, yazılım geliştirme projelerinde kaynak kod değişikliklerini takip etmek ve birden fazla geliştiricinin aynı proje üzerinde işbirliği yapmasını sağlamak için kullanılan dağıtık bir versiyon kontrol sistemidir. GitHub, GitLab veya Bitbucket gibi platformlar, Git depolarını barındırır.

Ön Koşullar ve Hazırlık

Bu rehbere başlamadan önce aşağıdaki araçlara ve hesaplara sahip olmanız gerekmektedir:

* DigitalOcean Hesabı: Bir DOKS kümesi oluşturmak ve yönetmek için.
* Docker Hub Hesabı veya Özel Container Registry: Uygulamanızın Docker imajını depolamak için. Docker Hub ücretsiz katman sunar.
* GitHub/GitLab Hesabı: Uygulama kodunuzu ve CircleCI yapılandırma dosyanızı barındırmak için.
* CircleCI Hesabı: GitHub/GitLab hesabınızla entegre edilecek.
* kubectl: Kubernetes kümeleriyle etkileşim kurmak için komut satırı aracı. Yerel makinenize kurulu olmalı.
* doctl (isteğe bağlı ama önerilir): DigitalOcean API’si ile etkileşim kurmak için komut satırı aracı. Küme oluşturma ve yönetme işlemlerini kolaylaştırır.
* Node.js, Python, Go veya başka bir programlama dili: Dağıtacağımız örnek bir uygulama için.

Uygulama Mimarisi ve Proje Yapısı

Bu rehberde, basit bir “Hello World” web uygulaması dağıtacağız. Uygulama, gelen isteklere basit bir yanıt dönecek. Proje yapımız aşağıdaki gibi olacak:

my-app/
├── .circleci/
│   └── config.yml
├── .kubernetes/
│   ├── deployment.yaml
│   └── service.yaml
├── src/
│   └── app.js  (veya app.py, main.go vb.)
├── Dockerfile
├── package.json (veya requirements.txt, go.mod vb.)
└── README.md

* src/app.js: Örnek Node.js uygulamamızın kaynak kodu.
* Dockerfile: Uygulamayı bir Docker imajına dönüştürmek için talimatları içerir.
* .kubernetes/deployment.yaml: Kubernetes Deployment nesnesini tanımlar. Uygulamanın nasıl çalıştırılacağını (kaç kopya, hangi imaj vb.) belirtir.
* .kubernetes/service.yaml: Kubernetes Service nesnesini tanımlar. Uygulamaya dışarıdan nasıl erişileceğini (port, tip vb.) belirtir.
* .circleci/config.yml: CircleCI’nin CI/CD pipeline’ını tanımlayan ana yapılandırma dosyası.

Adım Adım Kurulum ve Yapılandırma

Şimdi, DigitalOcean Kubernetes’e CircleCI ile otomatik dağıtım yapmak için gerekli adımları tek tek inceleyelim.

Adım 1: DigitalOcean Kubernetes Kümesi Oluşturma

İlk olarak, uygulamamızı dağıtacağımız bir Kubernetes kümesi oluşturmamız gerekiyor. Bunu DigitalOcean kontrol paneli veya doctl komut satırı aracı ile yapabiliriz.

DigitalOcean Kontrol Paneli ile:

1. DigitalOcean hesabınıza giriş yapın.
2. Sol menüden “Kubernetes”e gidin ve “Create Kubernetes Cluster” butonuna tıklayın.
3. Bir bölge seçin (örneğin, Frankfurt, London).
4. Bir Node Pool (düğüm havuzu) yapılandırın. Boyutunu ve düğüm sayısını seçin. Test için küçük bir boyutta (örneğin, s-2vcpu-4gb) 1-2 düğüm yeterli olacaktır.
5. Kümenize bir isim verin (örneğin, my-doks-cluster).
6. “Create Cluster” butonuna tıklayın. Kümenizin oluşturulması birkaç dakika sürecektir.
7. Küme hazır olduğunda, küme detayları sayfasından “Download Config File” butonuna tıklayarak kubeconfig dosyanızı indirin. Bu dosya, kubectl‘in kümenizle kimlik doğrulaması yapmasını sağlar. Genellikle bu dosyayı ~/.kube/config dizinine taşırsınız.

doctl ile (isteğe bağlı):

doctl kuruluysa ve DigitalOcean API anahtarınız yapılandırılmışsa, aşağıdaki komutla bir küme oluşturabilirsiniz:

doctl kubernetes cluster create my-doks-cluster \
  --region fra1 \
  --node-pool name=default,size=s-2vcpu-4gb,count=2

Ardından, kümenizin kubeconfig dosyasını almak için:

doctl kubernetes cluster kubeconfig save my-doks-cluster

kubectl‘in doğru küme bağlamını kullandığından emin olmak için:

kubectl config use-context do-fra1-my-doks-cluster
kubectl get nodes

Adım 2: Örnek Uygulama ve Dockerfile Hazırlama

Basit bir Node.js “Hello World” uygulaması oluşturalım.

src/app.js:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello from DigitalOcean Kubernetes with CircleCI!');
});

app.listen(port, () => {
  console.log(App listening at http://localhost:${port});
});

package.json:

{
  "name": "my-app",
  "version": "1.0.0",
  "description": "A simple Node.js app for DOKS deployment",
  "main": "src/app.js",
  "scripts": {
    "start": "node src/app.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Şimdi bu uygulamayı Dockerize edelim.

Dockerfile:

# Temel imaj olarak Node.js'in resmi imajını kullan
FROM node:16-alpine

Çalışma dizinini ayarla
WORKDIR /app

package.json ve package-lock.json dosyalarını kopyala
Bağımlılıkları yüklemek için önce bunları kopyalamak,
sadece kaynak kod değiştiğinde bağımlılıkların tekrar yüklenmesini önler.
COPY package*.json ./

Bağımlılıkları yükle
RUN npm install

Uygulama kaynak kodunu kopyala
COPY src ./src

Uygulamayı başlatma komutunu tanımla
CMD [ "npm", "start" ]

Uygulamanın dinleyeceği portu belirt
EXPOSE 3000

Adım 3: Kubernetes Manifest Dosyaları Oluşturma

Uygulamamızı Kubernetes kümesine dağıtmak için Deployment ve Service manifest dosyalarını oluşturalım.

.kubernetes/deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: my-app
spec:
  replicas: 2 # Uygulamanın 2 kopyasını çalıştır
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: your-dockerhub-username/my-app:latest # BURAYI KENDİ DOCKER IMAGINIZLA DEĞİŞTİRİN
        ports:
        - containerPort: 3000

ÖNEMLİ: your-dockerhub-username/my-app:latest kısmını kendi Docker Hub kullanıcı adınız ve belirleyeceğiniz imaj adı ile değiştirin (örneğin, gorkemyurt/my-app:latest).

.kubernetes/service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  type: LoadBalancer # DigitalOcean'da bir Load Balancer sağlar
  ports:
    - protocol: TCP
      port: 80 # Dışarıdan erişilecek port
      targetPort: 3000 # Container'ın dinlediği port

type: LoadBalancer kullanmak, DigitalOcean’da otomatik olarak bir Load Balancer oluşturur ve uygulamanıza dışarıdan erişilebilir bir IP adresi sağlar.

Adım 4: CircleCI Projesi Yapılandırma ve Ortam Değişkenleri

1. GitHub/GitLab Deposu Oluşturma: Tüm bu dosyaları (uygulama kodu, Dockerfile, Kubernetes manifestleri ve .circleci/config.yml) bir Git deposuna yükleyin.
2. CircleCI Hesabı Entegrasyonu: CircleCI’ya giriş yapın ve GitHub/GitLab hesabınızla entegre edin. Deponuzu CircleCI’da “Add Project” diyerek ekleyin.
3. Ortam Değişkenleri Tanımlama: CircleCI projenizin ayarlarında (Project Settings -> Environment Variables) aşağıdaki ortam değişkenlerini tanımlamanız gerekecek:
* DOCKER_USER: Docker Hub kullanıcı adınız.
* DOCKER_PASS: Docker Hub parolanız.
* DOCKER_REPO: Docker imajınızın adı (örneğin, my-app).
* KUBECONFIG_ENCODED: Bu en kritik değişkendir. DigitalOcean Kubernetes kümenizin kubeconfig dosyasının Base64 kodlanmış halini içermelidir.
* kubeconfig dosyanızı indirdikten sonra (Adım 1’de), aşağıdaki komutla Base64 kodlamasını yapın:

cat ~/.kube/config | base64
            # macOS için: cat ~/.kube/config | base64
            # Linux için: cat ~/.kube/config | base64 -w 0

* Çıktıyı kopyalayın ve KUBECONFIG_ENCODED ortam değişkenine yapıştırın. Bu, CircleCI’ın kümenizle güvenli bir şekilde kimlik doğrulaması yapmasını sağlar.
* DIGITALOCEAN_ACCESS_TOKEN (isteğe bağlı): Eğer CircleCI pipeline’ınız içinde doctl komutlarını kullanmayı planlıyorsanız (örneğin, küme bilgilerini sorgulamak için), DigitalOcean API anahtarınızı burada saklayabilirsiniz. Ancak bu rehberde kubeconfig üzerinden kubectl kullanacağımız için zorunlu değildir.

Adım 5: .circleci/config.yml Dosyası Oluşturma

Bu dosya, CircleCI pipeline’ımızın kalbidir. İki ana iş (job) tanımlayacağız: biri Docker imajını oluşturup göndermek için, diğeri ise bu imajı Kubernetes kümesine dağıtmak için.

.circleci/config.yml:

version: 2.1

Orbs, CircleCI'a önceden paketlenmiş komutlar ve işler eklemenizi sağlar.
Bu örnekte doctl orb'unu kullanmayacağız, ancak ihtiyacınız olursa ekleyebilirsiniz.
orbs:
doctl: digitalocean/doctl@x.y # En güncel versiyonu kullanın

jobs:
  build_and_push_docker_image:
    docker:
      - image: cimg/base:2023.09 # Docker CLI'ı içeren bir temel imaj
    steps:
      - checkout # Git deposunu klonla
      - setup_remote_docker: # Docker komutlarını çalıştırmak için uzak bir Docker ortamı ayarla
          version: 20.10.18 # Docker CLI versiyonu
      - run:
          name: Log in to Docker Hub
          command: echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin
      - run:
          name: Build Docker image
          command: docker build -t $DOCKER_USER/$DOCKER_REPO:$CIRCLE_SHA1 -t $DOCKER_USER/$DOCKER_REPO:latest .
      - run:
          name: Push Docker image to Docker Hub
          command: docker push $DOCKER_USER/$DOCKER_REPO --all-tags

  deploy_to_kubernetes:
    docker:
      - image: cimg/base:2023.09 # kubectl'i kurmak için temel imaj
    steps:
      - checkout # Git deposunu klonla
      - run:
          name: Install kubectl
          command: |
            curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
            chmod +x ./kubectl
            sudo mv ./kubectl /usr/local/bin/kubectl
      - run:
          name: Decode and save Kubeconfig
          command: |
            echo "$KUBECONFIG_ENCODED" | base64 -d > /tmp/kubeconfig
            chmod 600 /tmp/kubeconfig
      - run:
          name: Deploy to DigitalOcean Kubernetes
          command: |
            export KUBECONFIG=/tmp/kubeconfig
            kubectl apply -f .kubernetes/
            kubectl set image deployment/my-app-deployment my-app=$DOCKER_USER/$DOCKER_REPO:$CIRCLE_SHA1 --record

workflows:
  build_and_deploy:
    jobs:
      - build_and_push_docker_image
      - deploy_to_kubernetes:
          requires:
            - build_and_push_docker_image # Dağıtım işi, Docker imajı oluşturulduktan sonra çalışır
          filters:
            branches:
              only: main # Sadece 'main' dalına yapılan push'larda dağıtımı tetikle

config.yml Açıklaması:

* version: 2.1: CircleCI yapılandırma dosyasının versiyonunu belirtir.
* jobs:
* build_and_push_docker_image:
* docker: - image: cimg/base:2023.09: Bu işin çalışacağı Docker imajını belirtir. Bu imaj, Docker CLI’ı içerir.
* checkout: Depoyu CircleCI çalışma alanına klonlar.
* setup_remote_docker: Docker komutlarını çalıştırmak için izole bir Docker ortamı sağlar.
* docker login: Ortam değişkenlerinden alınan kullanıcı adı ve parola ile Docker Hub’a giriş yapar.
* docker build: Uygulama kodundan bir Docker imajı oluşturur. İki etiket kullanırız: biri benzersiz CIRCLE_SHA1 commit hash’i ile, diğeri ise latest olarak. Bu, geri dönüş (rollback) yapmayı veya belirli bir versiyonu hedeflemeyi kolaylaştırır.
* docker push: Oluşturulan imajı Docker Hub’a gönderir.
* deploy_to_kubernetes:
* docker: - image: cimg/base:2023.09: Bu işin çalışacağı Docker imajı.
* install kubectl: kubectl komut satırı aracını indirir ve yükler.
* Decode and save Kubeconfig: KUBECONFIG_ENCODED ortam değişkenindeki Base64 kodlu kubeconfig dosyasını çözer ve geçici bir dosyaya kaydeder. chmod 600 ile dosya izinlerini ayarlarız.
* Deploy to DigitalOcean Kubernetes:
* export KUBECONFIG=/tmp/kubeconfig: kubectl‘in doğru kubeconfig dosyasını kullanmasını sağlar.
* kubectl apply -f .kubernetes/: .kubernetes/ dizinindeki tüm manifest dosyalarını Kubernetes kümesine uygular. Bu, Deployment ve Service nesnelerini oluşturur veya günceller.
* kubectl set image deployment/my-app-deployment my-app=$DOCKER_USER/$DOCKER_REPO:$CIRCLE_SHA1 --record: Bu komut, mevcut Deployment‘ı yeni oluşturulan Docker imajıyla günceller. --record bayrağı, değişikliklerin geçmişini tutar ve gerektiğinde geri dönüş yapmayı kolaylaştırır.
* workflows:
* build_and_deploy: Bu iş akışı, build_and_push_docker_image işini çalıştırır ve ardından bu iş başarıyla tamamlandığında deploy_to_kubernetes işini çalıştırır.
* filters: deploy_to_kubernetes işinin yalnızca main dalına yapılan push işlemlerinde tetiklenmesini sağlar. Bu, geliştirme dallarında sadece imajın oluşturulup test edilmesini, dağıtımın ise sadece ana dala birleştirilen kodlar için yapılmasını sağlar.

Test ve Dağıtım

Tüm bu yapılandırmaları yaptıktan sonra, projenizi GitHub/GitLab’a push ettiğinizde (özellikle main dalına), CircleCI otomatik olarak tetiklenmeli ve pipeline’ınızı çalıştırmalıdır.

1. Kodunuzu yerel makinenizde değişiklik yapın ve Git’e commit edin.
2. git push origin main komutuyla main dalına push yapın.
3. CircleCI paneline gidin ve projenizin “Workflows” bölümünü izleyin. build_and_push_docker_image işinin başarıyla tamamlandığını ve ardından deploy_to_kubernetes işinin başladığını görmelisiniz.
4. Her iki iş de başarıyla tamamlandığında, uygulamanız DigitalOcean Kubernetes kümenize dağıtılmış olacaktır.
5. Uygulamanızın çalıştığını doğrulamak için, DigitalOcean kontrol panelinden kümenizin detaylarına gidin. “Load Balancers” bölümünde yeni bir Load Balancer’ın oluşturulduğunu ve bir IP adresi atandığını görmelisiniz. Bu IP adresini tarayıcınızda açtığınızda “Hello from DigitalOcean Kubernetes with CircleCI!” mesajını görmelisiniz. Alternatif olarak, kubectl get services komutunu kullanarak Service’inizin EXTERNAL-IP adresini alabilirsiniz.

export KUBECONFIG=/tmp/kubeconfig # Veya kendi kubeconfig dosyanızın yolu
kubectl get services -n default

my-app-service için EXTERNAL-IP sütunundaki IP adresini not alın.

Güvenlik ve En İyi Uygulamalar

Otomatik dağıtım süreçlerini uygularken güvenlik ve en iyi uygulamaları göz önünde bulundurmak kritik öneme sahiptir.

* Hassas Bilgilerin Yönetimi: DOCKER_PASS ve KUBECONFIG_ENCODED gibi hassas bilgileri asla kod deponuzda saklamayın. CircleCI’ın ortam değişkenleri veya Vault gibi gizli yönetim araçları, bu tür bilgileri güvenli bir şekilde saklamak için kullanılmalıdır.
* Minimum Yetkilendirme Prensibi: Kubernetes kümeniz için CircleCI’ın kullanacağı kimlik bilgilerine (kubeconfig) yalnızca dağıtım için gerekli olan minimum yetkileri verin. Örneğin, sadece belirli bir namespace’e dağıtım yapma veya belirli kaynakları güncelleme yetkisi gibi.
* Image Tagging ve Versiyonlama: Docker imajlarınızı latest etiketiyle birlikte CIRCLE_SHA1 veya semantik versiyonlama (örneğin, v1.2.3) gibi benzersiz etiketlerle etiketleyin. Bu, belirli bir imajı geri döndürmeyi veya sorun gidermeyi kolaylaştırır.
* Rollback Stratejileri: Dağıtımda bir sorun yaşanması durumunda hızlı bir şekilde önceki kararlı versiyona geri dönebilmek için bir rollback stratejisi belirleyin. kubectl rollout undo deployment/my-app-deployment gibi komutlar Kubernetes’te geri dönüş yapmayı sağlar.
* Sağlık Kontrolleri (Liveness/Readiness Probes): Kubernetes Deployment‘larınızda Liveness ve Readiness Probes tanımlayarak uygulamanızın sağlıklı olup olmadığını otomatik olarak kontrol edin. Bu, sorunlu pod’ların trafik almasını engeller ve otomatik olarak yeniden başlatılmasını sağlar.
* Test Otomasyonu: CI sürecinin temel amacı, kod değişikliklerinin entegrasyonunu ve testini otomatikleştirmektir. Dağıtım öncesinde birim testleri, entegrasyon testleri ve hatta uçtan uca testler çalıştırmak, üretim ortamına giden hataları büyük ölçüde azaltır. Bu rehberde test adımlarını atladık, ancak gerçek bir projede build_and_push_docker_image işinin içine test adımlarını eklemeniz şiddetle tavsiye edilir.

Sorun Giderme ve Yaygın Hatalar

Otomatik dağıtım süreçlerinde karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* kubectl Kimlik Doğrulama Sorunları:
* KUBECONFIG_ENCODED ortam değişkeninin doğru Base64 kodlu kubeconfig içeriğini içerdiğinden emin olun.
* kubeconfig dosyasının CircleCI konteyneri içinde doğru yola (örneğin, /tmp/kubeconfig) kaydedildiğinden ve KUBECONFIG ortam değişkeninin doğru şekilde ayarlandığından emin olun.
* Kubernetes kümenizin erişilebilir olduğundan ve kimlik bilgilerinin süresinin dolmadığından emin olun.
* Docker İmajı Çekme Hataları:
* DOCKER_USER ve DOCKER_PASS ortam değişkenlerinin doğru olduğundan emin olun.
* Dockerfile‘ınızın hatalı olmadığından ve imajın başarıyla oluşturulup Docker Hub’a gönderildiğinden emin olun.
* Kubernetes Deployment manifestindeki imaj adının (your-dockerhub-username/my-app:latest) doğru olduğundan emin olun.
* Kubernetes Manifest Hataları:
* deployment.yaml veya service.yaml dosyalarınızın YAML sözdizimi hataları içermediğinden emin olun. kubectl apply -f .kubernetes/ --dry-run=client komutuyla yerel olarak doğrulayabilirsiniz.
* Manifest dosyalarındaki etiketlerin (labels) ve seçicilerin (selectors) doğru bir şekilde eşleştiğinden emin olun.
* Ortam Değişkeni Eksiklikleri:
* CircleCI projenizin ayarlarında tüm gerekli ortam değişkenlerinin (DOCKER_USER, DOCKER_PASS, KUBECONFIG_ENCODED, DOCKER_REPO) tanımlandığından emin olun.

Sonuç

Bu makalede, DigitalOcean Kubernetes’e CircleCI kullanarak otomatik dağıtımlar yapmanın tüm adımlarını detaylı bir şekilde inceledik. Bir uygulamanın Docker imajının oluşturulmasından, bir container registry’ye gönderilmesine ve son olarak Kubernetes kümesine dağıtılmasına kadar uçtan uca bir CI/CD pipeline’ı kurduk. Bu otomasyon, geliştirme süreçlerinizi hızlandıracak, hataları azaltacak ve yazılım teslimatlarınızı daha güvenilir hale getirecektir.

CI/CD ve Kubernetes dünyası sürekli gelişmektedir. Bu temel kurulumun üzerine Helm ile paket yönetimi, Kustomize ile yapılandırma özelleştirmeleri veya ArgoCD gibi GitOps araçları ile daha gelişmiş dağıtım stratejileri ekleyerek süreçlerinizi daha da optimize edebilirsiniz. Unutmayın, otomasyon, sürekli iyileştirme yolculuğunun sadece başlangıcıdır.