Open In App

How to Dockerize a Golang Application?

Improve
Improve
Like Article
Like
Save
Share
Report

Docker is a containerization platform that lets you build, run, and manage applications in an isolated environment. In a container, software, libraries, and configuration files are bundled together and isolated from one another. Golang is an open-source, procedural, and statically typed programming language. In this article, we’ll discuss how to develop and deploy a Golang application using Docker.

Dockerizing a Golang application

As part of this tutorial, we will create a simple Golang application that acts as a REST API.

Step 1: Run the following commands to create a new Golang project.

$ mkdir docker-go

$ cd docker-go

$ go mod init dockergo

 

Step 2: Paste the following into a new file main.go

$ touch main.go

Go




package main
  
// Importing http and mux package
import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)
  
func main() 
{
    // Creating a new router instance
    router := mux.NewRouter()
      
    // Creating a new controller to handle response
    // for '/' endpoint
    router.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) 
    {
          
        response := map[string]string{
            "response": "Dockerizing Go Application",
    }
          
    // Setting the response
    json.NewEncoder(rw).Encode(response)
})
      
// Logging on console
log.Println("⚡️[bootup]: Server is running at port: 5000")
      
      
http.ListenAndServe(":5000", router)
// starting the server on port 5000
}


Step 3: You can start the application by running

$ go run main.go

 

Project Structure: This is how the project structure should look at this point.

 

Dockerfile for development: Create a Dockerfile for the development phase of our react project. Let’s name it Dockerfile.dev.

$ touch Dockerfile.dev

 

Step 4: In the newly created file, paste the following commands

# Latest golang image on apline linux
FROM golang:1.17-alpine

# Work directory
WORKDIR /docker-go

# Installing dependencies
COPY go.mod go.sum ./
RUN go mod download

# Copying all the files
COPY . .

# Starting our application
CMD ["go", "run", "main.go"]

# Exposing server port
EXPOSE 5000

Step 5: Now create a docker image by using the docker build command

$ docker build -f Dockerfile.dev -t [name:tag] .

Here,

  • -f: Path to the docker file
  • -t: Name and tag for the image
  • .: Context for the build process

Once the build process has been completed, you will receive the id and tag of your new image.

 

Step 6: Create a docker container by running

$ docker run -d -it –-rm -p [host_port]:[container_port] --name [container_name] [image_id/image_tag]

 

Here,

  • -d: Run container in background and print container ID
  • -it: Create an interactive container
  • -p: Map host port to container port
  • –name: Assign a name to the container
  • –rm: Remove the container when it exits.

Step 7: Verify whether the container has been created successfully by running

$ docker container ps

 

Step 8: Navigate to http://localhost:5001/  to verify the build process.

 

Dockerfile for production: By looking at the docker images, you will see that our simple go application takes up half a GB of space. So, we will reduce the size of our image for production deployments.

$ docker images

 

Step 9: The next step is to create a Dockerfile for production mode.

$ touch Dockerfile

 

# Latest golang image on apline linux
FROM golang:1.17 as builder

# Env variables
ENV GOOS linux
ENV CGO_ENABLED 0

# Work directory
WORKDIR /docker-go

# Installing dependencies
COPY go.mod go.sum ./
RUN go mod download

# Copying all the files
COPY . .

# Building the application
RUN go build -o docker-go

# Fetching the latest nginx image
FROM alpine:3.16 as production

# Certificates
RUN apk add --no-cache ca-certificates

# Copying built assets from builder
COPY --from=builder docker-go .

# Starting our application
CMD ./docker-go

# Exposing server port
EXPOSE 5000

Step 10: Build an image and create a container using the updated Dockerfile.

$ docker build -t [name:tag] .

 

 

$ docker run -d -it -–rm -p [host_port]:[container_port] –name [container_name] [image_id/image_tag]

 

Step 11: The application’s size has now been reduced to just 13MB.

$ docker images

 

Step 12: Browse to http://localhost:5002/ to view the dockerized golang application.

 

Project Structure: This is how the project structure should look at this point.

 

Note: Please refer to the Dockerfile used in this tutorial if you have difficulties following the above steps.



Last Updated : 30 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads