We use docker images to have same application with its dependencies on any kind environment. Having compile time and runtime dependencies is the nature of a specific developer’s life. For example, in previous article, we had Golang dependency to build our Golang REST API. We need to design our dependencies carefully to eliminate unnecessary dependency within container is alive. In this tutorial, we will see how to use docker multi-stage builds to bundle our application in real life.

Ways to Handle Dependencies

Let say that, you have a Golang application, and you are developing a docker image to run on production environment. You can follow 2 ways to handle this;

1. Use a build tool like Jenkins to compile you Golang application into a binary and add this binary to docker image. You need to have Golang installed on your Jenkins machine to build Golang project.
2. You can add Golang as dependency to your docker image, and you can run Golang application within container with go run … or build your Golang application inside docker image and execute binary.

In 1st strategy, you need to have Golang installed in order to build docker images, since you need a compiled binary. When a new joiner of your team clones project, he/she needs to install Golang and continue to work

In 2nd strategy, no need to install anything, just clone project and build docker image, since everything included inside Dockerfile definition.

Wait! Why we have Golang dependency inside docker image even I only need that at first time during compiling ? Because we are too lazy to install Golang locally and build project and use inside docker image to eliminate that dependency 🙂 Let’s find a proper way to be happy with our laziness and yet eliminate dependency.

Multi-Stage Builds

Multi-stage builds helps us to keep our Dockerfile clean and reduces the image size by not including the dependencies you will not need on run time. In order to do this, we will simply do some operations on first step and then send the output of first step to the second step as parameter.

FROM instrumentisto/glide as builder
WORKDIR /go/src/bitbucket.org/kloiahuseyin/flowmon-projects
COPY . .
RUN glide install
RUN CGO_ENABLED=0 GOOS=linux go build -a -tags flowmon -o build/flowmon-projects -ldflags ‘-w’ .

FROM scratch
COPY — from=builder /go/src/bitbucket.org/kloiahuseyin/flowmon-projects/build/flowmon-projects app
ENV PORT 3000
EXPOSE 3000
ENTRYPOINT [“/app”]

In first section, we add our dependent image for glide and provide an alias builder. Since, this Dockerfile inside our project, we simply add project files to docker image. With glide install, we install all the dependencies for Golang project. Finally, we compile our Golang application into a executable binary with CGO_ENABLED=0 GOOS=linux go build -a -tags flowmon -o build/flowmon-projects -ldflags ‘-w’ .

At the end of the first stage, we have likely created an image that contains our binary. On second step, we used stratch which is an empty image and then copied our binary from first image with FROM scratch
COPY — from=builder /go/src/bitbucket.org/kloiahuseyin/flowmon-projects/build/flowmon-projects app . Now we have our binary app, and only thing we need to do is providing this as entrypoint to our image.

Conclusion

There are several ways to create a docker image and the best way is to do this with minimum dependencies for cross platforms. Instead of being needed to install some dependencies, it is better to do this within Dockerfile by using multi-stage builds. For example, you don’t need to go to the Jenkins to see application dependencies in order to create your docker image on your local image. If you want to see this in action, you can refer for source code here

We are able to run an application in seconds with Docker nowadays just by grabbing specific image within several official / custom docker images and that’s it. However, this easiness, using ready images for your application, may let us to have docker images with a size hundreds of megabytes ! In this article, I will show you how to create damn small images for Go application and run them. Let’s rock!

Sample Go REST API

I assume you have already have Golang and necessary tools installed on your system. This project has no dependent external library, so just create a file called main.go and put following content inside

package main

import (
 "net/http"
 "fmt"
 "log"
)

func main() {
 http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
  fmt.Fprint(writer, "Hello, World")
 })
 log.Fatal(http.ListenAndServe(":3000", nil))
}

This is a sample application that listens requests on port 3000 and responds Hello, World. You can try it yourself by executing go run main.go, and going to http://localhost:3000

Dockerize Go Project with Official Image

What is your first step for dockerizing a project? Just search official image you need on Docker Hub and just use inside Dockerfile right? Let’s use this approach first. Create a Dockerfile inside project folder and use official golang image to run your project inside container.

FROM golang
ADD . ./
RUN go build -o main
ENV PORT 3000
EXPOSE 3000
CMD [“/main”]

Build your docker image with docker build -t my-go-app-golang .

Now check your image with docker images | grep my-go-app-golang

739 MB! If you are happy with this size, I think you don’t need to go further, thanks for reading so far 🙂 If you want to make this smaller, continue to read…

Dockerize Go Project with Official Alpine Image

Docker Alpine images are the images with minimal dependencies that means you will not be able to see lots of tools inside it when you exec and check. For a specific Golang application, we don’t need so much dependencies and this alpine images may fit well with our needs.

Use Alpine Image inside your Dockerfile like below;

FROM golang:alpine
ADD . ./
RUN go build -o main
ENV PORT 3000
EXPOSE 3000
ENTRYPOINT [“/main”]

Build it wit docker build -t my-go-app-alpine .

Now check your image with docker images | grep my-go-app-alpine

275 MB, is it small enough for you ? Ok, keep reading for next surprize docker image size.

Dockerize Go Project with Docker Stratch Image

Think about a docker image and there is nothing inside it. Yes, it is Docker Scratch image. You cannot pull this image, but you can refer this in your Dockerfile. The very first next line after referral will be your 1st layer of filesystem. The main strategy here is, provide your binary as entrypoint this scratch image and that’s all.

We need a binary of our Golang application to provide as an entrypoint to our scratch image. In order to build a binary, go to your project folder and execute:

CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

Here with CGO_ENABLED=0 we are saying that disable cgo and build golang application statically that means you will have all the dependencies once you copy this binary to image. -a is for re build entire packages to be sure you have all the dependencies. After this execution, you will have a binary inside your project folder.

We have a binary and now create Dockerfile with following content.

FROM scratch
ADD main ./
ENV PORT 3000
EXPOSE 3000
ENTRYPOINT [“/main”]

You can create your image with docker build -t my-go-app-scratch .

And when you check your image size docker images | grep my-go-app-scratch

6.1 MB! If this is not small enough for you, keep reading …

Just joking 🙂 This is the minimal image I can provide you for this application. We have make image 100 times smaller than initial one. This minimal image will keep our motivation very high because, you will be able to deploy this image in a very short time on any kind of environment.

Conclusion

Using an official docker image for an application is very good choice at first, but if you have good devops mindset, I know you will try to make docker image smaller. This time, the main step will be more probably using an alpine image or other small images like busybox, etc… If you are able to convert your project to a binary, do use docker scratch image to have smallest docker image.

You can find application on Github here