Um die Suche zu vereinfachen und die Dokumentation zu verbessern, teilen wir die Dokumentation der 1. Generation und der 2. Generation in separate Gruppen ein.

Cloud Run-Funktionen direkt aufrufen

Für eine schnelle Iteration und schnelles Debugging bietet Cloud Run Functions einen call-Befehl in der Befehlszeile sowie Testfunktionen in der Benutzeroberfläche der Google Cloud Console. So können Sie eine Funktion direkt aufrufen, um zu prüfen, ob sie sich erwartungsgemäß verhält. Das führt dazu, dass die Funktion sofort ausgeführt wird, obwohl sie eventuell für die Reaktion auf ein bestimmtes Ereignis bereitgestellt wurde.

Funktion mit der Google Cloud CLI testen

Verwenden Sie zum direkten Aufrufen Ihrer Funktion mit der gcloud CLI den gcloud functions call-Befehl und geben alle Daten, die Ihre Funktion erwartet, im Argument --data im JSON-Format an. Beispiel:

gcloud functions call YOUR_FUNCTION_NAME \
  --region=REGION --gen2 \
  --data '{"name":"Kalani"}'

Ersetzen Sie:

YOUR_FUNCTION_NAME: Der Name der Funktion, die Sie testen.
REGION: die Google Cloud-Region, in der Ihre Funktion bereitgestellt wird

Das Argument --data wird so an Ihre Funktion gesendet:

Bei HTTP-Funktionen werden die von Ihnen angegebenen Daten als der Haupttext einer POST-Anfrage gesendet.
Bei CloudEvent-Funktionen werden die Daten direkt als die Ereignisdaten an Ihre Funktion weitergeleitet.

Weitere Informationen finden Sie in der Dokumentationgcloud functions call.

Funktion mit der Google Cloud Console testen

Führen Sie zum direkten Aufrufen einer Funktion über die Google Cloud Console die folgenden Schritte aus:

Zur Cloud Run-Übersicht
Klicken Sie in der Liste auf den Namen der Funktion, die Sie aufrufen möchten. Sie werden zur Seite Funktionsdetails weitergeleitet.
Klicken Sie auf den Tab Testen.
Geben Sie im Feld Auslösendes Ereignis alle Daten, die Ihre Funktion erwartet, im JSON-Format ein.
Klicken Sie auf + Abfrageparameter hinzufügen und + Headerparameter hinzufügen, um dem Funktionsaufruf bei Bedarf Abfrage- und Headerparameter hinzuzufügen.

Die Google Cloud Console stellt die von Ihnen angegebenen Parameter im Fenster Befehl zum Testen der Befehlszeile in einem gcloud functions call-Befehl zusammen.
Wählen Sie In Cloud Shell ausführen aus, um ein Cloud Shell-Fenster zu öffnen und diesen Befehl auszuführen.
Drücken Sie die Eingabetaste, um den Befehl gcloud functions call auszuführen, sobald er im Cloud Shell-Fenster angezeigt wird.

Beispiel für ereignisgesteuerte Cloud Pub/Sub-Funktion

In diesem Beispiel wird gezeigt, wie eine ereignisgesteuerte Funktion direkt aufgerufen wird, die von Cloud Pub/Sub-Ereignissen ausgelöst wird:

Node.js

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

// Register a CloudEvent callback with the Functions Framework that will
// be executed when the Pub/Sub trigger topic receives a message.
functions.cloudEvent('helloPubSub', cloudEvent => {
  // The Pub/Sub message is passed as the CloudEvent's data payload.
  const base64name = cloudEvent.data.message.data;

  const name = base64name
    ? Buffer.from(base64name, 'base64').toString()
    : 'World';

  console.log(`Hello, ${name}!`);
});

Python

import base64

from cloudevents.http import CloudEvent
import functions_framework


# Triggered from a message on a Cloud Pub/Sub topic.
@functions_framework.cloud_event
def subscribe(cloud_event: CloudEvent) -> None:
    # Print out the data from Pub/Sub, to prove that it worked
    print(
        "Hello, " + base64.b64decode(cloud_event.data["message"]["data"]).decode() + "!"
    )

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"context"
	"fmt"
	"log"

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

