Trigger di Firebase Authentication

Beta

Questa funzionalità è coperta Termini dell'offerta pre-GA di Google Cloud Termini di servizio. Le funzionalità pre-GA potrebbero avere assistenza limitata e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

In particolare, tieni presente che CloudEvents che sono generati dagli attivatori beta potrebbero cambiare formato nel tempo. Source e Subject, gli attributi di estensione aggiuntivi e (payload) sono tutti soggetti a modifiche.

Nota: questi contenuti si applicano solo alle funzioni Cloud Run (1ª gen.), precedentemente Cloud Functions (1ª gen.).

Cloud Run Functions al momento supportare i trigger di Firebase Authentication.

Le funzioni Cloud Run possono essere attivate da eventi di Firebase Authentication nello stesso progetto Google Cloud della funzione. Questi eventi includono la creazione di utenti e l'eliminazione degli utenti. Ad esempio, potresti inviare un'email di benvenuto a un utente che ha appena creato un account nella tua app.

Tipi di evento

Firebase Authentication può attivare funzioni in risposta all'utente create e delete eventi.

Tipo di evento	Trigger
providers/firebase.auth/eventTypes/user.create	Si attiva quando viene creato un account utente.
providers/firebase.auth/eventTypes/user.delete	Si attiva quando un account utente viene eliminato.

Creazione utente

Gli account Firebase attivano gli eventi di creazione utente per le funzioni Cloud Run quando:

• Un utente crea un account email e una password.

• Un utente accede per la prima volta utilizzando un provider di identità federato.

• Lo sviluppatore crea un account utilizzando l'SDK Firebase Admin.

• Un utente accede per la prima volta a una nuova sessione di autenticazione anonima.

Nota: un evento delle funzioni Cloud Run non viene attivato quando un utente accede per la prima volta utilizzando un token personalizzato.

Eliminazione utente

Puoi anche configurare una funzione che si attivi al momento dell'eliminazione dell'utente.

Struttura evento

I dati sugli eventi vengono forniti come oggetto UserRecord.

Viene mostrato un esempio di evento di creazione di account basato su password sotto:

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

Alcune proprietà di questo oggetto vengono definite solo quando si utilizzano metodi di autenticazione. Ad esempio, gli eventi relativi all'account basato su password definiscono una proprietà email contenente l'indirizzo email dell'utente. La proprietà uid (che contiene un ID utente univoco per il progetto) è sempre definita.

Codice di esempio

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"])

Vai

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

esegui il deployment della funzione

Per eseguire il deployment della funzione, devi specificare il tipo di evento e il progetto per il quale hai configurato Firebase Auth. Nella console Google Cloud, c'è un singolo campo per Tipo di evento, poiché si presume che il progetto sia uguale a quello che contiene la funzione.

Nella riga di comando, tuttavia, devi utilizzare stringhe specifiche per specificare parametri. Il seguente comando gcloud esegue il deployment di una funzione che viene attivata per eventi create dell'utente:

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: quando esegui il deployment di una funzione utilizzando Google Cloud CLI, il comando deve includere il nome della funzione contenuta nel codice che vuoi che venga eseguito dal comando deploy. Puoi specificare tale funzione utilizzando FUNCTION_NAME o il flag facoltativo --entry-point, a seconda delle esigenze la tua implementazione. Consulta le guida all'implementazione per ulteriori discussioni.

Argomento	Descrizione
FUNCTION_NAME	Il nome registrato delle funzioni Cloud Run di cui stai eseguendo il deployment. Può essere il nome di una funzione nel codice sorgente o una stringa arbitraria. Se FUNCTION_NAME è una stringa arbitraria, devi includere il flag --entry-point.
--entry-point ENTRY_POINT	Il nome di una funzione o classe nel codice sorgente. Facoltativo, a meno che non hai utilizzato FUNCTION_NAME per specificare nel codice sorgente da eseguire durante il deployment. In questo caso, devi utilizzare --entry-point per fornire il nome della funzione eseguibile.
--trigger-event NAME	Il nome del tipo di evento che attiva la funzione. In questo caso, creare o eliminare, come elencato sopra.
--trigger-resource NAME	L'ID progetto (in questo esempio, YOUR_PROJECT_ID) per il progetto che contiene la funzione e l'autenticazione Firebase.
--runtime RUNTIME	Il nome del runtime in uso. Per un elenco completo, consulta la documentazione di riferimento di gcloud.