How to learn Go by building a Docker or Kubernetes command-line tool

The fastest way to learn practical Go is to build a command-line tool that grows in deliberate slices. Start with a small executable, then add command parsing, configuration, structured errors, tests, API calls and container packaging. Choose Docker if you want a compact first integration with daemon, image and container operations. Choose Kubernetes if you want deeper practice with typed resources, kubeconfig handling, authentication, namespaces, RBAC and continuously changing cluster state.

This guide takes you from an empty Go module to a maintainable CLI architecture. The examples are instructional; select and verify dependency versions for the Docker API, Kubernetes release and Go toolchain you intend to support.

#	Preview	Product	Price
1		Nicpro Mechanical Carpenter Pencils for Construction (Black, Red) With Case	$9.35	Buy on Amazon
2		DEWALT 20V MAX Drill and Impact Driver (DCK240C2) | Includes 2 Batteries, Charger and Bag (	$149.00	Buy on Amazon
3		Push to Unlock,Katerk 6pcs 1/4 inch Hex Shank Aluminum Alloy Screwdriver Bit Holder Light-Weight...	$9.49	Buy on Amazon
4		2 Pack Carpenter Pencils Mechanical Pencils with 12 Refills, (2 Colors)	$5.99	Buy on Amazon
5		Milwaukee 48-22-3104 Inkzall Point Marker, Fine, Black, 4-Pack	$4.28	Buy on Amazon

As an Amazon Associate I earn from qualifying purchases.

Choose the project that matches what you want to learn

Both projects teach the same Go fundamentals, but the external systems exercise different skills. A Docker command-line tool talks to one daemon and usually exposes operations such as listing images, inspecting containers or starting a container. A Kubernetes tool talks to an API server and works with desired resources, authentication, namespaces, permissions and state that can change after every request.

If Go itself is new, Docker is normally the gentler first milestone because the problem boundary is smaller. If you already understand Go packages and interfaces and want to learn cloud-native control planes, Kubernetes provides more demanding practice. You can build Docker first and reuse the same command, configuration, error and test architecture when you add a Kubernetes subcommand later.

#1 Best Overall

Sale

Nicpro Mechanical Carpenter Pencils for Construction (Black, Red) With Case

• Valued Carpenter Pencil Set: You will get 2 pcs solid carpenter pencils with 26 piece 2.8 mm refills, 1 replaceable sharpener, 1 plastic storage box.The complete carpenter pencils combination allows you to finish your work faster and more easily
• Deep Hole Marker Pencil: The deep-hole construction pencils adopts 45mm elongated tip design, which is more convenient to mark in the small hole or in other tight areas that other carpenter markers cannot reach
• Carpenter Pencils with Sharpener: The sharpener is screwed into the top of the work pencil, which won't get lost either. Built-in pencil sharpener that keep the lead with pointed and smooth to Improves line of sight in fine work
• Stronger Solid Lead: This work pencil is matched with a 2.8 mm thick lead , which is much thicker and stronger during the drawing process of construction work, it will not break or damage easily
• Marks on Various Surfaces: 3 colors solid construction pencil can marks on various surfaces,such as metal, plastic, wood, paper etc. Ideals for woodworkers, contractors, craftsmen, builders, merchants and masons

$9.35

Buy on Amazon

Define a narrow first version

A useful learning project has one command that a user can run repeatedly. Avoid starting with a complete replacement for an existing administration tool. Pick one operation and make its behavior explicit.

Good Docker starting points

• images: list local images in a table or JSON.
• containers: list containers, with an optional running-only filter.
• inspect: print details for one named object.

Good Kubernetes starting points

• pods: list pods in a selected namespace.
• deploy: display deployment state and the number of available replicas.
• resources: retrieve one resource and emit either human-readable or JSON output.

Write a one-sentence contract before coding: “When a user runs this command with these flags, the program requests this object, prints this shape and returns this exit status on failure.” That sentence prevents API code, terminal formatting and argument parsing from becoming one inseparable function.

Build the smallest Go executable

Install a Go toolchain supported by your target environment, then create a module. The module path can be the repository path you plan to publish.

mkdir orchestration-cli
cd orchestration-cli
go mod init example.com/orchestration-cli
cat > main.go <<'EOF'
package main

import "fmt"

func main() {
    fmt.Println("orchestration-cli")
}
EOF
go run .

At this point, keep the program deliberately boring. The first lesson is the Go build-and-run cycle: source files in one package compile together, imports must be used, and go run builds the current module before executing it. Commit this working state before adding an API dependency.

Separate the executable from application packages

Move the entry point under cmd once the program has more than a few functions. A layout such as the following keeps the process boundary thin:

cmd/orchestration-cli/main.go
internal/cli/commands.go
internal/config/config.go
internal/service/docker.go
internal/service/kubernetes.go
internal/output/table.go
internal/output/json.go
internal/exitcode/exitcode.go

The names are examples, not a requirement. The important boundary is that main creates dependencies, invokes a command runner and converts the final error into a process exit code. Service packages should not print directly to the terminal, and output packages should not know how an API client authenticates.

Add command parsing without coupling it to API calls

Begin with the standard library’s flag package if you want to understand parsing mechanics. You can replace it with a command framework later, but the separation should remain the same.

package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {
    images := flag.NewFlagSet("images", flag.ContinueOnError)
    output := images.String("output", "table", "table or json")

    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "usage: orchestration-cli images [flags]")
        os.Exit(2)
    }
    switch os.Args[1] {
    case "images":
        if err := images.Parse(os.Args[2:]); err != nil {
            os.Exit(2)
        }
        if err := runImages(*output); err != nil {
            fmt.Fprintln(os.Stderr, err)
            os.Exit(1)
        }
    default:
        fmt.Fprintf(os.Stderr, "unknown command %qn", os.Args[1])
        os.Exit(2)
    }
}

