Trigger di Firebase Authentication

L'attivazione di Cloud Functions può avvenire da eventi di Firebase Authentication nello stesso progetto Google Cloud della funzione. Questi eventi includono la creazione e l'eliminazione di 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 le funzioni in risposta agli eventi utente create e delete.

Tipo di evento Attivatore
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 eventi di creazione utente 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 a una nuova sessione di autenticazione anonima per la prima volta.

Eliminazione utente

Puoi anche configurare una funzione da attivare al momento dell'eliminazione dell'utente.

Struttura di eventi

I dati sugli eventi vengono forniti come oggetto UserRecord.

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

{
  "email": "me@example.com",
  "metadata": {
      "createdAt": "2018-10-19T19:29:16Z"
  },
  "uid": "XXXXX"
}

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

Codice di esempio

Node.js

Functions/firebase/helloAuth/index.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

Functions/firebase/main.py 
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

Functions/firebase/auth.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

Functions/firebase/auth/src/main/java/functions/FirebaseAuth.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#

Functions/firebase/FirebaseAuth/Function.cs 
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

Functions/firebase/auth/app.rb 
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

Functions/firebase_auth/index.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);
    }
}

Deployment della funzione in corso...

Per eseguire il deployment della funzione, devi specificare il tipo di evento e il progetto per cui hai configurato Firebase Auth. Nella console Google Cloud è presente un singolo campo per Tipo di evento, in quanto si presume che il progetto sia lo stesso del progetto che contiene la tua funzione.

Nella riga di comando, tuttavia, devi utilizzare stringhe specifiche per specificare questi due parametri. Il seguente comando gcloud esegue il deployment di una funzione che viene attivata dagli 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
Argomento Descrizione
FUNCTION_NAME Il nome registrato della Cloud Function 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 tuo codice sorgente. Facoltativo, a meno che non utilizzi 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 di tipo create o delete, come indicato sopra.
--trigger-resource NAME L'ID progetto (in questo esempio, YOUR_PROJECT_ID) del progetto che contiene la funzione e l'autenticazione Firebase.
--runtime RUNTIME Il nome del runtime che stai utilizzando. Per un elenco completo, consulta il riferimento gcloud.