Trigger di Firebase Authentication

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

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

Struttura degli eventi

I dati evento vengono forniti come oggetto UserRecord.

Di seguito è riportato un evento di creazione dell'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 account basato su password definiscono una proprietà email contenente l'indirizzo email dell'utente. La proprietà uid (che contiene uno User-ID univoco per il tuo progetto) è sempre definita.

Codice di esempio

Node.js

Functions/firebase/index.js

Visualizza su GitHub Feedback

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

Visualizza su GitHub Feedback

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

Visualizza su GitHub Feedback


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

Visualizza su GitHub Feedback

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

Visualizza su GitHub Feedback

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

Visualizza su GitHub Feedback

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

Visualizza su GitHub Feedback


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. In Cloud Console, è disponibile un unico campo per Tipo di evento, in quanto si presume che il progetto corrisponda a quello contenente la funzione.

Tuttavia, nella riga di comando devi utilizzare stringhe specifiche per specificare tali parametri. Il seguente comando gcloud esegue il deployment di una funzione che viene attivata dagli eventi utente create:

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 esegui 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 tu non abbia utilizzato `FUNCTION_NAME` per specificare la funzione nel codice sorgente da eseguire durante il deployment. In tal 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 quella di creazione o eliminazione, come indicato sopra.
`--trigger-resource NAME`	L'ID progetto (in questo esempio, `YOUR_PROJECT_ID`) per il progetto contenente la funzione e Firebase Authentication.
`--runtime RUNTIME`	Il nome del runtime che stai utilizzando. Per un elenco completo, consulta la documentazione di riferimento di `gcloud`.