benhall / golang-demo

Building Docker Images - benhall/golang-demo

Building Docker Images for the “golang-demo” project

When building Docker images for a Go application, there are several options and best practices to consider. This document will cover some of the key concepts and provide examples for each option, using the “golang-demo” project as a reference.

Table of Contents

The Big Picture

Building Docker images for a Go application involves creating a Dockerfile that defines the build process for the application’s container. This includes specifying the base image, copying the application code, building the application, and exposing the necessary ports.

Design Philosophy

When designing a Dockerfile for a Go application, it is important to keep the following principles in mind:

  • Simplicity: The Dockerfile should be easy to read and understand, with clear and concise instructions.
  • Reproducibility: The Dockerfile should produce consistent results, regardless of the environment in which it is run.
  • Efficiency: The Dockerfile should produce a small and efficient image, with only the necessary dependencies and components included.

Programming Languages

The “golang-demo” project is written in Go, which is a statically-typed, compiled language that is well-suited for building containerized applications.

Gorilla Mux

Gorilla Mux is a powerful URL router and dispatcher for matching incoming requests to their respective handler. It is used in the “golang-demo” project to handle routing and dispatching of incoming HTTP requests.

Go Context Packages

Go Context packages provide a way to propagate cancellation signals and deadlines across API boundaries. They are used in the “golang-demo” project to manage the lifecycle of HTTP requests and database connections.

Go SQL Driver for PostgreSQL

The Go SQL Driver for PostgreSQL is a driver for the database/sql package that allows Go applications to connect to and interact with PostgreSQL databases. It is used in the “golang-demo” project to manage database connections and queries.

GoDotEnv

GoDotEnv is a zero-dependency library for loading environment variables from a .env file. It is used in the “golang-demo” project to manage application configuration and settings.

CLI Toolkit for Go

The CLI Toolkit for Go is a collection of libraries and tools for building command-line interfaces in Go. It is used in the “golang-demo” project to build the application’s command-line interface.

PostgreSQL Driver for Go’s database/sql package

The PostgreSQL Driver for Go’s database/sql package is a driver for the database/sql package that allows Go applications to connect to and interact with PostgreSQL databases. It is used in the “golang-demo” project to manage database connections and queries.

GoRequest

GoRequest is a lightweight and flexible HTTP client for Go that makes it easy to send HTTP requests and handle responses. It is used in the “golang-demo” project to send HTTP requests to external APIs.

Structured Logging for Go

Structured Logging for Go is a library for generating structured log messages in Go. It is used in the “golang-demo” project to log application events and errors.

Extension to Go’s database/sql package

The Extension to Go’s database/sql package is a library that provides additional functionality for the database/sql package, including support for prepared statements and transactions. It is used in the “golang-demo” project to manage database connections and queries.

OpenAPI Specification for Go

The OpenAPI Specification for Go is a library for generating OpenAPI documentation for Go applications. It is used in the “golang-demo” project to generate documentation for the application’s API.

Building the Docker Image

To build the Docker image for the “golang-demo” project, you can use the following Dockerfile:

# Use an official Golang runtime as a parent image
FROM golang:1.17-alpine as build-env

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install the necessary dependencies
RUN apk add --no-cache git

# Download and install the Gorilla Mux package
RUN go get -v github.com/gorilla/mux

# Build the Go application
RUN go build -o main .

# Use an Alpine Linux image as the final stage
FROM alpine:3.14

# Copy the Go application from the previous stage
COPY --from=build-env /app/main /usr/local/bin/

# Set the working directory to /app
WORKDIR /app

# Expose port 8080 for the application
EXPOSE 8080

# Set the default command to run the Go application
CMD ["main"]

This Dockerfile uses a multi-stage build process to build the Go application and create a small, efficient image. The first stage (build-env) uses a Golang runtime image to build the application, and the second stage (alpine:3.14) uses an Alpine Linux image to create the final image.

To build the Docker image, run the following command:

docker build -t golang-demo .

This will build the Docker image and tag it with the name “golang-demo”.

To run the Docker image, run the following command:

docker run -p 8080:8080 golang-demo

This will run the Docker image and map port 8080 on the host to port 8080 in the container.

Conclusion

Building Docker images for a Go application involves creating a Dockerfile that defines the build process for the application’s container. By following best practices and using the right tools and libraries, you can create a small, efficient, and reproducible image that is easy to deploy and manage.

Sources