Anwendung mit dem Cloud Functions-Emulator verbinden

Bevor Sie Ihre App mit dem Cloud Functions Emulator verbinden, sollten Sie sich mit dem allgemeinen Firebase Local Emulator Suite Workflow vertraut machen, die Local Emulator Suite installieren und konfigurieren und die zugehörigen CLI-Befehle prüfen.

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 CLI im Arbeitsverzeichnis firebase use aus. Alternativ können Sie das Flag an jeden Emulator Befehl übergeben.--project

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

Wir empfehlen, Demoprojekte nach Möglichkeit zu verwenden. Dies sind 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 von nicht emulierten (Produktions-)Ressourcen durch Ihren Code keine Datenänderungen, Nutzung und Abrechnung erfolgen
• 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 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

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 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 URL bereitgestellt:

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

App für die Emulation von Task Queue-Funktionen instrumentieren

Der Emulator richtet automatisch emulierte Task Queues 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 Produktionsumgebungen genau widerspiegelt. Die Parameter im Emulator legen Obergrenzen für die Rate fest, mit der Aufgaben gesendet und wiederholt werden.

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

Der Cloud Functions Emulator unterstützt durch Hintergrundereignisse ausgelöste Funktionen aus den folgenden Quellen:

• Realtime Database Emulator
• Cloud Firestore Emulator
• Authentication Emulator
• Pub/Sub-Emulator
• Firebase Alerts-Emulator

Wenn Sie Hintergrundereignisse auslösen möchten, ändern Sie Backend-Ressourcen über die 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 Firebase Extensions benutzerdefinierter Ereignisse mit Cloud Functions v2 implementieren, wird der Cloud Functions Emulator mit dem Eventarc-Emulator kombiniert, um Eventarc-Trigger zu unterstützen.

Wenn Sie benutzerdefinierte Ereignishandler 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 EVENTARC_EMULATOR Umgebung variable 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 Konfigurieren Local Emulator Suite beschrieben ändern.

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

In den Funktionslogs auf der Emulator Suite UI finden Sie Details zur Handler-Ausführung.

Lokale Testumgebung konfigurieren

Wenn Ihre Funktionen auf der 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 Umgebung variablen 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 kann 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 Zugreifen auf vertrauliche Konfigurationsinformationen. Standardmäßig versucht der Emulator, mit den standardmäßigen Anmeldedaten der Anwendung auf Ihre Produktions-Secrets zuzugreifen. In bestimmten Situationen wie CI-Umgebungen kann der Emulator aufgrund von Berechtigungsbeschrä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 ganz einfach lokal testen, insbesondere wenn Sie keinen Zugriff auf den Secret-Wert haben.

Welche weiteren Tools zum Testen von Cloud Functions gibt es?

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

• Die Cloud Functions-Shell ermöglicht die interaktive, iterative Prototyperstellung und Entwicklung von Funktionen. Die Shell verwendet den Cloud Functions-Emulator mit einer REPL-ähnlichen Oberfläche für die Entwicklung. Es ist keine Integration mit den Cloud Firestore oder Realtime Database Emulatoren verfügbar. Mit 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 ist ein Node.js-Framework mit Mocha für die Funktionsentwicklung. Das Cloud Functions Test SDK bietet also eine 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 Unit-Tests von Cloud Functions.

Unterschiede zwischen dem Cloud Functions Emulator und der Produktion

Der Cloud Functions Emulator ähnelt in den meisten Anwendungsfällen 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 vollständige containerisierte Produktionsumgebung nach. Während der Code Ihrer Funktion 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. um das aufrufende Dienstkonto für Cloud Functions und damit Berechtigungen festzulegen, ist der Emulator jedoch nicht konfigurierbar und verwendet das global verfügbare Konto auf Ihrem Entwicklercomputer. Das ist ähnlich wie beim direkten Ausführen eines lokalen Skripts.

Arbeitsspeicher- und Prozessorbeschränkungen

Der Emulator erzwingt keine Arbeitsspeicher- oder Prozessorbeschränkungen für Ihre Funktionen. Er unterstützt jedoch das Timeout von Funktionen über das Laufzeitargument timeoutSeconds.

Die Ausführungszeit von Funktionen kann sich von der Produktionsumgebung unterscheiden, wenn Funktionen im Emulator ausgeführt werden. 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 planen

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 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 im Verhalten 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äre Kopie des fehlenden Programms zusammen mit der Bereitstellung Ihrer Funktion bereitstellen.

• Ähnlich können sich integrierte Dienstprogramme (z.B. Shell-Befehle wie ls, mkdir) 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 Alternativen zu nativen Befehlen verwenden, die nur Node verwenden, oder indem Sie Linux-Binärdateien erstellen, die Sie mit Ihrer Bereitstellung bündeln.

Neuer Versuch

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

Nächste Schritte

• 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.