In a real project, make runImages accept an interface or service object rather than constructing a Docker or Kubernetes client itself. Parsing then becomes testable with argument slices, while the service can be tested with a fake client.

Choose predictable command semantics

• Use exit code 2 for malformed usage, unknown commands or invalid flag values.
• Use a nonzero operational code, commonly 1, when a valid request cannot be completed.
• Write diagnostics to standard error and reserve standard output for requested data.
• Make a machine-readable mode such as --output json produce data without decorative headers.
• Keep command names and flags stable; users will script against them even during your learning project.

Make configuration explicit

Configuration usually comes from three places: command-line flags, environment variables and a configuration file. Decide the precedence once and document it. A practical order is flags first, environment variables second and file values third, with built-in defaults last.

Rank #2

Sale

DEWALT 20V MAX Drill and Impact Driver (DCK240C2) | Includes 2 Batteries, Charger and Bag (

• Ergonomically Designed: Work in tight areas with a compact design that gets into tough spots
• Both tools are designed to fit into difficult to reach spaces
• Complete a wide range of applications with a high-performance motor that delivers up to 300 UWO, and an impact driver delivering up to 1,400 in-lbs of torque
• Both the DEWALT impact driver and drill driver feature integrated LED work lights with a convenient 20-second delay, ensuring enhanced visibility in dimly lit or challenging work areas
• One-Handed Loading - Keep one hand free with a 1/4 in. hex chuck that accepts 1 in. bit tips

$149.00

Buy on Amazon

Represent configuration as data

type Config struct {
    Output    string
    Namespace string
    Kubeconfig string
    DockerHost string
}

func (c Config) Validate() error {
    if c.Output != "table" && c.Output != "json" {
        return fmt.Errorf("output must be table or json")
    }
    return nil
}

Load environment variables at the edge of the program, convert them to the same Config structure as flags and files, then validate once. Do not scatter calls to os.Getenv throughout API methods. Centralized configuration makes precedence visible and allows unit tests to provide a complete configuration without mutating the process environment.

Handle paths and credentials carefully

A Kubernetes command may accept an explicit kubeconfig path, while a Docker command may accept a daemon endpoint. Treat both as sensitive configuration. Never print credential contents in an error or debug message. When a path is not supplied, pass control to the client’s normal discovery behavior rather than silently inventing a location.

Design errors that help users recover

API clients return errors from several layers: invalid local input, transport failure, authentication failure, authorization denial, missing objects and server-side validation. Wrap errors with the operation and object involved, while preserving the underlying cause for tests and programmatic inspection.

func getImage(ctx context.Context, client ImageClient, name string) (Image, error) {
    image, err := client.Get(ctx, name)
    if err != nil {
        return Image{}, fmt.Errorf("get image %q: %w", name, err)
    }
    return image, nil
}

At the command boundary, classify errors into usage, connectivity, authentication, authorization and not-found categories when the client exposes enough information to do so. A message such as “list pods: forbidden in namespace tools; check the service account’s RBAC rules” gives a user a next action. “request failed” does not.

Do not confuse an empty result with an error

An empty image list or a namespace with no pods is a successful request. Render an explicit empty-state message in table mode and an empty array in JSON mode. Reserve errors for a failed request, invalid input or an operation that the server rejected.

Add output modes after the data model works

Keep API response types separate from terminal rows. Docker and Kubernetes responses contain nested fields and metadata that are useful for JSON but too noisy for a default table. Define a small row type containing only the columns your command promises.

type PodRow struct {
    Namespace string `json:"namespace"`
    Name      string `json:"name"`
    Phase     string `json:"phase"`
}

func renderJSON(w io.Writer, value any) error {
    encoder := json.NewEncoder(w)
    encoder.SetIndent("", "  ")
    return encoder.Encode(value)
}

Write table rendering to an injected io.Writer, not directly to os.Stdout. This lets tests capture output and lets callers embed the command runner in another program. Preserve stable column order and avoid depending on map iteration order.

Integrate Docker through the Engine API

Docker documents an API for interacting with the Docker daemon, called the Docker Engine API, and provides SDKs for Go and Python. A Go CLI can use the Go SDK instead of constructing HTTP requests manually. The SDK can negotiate an API version supported by both the client and daemon, which is safer than assuming that every daemon speaks the newest API.

Keep the Docker client behind an interface

type ImageSummary struct {
    ID      string
    Tags    []string
    Created int64
    Size    int64
}

type ImageClient interface {
    ListImages(context.Context, bool) ([]ImageSummary, error)
}

type DockerService struct {
    client ImageClient
}

func (s DockerService) Images(ctx context.Context, all bool) ([]ImageSummary, error) {
    return s.client.ListImages(ctx, all)
}

The concrete SDK client is assembled in your dependency-injection code. Configure it from the Docker daemon endpoint available in the user’s environment, allow the SDK to negotiate a mutually supported API version and close the client when the process exits if the SDK requires cleanup.

Rank #3

Sale

Push to Unlock,Katerk 6pcs 1/4 inch Hex Shank Aluminum Alloy Screwdriver Bit Holder Light-Weight Quick-Change Extension Bar Keychain Drill Screw Adapter Portable,Black Carabiner,Tool Gifts for Men

• 【Great Compatibility】This Katerk 1/4 inch hex shank bit holder is specifically designed for 1/4 inch hex shank drill bits. It's compatible with most 1/4 fast hex handles, hex sockets, various electric screwdrivers, and handheld screwdrivers. The bit holder makes it a valuable addition for any handyman.
• 【Secure and Safe】Built with a secure backup nut design, each drill bit holder securely locks onto your bits, ensuring they stay firmly in place. Additionally, our bit holder incorporates a high-quality steel ball rolling design that holds up to several kilograms of weight, ensuring your various drill bits don't fall off.
• 【Easy One-Handed Operation】The bit holder for impact driver allows you to change bits single-handedly, simplifying your workflow. Its multi-color design further allows for quick identification of the drill bit you need.
• 【Compact and Convenient】Thanks to its compact size, this 1/4 inch bit holder is easy to carry around. The bit holder allows for easy attachment to various tools, making this a convenient addition to your construction accessories. The Katerk bit holder is cast from high-quality alloy material, promising a long product lifespan. Despite its rugged strength, the bit holder remains lightweight, making it portable.
• 【Cool Christmas Gift For Men Stocking Stuffers】 This screwdriver bit holder, driver bit holder, impact bit holder, can be given as a gift to your loved one, especially for anyone involved in construction or electrical work. It's a must-have for stocking stuffers for men and women, tools gifts for dad, tech gadgets for men, gifts for dad, gifts for him, gifts for husband, gifts for boyfriend, cool gadgets for men, and cool gifts for dad.

$9.49

Buy on Amazon

Implement the first Docker command

1. Parse images, --all and --output.
2. Create a context with a cancellation path so an interrupted terminal session can stop the request.
3. Construct the SDK client and verify daemon connectivity through the list operation rather than a separate speculative request.
4. Map each SDK result into your own image-row type.
5. Render a table or JSON and return a classified error if the daemon cannot be reached or rejects the request.

Test the command with a fake ImageClient before requiring a live daemon. Then add an integration test that runs against a local or disposable daemon. Keep that test separate from fast unit tests because it depends on external state and daemon availability.

Account for Docker-specific failures

• Daemon unavailable: report the endpoint or connection class of failure and tell the user to check that the daemon is running and reachable.
• API incompatibility: preserve the SDK’s negotiated-version error instead of claiming that the command itself is invalid.
• Image not found: distinguish an absent object from an empty list.
• Permission denied: explain that access to the daemon is controlled outside the CLI, often by the user’s local daemon permissions.

Integrate Kubernetes with client-go

k8s.io/client-go is the official Go client for Kubernetes. Its documentation covers typed, dynamic, discovery and cache packages. Start with a typed client for the resource your command owns. Add dynamic or discovery clients only when the command genuinely needs unstructured resources or runtime API discovery.

Align the dependency with your target Kubernetes release

Kubernetes client libraries are not interchangeable across every release. Choose the Kubernetes release your CLI will support, select the corresponding release-aligned client-go tag and record that dependency in go.mod. The installation workflow uses go get; use the release tag you selected rather than blindly accepting an unrelated version.

go get k8s.io/client-go@<release-tag>
go mod tidy

Pin the resulting module versions in source control. When upgrading, change the target deliberately, read the compatibility notes for that release and run unit and integration tests against the cluster versions you claim to support. A successful compile alone does not prove that authentication, API discovery or resource behavior remains compatible.

Load a kubeconfig for a user-run command

Kubernetes documents that the Go client can use the same kubeconfig file as the kubectl CLI to locate and authenticate to an API server. A command-line tool should therefore offer an explicit kubeconfig option and otherwise use the normal user configuration behavior.

func kubeConfig(explicitPath string) (*rest.Config, error) {
    loading := clientcmd.NewDefaultClientConfigLoadingRules()
    if explicitPath != "" {
        loading.ExplicitPath = explicitPath
    }
    overrides := &clientcmd.ConfigOverrides{}
    return clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
        loading, overrides,
    ).ClientConfig()
}

