Announcing App Engine’s New Go 1.11 Runtime

16 October 2018

App Engine launched

experimental support for Go

in 2011. In the subsequent years, the Go community has grown significantly and

has settled on idiomatic

patterns for cloud-based applications. Today, Google Cloud is

announcing a new Go 1.11 runtime

for the Engine standard environment that provides all the

power of App Engine—things like paying only for what you use, automatic scaling,

and managed infrastructure—while supporting idiomatic Go.

Starting with Go 1.11, Go on App Engine has no limits on application structure,

supported packages, context.Context values, or HTTP clients. Write your Go

application however you prefer, add an app.yaml file, and your app is ready

to deploy on App Engine.

Specifying Dependencies

describes how the new

supports vendoring and

modules (experimental) for dependency

management.

Along with Cloud Functions support for Go

(more on that in a future post), App Engine provides a compelling way to run Go

code on Google Cloud Platform (GCP) with no concern for the underlying

infrastructure.

Let’s take a look at creating a small application for App Engine. For the

example here, we assume a GOPATH-based workflow, although Go modules have

experimental support

as well.

First, you create the application in your GOPATH:

// This server can run on App Engine.
package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    http.HandleFunc("/", hello)

    log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

func hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, 世界"))
}

The code contains an idiomatic setup for a small HTTP server that responds with

“Hello, 世界.” If you have previous App Engine experience, you’ll notice the

absence of any call to appengine.Main(), which is now entirely optional.

Furthermore, the application code is completely portable—there are no ties to

the infrastructure that your application is deployed on.

If you need to use external dependencies, you can add those dependencies to a

vendor directory or to a go.mod file, both of which the new runtime

supports.

With the application code complete, create an app.yaml file to specify

the runtime:

Finally, set your machine up with a Google Cloud Platform account:

With all the setup complete, you can deploy using one command:

We think Go developers will find the new Go 1.11 runtime for App Engine an

exciting addition to the available options to run Go applications. There is a

free tier. Check out the

getting started guide

or the

migration guide

and deploy an app to the new runtime today!

By Eno Compton and Tyler Bui-Palsulich





Source link https://blog.golang.org/appengine-go111

LEAVE A REPLY

Please enter your comment!
Please enter your name here