Trigger di Firebase Authentication

Beta

Questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini di servizio di Google Cloud. 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 i CloudEvents generati dagli attivatori beta potrebbero cambiare formato nel tempo. Gli attributi Source e Subject, gli attributi di estensione aggiuntivi e il formato dei dati (payload) sono soggetti a modifica.

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

Al momento le funzioni Cloud Run non supportano gli 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 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 agli eventi create e delete degli utenti.

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 da attivare al momento dell'eliminazione dell'utente.

Struttura dell'evento

I dati sugli eventi vengono forniti come oggetto UserRecord.

Di seguito è riportato un esempio di evento di creazione di un account basato su password:

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

Alcune proprietà di questo oggetto vengono definite solo quando si utilizzano determinati 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);
    }
}

Eseguire 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.

Tuttavia, nella riga di comando devi utilizzare stringhe specifiche per specificare questi due parametri. Il seguente comando gcloud esegue il deployment di una funzione attivata da eventi create 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 questa funzione utilizzando FUNCTION_NAME o il flag facoltativo --entry-point, a seconda delle esigenze della tua implementazione. Per ulteriori informazioni, consulta la guida all'implementazione.

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 di una classe nel codice sorgente. Facoltativo, a meno che non abbia utilizzato FUNCTION_NAME per specificare la funzione 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, deve essere uno dei valori create o delete, elencati 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 il riferimento gcloud.