1 min read

Creating a Multi-Stage Dockerfile for a GoLang Web Service

Multi-stage Dockerfiles are a powerful technique for building efficient and lightweight Docker images. By utilizing multiple stages in a single Dockerfile, developers can separate the build process from the runtime environment, resulting in a smaller and more streamlined image.

Benefits of Multi-Stage Dockerfiles

  1. Smaller Image Size: Multi-stage builds eliminate the need to include unnecessary build tools and dependencies in the final image, reducing the image size and improving deployment efficiency.
  2. Improved Security: By separating the build environment from the runtime environment, multi-stage builds minimize the attack surface and potential vulnerabilities.
  3. Faster Build Times: Multi-stage builds can optimize build times by caching intermediate layers and only running the necessary commands in each stage.

Multi-Stage Dockerfile for a Gin-GORM Web Service

Consider the following multi-stage Dockerfile for a Gin-GORM web service:

FROM golang:latest AS builder


COPY go.mod ./
RUN go mod download

COPY *.go ./
RUN go build -o main main.go

FROM alpine:latest AS runtime


COPY --from=builder /app/main .


CMD ["chmod", "+x", "main"]
CMD ["./main"]

Explanation of the Multi-Stage Dockerfile

Builder Stage:

  • Uses the lightweight golang:latest image for building the Go application.
  • Copies the go.mod file and runs go mod download to fetch dependencies.
  • Copies the .go source files and runs go build to build the executable.

Runtime Stage:

  • Uses the lightweight alpine:latest image for running the web service.
  • Copies the built executable (main) from the builder stage.
  • Exposes port 8080 for the web service.
  • Sets the execution commands to chmod and ./main to run the executable with appropriate permissions.

Building the Docker Image

To build the Docker image, save the Dockerfile as Dockerfile in the project directory and execute the following command:

docker build -t gin-gorm-webservice .

This will build the Docker image named gin-gorm-webservice.

Running the Docker Container

To run the Docker container, execute the following command:

docker run -d -p 8080:8080 gin-gorm-webservice

This will start the Docker container and map the container's port 8080 to the host's port 8080, making the web service accessible at http://localhost:8080.

By employing multi-stage Dockerfiles, developers can create efficient, secure, and lightweight Docker images for their GoLang web services, enhancing deployment and resource utilization.