After obtaining a REST configuration, construct the typed client for the resource you need. Keep kubeconfig loading in a package that can be tested independently from pod or deployment logic. If the file is missing, the selected context is invalid or credentials have expired, return an authentication-oriented error instead of a generic API failure.

Support in-cluster execution separately

A program running inside Kubernetes can use service-account configuration supplied to its pod. Detect in-cluster execution through the client-go configuration path and construct the in-cluster configuration when appropriate. Do not assume that a developer’s workstation kubeconfig exists inside a container. The service account must also have RBAC permissions for every verb and resource the command requests.

Use typed clients for predictable resources

For a pod-list command, use the typed core client and pass the namespace and list options explicitly. For deployments, use the typed apps client. Keep API calls in a service layer that returns domain data rather than exposing the entire client-go object to the renderer.

type PodLister interface {
    List(context.Context, string, metav1.ListOptions) (*corev1.PodList, error)
}

func listPodRows(ctx context.Context, lister PodLister, namespace string) ([]PodRow, error) {
    list, err := lister.List(ctx, namespace, metav1.ListOptions{})
    if err != nil {
        return nil, fmt.Errorf("list pods in namespace %q: %w", namespace, err)
    }
    rows := make([]PodRow, 0, len(list.Items))
    for _, pod := range list.Items {
        rows = append(rows, PodRow{
            Namespace: pod.Namespace,
            Name:      pod.Name,
            Phase:     string(pod.Status.Phase),
        })
    }
    return rows, nil
}

