Node.js Uygulamasını DigitalOcean Kubernetes’e Semaphore CI/CD ile Dağıtma Rehberi

Node.js Uygulamasını DigitalOcean Kubernetes’e Semaphore CI/CD ile Dağıtma Rehberi

Giriş

Modern yazılım geliştirme süreçleri, hız, güvenilirlik ve ölçeklenebilirlik gibi temel gereksinimleri karşılamak üzere sürekli evrim geçirmektedir. Bu evrimin merkezinde Sürekli Entegrasyon (CI) ve Sürekli Dağıtım (CD) pratikleri, konteynerizasyon teknolojileri (Docker) ve konteyner orkestrasyon platformları (Kubernetes) yer almaktadır. Özellikle Node.js gibi dinamik ve hızlı geliştirme süreçlerine olanak tanıyan dillerle oluşturulan uygulamalar için bu teknolojilerin entegrasyonu kritik öneme sahiptir.

Bu makalede, bir Node.js uygulamasını sıfırdan oluşturacak, Docker kullanarak konteynerize edecek, DigitalOcean Kubernetes (DOKS) üzerinde bir küme kuracak ve son olarak Semaphore CI/CD platformunu kullanarak bu uygulamanın otomatik olarak derlenmesini, test edilmesini ve Kubernetes kümesine dağıtılmasını sağlayacağız. Amacımız, geliştiricilere uçtan uca, üretim ortamına hazır bir CI/CD hattı oluşturma konusunda kapsamlı bir rehber sunmaktır. Bu süreç, geliştirme döngüsünü hızlandırırken, insan hatasını minimize edecek ve dağıtım süreçlerini standartlaştıracaktır.

Ön Koşullar ve Gerekli Araçlar

Bu rehberi takip edebilmek için aşağıdaki araçların sisteminizde kurulu olması ve ilgili platformlarda hesaplarınızın bulunması gerekmektedir:

Geliştirme Ortamı Araçları

* Node.js ve npm/yarn: Node.js uygulamamızı geliştirmek ve bağımlılıklarını yönetmek için gereklidir. Tercihen LTS (Uzun Süreli Destek) sürümü kullanılması önerilir.
* Git: Kaynak kod yönetimi ve Semaphore ile entegrasyon için bir Git istemcisi ve GitHub/GitLab/Bitbucket gibi bir Git sağlayıcısında bir hesap.
* Docker: Uygulamamızı konteynerize etmek ve yerel olarak test etmek için Docker Desktop veya Docker Engine.
* Kubectl: Kubernetes kümesiyle etkileşim kurmak için Kubernetes komut satırı aracı.

Bulut ve CI/CD Platformları

* DigitalOcean Hesabı: Kubernetes kümemizi barındırmak için bir DigitalOcean hesabı.
* Semaphore Hesabı: CI/CD hattımızı oluşturmak ve yönetmek için bir Semaphore hesabı.
* DigitalOcean API Token: Semaphore’un DigitalOcean hesabınızla etkileşim kurabilmesi için bir API token’a ihtiyacımız olacak. Bu token’ı DigitalOcean kontrol panelinden oluşturabilirsiniz (API -> Tokens/Keys -> Generate New Token). Okuma ve Yazma izinlerinin her ikisi de olmalıdır.

Node.js Uygulaması Oluşturma

Öncelikle, dağıtımını yapacağımız basit bir Node.js uygulaması oluşturalım. Bu uygulama, gelen HTTP isteklerine “Merhaba, Kubernetes!” şeklinde yanıt veren küçük bir Express sunucusu olacaktır.

Basit Bir Node.js Uygulaması

Yeni bir dizin oluşturun ve içine girin:

mkdir nodejs-kubernetes-app
cd nodejs-kubernetes-app

package.json dosyasını başlatın ve Express bağımlılığını ekleyin:

npm init -y
npm install express

Şimdi, index.js adında bir dosya oluşturun ve içine aşağıdaki kodu yapıştırın:

const express = require('express');
const app = express();
const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Merhaba, Kubernetes! Uygulama v1.0');
});

app.listen(port, () => {
  console.log(Uygulama ${port} portunda çalışıyor.);
});

Bu kod, PORT ortam değişkeninden veya varsayılan olarak 3000 portundan gelen istekleri dinleyen basit bir Express sunucusu başlatır.

Uygulamayı Yerel Olarak Test Etme

Uygulamanın doğru çalıştığından emin olmak için yerel olarak çalıştırın:

node index.js

Tarayıcınızda http://localhost:3000 adresine giderek “Merhaba, Kubernetes! Uygulama v1.0” mesajını görmelisiniz.

Uygulamayı Konteynerize Etme (Docker)

Uygulamamızı Kubernetes’e dağıtmadan önce, onu bir Docker imajına dönüştürmemiz gerekir. Bu, uygulamanın tüm bağımlılıkları ve çalışma zamanı ortamıyla birlikte taşınabilir ve izole bir paket haline gelmesini sağlar.

Dockerfile Oluşturma

Uygulama dizininizin kökünde Dockerfile adında bir dosya oluşturun ve içine aşağıdaki içeriği ekleyin:

# Node.js uygulamasını çalıştırmak için temel imajı belirle
FROM node:16-alpine

Uygulama kaynak kodunun kopyalanacağı çalışma dizinini belirle
WORKDIR /app

package.json ve package-lock.json dosyalarını kopyala
Bu adım, bağımlılıkların önbelleğe alınmasını sağlar
COPY package*.json ./

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

Uygulama kaynak kodunu kopyala
COPY . .

Uygulamanın dinleyeceği portu belirt
EXPOSE 3000

Uygulamayı başlatma komutunu belirle
CMD ["node", "index.js"]

Bu Dockerfile, çok aşamalı bir derleme (multi-stage build) olmasa da, çoğu Node.js uygulaması için iyi bir başlangıç noktasıdır. node:16-alpine imajı, küçük boyutu nedeniyle tercih edilmiştir.

Ayrıca, Docker imajına dahil etmek istemediğiniz dosyaları belirtmek için .dockerignore adında bir dosya oluşturun:

node_modules
npm-debug.log
.git
.gitignore
Dockerfile
README.md

Bu, imaj boyutunu küçültmeye ve gereksiz dosyaların imaja dahil edilmesini önlemeye yardımcı olur.

Docker İmajını Oluşturma ve Test Etme

Şimdi Docker imajını oluşturalım ve yerel olarak test edelim:

docker build -t nodejs-app-kubernetes .

İmaj başarıyla oluşturulduktan sonra, bir konteyner olarak çalıştırın:

docker run -p 3000:3000 nodejs-app-kubernetes

Tarayıcınızda tekrar http://localhost:3000 adresine giderek uygulamanın Docker konteyneri içinde çalıştığını doğrulayabilirsiniz.

DigitalOcean Kubernetes Kümesi Kurulumu

Uygulamamız konteynerize edildiğine göre, onu dağıtacağımız Kubernetes kümesini DigitalOcean üzerinde oluşturalım.

DigitalOcean Hesabı ve Projesi

DigitalOcean hesabınıza giriş yapın. Eğer birden fazla projeniz varsa, bu küme için yeni bir proje oluşturabilir veya mevcut bir projeyi kullanabilirsiniz. Projeler, kaynaklarınızı düzenlemenize yardımcı olur.

Kubernetes Kümesi Oluşturma

