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 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.

gcloud-Befehlszeile verwenden

Verwenden Sie zum direkten Aufrufen einer Funktion mit dem gcloud-Tool 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":"Keyboard Cat"}'

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.

Mit der GCP Console

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

  1. Rufen Sie die Cloud Functions-Übersicht auf.

  2. Klicken Sie in der Liste auf den Namen der Funktion, die Sie aufrufen möchten.

    Sie werden zur Seite Funktionsdetails weitergeleitet.

  3. Klicken Sie auf den Tab Testen.

  4. Geben Sie im Feld Auslösendes Ereignis alle Daten, die Ihre Funktion erwartet, im JSON-Format ein.

  5. 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.

Beispiel für eine Cloud Pub/Sub-Hintergrundfunktion

In diesem Beispiel wird gezeigt, wie eine durch Cloud Pub/Sub-Ereignisse ausgelöste Hintergrundfunktion direkt aufgerufen 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 `data` field contains the PubsubMessage message. The
         `attributes` field will contain custom attributes if there are any.
         context (google.cloud.functions.Context): The Cloud Functions event
         metadata. The `event_id` field contains the Pub/Sub message ID. The
         `timestamp` field contains the publish time.
    """
    import base64

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

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

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 com.google.events.cloud.pubsub.v1.Message;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

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

  @Override
  public void accept(Message 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;
  }
}

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

Node.js

DATA=$(printf 'Hello!'|base64) && gcloud functions call helloPubSub --data '{"data":"'$DATA'"}'

Python

DATA=$(printf 'Hello!'|base64) && gcloud functions call hello_pubsub --data '{"data":"'$DATA'"}'

Go

DATA=$(printf 'Hello!'|base64) && gcloud functions call HelloPubSub --data '{"data":"'$DATA'"}'

Java

DATA=$(printf 'Hello!'|base64) && gcloud functions call java-hello-pubsub --data '{"data":"'$DATA'"}'

Sie können die Funktion auch über die Cloud Console-UI aufrufen. Verwenden Sie dazu einfach dieselben Ereignisdaten im Feld Auslösendes Ereignis.