Activadores de Firebase Authentication

Beta

Esta función está sujeta a las Condiciones de las ofertas de la fase previa a la DG de las Condiciones del Servicio de Google Cloud. Las características de la fase previa a la DG pueden tener asistencia limitada, y es posible que los cambios en las características de la fase previa a la DG no sean compatibles con otras versiones de la fase previa a la DG. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

En particular, ten en cuenta que los CloudEvents generados por los activadores de versión beta pueden cambiar de formato con el tiempo. Los atributos Source y Subject, los atributos de extensión adicionales y el formato de datos (carga útil) están sujetos a cambios.

Nota: Este contenido se aplica solo a funciones de Cloud Run (1ª gen.), antes Cloud Functions (1ª gen.).

Actualmente, Cloud Run Functions no admite activadores de Firebase Authentication.

Cloud Run Functions se pueden activar a través de eventos de Firebase Authentication en el mismo proyecto de Google Cloud que la función. Estos eventos incluyen la creación y eliminación de usuarios. Por ejemplo, puedes enviar un correo electrónico de bienvenida a un usuario que acaba de crear una cuenta en tu app.

Tipos de eventos

Firebase Authentication puede activar funciones en respuesta a los eventos del usuario create y delete.

Tipo de evento	Activador
providers/firebase.auth/eventTypes/user.create	Se activa cuando se crea una cuenta de usuario.
providers/firebase.auth/eventTypes/user.delete	Se activa cuando se borra una cuenta de usuario.

Creación de usuarios

Las cuentas de Firebase activan los eventos de creación de usuarios para Cloud Run Functions en los siguientes casos:

• Un usuario crea una cuenta de correo electrónico y una contraseña.

• Un usuario accede por primera vez con un proveedor de identidad federada.

• El desarrollador crea una cuenta con el SDK de Firebase Admin.

• Un usuario accede a una sesión de autenticación anónima por primera vez.

Nota: Un evento de Cloud Run Functions no se activa cuando un usuario accede por primera vez con un token personalizado.

Eliminación de usuarios

También puedes configurar una función para que se active en el momento de la eliminación de un usuario.

Estructura de eventos

Los datos de eventos se proporcionan como un objeto UserRecord.

A continuación, se muestra un ejemplo de un evento de creación de una cuenta basada en contraseña:

{
  "email": "[e-mail]",
  "metadata": {
      "createdAt": "2018-10-19T19:29:16Z"
  },
  "uid": "XXXXX"
}

Algunas propiedades de este objeto solo se definen cuando se usan ciertos métodos de autenticación. Por ejemplo, los eventos de la cuenta basada en contraseña definen una propiedad email que contiene la dirección de correo electrónico del usuario. La propiedad uid (que contiene un ID de usuario único para el proyecto) siempre está definida.

Código de muestra

Node.js

/**
 * Background Function triggered by a change to a Firebase Auth user object.
 *
 * @param {!Object} event The Cloud Functions event.
 */
exports.helloAuth = event => {
  try {
    console.log(`Function triggered by change to user: ${event.uid}`);
    console.log(`Created at: ${event.metadata.createdAt}`);

    if (event.email) {
      console.log(`Email: ${event.email}`);
    }
  } catch (err) {
    console.error(err);
  }
};

Python

import json

def hello_auth(data, context):
    """Triggered by creation or deletion of a Firebase Auth user object.
    Args:
           data (dict): The event payload.
           context (google.cloud.functions.Context): Metadata for the event.
    """
    print("Function triggered by creation/deletion of user: %s" % data["uid"])
    print("Created at: %s" % data["metadata"]["createdAt"])

    if "email" in data:
        print("Email: %s" % data["email"])

Go

// Package firebase contains a Firestore Cloud Function.
package firebase

import (
	"context"
	"log"
	"time"
)

// AuthEvent is the payload of a Firestore Auth event.
type AuthEvent struct {
	Email    string `json:"email"`
	Metadata struct {
		CreatedAt time.Time `json:"createdAt"`
	} `json:"metadata"`
	UID string `json:"uid"`
}

// HelloAuth is triggered by Firestore Auth events.
func HelloAuth(ctx context.Context, e AuthEvent) error {
	log.Printf("Function triggered by creation or deletion of user: %q", e.UID)
	log.Printf("Created at: %v", e.Metadata.CreatedAt)
	if e.Email != "" {
		log.Printf("Email: %q", e.Email)
	}
	return nil
}

Java

import com.google.cloud.functions.Context;
import com.google.cloud.functions.RawBackgroundFunction;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.logging.Logger;

