Dagger: CI/CD Lập Trình Được với 15K+ Stars — So sánh với GitHub Actions, GitLab CI 2026

{{< resource-info >}}

Giới thiệu #

Lập trình viên trung bình push 3.2 commit mỗi ngày và chờ 12 phút để mỗi lần chạy CI hoàn thành. Nhân lên cho một nhóm 20 kỹ sư, bạn đang nhìn vào 4 giờ chờ đợi tập thể mỗi ngày —— tất cả chỉ vì pipeline CI/CD không thể test locally, bị khóa vào cú pháp YAML độc quyền của từng vendor, và thất bại không thể đoán trước giữa các môi trường.

Dagger, được tạo bởi Solomon Hykes (đồng sáng lập Docker), tiếp cận theo cách khác: coi pipeline CI/CD như code thông thường. Thay vì vật lộn với YAML của GitHub Actions hoặc DSL của GitLab CI, bạn viết automation bằng Go, Python hoặc TypeScript. Pipeline chạy bên trong container sử dụng cùng engine BuildKit điều khiển Docker, mang lại hành vi nhất quán trên laptop và production.

Với 15,829 GitHub stars, 878 forks và 304 contributors tính đến tháng 5/2026, Dagger đã khẳng định mình là một giải pháp thay thế nghiêm túc cho CI/CD truyền thống. Hướng dẫn này đi qua cài đặt Dagger đầy đủ, so sánh trực tiếp với GitHub Actions, GitLab CI và Jenkins, và bao gồm các mô hình tăng cường production có thể triển khai ngay hôm nay.

Dagger là gì? #

Một engine CI/CD lập trình được thực thi pipeline automation bên trong container OCI, cho phép developer định nghĩa logic build, test và deploy bằng ngôn ngữ lập trình đa năng thay vì YAML hoặc DSL độc quyền.

Giá trị cốt lõi #

• Viết một lần, chạy mọi nơi: Cùng một pipeline thực thi nhất quán trên laptop developer, trong GitHub Actions, GitLab CI, hoặc server bare-metal.
• SDK ngôn ngữ native: Hỗ trợ first-class cho Go, Python, TypeScript, PHP, Java, .NET, Elixir và Rust —— bao gồm autocomplete, type checking và unit testing.
• Thực thi container-native: Mỗi bước chạy trong container cách ly, loại bỏ sự khác biệt “chạy được trên máy tôi”.
• Caching thông minh: Caching content-addressed ở cấp operation có nghĩa là các bước không thay đổi không bao giờ chạy lại.
• Quan sát được mặc định: Mỗi operation phát ra OpenTelemetry traces có thể xem trong terminal hoặc export ra Jaeger, Honeycomb hoặc backend OTel bất kỳ.

Dagger hoạt động như thế nào #

Tổng quan kiến trúc #

Kiến trúc của Dagger gồm bốn lớp:

1. Code Pipeline (Go / Python / TypeScript) —— định nghĩa logic bằng Dagger SDK.
2. Dagger SDK —— chuyển đổi native function calls thành GraphQL queries.
3. Dagger Engine —— runtime container dựa trên BuildKit thực thi pipeline graph.
4. Container Runtime —— Docker, Podman hoặc runtime OCI-compliant nào host engine.

┌─────────────────────────────────────────────────────────────┐
│  Pipeline Code (Go/Python/TS)                               │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                 │
│  │  Build   │  │   Test   │  │  Deploy  │                 │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘                 │
└───────┼─────────────┼─────────────┼────────────────────────┘
        │             │             │
        ▼             ▼             ▼
┌─────────────────────────────────────────────────────────────┐
│  Dagger SDK (GraphQL client)                                │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Dagger Engine (BuildKit)                                   │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  DAG Executor  →  Cache Layer  →  Container Ops       │  │
│  └───────────────────────────────────────────────────────┘  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Docker / Podman / OCI Runtime                              │
└─────────────────────────────────────────────────────────────┘

Mô hình thực thi #

Khi bạn chạy pipeline Dagger, SDK chuyển đổi function calls thành Directed Acyclic Graph (DAG) của các operations. Mỗi node trong DAG đại diện cho một container operation: pull image, copy file, chạy command, hoặc export artifact. Dagger Engine lập lịch các operations này với tính song song tự động và cache mọi kết quả trung gian.

