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 Functions direkt aufrufen

Für eine schnelle Iteration und schnelles Debugging bietet Cloud 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 dem Google Cloud CLI testen

1. Generation

Wenn Sie eine Funktion der 1. Generation mithilfe der gcloud CLI direkt aufrufen möchten, verwenden Sie den Befehl gcloud functions call und geben alle Daten, die Ihre Funktion erwartet, im Argument --data im JSON-Format an. Beispiel:

gcloud functions call YOUR_FUNCTION_NAME --data '{"name":"Tristan"}'

Dabei ist YOUR_FUNCTION_NAME der Name der Funktion, die Sie ausführen möchten. 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 Hintergrundfunktionen werden die Daten direkt als die Ereignisdaten an Ihre Funktion weitergeleitet. Weitere Informationen zum Zugreifen auf Ereignisdaten in Hintergrundfunktionen finden Sie unter Hintergrundfunktionsparameter.
Bei CloudEvent-Funktionen werden die Daten direkt als die Ereignisdaten an Ihre Funktion weitergeleitet. Weitere Informationen zum Zugriff auf Ereignisdaten in CloudEvent-Funktionen finden Sie unter CloudEvent-Funktionsparameter.

2. Generation

Wenn Sie eine Funktion der 2. Generation mithilfe der gcloud CLI direkt aufrufen möchten, verwenden Sie die Version der 2. Generation des Befehls gcloud functions call und geben Sie 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 möchten
REGION: die Google Cloud-Region, in der die 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 zum Zugriff auf Ereignisdaten in CloudEvent-Funktionen finden Sie unter CloudEvent-Funktionsparameter.

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:

1. Generation

Zur Cloud Functions-Übersicht
Klicken Sie auf den Namen der Funktion, die Sie aufrufen möchten.
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 Funktion testen.

Die Antwort Ihrer Funktion wird im Feld Ausgabe angezeigt; Logs für die individuelle Ausführung werden im Feld Logs angezeigt.

2. Generation

Zur Cloud Functions-Ü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 nach Bedarf Abfrage- und Headerparameter hinzuzufügen.

Die Google Cloud Console stellt die von Ihnen angegebenen Parameter in einem gcloud functions call-Befehl im Fenster CLI-Testbefehl zusammen.
Wählen Sie In Cloud Shell ausführen aus, um ein Cloud Shell-Fenster zum Ausführen dieses Befehls zu öffnen.
Drücken Sie die Eingabetaste, um den Befehl gcloud functions call auszulösen, nachdem er in Ihrem Cloud Shell-Fenster angezeigt wurde.

Beispiel für ereignisgesteuerte Cloud Pub/Sub-Funktion

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

Node.js

/**
 * Background Cloud Function to be triggered by Pub/Sub.
 * This function is exported by index.js, and executed when
 * the trigger topic receives a message.
 *
 * @param {object} message The Pub/Sub message.
 * @param {object} context The event metadata.
 */
exports.helloPubSub = (message, context) => {
  const name = message.data
    ? Buffer.from(message.data, 'base64').toString()
    : 'World';

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

Python

def hello_pubsub(event, context):
    """Background Cloud Function to be triggered by Pub/Sub.
    Args:
         event (dict):  The dictionary with data specific to this type of
                        event. The `@type` field maps to
                         `type.googleapis.com/google.pubsub.v1.PubsubMessage`.
                        The `data` field maps to the PubsubMessage data
                        in a base64-encoded string. The `attributes` field maps
                        to the PubsubMessage attributes if any is present.
         context (google.cloud.functions.Context): Metadata of triggering event
                        including `event_id` which maps to the PubsubMessage
                        messageId, `timestamp` which maps to the PubsubMessage
                        publishTime, `event_type` which maps to
                        `google.pubsub.topic.publish`, and `resource` which is
                        a dictionary that describes the service API endpoint
                        pubsub.googleapis.com, the triggering topic's name, and
                        the triggering event type
                        `type.googleapis.com/google.pubsub.v1.PubsubMessage`.
    Returns:
        None. The output is written to Cloud Logging.
    """
    import base64

    print(
        """This Function was triggered by messageId {} published at {} to {}
    """.format(
            context.event_id, context.timestamp, context.resource["name"]
        )
    )

    if "data" in event:
        name = base64.b64decode(event["data"]).decode("utf-8")
    else:
        name = "World"
    print(f"Hello {name}!")

Einfach loslegen (Go)


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

import (
	"context"
	"log"
)

// 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 Pub/Sub message.
func HelloPubSub(ctx context.Context, m PubSubMessage) error {
	name := string(m.Data) // Automatically decoded from base64.
	if name == "" {
		name = "World"
	}
	log.Printf("Hello, %s!", name)
	return nil
}

Java


import com.google.cloud.functions.BackgroundFunction;
import com.google.cloud.functions.Context;
import functions.eventpojos.PubsubMessage;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

public class HelloPubSub implements BackgroundFunction<PubsubMessage> {
  private static final Logger logger = Logger.getLogger(HelloPubSub.class.getName());

  @Override
  public void accept(PubsubMessage message, Context context) {
    String name = "world";
    if (message != null && message.getData() != null) {
      name = new String(
          Base64.getDecoder().decode(message.getData().getBytes(StandardCharsets.UTF_8)),
          StandardCharsets.UTF_8);
    }
    logger.info(String.format("Hello %s!", name));
    return;
  }
}

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);
}

Zum direkten Aufrufen der Funktion senden Sie als Ereignisdaten eine PubsubMessage, die base64-codierte Daten erwartet: