Building a Simple Microservice with Go and Docker

Microservices have become a popular architectural style for developing scalable and maintainable applications. In this blog post, we will explore how to build a simple microservice using the Go programming language and Docker. With Go’s efficiency and Docker’s containerization capabilities, we can create robust microservices that can be deployed easily and run reliably. Let’s dive into the process step by step!

What Are Microservices?

Microservices are an architectural style that structures an application as a collection of small, independent services that communicate over well-defined APIs. Each service is responsible for a specific piece of functionality and can be developed, deployed, and scaled independently. This approach offers several advantages:

• Scalability: Individual services can be scaled based on demand.
• Flexibility: Developers can choose different technologies for different services.
• Resilience: If one service fails, the entire system doesn’t necessarily go down.

Setting Up Your Environment

Before we can start coding, we need to set up our development environment. This involves installing Go and Docker, which are essential for building and running our microservice.

Installing Go

To install Go, you can follow the instructions on the official Go installation page. After installation, verify it by running:

go version

Installing Docker

Docker can be installed by following the instructions on the official Docker installation page. After installation, verify it with:

docker --version

Creating a Simple Go Microservice

Now that we have our environment set up, let’s create a simple Go microservice that exposes a RESTful API. The API will allow users to manage a list of books.

Step 1: Project Structure

First, let’s create a directory for our project:

mkdir go-microservice
cd go-microservice

Your project structure should look like this:

go-microservice/
├── main.go
└── go.mod

Step 2: Initialize Go Modules

In the root of your project directory, initialize Go modules:

go mod init go-microservice

Step 3: Writing the Go Microservice

Now, let’s create our main Go file to handle HTTP requests:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "sync"
)

type Book struct {
    ID     string `json:"id"`
    Title  string `json:"title"`
    Author string `json:"author"`
}

var (
    books  = make(map[string]Book)
    mu     sync.Mutex
)

func getBooks(w http.ResponseWriter, r *http.Request) {
    mu.Lock()
    defer mu.Unlock()

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(books)
}

func addBook(w http.ResponseWriter, r *http.Request) {
    var book Book
    if err := json.NewDecoder(r.Body).Decode(&book); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    mu.Lock()
    books[book.ID] = book
    mu.Unlock()

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(book)
}

func main() {
    http.HandleFunc("/books", getBooks)
    http.HandleFunc("/books/add", addBook)

    log.Println("Server is running on port 8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

In the above code:

• We have defined a simple Book struct.
• Two HTTP handlers getBooks and addBook manage the list of books.
• We store books in a map and ensure concurrent access is handled appropriately using a mutex.

Testing Our Microservice

Run the microservice by executing the command:

go run main.go

Your microservice should now be up and running at http://localhost:8080. You can test it using tools like Postman or curl.

To add a book, you can use the following curl command:

curl -X POST http://localhost:8080/books/add -d '{"id":"1","title":"The Go Programming Language","author":"Alan A. A. Donovan"}' -H "Content-Type: application/json"

To retrieve the list of books:

curl http://localhost:8080/books

Containerizing Our Microservice with Docker

Now that we’ve built our Go microservice, the next step is to containerize it using Docker. This enables us to run our application in a consistent environment, regardless of where it is deployed.

Step 1: Creating a Dockerfile

In the root of your project directory, create a file named Dockerfile:

FROM golang:1.18 AS builder
WORKDIR /go/src/app
COPY . .

RUN go mod tidy
RUN go build -o microservice

FROM gcr.io/distroless/base
WORKDIR /app
COPY --from=builder /go/src/app/microservice .

CMD ["/app/microservice"]

This Dockerfile does the following:

• Uses the official Go image to build our application.
• Sets the working directory and copies the source code.
• Builds the Go application.
• Uses a distroless image to create a lightweight container.

Step 2: Building the Docker Image

In your terminal, navigate to your project directory and build your Docker image with the following command:

docker build -t go-microservice .

After the build completes, you can run your container using:

docker run -p 8080:8080 go-microservice

Step 3: Testing the Dockerized Microservice

Your microservice running inside a Docker container should still be accessible at http://localhost:8080. You can test it the same way you did earlier. This not only confirms that the microservice works but also showcases the power of Docker in creating portable applications.

Best Practices for Building Microservices

While this example provides a basic understanding of microservices, consider these best practices when developing your own:

• Implement proper logging and monitoring: Use tools like Prometheus and Grafana to monitor your microservices.
• Version your APIs: This ensures backward compatibility as you update services.
• Automate testing and deployment: Employ CI/CD tools to automate the testing and deployment of your microservices.
• Secure your APIs: Use authentication and authorization to secure access to your microservices.

Conclusion

In this tutorial, we built a simple microservice using Go and Docker. We explored how to structure the Go application, set up a RESTful API, and containerize the application using Docker. By leveraging Go’s high performance and Docker’s powerful capabilities, you can scale and deploy your microservices with ease.

As you advance in your microservices journey, remember to adhere to best practices and continuously look for opportunities to enhance your architecture for better scalability, maintainability, and resilience. Happy coding!

Resources

• Go Documentation
• Docker Documentation
• Microservices.io