Verbinden Sie Ihre App mit dem Cloud Functions Emulator

Bevor Sie Ihre App mit dem Cloud Functions-Emulator verbinden, stellen Sie sicher, dass Sie den gesamten Firebase Local Emulator Suite-Workflow verstehen , dass Sie die Local Emulator Suite installieren und konfigurieren und ihre CLI-Befehle überprüfen.

Wählen Sie ein Firebase-Projekt

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

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

Die Local Emulator Suite unterstützt die Emulation echter Firebase-Projekte und Demoprojekte .

Projekttyp Merkmale Verwendung mit Emulatoren
Real

Ein echtes Firebase-Projekt ist eines, das Sie erstellt und konfiguriert haben (höchstwahrscheinlich über die Firebase-Konsole).

Echte Projekte verfügen über Live-Ressourcen wie Datenbankinstanzen, Speicher-Buckets, Funktionen oder jede andere Ressource, die Sie für dieses Firebase-Projekt einrichten.

Wenn Sie mit echten Firebase-Projekten arbeiten, können Sie Emulatoren für einige oder alle unterstützten Produkte ausführen.

Bei allen Produkten, die Sie nicht emulieren, interagieren Ihre Apps und Ihr Code mit der Live- Ressource (Datenbankinstanz, Speicher-Bucket, Funktion usw.).

Demo

Ein Demo-Firebase-Projekt hat keine echte Firebase-Konfiguration und keine Live-Ressourcen. Der Zugriff auf diese Projekte erfolgt normalerweise über Codelabs oder andere Tutorials.

Projekt-IDs für Demoprojekte haben das Präfix demo- .

Wenn Sie mit Firebase-Demoprojekten arbeiten, interagieren Ihre Apps und Ihr Code nur mit Emulatoren. Wenn Ihre App versucht, mit einer Ressource zu interagieren, für die kein Emulator ausgeführt wird, schlägt dieser Code fehl.

Wir empfehlen Ihnen, nach Möglichkeit Demoprojekte zu verwenden. Zu den Vorteilen gehören:

  • Einfachere Einrichtung, da Sie die Emulatoren ausführen können, ohne jemals ein Firebase-Projekt zu erstellen
  • Höhere Sicherheit, denn wenn Ihr Code versehentlich nicht emulierte (Produktions-)Ressourcen aufruft, besteht keine Chance auf Datenänderung, Nutzung und Abrechnung
  • Bessere Offline-Unterstützung, da zum Herunterladen Ihrer SDK-Konfiguration kein Zugriff auf das Internet erforderlich ist.

Instrumentieren Sie Ihre App, um mit den Emulatoren zu kommunizieren

Instrumentieren Sie Ihre App für aufrufbare Funktionen

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

Kotlin+KTX
// 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)
Java
// 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);
Schnell
Functions.functions().useFunctionsEmulator(origin: "http://127.0.0.1:5001")

Web modular API

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

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

Web namespaced API

firebase.functions().useEmulator("127.0.0.1", 5001);

Instrumentieren Sie Ihre App für die Emulation von HTTPS-Funktionen

Jede HTTPS-Funktion in Ihrem Code wird vom lokalen Emulator unter Verwendung des folgenden URL-Formats bereitgestellt:

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

Beispielsweise würde eine einfache helloWorld Funktion mit dem Standard-Host-Port und der Standard-Host-Region bereitgestellt werden unter:

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

Instrumentieren Sie Ihre App für die Emulation von im Hintergrund ausgelösten Funktionen

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

  • Echtzeit-Datenbankemulator
  • Cloud Firestore-Emulator
  • Authentifizierungsemulator
  • Pub/Sub-Emulator

Um Hintergrundereignisse auszulösen, ändern Sie Back-End-Ressourcen über die Emulator Suite-Benutzeroberfläche oder indem Sie Ihre App oder Ihren Testcode über das SDK für Ihre Plattform mit den Emulatoren verbinden.

Testhandler für benutzerdefinierte Ereignisse, die von Erweiterungen ausgegeben werden

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

Um benutzerdefinierte Ereignishandler für Erweiterungen zu testen, 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 wie unter „Lokale Emulator Suite konfigurieren“ beschrieben ändern.

Wenn Umgebungsvariablen ordnungsgemäß konfiguriert sind, sendet das Firebase Admin SDK automatisch Ereignisse an den Eventarc-Emulator. Der Eventarc-Emulator wiederum ruft den Cloud Functions-Emulator zurück, um alle registrierten Handler auszulösen.

Sie können die Funktionsprotokolle in der Emulator Suite-Benutzeroberfläche auf Details zur Handlerausführung überprüfen.

