Cloud Functions è stato rinominato in Funzioni Cloud Run. Per ulteriori informazioni, consulta il post del blog sulle funzioni Cloud Run.

Questa pagina è stata tradotta dall'API Cloud Translation.

Chiama direttamente le funzioni Cloud Run

Per supportare l'iterazione e il debug rapidi, le funzioni Cloud Run forniscono un comando call nell'interfaccia a riga di comando e la funzionalità di test nell'interfaccia utente della console Google Cloud. In questo modo, puoi richiamare direttamente una funzione per assicurarti che funzioni come previsto. Di conseguenza, la funzione viene eseguita immediatamente, anche se potrebbe essere stata implementata per rispondere a un evento specifico.

Testa la funzione con Google Cloud CLI

Per invocare direttamente la funzione utilizzando gcloud CLI, utilizza il comando gcloud functions call e fornisci tutti i dati che la funzione si aspetta come JSON nell'argomento --data. Ad esempio:

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

Sostituisci:

YOUR_FUNCTION_NAME: il nome della funzione che stai testando
REGION: la regione Google Cloud in cui è dipiattaforma la funzione

L'argomento --data viene inviato alla funzione come segue:

Per le funzioni HTTP,i dati forniti vengono inviati come corpo di una richiesta POST.
Per le funzioni CloudEvent,i dati vengono passati direttamente come dati dell'evento alla funzione.

Per ulteriori informazioni, consulta la documentazione di gcloud functions call.

Testa la funzione con la Google Cloud Console

Per richiamare direttamente una funzione dalla console Google Cloud, segui questi passaggi:

Vai alla pagina Panoramica delle funzioni Cloud Run.
Nell'elenco, fai clic sul nome della funzione che vuoi chiamare. Verrà visualizzata la pagina Dettagli funzione.
Fai clic sulla scheda Test.
Nel campo Configura evento di attivazione, inserisci i dati previsti dalla funzione come JSON.
Fai clic su + Aggiungi parametro di query e + Aggiungi parametro di intestazione per aggiungere parametri di query e intestazione alla chiamata della funzione in base alle esigenze.

La console Google Cloud assembla i parametri specificati in un comando gcloud functions call nella finestra Comando di test dell'interfaccia a riga di comando.
Seleziona Esegui in Cloud Shell per aprire una finestra Cloud Shell in cui eseguire questo comando.
Premi Invio per attivare il comando gcloud functions call quando viene visualizzato nella finestra Cloud Shell.

Esempio di funzione basata su eventi Cloud Pub/Sub

Questo esempio mostra come richiamare direttamente una funzione basata su eventi attivata dagli eventi 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() + "!"
    )

Vai


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

Per invocare direttamente la funzione, invia un messaggio PubsubMessage, che prevede dati codificati in base64, come dati dell'evento: