HTTP Google Cloud Functions in Go

Join Sign in

HTTP Google Cloud Functions in Go

45 minutes 1 Credit


Google Cloud selp-paced labs logo


Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.

Cloud Functions is an event-driven serverless compute platform. Cloud Functions allows you to write your code without worrying about provisioning resources or scaling to handle changing requirements.

There are two types of Cloud Functions:

  • HTTP functions respond to HTTP requests. You'll build one in this codelab.
  • Background functions are triggered by events, like a message being published to Cloud Pub/Sub or a file being uploaded to Cloud Storage. We don't address this in this lab, but you can read more in the documentation.


This codelab will walk you through creating your own Google Cloud Function in Go.

What you will build

In this codelab, you will publish and Cloud Function that when invoked via HTTP will display an image of the Go gopher, designed by Renee French.


What you will learn

  • How to write an HTTP Cloud Function in Go.

  • How to test an HTTP Cloud Function in Go.

  • How to run a local Go HTTP server to try the function.

What you will need

  • A recent version of Go ( installation instructions). Go is already installed when using Cloud Shell.

  • The gcloud command line tool ( download page). This comes pre-installed and configured when using Cloud Shell.

  • A text editor, like the editor built into Cloud Shell


Before you click the Start Lab button

Read these instructions. Labs are timed and you cannot pause them. The timer, which starts when you click Start Lab, shows how long Google Cloud resources will be made available to you.

This hands-on lab lets you do the lab activities yourself in a real cloud environment, not in a simulation or demo environment. It does so by giving you new, temporary credentials that you use to sign in and access Google Cloud for the duration of the lab.

To complete this lab, you need:

  • Access to a standard internet browser (Chrome browser recommended).
Note: Use an Incognito or private browser window to run this lab. This prevents any conflicts between your personal account and the Student account, which may cause extra charges incurred to your personal account.
  • Time to complete the lab---remember, once you start, you cannot pause a lab.
Note: If you already have your own personal Google Cloud account or project, do not use it for this lab to avoid extra charges to your account.

How to start your lab and sign in to the Google Cloud Console

  1. Click the Start Lab button. If you need to pay for the lab, a pop-up opens for you to select your payment method. On the left is the Lab Details panel with the following:

    • The Open Google Console button
    • Time remaining
    • The temporary credentials that you must use for this lab
    • Other information, if needed, to step through this lab
  2. Click Open Google Console. The lab spins up resources, and then opens another tab that shows the Sign in page.

    Tip: Arrange the tabs in separate windows, side-by-side.

    Note: If you see the Choose an account dialog, click Use Another Account.
  3. If necessary, copy the Username from the Lab Details panel and paste it into the Sign in dialog. Click Next.

  4. Copy the Password from the Lab Details panel and paste it into the Welcome dialog. Click Next.

    Important: You must use the credentials from the left panel. Do not use your Google Cloud Skills Boost credentials. Note: Using your own Google Cloud account for this lab may incur extra charges.
  5. Click through the subsequent pages:

    • Accept the terms and conditions.
    • Do not add recovery options or two-factor authentication (because this is a temporary account).
    • Do not sign up for free trials.

After a few moments, the Cloud Console opens in this tab.

Note: You can view the menu with a list of Google Cloud Products and Services by clicking the Navigation menu at the top-left. Navigation menu icon

Activate Cloud Shell

Cloud Shell is a virtual machine that is loaded with development tools. It offers a persistent 5GB home directory and runs on the Google Cloud. Cloud Shell provides command-line access to your Google Cloud resources.

  1. Click Activate Cloud Shell Activate Cloud Shell icon at the top of the Google Cloud console.

  2. Click Continue.

It takes a few moments to provision and connect to the environment. When you are connected, you are already authenticated, and the project is set to your PROJECT_ID. The output contains a line that declares the PROJECT_ID for this session:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud is the command-line tool for Google Cloud. It comes pre-installed on Cloud Shell and supports tab-completion.

  1. (Optional) You can list the active account name with this command:

gcloud auth list


ACTIVE: * ACCOUNT: To set the active account, run: $ gcloud config set account `ACCOUNT`
  1. (Optional) You can list the project ID with this command:

gcloud config list project


[core] project = <project_ID>

Example output:

[core] project = qwiklabs-gcp-44776a13dea667a6 Note: For full documentation of gcloud, in Google Cloud, refer to the gcloud CLI overview guide.

Ensure the Cloud Functions API is enabled

Run the following command from Cloud Shell to make sure the Cloud Functions API is enabled. This will make sure we can deploy Cloud Functions later in the codelab.

gcloud services enable

Download and setup the code

From the Cloud Shell terminal, use curl to download a zip with the code for this lab:

curl -LO