DigitalOcean kontrol panelinde sol menüden “Kubernetes” seçeneğine tıklayın ve “Create a Kubernetes Cluster” düğmesine basın.
* Choose a datacenter region: Uygulamanızın hedef kitlesine en yakın bölgeyi seçin (örneğin, Frankfurt, London, New York).
* Choose a Kubernetes version: En son kararlı sürümü seçin.
* Add node pools: Düğüm havuzları, kümenizin fiziksel sunucularını (Droplets) temsil eder.
* Node plan: Geliştirme veya küçük uygulamalar için “Basic” plan yeterli olabilir. Üretim ortamları için daha güçlü makineler seçmelisiniz. Örneğin, “s-2vcpu-4gb” planını seçebiliriz.
* Nodes: Başlangıç için 2 veya 3 düğüm yeterli olacaktır. Yüksek erişilebilirlik için en az 2 düğüm önerilir.
* Choose a name: Kümeniz için açıklayıcı bir ad verin (örneğin, nodejs-prod-cluster).
* Choose a project: Kümenizi ilgili bir projeye atayın.

“Create Cluster” düğmesine tıkladıktan sonra, kümenizin oluşturulması birkaç dakika sürecektir.

Kubectl Yapılandırması

Küme oluşturulduktan sonra, DigitalOcean kontrol panelinden kümenizin detay sayfasına gidin. Burada “Actions” menüsünden “Download Config File” seçeneğini göreceksiniz. Bu dosyayı indirin veya daha iyisi, doctl komut satırı aracını kullanarak yapılandırmayı otomatik olarak kaydedin.

doctl aracını henüz yüklemediyseniz, DigitalOcean dokümantasyonundan kurulum talimatlarını takip edin. Yüklendikten sonra, DigitalOcean API token’ınızla kimlik doğrulaması yapın:

doctl auth init

Ardından, kümenizin yapılandırmasını yerel kubeconfig dosyanıza kaydedin. Küme adınızı veya ID’nizi kullanabilirsiniz:

doctl kubernetes cluster kubeconfig save 

Örneğin:

doctl kubernetes cluster kubeconfig save nodejs-prod-cluster

Bu komut, ~/.kube/config dosyanıza kümenizin kimlik doğrulama bilgilerini ekleyecektir.

Bağlantıyı test etmek için:

kubectl get nodes

Kümenizdeki düğümleri listelediğini görmelisiniz.

Kubernetes Dağıtım Dosyaları Oluşturma

Uygulamamızı Kubernetes’e dağıtmak için iki temel Kubernetes kaynağına ihtiyacımız var: bir Deployment ve bir Service.

Deployment Tanımı

deployment.yaml adında bir dosya oluşturun:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nodejs-app-deployment
  labels:
    app: nodejs-app
spec:
  replicas: 3 # Uygulamanın 3 kopyasını çalıştır
  selector:
    matchLabels:
      app: nodejs-app
  template:
    metadata:
      labels:
        app: nodejs-app
    spec:
      containers:
      - name: nodejs-app-container
        image: your_docker_registry/nodejs-app-kubernetes:latest # Docker imajınızın yolu
        ports:
        - containerPort: 3000
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
          requests:
            memory: "64Mi"
            cpu: "250m"
        livenessProbe: # Uygulamanın canlı olup olmadığını kontrol eder
          httpGet:
            path: /
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe: # Uygulamanın trafiği kabul etmeye hazır olup olmadığını kontrol eder
          httpGet:
            path: /
            port: 3000
          initialDelaySeconds: 10
          periodSeconds: 10

* apiVersion ve kind: Kaynak türünü belirtir (Deployment).
* metadata: Dağıtımın adı ve etiketleri.
* spec.replicas: Uygulamanızın kaç kopyasının çalışacağını belirtir. Yüksek erişilebilirlik ve yük dengeleme için birden fazla kopya önerilir.
* spec.selector: Bu Deployment’ın hangi Pod’ları yöneteceğini belirler.
* spec.template: Pod şablonu.
* metadata.labels: Pod’a atanacak etiketler.
* spec.containers: Pod içinde çalışacak konteynerlerin listesi.
* name: Konteynerin adı.
* image: Docker imajınızın tam yolu. Buraya DigitalOcean Container Registry veya Docker Hub’daki imajınızın yolunu yazacaksınız. Örneğin, registry.digitalocean.com/my-registry/nodejs-app-kubernetes:latest.
* ports: Konteynerin açığa çıkardığı portlar.
* resources: Konteynerin kullanabileceği CPU ve bellek kaynaklarının limitlerini ve isteklerini belirler. Bu, kümenizin kaynaklarını verimli kullanmak için önemlidir.
* livenessProbe ve readinessProbe: Kubernetes’in uygulamanızın sağlığını ve trafiği kabul etmeye hazır olup olmadığını kontrol etmesini sağlar. Bu, uygulamanızın istikrarlı çalışması için kritik öneme sahiptir.

