Déclencheurs Firebase Authentication

Bêta

Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions d'utilisation de Google Cloud. Les fonctionnalités avant disponibilité générale sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Plus précisément, notez que les CloudEvents générés par des déclencheurs bêta peuvent changer de format au fil du temps. Les attributs Source et Subject, les attributs d'extension supplémentaires et le format de données (charge utile) sont tous susceptibles d'être modifiés.

Remarque : Ce contenu ne s'applique qu'aux fonctions Cloud Run (1re génération) (anciennement Cloud Functions (1re génération).)

Cloud Run Functions n'est actuellement pas compatible avec les déclencheurs Firebase Authentication.

Les fonctions Cloud Run peuvent ê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 les fonctions Cloud Run 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.

Remarque: Un événement de fonction Cloud Run n'est pas déclenché lorsqu'un utilisateur se connecte pour la première fois à l'aide d'un jeton personnalisé.

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": "[e-mail]",
  "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 \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event providers/firebase.auth/eventTypes/user.create \
  --trigger-resource YOUR_PROJECT_ID \
  --runtime RUNTIME

Remarque : Lorsque vous déployez une fonction à l'aide de Google Cloud CLI, la commande doit inclure le nom de la fonction contenue dans votre code et que la commande deploy doit exécuter. Vous pouvez spécifier cette fonction par le biais de FUNCTION_NAME ou de l'option facultative --entry-point, suivant les besoins de votre implémentation. Pour en savoir plus, consultez le guide de déploiement.

Argument	Description
FUNCTION_NAME	Nom enregistré des fonctions Cloud Run 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.