# Luồng thực thi DAG mẫu
Pull base image ──┬── Install deps ──┬── Run tests ──┬── Export binary
                  │                   │                │
                  └── Cache hit? Bỏ qua  └── Cache hit?   └── Cache hit?

Các khái niệm chính #

Cài đặt & Thiết lập #

Yêu cầu tiên quyết #

• Docker Engine 24.0+ hoặc Podman 4.0+ chạy locally
• Container runtime có thể truy cập qua default socket

Cài đặt Dagger CLI #

macOS (Homebrew):

# Cài đặt qua Homebrew tap
brew install dagger/tap/dagger

# Xác minh cài đặt
dagger version
# Kỳ vọng: dagger v0.19.7 (registry.dagger.io/engine:v0.19.7)

Linux:

# Cài đặt bằng script chính thức
curl -fsSL https://dl.dagger.io/dagger/install.sh | BIN_DIR=/usr/local/bin sh

# Hoặc với sudo để cài đặt toàn hệ thống
curl -fsSL https://dl.dagger.io/dagger/install.sh | \
  DAGGER_VERSION=0.19.7 BIN_DIR=/usr/local/bin sudo -E sh

# Xác minh
dagger version

Windows:

# Cài đặt qua scoop
scoop bucket add dagger https://github.com/dagger/scoop-bucket
scoop install dagger

# Xác minh
dagger version

Khởi tạo dự án đầu tiên #

# Tạo module Dagger mới
dagger init --sdk=python --source=./dagger my-pipeline

# Hoặc với Go
dagger init --sdk=go --source=./dagger my-pipeline

# Hoặc với TypeScript
dagger init --sdk=typescript --source=./dagger my-pipeline

# Lệnh này tạo ra:
# ├── dagger/
# │   └── src/main.py (hoặc main.go, hoặc index.ts)
# ├── dagger.json
# └── .gitignore

Test nhanh locally #

# dagger/src/main.py — Pipeline Dagger tối thiểu
import dagger
from dagger import dag, function, object_type

@object_type
class MyPipeline:
    @function
    async def hello(self, name: str = "World") -> str:
        return await dag.container()
            .from_("alpine:latest")
            .with_exec(["echo", f"Hello, {name}!"])
            .stdout()

# Chạy function locally
dagger call hello --name="Dagger"

# Output:
# Hello, Dagger!

Tích hợp với Docker, Go, Python và TypeScript #

Tích hợp Docker — Build và Push Image #

Dagger thao tác container trong hệ sinh thái Docker một cách native. Đây là pipeline đầy đủ build, tag và push Docker image:

# dagger/src/main.py — Build và push Docker image
import dagger
from dagger import dag, function, object_type, Directory

@object_type
class CiPipeline:
    @function
    async def build_and_push(
        self,
        source: Directory,
        registry: str,
        username: str,
        password: dagger.Secret,
        repository: str,
        tag: str = "latest"
    ) -> str:
        # Build container từ Dockerfile trong source directory
        image = await dag.container()
            .build(source, dockerfile="Dockerfile")

        # Publish lên container registry
        digest = await image.with_registry_auth(registry, username, password)
            .publish(f"{registry}/{repository}:{tag}")

        return digest

# Chạy function build-and-push
dagger call build-and-push \
  --source=. \
  --registry=ghcr.io \
  --username=$GITHUB_USER \
  --password=env:GITHUB_TOKEN \
  --repository=my-org/my-app \
  --tag=v1.2.3

Go SDK — Pipeline CI đầy đủ #

// dagger/main.go — Pipeline CI Go với testing
dagger "dagger.io/dagger"

import (
    "context"
    "fmt"
    "os"
)

type CiPipeline struct{}

