Catch up on highlights from Firebase at Google I/O 2023. Learn more

Verbinden Sie Ihre App mit dem Cloud Functions-Emulator

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

Wählen Sie ein Firebase-Projekt aus

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

Um das zu verwendende Projekt auszuwählen, bevor Sie die Emulatoren starten, führen Sie in der Befehlszeilenschnittstelle firebase use in Ihrem Arbeitsverzeichnis aus. Oder Sie können das Flag --project an jeden Emulatorbefehl übergeben.

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

Projekttyp Merkmale Verwenden Sie mit Emulatoren
Real

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

Echte Projekte haben Live-Ressourcen wie Datenbankinstanzen, Speicher-Buckets, Funktionen oder andere Ressourcen, die Sie für dieses Firebase-Projekt eingerichtet haben.

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. Auf diese Projekte wird normalerweise über Codelabs oder andere Tutorials zugegriffen.

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

 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, möglichst 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
  • Besserer Offline-Support, da Sie nicht auf das Internet zugreifen müssen, um Ihre SDK-Konfiguration herunterzuladen.

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 Back-End-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)
MainActivity.kt
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);
MainActivity.java
Schnell
Functions.functions().useEmulator(withHost: "localhost", port: 5001)
ViewController.swift

Web version 9

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

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

Web version 8

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

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 standardmäßigen Host-Port und der standardmäßigen Region bereitgestellt werden unter:

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

Instrumentieren Sie Ihre App für die Emulation von Funktionen, die vom Hintergrund ausgelöst werden

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

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

Ändern Sie zum Auslösen von Hintergrundereignissen Backend-Ressourcen mithilfe der Benutzeroberfläche der Emulator Suite oder indem Sie Ihre App oder Ihren Testcode mithilfe des 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 Ereignisse von Firebase Extensions 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 richtig konfiguriert sind, sendet das 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.

Sie können die Funktionsprotokolle in der Benutzeroberfläche der Emulator Suite auf Details zur Handler-Ausfü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. Inhalte von .env.local haben Vorrang vor .env und der projektspezifischen .env Datei.

Ein Projekt könnte beispielsweise diese drei Dateien enthalten, die leicht unterschiedliche Werte für 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 Anmeldedaten 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, mit den Standardanmeldeinformationen der Anwendung auf Ihre Produktionsgeheimnisse zuzugreifen. In bestimmten Situationen wie CI-Umgebungen kann der Emulator aufgrund von Berechtigungsbeschränkungen möglicherweise nicht auf geheime Werte zugreifen.

Ähnlich wie bei der Cloud Functions-Emulatorunterstützung für Umgebungsvariablen können Sie geheime Werte überschreiben, indem Sie eine .secret.local Datei einrichten. Dies macht es Ihnen leicht, Ihre Funktionen lokal zu 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 weitere Prototypen- und Testwerkzeuge ergänzt:

  • Die Cloud Functions-Shell, die interaktives, iteratives Funktionsprototyping und -entwicklung ermöglicht. Die Shell verwendet den Cloud Functions-Emulator mit einer Schnittstelle im REPL-Stil für die Entwicklung. Es wird keine Integration mit den Cloud Firestore- oder Realtime Database-Emulatoren bereitgestellt. Mithilfe der Shell simulieren Sie Daten und führen Funktionsaufrufe durch, 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-Funktionen, ein Node.js mit Mocha-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 Interaktives Testen von Funktionen und Komponententests 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 viel Arbeit investiert, um sicherzustellen, dass alles innerhalb der Node-Laufzeit so nah wie möglich an der Produktion ist. Der Emulator ahmt jedoch nicht die vollständige containerisierte Produktionsumgebung nach, sodass Ihr Funktionscode zwar realistisch ausgeführt wird, andere Aspekte Ihrer Umgebung (dh lokale Dateien, Verhalten nach Funktionsabstürzen usw.) jedoch abweichen.

Cloud-IAM

Die Firebase Emulator Suite versucht nicht, IAM-bezogenes Verhalten für die Ausführung zu replizieren oder zu respektieren. Emulatoren halten sich an die bereitgestellten Firebase-Sicherheitsregeln, aber in Situationen, in denen IAM normalerweise verwendet würde, z. B. um Cloud-Funktionen zum Aufrufen von Dienstkonten und damit Berechtigungen festzulegen, ist der Emulator nicht konfigurierbar und verwendet das global verfügbare Konto auf Ihrem Entwicklercomputer. ähnlich wie beim direkten Ausführen 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 Ausführungszeit der Funktion von der Produktion abweichen kann, wenn Funktionen im Emulator ausgeführt werden. Wir empfehlen, dass Sie nach dem Entwerfen und Testen von Funktionen mit dem Emulator begrenzte Tests in der Produktion ausfü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, hängt er von Ihrer lokalen Umgebung für Anwendungen und integrierte Programme und Dienstprogramme ab.

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 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ären Kopie des fehlenden Programms neben Ihrer Funktionsbereitstellung.

  • Ebenso 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 umgehen, indem Sie reine Node-Alternativen zu nativen Befehlen verwenden oder Linux-Binärdateien erstellen, die mit Ihrer Bereitstellung gebündelt werden.

Wiederholen

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

Was als nächstes?