DEV Community: Prajwol KC

Lets Deploy Dockerized Golang App to Google Cloud Run

Prajwol KC — Wed, 27 Jul 2022 17:32:56 +0000

In this article, we will create a simple golang webapp using microframework fiber. Then we will run in our local system using the docker container. Then after is done on our local system, we will deploy it to Google Cloud Platform Google Container Registry (GCR). Then we will connect the GCR container to be deployed to Google Cloud Run. So let's begin.

We will create a simple golang web app using fiber web framework which shows a simple hello world text on the screen.

This is main.go

package main

import (
    "log"
    "github.com/gofiber/fiber/v2"
)

func main() {
    app := fiber.New()
    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })
    log.Fatal(app.Listen(":8080"))
}

Here we just imported fiber web framework which is basically a nestjs like a framework under golang. We are using a GET method to get all the incoming requests under root and show a hello world text. We are listening to the container to port 8080.

Next, we create a Dockerfile on the root directory to actually dockerized the application. Dockerfile

FROM golang:1.16-alpine

WORKDIR /app

COPY go.mod .
COPY go.sum .

RUN go mod download

COPY . .

RUN go build -o ./out/dist .

CMD ./out/dist

We can run the app locally by building the container and running the following under the system cli. Here golangrun is the name of the app

docker build --platform linux/amd64 -t golangrun .

docker run -p 8888:8080 golangrun

If we go to http://localhost:8888/ then we will see our Hello World.

Now next step is to deploy the same web app to GCR and run it on Cloud Run. To init the process the container has to be tagged and push to GCR.

Let's tag our container for Google Docker Registry with GCR name as readytoworkjapan followed by app name

docker tag golangrun gcr.io/readytoworkjapan/golangrun

Now let's push our tagged container to GCR and can see it on our GCR portal

docker push  gcr.io/readytoworkjapan/golangrun

The container is in my GCR, We can deploy the container to our preferred Cloud Run, GKE, or GCE. For our use we will deploy to Cloud Run.

Create Cloud Run Service, by selecting the latest container tag which was just pushed. Name the service name with general selections. The ingress can be for now all incoming traffic and authentication can be unauthenticated invocations.

After the cloud run service is created, we can see all the details with logs. Just open the URL that is given in the top section. When we open it voila we just get the dockerized golang run running on Cloud Run. The URL, in this case, is https://golangrun-ok-24wnkzib7q-uc.a.run.app/

This article is only the tip of the iceberg. There are many other sections and topics that can be modified and configured.

If we want to change anything let's say change hello world to hello Golang, then we just change the code

Build the container -> docker build --platform linux/amd64 -t golangrun .
Tag the container with change -> docker tag golangrun gcr.io/readytoworkjapan/golangrun
Push the container -> docker push gcr.io/readytoworkjapan/golangrun
ReDeploy on the same Cloud Run Service and see the changes with the same URL

Note:

docker build --platform linux/amd64 -t golangrun .

For this use case, we are using mac m1 so the container build is expected to run on linux/amd64 rather than arm64 which is the default case under mac m1.

Go Application deployment on Google App engine flexible environment

Prajwol KC — Wed, 26 May 2021 19:01:55 +0000

Google Cloud App Engine is a Platform as a Service product that allows us to deploy apps written in various runtimes, such as:

Python
PHP
Java
Ruby
Node
Go
Ruby, etc

App Engine provides us with two options: the Standard Environment and the Flexible Environment.

The Standard environment is a cloud-native option because it has a very fast spin-up engine that creates instances for our traffic in milliseconds.

The Flexible environment, on the other hand, is different due to its container-based environment that relies on Compute Engine VMs. This is important for many use cases as we can customize our server as per our usage and requirement. This can be the installation of custom packages like ImageMagick, MuPDF libraries, or SSH into our server or run our own bash script, etc. We can use any type of runtime to run our app, and the important thing is that our app should respond in the default 8080 port unless we make some changes.

Here is a detailed idea of the difference between them. Here

Here we will be deploying a GO application on Flexible Environment on custom runtime rather than Google App Engine default go runtime as it brings up more concerns, unlike the standard one. We will be adding two files one app.yaml and other Docker file

Lets a take simple GO application that uses GIN web framework to render Hello World to our web browser.

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello World")
    })
    r.Run()
}

Time to show the world 🤠🤠 . Lets make this say through our App Engine Flexible environment.

app.yaml

runtime: custom
env: flex

This is pretty straightforward, as we are defining our custom image as runtime with a flexible environment. We can add other options for scaling purposes and port settings. Check out here

Now, let create a Docker file that resides into the root directory.

Docker

# Golang docker image
FROM golang:1.14

# Set necessary environmet variables needed for our image
ENV GO111MODULE=on \
    CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# install build essentials (optional)
RUN apt-get update && \
    apt-get install -y wget build-essential pkg-config --no-install-recommends

# Move to working directory /build
WORKDIR /build

# Copy and download dependency using go mod
COPY go.mod .
COPY go.sum .
RUN go mod download

# Copy the code into the container
COPY . .
COPY . /dist

# Build the application
RUN go build -o main .

# Move to /dist directory as the place for resulting binary folder
WORKDIR /dist

# Copy binary from build to main folder
RUN cp /build/main .

# Export necessary port, default GCP App Engine Port
EXPOSE 8080

# Command to run when starting the container
CMD ["/dist/main"]

The docker file will contain all the necessary configuration setup that we need to expose the application over 8080. Here 8080 is our default port for GAE.

Also make sure go.mod and go.sum exists on the root directory so that necessary packages get installed on the deployment system

Now from the gcloud CLI set project on which the application is going to be deployed.

 gcloud app deploy

After successful deployment, there will be a URL to the application and we have our app successfully deployed on google app engine flexible environment using a custom runtime image.

For more, if we want our application using GORM to connect over Google Cloud SQL, there is some changes to be done.

First, Enable the Cloud SQL Admin API in the project
Under app.yaml, we have to tell our application to allow secure connection or else the application can connect to database, make changes as following

runtime: custom
env: flex
beta_settings:
  cloud_sql_instances: $INSTANCE_CONNECTION_NAME$

$INSTANCE_CONNECTION_NAME$ is the connection name of our cloud SQL that we can get from its instance detail.

Like before deploy application.

gcloud app deploy

As the flexible environment, there are many configurations that can be implemented to actually make our system like we want to make and behave as we intend to.