// Run thực thi pipeline CI đầy đủ: lint → test → build
func (m *CiPipeline) Run(ctx context.Context, source *dagger.Directory) (*dagger.File, error) {
    // Định nghĩa Go builder container với source được mount
    builder := dag.Container().
        From("golang:1.24-alpine").
        WithMountedDirectory("/src", source).
        WithWorkdir("/src")

    // Chạy lint
    lint := builder.WithExec([]string{"go", "vet", "./..."})

    // Chạy test với race detection
    tested := lint.WithExec([]string{
        "go", "test", "-race", "-coverprofile=coverage.out", "./...",
    })

    // Build binary
    binary := tested.WithExec([]string{
        "go", "build", "-ldflags=-s -w", "-o", "bin/myapp", "./cmd/myapp",
    })

    // Trích xuất binary đã build như một file
    return binary.File("/src/bin/myapp"), nil
}

# Chạy pipeline Go từ project root
dagger call run --source=. -o ./bin/myapp

Python SDK — Integration Test với Services #

# dagger/src/main.py — Integration test với PostgreSQL service
import dagger
from dagger import dag, function, object_type, Directory, Service

@object_type
class TestPipeline:
    @function
    async def integration_test(self, source: Directory) -> str:
        # Khởi động PostgreSQL service container
        postgres = dag.service(
            dag.container()
            .from_("postgres:16-alpine")
            .with_env_variable("POSTGRES_USER", "test")
            .with_env_variable("POSTGRES_PASSWORD", "test")
            .with_env_variable("POSTGRES_DB", "testdb")
            .with_exposed_port(5432)
        )

        # Chạy integration test chống lại database
        test_result = await (
            dag.container()
            .from_("python:3.12-slim")
            .with_mounted_directory("/app", source)
            .with_service_binding("db", postgres)
            .with_env_variable("DATABASE_URL", "postgresql://test:test@db:5432/testdb")
            .with_workdir("/app")
            .with_exec(["pip", "install", "-r", "requirements-test.txt"])
            .with_exec(["pytest", "tests/integration", "-v", "--tb=short"])
            .stdout()
        )

        return test_result

TypeScript SDK — Build đa nền tảng #

// dagger/src/index.ts — Build container đa nền tảng
import { dag, function, objectType, Directory } from "@dagger.io/dagger";

@objectType
class BuildPipeline {
    @function
    async multiPlatformBuild(source: Directory): Promise<string[]> {
        const platforms = ["linux/amd64", "linux/arm64"];
        const image = dag.container().build(source);

        const digests = await Promise.all(
            platforms.map(async (platform) => {
                return await image
                    .platform(platform)
                    .publish(`ghcr.io/my-org/my-app:${platform.replace("/", "-")}`);
            })
        );

        return digests;
    }
}

Benchmark / Use Case thực tế #

Hiệu năng Caching #

Cache content-addressed của Dagger cung cấp tốc độ đo được so với hệ thống CI truyền thống. Trong benchmark kiểm soát build Go microservice (khoảng 50 dependencies) qua 10 lần chạy liên tiếp:

Insight chính: GitHub Actions và GitLab CI cache Docker layers và dependency directories, nhưng chúng re-execute toàn bộ job graph. Dagger cache ở cấp operation riêng lẻ, nên chỉ các operations thay đổi mới chạy lại.

Case Study: Thay thế 700 dòng GitHub Actions YAML #

Một nhóm kỹ sư đã thay thế workflow GitHub Actions 700 dòng (build, test, push và deploy 3 microservices) bằng pipeline Dagger Python 180 dòng. Kết quả sau 30 ngày:

• Bật chạy pipeline local: developer test thay đổi CI trước khi push (trước đây không thể)
• Thờigian debug CI trung bình: giảm từ 45 phút xuống 5 phút mỗi developer mỗi tuần
• Tiêu thụ phút CI: giảm 34% nhờ caching thông minh
• Trùng lặp code pipeline: loại bỏ thông qua Dagger modules chia sẻ

Daggerverse: Hệ sinh thái Module #

Daggerverse (daggerverse.dev) là registry module cộng đồng. Tính đến tháng 5/2026, nó host 800+ module bao gồm:

• Language toolchains: Go, Python, Node.js, Rust builds
• Cloud deployments: AWS, GCP, Azure, Fly.io
• Security scanning: Trivy, Snyk, SLSA verification
• Testing: k6 load tests, Playwright browser tests

