Dagger 0.4: service containers, secrets scrubbing, and more
Read more
Develop Your CI/CD Pipelines as Code and Run Them Anywhere
package main
import (
"context"
"fmt"
"dagger.io/dagger"
)
func main() {
ctx := context.Background()
client, err := dagger.Connect(ctx)
if err != nil {
panic(err)
}
defer client.Close()
output, err := client.Pipeline("test").
Container().
From("alpine").
WithExec([]string{"apk", "add", "curl"}).
WithExec([]string{"curl", "https://dagger.io"}).
Stdout(ctx)
if err != nil {
panic(err)
}
fmt.Println(output[:300])
}
Dagger is a programmable CI/CD engine that runs your pipelines in containers.
Develop your pipelines as code, in the same programming language as your application. Choose your SDK and start coding!
Dagger executes your pipelines entirely as standard OCI containers. This has several benefits:
- Instant local testing
- Portability: the same pipeline can run on your local machine, a CI runner, a dedicated server, or any container hosting service.
- Superior caching: every operation is cached by default, and caching works the same everywhere
- Compatibility with the Docker ecosystem: if it runs in a container, you can add it to your pipeline.
- Cross-language instrumentation: teams can use each other's tools without learning each other's language.
Who is it for?
👍 Dagger may be a good fit if you are...
- A developer wishing your CI pipelines were code instead of YAML
- Your team's "designated devops person", hoping to replace a pile of artisanal scripts with something more powerful
- A platform engineer writing custom tooling, with the goal of unifying continuous delivery across organizational silos
- A cloud-native developer advocate or solutions engineer, looking to demonstrate a complex integration on short notice
🤚 Dagger may not be a good fit if you are...
- A developer who doesn't care how your CI/CD pipelines work, and prefers someone else to worry about that
- Someone who loves writing YAML all day, thank you very much
- A container skeptic: the less containers are involved in your stack, the happier you are
How it Works
- Your program of choice imports the Dagger SDK library
- Using the SDK library, your program opens a new session to a Dagger Engine: either by connecting to an existing engine, or by provisioning one on-the-fly.
- Using the SDK library, your program prepares API requests describing pipelines to run, then sends them to the engine. The wire protocol used to communicate with the engine is private and not yet documented, but this will change in the future. For now, the SDK library is the only documented API available to your program.
- When the engine receives an API request, it computes a DAG of low-level operations required to compute the result, and starts processing operations concurrently.
- When all operations in the pipeline have been resolved, the engine sends the pipeline result back to your program.
- Your program may use the pipeline's result as input to new pipelines.