Use unzip to unpack the code. This unpacks a directory (golang-samples-main), which contains sample Go code for


Change to the directory containing the code for this codelab:

cd golang-samples-main/functions/codelabs/gopher

The gopher directory contains the following directories and files:

$ tree . ├── cmd │ └── main.go # Binary to run the function locally. ├── go.mod # Go module definition. ├── gophercolor.png # The gopher! ├── gopher.go # Go file with the function. └── gopher_test.go # Go test file.

Introducing HTTP Cloud Functions in Go

HTTP Cloud Functions in Go are written as http.HandlerFunc functions, which is an interface defined in the Go standard library. The function must:

  • Be exported, meaning it can be used from another package, which is indicated by the name starting with an uppercase letter.
  • Match the http.HandlerFunc type, meaning the function is of the form func(http.ResponseWriter, *http.Request). (See the Writing Web Applications tutorial for an in-depth guide to writing a full web application in Go.)

For example, here is a "Hello, world" function:

package gopher import ( "fmt" "net/http" ) // HelloWorld prints "Hello, world." func HelloWorld(w http.ResponseWriter, r *http.Request) { fmt.Fprintln(w, "Hello, world.") } You can open this file in Cloud Shell by opening the editor (click the pencil icon at the top right of Cloud Shell) then using the file tree on the left side of the editor to open the file, golang-samples-main/functions/codelabs/gopher/hello.go.

Deploy this function as an HTTP Cloud Function!

From the functions/codelabs/gopher directory you can deploy the function name with gcloud functions deploy:

gcloud functions deploy HelloWorld --runtime go111 --trigger-http

This will take a minute or two.


Deploying function (may take a while - up to 2 minutes)...done. availableMemoryMb: 256 entryPoint: HelloWorld httpsTrigger: url: ...

Click Check my progress to verify the objective. Create HelloWorld HTTP Cloud Function

Did you get an error during deployment? Check:

  • Is the Cloud Functions API enabled? If not, there will be an error with a link allowing you to enable it. Otherwise, you can enable it with the command gcloud services enable
  • Be sure your working directory (where you're running gcloud from) is the directory with the .go file in it. You can change directories using cd golang-samples/functions/codelabs/gopher.
  • Is the function name correct? It should be HelloWorld, the name of the Go function we're trying to deploy.

Copy the httpsTrigger URL that's displayed in the output. It will have a form like this:


To test the HelloWorld function, curl into the URL from the last output:

curl https://<REGION>-$


Hello, world.

You've written and deployed a HTTP Cloud Function!

Writing the Gopher HTTP Cloud Function

Now make the "Hello, world" function a bit more entertaining by printing an image of a Gopher for every request.


The following block shows the code to make it happen. You can see this code in Cloud Shell at golang-samples-master/functions/codelabs/gopher/gopher.go.

// Package gopher contains an HTTP function that shows a gopher. package gopher import ( "fmt" "io" "net/http" "os" ) // Gopher prints a gopher. func Gopher(w http.ResponseWriter, r *http.Request) { // Read the gopher image file. f, err := os.Open("gophercolor.png") if err != nil { http.Error(w, fmt.Sprintf("Error reading file: %v", err), http.StatusInternalServerError) return } defer f.Close() // Write the gopher image to the response writer. if _, err := io.Copy(w, f); err != nil { http.Error(w, fmt.Sprintf("Error writing response: %v", err), http.StatusInternalServerError) } w.Header().Add("Content-Type", "image/png") }
  1. The file starts with a package declaration and comment. All Go code is written inside a package, with a declaration like this at the top.
  2. The import block contains a list of other packages that this file depends on. These packages are referred to in the rest of the file using their name. For example, to use the ResponseWriter type from the http package, you write http.ResponseWriter.
  3. Next is the Gopher function declaration.
  4. The function starts by reading the gophercolor.png file (see the sample code) using the os.Open function.
  5. Then, it checks whether there was an error reading the file, which might occur if the file is corrupted or was accidentally left out of the upload.
  6. It uses io.Copy to copy the gopher image to w, the http.ResponseWriter argument. Everything written to w will be sent in the HTTP response.
  7. If there was no error when writing the response, the function returns normally.

Deploy this function as you did the "Hello, world" function from before, using gcloud functions deploy and the name of the function, Gopher:

gcloud functions deploy Gopher --runtime go111 --trigger-http

To test the function, visit the function's URL in the output from the last command. If everything is working correctly, you will see the gopher in your browser!

The next step is to add a test to make sure your function continues to work.

Click Check my progress to verify the objective. Create Gopher HTTP Cloud Function

Writing a test

HTTP Cloud Functions in Go are tested using the testing and httptest packages from the standard library. There is no need to run an emulator or other simulation to test your function—just normal Go code.

Here is what a test looks like for the Gopher function:

package gopher import ( "net/http" "net/http/httptest" "testing" ) func TestGopher(t *testing.T) { rr := httptest.NewRecorder() req := httptest.NewRequest("GET", "/", nil) Gopher(rr, req) if rr.Result().StatusCode != http.StatusOK { t.Errorf("Gopher StatusCode = %v, want %v", rr.Result().StatusCode, http.StatusOK) } }
  1. Go tests are written the same way as other Go files. They start with a package declaration and set of imports.
  2. The test declaration is of the form func MyTest(t *testing.T). It must be exported and take one argument of type *testing.T.
  3. The test creates test response and request values using the httptest package.
  4. It calls the Gopher function.
  5. After invoking the Gopher function, the test checks the HTTP response code to be sure there were no errors.

To run these tests locally, cd to the directory with the files you're testing: ???


cd golang-samples-main/functions/codelabs/gopher

In the golang-samples-main/functions/codelabs/gopher directory, use the go test command:

go test -v


=== RUN TestGopher --- PASS: TestGopher (0.00s) PASS ok 0.037s

Test not passing?

  • Check the error message for anything helpful.
  • Are you in the same directory as the gopher.go and gopher_test.go files (golang-samples-main/functions/codelabs/gopher)?

Next, you'll create a binary (package main, in Go) so that you can run your function locally and try it in a browser.

Running the function locally

To run an HTTP function locally, create an HTTP server and register your function as a handler. (See the Writing Web Applications tutorial for an in-depth guide to writing a full web application in Go.)

You can write an HTTP server for your function in a subdirectory of your function.

Following a Go convention, you name that directory cmd and create a main.go file inside it:

// The cmd command starts an HTTP server. package main import ( "fmt" "log" "net/http" "" ) func main() { http.HandleFunc("/", gopher.Gopher) fmt.Println("Listening on localhost:8080") log.Fatal(http.ListenAndServe(":8080", nil)) }
  1. This file uses package main as the package. A main package will be built as a binary that you can run.
  2. This file imports, based on the module line of the go.mod next to your function file. When you're writing your own functions, you can name the module whatever you prefer.
  3. The func main() is the entry point for the binary. It registers the gopher.Gopher function as an HTTP handler then starts the server using http.ListenAndServe.

To build and run this binary locally, run the following commands:

GO111MODULES=on # Turn on Go modules. go build -o start ./cmd ./start


Listening on localhost:8080

Because the function loads the gophercolor.png image from the current working directory, you have to start your binary from the same directory as the gophercolor.png file. The -o start flag says to name the output binary start. The ./cmd says to build the binary located in the cmd directory.

Now use the Cloud Shell Web Preview to test the server in your browser. Click the Web Preview button fdadb4e0e8f3cd52.png and then select port 8080 from the displayed menu.

Cloud Shell opens the preview URL on its proxy service in a new browser window. The web preview restricts access over HTTPS to your user account only.

If everything is working properly, you should see the Go Gopher!

Can't see the gopher?

  • Are you in the same directory as the gopher.go and gopher_test.go files (golang-samples-main/functions/codelabs/gopher)?
  • Is the server started? Be sure to build it with the go build -o start ./cmd command, then start it by running ./start. It should print Listening on localhost:8080.
  • Did you select the right port when opening the web preview? Be sure to use 8080, the port the server is listening on.

Cleaning up

For this lab, Qwiklabs will delete all resources you've used. It's always a good idea to know what you would need to do on your own environment to save on cost and to be a good cloud citizen.

Stop serving your URL with Ctrl + c

Once you're done testing your Cloud Functions, you can delete it using gcloud:

gcloud functions delete Gopher gcloud functions delete HelloWorld

You can also delete the function from the Cloud Console.


We hope you enjoy using Cloud Functions in Go!


Finish Your Quest

This self-paced lab is part of the Qwiklabs Getting Started with Go on Google Cloud Quest. A Quest is a series of related labs that form a learning path. Completing this Quest earns you the badge above, to recognize your achievement. You can make your badge (or badges) public and link to them in your online resume or social media account. Enroll in this Quest and get immediate completion credit if you've taken this lab. See other available Qwiklabs Quests.

Google Cloud training and certification

...helps you make the most of Google Cloud technologies. Our classes include technical skills and best practices to help you get up to speed quickly and continue your learning journey. We offer fundamental to advanced level training, with on-demand, live, and virtual options to suit your busy schedule. Certifications help you validate and prove your skill and expertise in Google Cloud technologies.

Manual Last Updated June 3, 2022
Lab Last Tested June 3, 2022

Copyright 2022 Google LLC All rights reserved. Google and the Google logo are trademarks of Google LLC. All other company and product names may be trademarks of the respective companies with which they are associated.

Provide Feedback on this Lab