# Cài đặt và sử dụng module từ Daggerverse
dagger -m github.com/kpenfound/blueprints/go call build \
  --source=. --args=./cmd/myapp

# Liệt kê module đã cài đặt
dagger module use github.com/Dudesons/daggerverse/node

Sử dụng nâng cao / Tăng cường Production #

Quản lý Secret #

Không bao giờ truyền secret dạng plain string. Kiểu Secret của Dagger đảm bảo các giá trị nhạy cảm được che trong log và trace:

import dagger
from dagger import dag, function, object_type, Secret

@object_type
class SecurePipeline:
    @function
    async def deploy(
        self,
        kubeconfig: Secret,
        image_digest: str
    ) -> str:
        return await (
            dag.container()
            .from_("bitnami/kubectl:latest")
            .with_mounted_secret("/root/.kube/config", kubeconfig)
            .with_exec([
                "kubectl", "set", "image",
                "deployment/myapp",
                f"myapp={image_digest}",
                "--namespace=production"
            ])
            .stdout()
        )

# Truyền secret từ environment variable
dagger call deploy \
  --kubeconfig=file:$HOME/.kube/config \
  --image-digest=ghcr.io/my-org/my-app@sha256:abc123...

Mẫu thực thi song song #

Dagger tự động song song hóa các operations độc lập. Cấu trúc pipeline một cách rõ ràng để tối đa hóa tính song song:

import asyncio
from dagger import dag, function, object_type, Directory

@object_type
class ParallelPipeline:
    @function
    async def run_parallel(self, source: Directory) -> list[str]:
        # Ba operations này chạy song song tự động
        results = await asyncio.gather(
            self.lint(source),
            self.unit_tests(source),
            self.security_scan(source),
        )
        return list(results)

    async def lint(self, source: Directory) -> str:
        return await dag.container()
            .from_("golangci/golangci-lint:latest")
            .with_mounted_directory("/src", source)
            .with_workdir("/src")
            .with_exec(["golangci-lint", "run", "--timeout=5m"])
            .stdout()

    async def unit_tests(self, source: Directory) -> str:
        return await dag.container()
            .from_("golang:1.24")
            .with_mounted_directory("/src", source)
            .with_workdir("/src")
            .with_exec(["go", "test", "-short", "./..."])
            .stdout()

    async def security_scan(self, source: Directory) -> str:
        return await dag.container()
            .from_("aquasec/trivy:latest")
            .with_mounted_directory("/src", source)
            .with_workdir("/src")
            .with_exec(["trivy", "fs", "--scanners=vuln", "."])
            .stdout()

Monitoring với OpenTelemetry #

Dagger phát ra OpenTelemetry traces cho mọi operation. Export ra backend để có khả năng quan sát pipeline:

# Chạy với OTel export sang Jaeger
export OTEL_EXPORTER_OTLP_ENDPOINT=http://jaeger:4317
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc

dagger call run --source=. --otel-export=auto

# Xem trace trong Jaeger UI tại http://localhost:16686

Tích hợp CI — GitHub Actions #

# .github/workflows/dagger.yml
name: Dagger CI

on: [push, pull_request]

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Chạy pipeline Dagger
        uses: dagger/dagger-for-github@v7
        with:
          version: "0.19.7"
          verb: call
          module: .
          args: run --source=.
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Tích hợp CI — GitLab CI #

# .gitlab-ci.yml
stages: [build]

dagger:build:
  stage: build
  image: docker:24-dind
  services:
    - docker:24-dind
  variables:
    DAGGER_VERSION: "0.19.7"
  before_script:
    - apk add --no-cache curl
    - curl -fsSL https://dl.dagger.io/dagger/install.sh | BIN_DIR=/usr/local/bin sh
  script:
    - dagger call run --source=.
  cache:
    key: dagger-cache
    paths:
      - .dagger-cache/

Tích hợp CI — Jenkins #

// Jenkinsfile
pipeline {
    agent any
    environment {
        DAGGER_VERSION = '0.19.7'
    }
    stages {
        stage('Chạy Pipeline Dagger') {
            steps {
                sh '''
                    curl -fsSL https://dl.dagger.io/dagger/install.sh | \
                        BIN_DIR=/usr/local/bin sh
                    dagger call run --source=.
                '''
            }
        }
    }
}

So sánh với các giải pháp thay thế #

Khi nào chọn từng công cụ #

Chọn Dagger khi:

• Cần test CI/CD pipeline locally trước khi push
• Độ phức tạp pipeline vượt quá ~50 dòng YAML
• Team đã làm việc với Go, Python hoặc TypeScript
• Tránh vendor lock-in là ưu tiên chiến lược

Chọn GitHub Actions khi:

• Repository đã ở trên GitHub
• Workflow đơn giản và hưởng lợi từ marketplace actions
• Team ưu tiên overhead cấu hình tối thiểu

Chọn GitLab CI khi:

• Sử dụng GitLab như nền tảng DevOps chính
• Cần tính năng security scanning và compliance built-in
• DAG pipeline execution cho dependencies phức tạp là quan trọng

Chọn Jenkins khi:

• Cần linh hoạt plugin tối đa
• Infrastructure tự host với kiểm soát hoàn toàn là yêu cầu
• Có chuyên môn Groovy trong nội bộ

Hạn chế / Đánh giá trung thực #

Dagger không phải công cụ phù hợp cho mọi tình huống. Đây là những gì nó không làm tốt:

Đường cong học tập là thực tế. Viết pipeline bằng Go hoặc Python đòi hỏi đầu tư ban đầu nhiều hơn so với copy template YAML GitHub Actions. Các team không thành thạo Go/TypeScript/Python đối mặt với lộ trình áp dụng dốc hơn.

Hệ sinh thái nhỏ hơn. Với ~800 module Daggerverse so với 20,000+ GitHub Actions, đôi khi bạn cần viết chức năng mà trong GitHub Actions chỉ cần một dòng Action step.

Không có lập lịch CI built-in. Dagger là executor pipeline, không phải CI server. Bạn vẫn cần GitHub Actions, GitLab CI hoặc cơ chế trigger khác để chạy pipeline khi push, PR hoặc theo lịch.

Debug phức tạp. Khi pipeline Dagger thất bại bên trong engine BuildKit, trace lỗi có thể dài dòng và đòi hỏi hiểu mô hình thực thi DAG. TUI giúp ích, nhưng debug lỗi container lồng nhau khó hơn đọc log CI tuần tự.

Phối hợp nhóm. Dagger Cloud bắt đầu từ $50/tháng cho 10 user. Tier miễn phí chỉ hỗ trợ observability một user, nghĩa là thêm thành viên thứ hai bắt buộc phải nâng cấp để có shared caching và dashboards.

Câu hỏi thường gặp #

Q: Dagger hỗ trợ những ngôn ngữ lập trình nào? Dagger cung cấp SDK first-party cho tám ngôn ngữ: Go, Python, TypeScript, PHP, Java, .NET, Elixir và Rust. Các SDK Go, Python và TypeScript là trưởng thành và được sử dụng rộng rãi nhất. Mỗi SDK được tạo từ schema GraphQL của Dagger, mang lại type safety đầy đủ và IDE autocomplete.

Q: Dagger có thể thay thế hoàn toàn CI server của tôi không? Không. Dagger là engine thực thi pipeline, không phải nền tảng orchestration CI. Bạn vẫn cần cơ chế trigger —— GitHub Actions, GitLab CI, Jenkins hoặc cron job —— để gọi pipeline Dagger khi có sự kiện push, pull request hoặc chạy theo lịch. Dagger thay thế định nghĩa job dạng YAML, không phải chính CI scheduler.

Q: Cache của Dagger so với Docker layer caching như thế nào? Dagger sử dụng caching content-addressed ở cấp operation, chi tiết hơn Docker layer caching. Nếu bạn thay đổi một file source, Dagger chỉ chạy lại các operations phụ thuộc vào file đó. Docker layer caching vô hiệu hóa tất cả layers sau layer thay đổi. Thực tế, điều này có nghĩa là cache hit của Dagger thường xuyên hơn và rebuild nhanh hơn.

