Cloud Functions a été renommé Cloud Run Functions. Pour en savoir plus, consultez l'article de blog sur Cloud Run Functions.

Appeler directement des fonctions Cloud Run

Pour prendre en charge l'itération et le débogage rapides, Cloud Run Functions fournit une commande call dans l'interface de ligne de commande et des fonctionnalités de test dans l'interface utilisateur de la console Google Cloud. Cela vous permet d'appeler directement une fonction pour vous assurer qu'elle se comporte comme prévu. La fonction s'exécute immédiatement, même si elle a été déployée pour répondre à un événement spécifique.

Tester votre fonction avec Google Cloud CLI

Pour appeler directement une fonction à l'aide de gcloud CLI, utilisez la commande gcloud functions call et fournissez toutes les données que votre fonction attend au format JSON dans l'argument --data. Exemple :

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

Remplacez :

YOUR_FUNCTION_NAME : nom de la fonction que vous testez.
REGION : région Google Cloud dans laquelle votre fonction est déployée

L'argument --data est envoyé à votre fonction comme suit :

Pour les fonctions HTTP, les données que vous fournissez sont envoyées en tant que corps d'une requête POST.
Pour les fonctions CloudEvent, les données sont directement transmises à votre fonction en tant que données d'événement.

Pour en savoir plus, reportez-vous à la documentation gcloud functions call.

Tester votre fonction avec la console Google Cloud

Pour appeler directement une fonction à partir de la console Google Cloud, procédez comme suit :

Accéder à la page de présentation de Cloud Run Functions
Dans la liste, cliquez sur le nom de la fonction que vous souhaitez appeler. La page d'informations de la fonction s'affiche.
Cliquez sur l'onglet Tests.
Dans le champ Configurer un événement déclencheur, saisissez les données que votre fonction attend au format JSON.
Cliquez sur +Ajouter un paramètre de requête et +Ajouter un paramètre d'en-tête pour ajouter des paramètres de requête et d'en-tête à l'appel de fonction, si nécessaire.

La console Google Cloud assemble les paramètres que vous spécifiez dans une commande gcloud functions call dans la fenêtre de la commande de test de la CLI.
Sélectionnez Exécuter dans Cloud Shell pour ouvrir une fenêtre Cloud Shell afin d'exécuter cette commande.
Appuyez sur Entrée pour déclencher la commande gcloud functions call après son affichage dans votre fenêtre Cloud Shell.

Exemple de fonction Cloud Pub/Sub basée sur des événements

Cet exemple montre comment appeler directement une fonction basée sur des événements déclenchée par des événements Cloud Pub/Sub :

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

Pour appeler directement la fonction, envoyez une requête PubsubMessage, qui attend des données encodées en base64 en tant que données d'événement :