ko

https://ko.build
Admin
ko is a simple, fast, and secure container image builder for Go applications, enabling easy...
Tokens:13,374
Snippets:236
Trust Score:7.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup ko in GitHub Actions

Source: https://ko.build/install

Use the setup-ko action to install ko and configure authentication for GitHub Container Registry within a GitHub Actions workflow.

```yaml
steps:
- uses: ko-build/setup-ko@v0.6

```

--------------------------------

### Install ko on Alpine Linux

Source: https://ko.build/install

Install ko on Alpine Linux by adding the testing repository and then installing the package.

```bash
echo https://dl-cdn.alpinelinux.org/alpine/edge/testing/ >> /etc/apk/repositories
apk update
apk add ko

```

--------------------------------

### Build and Install ko from Source

Source: https://ko.build/install

Build and install the latest released version of ko from source using Go 1.16+.

```go
go install github.com/google/ko@latest

```

--------------------------------

### Install ko on Windows using Scoop

Source: https://ko.build/install

Install ko on Windows using the Scoop package manager.

```bash
scoop install ko

```

--------------------------------

### Run a Go Binary with Relative Import Path

Source: https://ko.build/reference/ko_run

This example demonstrates using a relative import path with 'ko run'. It's useful for projects with local package structures.

```bash
ko run ./cmd/baz
```

--------------------------------

### Install ko using Homebrew

Source: https://ko.build/install

Install ko on macOS or Linux using the Homebrew package manager.

```bash
brew install ko

```

--------------------------------

### Build and Publish Container Image with ko Packages

Source: https://ko.build/advanced/go-packages

Use `pkg/build` to build a container image and `pkg/publish` to push it. This example shows the core functionality for building and publishing an image, including specifying platforms, base images, tags, and authentication.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/google/go-containerregistry/pkg/authn"
    "github.com/google/go-containerregistry/pkg/name"
    "github.com/google/go-containerregistry/pkg/v1/remote"
    "github.com/google/ko/pkg/build"
    "github.com/google/ko/pkg/publish"
)

const (
    baseImage  = "cgr.dev/chainguard/static:latest"
    targetRepo = "example.registry/my-repo"
    importpath = "github.com/my-org/miniko"
    commitSHA  = "deadbeef"
)

func main() {
    ctx := context.Background()

    b, err := build.NewGo(ctx, ".",
        build.WithPlatforms("linux/amd64"), // only build for these platforms.
        build.WithBaseImages(func(ctx context.Context, _ string) (name.Reference, build.Result, error) {
            ref := name.MustParseReference(baseImage)
            base, err := remote.Index(ref, remote.WithContext(ctx))
            return ref, base, err
        }))
    if err != nil {
        log.Fatalf("NewGo: %v", err)
    }
    r, err := b.Build(ctx, importpath)
    if err != nil {
        log.Fatalf("Build: %v", err)
    }

    p, err := publish.NewDefault(targetRepo,                 // publish to example.registry/my-repo
        publish.WithTags([]string{commitSHA}),               // tag with :deadbeef
        publish.WithAuthFromKeychain(authn.DefaultKeychain)) // use credentials from ~/.docker/config.json
    if err != nil {
        log.Fatalf("NewDefault: %v", err)
    }
    ref, err := p.Publish(ctx, r, importpath)
    if err != nil {
        log.Fatalf("Publish: %v", err)
    }
    fmt.Println(ref.String())
}

```

--------------------------------

### Build and Push Go Image with ko

Source: https://ko.build/advanced/migrating-from-dockerfile

Use this command to build and push your Go application's container image to a registry using `ko`. This command assumes your Go source is laid out as described in the tutorial and `ko` is installed and configured.

```bash
ko build ./ 

```

--------------------------------

### Install ko using MacPorts

Source: https://ko.build/install

Install ko on macOS using the MacPorts package manager.

```bash
sudo port install ko

```

--------------------------------

### Build Go App with Custom Base Image

Source: https://ko.build/advanced/root-ca-certificates

Build the Go application container image using `ko build` after configuring it to use a custom base image. The resulting image will trust the CA certificates installed in the custom base.

```bash
ko build .
```

--------------------------------

### Set File Capabilities in .ko.yaml

Source: https://ko.build/advanced/linux-capabilities

Configure file capabilities for an image build using the `linux_capabilities` field in `.ko.yaml`. This example sets the `bpf` capability to be permitted and effective (`=ep`).

```yaml
builds:
- id: caps
  linux_capabilities: bpf=ep

```

--------------------------------

### Set Multiple File Capabilities in .ko.yaml

Source: https://ko.build/advanced/linux-capabilities

Specify multiple capabilities using a comma-separated list in `.ko.yaml`. This example sets `bpf`, `perfmon`, and `net_admin` capabilities to be permitted and effective (`=ep`).

```yaml
builds:
- id: caps
  linux_capabilities: bpf,perfmon,net_admin=ep

```

--------------------------------

### Download and Verify ko Release

Source: https://ko.build/install

Download the latest ko release archive and its SLSA provenance for verification. Ensure you have the slsa-verifier tool installed.

```bash
$ VERSION=TODO # choose the latest version (without v prefix)
$ OS=Linux     # or Darwin
$ ARCH=x86_64  # or arm64, i386, s390x

```

```bash
$ curl -sSfL "https://github.com/ko-build/ko/releases/download/v${VERSION}/ko_${VERSION}_${OS}_${ARCH}.tar.gz" > ko.tar.gz
$ curl -sSfL https://github.com/ko-build/ko/releases/download/v${VERSION}/multiple.intoto.jsonl > multiple.intoto.jsonl
$ slsa-verifier verify-artifact --provenance-path multiple.intoto.jsonl --source-uri github.com/ko-build/ko --source-tag "v${VERSION}" ko.tar.gz

```

--------------------------------

### Build and publish import path references preserving import path names

Source: https://ko.build/reference/ko_resolve

This example shows how to build and publish Go import path references to a Docker Registry while preserving the original import path names. The images are tagged as ${KO_DOCKER_REPO}/<import path>. When KO_DOCKER_REPO is 'ko.local', this is equivalent to using the --local flag.

```bash
ko resolve --preserve-import-paths -f config/
```

--------------------------------

### Add BPF Capability to Docker Container

Source: https://ko.build/advanced/linux-capabilities

Use the `--cap-add` option with `docker run` to grant specific capabilities to a container. This example adds the `bpf` capability.

```bash
docker run --cap-add bpf hello-world

```

--------------------------------

### Logging into OpenShift Internal Registry

Source: https://ko.build/advanced/faq

Log in to your OpenShift installation's internal registry using `oc registry login` to enable pushing images.

```bash
oc registry login --to=$HOME/.docker/config.json

```

--------------------------------

### Pass flags to kubectl apply

Source: https://ko.build/reference/ko_create

Demonstrates how to pass flags directly to `kubectl apply` after the '--' separator when using `ko apply` (note: example uses `ko apply` but the principle applies to `ko create` as well).

```bash
ko apply -f config -- --namespace=foo --kubeconfig=cfg.yaml
```

--------------------------------

### Setting KO_DOCKER_REPO for OpenShift Internal Registry

Source: https://ko.build/advanced/faq

Configure `KO_DOCKER_REPO` to publish images to the OpenShift internal registry by using `oc registry info --public` to get the registry address.

```bash
export KO_DOCKER_REPO=$(oc registry info --public)/ko-images

```

--------------------------------

### Create Custom Base Image with CA Certificates (Dockerfile)

Source: https://ko.build/advanced/root-ca-certificates

Create a custom container image based on Alpine Linux, installing CA certificates and adding new root certificates. This image can then be used to override ko's default base image.

```dockerfile
# Dockerfile
FROM alpine

RUN apk update
RUN apk add ca-certificates

ADD new-root-ca.crt /usr/local/share/ca-certificates/new-root-ca.crt
RUN chmod 644 /usr/local/share/ca-certificates/new-root-ca.crt
RUN update-ca-certificates

```

--------------------------------

### Run a Go Binary with Arguments

Source: https://ko.build/reference/ko_run

This snippet shows how to pass arguments and flags to the Go binary being run on Kubernetes. Arguments after '--' are passed directly to the application.

```bash
ko run ./cmd/baz -- -v arg1 arg2 --yes
```

--------------------------------

### Build Go App Image with Static Assets

Source: https://ko.build/advanced/root-ca-certificates

Build the Go application container image using `ko build` with static assets. The root certificates copied to the `kodata/` directory will be bundled into the image at `$KO_DATA_PATH`.

```bash
KO_DOCKER_REPO=docker.io/ko-build/static-assets-certs ko build .
```

--------------------------------

### Multi-stage Dockerfile for Go Application

Source: https://ko.build/advanced/migrating-from-dockerfile

This is a best practice multi-stage Dockerfile for building a Go application. It first builds the executable in a Go environment and then copies it into a minimal distroless base image for deployment.

```dockerfile
## Build
FROM golang:1.16-buster AS build

