Dagger: Modern CI/CD ve İş Akışları için Güçlü Bir Çözüm

8 Mayıs 2025 · netologist · 7 dakika, 1282 kelime

Giriş

Günümüzün yazılım geliştirme dünyasında, otomatikleştirilmiş test ve dağıtım süreçleri (CI/CD) her zamankinden daha önemli hale geldi. Ancak bu süreçlerin yönetimi genellikle karmaşık, zaman alıcı ve hata yapmaya açıktır. Docker’ın yaratıcıları tarafından geliştirilen Dagger, bu sorunlara çözüm getirmek için ortaya çıkan heyecan verici bir araç. Bu blog yazısında, Dagger’ın ne olduğunu, diğer araçlarla nasıl karşılaştırıldığını ve gerçek dünya senaryolarında nasıl kullanılabileceğini detaylı olarak inceleyeceğiz.

Dagger Nedir ve Nasıl Çalışır?

Dagger, bileşimli iş akışları için açık kaynaklı bir çalışma zamanı platformudur. Özellikle çok sayıda hareketli parçası olan ve tekrarlanabilirlik, modülerlik, gözlemlenebilirlik ve platformlar arası destek gerektiren sistemler için mükemmel bir çözüm sunar.

Dagger, konteynerleri, dosyaları, dizinleri, ağ hizmetlerini ve gizli anahtarları yönetmek için çeşitli araçlar sunan Dagger API’sindeki fonksiyonların kombinasyonlarını kullanarak iş akışlarını ifade eder. Bu API’yi iki şekilde çağırabilirsiniz:

Dagger Shell - Doğrudan terminal üzerinden API’yi çağırmak için
Özel Dagger Fonksiyonları - Bir programlama dilinde (Go, Python, TypeScript vb.) yazılmış kodla API’yi çağırmak için

Temel Bir Dagger Örneği

İşte Python’da basit bir Dagger örneği:

import sys
import anyio
import dagger
from dagger import dag

async def main(args: list[str]):
    async with dagger.connection():
        # Cowsay yüklü bir konteyner oluştur
        ctr = (
            dag.container()
            .from_("python:alpine")
            .with_exec(["pip", "install", "cowsay"])
        )
        
        # Cowsay'i istenen mesajla çalıştır
        result = await ctr.with_exec(["cowsay", *args]).stdout()
        print(result)

anyio.run(main, sys.argv[1:])

Bu kodu çalıştırdığınızda (örneğin python main.py "Merhaba Dagger"), bir inek şeklinde “Merhaba Dagger” mesajını verecektir.

Daggerverse: Modüller Ekosistemi

Daggerverse, tüm genel Dagger Fonksiyonlarının aranabilir bir dizinidir. Topluluk tarafından oluşturulan modülleri keşfedebilir, nasıl çalıştıklarını öğrenebilir ve kendi projelerinizde kullanmaya başlayabilirsiniz.

Dagger modülleri, dil bağımsız bir yapıya sahiptir. Yani bir modül Go’da yazılmış olsa bile, Python veya TypeScript’ten çağırılabilir. Bu özellik, farklı ekiplerin kendi tercih ettikleri dillerde çalışmasına olanak tanır.

Dagger vs Testcontainers: Farklar ve Avantajlar

Temel Amaç Farkları

Testcontainers, veritabanları, mesaj aracıları, web tarayıcıları veya Docker konteynerinde çalışabilen her şey için geçici, hafif örnekler sağlayan açık kaynaklı bir kütüphanedir. Temel amacı, entegrasyon testlerini kolaylaştırmaktır.

Dagger ise sadece test ortamı sağlamak için değil, genel olarak CI/CD süreçleri ve otomasyonlu iş akışları için tasarlanmıştır.

Dagger’ın Avantajları

Geniş Kullanım Alanı: Hem test hem de CI/CD süreçleri, otomatik dağıtım ve genel iş akışları için kapsamlı bir çözüm sunar.
Dil Bağımsız Evrensel Tip Sistemi: GraphQL tabanlı evrensel bir tip sistemi kullanır, farklı dillerde yazılmış modüller birlikte çalışabilir.
Modülerlik ve Kompozisyon: Modüller halinde kodlanmış fonksiyonları yeniden kullanabilme ve bunları farklı iş akışlarında birleştirme konusunda esneklik sağlar.
CI/CD Sistemlerine Kolay Entegrasyon: Docker konteynerlerine dayalı tasarımı sayesinde geleneksel CI/CD yöntemlerine göre çeşitli avantajlar sunar.
Yerel Geliştirme ve Test: Dagger CLI kullanarak iş akışlarınızı yerel olarak test edebilme özelliğine sahiptir.
Önbellekleme Sistemi: Tüm işlemleri otomatik olarak önbelleğe alır ve bu önbellekleme her ortamda aynı şekilde çalışır.
Yapay Zeka Entegrasyonu: LLM’ler ile doğal entegrasyon yetenekleri sunar ve AI ajanlarını destekler.

