Anwendung mit dem Cloud Functions-Emulator verbinden

Bevor Sie Ihre App mit dem Cloud Functions-Emulator verbinden, müssen Sie den allgemeinen Firebase Local Emulator Suite-Workflow verstehen, die Local Emulator Suite installieren und konfigurieren und die CLI-Befehle prüfen.

Firebase-Projekt auswählen

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

Wenn Sie das zu verwendende Projekt auswählen möchten, führen Sie vor dem Starten der Emulatoren 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 Aufrufen nicht emulierter (Produktions-)Ressourcen durch Ihren Code keine Datenänderung, Nutzung und Abrechnung erfolgt.
• Bessere Offlineunterstützung, da Sie nicht auf das Internet zugreifen müssen, um Ihre SDK-Konfiguration herunterzuladen.

App für die Kommunikation mit den Emulatoren instrumentieren

App für aufrufbare Funktionen instrumentieren

Wenn Ihr Prototyp und Ihre 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

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 über den lokalen Emulator mit dem folgenden URL-Format bereitgestellt:

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

Eine einfache helloWorld-Funktion mit dem Standardhostport und der Standardregion wird beispielsweise unter folgender Adresse bereitgestellt:

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

App für die Emulation von Task-Queue-Funktionen 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. Daher sollten Sie nicht erwarten, dass das emulierte Verhalten genau dem in Produktionsumgebungen entspricht. Die Parameter im Emulator legen Obergrenzen für die Rate fest, mit der Aufgaben weitergeleitet und wiederholt werden.

App für die Emulation von durch den Hintergrund ausgelösten Funktionen instrumentieren

Der Cloud Functions-Emulator unterstützt durch den 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 Backend-Ressourcen mit der Emulator Suite UI oder verbinden Sie Ihre App oder Ihren Testcode mit den Emulatoren über das SDK für Ihre Plattform.

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

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

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

Die Cloud Functions-Laufzeit legt die Umgebungsvariable EVENTARC_EMULATOR im aktuellen Prozess auf localhost:9299 fest, 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 die Umgebungsvariablen richtig konfiguriert sind, sendet Firebase Admin SDK automatisch Ereignisse an den Eventarc-Emulator. Der Eventarc-Emulator ruft dann den Cloud Functions-Emulator auf, um alle registrierten Handler auszulösen.

In den Funktionslogs in Emulator Suite UI finden Sie Details zur Ausführung des Handlers.

Lokale Testumgebung konfigurieren

Wenn Ihre Funktionen auf der Umgebungskonfiguration basieren, die auf „dotenv“ basiert, 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, werden die Umgebungsvariablen wie folgt geladen:

  $ 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 Standardanmeldedaten für Anwendungen auf Ihre Produktionsgeheimnisse zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen möglicherweise nicht auf geheime Werte zugreifen.

Ähnlich wie bei der Cloud Functions-Emulatorsupport für Umgebungsvariablen können Sie Geheimniswerte überschreiben, indem Sie eine .secret.local-Datei einrichten. So können Sie Ihre Funktionen ganz einfach lokal testen, insbesondere wenn Sie keinen Zugriff auf den geheimen 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 interaktive, iterative Funktionenprototypen und -entwicklung ermöglicht. Die Shell verwendet den Cloud Functions-Emulator mit einer REPL-ähnlichen Schnittstelle für die Entwicklung. Es gibt keine Integration mit den Emulatoren Cloud Firestore oder Realtime Database. In der Shell können Sie Daten simulieren und Funktionsaufrufe ausführen, um die Interaktion mit Produkten zu simulieren, die von Local Emulator Suite derzeit nicht unterstützt werden: Analytics, Remote Config und Crashlytics.
• Das Firebase Test SDK for Cloud Functions, ein Node.js-Framework mit Mocha für die Funktionsentwicklung. Das Cloud Functions Test SDK bietet also Automatisierung für die Cloud Functions-Shell.

Weitere Informationen zur Cloud Functions-Shell und zum Cloud Functions Test SDK finden Sie unter Funktionen interaktiv testen und Cloud Functions-Funktionen unit-testen.

Unterschiede zwischen dem Cloud Functions-Emulator und der Produktion

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

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 würde, z. B. zum Festlegen des Dienstkontos und damit der Berechtigungen für den Aufruf von Cloud Functions, ist der Emulator jedoch nicht konfigurierbar. Er verwendet das global verfügbare Konto auf Ihrem Entwicklercomputer, ähnlich wie beim direkten Ausführen eines lokalen Skripts.

Arbeitsspeicher- und Prozessor-Einschränkungen

Im Emulator werden keine Speicher- oder Prozessor-Einschränkungen für Ihre Funktionen erzwungen. Der Emulator unterstützt jedoch das Zeitlimit für Funktionen über das Laufzeitargument timeoutSeconds.

Die Ausführungszeit von Funktionen kann sich im Emulator von der in der Produktion unterscheiden. Nachdem Sie Funktionen mit dem Emulator entworfen und getestet haben, empfehlen wir, begrenzte Tests in der Produktion durchzuführen, um die Ausführungszeiten zu bestätigen.

Unterschiede zwischen lokaler Umgebung und Produktionsumgebung berücksichtigen

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

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

• Anwendungen, die Sie lokal installieren, um die Produktionsumgebung zu simulieren (z.B. ImageMagick aus diesem Tutorial), können sich in ihrem Verhalten von der Produktionsumgebung unterscheiden, insbesondere wenn Sie eine andere Version benötigen oder in einer Nicht-Linux-Umgebung entwickeln. Sie können eine eigene binäre Kopie des fehlenden Programms zusammen mit der Bereitstellung 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 Node-only-Alternativen zu nativen Befehlen verwenden oder Linux-Binärdateien erstellen, die in Ihr Deployment eingebunden werden.

Neuer Versuch

Der Cloud Functions-Emulator unterstützt keine Wiederholungsversuche für Funktionen bei Fehlern.

Und jetzt?

• Eine Auswahl an Videos und detaillierten Beispielen finden Sie in der Playlist zum Training von Firebase Emulators.
• Weitere Informationen zum Cloud Functions for Firebase-Emulator finden Sie unter Funktionen lokal ausführen.