How to deploy Go web applications using Docker

This article introduces how to use Docker and Docker Compose to deploy our Go web application.

Why do we need Docker?

The main purpose of using docker is containerization. That is, providing a consistent environment for your application, independent of the host it runs on.

Imagine if you have also encountered the following scenario, you have developed your application locally, it is likely to have many dependent environments or packages, and even have strict requirements on the specific versions of the dependencies. When the development process is completed, you want to deploy the application to the web server. At this point you must make sure that all dependencies are installed correctly and are the exact same versions, otherwise the application may crash and not run. If you want to deploy the application on another web server, you have to repeat the process from the beginning. This scenario is where Docker comes into play.

For the host running our application, whether it is a laptop or a web server, the only thing we need to do is to run a docker container platform. From now on, you don’t need to worry about whether you are using MacOS, Ubuntu, Arch or other. You define your application once and run it anywhere.

Docker deployment example

Preparing the code

Here I will use a simple code written using the net/http library as an example to explain how to use Docker for deployment, and then explain a slightly more complex project deployment case.

package main

import (
 "fmt"
 "net/http"
)

func main() {
 http.HandleFunc("/", hello)
 server := &http.Server{
 Addr: ":8888",
 }
 fmt.Println("server startup...")
 if err := server.ListenAndServe(); err != nil {
 fmt.Printf("server startup failed, err:%v\n", err)
 }
}

func hello(w http.ResponseWriter, _ *http.Request) {
 w.Write([]byte("hello liwenzhou.com!"))
}

The above code provides external services through port 8888 and returns a string response: hello liwenzhou.com!.

Creating a Docker Image

An image contains everything needed to run an application - the code or binaries, the runtime, dependencies, and any other file system objects required.

Or simply put, an image is everything that defines an application and needs to run it.

Writing a Dockerfile

To create a Docker image, you must specify the steps in the configuration file. By default, this file is usually called Dockerfile. (Although you can name this file anything you want, it’s best to use the default Dockerfile.)

Now we start writing the Dockerfile, the specific contents are as follows:

Note: Some steps are not unique and can be modified according to your needs, such as file path, name of the final executable file, etc.

FROM golang:alpine

# Set the necessary environment variables ENV GO111MODULE=on for our image \
 CGO_ENABLED=0 \
 GOOS=linux \
 GOARCH=amd64

# Move to the working directory: /build
WORKDIR /build

# Copy the code into the container COPY . .

# Compile our code into a binary executable file app
RUN go build -o app .

# Move to the /dist directory for storing generated binary files WORKDIR /dist

# Copy the binary files from the /build directory here RUN cp /build/app .

#Declare service port EXPOSE 8888

# Command to run when starting the container CMD ["/dist/app"]

Dockerfile parsing

From
We are using the base image golang:alpine to create our image. This is the same base image we are going to create that is stored in a Docker repository that we can access. This image runs the alpine Linux distribution, which is small in size and has Go built in, making it a good fit for our use case. There are a large number of publicly available Docker images, see https://hub.docker.com/_/golang

Env
Used to set the environment variables we need during the compilation phase.

WORKDIR, COPY, RUN
The commands are explained in the comments, so it is easy to understand.

EXPORT，CMD
Finally, we declare the service port because our application listens on this port and provides external services through this port. And we also define the default command CMD ["/dist/app"] that is executed when we run the image.

Build the image

In the project directory, execute the following command to create an image and specify the image name as goweb_app:

docker build . -t goweb_app

Wait for the build process to finish and the following prompt will be output:

...
Successfully built 90d9283286b7
Successfully tagged goweb_app:latest

Now we have our image ready, but it currently does nothing. What we need to do next is run our image so that it can handle our requests. A running image is called a container.

Execute the following command to run the image:

docker run -p 8888:8888 goweb_app

The -p flag is used to define port binding. Since the application in the container is running on port 8888, we bind it to the host port also 8888. If you want to bind to another port, you can use -p $HOST_PORT:8888. For example -p 5000:8888.

Now we can test whether our web program is working properly. Open the browser and enter http://127.0.0.1:8888 to see the response content we defined in advance as follows:

hello liwenzhou.com!

Staged build example

After compiling our Go program, we will get an executable binary file. In fact, the go compiler is not needed in the final image, that is to say, we only need a container to run the final binary file.

One of the best practices with Docker is to reduce the image size by keeping only the binary files, to do this we will use a technique called multi-stage builds, which means we will build the image in multiple steps.

FROM golang:alpine AS builder

# Set the necessary environment variables ENV GO111MODULE=on for our image \
 CGO_ENABLED=0 \
 GOOS=linux \
 GOARCH=amd64

# Move to the working directory: /build
WORKDIR /build

# Copy the code into the container COPY . .

# Compile our code into a binary executable file app
RUN go build -o app .

###################
# Next, create a small mirror####################
FROM scratch

# Copy /dist/app from the builder image to the current directory COPY --from=builder /build/app /

# Command to be run ENTRYPOINT ["/app"]

Using this technique, we stripped out the process of compiling a binary executable using golang:alpine as a build image and generated a simple, very small new image based on scratch. We copy the binaries from the first image named builder to the newly created scratch image. For more information about the scratch image, see https://hub.docker.com/_/scratch

Deployment example with additional files

Here I take the small list project in my previous "Go Web Video Tutorial" as an example. The Github repository address of the project is: https://github.com/Q1mi/bubble.

If the project contains static files or configuration files, they need to be copied to the final image file.

Our bubble project uses static files and configuration files. The specific directory structure is as follows:

bubble
├── README.md
├── bubble
├── conf
│ └── config.ini
├── controller
│ └── controller.go
├── dao
│ └── mysql.go
├── example.png
├── go.mod
├── go.sum
├── main.go
├── models
│ └── todo.go
├── routers
│ └── routers.go
├── setting
│ └── setting.go
├── static
│ ├── css
│ │ ├── app.8eeeaf31.css
│ │ └── chunk-vendors.57db8905.css
│ ├── fonts
│ │ ├── element-icons.535877f5.woff
│ │ └── element-icons.732389de.ttf
│ └── js
│ ├── app.007f9690.js
│ └── chunk-vendors.ddcb6f91.js
└── templates
 ├── favicon.ico
 └── index.html

We need to copy the contents of the templates, static, and conf folders to the final image file. The updated Dockerfile is as follows

FROM golang:alpine AS builder

# Set the necessary environment variables ENV GO111MODULE=on for our image \
 CGO_ENABLED=0 \
 GOOS=linux \
 GOARCH=amd64

# Move to the working directory: /build
WORKDIR /build

# Copy the go.mod and go.sum files in the project and download dependency information COPY go.mod .
COPY go.sum .
RUN go mod download

# Copy the code into the container COPY . .

# Compile our code into a binary executable file bubble
RUN go build -o bubble .

###################
# Next, create a small mirror####################
FROM scratch

COPY ./templates /templates
COPY ./static /static
COPY ./conf /conf

# Copy /dist/app from the builder image to the current directory COPY --from=builder /build/bubble /

# Command to run ENTRYPOINT ["/bubble", "conf/config.ini"]

To put it simply, there are a few more COPY steps. Just look at the comments in the Dockerfile.

Tips: Here, put the steps of COPY static files in the upper layer and COPY binary executable files in the lower layer, and try to use more cache.

Linking other containers

Because MySQL is used in our project, we can choose to start a MySQL container with the following command. Its alias is mysql8019; the root user's password is root1234; mount the /var/lib/mysql in the container to the local /Users/q1mi/docker/mysql directory; the internal service port is 3306, which is mapped to the external port 13306.

docker run --name mysql8019 -p 13306:3306 -e MYSQL_ROOT_PASSWORD=root1234 -v /Users/q1mi/docker/mysql:/var/lib/mysql -d mysql:8.0.19

Here we need to modify the MySQL host address configured in our program to the container alias so that they can communicate internally through the alias (mysql8019 here).

[mysql]
user = root
password = root1234
host = mysql8019
port = 3306
db = bubble

Remember to rebuild the bubble_app image after modification:

docker build . -t bubble_app

When we run the bubble_app container here, we need to use the --link method to associate it with the mysql8019 container above. The specific commands are as follows:

docker run --link=mysql8019:mysql8019 -p 8888:8888 bubble_app

Docker Compose Mode

In addition to using the --link method to associate two containers as above, we can also use Docker Compose to define and run multiple containers.

