Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Trigger di Firebase Authentication

L'attivazione di Cloud Functions può essere attivata da eventi di Firebase Authentication nello stesso progetto Cloud della funzione. Questi eventi comprendono 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 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 Attivato quando un account utente viene eliminato.

Creazione utente

Gli account Firebase attivano gli 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 Admin di Firebase.

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

Eliminazione utente

Puoi anche configurare una funzione da attivare dopo l'eliminazione dell'utente.

Struttura dell'evento

I dati sugli eventi vengono forniti come oggetto UserRecord.

Di seguito è riportato un evento di creazione di un 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 dell'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 tuo progetto) è sempre definita.

Codice di esempio

Node.js

function/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

function/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#

function/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

function/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

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 solo campo per Tipo di evento in quanto il progetto dovrebbe essere uguale a quello che contiene la funzione.

Tuttavia, devi utilizzare stringhe specifiche per specificare questi due parametri nella riga di comando. 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 funzione Cloud Functions 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 crea o elimina, come indicato in precedenza.
--trigger-resource NAME L'ID del 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, consulta il riferimento gcloud.