Service Tanımı

service.yaml adında bir dosya oluşturun:

apiVersion: v1
kind: Service
metadata:
  name: nodejs-app-service
spec:
  selector:
    app: nodejs-app # Bu servis, 'app: nodejs-app' etiketine sahip Pod'ları hedefleyecek
  ports:
    - protocol: TCP
      port: 80 # Servisin dışarıdan dinleyeceği port
      targetPort: 3000 # Pod'un dinlediği port
  type: LoadBalancer # Dışarıdan erişilebilir bir LoadBalancer oluştur

* apiVersion ve kind: Kaynak türünü belirtir (Service).
* metadata: Servisin adı.
* spec.selector: Bu servisin trafiği yönlendireceği Pod’ları belirler. Deployment‘taki etiketle eşleşmelidir.
* spec.ports: Servisin dinleyeceği portlar ve bu portlardan gelen trafiğin Pod’lardaki hangi portlara yönlendirileceği.
* type: LoadBalancer: DigitalOcean’da otomatik olarak bir Yük Dengeleyici (Load Balancer) oluşturur ve uygulamanızı internet üzerinden erişilebilir hale getirir. Alternatif olarak, küme içi iletişim için ClusterIP veya düğüm portu üzerinden erişim için NodePort kullanılabilir.

Önemli: your_docker_registry/nodejs-app-kubernetes:latest kısmını kendi Docker kayıt defterinizdeki imajınızın tam yolu ile değiştirmelisiniz. Bu genellikle registry.digitalocean.com//nodejs-app-kubernetes:latest veya docker.io//nodejs-app-kubernetes:latest şeklinde olacaktır.

Uygulamayı Kubernetes’e Dağıtma (Manuel Test)

CI/CD hattını kurmadan önce, bu dosyaları manuel olarak uygulayarak her şeyin beklendiği gibi çalıştığından emin olabilirsiniz:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

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

kubectl get pods
kubectl get svc

kubectl get svc çıktısında nodejs-app-service için bir EXTERNAL-IP atandığını göreceksiniz. Bu IP adresini tarayıcınızda açarak uygulamanızın Kubernetes üzerinde çalıştığını doğrulayabilirsiniz.

Sürekli Entegrasyon ve Dağıtım (CI/CD) için Semaphore Kullanımı

Şimdi sıra geldi uygulamanın otomatik olarak derlenmesi, test edilmesi ve DigitalOcean Kubernetes kümesine dağıtılması için bir CI/CD hattı oluşturmaya. Bunun için Semaphore CI/CD’yi kullanacağız.

Semaphore’a Giriş

Semaphore, hızlı ve güvenilir CI/CD süreçleri sunan, bulut tabanlı bir platformdur. Özellikle Docker ve Kubernetes entegrasyonları sayesinde modern bulut uygulamaları için ideal bir çözümdür. Semaphore’un hızı, esnekliği ve kolay yapılandırılabilirliği, geliştirme süreçlerini önemli ölçüde hızlandırır.

Proje Oluşturma ve GitHub Bağlantısı

