
Security News
Deno 2.2 Improves Dependency Management and Expands Node.js Compatibility
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
github.com/GoogleCloudPlatform/functions-framework-go
An open source FaaS (Function as a Service) framework for writing portable Go functions.
The Functions Framework lets you write lightweight functions that run in many different environments, including:
The framework allows you to go from:
func HelloWorld(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello, World!")
}
To:
curl http://my-url
# Output: Hello, World!
All without needing to worry about writing an HTTP server or request handling logic.
Install Go 1.18+.
Create a Go module:
go mod init example.com/hello
Note: You can use a different module name rather than
example.com/hello
.
Create a function.go
file with the following contents:
package function
import (
"fmt"
"net/http"
"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)
func init() {
functions.HTTP("HelloWorld", helloWorld)
}
// helloWorld writes "Hello, World!" to the HTTP response.
func helloWorld(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "Hello, World!")
}
Note that you can use any file name or package name (convention is to make package name same as directory name).
To run locally, you'll need to create a main package to start your server (see instructions below for container builds to skip this step and match your local development environment to production):
mkdir cmd
Create a cmd/main.go
file with the following contents:
package main
import (
"log"
"os"
// Blank-import the function package so the init() runs
_ "example.com/hello"
"github.com/GoogleCloudPlatform/functions-framework-go/funcframework"
)
func main() {
// Use PORT environment variable, or default to 8080.
port := "8080"
if envPort := os.Getenv("PORT"); envPort != "" {
port = envPort
}
// By default, listen on all interfaces. If testing locally, run with
// LOCAL_ONLY=true to avoid triggering firewall warnings and
// exposing the server outside of your own machine.
hostname := ""
if localOnly := os.Getenv("LOCAL_ONLY"); localOnly == "true" {
hostname = "127.0.0.1"
}
if err := funcframework.StartHostPort(hostname, port); err != nil {
log.Fatalf("funcframework.StartHostPort: %v\n", err)
}
}
Run go mod tidy
to update dependency requirements.
Start the local development server:
FUNCTION_TARGET=HelloWorld LOCAL_ONLY=true go run cmd/main.go
# Output: Serving function: HelloWorld
Upon starting, the framework will listen to HTTP requests at /
and invoke your registered function
specified by the FUNCTION_TARGET
environment variable (i.e. FUNCTION_TARGET=HelloWorld
).
Send requests to this function using curl
from another terminal window:
curl localhost:8080
# Output: Hello, World!
Build a container from your function using the Functions buildpacks:
pack build \
--builder gcr.io/buildpacks/builder:v1 \
--env GOOGLE_FUNCTION_SIGNATURE_TYPE=http \
--env GOOGLE_FUNCTION_TARGET=HelloWorld \
my-first-function
Start the built container:
docker run --rm -p 8080:8080 my-first-function
# Output: Serving function...
Send requests to this function using curl
from another terminal window:
curl localhost:8080
# Output: Hello, World!
Deploy from your local machine using the gcloud
command-line tool.
Check out the Cloud Functions quickstart.
The Functions Framework is designed to be compatible with Knative environments.
Just build and deploy your container to a Knative environment. Note that your app needs to listen
PORT
environment variable per Knative runtime contract.
The Go Functions Framework conforms to the Functions Framework Contract, As such, it supports HTTP functions, background event functions, and CloudEvent functions (as of v1.1.0). The primary build mechanism is the GCP buildpacks stack, which takes a function of one of the accepted types, converts it to a full HTTP serving app, and creates a launchable container to run the server.
The Framework provides support for handling native Go HTTP-style functions:
package function
import (
"net/http"
"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)
func init() {
functions.HTTP("HelloWorld", helloWorld)
}
func helloWorld(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, World!"))
}
The Functions Framework provides support for unmarshalling an incoming
CloudEvent payload into a cloudevents.Event
object.
These will be passed as arguments to your function when it receives a request.
package function
import (
cloudevents "github.com/cloudevents/sdk-go/v2"
"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)
func init() {
functions.CloudEvent("CloudEventFunc", cloudEventFunc)
}
func cloudEventFunc(ctx context.Context, e cloudevents.Event) error {
// Do something with event.Context and event.Data (via event.DataAs(foo)).
return nil
}
These functions are registered with the handler via funcframework.RegisterCloudEventFunctionContext
.
To learn more about CloudEvents, see the Go SDK for CloudEvents.
Background events are also supported. This type of function takes two parameters: a Go context and a user-defined data struct.
func BackgroundEventFunction(ctx context.Context, data userDefinedEventStruct) error {
// Do something with ctx and data.
}
This type of event requires you to define a struct with the appropriate data fields (e.g. those for a PubSub message or GCS event) and pass that struct as the data parameter. See the samples for details.
The context parameter is a Go context.Context
, and contains additional event
metadata under a functions-specific key. This data is accesible via the cloud.google.com/go/functions/metadata
package:
m := metadata.FromContext(ctx)
These functions can be registered in main.go
for local testing with the handler via funcframework.RegisterEventFunctionContext
.
FAQs
Unknown package
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
Security News
React's CRA deprecation announcement sparked community criticism over framework recommendations, leading to quick updates acknowledging build tools like Vite as valid alternatives.
Security News
Ransomware payment rates hit an all-time low in 2024 as law enforcement crackdowns, stronger defenses, and shifting policies make attacks riskier and less profitable.