Dagger: Programmable CI/CD Engine

Dagger เป็น programmable CI/CD engine ที่ช่วยให้คุณเขียน pipeline เป็น code ด้วยภาษาโปรแกรมจริง (เช่น Go, Python, TypeScript) แทนที่จะใช้ YAML configuration files ที่มักซับซ้อนและยากต่อการจัดการ

Dagger ถูกสร้างโดยทีมผู้สร้าง Docker (Solomon Hykes) และออกแบบมาเพื่อแก้ปัญหาหลักของ CI/CD แบบดั้งเดิม:

• "Works on my machine" problem: Pipeline ที่ทำงานบน local ไม่เหมือนกับบน CI server
• YAML complexity: YAML files ที่ขยายใหญ่ขึ้นและยากต่อการอ่าน/แก้ไข
• Vendor lock-in: Pipeline ที่ผูกติดกับ CI provider เฉพาะ
• Slow feedback loop: ต้อง push code ไปที่ remote repository ทุกครั้งเพื่อทดสอบ pipeline

ด้วย Dagger คุณสามารถเขียน pipeline ครั้งเดียวแล้วรันได้ทั้งบน local machine และ CI/CD platform ใดก็ได้ (GitHub Actions, GitLab CI, Jenkins, etc.) โดยใช้ container เป็น execution environment

ก่อนเริ่มใช้งาน Dagger คุณต้องมีสิ่งต่อไปนี้:

Core Features

if os == "linux":
    build_linux()
elif os == "windows":
    build_windows()
else:
    build_macos()

การติดตั้ง Dagger ทำได้หลายวิธี ขึ้นอยู่กับระบบปฏิบัติการและความต้องการของคุณ

วิธีที่ 1: ติดตั้งบน Ubuntu/Debian

# Download และติดตั้ง Dagger CLI
curl -L https://dl.dagger.io/dagger/install.sh | DAGGER_VERSION=0.14.0 sh

# เพิ่มไปที่ PATH
sudo mv ./dagger /usr/local/bin/

# ตรวจสอบการติดตั้ง
dagger version

วิธีที่ 2: ใช้ Docker (ไม่ต้องติดตั้ง)

# รัน Dagger ผ่าน Docker container
docker run --rm -v $(pwd):/work -w /work \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/dagger/dagger:latest \
  dagger version

วิธีที่ 3: ติดตั้งผ่าน Package Manager

brew install dagger/tap/dagger

scoop bucket add dagger
scoop install dagger

ในส่วนนี้เราจะสร้าง simple pipeline สำหรับ build และ test Node.js application

Step 1: Initialize Dagger Project

# สร้าง directory สำหรับ project
mkdir my-dagger-project
cd my-dagger-project

# Initialize Dagger project (เลือกภาษา)
dagger init --sdk=python
# หรือ
dagger init --sdk=go
# หรือ
dagger init --sdk=typescript

Step 2: เขียน Pipeline (Python Example)

import dagger
from dagger import dag, function, object_type

@object_type
class MyApp:
    @function
    async def build(self, source: dagger.Directory) -> dagger.Directory:
        """Build Node.js application"""
        return await (
            dag.container()
            .from_("node:18-alpine")
            .with_directory("/src", source)
            .with_workdir("/src")
            .with_exec(["npm", "ci"])
            .with_exec(["npm", "run", "build"])
            .directory("/src/dist")
        )
    
    @function
    async def test(self, source: dagger.Directory) -> str:
        """Run tests"""
        return await (
            dag.container()
            .from_("node:18-alpine")
            .with_directory("/src", source)
            .with_workdir("/src")
            .with_exec(["npm", "ci"])
            .with_exec(["npm", "test"])
            .stdout()
        )
    
    @function
    async def docker_image(self, source: dagger.Directory, tag: str = "latest") -> str:
        """Build Docker image"""
        build_dir = await self.build(source)
        
        return await (
            dag.container()
            .from_("nginx:alpine")
            .with_directory("/usr/share/nginx/html", build_dir)
            .publish(f"myapp:{tag}")
        )

Step 3: รัน Pipeline Locally

# รัน build function
dagger call build --source=. --progress=plain

# รัน test function
dagger call test --source=.

# Build Docker image
dagger call docker-image --source=. --tag=v1.0.0

Step 4: ตัวอย่างเพิ่มเติม (Go & TypeScript)

package main

import (
    "context"
    "dagger.io/dagger"
)

func main() {
    ctx := context.Background()
    client, err := dagger.Connect(ctx)
    if err != nil { panic(err) }
    defer client.Close()
    
    source := client.Host().Directory(".")
    
    node := client.Container().
        From("node:18").
        WithDirectory("/src", source).
        WithWorkdir("/src")
    
    build := node.WithExec([]string{"npm", "run", "build"})
    
    output := build.Directory("./dist")
    _, err = output.Export(ctx, "./dist")
    if err != nil { panic(err) }
}

import { connect, Container } from "@dagger.io/dagger";

async function main() {
  const client = await connect();
  
  const source = client.host().directory(".");
  
  const node = client.container()
    .from("node:18")
    .withDirectory("/src", source)
    .withWorkdir("/src");
  
  const build = node.withExec(["npm", "run", "build"]);
  
  const output = build.directory("./dist");
  await output.export("./dist");
  
  await client.close();
}

main();

สำหรับทีมพัฒนาและบริษัทเทคโนโลยีในประเทศไทย Dagger สามารถช่วยแก้ปัญหาหลายอย่างที่พบเจอในการทำ CI/CD

💡 ประโยชน์สำหรับทีมไทย

🏢 Use Cases สำหรับบริษัทไทย

📊 ตัวอย่างจริง: Thai Tech Company

Dagger ทำงานร่วมกับ CI/CD platforms และ tools อื่นๆ ได้อย่างดี

# .github/workflows/dagger.yml
name: Dagger Pipeline
on: [push]

jobs:
  dagger:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dagger/dagger-for-github@v4
        with:
          version: 0.14.0
      - run: dagger call build
      - run: dagger call test

# .gitlab-ci.yml
image: docker:latest

services:
  - docker:dind

stages:
  - dagger

dagger:
  stage: dagger
  script:
    - apk add curl
    - curl -L https://dl.dagger.io/dagger/install.sh | sh
    - ./dagger version
    - ./dagger call build
    - ./dagger call test

// Jenkinsfile
pipeline {
    agent { docker { image 'docker:latest' } }
    
    stages {
        stage('Dagger') {
            steps {
                sh '''
                curl -L https://dl.dagger.io/dagger/install.sh | sh
                ./dagger call build
                ./dagger call test
                '''
            }
        }
    }
}

Daggerverse: Ecosystem ของ Modules

Daggerverse เป็น registry สำหรับ Dagger modules ที่ community สร้างขึ้น คุณสามารถค้นหาและใช้งาน modules สำเร็จรูปได้:

✅ Best Practices สำหรับการใช้ Dagger

# ใช้ directory caching สำหรับ dependencies
.with_mounted_cache("/src/node_modules", 
    dag.cache_volume("node-modules"))

# ใช้ secrets
.with_secret_variable("DOCKER_PASSWORD", 
    dag.set_secret("docker-pass", "..."))

🔧 Troubleshooting ปัญหาที่พบบ่อย

# ตรวจสอบ Docker
docker ps
# หากไม่ได้ ให้ start Docker
sudo systemctl start docker

# Start buildkitd
docker run -d --name buildkitd --privileged \
  moby/buildkit:latest

# หรือให้ Dagger จัดการเอง (recommended)
export DAGGER_HOST=docker-container://buildkitd

dagger call build --progress=plain

Dagger เป็นเครื่องมือที่มีแนวคิดใหม่สำหรับการทำ CI/CD โดยเปลี่ยนจากการเขียน YAML configuration เป็นการเขียน pipeline logic ด้วยภาษาโปรแกรมจริง ซึ่งให้ประโยชน์หลายด้านสำหรับทีมพัฒนา

🎯 Key Takeaways

• Programmable pipelines: เขียน CI/CD logic ด้วย Go, Python, หรือ TypeScript แทน YAML
• Local & CI parity: รัน pipeline เดียวกันได้ทั้งบน local และ CI server
• Container-native: ใช้ container เป็น execution environment สำหรับแต่ละ step
• Portable: Pipeline ทำงานได้กับทุก CI platform ที่รัน container ได้
• Composable: สร้าง reusable modules และ functions สำหรับองค์กร

🚀 ต่อไปทำอะไร?