1. Semaphore Hesabı Oluşturma: semaphoreci.com adresine gidin ve GitHub, GitLab veya Bitbucket hesabınızla kaydolun.
2. Yeni Proje Oluşturma: Semaphore kontrol panelinde “Create New Project” düğmesine tıklayın.
3. Depo Seçimi: Uygulama kodunuzu içeren Git deposunu (GitHub, GitLab, Bitbucket) seçin. Semaphore, deponuzu otomatik olarak tarayacak ve bir başlangıç yapılandırması önerecektir.

Semaphore Yapılandırma Dosyası: .semaphore/semaphore.yml

Semaphore, CI/CD hattınızı .semaphore/semaphore.yml adında bir YAML dosyası aracılığıyla yapılandırır. Bu dosyayı projenizin kök dizininde oluşturun.

version: v1.0
name: Node.js Kubernetes Dağıtımı

Semaphore'un CI/CD işlemlerini yürüteceği makineyi tanımlar
agent:
  machine:
    type: e1-standard-2 # Daha hızlı bir makine tipi seçilebilir
    os_image: ubuntu1804 # Ubuntu 18.04 imajı

Global ortam değişkenleri
Bu değişkenler tüm bloklarda kullanılabilir
env_vars:
  - name: DOCKER_IMAGE_NAME
    value: registry.digitalocean.com//nodejs-app-kubernetes # DigitalOcean Container Registry yolunuz
  - name: KUBERNETES_CLUSTER_NAME
    value: nodejs-prod-cluster # DigitalOcean Kubernetes kümenizin adı
  - name: KUBERNETES_DEPLOYMENT_NAME
    value: nodejs-app-deployment
  - name: KUBERNETES_CONTAINER_NAME
    value: nodejs-app-container