Dagger vs Docker: Tamamlayıcı Teknolojiler

Docker ve Dagger birbirlerinin rakibi değil, birbirlerini tamamlayan teknolojilerdir.

Temel Amaç ve Odak Noktaları

Docker: Uygulamaları konteynerlerde paketlemeye, dağıtmaya ve çalıştırmaya odaklanan bir platformdur.

Dagger: Docker’ın kurucuları tarafından geliştirilen ve CI/CD süreçlerine odaklanan taşınabilir bir geliştirme kitidir.

İlişkileri ve Bağlantıları

Dagger, Docker’ın bir parçası olan BuildKit’i kullanmak üzere tasarlanmıştır ve iş akışlarını konteynerler içinde çalıştırır. BuildKit, gelişmiş önbellek sistemi, yapı görevlerinin paralelleştirilmesi ve Dockerfile’daki yeni özelliklerin desteklenmesi sayesinde eski Docker builder’dan çok daha verimlidir.

Dagger’ın Docker’a Göre Avantajları

İş Akışı Odaklı: Sadece konteynerler oluşturmakla kalmaz, tüm CI/CD süreçlerinizi kod olarak yazmanıza ve bunları standartlaştırmanıza olanak tanır.
Yerel Testler: Dagger CLI kullanarak süreçlerinizi yerel olarak test edebilme yeteneği, geliştirme ve test süreçlerini kolaylaştırır.
Evrensel Tip Sistemi: Farklı dillerde yazılmış modüllerin birlikte çalışabilmesini sağlar.
Otomatik Önbellekleme: İşlemler önbelleğe alınabilen, değişmez artifaktlar üretir.
Entegre Gözlemlenebilirlik: İşlemlere izleme, günlük kaydı ve metriklerle tam görünürlük sağlar.

Docker’ı Dagger’ın yerine değil, Dagger’ı Docker’ı kullanan ve genişleten bir araç olarak düşünmek daha doğrudur. İki teknoloji birlikte kullanılabilir ve birbirlerini tamamlarlar.

Dagger ile Kompleks Bir CI/CD Örneği

Aşağıda, bir Go uygulaması için kapsamlı bir Dagger CI/CD iş akışı örneği bulunmaktadır:

import dagger
from dagger import dag, function, object_type

@object_type
class GoPipeline:
    @function
    async def build_test_deploy(self, source: dagger.Directory) -> str:
        """Tam bir CI/CD iş akışı çalıştırır: lint, test, birden fazla platforma derleme, imaj oluştur, zafiyet tara, yayınla"""
        
        # Sonuçların ortak depolanacağı dizin
        results = []
        
        # Go projesi yapılandırması
        go_project = dag.golang().with_project(source)
        
        # 1. Linting işlemi
        lint_result = await self.lint(source)
        results.append(f"Lint sonucu: {lint_result}")
        
        # 2. Çoklu Go sürümleriyle test etme
        for version in ["1.18", "1.19", "1.20"]:
            test_result = await self.test(source, version)
            results.append(f"Go {version} test sonucu: {test_result}")
        
        # 3. Çoklu mimari için derleme
        platforms = ["linux/amd64", "linux/arm64", "darwin/amd64", "windows/amd64"]
        for platform in platforms:
            build_result = await self.build(source, platform)
            results.append(f"{platform} derleme sonucu: {build_result}")
        
        # 4. Docker imajı oluştur
        image = await go_project.build_container()
        results.append(f"İmaj oluşturuldu: {await image.id()}")
        
        # 5. Güvenlik taraması
        scan_result = await dag.trivy().scan_container(image)
        results.append(f"Güvenlik taraması sonucu: {scan_result}")
        
        # 6. Registr'ye gönderme
        reg_result = await image.publish("my-registry.io/my-app:latest")
        results.append(f"İmaj yayınlandı: {reg_result}")
        
        # 7. Deployment işlemi
        deploy_result = await self.deploy(reg_result)
        results.append(f"Deployment sonucu: {deploy_result}")
        
        return "\n".join(results)
    
    @function
    async def lint(self, source: dagger.Directory) -> str:
        """Go kodunu lint'ler"""
        return await dag.golang().with_project(source).lint()
    
    @function
    async def test(self, source: dagger.Directory, version: str) -> str:
        """Belirli bir Go sürümüyle testleri çalıştırır"""
        return await dag.golang().with_version(version).with_project(source).test()
    
    @function
    async def build(self, source: dagger.Directory, platform: str) -> str:
        """Belirli bir platform için Go uygulamasını derler"""
        os, arch = platform.split("/")
        return await dag.golang().with_project(source).build(os=os, arch=arch)
    
    @function
    async def deploy(self, image_ref: str) -> str:
        """Uygulamayı deploy eder"""
        # Deployment mantığı burada yer alacak
        return f"Başarıyla deploy edildi: {image_ref}"

