DaggerRuby CI/CD Pipeline Builder

A skill for building container-based CI/CD pipelines using DaggerRuby, the Ruby SDK for Dagger. Create powerful, programmable build and deployment workflows with Ruby code instead of YAML configurations.

What This Skill Does

Helps you build CI/CD pipelines using DaggerRuby by:

Creating container-based build workflows

Managing dependencies and caching strategies

Integrating Git repositories and host filesystems

Running tests and deployments in isolated containers

Building multi-stage Docker images

Managing secrets and environment variables

Instructions

When the user requests help with DaggerRuby pipelines, follow these steps:

1. Understand the Build Requirements

First, identify what the user needs:

What application/language are they building? (Ruby, Node.js, Go, etc.)

What operations are needed? (install deps, run tests, build, deploy)

Are there caching requirements for faster builds?

Do they need Git integration or host filesystem access?

Are secrets/credentials involved?

Ask clarifying questions if requirements are unclear.

2. Examine Existing Code (if applicable)

If working with an existing project:

Read the project's source files to understand structure

Check for existing Gemfile, package.json, or dependency files

Look for test scripts or build commands

Identify directories that need to be mounted or cached

3. Design the Pipeline Structure

Plan the pipeline using DaggerRuby patterns:

**Basic structure:**

```ruby

require 'dagger_ruby'

DaggerRuby.connection do |client|

# 1. Define source directories

# 2. Create containers with base images

# 3. Mount directories and caches

# 4. Execute build/test commands

# 5. Export artifacts or results

end

```

**Key patterns to use:**

**Lazy evaluation**: Chain operations; execution happens on terminal methods (`.stdout`, `.id`, `.export`)

**Caching**: Use `cache_volume` for dependency caches (`node_modules`, `vendor/bundle`, etc.)

**Method chaining**: Build fluent pipelines with `.with_exec`, `.with_directory`, etc.

**Git integration**: Use `client.git(url).branch(name).tree` for cloning repos

4. Implement Core Operations

Build the pipeline step-by-step:

**Container creation:**

```ruby

container = client.container.from("ruby:3.2-alpine")

```

**Mounting source code:**

```ruby

source = client.host.directory(".", exclude: ["node_modules", ".git"])

container = container.with_directory("/app", source)

```

**Adding cache volumes:**

```ruby

cache = client.cache_volume("bundle-cache")

container = container.with_mounted_cache("/usr/local/bundle", cache)

```

**Running commands:**

```ruby

container = container

.with_exec(["bundle", "install"])

.with_exec(["bundle", "exec", "rspec"])

```

**Exporting results:**

```ruby

container.stdout # Get command output

container.directory("/app/build").export("./dist") # Export directory

```

5. Handle Secrets and Configuration

For sensitive data:

```ruby

secret = client.set_secret("api_token", ENV["API_TOKEN"])

container = container.with_secret_variable("API_TOKEN", secret)

```

For environment variables:

```ruby

container = container.with_env_variable("NODE_ENV", "production")

```

6. Implement Error Handling

Wrap operations with error handling:

```ruby

begin

DaggerRuby.connection do |client|

# Pipeline operations

end

rescue DaggerRuby::GraphQLError => e

puts "GraphQL error: #{e.message}"

exit 1

rescue DaggerRuby::ConnectionError => e

puts "Connection error: #{e.message}"

exit 1

end

```

7. Optimize for Performance

Apply caching strategies:

Cache package managers: `/root/.npm`, `/usr/local/bundle`, `/go/pkg/mod`

Use `.with_mounted_cache` for persistent caches

Exclude unnecessary files when mounting directories

Order operations: Install dependencies before copying source code

8. Test and Validate

Before finalizing:

Ensure the Dagger CLI is installed (`dagger version`)

Test the pipeline locally: `ruby pipeline.rb`

Verify all required environment variables are set

Check that exported artifacts are created correctly

9. Document the Pipeline

Provide clear documentation:

List required environment variables

Document any setup steps (installing Dagger CLI)

Explain caching strategy

Add comments for complex operations

Common Pipeline Examples

**Ruby application with tests:**

```ruby

DaggerRuby.connection do |client|

source = client.host.directory(".")

cache = client.cache_volume("bundle-cache")

output = client.container

.from("ruby:3.2")

.with_directory("/app", source)

.with_workdir("/app")

.with_mounted_cache("/usr/local/bundle", cache)

.with_exec(["bundle", "install"])

.with_exec(["bundle", "exec", "rspec"])

.stdout

puts output

end

```

**Node.js build with caching:**

```ruby

DaggerRuby.connection do |client|

source = client.host.directory(".", exclude: ["node_modules"])

npm_cache = client.cache_volume("npm-cache")

client.container

.from("node:18-alpine")

.with_directory("/src", source)

.with_workdir("/src")

.with_mounted_cache("/root/.npm", npm_cache)

.with_exec(["npm", "ci"])

.with_exec(["npm", "run", "build"])

.directory("/src/dist")

.export("./build")

end

```

**Git repository build:**

```ruby

DaggerRuby.connection do |client|

repo = client.git("https://github.com/user/repo.git")

.branch("main")

.tree

client.container

.from("golang:1.21")

.with_directory("/src", repo)

.with_workdir("/src")

.with_exec(["go", "build", "-o", "app"])

.file("/src/app")

.export("./app")

end

```

Important Notes

**Requires Dagger CLI**: Users must have the Dagger CLI installed

**Session management**: DaggerRuby auto-wraps commands with `dagger run` if not in session

**Ruby 3.1+**: Minimum Ruby version requirement

**Docker runtime**: Dagger requires a container runtime (Docker, Podman, etc.)

**Lazy evaluation**: Operations only execute when terminal methods are called

**No external gems**: DaggerRuby uses only Ruby stdlib

File Structure Reference

When creating new pipelines, typical structure:

```

project/

├── dagger.rb # Main pipeline script

├── Gemfile # Include dagger_ruby gem

├── .dockerignore # Exclude files from context

└── src/ # Source code

```

Constraints

Always validate that required tools (Dagger CLI, Docker) are available

Use appropriate base images for the target language/framework

Implement proper caching to avoid redundant work

Handle secrets securely using DaggerRuby's secret objects

Test pipelines locally before CI integration

Keep pipelines focused and modular

DaggerRuby CI/CD Pipeline Builder

DaggerRuby CI/CD Pipeline Builder

What This Skill Does

Instructions

1. Understand the Build Requirements

2. Examine Existing Code (if applicable)

3. Design the Pipeline Structure

4. Implement Core Operations

5. Handle Secrets and Configuration

6. Implement Error Handling

7. Optimize for Performance

8. Test and Validate

9. Document the Pipeline

Common Pipeline Examples

Important Notes

File Structure Reference

Constraints

Reviews (0)