Llama Cloud Functions directamente

Para admitir iteraciones y depuraciones rápidas, Cloud Functions proporciona un comando call en la interfaz de línea de comandos y la funcionalidad de prueba en la IU de Cloud Console. Esto te permite invocar directamente una función para asegurarte de que se comporta como se esperaba. Esto hace que la función se ejecute de inmediato, incluso si se implementó para responder a un evento específico.

Usa la interfaz de línea de comandos de gcloud

Para invocar directamente una función con la herramienta de gcloud, usa el comando gcloud functions call y proporciona los datos que tu función espera como JSON en el argumento --data. Por ejemplo:

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

donde YOUR_FUNCTION_NAME es el nombre de la función que quieres ejecutar. El argumento --data se envía a tu función como se muestra a continuación:

  • Para las funciones de HTTP, los datos que suministras se envían como el cuerpo de una solicitud POST.
  • Para las funciones en segundo plano, los datos se pasan directamente a tu función como los datos del evento. Para obtener más información sobre cómo acceder a los datos de eventos en funciones en segundo plano, consulta los parámetros de las funciones en segundo plano.

Usa GCP Console

Para invocar directamente una función desde Cloud Console, sigue estos pasos:

  1. Ve a la página Descripción general de Cloud Functions.

  2. En la lista, haz clic en el nombre de la función que quieres invocar.

    Esta acción te lleva a la página Detalles de la función.

  3. Haz clic en la pestaña Prueba.

  4. En el campo Evento de activación, ingresa cualquier dato que tu función espere como archivo JSON.

  5. Haz clic en Probar la función.

La respuesta de tu función aparece en el campo Resultado y los registros de la ejecución individual aparecen en el campo Registros.

Ejemplo de función en segundo plano de Cloud Pub/Sub

En este ejemplo, se muestra cómo invocar directamente una función en segundo plano activada por eventos de 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 `data` field contains the PubsubMessage message. The
         `attributes` field will contain custom attributes if there are any.
         context (google.cloud.functions.Context): The Cloud Functions event
         metadata. The `event_id` field contains the Pub/Sub message ID. The
         `timestamp` field contains the publish time.
    """
    import base64

    print("""This Function was triggered by messageId {} published at {}
    """.format(context.event_id, context.timestamp))

    if 'data' in event:
        name = base64.b64decode(event['data']).decode('utf-8')
    else:
        name = 'World'
    print('Hello {}!'.format(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.
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

Para invocar directamente una función, es necesario que envíes un PubsubMessage, que espera datos codificados en Base 64 como los datos del 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'"}'

También puedes invocar la función desde la IU de Cloud Console: simplemente usa los mismos datos de eventos en el campo Evento de activación.