Chiama direttamente Cloud Functions

Per supportare l'iterazione e il debug rapidi, Cloud Functions fornisce un comando call nell'interfaccia a riga di comando e funzionalità di test nell'interfaccia utente della console Google Cloud. Ciò consente di richiamare direttamente una funzione per assicurarsi che funzioni come previsto. Questo determina l'esecuzione immediata della funzione, anche se è stato eseguito il deployment della funzione per rispondere a un evento specifico.

Nota: le chiamate a funzioni dirette utilizzano il metodo di chiamata. Questo metodo ha una quota limitata che non può essere aumentata. È destinata ai test e non deve essere utilizzata in produzione.

Testa la funzione con Google Cloud CLI

1ª generazione

Per richiamare direttamente una funzione di 1ª generazione utilizzando gcloud CLI, utilizza il comando gcloud functions call e fornisci tutti i dati che la funzione prevede come JSON nell'argomento --data. Ad esempio:

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

dove YOUR_FUNCTION_NAME è il nome della funzione che vuoi eseguire. L'argomento --data viene inviato alla funzione nel seguente modo:

• Per le funzioni HTTP, i dati forniti vengono inviati come corpo di una richiesta POST.
• Per le funzioni in background, i dati vengono passati direttamente come dati dell'evento alla funzione. Per ulteriori informazioni sull'accesso ai dati sugli eventi nelle funzioni in background, consulta Parametri delle funzioni in background.
• Per le funzioni CloudEvent, i dati vengono passati direttamente come dati dell'evento alla funzione. Per ulteriori informazioni sull'accesso ai dati sugli eventi nelle funzioni CloudEvent, consulta Parametri delle funzioni CloudEvent.

2ª generazione

Per richiamare direttamente una funzione di 2ª generazione utilizzando gcloud CLI, utilizza la versione di 2ª generazione del comando gcloud functions call e fornisci tutti i dati che la tua funzione prevede 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 viene eseguito il deployment della funzione

L'argomento --data viene inviato alla funzione nel seguente modo:

• 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 sull'accesso ai dati sugli eventi nelle funzioni CloudEvent, consulta Parametri delle funzioni CloudEvent.

Per saperne di più, consulta la documentazione di gcloud functions call.

Testa la tua funzione con la Google Cloud Console

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

1ª generazione

1. Vai alla pagina Panoramica di Cloud Functions.

2. Fai clic sul nome della funzione che vuoi richiamare.

3. Fai clic sulla scheda Test.

4. Nel campo Configura evento di trigger, inserisci i dati previsti dalla funzione in formato JSON.

5. Fai clic su Testa la funzione.

La risposta della funzione viene visualizzata nel campo Output, mentre i log della singola esecuzione vengono visualizzati nel campo Log.

2ª generazione

1. Vai alla pagina Panoramica di Cloud Functions.

2. Nell'elenco, fai clic sul nome della funzione che vuoi richiamare. Verrà visualizzata la pagina Dettagli funzione.

3. Fai clic sulla scheda Test.

4. Nel campo Configura evento di trigger, inserisci i dati previsti dalla funzione come JSON.

5. Fai clic sui pulsanti + Aggiungi parametro di query e +Aggiungi parametro di intestazione per aggiungere parametri di query e intestazione alla chiamata di funzione in base alle esigenze.

   La console Google Cloud assembla i parametri specificati in un comando gcloud functions call nella finestra di comando di test dell'interfaccia a riga di comando.

6. Seleziona Esegui in Cloud Shell per aprire una finestra di Cloud Shell in cui eseguire il comando.

7. Premi Invio per attivare il comando gcloud functions call quando viene visualizzato nella finestra di Cloud Shell.

Esempio di funzione basata su eventi Cloud Pub/Sub

Questo esempio mostra come richiamare direttamente una funzione basata su eventi di 1ª generazione attivata dagli eventi Cloud Pub/Sub:

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}!")

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

Per richiamare direttamente la funzione, invia un PubsubMessage, che prevede dati codificati in base64, come dati evento:

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'"}'

C#

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

Ruby

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

PHP

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

Questo esempio di interfaccia a riga di comando utilizza la sintassi bash o sh. Funziona negli ambienti Linux e Mac, ma non in Windows.

Puoi anche richiamare la funzione dalla console Google Cloud utilizzando gli stessi dati sugli eventi nel campo Evento di trigger.