Node.js

The basic directory structure for Node.js functions is as follows:

.├── index.js└── package.json

By default, Cloud Run attempts to load source code from a filenamedindex.js at the root of your function directory. To specify a differentmain source file, use themain field in yourpackage.json file.

Yourpackage.json file must also include theFunctions Framework for Node.jsas a dependency:

{"main":"index.js","dependencies":{"@google-cloud/functions-framework":"^3.0.0"},"type":"module"}

The code in your main file must define yourfunction entry pointand can import other code and Node.js modules. The main file can alsodefine multiple function entry points that can be deployed separately.

See theNode.js runtime overview and theFunctions Framework for Node.jsfor more details.

Python

The basic directory structure for Python functions is as follows:

.├── main.py└── requirements.txt

Cloud Run loads source code from a file namedmain.py at theroot of your function directory. You must name your main filemain.py.

Yourrequirements.txt file must include theFunctions Framework for Pythonas a dependency:

functions-framework==3.*

The code in yourmain.py file must define yourfunction entry point and can import other code and externaldependencies as normal. Themain.py file can also define multiple functionentry points that can be deployed separately.

See thePython runtime overview and theFunctions Framework for Pythonfor more details.

Go

The basic directory structure for Go functions is as follows:

.├── myfunction.go└── go.mod

Your function must be in a Go package at the root of your project. The packageand its source files can have any name, except your function cannot be inpackage main. If you need amain package, for example for local testing,you can create one in a subdirectory:

.├── myfunction.go├── go.mod└── cmd/  └── main.go

Yourgo.mod file must include theFunctions Framework for Goas a dependency:

moduleexample.com/my-modulerequire(github.com/GoogleCloudPlatform/functions-framework-gov1.5.2)

The code in your root package must define yourfunction entry point and can import other code from subpackagesand dependencies as normal. Your package can also define multiple functionentry points that can be deployed separately.

See theGo runtime overview and theFunctions Framework for Gofor more details.

Java

The basic directory structure for Java functions is as follows:

.├── pom.xml└── src/  └── main/      └── java/          └── MyFunction.java

Your Java source files must be under thesrc/main/java/ directory and can haveany name. If your source files declare a package, add an extra directory undersrc/main/java with the name of the package:

.├── pom.xml└── src/  └── main/      └── java/          └── mypackage/              └── MyFunction.java

We recommend putting associated tests under asrc/test/java/ subdirectory.

Yourpom.xml file must include theFunctions Framework for Javaas a dependency:

...<dependency><groupId>com.google.cloud.functions</groupId><artifactId>functions-framework-api</artifactId><version>1.0.4</version></dependency>...

The code in your source files must define yourfunction entry point and can import other code and externaldependencies as normal. Your source files can also define multiple functionentry points that can be deployed separately.

See theJava runtime overview and theFunctions Framework for Javafor more details.

.NET

The basic directory structure for .NET functions is as follows:

.├── MyFunction.cs└── MyProject.csproj

You can structure your projects as you would any other .NET source code.Your source files can have any name.

Your project file must include theFunctions Framework for .NETas a dependency:

...<PackageReferenceInclude="Google.Cloud.Functions.Hosting"Version="1.0.0"/>...

The code in your source files must define yourfunction entry point and can import other code and externaldependencies as normal. Your source files can also define multiple functionentry points that can be deployed separately.

See the.NET runtime overview and theFunctions Framework for .NETfor more details.

Ruby

The basic directory structure for Ruby functions is as follows:

.├── app.rb├── Gemfile└── Gemfile.lock

Cloud Run loads source code from a file namedapp.rb at theroot of your function directory. Your main file must be namedapp.rb.

YourGemfile file must include theFunctions Framework for Rubyas a dependency:

source "https://rubygems.org"gem "functions_framework", "~> 1.0"

The code in yourapp.rb file must define yourfunction entry point and can import other code and externaldependencies as normal. Theapp.rb file can also define multiple functionentry points that can be deployed separately.

See theRuby runtime overview and theFunctions Framework for Rubyfor more details.

PHP

The basic directory structure for PHP functions is as follows:

.├── index.php└── composer.json

Cloud Run loads source code from a file namedindex.php at theroot of your function directory. You must name your main fileindex.php.

Yourcomposer.json file must include theFunctions Framework for PHPas a dependency:

{"require":{"google/cloud-functions-framework":"^1.1"}}

The code in yourindex.php file must define yourfunction entry point and can import other code andexternal dependencies as normal. Theindex.php file can also define multiplefunction entry points that can be deployed separately.

See thePHP runtime overview and theFunctions Framework for PHPfor more details.

Node.js

import{http}from'@google-cloud/functions-framework';http('myHttpFunction',(req,res)=>{// Your code here// Send an HTTP responseres.send('OK');});

{"dependencies":{"@google-cloud/functions-framework":"^3.0.0"},"type":"module"}

constfunctions=require('@google-cloud/functions-framework');// Register an HTTP function with the Functions Frameworkfunctions.http('myHttpFunction',(req,res)=>{// Your code here// Send an HTTP responseres.send('OK');});

{"dependencies":{"@google-cloud/functions-framework":"^3.0.0"}}

In Node.js, you register an HTTP handler function with theFunctions Framework for Node.js.Your HTTP handler function must be anExpress middleware functionthat accepts therequestandresponse arguments and sendsan HTTP response.

Cloud Run automatically parses the request body for you based on therequest'sContent-Type header usingbody-parser,so you can access thereq.body andreq.rawBody objects in your HTTP handler.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismyHttpFunction.

Python

importfunctions_framework# Register an HTTP function with the Functions Framework@functions_framework.httpdefmy_http_function(request):# Your code here# Return an HTTP responsereturn'OK'

In Python, you register an HTTP handler function with theFunctions Framework for Python.Your HTTP handler function must accept aFlask requestobject as an argument and returna value that Flask can convert into an HTTP response object.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismy_http_function.

Go

packagemyhttpfunctionimport("fmt""net/http""github.com/GoogleCloudPlatform/functions-framework-go/functions")funcinit(){// Register an HTTP function with the Functions Frameworkfunctions.HTTP("MyHTTPFunction",myHTTPFunction)}// Function myHTTPFunction is an HTTP handlerfuncmyHTTPFunction(whttp.ResponseWriter,r*http.Request){// Your code here// Send an HTTP responsefmt.Fprintln(w,"OK")}

In Go, you register an HTTP handler function with theFunctions Framework for Goin yourinit() function. Your HTTP handler function must use the standardhttp.HandlerFuncinterface to send an HTTP response.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point isMyHTTPFunction.

Your HTTP handler function must implement the standardhttp.HandlerFuncinterface. It accepts anhttp.ResponseWriter interface that your function usesto create a reply to the request, and a pointer to anhttp.Request struct containing thedetails of the inbound HTTP request.

Java

packagemyhttpfunction;importcom.google.cloud.functions.HttpFunction;importcom.google.cloud.functions.HttpRequest;importcom.google.cloud.functions.HttpResponse;// Define a class that implements the HttpFunction interfacepublicclassMyHttpFunctionimplementsHttpFunction{// Implement the service() method to handle HTTP requests@Overridepublicvoidservice(HttpRequestrequest,HttpResponseresponse)throwsException{// Your code here// Send an HTTP responseresponse.getWriter().write("OK");}}

In Java, you use theFunctions Framework Java APIto implement an HTTP handler class with theHttpFunctioninterface. Theservice() method must send an HTTP response.

Thefunction entry pointis the fully-qualified name of the HTTP handler class, including the packagename. In this example, the entry point ismyhttpfunction.MyHttpFunction.

Yourservice method receives anHttpRequestobject describing the inbound HTTP request, and anHttpResponseobject that your function populates with a response message.

.NET

usingGoogle.Cloud.Functions.Framework;usingMicrosoft.AspNetCore.Http;usingSystem.Threading.Tasks;namespaceMyProject{// Define a class that implements the IHttpFunction interfacepublicclassMyHttpFunction:IHttpFunction{// Implement the HandleAsync() method to handle HTTP requestspublicasyncTaskHandleAsync(HttpContextcontext){// Your code here// Send an HTTP responseawaitcontext.Response.WriteAsync("OK");}}}

In .NET runtimes, you use theFunctions Framework for .NETto implement an HTTP handler class with theIHttpFunctioninterface. TheHandleAsync() method accepts a standard ASP.NETHttpContextobject as an argument and must send an HTTP response.

Thefunction entry pointis the fully-qualified name of the HTTP handler class, including thenamespace. In this example, the entry point isMyProject.MyHttpFunction.

Ruby

require"functions_framework"# Register an HTTP function with the Functions FrameworkFunctionsFramework.http"my_http_function"do|request|# Your code here# Return an HTTP response"OK"end

In Ruby, you register an HTTP handler function with theFunctions Framework for Ruby.Your HTTP handler function must accept aRack requestobject as an argument and returna value that can be used as an HTTP response.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismy_http_function.

PHP

<?phpuse Google\CloudFunctions\FunctionsFramework;use Psr\Http\Message\ServerRequestInterface;// Register an HTTP function with the Functions FrameworkFunctionsFramework::http('myHttpFunction', 'myHttpHandler');// Define your HTTP handlerfunction myHttpHandler(ServerRequestInterface $request): string{    // Your code here    // Return an HTTP response    return 'OK';}

In PHP, you register an HTTP handler function with theFunctions Framework for PHP.Your HTTP handler function must accept an argument that implements the PSR-7ServerRequestInterfaceinterface, and must return an HTTP response as either a string or an objectthat implements the PSR-7ResponseInterfaceinterface.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismyHttpFunction.

Node.js

constfunctions=require('@google-cloud/functions-framework');/** * HTTP function that supports CORS requests. * * @param {Object} req Cloud Function request context. * @param {Object} res Cloud Function response context. */functions.http('corsEnabledFunction',(req,res)=>{// Set CORS headers for preflight requests// Allows GETs from any origin with the Content-Type header// and caches preflight response for 3600sres.set('Access-Control-Allow-Origin','*');if(req.method==='OPTIONS'){// Send response to OPTIONS requestsres.set('Access-Control-Allow-Methods','GET');res.set('Access-Control-Allow-Headers','Content-Type');res.set('Access-Control-Max-Age','3600');res.status(204).send('');}else{res.send('Hello World!');}});

Python

importfunctions_framework@functions_framework.httpdefcors_enabled_function(request):# For more information about CORS and CORS preflight requests, see:# https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request# Set CORS headers for the preflight requestifrequest.method=="OPTIONS":# Allows GET requests from any origin with the Content-Type# header and caches preflight response for an 3600sheaders={"Access-Control-Allow-Origin":"*","Access-Control-Allow-Methods":"GET","Access-Control-Allow-Headers":"Content-Type","Access-Control-Max-Age":"3600",}return("",204,headers)# Set CORS headers for the main requestheaders={"Access-Control-Allow-Origin":"*"}return("Hello World!",200,headers)

Go

// Package http provides a set of HTTP Cloud Functions samples.packagehttpimport("fmt""net/http""github.com/GoogleCloudPlatform/functions-framework-go/functions")// CORSEnabledFunction is an example of setting CORS headers.// For more information about CORS and CORS preflight requests, see// https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request.funcCORSEnabledFunction(whttp.ResponseWriter,r*http.Request){// Set CORS headers for the preflight requestifr.Method==http.MethodOptions{w.Header().Set("Access-Control-Allow-Origin","*")w.Header().Set("Access-Control-Allow-Methods","POST")w.Header().Set("Access-Control-Allow-Headers","Content-Type")w.Header().Set("Access-Control-Max-Age","3600")w.WriteHeader(http.StatusNoContent)return}// Set CORS headers for the main request.w.Header().Set("Access-Control-Allow-Origin","*")fmt.Fprint(w,"Hello, World!")}funcinit(){functions.HTTP("CORSEnabledFunction",CORSEnabledFunction)}

Java

importcom.google.cloud.functions.HttpFunction;importcom.google.cloud.functions.HttpRequest;importcom.google.cloud.functions.HttpResponse;importjava.io.BufferedWriter;importjava.io.IOException;importjava.net.HttpURLConnection;publicclassCorsEnabledimplementsHttpFunction{// corsEnabled is an example of setting CORS headers.// For more information about CORS and CORS preflight requests, see// https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request.@Overridepublicvoidservice(HttpRequestrequest,HttpResponseresponse)throwsIOException{// Set CORS headers//   Allows GETs from any origin with the Content-Type//   header and caches preflight response for 3600sresponse.appendHeader("Access-Control-Allow-Origin","*");if("OPTIONS".equals(request.getMethod())){response.appendHeader("Access-Control-Allow-Methods","GET");response.appendHeader("Access-Control-Allow-Headers","Content-Type");response.appendHeader("Access-Control-Max-Age","3600");response.setStatusCode(HttpURLConnection.HTTP_NO_CONTENT);return;}// Handle the main request.BufferedWriterwriter=response.getWriter();writer.write("CORS headers set successfully!");}}

.NET

usingGoogle.Cloud.Functions.Framework;usingMicrosoft.AspNetCore.Http;usingSystem.Net;usingSystem.Threading.Tasks;namespaceCors;// For more information about CORS and CORS preflight requests, see// https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request.publicclassFunction:IHttpFunction{publicasyncTaskHandleAsync(HttpContextcontext){HttpRequestrequest=context.Request;HttpResponseresponse=context.Response;// Set CORS headers//   Allows GETs from any origin with the Content-Type//   header and caches preflight response for 3600sresponse.Headers.Append("Access-Control-Allow-Origin","*");if(HttpMethods.IsOptions(request.Method)){response.Headers.Append("Access-Control-Allow-Methods","GET");response.Headers.Append("Access-Control-Allow-Headers","Content-Type");response.Headers.Append("Access-Control-Max-Age","3600");response.StatusCode=(int)HttpStatusCode.NoContent;return;}awaitresponse.WriteAsync("CORS headers set successfully!",context.RequestAborted);}}

Ruby

FunctionsFramework.http"cors_enabled_function"do|request|# For more information about CORS and CORS preflight requests, see# https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request# for more information.# Set CORS headers for the preflight requestifrequest.options?# Allows GET requests from any origin with the Content-Type# header and caches preflight response for an 3600sheaders={"Access-Control-Allow-Origin"=>"*","Access-Control-Allow-Methods"=>"GET","Access-Control-Allow-Headers"=>"Content-Type","Access-Control-Max-Age"=>"3600"}[204,headers,[]]else# Set CORS headers for the main requestheaders={"Access-Control-Allow-Origin"=>"*"}[200,headers,["Hello World!"]]endend

PHP

use Psr\Http\Message\ResponseInterface;use Psr\Http\Message\ServerRequestInterface;use GuzzleHttp\Psr7\Response;function corsEnabledFunction(ServerRequestInterface $request): ResponseInterface{    // Set CORS headers for preflight requests    // Allows GETs from any origin with the Content-Type header    // and caches preflight response for 3600s    $headers = ['Access-Control-Allow-Origin' => '*'];    if ($request->getMethod() === 'OPTIONS') {        // Send response to OPTIONS requests        $headers = array_merge($headers, [            'Access-Control-Allow-Methods' => 'GET',            'Access-Control-Allow-Headers' => 'Content-Type',            'Access-Control-Max-Age' => '3600'        ]);        return new Response(204, $headers, '');    } else {        return new Response(200, $headers, 'Hello World!');    }}

Node.js

import{cloudEvent}from"@google-cloud/functions-framework";cloudEvent('myCloudEventFunction',cloudEvent=>{// Your code here// Access the CloudEvent data payload using cloudEvent.data});

{"dependencies":{"@google-cloud/functions-framework":"^3.0.0"},"type":"module"}

constfunctions=require('@google-cloud/functions-framework');// Register a CloudEvent function with the Functions Frameworkfunctions.cloudEvent('myCloudEventFunction',cloudEvent=>{// Your code here// Access the CloudEvent data payload using cloudEvent.data});

{"dependencies":{"@google-cloud/functions-framework":"^3.0.0"}}

In Node.js, you register a CloudEvent handler function with theFunctions Framework for Node.js.Your handler function must accept aCloudEventobject as an argument.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismyCloudEventFunction.

Python

importfunctions_framework# Register a CloudEvent function with the Functions Framework@functions_framework.cloud_eventdefmy_cloudevent_function(cloud_event):# Your code here# Access the CloudEvent data payload via cloud_event.data

In Python, you register a CloudEvent handler function with theFunctions Framework for Python.Your handler function must accept aCloudEventobject as an argument.

Thefunction entry pointis the name of the handler function registered with the Functions Framework.In this example, the entry point ismy_cloudevent_function.

Go

packagemycloudeventfunctionimport("context""github.com/GoogleCloudPlatform/functions-framework-go/functions""github.com/cloudevents/sdk-go/v2/event")funcinit(){// Register a CloudEvent function with the Functions Frameworkfunctions.CloudEvent("MyCloudEventFunction",myCloudEventFunction)}// Function myCloudEventFunction accepts and handles a CloudEvent objectfuncmyCloudEventFunction(ctxcontext.Context,eevent.Event)error{// Your code here// Access the CloudEvent data payload using e.Data() or e.DataAs(...)// Returning an error causes its message to be logged.// Example:err:=myInternalFunction()// may return an erroriferr!=nil{// Append error message to logreturnerr}// Return nil if no error occurredreturnnil}

In Go, you register a CloudEvent handler function with theFunctions Framework for Go.Your handler function must accept a CloudEventsevent.Eventobject as an argument.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point isMyCloudEventFunction.

Java

packagemycloudeventfunction;importcom.google.cloud.functions.CloudEventsFunction;importio.cloudevents.CloudEvent;// Define a class that implements the CloudEventsFunction interfacepublicclassMyCloudEventFunctionimplementsCloudEventsFunction{// Implement the accept() method to handle CloudEvents@Overridepublicvoidaccept(CloudEventevent){// Your code here// Access the CloudEvent data payload using event.getData()// To get the data payload as a JSON string, use:// new String(event.getData().toBytes())}}

In Java, you use theFunctions Framework Java APIto implement a CloudEvent handler class with theCloudEventsFunctioninterface. Theaccept() method must accept aCloudEventobject as an argument and perform any processing on the event.

Thefunction entry pointis the fully-qualified name of the CloudEvent handler class, including thepackage name. In this example, the entry point ismycloudeventfunction.MyCloudEventFunction.

.NET

usingCloudNative.CloudEvents;usingGoogle.Cloud.Functions.Framework;usingSystem.Threading;usingSystem.Threading.Tasks;namespaceMyProject{// Define a class that implements the ICloudEventFunction<T> interfacepublicclassMyCloudEventFunction:ICloudEventFunction<CloudEventDataType>{// Implement the HandleAsync() method to handle CloudEventspublicTaskHandleAsync(CloudEventcloudEvent,CloudEventDataTypedata,CancellationTokencancellationToken){// Your code here// The data argument represents the CloudEvent data payload// Signal function completionreturnTask.CompletedTask;}}}

In .NET runtimes, you use theFunctions Framework for .NETto implement a CloudEvent handler class with theICloudEventFunction<T>interface. TheHandleAsync() method accepts aCloudEventobject and the associated CloudEvent data payload as arguments.

The type of the CloudEvent data payload argument, shown in the example code asCloudEventDataType, must correspond to the type of eventthe function handles. TheGoogle CloudEvents .NET libraryprovides data types for the various events supported by Google.

Thefunction entry pointis the fully-qualified name of the CloudEvent handler class, including thenamespace. In this example, the entry point isMyProject.MyCloudEventFunction.

Ruby

require"functions_framework"# Register a CloudEvent function with the Functions FrameworkFunctionsFramework.cloud_event"my_cloudevent_function"do|cloud_event|# Your code here# Access the CloudEvent data payload via cloud_event.dataend

In Ruby, you register a CloudEvent handler function with theFunctions Framework for Ruby.Your handler function must accept a CloudEventsEventobject as an argument.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismy_cloudevent_function.

PHP

<?phpuse CloudEvents\V1\CloudEventInterface;use Google\CloudFunctions\FunctionsFramework;// Register a CloudEvent function with the Functions FrameworkFunctionsFramework::cloudEvent('myCloudEventFunction', 'myCloudEventHandler');// Define your CloudEvent handlerfunction myCloudEventHandler(CloudEventInterface $event): void{    // Your code here    // Access the CloudEvent data payload using $event->getData()}

In PHP, you register a CloudEvent handler function with theFunctions Framework for PHP.Your handler function must accept an argument that conforms to theCloudEventInterfaceinterface.

Thefunction entry pointis the name with which the handler is registered with the Functions Framework.In this example, the entry point ismyCloudEventFunction.