Go Cache

Configuring Go to use Depot Cache

Depot Cache can be used with Go from Depot's managed GitHub Actions runners, from your local machine, from any CI/CD system, or within containerized builds using Dockerfiles or Bake files.

From Depot-managed Actions runners

Depot GitHub Actions runners are pre-configured to use Depot Cache with Go - each runner is launched with the GOCACHEPROG environment variable pre-populated with the connection details for Depot Cache.

If you don't want Depot to set up the GOCACHEPROG environment variable on each runner, disable Allow Actions jobs to automatically connect to Depot Cache in your organization settings page. You can manually configure GOCACHEPROG to use Depot Cache as described in the "Using Depot Cache from your local machine or any CI/CD system" section.

Using Depot Cache with Go in depot/build-push-action

When using depot/build-push-action to build Docker images that contain Go projects, your build needs access to Go's remote cache credentials to benefit from caching.

These credentials are not automatically available inside your Docker build environment. Unlike builds running directly on Depot-managed GitHub Actions runners (which have automatic access to Depot Cache environment variables), containerized builds execute in isolated VMs that require explicit configuration.

Follow these steps to securely pass your Go cache credentials into your Docker build:

1. Store the Depot token in a GitHub Secret named DEPOT_TOKEN.

2. Configure your GitHub Action to pass secrets to the container build:

- name: Build and push
  uses: depot/build-push-action@v1
  with:
    context: .
    file: ./Dockerfile
    push: true
    tags: your-image:tag
    secrets: |
      "DEPOT_TOKEN=${{ secrets.DEPOT_TOKEN }}"

3. Update your Dockerfile to install the Depot CLI and configure Go cache:

# syntax=docker/dockerfile:1

# ... other Dockerfile instructions

# Install Depot CLI
RUN curl -L https://depot.dev/install-cli.sh | sh

# Mount secret and set GOCACHEPROG
RUN --mount=type=secret,id=DEPOT_TOKEN,env=DEPOT_TOKEN \
    PATH="/root/.depot/bin:$PATH" \
    GOCACHEPROG="depot gocache" \
    go build -v ./

Adding # syntax=docker/dockerfile:1 as the first line of your Dockerfile enables mounting secrets as environment variables.

Using Depot Cache from your local machine or any CI/CD system

To manually configure Go to use Depot Cache, set the GOCACHEPROG in your environment:

export GOCACHEPROG="depot gocache"

The depot CLI will need to have authorization to write to the cache.

If you are a member of multiple organizations, and you are authenticating with a user token, you must instead specify which organization should be used for cache storage as follows:

export GOCACHEPROG='depot gocache --organization ORG_ID'

To clean the cache, you can use the typical go clean workflow:

go clean -cache

To set verbose output, add the --verbose option:

export GOCACHEPROG='depot gocache --verbose'

After Go is configured to use Depot Cache, you can then run your builds as you normally would. Go will automatically communicate with GOCACHEPROG to fetch from Depot Cache and reuse any stored build artifacts from your previous builds.

Using Depot Cache with Go in Depot CLI

When building directly with Depot CLI, follow these steps:

1. Update your Dockerfile to install the Depot CLI and configure Go cache:

# syntax=docker/dockerfile:1

# ... other Dockerfile instructions

# Install Depot CLI
RUN curl -L https://depot.dev/install-cli.sh | sh

# Mount secret and set GOCACHEPROG
RUN --mount=type=secret,id=DEPOT_TOKEN,env=DEPOT_TOKEN \
    PATH="/root/.depot/bin:$PATH" \
    GOCACHEPROG="depot gocache" \
    go build -v ./

Adding # syntax=docker/dockerfile:1 as the first line of your Dockerfile enables mounting secrets as environment variables.

2. Build with Depot CLI:

depot build --secret id=DEPOT_TOKEN,env=DEPOT_TOKEN -t your-image:tag .

Or with Docker Buildx:

docker buildx build --secret id=DEPOT_TOKEN,env=DEPOT_TOKEN -t your-image:tag .

Using Depot Cache with Go in Bake files

When using Bake files to build Docker images containing Go projects, you can pass secrets through the target.secret attribute:

1. Define the secret in your docker-bake.hcl file:

target "default" {
  context    = "."
  dockerfile = "Dockerfile"
  tags       = ["your-image:tag"]
  secret = [
    {
      type = "env"
      id   = "DEPOT_TOKEN"
    }
  ]
}

2. Update your Dockerfile to install the Depot CLI and configure Go cache:

# syntax=docker/dockerfile:1

# ... other Dockerfile instructions

# Install Depot CLI
RUN curl -L https://depot.dev/install-cli.sh | sh

# Mount secret and set GOCACHEPROG
RUN --mount=type=secret,id=DEPOT_TOKEN,env=DEPOT_TOKEN \
    PATH="/root/.depot/bin:$PATH" \
    GOCACHEPROG="depot gocache" \
    go build -v ./

Adding # syntax=docker/dockerfile:1 as the first line of your Dockerfile enables mounting secrets as environment variables.

3. Run the build with depot bake:

DEPOT_TOKEN=your_token depot bake