Cloud Run-Funktionen schreiben

Node.js

Die grundlegende Verzeichnisstruktur für Node.js-Funktionen sieht so aus:

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

Standardmäßig versucht Cloud Run, Quellcode aus einer Datei mit dem Namen index.js im Stammverzeichnis Ihres Funktionsverzeichnisses zu laden. Verwenden Sie das Feld main in der Datei package.json, um eine andere Hauptquelldatei anzugeben.

Die Datei package.json muss auch das Functions Framework für Node.js als Abhängigkeit enthalten:

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

Der Code in der Hauptdatei muss den Funktionseinstiegspunkt definieren und kann anderen Code und Node.js-Module importieren. Die Hauptdatei kann auch mehrere Funktionseinstiegspunkte definieren, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Übersicht über die Node.js-Laufzeit und im Functions Framework für Node.js.

Python

Die grundlegende Verzeichnisstruktur für Python-Funktionen sieht so aus:

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

Cloud Run lädt den Quellcode aus einer Datei namens main.py im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss main.py heißen.

Die Datei requirements.txt muss das Functions Framework für Python als Abhängigkeit enthalten:

functions-framework==3.*

Der Code in der Datei main.py muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei main.py können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Python-Laufzeitübersicht und im Functions Framework für Python.

Go

Die grundlegende Verzeichnisstruktur für Go-Funktionen ist so:

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

Ihre Funktion muss sich in einem Go-Paket im Stammverzeichnis des Projekts befinden. Das Paket und seine Quelldateien können einen beliebigen Namen haben, aber Ihre Funktion darf sich nicht in package main befinden. Wenn Sie ein main-Paket benötigen, z. B. für lokale Tests, können Sie eines in einem Unterverzeichnis erstellen:

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

Die Datei go.mod muss das Functions Framework für Go als Abhängigkeit enthalten:

module example.com/my-module

require (
  github.com/GoogleCloudPlatform/functions-framework-go v1.5.2
)

Der Code im Root-Paket muss den Funktionseinstiegspunkt definieren und anderen Code aus Unterpaketen und Abhängigkeiten wie gewohnt importieren. Mit dem Paket können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Go-Laufzeitübersicht und im Functions Framework für Go.

Java

Die grundlegende Verzeichnisstruktur für Java-Funktionen sieht so aus:

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

Ihre Java-Quelldateien müssen sich im Verzeichnis src/main/java/ befinden und einen beliebigen Namen haben. Fügen Sie unter src/main/java ein zusätzliches Verzeichnis mit dem Namen des Pakets hinzu, wenn Ihre Quelldateien ein Paket deklarieren:

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

Wir empfehlen, die zugehörigen Tests in einem Unterverzeichnis src/test/java/ abzulegen.

Die Datei pom.xml muss das Functions Framework für Java als Abhängigkeit enthalten:

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

Der Code in Ihren Quelldateien muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. Mit Quelldateien können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie unter Java-Laufzeit – Übersicht und Functions Framework für Java.

.NET

Die grundlegende Verzeichnisstruktur für .NET-Funktionen ist folgende:

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

Sie können Ihre Projekte wie jeden anderen .NET-Quellcode strukturieren. Ihre Quelldateien können einen beliebigen Namen haben.

Ihre Projektdatei muss das Functions Framework für .NET als Abhängigkeit enthalten:

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

Der Code in Ihren Quelldateien muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. Mit Quelldateien können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Übersicht über die.NET-Laufzeit und im Functions Framework für .NET.

Ruby

Die grundlegende Verzeichnisstruktur für Ruby-Funktionen sieht so aus:

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

Cloud Run lädt den Quellcode aus einer Datei namens app.rb im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss app.rb heißen.

Die Datei Gemfile muss das Functions Framework für Ruby als Abhängigkeit enthalten:

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

Der Code in der Datei app.rb muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei app.rb können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Übersicht über die Ruby-Laufzeit und im Functions Framework für Ruby.

PHP

Die grundlegende Verzeichnisstruktur für PHP-Funktionen sieht so aus:

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

Cloud Run lädt den Quellcode aus einer Datei namens index.php im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss index.php heißen.

Die Datei composer.json muss das Functions Framework für PHP als Abhängigkeit enthalten:

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

Der Code in der Datei index.php muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei index.php können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Weitere Informationen finden Sie in der Übersicht: PHP-Laufzeit und im Functions Framework für PHP.