The interface makes the transformation testable without a cluster. A separate integration test can use a disposable cluster and the real client-go implementation.

Rank #4

Sale

2 Pack Carpenter Pencils Mechanical Pencils with 12 Refills, (2 Colors)

• Long Nib and Deep Hole Marker: Our mechanical carpenter pencil with 45mm nib is designed for easy marking of deep holes or narrow areas. These construction pencils are the great choice for woodworking tools, construction tools, carpenter tools, contractor tools, wood carpentry tools and architect tools
• Extra Refills in 2 Colors for Versatile Marking: The construction mechanical pencil comes with 12 extra 2.8mm refills, including 6 red and 6 black refills. The black refill is suitable for light surfaces, while the red wax is perfect for dark surfaces. Our carpenter mechanical pencil makes sure that you'll have an ample supply for extended use
• Built-in Sharpener: Our construction pencil comes with a built-in sharpener to ensure the mechanical pencil tip is always sharp and ready for use. Never buy an extra pencil sharpener again. A great tool for any woodworker pencil, contractor pencils. The refill can easily be extended or retracted with a simple click of the pencils mechanical, allowing you to work more efficiently and accurately
• Portable Clip Design: Our deep hole construction pencil features a portable clip design, easy to carry and attach to your pocket or tool box, so that you can keep the carpenter pencils mechanical close at hand, making it a convenient tool to have on the go. Great gifts choice for carpenters
• Stronger Pencil Lead: The black refills are made of lead, sturdy and smooth. The red refills are made of wax, clear and light. These marking pencils are much thicker and stronger than normal pencils during the marking process of construction work, suitable for various surfaces, such as glasses, metal, boards, floors, walls, furniture, etc. The written marks can be easily wiped with a wet paper towel when needed

