Golang

How to Create a Go (Golang) API on Google App Engine

A simple walkthrough on creating an API with a server, written in Go, to deploy to Google App Engine.

Why Google App Engine?

Google App Engine is Platform as a Service (PaaS). It aims to make deployment easier. It is fully managed, pay-as-you-go, high availability, it ensures a fast time to market, and supports a wide variety of programming languages.

App Engine allows you to build scalable web and mobile back-ends with traffic splitting and firewall capabilities.

Standard vs Flexible Environment

You have two options when creating an App Engine environment:

• Standard — Applications run in a sandbox. Choose this if you need rapid scaling or you experience dramatic and unexpected spikes of traffic
• Flexible — Instances run within Docker containers on Compute Engine virtual machines. Choose this if you have consistent traffic, need to scale up or down, or access resources on the Compute Engine.

It’s important to note that the App Engine Application URL will be named based on the project name. So take this into account when choosing your cloud project.

Let’s get started!

1) Setting up App Engine in Cloud Console

Firstly, let’s set up the App Engine Project.

Go to https://console.cloud.google.com/appengine.

After some automatic initialization, you should be greeted with this screen…

Click ‘Get Started’

Choose ‘Go’ from the dropdown.

We’ll be using the standard environment for this example.

The next steps are to download the SDK

This gives you access to the command line tools (CLI).

Initialize the project

Using the gcloud command, initialize the project.

$ gcloud init

Until you’ve deployed your application to the app engine, your dashboard will look like this.

So now that the app engine is all setup, it’s time to actually write our server.

2) Write a simple Server application in Go

We’ll be using the Go version 1.14. We’ll also be using Go modules.

There are 3 files that are essential to our application. These are outlined below.

Runtime Config — app.yaml

The first file that we need to create is the app.yaml file. This file is mandatory in an app engine project.

Go Module — go.mod

We also need to create our Go module.

Main File — main.go

Firstly, we need to create a function in the main file that grabs the port number. It’s just a function that just gets the appropriate port number that our API is listening on based on the current environment.

We use the os library to get the port (if it is an environment variable), default to port 8080 if the environment variable isn’t set, and return the port number to the caller as a string.

Initialize our HTTP server client

Let’s create our simple HTTP server to listen to requests.

Firstly we’ll get the port using our getPort() function we created previously.

We’ll then write our anonymous handler function to handle requests and deal with the response.

Our API doesn’t do anything yet, so it’s pretty useless. But we’ll soon start handling some parameters like you would in an actual API.

Then we’ll call the function that instructs our HTTP client to listen and serve our application on the specified port with http.ListenAndServe , while catching any errors that might arise.

As you can see, the callback function takes two parameters http.ResponseWriter to write the response to, and *http.Request which is a pointer to the Request object.

Dealing with Query Params

The API is a bit too basic at the moment. In the real world, you’d need to handle query parameters to feed our API.

Dealing with query parameters is pretty simple in Go. You just have to remember that, when accessing a query parameter with URL.Query()['value'] , it’ll always return an array of items. So make sure you access the value via array indexing.

Instead of writing an anonymous function as the callback to the HandleFunc function, we’ll provide our new function APIHandler to handle the request along with any parameters that are provided in the URL.

Our APIHandler function has to conform to callback signature so we have our two parameters http.ResponseWriter and *http.Request .

In this example function, we don’t accept POST request, and return early with an HTTP error if that is the case.

We then grab the query parameter value , if there is one. If it is invalid or empty, we return and don’t do anything.

If it exists and is valid, we return the value in the response (for demonstration purposes).

That’s our basic API written…

3) Deploy to App Engine

Running the gcloud init command in the earlier step should have logged you in to your google cloud account. But if not, run gcloud auth login to login.

After this step, you’ll want to deploy your application to the App Engine using

$ gcloud app deploy

This means that your API is successfully deployed to the URL provided.

4) Test the application

Find your reserved app engine URL in the google cloud console.

To test that it's all up and running, all you need to do is click the link to see your working app engine application.

You can see if your application has successfully parsed the query parameters by testing the URL (typing it into the browser).

https://<INSERT_PROJECT_ID>.uc.r.appspot.com/?value=hello

That’s it! 🚀

Now you have a basic API deployed on App Engine, written in Go, that you can extend and make it do something useful.

Thanks for reading! Any questions let me know in the comments.