Bu örnek şunları göstermektedir:

Modülerlik: Her adım ayrı fonksiyonlara bölünmüş
Çoklu Platforma Destek: Çeşitli işletim sistemleri ve mimariler için derleme
Çoklu Sürüm Testi: Farklı Go sürümleriyle test etme
Otomatik Güvenlik Taraması: Trivy modülü ile güvenlik açıklarını tarama
Yayınlama ve Deployment: İmajı registr’ye gönderme ve deployment işlemleri

Dagger vs GitHub Actions: Farklı Yaklaşımlar

Dagger ve GitHub Actions arasındaki temel fark, yaklaşımlarındadır:

1. Kod Tabanlı vs YAML Tabanlı

Dagger: İş akışlarınızı herhangi bir programlama dilinde yazabilir ve dilinizin tüm gücünü kullanabilirsiniz.

GitHub Actions: İş akışları YAML formatında tanımlanır, bu da daha kısıtlayıcı ve daha az programatik bir yaklaşımdır.

2. Yerel Çalıştırma ve Hata Ayıklama

Dagger: İş akışlarınızı yerel olarak hata ayıklayabilir, anında geri bildirim alabilirsiniz.

GitHub Actions: İş akışlarını yerel olarak test etmek zordur.

3. CI/CD Araçları Arasında Taşınabilirlik

Dagger: Küçük ve standartlaştırılmış bir yapılandırma ile çalışır, herhangi bir CI/CD ortamında kullanılabilir.

GitHub Actions: GitHub’a özgüdür, GitHub dışı sürüm kontrol sistemleri için uygun değildir.

4. İş Akışı Yapısı ve Paralel Çalışma

Dagger: Adımları yönlendirilmiş bir asiklik çizge (DAG) olarak düzenler, bağımsız adımlar paralel çalışabilir.

GitHub Actions: İşleri paralel çalıştırabilir, ancak bir iş içindeki adımlar sıralı çalışır.

5. Önbellekleme ve Performans

Dagger: Otomatik ve güçlü önbellekleme sistemi sunar.

GitHub Actions: Manuel yapılandırılması gereken daha sınırlı önbellekleme sunar.

6. Ekosistem ve Entegrasyon

Dagger: Dil bağımsız, modüler yapı sunar.

GitHub Actions: Eylemler Marketplace’te çok sayıda önceden hazırlanmış eylem sunar.

GitHub Actions ile Dagger’ı Birlikte Kullanmak

İlginç bir şekilde, bu iki aracı birlikte kullanabilirsiniz:

name: Dagger CI/CD Pipeline
on:
  push:
    branches: [main]
  pull_request:
jobs:
  dagger:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Run Dagger pipeline
        uses: dagger/dagger-for-github@v7
        with:
          verb: call
          args: build_test_deploy --source=.
          cloud-token: ${{ secrets.DAGGER_CLOUD_TOKEN }}

Bu yaklaşım, Dagger’ın programlanabilirliğini GitHub Actions’ın kolay kurulumu ve entegrasyonuyla birleştirir.

Sonuç

Dagger, modern CI/CD ve iş akışı otomasyonu için güçlü, esnek ve yenilikçi bir çözüm sunmaktadır. Docker’ın kurucuları tarafından geliştirilen ve Docker’ın temel teknolojisini kullanan Dagger, kod tabanlı yaklaşımı, dil bağımsız yapısı ve yerel test özellikleri ile öne çıkmaktadır.

Diğer araçlarla karşılaştırıldığında, Testcontainers’a göre daha kapsamlı ve genel amaçlı bir çözüm sunarken, GitHub Actions gibi YAML tabanlı CI/CD sistemlerine göre daha programatik ve taşınabilir bir alternatif sunmaktadır.

Dagger, özellikle karmaşık iş akışları olan, çoklu dilde geliştirme yapan ve yerel test etme ihtiyacı yüksek olan ekipler için ideal bir seçimdir. Özellikle “push ve dua et” yaklaşımından kurtulmak isteyen yazılım ekipleri için, Dagger gerçek bir devrim niteliğindedir.

Yazılım dünyasındaki CI/CD yaklaşımınızı iyileştirmek, daha modüler, test edilebilir ve taşınabilir hale getirmek istiyorsanız, Dagger’ı mutlaka değerlendirmelisiniz.