Trigger di Firebase Authentication

Beta

Questa funzionalità è coperta Termini dell'offerta pre-GA di Google Cloud Termini di servizio della piattaforma. Le funzionalità pre-GA potrebbero avere supporto limitato e 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 a Cloud Functions (1ª generazione.). Consulta Cloud Functions confronto tra versioni per ulteriori informazioni.

Cloud Functions (2nd gen) al momento non supporta supportare i trigger di Firebase Authentication.

Le funzioni Cloud Functions possono essere attivate da eventi Firebase Authentication nella stessa progetto Google Cloud come 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 viene eliminato un account utente.

Creazione utente

Gli account Firebase attivano gli eventi di creazione utenti per Cloud Functions 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 Cloud Functions non viene attivato quando un utente accede al la prima volta che utilizzi 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, account basato su password definiscono una proprietà email contenente l'indirizzo email dell'utente. uid (che contiene uno User-ID univoco per il progetto) sia 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 in cui hai configurato Firebase Auth. Nella console Google Cloud, è un singolo campo per Tipo di evento, in quanto si presume che il progetto sia uguale a il progetto che contiene la tua 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 \
  --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, deve includere il nome della funzione contenuta nel codice che che vuoi venga eseguito il 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 della Cloud Function di cui esegui il deployment. Può essere il nome di una funzione nel del codice sorgente o una stringa arbitraria. Se FUNCTION_NAME è un stringa arbitraria, devi includere 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 devi utilizzare --entry-point per indicare il nome del una 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 tua funzione e Firebase Authentication.
--runtime RUNTIME	Il nome del runtime che stai utilizzando. Per un elenco completo, vedi Riferimento gcloud.