$5.99

Buy on Amazon

Understand Kubernetes-specific failures

• API-server connectivity: the selected cluster endpoint may be unreachable, or the container may lack network access.
• Authentication failure: kubeconfig credentials or in-cluster service-account credentials are missing, expired or invalid.
• RBAC denial: the identity is authenticated but lacks permission for the requested verb, resource or namespace.
• Namespace mistakes: a resource may exist in another namespace, while cluster-scoped resources do not accept a namespace.
• Resource state: a deployment can exist while its pods are pending, unavailable or repeatedly restarting; distinguish object existence from readiness.

Build a progression that keeps each slice working

Use the following sequence so every addition has a visible outcome.

1. Executable: create the module, compile a minimal program and establish the command name.
2. Pure parser: turn argument slices into a command structure without making network calls.
3. Configuration: merge flags, environment variables and file settings, then validate once.
4. Pure output: convert domain rows to table and JSON representations using injected writers.
5. Structured errors: wrap failures with operation context and map them to stable exit categories.
6. Fake-backed service: test command behavior with an interface and deterministic responses.
7. Real API integration: connect to Docker’s daemon or a Kubernetes API server only after the local layers are reliable.
8. Operational safeguards: add request cancellation, timeouts, logging controls and safe handling of credential-related errors.
9. Packaging: build a small distributable binary and run it in a container with the correct configuration path.