public class FirebaseAuth implements RawBackgroundFunction {
  private static final Logger logger = Logger.getLogger(FirebaseAuth.class.getName());

  // Use GSON (https://github.com/google/gson) to parse JSON content.
  private static final Gson gson = new Gson();

  @Override
  public void accept(String json, Context context) {
    JsonObject body = gson.fromJson(json, JsonObject.class);

    if (body != null && body.has("uid")) {
      logger.info("Function triggered by change to user: " + body.get("uid").getAsString());
    }

    if (body != null && body.has("metadata")) {
      JsonObject metadata = body.get("metadata").getAsJsonObject();
      logger.info("Created at: " + metadata.get("createdAt").getAsString());
    }

    if (body != null && body.has("email")) {
      logger.info("Email: " + body.get("email").getAsString());
    }
  }
}

C#

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Firebase.Auth.V1;
using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

namespace FirebaseAuth;

public class Function : ICloudEventFunction<AuthEventData>
{
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public Task HandleAsync(CloudEvent cloudEvent, AuthEventData data, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Function triggered by change to user: {uid}", data.Uid);
        if (data.Metadata is UserMetadata metadata)
        {
            _logger.LogInformation("User created at: {created:s}", metadata.CreateTime.ToDateTimeOffset());
        }
        if (!string.IsNullOrEmpty(data.Email))
        {
            _logger.LogInformation("Email: {email}", data.Email);
        }

        // In this example, we don't need to perform any asynchronous operations, so the
        // method doesn't need to be declared async.
        return Task.CompletedTask;
    }
}

Ruby

require "functions_framework"

# Triggered by creation or deletion of a Firebase Auth user object.
FunctionsFramework.cloud_event "hello_auth" do |event|
  # Event-triggered Ruby functions receive a CloudEvents::Event::V1 object.
  # See https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event/V1.html
  # The Firebase event payload can be obtained from the `data` field.
  payload = event.data

  logger.info "Function triggered by creation/deletion of user: #{payload['uid']}"
  logger.info "Created at: #{payload['metadata']['createdAt']}"
  logger.info "Email: #{payload['email']}" if payload.key? "email"
end

PHP

use Google\CloudFunctions\CloudEvent;

function firebaseAuth(CloudEvent $cloudevent)
{
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb');
    $data = $cloudevent->getData();

    fwrite(
        $log,
        'Function triggered by change to user: ' . $data['uid'] . PHP_EOL
    );
    fwrite($log, 'Created at: ' . $data['metadata']['createTime'] . PHP_EOL);

    if (isset($data['email'])) {
        fwrite($log, 'Email: ' . $data['email'] . PHP_EOL);
    }
}

Implementa la función

Si deseas implementar tu función, es necesario que especifiques el tipo de evento y el proyecto para el cual configuraste Firebase Authentication. En la consola de Google Cloud, hay un solo campo para Tipo de evento, ya que se supone que este proyecto es el mismo que contiene tu función.

En la línea de comandos, sin embargo, debes usar strings particulares para especificar estos dos parámetros. El siguiente comando gcloud implementa una función que activan los eventos del usuario create:

gcloud functions deploy FUNCTION_NAME \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event providers/firebase.auth/eventTypes/user.create \
  --trigger-resource YOUR_PROJECT_ID \
  --runtime RUNTIME

Nota: Cuando implementas una función con Google Cloud CLI, el comando debe incluir el nombre de la función contenida en el código que deseas que ejecute el comando deploy. Puedes especificar esa función mediante FUNCTION_NAME o la marca opcional --entry-point, según las necesidades de la implementación. Consulta la guía de implementación para obtener más información.

Argumento	Descripción
FUNCTION_NAME	El nombre registrado de Cloud Run Functions que estás implementando. Puede ser el nombre de una función en tu código fuente o una string arbitraria. Si FUNCTION_NAME es una string arbitraria, debes incluir la marca --entry-point.
--entry-point ENTRY_POINT	El nombre de una función o clase en tu código fuente. Opcional, a menos que no hayas usado FUNCTION_NAME para especificar la función en tu código fuente que se ejecutará durante la implementación. En ese caso, debes usar --entry-point para proporcionar el nombre de la función ejecutable.
--trigger-event NAME	El nombre del tipo de evento que activa la función. En este caso, debería ser un evento de creación o eliminación, como se describe antes.
--trigger-resource NAME	El ID del proyecto (en este ejemplo, YOUR_PROJECT_ID) que contiene tu función y Firebase Authentication.
--runtime RUNTIME	El nombre del entorno de ejecución que usas. Para obtener una lista completa, consulta la gcloudreferencia.