WORKDIR /app

COPY go.mod ./
COPY go.sum ./
RUN go mod download

COPY *.go ./

RUN go build -o /docker-gs-ping

## Deploy
FROM gcr.io/distroless/base-debian10

WORKDIR /

COPY --from=build /docker-gs-ping /docker-gs-ping

EXPOSE 8080

USER nonroot:nonroot

ENTRYPOINT ["/docker-gs-ping"]

```

--------------------------------

### Extract and Make ko Executable

Source: https://ko.build/install

After downloading and verifying the release, extract the ko binary and make it executable.

```bash
$ tar xzf ko.tar.gz ko
$ chmod +x ./ko

```

--------------------------------

### Building Windows containers with ko build

Source: https://ko.build/advanced/faq

Build Windows container images by specifying a Windows base image in `.ko.yaml` and using the --platform=windows/amd64 flag during the build process.

```yaml
defaultBaseImage: mcr.microsoft.com/windows/nanoserver:ltsc2022

```

```bash
ko build ./ --platform=windows/amd64

```

--------------------------------

### Build and publish to local Docker daemon

Source: https://ko.build/reference/ko_create

Builds and publishes Go import path references to the local Docker daemon. The resulting YAML is then fed into `kubectl create`.

```bash
ko create --local -f config/
```

--------------------------------

### ko create command usage

Source: https://ko.build/reference/ko_create

Basic syntax for the `ko create` command.

```bash
ko create -f FILENAME [flags]
```

--------------------------------

### Build Go App Image with ko

Source: https://ko.build/advanced/root-ca-certificates

Build and push your Go application container image using `ko build`. Ensure `KO_DOCKER_REPO` is set to your desired image repository and tag.

```bash
KO_DOCKER_REPO=mycompany/myimage:latest ko build .
```

--------------------------------

### Publish and Run a Go Binary on Kubernetes

Source: https://ko.build/reference/ko_run

This is the basic usage of 'ko run'. It containerizes the specified Go import path and runs it on Kubernetes. The image is published to a repository determined by the KO_DOCKER_REPO environment variable.

```bash
ko run github.com/foo/bar/cmd/baz
```

--------------------------------

### Build and publish import path references to a Docker Registry

Source: https://ko.build/reference/ko_resolve

This snippet demonstrates building and publishing Go import path references to a Docker Registry. The resulting image is tagged with a hash of the import path under the specified KO_DOCKER_REPO. When KO_DOCKER_REPO is 'ko.local', it behaves as if --local and --preserve-import-paths were used.

```bash
ko resolve -f config/
```

--------------------------------

### Build and publish to Docker Registry

Source: https://ko.build/reference/ko_create

Builds and publishes Go import path references to a Docker Registry using the default naming convention. The resulting YAML is then fed into `kubectl create`.

```bash
ko create -f config/
```

--------------------------------

### Create from stdin

Source: https://ko.build/reference/ko_create

Creates resources by piping YAML content from stdin to `ko create`.

```bash
cat config.yaml | ko create -f -
```

--------------------------------

### Build and Push Container Image with Ko

Source: https://ko.build/get-started

Use this command to build a container image from a Go package and push it to a configured registry. The resulting image digest is printed to standard output. Ensure your `KO_DOCKER_REPO` environment variable is set.

```bash
$ ko build ./cmd/app
... 
registry.example.com/my-project/app-099ba5bcefdead87f92606265fb99ac0@sha256:6e398316742b7aa4a93161dce4a23bc5c545700b862b43347b941000b112ec3e

