O Cloud Functions foi renomeado para Cloud Run functions. Para mais informações, consulte a postagem do blog do Cloud Run functions.

Chamar funções do Cloud Run diretamente

Para dar suporte à iteração e depuração rápida, as funções do Cloud Run fornecem um comando call na interface de linha de comando e a funcionalidade de teste na UI 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.

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

Para invocar diretamente a função usando a gcloud CLI, use o comando gcloud functions call e forneça os dados que a função espera 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, 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:

Acesse a página de visão geral das funções do Cloud Run.
Na lista, clique no nome da função que você quer invocar. Isso leva você à página Detalhes da função.
Clique na guia Testes.
No campo Configurar evento acionador, insira todos os dados esperados pela função como JSON.
Clique em +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.
Selecione Executar no Cloud Shell para abrir uma janela do Cloud Shell e executar este comando.
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 a eventos acionada por eventos do 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);
}

Para invocar a função diretamente, envie um PubsubMessage, que espera dados codificados em base64, como os dados do evento: