Anwendung mit dem Cloud Functions-Emulator verbinden

Bevor Sie Ihre Anwendung mit dem Cloud Functions-Emulator verbinden, sollten Sie sich mit dem allgemeinen Firebase Local Emulator Suite-Workflow vertraut machen. Außerdem müssen Sie die Local Emulator Suite installieren und konfigurieren und sich die CLI-Befehle ansehen.

Firebase-Projekt auswählen

Die Firebase Local Emulator Suite emuliert Produkte für ein einzelnes Firebase-Projekt.

Wenn Sie das zu verwendende Projekt auswählen möchten, führen Sie vor dem Starten der Emulatoren in der Befehlszeile firebase use in Ihrem Arbeitsverzeichnis aus. Alternativ können Sie das Flag --project an jeden Emulatorbefehl übergeben.

Local Emulator Suite unterstützt die Emulation von echten Firebase-Projekten und Demoprojekten.

Wir empfehlen, nach Möglichkeit Demoprojekte zu verwenden. Die wichtigsten Vorteile:

• Einfachere Einrichtung, da Sie die Emulatoren ausführen können, ohne ein Firebase-Projekt erstellen zu müssen
• Höhere Sicherheit, da bei versehentlichem Aufruf nicht emulierter (Produktions-)Ressourcen durch Ihren Code keine Datenänderung, Nutzung und Abrechnung möglich ist.
• Bessere Offline-Unterstützung, da kein Internetzugriff erforderlich ist, um Ihre SDK-Konfiguration herunterzuladen.

Anwendung für die Kommunikation mit den Emulatoren instrumentieren

Anwendung für aufrufbare Funktionen instrumentieren

Wenn Ihre Prototyp- und Testaktivitäten aufrufbare Backend-Funktionen umfassen, konfigurieren Sie die Interaktion mit dem Cloud Functions for Firebase-Emulator so:

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
val functions = Firebase.functions
functions.useEmulator("10.0.2.2", 5001)
MainActivity.kt

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
FirebaseFunctions functions = FirebaseFunctions.getInstance();
functions.useEmulator("10.0.2.2", 5001);
MainActivity.java

Functions.functions().useEmulator(withHost: "localhost", port: 5001)
ViewController.swift

FirebaseFunctions functions = FirebaseFunctions.DefaultInstance;
// Connects to the Functions Emulator running on port 5001
functions.UseFunctionsEmulator("http://127.0.0.1:5001");

import { getApp } from "firebase/app";
import { getFunctions, connectFunctionsEmulator } from "firebase/functions";

const functions = getFunctions(getApp());
connectFunctionsEmulator(functions, "127.0.0.1", 5001);
fb_functions_emulator_connect.js

firebase.functions().useEmulator("127.0.0.1", 5001);
emulator-suite.js

App für die Emulation von HTTPS-Funktionen instrumentieren

Jede HTTPS-Funktion in Ihrem Code wird vom lokalen Emulator im folgenden URL-Format bereitgestellt:

http://$HOST:$PORT/$PROJECT/$REGION/$NAME

Eine einfache helloWorld-Funktion mit dem Standard-Hostport und der Standardregion würde beispielsweise unter folgender Adresse bereitgestellt:

https://localhost:5001/$PROJECT/us-central1/helloWorld

Anwendung für die Emulation von Aufgabenwarteschlangenfunktionen instrumentieren

Der Emulator richtet automatisch emulierte Aufgabenwarteschlangen basierend auf Triggerdefinitionen ein. Das Admin SDK leitet in die Warteschlange gestellte Anfragen an den Emulator weiter, wenn es erkennt, dass er über die Umgebungsvariable CLOUD_TASKS_EMULATOR_HOST ausgeführt wird.

Das in der Produktion verwendete Dispatch-System ist komplexer als das im Emulator implementierte. Sie sollten daher nicht erwarten, dass das emulierte Verhalten die Produktionsumgebungen genau widerspiegelt. Die Parameter im Emulator geben Obergrenzen für die Rate an, mit der Aufgaben gesendet und wiederholt werden.

Anwendung für die Emulation von durch Hintergrundereignisse ausgelösten Funktionen instrumentieren

Der Cloud Functions-Emulator unterstützt im Hintergrund ausgelöste Funktionen aus den folgenden Quellen:

• Realtime Database-Emulator
• Cloud Firestore-Emulator
• Authentication-Emulator
• Pub/Sub-Emulator
• Emulator für Firebase-Benachrichtigungen

Wenn Sie Hintergrundereignisse auslösen möchten, ändern Sie die Back-End-Ressourcen mit der Emulator Suite UI oder verbinden Sie Ihre App oder Ihren Testcode über das SDK für Ihre Plattform mit den Emulatoren.

Handler für benutzerdefinierte Ereignisse testen, die von Erweiterungen ausgegeben werden

Für Funktionen, die Sie zur Verarbeitung benutzerdefinierter Firebase Extensions-Ereignisse mit Cloud Functions v2 implementieren, wird der Cloud Functions-Emulator mit dem Eventarc-Emulator gekoppelt, um Eventarc-Trigger zu unterstützen.

Wenn Sie benutzerdefinierte Ereignis-Handler für Erweiterungen testen möchten, die Ereignisse ausgeben, müssen Sie die Emulatoren Cloud Functions und Eventarc installieren.

Die Cloud Functions-Laufzeit setzt die Umgebungsvariable EVENTARC_EMULATOR im aktuellen Prozess auf localhost:9299, wenn der Eventarc-Emulator ausgeführt wird. Die Firebase Admin SDKs stellen automatisch eine Verbindung zum Eventarc-Emulator her, wenn die Umgebungsvariable EVENTARC_EMULATOR festgelegt ist. Sie können den Standardport ändern, wie unter Local Emulator Suite konfigurieren beschrieben.

Wenn Umgebungsvariablen richtig konfiguriert sind, sendet Firebase Admin SDK automatisch Ereignisse an den Eventarc-Emulator. Der Eventarc-Emulator ruft wiederum den Cloud Functions-Emulator auf, um alle registrierten Handler auszulösen.

In den Functions-Logs im Emulator Suite UI finden Sie Details zur Handler-Ausführung.

Lokale Testumgebung konfigurieren

Wenn Ihre Funktionen auf einer dotenv-basierten Umgebungskonfiguration basieren, können Sie dieses Verhalten in Ihrer lokalen Testumgebung emulieren.

Wenn Sie einen lokalen Cloud Functions-Emulator verwenden, können Sie Umgebungsvariablen für Ihr Projekt überschreiben, indem Sie eine .env.local-Datei einrichten. Der Inhalt von .env.local hat Vorrang vor .env und der projektspezifischen .env-Datei.

Ein Projekt könnte beispielsweise diese drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

Wenn der Emulator im lokalen Kontext gestartet wird, lädt er die Umgebungsvariablen wie gezeigt:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

Secrets und Anmeldedaten im Cloud Functions-Emulator

Der Cloud Functions-Emulator unterstützt die Verwendung von Secrets zum Speichern und Abrufen vertraulicher Konfigurationsinformationen. Standardmäßig versucht der Emulator, mit den Standardanmeldedaten für Anwendungen auf Ihre Produktions-Secrets zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen möglicherweise nicht auf Secret-Werte zugreifen.

Ähnlich wie bei der Unterstützung von Umgebungsvariablen im Cloud Functions-Emulator können Sie Secret-Werte überschreiben, indem Sie eine .secret.local-Datei einrichten. So können Sie Ihre Funktionen lokal testen, insbesondere wenn Sie keinen Zugriff auf den Secret-Wert haben.

Welche anderen Tools zum Testen von Cloud Functions gibt es?

Der Cloud Functions-Emulator wird durch andere Prototyp- und Testtools ergänzt:

• Die Cloud Functions-Shell, die interaktives, iteratives Prototyping und Entwickeln von Funktionen ermöglicht. Die Shell verwendet den Cloud Functions-Emulator mit einer REPL-ähnlichen Oberfläche für die Entwicklung. Es wird keine Integration mit den Emulatoren Cloud Firestore oder Realtime Database bereitgestellt. In der Shell können Sie Daten simulieren und Funktionsaufrufe ausführen, um die Interaktion mit Produkten zu simulieren, die die Local Emulator Suite derzeit nicht unterstützt: Analytics, Remote Config und Crashlytics.
• Das Firebase Test SDK for Cloud Functions, ein Node.js-Framework mit Mocha für die Funktionsentwicklung. Im Grunde bietet das Cloud Functions Test SDK Automatisierung über die Cloud Functions-Shell.

Weitere Informationen zur Cloud Functions-Shell und zum Cloud Functions Test SDK finden Sie unter Funktionen interaktiv testen und Unittests für Cloud Functions.

Unterschiede zwischen dem Cloud Functions-Emulator und der Produktion

Der Cloud Functions-Emulator ist für die meisten Anwendungsfälle ziemlich nah an der Produktionsumgebung. Wir haben viel Arbeit investiert, um sicherzustellen, dass alles in der Node-Laufzeit so nah wie möglich an der Produktion ist. Der Emulator ahmt jedoch nicht die gesamte containerisierte Produktionsumgebung nach. Ihr Funktionscode wird zwar realistisch ausgeführt, andere Aspekte Ihrer Umgebung (z. B. lokale Dateien, Verhalten nach Funktionsabstürzen usw.) unterscheiden sich jedoch.

Cloud IAM

Die Firebase Emulator Suite versucht nicht, IAM-bezogenes Verhalten für die Ausführung zu replizieren oder zu berücksichtigen. Emulatoren halten sich an die bereitgestellten Firebase-Sicherheitsregeln. In Situationen, in denen normalerweise IAM verwendet wird, z. B. zum Festlegen des Dienstkontos für den Aufruf von Cloud Functions und damit der Berechtigungen, ist der Emulator jedoch nicht konfigurierbar und verwendet das global verfügbare Konto auf Ihrer Entwicklungsmaschine, ähnlich wie beim direkten Ausführen eines lokalen Skripts.

Arbeitsspeicher- und Prozessoreinschränkungen

Der Emulator erzwingt keine Speicher- oder Prozessorbeschränkungen für Ihre Funktionen. Der Emulator unterstützt jedoch das Zeitlimit für Funktionen über das Laufzeitargument timeoutSeconds.

Beachten Sie, dass die Ausführungszeit von Funktionen in der Produktion von der Ausführungszeit im Emulator abweichen kann. Wir empfehlen, nach dem Entwerfen und Testen von Funktionen mit dem Emulator begrenzte Tests in der Produktion auszuführen, um die Ausführungszeiten zu bestätigen.

Unterschiede zwischen lokalen und Produktionsumgebungen berücksichtigen

Da der Emulator auf Ihrem lokalen Computer ausgeführt wird, ist er von Ihrer lokalen Umgebung für Anwendungen und integrierte Programme und Dienstprogramme abhängig.

Beachten Sie, dass sich Ihre lokale Umgebung für die Cloud Functions-Entwicklung von der Google-Produktionsumgebung unterscheiden kann:

• Anwendungen, die Sie lokal installieren, um die Produktionsumgebung zu simulieren (z.B. ImageMagick aus dieser Anleitung), können sich von der Produktion unterscheiden, insbesondere wenn Sie eine andere Version benötigen oder in einer Nicht-Linux-Umgebung entwickeln. Sie können eine eigene Binärkopie des fehlenden Programms zusammen mit Ihrer Funktion bereitstellen.

• Auch integrierte Dienstprogramme (z.B. Shell-Befehle wie ls, mkdir) können sich von den in der Produktion verfügbaren Versionen unterscheiden, insbesondere wenn Sie in einer Nicht-Linux-Umgebung (z.B. macOS) entwickeln. Sie können dieses Problem beheben, indem Sie reine Node-Alternativen zu nativen Befehlen verwenden oder Linux-Binärdateien erstellen, die Sie mit Ihrer Bereitstellung bündeln.

Neuer Versuch

Der Cloud Functions-Emulator unterstützt keine Wiederholung von Funktionen bei Fehlern.

Nächste Schritte

• Eine Auswahl an Videos und detaillierte Anleitungen finden Sie in der Playlist mit Schulungen zu Firebase-Emulatoren.
• Weitere Informationen zum Cloud Functions for Firebase-Emulator finden Sie unter Funktionen lokal ausführen.