Q: Dagger có phù hợp cho monorepo lớn không? Có, nhưng có điều kiện. Caching content-addressed của Dagger hoạt động tốt trong monorepo vì các package không thay đổi được bỏ qua hoàn toàn. Tuy nhiên, việc xây dựng DAG ban đầu và quét file có thể chậm hơn cho repository rất lớn (10GB+). Nhóm Dagger đang tích cực tối ưu hiệu năng monorepo trong chu kỳ phát hành v0.20.x.

Q: Làm thế nào để migrate workflow GitHub Actions hiện có sang Dagger? Bắt đầu từ từng phần nhỏ. Port từng job một —— thường là job build hoặc test trước. Giữ workflow GitHub Actions làm lớp orchestration và thay thế từng step bằng lệnh gọi dagger call. Cách tiếp cận hybrid này cho phép bạn xác thực Dagger locally trong khi duy trì infrastructure CI hiện có. Dần dần, hợp nhất các job còn lại vào Dagger functions.

Q: Dagger hỗ trợ những container runtime nào? Dagger yêu cầu container runtime Linux: Docker Engine 24.0+, Podman 4.0+, containerd hoặc runtime OCI-compliant bất kỳ. Trên macOS và Windows, cần Docker Desktop hoặc Podman Desktop. Rootless Docker và Podman được hỗ trợ với một số lưu ý cấu hình được ghi trong tài liệu tham khảo chính thức.

Q: Tôi có thể dùng Dagger cho automation không phải CI/CD không? Có. Dagger là nền tảng automation container đa năng. Các nhóm sử dụng nó cho thiết lập môi trường phát triển local, pipeline xử lý dữ liệu, workflow security scanning và kiểm thử infrastructure. Bất kỳ tác vụ nào liên quan đến chạy container với dependencies giữa các bước đều là use case Dagger tiềm năng.

Kết luận #

Dagger mang đến cách tiếp cận căn bản khác cho CI/CD: pipeline như code thực sự, thực thi trong container, với hành vi giống nhau trên mọi máy. 15,829 GitHub Star phản ánh cộng đồng developer mệt mỏi với debug YAML và bị khóa vào vendor.

Cho các team làm việc với Go, Python hoặc TypeScript, Dagger loại bỏ overhead nhận thức của việc chuyển đổi giữa code ứng dụng và cấu hình CI. Chỉ riêng mô hình thực thi local-first —— chạy pipeline CI 4 phút trong 8 giây trên laptop —— đủ để chứng minh nỗ lực migration cho các team triển khai nhiều lần mỗi ngày.

Các bước hành động #

1. Cài đặt Dagger CLI: brew install dagger/tap/dagger
2. Chạy quickstart: dagger init --sdk=python --source=./dagger my-pipeline
3. Port job build trước —— giữ CI hiện tại làm lớp trigger
4. Tham gia cộng đồng Dagger trên Discord để được hỗ trợ
5. Khám phá Daggerverse cho các module tái sử dụng

Theo dõi nhóm Telegram DevOps dibi8 để cập nhật công cụ CI/CD hàng tuần và mẫu triển khai production: https://t.me/dibi8dev

Hosting Và Hạ Tầng Được Đề Xuất #

Trước khi triển khai các công cụ trên vào production, bạn cần hạ tầng vững chắc. Hai lựa chọn dibi8 đang dùng:

• DigitalOcean — Credit miễn phí $200 trong 60 ngày, 14+ khu vực toàn cầu. Lựa chọn mặc định cho dev chạy AI tools open source.
• HTStack — VPS Hong Kong, độ trễ thấp khi truy cập từ Trung Quốc. Cùng IDC đang host dibi8.com.

Liên kết tiếp thị — không tăng chi phí của bạn, giúp dibi8.com hoạt động.

Nguồn & Tài liệu tham khảo #

• Tài liệu chính thức Dagger
• Repository GitHub Dagger — 15.8k stars, Apache-2.0
• Registry Module Daggerverse
• Hướng dẫn cài đặt Dagger
• Khái niệm cốt lõi Dagger
• Dagger Cookbook
• Giá Dagger Cloud
• So sánh công cụ CI/CD tốt nhất 2026
• Hướng dẫn Dagger CI/CD: Viết Pipeline bằng Code
• Công cụ CI/CD tốt nhất 2026: Phân tích dữ liệu
• Dagger for GitHub Action