Déclencheurs Firebase Authentication

Les fonctions Cloud Functions peut être déclenchées par des événements issus de Firebase Authentication dans le même projet Google Cloud contenant la fonction. Ces événements incluent la création et la suppression d'utilisateurs. Par exemple, vous pouvez envoyer un e-mail de bienvenue à un utilisateur qui vient de créer un compte dans votre application.

Types d'événement

Firebase Authentication peut déclencher des fonctions en réponse aux événements utilisateur create et delete.

Type d'événement Déclencheur
providers/firebase.auth/eventTypes/user.create Déclenché lorsqu'un compte d'utilisateur est créé.
providers/firebase.auth/eventTypes/user.delete Déclenché lorsqu'un compte d'utilisateur est supprimé.

Création de compte utilisateur

Les comptes Firebase déclenchent des événements de création d'utilisateurs pour Cloud Functions dans les cas suivants :

  • Un utilisateur crée un compte de messagerie et un mot de passe.

  • Un utilisateur se connecte pour la première fois à l'aide d'un fournisseur d'identité fédéré.

  • Le développeur crée un compte à l'aide du SDK Admin Firebase.

  • Un utilisateur se connecte à une nouvelle session d'authentification anonyme pour la première fois.

Suppression de compte utilisateur

Vous pouvez également configurer une fonction qui est déclenchée lors de la suppression de l'utilisateur.

Structure de l'événement

Les données d'événement sont fournies en tant qu'objet UserRecord.

Vous trouverez ci-dessous un exemple d'événement de création de compte basé sur un mot de passe :

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

Certaines propriétés de cet objet ne sont définies que lorsque vous utilisez certaines méthodes d'authentification. Par exemple, les événements de compte basé sur un mot de passe définissent une propriété email contenant l'adresse e-mail de l'utilisateur. La propriété uid (qui contient un ID utilisateur propre à votre projet) est toujours définie.

Exemple de code

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"])

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 

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);
    }
}

Déployer votre fonction

Pour déployer votre fonction, vous devez spécifier le type d'événement et le projet pour lesquels Firebase Auth est configuré. La console Google Cloud contient un seul champ Type d'événement, car le projet est supposé être le même que celui qui contient votre fonction.

Sur la ligne de commande, vous devez cependant utiliser des chaînes particulières pour spécifier ces deux paramètres. La commande gcloud suivante déploie une fonction qui est déclenchée par les événements utilisateur 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
Argument Description
FUNCTION_NAME Nom enregistré de la fonction Cloud que vous déployez. Il peut s'agir du nom d'une fonction dans votre code source ou d'une chaîne arbitraire. Si FUNCTION_NAME est une chaîne arbitraire, vous devez alors inclure l'option --entry-point.
--entry-point ENTRY_POINT Nom d'une fonction ou d'une classe dans votre code source. Ce paramètre est facultatif, sauf si vous n'avez pas utilisé FUNCTION_NAME pour spécifier quelle fonction de votre code source exécuter lors du déploiement. Dans ce cas, vous devez utiliser --entry-point pour fournir le nom de la fonction exécutable.
--trigger-event NAME Nom du type d'événement qui déclenche la fonction. Dans ce cas, il doit s'agir de l'événement de création ou de suppression, comme indiqué ci-dessus.
--trigger-resource NAME ID du projet (dans cet exemple, YOUR_PROJECT_ID) qui héberge votre fonction et Firebase Authentication.
--runtime RUNTIME Nom de l'environnement d'exécution que vous utilisez. Pour obtenir une liste complète, consultez la documentation de référence sur gcloud.