Pipeline'ı oluşturan bloklar
blocks:
  - name: Bağımlılıkları Kur ve Test Et
    task:
      jobs:
        - name: Kurulum ve Test
          commands:
            - checkout # Git deposunu kopyala
            - cache restore # Önbelleği geri yükle (node_modules için)
            - npm install # Bağımlılıkları yükle
            - cache store # Önbelleği kaydet
            - npm test # Uygulama testlerini çalıştır (eğer varsa)

  - name: Docker İmajını Oluştur ve Kayıt Defterine Gönder
    task:
      env_vars:
        - name: DOCKER_TAG
          value: ${SEMAPHORE_GIT_SHA} # Git commit SHA'sını etiket olarak kullan
      jobs:
        - name: Docker İşlemleri
          commands:
            # DigitalOcean Container Registry'ye giriş yap
            # DOCKER_USERNAME ve DOCKER_PASSWORD Semaphore Secrets olarak tanımlanmalı
            - echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin ${DOCKER_IMAGE_NAME%%/*}
            - docker build -t ${DOCKER_IMAGE_NAME}:${DOCKER_TAG} .
            - docker push ${DOCKER_IMAGE_NAME}:${DOCKER_TAG}

  - name: Kubernetes'e Dağıt
    task:
      jobs:
        - name: Dağıtım
          commands:
            # DigitalOcean CLI (doctl) kurulumu ve kimlik doğrulama
            - checkout
            - curl -sL https://github.com/digitalocean/doctl/releases/download/v1.73.0/doctl-1.73.0-linux-amd64.tar.gz | tar -xzv
            - sudo mv doctl /usr/local/bin
            # DigitalOcean API token'ı kullanarak kimlik doğrulaması yap
            # DO_API_TOKEN Semaphore Secret olarak tanımlanmalı
            - doctl auth init -t "${DO_API_TOKEN}"
            
            # Kubernetes kümesi yapılandırmasını al
            - doctl kubernetes cluster kubeconfig save ${KUBERNETES_CLUSTER_NAME} --kubeconfig $SEMAPHORE_KUBECONFIG_PATH
            - export KUBECONFIG=$SEMAPHORE_KUBECONFIG_PATH
            - kubectl config use-context do-fra1-${KUBERNETES_CLUSTER_NAME} # Küme bağlamını kullan (bölgeye dikkat)

            # Kubernetes Deployment'ını güncelle
            # Yeni Docker imajı etiketi ile konteyneri güncelle
            - kubectl set image deployment/${KUBERNETES_DEPLOYMENT_NAME} ${KUBERNETES_CONTAINER_NAME}=${DOCKER_IMAGE_NAME}:${DOCKER_TAG}
            - kubectl rollout status deployment/${KUBERNETES_DEPLOYMENT_NAME} # Dağıtımın tamamlanmasını bekle

Yapılandırma Dosyası Açıklaması:

1. agent: CI/CD işlerinin çalışacağı sanal makineyi tanımlar. e1-standard-2 daha iyi performans sunar.
2. env_vars: Pipeline genelinde kullanılacak ortam değişkenlerini tanımlar. DOCKER_IMAGE_NAME kısmını kendi DigitalOcean Container Registry adınızla güncellemeyi unutmayın. Eğer Docker Hub kullanıyorsanız, docker.io//nodejs-app-kubernetes şeklinde olmalıdır.
3. blocks: Pipeline’ı mantıksal aşamalara böler.

* Block 1: Bağımlılıkları Kur ve Test Et
* checkout: Git deposunu Semaphore çalışma dizinine kopyalar.
* cache restore ve cache store: node_modules dizinini önbelleğe alarak sonraki derlemelerde bağımlılıkların tekrar indirilmesini engeller, bu da süreyi kısaltır.
* npm install: Node.js bağımlılıklarını yükler.
* npm test: Uygulamanın testlerini çalıştırır (eğer package.json içinde tanımlıysa).

* Block 2: Docker İmajını Oluştur ve Kayıt Defterine Gönder
* DOCKER_TAG: Git commit’inin SHA’sını Docker imaj etiketi olarak kullanırız. Bu, her dağıtımın benzersiz bir versiyona sahip olmasını sağlar.
* docker login: DigitalOcean Container Registry (veya Docker Hub) kimlik doğrulaması yapar. DOCKER_USERNAME ve DOCKER_PASSWORD güvenli bir şekilde Semaphore Secrets olarak saklanmalıdır (aşağıya bakınız).
* docker build: Docker imajını oluşturur.
* docker push: Oluşturulan imajı kayıt defterine gönderir.

* Block 3: Kubernetes’e Dağıt
* doctl kurulumu ve kimlik doğrulama: Semaphore çalışma ortamına doctl komut satırı aracını indirir ve DigitalOcean API token’ı ile kimlik doğrulaması yapar. DO_API_TOKEN da Semaphore Secret olarak saklanmalıdır.
* doctl kubernetes cluster kubeconfig save: Kubernetes kümesi yapılandırmasını indirir ve Semaphore’un geçici kubeconfig dosyasına kaydeder.
* kubectl config use-context: Kubernetes kümesi bağlamını ayarlar. Küme adınız ve bölgenize göre (do--) bağlam adı değişebilir.
* kubectl set image: Kubernetes Deployment’ınızdaki konteynerin imajını yeni oluşturulan ve kayıt defterine gönderilen imaj etiketiyle günceller. Bu, Kubernetes’in yeni Pod’ları eski Pod’larla değiştirerek uygulamanızı güncellemeyi tetikler (Rolling Update).
* kubectl rollout status: Dağıtımın başarılı bir şekilde tamamlanmasını bekler.

Semaphore Secrets Oluşturma

Güvenlik nedeniyle hassas bilgileri (API token’ları, şifreler) doğrudan .semaphore/semaphore.yml dosyasına yazmamalıyız. Bunun yerine Semaphore Secrets kullanmalıyız.

1. Semaphore kontrol panelinde projenizi seçin.
2. Sol menüden “Configuration” -> “Secrets” seçeneğine gidin.
3. “Create New Secret” düğmesine tıklayın ve aşağıdaki sırları oluşturun:
* DO_API_TOKEN:
* Name: digitalocean-api-token
* Environment variable: DO_API_TOKEN
* Value: DigitalOcean API token’ınız.
* DOCKER_USERNAME:
* Name: docker-credentials
* Environment variable: DOCKER_USERNAME
* Value: DigitalOcean Container Registry kullanıcı adınız (bu genellikle DigitalOcean hesap e-posta adresinizdir) veya Docker Hub kullanıcı adınız.
* DOCKER_PASSWORD:
* Name: docker-credentials (aynı sır adı altında)
* Environment variable: DOCKER_PASSWORD
* Value: DigitalOcean Container Registry şifreniz (bu genellikle DigitalOcean API token’ınızdır) veya Docker Hub şifreniz.

Bu sırları oluşturduktan sonra, .semaphore/semaphore.yml dosyanızdaki blocks kısmının altında secrets bölümünü ekleyerek bu sırları pipeline’ınıza bağlamanız gerekir:

# ... diğer kısımlar ...

blocks:
  - name: Bağımlılıkları Kur ve Test Et
    task:
      jobs:
        - name: Kurulum ve Test
          commands:
            # ... commands ...

  - name: Docker İmajını Oluştur ve Kayıt Defterine Gönder
    task:
      secrets:
        - name: docker-credentials # Oluşturduğunuz secret'ın adı
      env_vars:
        - name: DOCKER_TAG
          value: ${SEMAPHORE_GIT_SHA}
      jobs:
        - name: Docker İşlemleri
          commands:
            # ... commands ...

  - name: Kubernetes'e Dağıt
    task:
      secrets:
        - name: digitalocean-api-token # Oluşturduğunuz secret'ın adı
      jobs:
        - name: Dağıtım
          commands:
            # ... commands ...

Bu değişiklikleri yaptıktan sonra, .semaphore/semaphore.yml dosyanızı ve diğer tüm uygulama dosyalarını Git deponuza commit edin ve push edin. Semaphore otomatik olarak bir pipeline çalıştırması başlatacaktır.

Her başarılı git push işlemi, Semaphore’da otomatik olarak yeni bir derleme ve dağıtım tetikleyecektir. Pipeline’ınızın durumunu Semaphore kontrol panelinden izleyebilirsiniz.

Güvenlik ve En İyi Uygulamalar

CI/CD ve bulut ortamlarında güvenlik, her zaman öncelikli olmalıdır.

* Ortam Değişkenlerinin Güvenli Kullanımı (Semaphore Secrets): Hassas bilgileri (API anahtarları, şifreler) asla doğrudan yapılandırma dosyalarına yazmayın. Semaphore Secrets gibi mekanizmaları kullanarak bu bilgileri şifreli ve güvenli bir şekilde saklayın ve sadece yetkili işlere erişim izni verin.
* En Düşük Ayrıcalık İlkesi (Least Privilege): DigitalOcean API token’ınıza ve Kubernetes Service Account’larınıza yalnızca görevlerini yerine getirmek için kesinlikle gerekli olan minimum izinleri verin. Örneğin, doctl için oluşturduğunuz token’a sadece Kubernetes kümesi yönetimi ve Container Registry erişimi izinleri verin, diğer hizmetlere erişimini kısıtlayın.
* Konteyner Güvenliği:
* Küçük ve güncel temel imajlar kullanın (örn. node:16-alpine).
* Konteyner içinde root kullanıcısı olarak çalışmaktan kaçının. USER node gibi bir komut ekleyerek daha az yetkili bir kullanıcıyla çalışın.
* Gereksiz bağımlılıkları ve araçları imajdan kaldırın.
* Güvenlik tarayıcıları kullanarak imajlardaki bilinen güvenlik açıklarını düzenli olarak kontrol edin.
* Sağlık Kontrolleri (Health Checks): Kubernetes livenessProbe ve readinessProbe kullanarak uygulamanızın sağlığını sürekli izleyin. Bu, sorunlu Pod’ların otomatik olarak yeniden başlatılmasını veya trafikten çıkarılmasını sağlar.
* Geri Alma Stratejileri (Rollback): Bir dağıtım başarısız olursa veya sorunlara yol açarsa, hızlıca önceki kararlı bir sürüme geri dönebilmek için stratejileriniz olmalıdır. Kubernetes Deployment‘ları otomatik olarak geçmiş sürümleri saklar ve kubectl rollout undo komutuyla geri alma imkanı sunar.
* Yapılandırma Yönetimi (ConfigMaps, Secrets): Uygulama yapılandırmalarını ve hassas verileri doğrudan imajın içine gömmek yerine Kubernetes ConfigMaps ve Secrets kullanarak yönetin. Bu, imajları yeniden derlemeden yapılandırma değişiklikleri yapmanıza olanak tanır ve hassas verileri daha güvenli tutar.
* Günlükleme ve İzleme: Uygulamanızın ve kümenizin performansını ve sağlığını izlemek için Prometheus/Grafana gibi araçlar, günlükleri toplamak için ELK Stack (Elasticsearch, Logstash, Kibana) veya diğer merkezi günlükleme çözümleri kurun.

Sonuç ve Gelecek Adımlar

Bu makalede, Node.js uygulamasını DigitalOcean Kubernetes’e Semaphore CI/CD kullanarak dağıtma sürecini adım adım ele aldık. Basit bir Node.js uygulamasını Docker ile konteynerize ettik, DigitalOcean üzerinde bir Kubernetes kümesi kurduk ve son olarak Semaphore CI/CD hattını yapılandırarak otomatik derleme, test ve dağıtım işlemlerini otomatikleştirdik.

Bu süreç, modern yazılım geliştirme pratiklerinin temel taşlarını oluşturmaktadır:
* Otomasyon: Manuel hataları ortadan kaldırır ve dağıtım süreçlerini hızlandırır.
* Hız: Geliştiricilerin kodlarını daha hızlı bir şekilde üretim ortamına ulaştırmasını sağlar.
* Güvenilirlik: Tutarlı ve tekrarlanabilir dağıtımlar sayesinde üretim ortamının istikrarını artırır.
* Ölçeklenebilirlik: Kubernetes’in sağladığı esneklik sayesinde uygulama kolayca ölçeklenebilir.

Gelecek Adımlar:
Bu kurulum, sağlam bir başlangıç noktasıdır. Uygulamanızı daha da geliştirmek ve üretim ortamına uygun hale getirmek için aşağıdaki konuları düşünebilirsiniz:
* Helm Kullanımı: Kubernetes uygulamalarını paketlemek ve yönetmek için Helm kullanmak, karmaşık uygulamaların dağıtımını basitleştirebilir.
* İzleme ve Günlükleme: Uygulamanızın performansını ve hatalarını izlemek için Prometheus, Grafana, ELK Stack gibi araçları entegre edin.
* Daha Gelişmiş CI/CD Senaryoları: Ortam bazlı dağıtımlar (geliştirme, test, üretim), manuel onay adımları, A/B testi dağıtımları gibi daha karmaşık CI/CD stratejilerini keşfedin.
* Veritabanı ve Kalıcı Depolama: Uygulamanızın bir veritabanına ihtiyacı varsa, DigitalOcean Managed Databases veya Kubernetes Persistent Volumes kullanarak kalıcı depolama çözümlerini entegre edin.
* API Gateway ve Ingress: Trafik yönetimi, SSL sonlandırma ve birden fazla hizmeti tek bir giriş noktasından yönetmek için Kubernetes Ingress Controller veya bir API Gateway kullanın.
* Test Otomasyonu: Birim testleri, entegrasyon testleri ve uçtan uca testleri CI/CD hattınıza dahil ederek yazılım kalitesini artırın.

Bu rehberin, Node.js uygulamalarınızı DigitalOcean Kubernetes’e Semaphore CI/CD ile dağıtma yolculuğunuzda size yardımcı olmasını umuyoruz.