Compose is a tool for defining and running multi-container Docker applications. With Compose, you use YML files to configure all the services your application needs. Then, with a single command, you can create and start all services from the YML file configuration.

Using Compose is basically a three-step process:

1. Use Dockerfile to define your application environment so it can be replicated anywhere.
2. Define the services that make up your application in docker-compose.yml so that they can run together in isolated environments.
3. Execute the docker-compose up command to start and run the entire application.

Our project requires two containers to run mysql and bubble_app respectively. The content of the docker-compose.yml file we wrote is as follows:

#yaml configuration version: "3.7"
services:
 mysql8019:
 image: "mysql:8.0.19"
 ports:
  - "33061:3306"
 command: "--default-authentication-plugin=mysql_native_password --init-file /data/application/init.sql"
 environment:
  MYSQL_ROOT_PASSWORD: "root1234"
  MYSQL_DATABASE: "bubble"
  MYSQL_PASSWORD: "root1234"
 volumes:
  - ./init.sql:/data/application/init.sql
 bubble_app:
 build: .
 command: sh -c "./wait-for.sh mysql8019:3306 -- ./bubble ./conf/config.ini"
 depends_on:
  -mysql8019
 ports:
  - "8888:8888"

This Compose file defines two services: bubble_app and mysql8019. in:

bubble_app
Use the Dockerfile file in the current directory to build the image, specify the dependency on the mysql8019 service through depends_on, declare the service port 8888 and bind the external port 8888.

mysql8019
The mysql8019 service uses the public mysql:8.0.19 image from Docker Hub, with internal port 3306 and external port 33061.

One thing to note here is that our bubble_app container needs to wait for the mysql8019 container to start normally before trying to start, because our web program will initialize the MySQL connection when it starts. There are two places to change here. The first is to comment out the last sentence in our Dockerfile:

# Dockerfile
...
# Commands to run (comment this sentence because we need to wait until MySQL is started before starting our web program)
# ENTRYPOINT ["/bubble", "conf/config.ini"]

The second place is to add the following command under bubble_app, use the pre-written wait-for.sh script to detect that mysql8019:3306 is normal before executing the subsequent command to start the Web application:

command: sh -c "./wait-for.sh mysql8019:3306 -- ./bubble ./conf/config.ini"

Of course, because we are now going to execute the sh command in the bubble_app image, we cannot use the scratch image to build it. Instead, we use debian:stretch-slim. At the same time, we also need to install netcat used by the wait-for.sh script. Finally, don’t forget to copy the wait-for.sh script file to the final image and grant executable permissions. The updated Dockerfile content is as follows:

FROM golang:alpine AS builder

# Set the necessary environment variables ENV GO111MODULE=on for our image \
 CGO_ENABLED=0 \
 GOOS=linux \
 GOARCH=amd64

# Move to the working directory: /build
WORKDIR /build

# Copy the go.mod and go.sum files in the project and download dependency information COPY go.mod .
COPY go.sum .
RUN go mod download

# Copy the code into the container COPY . .

# Compile our code into a binary executable file bubble
RUN go build -o bubble .

###################
# Next, create a small mirror####################
FROM debian:stretch-slim

COPY ./wait-for.sh /
COPY ./templates /templates
COPY ./static /static
COPY ./conf /conf


# Copy /dist/app from the builder image to the current directory COPY --from=builder /build/bubble /

RUN set -eux; \
 apt-get update; \
 apt-get install -y \
 --no-install-recommends \
 netcat; \
  chmod 755 wait-for.sh

# Command to run # ENTRYPOINT ["/bubble", "conf/config.ini"]

After all the conditions are ready, you can execute the following command to run:

docker-compose up

For the complete code example, please check out my github repository: https://github.com/Q1mi/deploy_bubble_using_docker.

Summarize

Using Docker containers can greatly simplify our operations in configuring dependent environments, but it also places higher demands on our technical reserves. Whether you are familiar with Docker or not, the wheel of technological development is rolling forward.

Reference Links:

https://levelup.gitconnected.com/complete-guide-to-create-docker-container-for-your-golang-application-80f3fb59a15e

This is the end of this article on how to use Docker to deploy Go Web applications. For more information about Docker deployment of Go Web, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!