Zahraa Jawad

Posted on Oct 27

Building a Go Application with Docker on AWS: Creating a RESTful Interface for Adding and Retrieving Items

#aws #docker #go #cloudcomputing

Introduction

While most Go applications are compiled into a single binary file, web applications also come with templates, assets, and configuration files; these can get out of sync and cause erroneous deployments.
Docker allows us to create a standalone image with everything our application needs to run. In this article, we will learn how to deploy a Go web application using Docker installed on an instance, and how Docker can help you improve your development workflow and deployment process.

The steps we need will be as follows:

- Launch an instance (your machine)to build Docker on and the Go application
- Install Docker in instance
- Installing Go in instance
- Create code files for your Go application
- Application Testing

Launch an instance (your machine)to build Docker on and the Go
application

You can find the same steps of the launch and connect of instance described in the article:

https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Note: Make sure you choose the security group:

SSH-Port 22: To access and connect to the instance using SSH
protocol to manage the system remotely.
HTTP-Port 8080: To run the Go application on this port (8080) to access it from the Internet or local network, this port must be open.

- Install Docker in our instance

The specific workflow architecture we will create uses Docker to provide an integrated workflow environment.
So after connecting to the instance via SSH and obtaining the root privilege, use the following command automation to install Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && sudo apt-get update && apt-cache policy docker-ce

Docker experience: Run a simple test command docker -v to check that Docker is working properly and to see the Docker version:

Installing Go

You can install Go by downloading it from the official Go website https://go.dev/dl/
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile source ~/.bash_profile

where :
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz is to download Go binary.

and
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz is to extract the tarball to /usr/local.
and
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile to Update the PATH environment variable.
and source ~/.bash_profile to apply the changes made to the profile

So after executing the commands and verifying the execution through the command ls to show the downloaded files:

Initialize the Go application with the following code:
go mod init my-go-app

Now we need to create a project folder by the command:
mkdir <name of our work>
Then change the current directory by the command :
cd <name of our work>
so the execution is :

Create code files for your Go application

The main.go file

We create a new file called main.go which contains the following functions and codes which we will explain in detail and then we put all the codes in the main.go file:

To import the necessary packages we use the code:

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

For the data structure item:

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

where itemis a data structure containing an identifier (ID) and a name (Name). These fields are converted to JSON format using tags (json:"id" and json:"name".

items variable

var items []Item

which is a slice of items stored in server memory.

Through the main function the structures are arranged by reading the port (here it will be on port 8080) in addition to directing the various requests from retrieving or adding a new element and displaying a simple HTML page.

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

The function getItems returns a list of items in JSON format. The content type in the header is set to application/json.

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

The createItem function adds a new item to the items list. The data is read from the Request Body in JSON format, the item is assigned an ID based on the number of existing items, and the added item is returned as JSON.

func createItem(w http.ResponseWriter, r *http.Request) {
    var item Item
    json.NewDecoder(r.Body).Decode(&item)
    item.ID = len(items) + 1
    items = append(items, item)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(item)
}

The serveHome function displays a simple HTML page with a welcome message (Welcome to the Go App) and links to access the data.

func serveHome(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Go App</title>
        </head>
        <body>
            <h1>Welcome to the Go App</h1>
            <p>This is a simple API application.</p>
            <p>Access <a href="/items">/items</a> to see all items.</p>
        </body>
        </html>
    `))
}

So the entire main.go file is:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

// Item represents the data structure we will be using
type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var items []Item

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

func createItem(w http.ResponseWriter, r *http.Request) {
    var item Item
    json.NewDecoder(r.Body).Decode(&item)
    item.ID = len(items) + 1
    items = append(items, item)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(item)
}

func serveHome(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Go App</title>
        </head>
        <body>
            <h1>Welcome to the Go App</h1>
            <p>This is a simple API application.</p>
            <p>Access <a href="/items">/items</a> to see all items.</p>
        </body>
        </html>
    `))
}

Now through the command vim or nano create the main.go file and put above code in the file, here we will use the command nano:

nano main.go

And past the codes:

then exit the file from the keyboard by ctrl x then y (to save the file) then click enter

Dockerfile:

Is a text document that contains all the commands a user could call on the command line to assemble an image.
Dockerfile can build images automatically by reading the instructions from a Dockerfile.

Create a Dockerfile:

A Dockerfile with build instructions is required to build a container image with Docker.
We create a Dockerfile and add the following code in the same way as before through the command nano Dockerfile:

Dockerfile command details can be found on the docker docs homepage https://docs.docker.com/guides/golang/build-images/

Now that we have prepared the Dockerfile, it is time to build a Docker image for the Go application. The image can be made from the official Docker images which are:

docker build -t my-go-app .