```

--------------------------------

### Serve Static Assets using Go HTTP

Source: https://ko.build/features/static-assets

Use `http.FileServer` with the `KO_DATA_PATH` environment variable to serve bundled static assets. Ensure the `KO_DATA_PATH` is correctly set.

```go
func main() {
    http.Handle("/", http.FileServer(http.Dir(os.Getenv("KO_DATA_PATH"))))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

--------------------------------

### ko CLI Options

Source: https://ko.build/reference/ko

Global options available for the ko CLI. Use --help for detailed command-specific options.

```bash
  -h, --help      help for ko
  -v, --verbose   Enable debug logs

```

--------------------------------

### Build and publish to Docker Registry

Source: https://ko.build/reference/ko_apply

Builds and publishes image references to a Docker Registry. The image name is formatted as ${KO_DOCKER_REPO}/<package name>-<hash of import path>. If KO_DOCKER_REPO is 'ko.local', it behaves like --local.

```bash
ko apply -f config/
```

--------------------------------

### Build and publish import path references to a local Docker daemon

Source: https://ko.build/reference/ko_resolve

This snippet demonstrates building and publishing Go import path references directly to the local Docker daemon. The images are tagged under 'ko.local/<import path>', and import paths are always preserved in this mode.

```bash
ko resolve --local -f config/
```

--------------------------------

### Build and publish to local Docker daemon

Source: https://ko.build/reference/ko_apply

Builds and publishes image references to the local Docker daemon. The image name is formatted as ko.local/<import path>.

```bash
ko apply --local -f config/
```

--------------------------------

### Integrating Ko with Kustomize

Source: https://ko.build/advanced/faq

Process Kustomize build output with Ko by piping the output of `kustomize build` to `ko resolve -f -`.

```bash
kustomize build config | ko resolve -f -

```

--------------------------------

### Run Go App Container with SSL_CERT_DIR

Source: https://ko.build/advanced/root-ca-certificates

Run the Go application container image, setting the `SSL_CERT_DIR` environment variable to `/var/run/ko` (the default value for `$KO_DATA_PATH`). This tells the Go application to trust the bundled root certificates.

```bash
docker run -e SSL_CERT_DIR=/var/run/ko docker.io/ko-build/static-assets-certs
```

--------------------------------

### ko version command options

Source: https://ko.build/reference/ko_version

The `ko version` command supports a help flag to display available options.

```bash
  -h, --help   help for version

```

--------------------------------

### Configure and Use ko Terraform Provider

Source: https://ko.build/advanced/terraform

This snippet demonstrates how to require and configure the ko Terraform provider, define a build resource, and output the resulting image reference. Ensure the `repo` attribute in the provider configuration matches your desired Docker repository.

```terraform
terraform {
  required_providers {
    ko = { source = "ko-build/ko" }
  }
}

provider "ko" {
  repo = "example.registry/my-repo" // equivalent to KO_DOCKER_REPO
}

resource "ko_build" "app" {
  importpath = "github.com/example/repo/cmd/app"
}

output "image" {
  value = ko_build.app.image_ref
}
```

--------------------------------

### Build and Push Custom Base Image

Source: https://ko.build/advanced/root-ca-certificates

Build the custom container image locally and push it to a container registry. This makes the image available for ko to use as a base.

```bash
docker build . -t docker.io/ko-build/image-with-new-root-certs
docker push docker.io/ko-build/image-with-new-root-certs
```

--------------------------------

### Build and publish preserving import paths

Source: https://ko.build/reference/ko_create

Builds and publishes Go import path references to a Docker Registry while preserving the full import path names. The resulting YAML is then fed into `kubectl create`.

```bash
ko create --preserve-import-paths -f config/
```

--------------------------------

### Configure Go Builds in .ko.yaml

Source: https://ko.build/configuration

Define custom build configurations, including main entry points, environment variables, build flags, and linker flags, for specific Go packages. This section is influenced by GoReleaser's `builds` configuration.

```yaml
builds:
- id: foo
  dir: .  # default is .
  main: ./foobar/foo
  env:
  - GOPRIVATE=git.internal.example.com,source.developers.google.com
  flags:
  - -tags
  - netgo
  ldflags:
  - -s -w
  - -extldflags "-static"
  - -X main.version={{.Env.VERSION}}
- id: bar
  dir: ./bar
  main: .  # default is .
  env:
  - GOCACHE=/workspace/.gocache
  ldflags:
  - -s
  - -w
```

--------------------------------

### Log in to a registry

Source: https://ko.build/reference/ko_login

Use this command to log in to a specific registry server. Provide the username and password directly. Ensure you are using a secure method for password input in production environments.

```bash
ko login reg.example.com -u AzureDiamond -p hunter2
```

--------------------------------

### Print ko version

Source: https://ko.build/reference/ko_version

Use the `ko version` command to display the current version of ko. Flags can be appended for additional options.

```bash
ko version [flags]
```

--------------------------------

### Build Multi-Arch Image with ko

Source: https://ko.build/advanced/migrating-from-dockerfile

Add the `--platform=all` flag to the `ko build` command to create a multi-architecture container image. This is equivalent to specifying multiple build platforms in Docker.

```bash
ko build --platform=all 

```

--------------------------------

### Set File Capabilities as a List in .ko.yaml

Source: https://ko.build/advanced/linux-capabilities

An alternative syntax for setting file capabilities in `.ko.yaml` is to provide them as a list. This is equivalent to a comma-separated string.

```yaml
builds:
- id: caps
  linux_capabilities:
  - cap1
  - cap2
  - cap3

```

--------------------------------

### ko CLI Usage

Source: https://ko.build/reference/ko

Basic usage of the ko CLI. Use this to see available commands and global flags.

```bash
ko [flags]

```

--------------------------------

### Deploy to fly.io

Source: https://ko.build/deployment

Deploy the container image to fly.io. The image must be pushed to Fly.io's container registry or be publicly available. Log in with `flyctl auth docker` if pushing to `registry.fly.io`.

```bash
flyctl launch --image=$(ko build ./cmd/app)
```

--------------------------------

### Directory Structure for Static Assets

Source: https://ko.build/features/static-assets

Organize your static assets within a `kodata/` directory alongside your application code. This structure is recognized by Ko for bundling.

```go
cmd/
  app/
    main.go
    kodata/
      favicon.ico
      index.html

```

--------------------------------

### ko login

Source: https://ko.build/reference/ko_login

Logs in to a specified container registry server using provided credentials.

```APIDOC
## ko login

### Description
Log in to a registry.

### Usage
```
ko login [OPTIONS] [SERVER] [flags]
```

### Options
- `-h, --help` (bool) - help for login
- `-p, --password string` - Password
- `--password-stdin` (bool) - Take the password from stdin
- `-u, --username string` - Username

### Inherited Options
- `-v, --verbose` (bool) - Enable debug logs

### Examples
```
# Log in to reg.example.com
ko login reg.example.com -u AzureDiamond -p hunter2
```
```

--------------------------------

### Applying a Kubernetes Deployment

Source: https://ko.build/features/k8s

Command to apply a Kubernetes deployment configuration to a cluster.

```bash
kubectl apply -f deployment.yaml

```

--------------------------------

### Build and publish to local Docker daemon

Source: https://ko.build/reference/ko_build

Builds and publishes import path references to a local Docker daemon. This method always preserves import paths.

```bash
ko build --local github.com/foo/bar/cmd/baz github.com/foo/bar/cmd/blah
```

--------------------------------

### Set Default Platforms with Environment Variable

Source: https://ko.build/configuration

Use the `KO_DEFAULTPLATFORMS` environment variable to set the default build platforms, overriding the configuration in `.ko.yaml`.

```bash
KO_DEFAULTPLATFORMS=linux/arm64,linux/amd64
```

--------------------------------

### Build and publish to Docker Registry

Source: https://ko.build/reference/ko_build

Builds and publishes import path references to a Docker Registry. When KO_DOCKER_REPO is 'ko.local', it behaves as if --local and --preserve-import-paths were passed. If no import path is provided, the current working directory is used.

```bash
ko build github.com/foo/bar/cmd/baz github.com/foo/bar/cmd/blah
```

--------------------------------

### Configure ko to Use Custom Base Image (.ko.yaml)

Source: https://ko.build/advanced/root-ca-certificates

Configure ko to use your custom base image by specifying `defaultBaseImage` in the `.ko.yaml` file. This ensures your Go application image inherits the CA certificates from the custom base.

```yaml
# .ko.yaml
defaultBaseImage: docker.io/ko-build/image-with-new-root-certs

```

--------------------------------

### Build and publish with preserved import paths

Source: https://ko.build/reference/ko_build

Builds and publishes a relative import path, preserving the full import path after KO_DOCKER_REPO. When KO_DOCKER_REPO is 'ko.local', it behaves as if --local was passed.

```bash
ko build --preserve-import-paths ./cmd/blah
```

--------------------------------

### Run container locally with docker run

Source: https://ko.build/deployment

Use this command to run the built container image locally. Ensure the image is built using `ko build`.

```bash
docker run -p 8080:8080 $(ko build ./cmd/app)
```

--------------------------------

### Build and publish preserving import paths

Source: https://ko.build/reference/ko_apply

Builds and publishes image references to a Docker Registry while preserving the full import path. The image name is formatted as ${KO_DOCKER_REPO}/<import path>.

```bash
ko apply --preserve-import-paths -f config/
```

--------------------------------

### Build and Push Lambda Image with ko

Source: https://ko.build/advanced/lambda

Build a Docker image for your Lambda function using `ko` and set the `KO_DOCKER_REPO` environment variable to your AWS ECR repository. The output `image` variable will contain the ECR image URI.

```bash
KO_DOCKER_REPO=[account-id].dkr.ecr.[region].amazonaws.com/my-repo
image=$(ko build ./cmd/app)

```

--------------------------------

### Copy Root Certificates to kodata Directory

Source: https://ko.build/advanced/root-ca-certificates

Copy your root certificate files to the `<importpath>/kodata/` directory. This directory is used by ko to bundle static assets into the container image.

```bash
# $(pwd) assumed to be at <importpath> for this example
mkdir -p kodata
cp $CERT_FILE_DIR/*.crt kodata/

```

--------------------------------

### ko apply command usage

Source: https://ko.build/reference/ko_apply

Basic syntax for the ko apply command.

```bash
ko apply -f FILENAME [flags]
```

--------------------------------

### Set Default Platforms in .ko.yaml

Source: https://ko.build/configuration

Specify the target platforms for `ko` builds in your `.ko.yaml` file. This is useful when your build environment differs from your target deployment environment.

```yaml
defaultPlatforms:
- linux/arm64
- linux/amd64
```

--------------------------------

### Build and publish relative import path

Source: https://ko.build/reference/ko_build

Builds and publishes a relative import path to a Docker Registry. When KO_DOCKER_REPO is 'ko.local', it behaves as if --local and --preserve-import-paths were passed.

```bash
ko build ./cmd/blah
```

--------------------------------

### ko delete Options

Source: https://ko.build/reference/ko_delete

Lists the available options for the 'ko delete' command, including help flags.

```bash
-h, --help   help for delete
```

--------------------------------

### Deploy to Google Cloud Run

Source: https://ko.build/deployment

Deploy the container image to Google Cloud Run. The image must be pushed to Google Container Registry or Artifact Registry before deployment.

```bash
gcloud run deploy --image=$(ko build ./cmd/app)
```

--------------------------------

### Build Debug-Enabled Image with Ko

Source: https://ko.build/features/debugging

Use the `--debug` flag when building your Go application image to include delve and configure the entrypoint for debugging. This feature is intended for development workflows only.

```bash
ko build . --debug

```

--------------------------------

### Apply from stdin

Source: https://ko.build/reference/ko_apply

Applies resources from standard input. This is useful for piping YAML content directly to ko apply.

```bash
cat config.yaml | ko apply -f -
```

--------------------------------

### Run Debug Container and Expose Port

Source: https://ko.build/features/debugging

After building the debug-enabled image, run the container and expose the default debug port (40000) to allow your debugger client to connect.

```bash
docker run -p 40000:40000 <img>

```

--------------------------------

### Configure ko to Use Custom Base Image (Environment Variable)

Source: https://ko.build/advanced/root-ca-certificates

Alternatively, configure ko to use your custom base image by setting the `KO_DEFAULTBASEIMAGE` environment variable. This achieves the same result as configuring `.ko.yaml`.

```bash
export KO_DEFAULTBASEIMAGE=docker.io/ko-build/image-with-new-root-certs
```

--------------------------------

### Set Default Base Image for Local Docker Daemon

Source: https://ko.build/configuration

Configure a default base image when using `ko` to load images into a local Docker daemon. Ensure `KO_DOCKER_REPO` is set to `ko.local`.

```yaml
defaultBaseImage: ko.local/example/base/image
```

--------------------------------

### Resolving YAML and Applying with Kubectl

Source: https://ko.build/features/k8s

Command to resolve Ko image references and pipe the output directly to `kubectl apply`.

```bash
ko resolve -f config/ | kubectl apply -f -

```

--------------------------------

### Set Default Build Flags and Ldflags in .ko.yaml

Source: https://ko.build/configuration

Configure default build flags and linker flags globally in your `.ko.yaml` file. These defaults can be overridden by per-build specific flags.

```yaml
defaultFlags:
- -v
defaultLdflags:
- -s
builds:
- id: foo
  dir: .
  main: ./foobar/foo
  flags:
  - -trimpath
  ldflags:
  - -w
- id: bar     # Will use defaultFlags and defaultLdflags.
  dir: ./bar
  main: .
```

--------------------------------

### Applying Resolved YAML with Ko

Source: https://ko.build/features/k8s

Command to resolve Ko image references and apply the resulting YAML to the Kubernetes cluster.

```bash
ko apply -f config/

```

--------------------------------

### Sourcing Ko autocompletion script

Source: https://ko.build/advanced/faq

Enable Ko autocompletion in your current shell session by sourcing the output of the `ko completion` command.

```bash
source <(ko completion)

```

--------------------------------

### Kubernetes Deployment YAML with Ko Image Reference

Source: https://ko.build/features/k8s

A Kubernetes Deployment manifest modified to use a `ko://` import path for the image.

```yaml
    ...
    spec:
      containers:
      - name: my-app
        image: ko://github.com/my-user/my-repo/cmd/app


```

--------------------------------

### Setting reproducible build timestamps

Source: https://ko.build/advanced/faq

Ensure reproducible container image builds by setting the SOURCE_DATE_EPOCH environment variable to the current Unix timestamp.

```bash
export SOURCE_DATE_EPOCH=$(date +%s)

```

--------------------------------

### ko delete Command Usage

Source: https://ko.build/reference/ko_delete

This shows the basic usage of the 'ko delete' command. Use 'kubectl help delete' for detailed options.

```bash
ko delete [flags]
```

--------------------------------

### Setting ldflags with ko build

Source: https://ko.build/advanced/faq

Embed version information into Go binaries using the --ldflags argument with `ko build`. This method takes precedence over ldflags defined in `.ko.yaml`.

```bash
ko build --ldflags "-X=main.version=1.2.3" --ldflags "-s -w" .

```

--------------------------------

### Docker Run Failure with Insufficient Capabilities

Source: https://ko.build/advanced/linux-capabilities

Demonstrates a runtime error when a container is run with fewer capabilities (`--cap-add bpf`) than specified as file capabilities (`=ep`) in the image. The generic 'operation not permitted' error can be difficult to diagnose.

```bash
$ docker run --cap-add bpf ko.local/caps.test-4b8f7bca75c467b3d2803e1c087a3287
exec /ko-app/caps.test: operation not permitted

```

--------------------------------

### Standard Kubernetes Deployment YAML

Source: https://ko.build/features/k8s

A typical Kubernetes Deployment manifest defining a container that runs a specific image.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: registry.example.com/my-app:v1.2.3


```

--------------------------------

### Create AWS Lambda Function from Image

Source: https://ko.build/advanced/lambda

Create an AWS Lambda function using the previously built container image. Replace `[account-id]` and `[region]` with your AWS account ID and region, and ensure the specified IAM role exists.

```bash
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=${image} \
  --role arn:aws:iam::[account-id]:role/lambda-ex

```

--------------------------------

### Applying Resolved YAML with Ko and Kubectl Flags

Source: https://ko.build/features/k8s

Command to apply resolved YAML using `ko apply`, passing additional flags to `kubectl apply`.

```bash
ko apply -f config/ -- --context=foo --kubeconfig=cfg.yaml

```

--------------------------------

### Basic AWS Lambda Function in Go

Source: https://ko.build/advanced/lambda

A simple AWS Lambda function written in Go using the `lambda` package. This function takes a name from the event and returns a greeting. Ensure you have the `github.com/aws/aws-lambda-go/lambda` package imported.

```go
package main

import (
    "context"
    "fmt"
    "github.com/aws/aws-lambda-go/lambda"
)

type Event struct {
    Name string `json:"name"`
    // TODO: add other request fields here.
}

func main() {
    lambda.Start(func(ctx context.Context, event Event) (string, error) {
        return fmt.Sprintf("Hello %s!", event.Name), nil
    })
}

```

--------------------------------

### Resolving Ko Image References in YAML

Source: https://ko.build/features/k8s

Command to resolve `ko://` import paths in YAML files to fully-qualified image references.

```bash
ko resolve -f deployment.yaml

```

--------------------------------

### Improved Diagnostics with Permitted Capabilities

Source: https://ko.build/advanced/linux-capabilities

When using `=p` (permitted only) for file capabilities and explicitly promoting them within the application, more informative error messages can be generated at runtime, aiding in debugging.

```bash
$ docker run --cap-add bpf ko.local/caps.test-4b8f7bca75c467b3d2803e1c087a3287
current capabilities: cap_bpf=p
activating capabilities: cap_net_admin,cap_perfmon,cap_bpf=ep: operation not permitted

```

--------------------------------

### Override Default Base Image with Environment Variable

Source: https://ko.build/configuration

Use the `KO_DEFAULTBASEIMAGE` environment variable to set the default base image, overriding any configuration in `.ko.yaml`.

```bash
KO_DEFAULTBASEIMAGE=registry.example.com/base/image ko build .
```

--------------------------------

### Generating Ko autocompletion script

Source: https://ko.build/advanced/faq

Generate shell autocompletion scripts for Ko by running the `ko completion` command with the desired shell (bash, zsh, fish, powershell).

```bash
ko completion [bash|zsh|fish|powershell] --help

```

--------------------------------

### Resolving and Saving Resolved YAML

Source: https://ko.build/features/k8s

Command to resolve Ko image references and redirect the output to a file.

```bash
ko resolve -f config/ > release.yaml

```

--------------------------------

### Set Default Environment Variables in .ko.yaml

Source: https://ko.build/configuration

Define default environment variables for `ko` builds in your `.ko.yaml` file. These can be overridden by build-specific environment variables.

```yaml
defaultEnv:
- FOO=foo
builds:
- id: foo
  dir: .
  main: ./foobar/foo
  env:
  - FOO=bar
- id: bar     # Will use defaultEnv.
  dir: ./bar
  main: .
```

--------------------------------

### Inherited Options for ko delete

Source: https://ko.build/reference/ko_delete

Shows options inherited from parent commands, such as verbose logging.

```bash
-v, --verbose   Enable debug logs
```

--------------------------------

### Deleting Resources Applied with Ko

Source: https://ko.build/features/k8s

Command to delete Kubernetes resources that were previously applied using `ko apply`.

```bash
ko delete -f config/

```

--------------------------------

### Append CA Certificates with incert

Source: https://ko.build/advanced/root-ca-certificates

Append custom CA certificates to an existing image using `incert`. Specify the source image, the CA certificates file, and the destination image URL.

```bash
incert -image-url=mycompany/myimage:latest -ca-certs-file=/path/to/cacerts.pem -dest-image-url=myregistry/myimage:latest
```

--------------------------------

### Override Base Image per Import Path in .ko.yaml

Source: https://ko.build/configuration

Define specific base images for different import paths within your `.ko.yaml` file. This allows for granular control over base images for various components of your project.

```yaml
baseImageOverrides:
  github.com/my-user/my-repo/cmd/app: registry.example.com/base/for/app
  github.com/my-user/my-repo/cmd/foo: registry.example.com/base/for/foo
```

--------------------------------

### Setting ldflags with GOFLAGS environment variable

Source: https://ko.build/advanced/faq

Alternatively, set ldflags using the GOFLAGS environment variable. Note that this method has limitations for setting multiple ldflags arguments.

```bash
GOFLAGS="-ldflags=-X=main.version=1.2.3" ko build .

```

--------------------------------

### Inherited options for ko version

Source: https://ko.build/reference/ko_version

The `ko version` command inherits options from parent commands, such as the verbose flag for enabling debug logs.

```bash
  -v, --verbose   Enable debug logs

```

--------------------------------

### ko delete command

Source: https://ko.build/reference/ko_delete

The 'ko delete' command allows users to delete Kubernetes resources. For detailed usage, refer to 'kubectl help delete'.

```APIDOC
## ko delete

### Description
Deletes resources managed by ko.

### Usage
```
ko delete [flags]
```

### Options
```
-h, --help   help for delete
```

### Options inherited from parent commands
```
-v, --verbose   Enable debug logs
```

### SEE ALSO
* ko - Rapidly iterate with Go, Containers, and Kubernetes.
```

--------------------------------

### Override Default Base Image in .ko.yaml

Source: https://ko.build/configuration

Specify a custom base image for all ko builds in your `.ko.yaml` file. This setting can be overridden by the `KO_DEFAULTBASEIMAGE` environment variable.

```yaml
defaultBaseImage: registry.example.com/base/image
```

--------------------------------

### Update Azure Container App

Source: https://ko.build/deployment

Update an Azure Container App with a new container image. The image must be pushed to ACR or another registry service.

```bash
az containerapp update \
  --name my-container-app \
  --resource-group my-resource-group \
  --image $(ko build ./cmd/app)
```

--------------------------------

### Setting KO_DATA_DATE_EPOCH for file modtime

Source: https://ko.build/advanced/faq

Set the modification time for files within KO_DATA_PATH to the latest Git commit's timestamp using the KO_DATA_DATE_EPOCH environment variable.

```bash
export KO_DATA_DATE_EPOCH=$(git log -1 --format='%ct')

```

--------------------------------

### Update AWS Lambda function code

Source: https://ko.build/deployment

Update an AWS Lambda function with a new container image. The image must be pushed to ECR and use the `aws-lambda-go` framework.

```bash
aws lambda update-function-code \
  --function-name=my-function-name \
  --image-uri=$(ko build ./cmd/app)
```
Tokens:
Raw