At each step, keep the previous command behavior intact. If adding JSON output breaks the table path, fix that regression before introducing an API client. This turns a large project into a chain of small, explainable Go exercises.

Test pure logic first, integrations second

Unit tests should cover functions that do not need Docker or Kubernetes: argument parsing, configuration precedence, validation, error classification, row conversion and rendering. Table-driven tests are a natural fit because the same function usually has several input and expected-output combinations.

func TestConfigValidate(t *testing.T) {
    cases := []struct {
        name string
        cfg  Config
        wantErr bool
    }{
        {name: "table", cfg: Config{Output: "table"}},
        {name: "json", cfg: Config{Output: "json"}},
        {name: "invalid", cfg: Config{Output: "yaml"}, wantErr: true},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            err := tc.cfg.Validate()
            if (err != nil) != tc.wantErr {
                t.Fatalf("Validate() error = %v, wantErr %v", err, tc.wantErr)
            }
        })
    }
}

For Docker, integration tests should exercise the real SDK against a local or disposable daemon. For Kubernetes, use a disposable cluster when you need to verify authentication, discovery, namespace behavior or RBAC. Keep those tests opt-in or in a separate test stage so a developer can run fast unit tests without infrastructure.

Test failure paths deliberately

• Return an error from the fake client and assert that the command includes the operation name.
• Return an empty list and assert successful empty output.
• Return a permission-style error and assert the nonzero exit classification.
• Pass malformed flags and verify that no client is constructed.
• Cancel the context and verify that the service returns promptly.

Package the CLI in Docker

Docker’s Go guidance recommends using an official Go image and copying module files before downloading dependencies. That ordering lets Docker reuse the dependency-download layer when application source changes.

FROM golang:<go-version> AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /out/orchestration-cli ./cmd/orchestration-cli

FROM scratch
COPY --from=build /out/orchestration-cli /orchestration-cli
ENTRYPOINT ["/orchestration-cli"]

Select an official Go image tag that matches the toolchain used to build and support the project. The final image shown here is intentionally minimal; if your program needs certificate authorities, timezone data or a shell for diagnostics, choose a runtime base that supplies those pieces instead of assuming they exist.

Decide how the container receives credentials

A containerized Docker command needs a reachable Docker daemon endpoint and the appropriate permissions. A containerized Kubernetes command can receive a mounted kubeconfig for user-style execution or use in-cluster service-account configuration when it runs as a pod. Do not bake credentials into the image or copy a developer’s kubeconfig into a build context. Pass paths and endpoints at runtime, and document the required mounts, environment variables and service-account permissions.

Common mistakes and recovery paths

Putting everything in main

Symptom: parsing, client creation, API calls and printing occupy one function, so every test needs a live service. Recovery: move each concern behind a small function or interface, then make main only assemble dependencies and translate the final error.

Using the newest dependency without a support policy

Symptom: a client compiles locally but behaves differently against the daemon or cluster you support. Recovery: write down the Docker API compatibility target or Kubernetes release, pin dependencies and upgrade them intentionally.

Best Value

Milwaukee 48-22-3104 Inkzall Point Marker, Fine, Black, 4-Pack

• Milwaukee Ink all Fine Point Marker, Black, 4 Per Pack
• 4 per pack Features Clog Resistant Marker Tip Writes through Dusty, Wet and Oily Surfaces Durable Marker Tip for Writing on Concrete, OSB and Rough Surfaces
• Clog resistant tip writes on dusty, wet and oily surfaces and is optimized for rough surfaces such as OSB, cinderblock and concrete
• Hard hat clip- attaches for easy access
• Quick dry time with reduced smearing and marking

$4.28

Buy on Amazon

Treating authentication and authorization as the same failure

Symptom: users are told to replace credentials when the identity is valid but lacks an RBAC rule. Recovery: preserve the server’s distinction between unauthenticated and forbidden responses and include the resource, verb and namespace in the diagnostic when available.

Printing secrets while debugging

Symptom: verbose logs expose kubeconfig tokens, certificate data or daemon credentials. Recovery: log operation names, endpoints with sensitive components removed and safe identifiers only. Make debug logging opt-in and review it before shipping.

Assuming a successful API call means the workload is ready

Symptom: a deployment command exits successfully because the object was created, even though no replica is available. Recovery: define whether the command reports submission or readiness, inspect the relevant status fields and state that contract in the help text.

Relying on a workstation-only configuration

Symptom: the binary works with a local kubeconfig but fails in a container or CI job. Recovery: test both explicit kubeconfig loading and in-cluster service-account configuration, and document which execution mode each command expects.

Turn the project into a reusable Go curriculum

Every feature should teach one Go concept and one operational concept. Command parsing exercises structs, slices and validation. Configuration exercises file and environment handling. Error wrapping exercises interfaces and control flow. Output rendering exercises encoders and writers. API integration exercises context propagation, dependency injection and compatibility management. Packaging exercises reproducible builds and runtime configuration.

Keep a short design note beside the code describing the supported Docker daemon or Kubernetes release, authentication modes, command exit codes and output schema. When you later add a second command, copy the boundaries—not the implementation. A new containers command should reuse configuration, output and error handling while owning only its Docker service and row conversion. A deploy command should do the same with its Kubernetes typed client.

Final checklist before calling the CLI usable

• The module builds from a clean checkout with dependencies recorded in go.mod and go.sum.
• Help text names commands, required flags, defaults, output modes and authentication expectations.
• Malformed input fails before any API client or network request is created.
• Docker clients use negotiated API compatibility rather than an assumed daemon version.
• Kubernetes client-go is aligned with the release you target.
• Kubeconfig and in-cluster service-account paths are tested separately.
• RBAC, namespace and resource-state failures produce actionable diagnostics.
• Unit tests cover pure functions and fake-client behavior; integration tests are isolated from them.
• Table output is readable by people, JSON output is stable for scripts and empty results are successful.
• The container build copies module files before downloading dependencies and receives credentials only at runtime.

Where this learning path leads

A Docker version gives you a compact, demonstrable Go application: parse a command, call a daemon API, transform results and package one binary. A Kubernetes version extends the same architecture into release compatibility, kubeconfig discovery, service-account authentication, typed resources, RBAC and eventually watches or caches. The project becomes valuable when each layer remains understandable and independently testable.

Start with one command, keep the external client behind an interface, and add complexity only after the previous slice works. That approach teaches Go through decisions you can observe in a real tool rather than through isolated language exercises.

Quick Recap

SaleBestseller No. 1

Nicpro Mechanical Carpenter Pencils for Construction (Black, Red) With Case

$9.35

SaleBestseller No. 2

DEWALT 20V MAX Drill and Impact Driver (DCK240C2) | Includes 2 Batteries, Charger and Bag (

Both tools are designed to fit into difficult to reach spaces

$149.00

SaleBestseller No. 3

Push to Unlock,Katerk 6pcs 1/4 inch Hex Shank Aluminum Alloy Screwdriver Bit Holder Light-Weight Quick-Change Extension Bar Keychain Drill Screw Adapter Portable,Black Carabiner,Tool Gifts for Men

$9.49

SaleBestseller No. 4

2 Pack Carpenter Pencils Mechanical Pencils with 12 Refills, (2 Colors)

$5.99

Bestseller No. 5

Milwaukee 48-22-3104 Inkzall Point Marker, Fine, Black, 4-Pack

Milwaukee Ink all Fine Point Marker, Black, 4 Per Pack; Hard hat clip- attaches for easy access

$4.28

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.

client-goCommand Line ToolsDockerDocker Engine APIGoKubernetesSoftware Development