func init() {
	functions.CloudEvent("HelloPubSub", helloPubSub)
}

// MessagePublishedData contains the full Pub/Sub message
// See the documentation for more details:
// https://cloud.google.com/eventarc/docs/cloudevents#pubsub
type MessagePublishedData struct {
	Message PubSubMessage
}

// PubSubMessage is the payload of a Pub/Sub event.
// See the documentation for more details:
// https://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage
type PubSubMessage struct {
	Data []byte `json:"data"`
}

// helloPubSub consumes a CloudEvent message and extracts the Pub/Sub message.
func helloPubSub(ctx context.Context, e event.Event) error {
	var msg MessagePublishedData
	if err := e.DataAs(&msg); err != nil {
		return fmt.Errorf("event.DataAs: %w", err)
	}

	name := string(msg.Message.Data) // Automatically decoded from base64.
	if name == "" {
		name = "World"
	}
	log.Printf("Hello, %s!", name)
	return nil
}

Java

import com.google.cloud.functions.CloudEventsFunction;
import com.google.gson.Gson;
import functions.eventpojos.PubSubBody;
import io.cloudevents.CloudEvent;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.logging.Logger;

public class SubscribeToTopic implements CloudEventsFunction {
  private static final Logger logger = Logger.getLogger(SubscribeToTopic.class.getName());

  @Override
  public void accept(CloudEvent event) {
    // The Pub/Sub message is passed as the CloudEvent's data payload.
    if (event.getData() != null) {
      // Extract Cloud Event data and convert to PubSubBody
      String cloudEventData = new String(event.getData().toBytes(), StandardCharsets.UTF_8);
      Gson gson = new Gson();
      PubSubBody body = gson.fromJson(cloudEventData, PubSubBody.class);
      // Retrieve and decode PubSub message data
      String encodedData = body.getMessage().getData();
      String decodedData =
          new String(Base64.getDecoder().decode(encodedData), StandardCharsets.UTF_8);
      logger.info("Hello, " + decodedData + "!");
    }
  }
}

C#

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Cloud.PubSub.V1;
using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

namespace HelloPubSub;

public class Function : ICloudEventFunction<MessagePublishedData>
{
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public Task HandleAsync(CloudEvent cloudEvent, MessagePublishedData data, CancellationToken cancellationToken)
    {
        string nameFromMessage = data.Message?.TextData;
        string name = string.IsNullOrEmpty(nameFromMessage) ? "world" : nameFromMessage;
        _logger.LogInformation("Hello {name}", name);
        return Task.CompletedTask;
    }
}

Ruby

require "functions_framework"
require "base64"

FunctionsFramework.cloud_event "hello_pubsub" do |event|
  # The event parameter is a CloudEvents::Event::V1 object.
  # See https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event/V1.html
  name = Base64.decode64 event.data["message"]["data"] rescue "World"

  # A cloud_event function does not return a response, but you can log messages
  # or cause side effects such as sending additional events.
  logger.info "Hello, #{name}!"
end

PHP


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

// Register the function with Functions Framework.
// This enables omitting the `FUNCTIONS_SIGNATURE_TYPE=cloudevent` environment
// variable when deploying. The `FUNCTION_TARGET` environment variable should
// match the first parameter.
FunctionsFramework::cloudEvent('helloworldPubsub', 'helloworldPubsub');

function helloworldPubsub(CloudEventInterface $event): void
{
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb');

    $cloudEventData = $event->getData();
    $pubSubData = base64_decode($cloudEventData['message']['data']);

    $name = $pubSubData ? htmlspecialchars($pubSubData) : 'World';
    fwrite($log, "Hello, $name!" . PHP_EOL);
}

Wenn Sie die Funktion direkt aufrufen möchten, senden Sie als Ereignisdaten eine PubsubMessage, die base64-codierte Daten erwartet: