Firebase Authentication-Trigger

Beta

Dieses Feature unterliegt den Bedingungen des Pre-GA-Angebots in den Nutzungsbedingungen von Google Cloud. Pre-GA-Features werden eventuell nur eingeschränkt unterstützt. Änderungen an diesen Features sind möglicherweise nicht mit anderen Pre-GA-Versionen kompatibel. Weitere Informationen finden Sie unter Beschreibungen der Startphase.

Beachten Sie, dass sich die von Beta-Triggern generierten CloudEvents im Laufe der Zeit ändern können. Die Attribute Source und Subject, zusätzliche Erweiterungsattribute und das Datenformat (Nutzlast) können sich ändern.

Hinweis: Dieser Inhalt gilt nur für Cloud Run Functions (1. Generation), früher Cloud Functions (1. Generation).

Cloud Run Functions unterstützt derzeit keine Firebase Authentication-Trigger.

Cloud Run Functions-Funktionen können durch Ereignisse aus Firebase Authentication im selben Google 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 Run Functions-Funktionen 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

Hinweis: Es wird kein Cloud Run Functions-Ereignis ausgelöst, wenn sich ein Nutzer zum ersten Mal über ein benutzerdefiniertes Token anmeldet.

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": "[e-mail]",
  "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

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

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 Google 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 \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event providers/firebase.auth/eventTypes/user.create \
  --trigger-resource YOUR_PROJECT_ID \
  --runtime RUNTIME

Hinweis: Wenn Sie eine Funktion mit der Google Cloud CLI bereitstellen, muss der Befehl den Namen der Funktion enthalten, die in Ihrem Code enthalten ist und die der Befehl deploy ausführen soll. Sie können diese Funktion abhängig von den Anforderungen Ihrer Implementierung entweder mit dem Flag FUNCTION_NAME oder mit dem optionalen Flag --entry-point angeben. Weitere Informationen finden Sie im Bereitstellungsleitfaden.

Argument	Beschreibung
FUNCTION_NAME	Der registrierte Name der Cloud Run Functions-Funktionen, 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.