Konfigurieren Sie eine lokale Testumgebung

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 enthalten, die leicht unterschiedliche Werte für die Entwicklung und lokale Tests enthalten:

.env .env.dev .env.local
PLANET=Erde

PUBLIKUM=Menschen

PUBLIKUM=Entwicklermenschen PUBLIKUM=Lokale Menschen

Beim Start im lokalen Kontext lädt der Emulator die Umgebungsvariablen wie gezeigt:

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

Geheimnisse und Anmeldeinformationen im Cloud Functions-Emulator

Der Cloud Functions-Emulator unterstützt die Verwendung von Geheimnissen zum Speichern und Zugreifen auf vertrauliche Konfigurationsinformationen . Standardmäßig versucht der Emulator, mithilfe der Standardanmeldeinformationen der Anwendung 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-Emulatorunterstützung für Umgebungsvariablen können Sie Secrets-Werte überschreiben, indem Sie eine .secret.local Datei einrichten. Dies erleichtert Ihnen das lokale Testen Ihrer Funktionen, 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 weitere Prototypen- und Testtools ergänzt:

  • Die Cloud Functions-Shell, die interaktives, iteratives Prototyping und Entwicklung von Funktionen ermöglicht. Die Shell verwendet den Cloud Functions-Emulator mit einer Schnittstelle im REPL-Stil für die Entwicklung. Es ist keine Integration mit den Cloud Firestore- oder Realtime Database-Emulatoren vorgesehen. Mit der Shell simulieren Sie Daten und führen Funktionsaufrufe aus, 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 für Cloud Functions, ein Node.js mit Mokka-Framework für die Funktionsentwicklung. Tatsächlich bietet das Cloud Functions Test SDK Automatisierung auf der Cloud Functions-Shell.

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

Wie sich der Cloud Functions-Emulator von der Produktion unterscheidet

Der Cloud Functions-Emulator ist für die meisten Anwendungsfälle ziemlich nah an der Produktionsumgebung. Wir haben umfangreiche Arbeit darauf verwendet, sicherzustellen, dass alles innerhalb der Node-Laufzeitumgebung so produktionsnah wie möglich ist. Allerdings ahmt der Emulator nicht die vollständige containerisierte Produktionsumgebung nach, sodass Ihr Funktionscode zwar realistisch ausgeführt wird, andere Aspekte Ihrer Umgebung (z. B. lokale Dateien, Verhalten nach Funktionsabstürzen usw.) jedoch unterschiedlich sind.

Cloud-IAM

Die Firebase Emulator Suite versucht nicht, IAM-bezogenes Verhalten bei der Ausführung zu reproduzieren oder zu respektieren. Emulatoren halten sich an die bereitgestellten Firebase-Sicherheitsregeln, aber in Situationen, in denen IAM normalerweise verwendet wird, beispielsweise zum Festlegen von Cloud Functions, die ein Dienstkonto und damit Berechtigungen aufrufen, ist der Emulator nicht konfigurierbar und verwendet das global verfügbare Konto auf Ihrem Entwicklercomputer. Ähnlich wie die direkte Ausführung eines lokalen Skripts.

Speicher- und Prozessorbeschränkungen

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

Beachten Sie, dass die Funktionsausführungszeit von der Produktionszeit abweichen kann, wenn Funktionen im Emulator ausgeführt werden. Wir empfehlen, dass Sie, nachdem Sie Funktionen mit dem Emulator entworfen und getestet haben, begrenzte Tests in der Produktion durchführen, um die Ausführungszeiten zu bestätigen.

Planung für Unterschiede in lokalen und Produktionsumgebungen

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

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

  • Anwendungen, die Sie lokal installieren, um die Produktionsumgebung zu simulieren (z. B. ImageMagick aus diesem Tutorial ), können sich im Verhalten von der Produktion unterscheiden, insbesondere wenn Sie andere Versionen benötigen oder in einer Nicht-Linux-Umgebung entwickeln. Erwägen Sie die Bereitstellung Ihrer eigenen Binärkopie des fehlenden Programms neben Ihrer Funktionsbereitstellung.

  • Ebenso können integrierte Dienstprogramme (z. B. Shell-Befehle wie ls , mkdir ) von den in der Produktion verfügbaren Versionen abweichen, insbesondere wenn Sie in einer Nicht-Linux-Umgebung (z. B. macOS) entwickeln. Sie können dieses Problem lösen, indem Sie Node-only-Alternativen zu nativen Befehlen verwenden oder Linux-Binärdateien erstellen, die mit Ihrer Bereitstellung gebündelt werden.

Erneuter Versuch

Der Cloud Functions-Emulator unterstützt keine Wiederholungsversuche von Funktionen bei einem Fehler.

Was als nächstes?