Node.js

  import { http } from '@google-cloud/functions-framework';
  http('myHttpFunction', (req, res) => {
    // Your code here

    // Send an HTTP response
    res.send('OK');
  });

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

  const functions = require('@google-cloud/functions-framework');

  // Register an HTTP function with the Functions Framework
  functions.http('myHttpFunction', (req, res) => {
    // Your code here

    // Send an HTTP response
    res.send('OK');
  });

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

In Node.js registrieren Sie eine HTTP-Handler-Funktion mit dem Functions Framework für Node.js. Ihre HTTP-Handler-Funktion muss eine Express-Middleware-Funktion sein, die die Anfrage- und Antwortargumente akzeptiert und eine HTTP-Antwort sendet.

Cloud Run parst den Anfragetext automatisch anhand des Content-Type-Headers der Anfrage mithilfe von body-parser, sodass Sie auf req.body und req.rawBody-Objekte im HTTP-Handler zugreifen können.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt myHttpFunction.

Python

import functions_framework

# Register an HTTP function with the Functions Framework
@functions_framework.http
def my_http_function(request):
  # Your code here

  # Return an HTTP response
  return 'OK'

In Python registrieren Sie eine HTTP-Handler-Funktion mit dem Functions Framework für Python. Ihre HTTP-Handler-Funktion muss ein Flask-Anfrageobjekt als Argument akzeptieren und einen Wert zurückgeben, den Flask in ein HTTP-Antwortobjekt konvertieren kann.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt my_http_function.

Go

package myhttpfunction

