Dagger - Notes - Sheldon Hull

Containerized magic with Go and BuildKit

I will soon put some experience notes here, as I’ve successfully built Angular and Nginx containers with it, which was a great experience. With the upcoming service support, I can foresee even more use cases.

Example of Building an Angular Project

Using mage, here’s a demonstration of invoking Mage to build an Angular project without any Angular tooling installed locally.

const AngularVersion = "15"

// Build runs the Angular build via Dagger.
func (Dagger) Build(ctx context.Context) error &#123;
  client, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
  if err != nil &#123;
    pterm.Error.Printfln("unable to connect to dagger: %s", err)
    return err
  &#125;
  defer client.Close()

  homedir, err := os.UserHomeDir()
  if err != nil &#123;
    return err
  &#125;
  npm := client.Container().From("node:lts-alpine")
  npm = npm.WithMountedDirectory("/src", client.Host().Directory(".")).
    WithWorkdir("/src")

  path := "dist/"
  npm = npm.WithExec([]string&#123;"npm", "install", "-g", fmt.Sprintf("@angular/cli@%s", AngularVersion)&#125;)
  npm = npm.WithExec([]string&#123;"ng", "config", "-g", "cli.warnings.versionMismatch", "false"&#125;)
  npm = npm.WithExec([]string&#123;"ng", "v"&#125;)
  npm = npm.WithExec([]string&#123;"npm", "ci"&#125;)
  npm = npm.WithExec([]string&#123;"ng", "build", "--configuration", "production"&#125;)

  // Copy "dist/" from container to host.
  _, err = npm.Directory(path).Export(ctx, path)
  if err != nil &#123;
    return err
  &#125;
  return nil
&#125;

Example of handling both local and CI private npm auth

This demonstrates how to handle both running in a CI context and a remote context by evaluating for a CI variable. If provided, this will return a CI system-generated .npmrc. If not provided, the file from the home directory will be mounted into the build container.

Please note that this container is not for publishing; it’s a build container which copies the dist/ contents back to the project directory.

npmrcFile := &dagger.Secret&#123;&#125;

// Bypass any mounting of npmrc, as CI tooling should update any private inline with current file here
if os.Getenv("NPM_CONFIG_USERCONFIG") != "" &#123;
  pterm.Info.Printfln("[OVERRIDE] NPM_CONFIG_USERCONFIG: %s", os.Getenv("NPM_CONFIG_USERCONFIG"))
  npmrcDir := filepath.Dir(os.Getenv("NPM_CONFIG_USERCONFIG"))
&#125; else &#123;
  // [DEFAULT] NPM config set from home/.npmrc
  npmrcFile = client.Host().Directory(homedir, dagger.HostDirectoryOpts&#123;Include: []string&#123;".npmrc"&#125;&#125;).File(".npmrc").Secret()

  // Output error if npmrcFile doesn't exist
  if _, err := os.Stat(filepath.Join(homedir, ".npmrc")); os.IsNotExist(err) &#123;
    return errors.New("missing npmrc file")
  &#125;
  npm = npm.WithMountedSecret("/root/.npmrc", npmrcFile)
&#125;

Building a Go App with Caching

Using Mage and the excellent Chainguard Go builder image, this example shows how to build a binary for the current platform and architecture, while wrapping up the entire build process inside the Dagger engine. The output goes to the standard .artifacts directory, which is typically included in all projects, and should be ignored by Git.

package main

import (
  "context"
  "os"
  "path/filepath"
  "runtime"

  "dagger.io/dagger"
  "github.com/magefile/mage/mg"
  "github.com/pterm/pterm"
)

type Build mg.Namespace  // Build contains all the build-related Mage targets.


const (
  ArtifactDirectory = ".artifacts"  // ArtifactDirectory is a directory for project artifacts, and shouldn't be committed to source.
  PermissionUserReadWriteExecute = 0o0700  // PermissionUserReadWriteExecute is the permissions for the artifact directory.
)

var TargetBuildDirectory = filepath.Join(ArtifactDirectory, "builds")  // TargetBuildDirectory is the directory where the build artifacts will be placed.

// 🔨 MyAppName builds the service using Dagger for the current system architecture.
//
// Development notes: This is a fully containerized build, using Dagger. Requires Docker.
func (Build) MyAppName() error &#123;

  ctx := context.Background()
  pterm.DefaultHeader.Println("Building with Dagger")

  buildThis := "./myApp/main.go" // This is the specific file to build, could be an input variable/slice though
  appName := "myApp"
  // create the target directory
  if err := os.MkdirAll(filepath.Join(TargetBuildDirectory, appName), PermissionUserReadWriteExecute); err != nil &#123;
    return err
  &#125;
  // initialize Dagger client
  client, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
  if err != nil &#123;
    return err
  &#125;
  defer client.Close()

  // get reference to the local project
  src := client.Host().Directory(".")
  cachedBuild := client.CacheVolume("go-build-cache")
  cachedMod := client.CacheVolume("go-mod-cache")

  modcache := "/nonroot/.cache/go-mod-cache"
  buildcache := "/nonroot/.cache/go-build-cache"

  // get `golang` image
  golang := client.Container().From("cgr.dev/chainguard/go:latest").
    WithEnvVariable("CGO_ENABLED", "0").
    WithEnvVariable("GOOS", runtime.GOOS).
    WithEnvVariable("GOARCH", runtime.GOARCH).
    WithEnvVariable("GOMODCACHE", modcache). // Attempt to optimize mod and build caching
    WithEnvVariable("GOCACHE", buildcache)

  // mount cloned repository into `golang` image
  golang = golang.WithMountedDirectory("/src", src).
    WithWorkdir("/src").
    WithMountedCache(modcache, cachedMod).
    WithMountedCache(buildcache, cachedBuild)

  // define the application build command
  outputDirectory := filepath.Join(TargetBuildDirectory, appName)
  outputFile := filepath.Join(outputDirectory, fmt.Sprintf("%s-service",appName))
  golang = golang.WithExec([]string&#123;"build", "-o", outputFile, "-ldflags", "-s -w", "-trimpath", buildThis&#125;)

  // get reference to build output directory in container
  output := golang.Directory(outputDirectory).File(fmt.Sprintf("%s-service",appName))

  // write contents of container build/ directory to the host
  _, err = output.Export(ctx, outputFile)
  if err != nil &#123;
    return err
  &#125;

  return nil
&#125;