Chamar o Cloud Functions diretamente

Para dar suporte à iteração e depuração rápida, o Cloud Functions fornece um comando call na interface da linha de comando e a funcionalidade de teste na IU do console do Google Cloud. Isso permite invocar diretamente uma função para garantir que ela esteja se comportando conforme o esperado. Isso faz a função ser executada imediatamente, mesmo que possa ter sido implantada para responder a um evento específico.

Observação: as invocações de função diretas usam o método de chamada. Este método tem uma cota limitada que não pode ser aumentada. Ele é destinado a testes e não deve ser usado na produção.

Testar a função com a CLI do Google Cloud

Primeira geração

Para invocar diretamente uma função de 1ª geração usando a CLI gcloud, use o comando gcloud functions call e forneça todos os dados esperados pela função como JSON no argumento --data. Exemplo:

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

em que YOUR_FUNCTION_NAME é o nome da função que você quer executar. O argumento --data é enviado para a função da seguinte maneira:

• Para funções HTTP, os dados fornecidos são enviados como o corpo de uma solicitação POST.
• Para funções em segundo plano, os dados são passados diretamente como os dados do evento para a função. Para mais informações sobre como acessar dados do evento nas funções em segundo plano, consulte Parâmetros da função em segundo plano.
• Para funções do CloudEvent, os dados são transmitidos diretamente como os dados do evento para a função. Para mais informações sobre como acessar dados do evento nas funções do CloudEvent, consulte Parâmetros de função do CloudEvent.

Segunda geração

Para invocar diretamente uma função de 2ª geração usando a CLI gcloud, use a versão de 2ª geração do comando gcloud functions call e forneça todos os dados esperados pela função como JSON no argumento --data. Exemplo:

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

Substitua:

• YOUR_FUNCTION_NAME: o nome da função que você está testando.
• REGION: a região do Google Cloud em que a função está implantada

O argumento --data é enviado para a função da seguinte maneira:

• Para funções HTTP, os dados fornecidos são enviados como o corpo de uma solicitação POST.
• Para funções do CloudEvent, os dados são transmitidos diretamente como os dados do evento para a função. Para mais informações sobre como acessar dados do evento nas funções do CloudEvent, consulte Parâmetros de função do CloudEvent.

Para mais informações, consulte a documentação gcloud functions call.

Testar a função com o Console do Google Cloud

Para invocar diretamente uma função pelo console do Google Cloud, siga estes passos:

Primeira geração

1. Acessar a página Visão geral do Cloud Functions.

2. Clique no nome da função que você quer invocar.

3. Clique na guia Testes.

4. No campo Configurar evento acionador, insira todos os dados esperados pela função como JSON.

5. Clique em Testar a função.

A resposta da função é exibida no campo Saída, e os registros da execução individual aparecem no campo Registros.

Segunda geração

1. Acessar a página Visão geral do Cloud Functions.

2. Na lista, clique no nome da função que você quer invocar. Isso leva você à página Detalhes da função.

3. Clique na guia Testes.

4. No campo Configurar evento acionador, insira todos os dados esperados pela função como JSON.

5. Clique nos botões +Adicionar parâmetro de consulta e +Adicionar parâmetro de cabeçalho para adicionar parâmetros de consulta e cabeçalho à chamada de função conforme necessário.

   O console do Google Cloud monta os parâmetros que você especifica em um comando gcloud functions call na janela comando de teste da CLI.

6. Selecione Executar no Cloud Shell para abrir uma janela do Cloud Shell e executar este comando.

7. Pressione Enter para acionar o comando gcloud functions call depois que ele aparecer na janela do Cloud Shell.

Exemplo de função orientada a eventos do Cloud Pub/Sub

Este exemplo mostra como invocar diretamente uma função orientada por eventos de 1ª geração acionada por eventos do 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);
}

Para invocar a função diretamente, envie um PubsubMessage, que espera dados codificados em base64, como os dados do 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'"}'

Este exemplo da CLI usa a sintaxe bash ou sh. Ele funciona em ambientes Linux e Mac, mas não no Windows.

Também é possível invocar a função do console do Google Cloud usando os mesmos dados de evento no campo Evento acionador.