import (
    "fmt"
    "net/http"

    "github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

func init() {
    // Register an HTTP function with the Functions Framework
    functions.HTTP("MyHTTPFunction", myHTTPFunction)
}

// Function myHTTPFunction is an HTTP handler
func myHTTPFunction(w http.ResponseWriter, r *http.Request) {
    // Your code here

    // Send an HTTP response
    fmt.Fprintln(w, "OK")
}

In Go registrieren Sie eine HTTP-Handler-Funktion mit dem Functions Framework für Go in Ihrer init()-Funktion. Ihre HTTP-Handler-Funktion muss die Standardschnittstelle http.HandlerFunc verwenden, um eine HTTP-Antwort zu senden.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt MyHTTPFunction.

Ihre HTTP-Handler-Funktion muss die Standardschnittstelle http.HandlerFunc implementieren. Sie akzeptiert eine http.ResponseWriter-Schnittstelle, mit der Ihre Funktion eine Antwort auf die Anfrage erstellt, und einen Zeiger auf eine http.Request-Struktur, die die Details der eingehenden HTTP-Anfrage enthält.

Java

package myhttpfunction;

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;

// Define a class that implements the HttpFunction interface
public class MyHttpFunction implements HttpFunction {
  // Implement the service() method to handle HTTP requests
  @Override
  public void service(HttpRequest request, HttpResponse response) throws Exception {
    // Your code here

    // Send an HTTP response
    response.getWriter().write("OK");
  }
}

In Java verwenden Sie die Functions Framework Java API, um eine HTTP-Handler-Klasse mit der Schnittstelle HttpFunction zu implementieren. Die Methode service() muss eine HTTP-Antwort senden.

Der Funktionseinstiegspunkt ist der voll qualifizierte Name der HTTP-Handler-Klasse, einschließlich des Paketnamens. In diesem Beispiel ist der Einstiegspunkt myhttpfunction.MyHttpFunction.

Die Methode service empfängt ein HttpRequest-Objekt, das die eingehende HTTP-Anfrage beschreibt, und ein HttpResponse-Objekt, das von der Funktion mit einer Antwortnachricht ausgefüllt wird.

.NET

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

namespace MyProject
{
    // Define a class that implements the IHttpFunction interface
    public class MyHttpFunction : IHttpFunction
    {
        // Implement the HandleAsync() method to handle HTTP requests
        public async Task HandleAsync(HttpContext context)
        {
            // Your code here

            // Send an HTTP response
            await context.Response.WriteAsync("OK");
        }
    }
}

In .NET-Laufzeiten verwenden Sie das Functions Framework für .NET, um eine HTTP-Handler-Klasse mit der Benutzeroberfläche IHttpFunction. Die Methode HandleAsync() akzeptiert ein Standard-ASP.NET-Objekt HttpContext als Argument und muss eine HTTP-Antwort senden.

Der Funktionseinstiegspunkt ist der vollständig qualifizierte Name der HTTP-Handler-Klasse, einschließlich des Namespace. In diesem Beispiel ist der Einstiegspunkt MyProject.MyHttpFunction.

Ruby

require "functions_framework"

# Register an HTTP function with the Functions Framework
FunctionsFramework.http "my_http_function" do |request|
  # Your code here

  # Return an HTTP response
  "OK"
end

In Ruby registrieren Sie eine HTTP-Handler-Funktion mit dem Functions Framework für Ruby. Die HTTP-Handler-Funktion muss ein Rack-Anfrageobjekt als Argument akzeptieren und einen Wert zurückgeben, der als HTTP-Antwort verwendet werden kann.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt my_http_function.

PHP

<?php

use Google\CloudFunctions\FunctionsFramework;
use Psr\Http\Message\ServerRequestInterface;

// Register an HTTP function with the Functions Framework
FunctionsFramework::http('myHttpFunction', 'myHttpHandler');

// Define your HTTP handler
function myHttpHandler(ServerRequestInterface $request): string
{
    // Your code here

    // Return an HTTP response
    return 'OK';
}

In PHP registrieren Sie eine HTTP-Handler-Funktion mit dem Functions Framework für PHP. Ihre HTTP-Handler-Funktion muss ein Argument akzeptieren, das die PSR-7-Schnittstelle ServerRequestInterface implementiert, und muss eine HTTP-Antwort als String oder Objekt zurückgeben, das die PSR-7-Schnittstelle ResponseInterface implementiert.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt myHttpFunction.

Node.js

const functions = 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 3600s

  res.set('Access-Control-Allow-Origin', '*');

  if (req.method === 'OPTIONS') {
    // Send response to OPTIONS requests
    res.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

import functions_framework

@functions_framework.http
def cors_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 request
    if request.method == "OPTIONS":
        # Allows GET requests from any origin with the Content-Type
        # header and caches preflight response for an 3600s
        headers = {
            "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 request
    headers = {"Access-Control-Allow-Origin": "*"}

    return ("Hello World!", 200, headers)

Go

// Package http provides a set of HTTP Cloud Functions samples.
package http

import (
	"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.
func CORSEnabledFunction(w http.ResponseWriter, r *http.Request) {
	// Set CORS headers for the preflight request
	if r.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!")
}

func init() {
	functions.HTTP("CORSEnabledFunction", CORSEnabledFunction)
}

Java

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.BufferedWriter;
import java.io.IOException;
import java.net.HttpURLConnection;

public class CorsEnabled implements HttpFunction {
  // 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.
  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // Set CORS headers
    //   Allows GETs from any origin with the Content-Type
    //   header and caches preflight response for 3600s
    response.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.
    BufferedWriter writer = response.getWriter();
    writer.write("CORS headers set successfully!");
  }
}

.NET

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using System.Net;
using System.Threading.Tasks;

namespace Cors;

// For more information about CORS and CORS preflight requests, see
// https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request.
public class Function : IHttpFunction
{
    public async Task HandleAsync(HttpContext context)
    {
        HttpRequest request = context.Request;
        HttpResponse response = context.Response;

        // Set CORS headers
        //   Allows GETs from any origin with the Content-Type
        //   header and caches preflight response for 3600s

        response.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;
        }

        await response.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 request
  if request.options?
    # Allows GET requests from any origin with the Content-Type
    # header and caches preflight response for an 3600s
    headers = {
      "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 request
    headers = {
      "Access-Control-Allow-Origin" => "*"
    }

    [200, headers, ["Hello World!"]]
  end
end

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"
  }

const functions = require('@google-cloud/functions-framework');

// Register a CloudEvent function with the Functions Framework
functions.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 registrieren Sie eine CloudEvent-Handler-Funktion mit dem Functions Framework für Node.js. Ihre Handler-Funktion muss ein CloudEvent-Objekt als Argument akzeptieren.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt myCloudEventFunction.

Python

import functions_framework

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

In Python registrieren Sie eine CloudEvent-Handler-Funktion mit dem Functions Framework für Python. Ihre Handler-Funktion muss ein CloudEvent-Objekt als Argument akzeptieren.

Der Funktionseinstiegspunkt ist der Name der Handler-Funktion, die bei Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt my_cloudevent_function.

Go

package mycloudeventfunction

import (
    "context"

    "github.com/GoogleCloudPlatform/functions-framework-go/functions"
    "github.com/cloudevents/sdk-go/v2/event"
)

func init() {
    // Register a CloudEvent function with the Functions Framework
    functions.CloudEvent("MyCloudEventFunction", myCloudEventFunction)
}

// Function myCloudEventFunction accepts and handles a CloudEvent object
func myCloudEventFunction(ctx context.Context, e event.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 error
    if err != nil {
        // Append error message to log
        return err
    }

    // Return nil if no error occurred
    return nil
}

In Go registrieren Sie eine CloudEvent-Handler-Funktion mit dem Functions Framework für Go. Ihre Handler-Funktion muss eine CloudEvents event.Event Objekt akzeptieren als Argument.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt MyCloudEventFunction.

Java

package mycloudeventfunction;

import com.google.cloud.functions.CloudEventsFunction;
import io.cloudevents.CloudEvent;

// Define a class that implements the CloudEventsFunction interface
public class MyCloudEventFunction implements CloudEventsFunction {
  // Implement the accept() method to handle CloudEvents
  @Override
  public void accept(CloudEvent event) {
    // 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 verwenden Sie die Functions Framework Java API, um eine CloudEvent-Handler-Klasse mit der Schnittstelle CloudEventsFunction zu implementieren. Die Methode accept() muss ein CloudEvent-Objekt als Argument akzeptieren und alle erforderlichen Verarbeitungsschritte für das Ereignis ausführen.

Der Funktionseinstiegspunkt ist der voll qualifizierte Name der CloudEvent-Handler-Klasse, einschließlich des Paketnamens. In diesem Beispiel ist der Einstiegspunkt mycloudeventfunction.MyCloudEventFunction.

.NET

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using System.Threading;
using System.Threading.Tasks;

namespace MyProject
{
  // Define a class that implements the ICloudEventFunction<T> interface
  public class MyCloudEventFunction : ICloudEventFunction<CloudEventDataType>
  {
      // Implement the HandleAsync() method to handle CloudEvents
      public Task HandleAsync(CloudEvent cloudEvent, CloudEventDataType data, CancellationToken cancellationToken)
      {
          // Your code here
          // The data argument represents the CloudEvent data payload

          // Signal function completion
          return Task.CompletedTask;
      }
  }
}

In .NET-Laufzeiten verwenden Sie dasFunctions Framework für .NET So implementieren Sie eine CloudEvent-Handler-Klasse mit der ICloudEventFunction<T>-Schnittstelle. Die Methode HandleAsync() akzeptiert ein CloudEvent-Objekt und die zugehörige CloudEvent-Daten-Payload als Argumente.

Der Typ des CloudEvent-Datennutzlastarguments, der im Beispielcode als CloudEventDataType gezeigt wird, muss dem Typ des Ereignisses entsprechen, das von der Funktion verarbeitet wird. Die Google CloudEvents .NET-Bibliothek bietet Datentypen für die verschiedenen von Google unterstützten Ereignisse.

Der Funktionseinstiegspunkt ist der vollständig qualifizierte Name der CloudEvent-Handler-Klasse, einschließlich des Namespace. In diesem Beispiel ist der Einstiegspunkt MyProject.MyCloudEventFunction.

Ruby

require "functions_framework"

# Register a CloudEvent function with the Functions Framework
FunctionsFramework.cloud_event "my_cloudevent_function" do |cloud_event|
  # Your code here
  # Access the CloudEvent data payload via cloud_event.data
end

In Ruby registrieren Sie eine CloudEvent-Handler-Funktion mit dem Functions Framework für Ruby. Ihre Handler-Funktion muss eine CloudEvents Event Objekt akzeptieren als Argument.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt my_cloudevent_function.

PHP

<?php

use CloudEvents\V1\CloudEventInterface;
use Google\CloudFunctions\FunctionsFramework;

// Register a CloudEvent function with the Functions Framework
FunctionsFramework::cloudEvent('myCloudEventFunction', 'myCloudEventHandler');

// Define your CloudEvent handler
function myCloudEventHandler(CloudEventInterface $event): void
{
    // Your code here
    // Access the CloudEvent data payload using $event->getData()
}

In PHP registrieren Sie eine CloudEvent-Handler-Funktion mit dem Functions Framework für PHP. Ihre Handler-Funktion muss ein Argument akzeptieren, das der Schnittstelle CloudEventInterface entspricht.

Der Funktionseinstiegspunkt ist der Name, mit dem der Handler beim Functions Framework registriert ist. In diesem Beispiel ist der Einstiegspunkt myCloudEventFunction.