Dockerizing Go Applications

Learn dockerizing go applications through an executable example, then connect the small demonstration to production code.

Containers package a Go binary with a defined runtime environment. A multi-stage Docker build can compile with the Go toolchain, then copy the binary into a smaller runtime image.

The runnable example models a server address without actually starting a listener; the Dockerfile is supplied separately for a real container build.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

Example Dockerfile

FROM golang:1.23 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /app ./cmd/api

FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /app /app
EXPOSE 8080
USER nonroot:nonroot
ENTRYPOINT ["/app"]

Adjust the Go builder version, binary package path and dependency copy step to your actual project. go.sum may be absent if the project has no external dependencies. Pin and update base-image digests for production.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func main() {
	address := ":8080"
	fmt.Println("Configure HTTP listen address:", address)
	fmt.Println("Container must expose or publish the chosen port")
}

Output

Configure HTTP listen address: :8080
Container must expose or publish the chosen port

The program prints a proposed listen address and a deployment reminder. A real server must pass this address to http.ListenAndServe or a configured http.Server.

• EXPOSE documents a port but does not publish it onto the host.
• Use trusted, updated builder/runtime images and avoid embedding production secrets in Dockerfile layers.

Write a server that listens on :8080, build the example container, and access it with a published port.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Dockerizing Go Applications in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.