Firebase Authentication-Trigger

Cloud Functions können durch Ereignisse aus der Firebase-Authentifizierung im selben Cloud-Projekt wie die Funktion ausgelöst werden. Solche Ereignisse sind z. B. das Erstellen oder das Löschen von Nutzern. Sie könnten beispielsweise eine Willkommens-E-Mail an einen Nutzer senden, der gerade ein Konto in Ihrer Anwendung erstellt hat.

Ereignistypen

Als Antwort auf die Ereignisse create und delete von Nutzern kann Firebase Authentication Funktionen auslösen.

Ereignistyp Trigger
providers/firebase.auth/eventTypes/user.create Wird ausgelöst, wenn ein Nutzerkonto erstellt wird
providers/firebase.auth/eventTypes/user.delete Wird ausgelöst, wenn ein Nutzerkonto gelöscht wird

Nutzer erstellen

Firebase-Konten lösen in den folgenden Fällen Nutzererstellungsereignisse für Cloud Functions aus:

  • Ein Nutzer erstellt ein E-Mail-Konto und ein Passwort

  • Ein Nutzer meldet sich zum ersten Mal über einen Anbieter föderierter Identität an

  • Der Entwickler erstellt mithilfe des Firebase Admin SDK ein Konto

  • Ein Nutzer meldet sich zum ersten Mal bei einer neuen anonymen Authentifizierungssitzung an

Nutzer löschen

Sie können auch eine Funktion konfigurieren, die beim Löschen eines Nutzers ausgelöst wird.

Ereignisstruktur

Ereignisdaten werden als UserRecord-Objekt bereitgestellt.

Im Folgenden ist ein Beispiel für ein passwortbasiertes Kontoerstellungsereignis dargestellt:

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

Einige Attribute dieses Objekts werden nur bei Verwendung bestimmter Authentifizierungsmethoden definiert. So definieren beispielsweise passwortbasierte Kontoereignisse ein email-Attribut, das die E-Mail-Adresse des Nutzers enthält. Das Attribut uid, das eine für das Projekt eindeutige Nutzer-ID enthält, ist immer definiert.

Beispielcode

Node.js

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

Funktion bereitstellen

Zum Bereitstellen Ihrer Funktion müssen Sie den Ereignistyp und das Projekt angeben, für das Sie Firebase Authentication konfiguriert haben. In der Cloud Console gibt es ein einzelnes Feld für den Ereignistyp, da angenommen wird, dass das Projekt mit dem Projekt identisch ist, das die Funktion enthält.

In der Befehlszeile müssen Sie jedoch bestimmte Strings verwenden, um diese beiden Parameter anzugeben. Mit dem folgenden gcloud-Befehl wird eine Funktion bereitgestellt, die durch Nutzerereignisse wie create ausgelöst wird:

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 Beschreibung
FUNCTION_NAME Der registrierte Name der Cloud Functions-Funktion, die Sie bereitstellen. Dies kann entweder der Name einer Funktion in Ihrem Quellcode oder ein beliebiger String sein. Wenn FUNCTION_NAME ein beliebiger String ist, müssen Sie das Flag --entry-point einfügen.
--entry-point ENTRY_POINT Der Name einer Funktion oder Klasse in Ihrem Quellcode. Optional, es sei denn, Sie haben FUNCTION_NAME nicht verwendet, um die Funktion in Ihrem Quellcode anzugeben, die während der Bereitstellung ausgeführt werden soll. In diesem Fall müssen Sie mit --entry-point den Namen der ausführbaren Funktion angeben.
--trigger-event NAME Der Name des Ereignistyps, der die Funktion auslöst. In diesem Fall sollte es create oder delete sein, wie oben erläutert.
--trigger-resource NAME Die Projekt-ID (im Beispiel YOUR_PROJECT_ID) für das Projekt, das die Funktion Firebase Authentication enthält.
--runtime RUNTIME Der Name der Laufzeit, die Sie verwenden. Eine vollständige Liste finden Sie in der gcloud-Referenz.