Building a Go Microservice for AWS Fargate

Overview
Prerequisites
Setup
Creating a Go Microservice
Building the Docker Image
Deploying to AWS Fargate
Conclusion

Overview

In this tutorial, we will learn how to build a Go microservice and deploy it to AWS Fargate. We will cover the entire process from creating the microservice to building a Docker image and deploying it to AWS Fargate. By the end of this tutorial, you will have a working Go microservice running on AWS Fargate.

Prerequisites

To follow along with this tutorial, you will need:

A basic understanding of Go programming language
An AWS account
Docker installed on your machine
AWS CLI installed on your machine

Setup

Before we start building our microservice, we need to set up AWS credentials on our local machine. Follow these steps:

Install the AWS CLI by following the instructions provided in the AWS documentation.
Once installed, open a terminal and run the following command to configure the AWS CLI:
```
 aws configure
```
This command will prompt you to enter your AWS Access Key ID, AWS Secret Access Key, default region name, and default output format. Enter the required information accordingly.

Creating a Go Microservice

Let’s begin by creating a new Go module for our microservice:

Open a terminal and navigate to the desired location where you want to create the microservice.
Run the following command to create a new Go module:
```
 go mod init github.com/your-username/microservice
```
Replace your-username with your GitHub username or any other repository hosting provider you prefer.
Create a new directory inside the module directory for our microservice code:
```
 mkdir service
```
Change into the service directory:
```
 cd service
```

Create a new Go file named main.go using any text editor of your choice and add the following code:

 package main
    
 import (
 	"fmt"
 	"net/http"
 )
    
 func main() {
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, "Hello, World!")
 	})
    
 	http.ListenAndServe(":8080", nil)
 }

This code sets up a basic HTTP server that listens on port 8080 and responds with “Hello, World!” for any incoming requests.

Save the file and exit the text editor.

Building the Docker Image

To deploy our microservice to AWS Fargate, we need to build a Docker image. Here’s how:

Create a new file named Dockerfile in the root directory of your Go module:
```
 touch Dockerfile
```
Open the Dockerfile using a text editor and add the following code:
```
 FROM golang:1.17-alpine
    
 WORKDIR /app
    
 COPY go.mod .
 COPY go.sum .
    
 RUN go mod download
    
 COPY . .
    
 RUN go build -o main ./service
    
 CMD ["./main"]
```
This Dockerfile uses the official Go Docker image as the base image, copies the module files and downloads dependencies, copies the microservice code, builds the Go binary, and sets the binary as the entry point.
Save the Dockerfile and exit the text editor.
Open a terminal and navigate to the root directory of your Go module.
Build the Docker image by running the following command:
```
 docker build -t my-microservice .
```
This command builds a Docker image with the tag my-microservice using the current directory as the build context.
Wait for the image to build successfully.

Deploying to AWS Fargate

Now that we have the Docker image ready, we can deploy our microservice to AWS Fargate:

Open a terminal and log in to your AWS account using the AWS CLI:
```
 aws configure
```
Run the following command to create a new ECR repository for storing the Docker image:
```
 aws ecr create-repository --repository-name my-microservice
```
Take note of the repositoryUri value returned by the command as we will need it later.
Authenticate the Docker client with the ECR registry by running the following command:
```
 aws ecr get-login-password --region your-region | docker login --username AWS --password-stdin your-account-id.dkr.ecr.your-region.amazonaws.com
```
Replace your-region with your desired AWS region and your-account-id with your AWS account ID.

Push the Docker image to the ECR repository by running the following command:

 docker tag my-microservice:latest your-account-id.dkr.ecr.your-region.amazonaws.com/my-microservice:latest
 docker push your-account-id.dkr.ecr.your-region.amazonaws.com/my-microservice:latest

Replace your-account-id and your-region with your AWS account ID and desired AWS region.

Open the AWS Management Console and navigate to the Amazon ECS service.
Click on “Clusters” and create a new cluster with the desired configuration.
Once the cluster is created, click on “Task Definitions” and then “Create new Task Definition”.
Configure the task definition with the necessary settings, including the Docker image URI, port mappings, and resource allocation.
Click on “Next” and then “Create”.
Navigate back to the cluster and click on “Services”.
Create a new service using the task definition created in the previous step.
Configure the service with the desired settings, including the number of desired tasks and the load balancer.
Click on “Next”, review the configuration, and then click on “Create Service”.
Wait for the service to be created and deployed.

Congratulations! Your Go microservice is now running on AWS Fargate. You can access it using the URL provided by the load balancer.

Conclusion

In this tutorial, we learned how to build a Go microservice and deploy it to AWS Fargate. We covered the steps for creating a Go module, writing the microservice code, building a Docker image, and deploying the image to AWS Fargate. By following these steps, you now have a fully functioning Go microservice running on AWS Fargate.

Remember to clean up your AWS resources after you finish experimenting to avoid incurring unnecessary costs.

Published: 24 December 2022