Diese Seite wurde von der Cloud Translation API übersetzt.

Installieren, konfigurieren und integrieren Sie die Local Emulator Suite

Die Firebase Local Emulator Suite kann für verschiedene Prototypen- und Testumgebungen installiert und konfiguriert werden, von einmaligen Prototyping-Sitzungen bis hin zu kontinuierlichen Integrationsworkflows im Produktionsmaßstab.

Installieren Sie die Local Emulator Suite

Vor der Installation der Emulator Suite benötigen Sie:

Node.js -Version 16.0 oder höher.
Java JDK Version 11 oder höher.

So installieren Sie die Emulator Suite:

Installieren Sie die Firebase-CLI . Wenn Sie die Firebase-CLI noch nicht installiert haben, installieren Sie sie jetzt . Um die Emulator Suite nutzen zu können, benötigen Sie die CLI-Version 8.14.0 oder höher. Mit dem folgenden Befehl können Sie überprüfen, welche Version Sie installiert haben:
```
firebase --version
```
Falls Sie dies noch nicht getan haben, initialisieren Sie das aktuelle Arbeitsverzeichnis als Firebase-Projekt und befolgen Sie die Anweisungen auf dem Bildschirm, um anzugeben, welche Produkte verwendet werden sollen:
```
firebase init
```
Richten Sie die Emulator Suite ein. Dieser Befehl startet einen Konfigurationsassistenten, mit dem Sie die gewünschten Emulatoren auswählen, die entsprechenden Emulator-Binärdateien herunterladen und Emulator-Ports festlegen können, wenn die Standardeinstellungen nicht geeignet sind.
```
firebase init emulators
```

Sobald ein Emulator installiert ist, werden keine Aktualisierungsprüfungen durchgeführt und es finden keine weiteren automatischen Downloads statt, bis Sie Ihre Firebase-CLI-Version aktualisieren.

Konfigurieren Sie die Emulator Suite

Sie können optional die Netzwerkports und den Pfad zu den Sicherheitsregeldefinitionen der Emulatoren in der Datei firebase.json konfigurieren:

Ändern Sie die Emulator-Ports, indem Sie firebase init emulators ausführen oder firebase.json manuell bearbeiten.
Ändern Sie den Pfad zu den Sicherheitsregeldefinitionen, indem Sie firebase.json manuell bearbeiten.

Wenn Sie diese Einstellungen nicht konfigurieren, überwachen die Emulatoren ihre Standardports und die Emulatoren Cloud Firestore, Realtime Database und Cloud Storage für Firebase werden mit offener Datensicherheit ausgeführt.

Befehl	Beschreibung
Init-Emulatoren	Starten Sie einen Emulator-Initialisierungsassistenten. Identifizieren Sie die zu installierenden Emulatoren und geben Sie optional Emulator-Porteinstellungen an. `init emulators` sind zerstörungsfrei; Durch das Akzeptieren der Standardeinstellungen bleibt die aktuelle Emulatorkonfiguration erhalten.

Portkonfiguration

Jeder Emulator bindet an einen anderen Port auf Ihrem Computer mit einem bevorzugten Standardwert.

Emulator	Standardport
Authentifizierung	9099
Benutzeroberfläche der Emulator Suite	4000
Cloud-Funktionen	5001
Eventarc	9299
Echtzeitdatenbank	9000
Cloud Firestore	8080
Cloud-Speicher für Firebase	9199
Firebase-Hosting	5000
Pub/Sub	8085

Projekt-ID-Konfiguration

Je nachdem, wie Sie Emulatoren aufrufen, können Sie mehrere Instanzen eines Emulators mit unterschiedlichen Firebase-Projekt-IDs oder mehrere Emulatorinstanzen für eine bestimmte Projekt-ID ausführen. In solchen Fällen werden Emulatorinstanzen in einer separaten Umgebung ausgeführt.

Im Allgemeinen empfiehlt es sich, eine Projekt-ID für alle Emulatoraufrufe festzulegen, damit die Benutzeroberfläche der Emulator Suite, verschiedene Produktemulatoren und alle laufenden Instanzen eines bestimmten Emulators in allen Fällen korrekt kommunizieren können.

Local Emulator Suite gibt Warnungen aus, wenn mehrere Projekt-IDs in der Umgebung erkannt werden. Sie können dieses Verhalten jedoch außer Kraft setzen, indem Sie den Schlüssel singleProjectMode in Ihrer firebase.json auf false setzen.

Sie können die Projekt-ID-Erklärung(en) auf Nichtübereinstimmungen überprüfen in:

Das Standardprojekt in der Befehlszeile. Standardmäßig wird die Projekt-ID beim Start aus dem mit firebase init oder firebase use ausgewählten Projekt übernommen. Um die Liste der Projekte anzuzeigen (und zu sehen, welches ausgewählt ist), verwenden Sie firebase projects:list .
Regeln für Unit-Tests. Die Projekt-ID wird häufig in Aufrufen der Methoden initializeTestEnvironment oder initializeTestApp der Rules Unit Testing-Bibliothek angegeben.
Das Befehlszeilen-Flag --project . Durch Übergeben des Firebase-CLI-Flags --project wird das Standardprojekt überschrieben. Sie müssen sicherstellen, dass der Wert des Flags bei Unit-Tests und der App-Initialisierung mit der Projekt-ID übereinstimmt.

Überprüfen Sie auch die plattformspezifischen Projekt-ID-Konfigurationen, die Sie beim Konfigurieren Ihrer Apple-Plattformen , Android- und Webprojekte festgelegt haben.

Konfiguration der Sicherheitsregeln

Die Emulatoren übernehmen die Konfiguration der Sicherheitsregeln aus den database , firestore und storage in firebase.json .

{
  // Existing firebase configuration ...
  "database": {
    "rules": "database.rules.json"
  },
  "firestore": {
    "rules": "firestore.rules"
  },
  "storage": {
    "rules": "storage.rules"
  }

  // ...

  // Optional emulator configuration. Default
  // values are used if absent.
  "emulators": {
    "singleProjectMode": false, // do not warn on detection of multiple project IDs
    "firestore": {
      "port": "8080"
    },
    "ui": {
      "enabled": true,      // Default is `true`
      "port": 4000          // If unspecified, see CLI log for selected port
    },
    "auth": {
      "port": "9099"
    },
    "pubsub": {
      "port": "8085"
    }
  }
}

Angeben von Java-Optionen

Der Realtime Database-Emulator, der Cloud Firestore-Emulator und ein Teil des Cloud Storage for Firebase-Emulators basieren auf Java, das mit JVM-Flags über die Umgebungsvariable JAVA_TOOL_OPTIONS angepasst werden kann.

Wenn beispielsweise Fehler im Zusammenhang mit dem Java-Heapspeicher auftreten, können Sie die maximale Größe des Java-Heapspeichers auf 4 GB erhöhen:

export JAVA_TOOL_OPTIONS="-Xmx4g"
firebase emulators:start

Mehrere Flags können in durch Leerzeichen getrennten Anführungszeichen angegeben werden, z. B. JAVA_TOOL_OPTIONS="-Xms2g -Xmx4g" . Die Flags wirken sich nur auf die Java-basierten Komponenten der Emulatoren aus und haben keine Auswirkungen auf andere Teile der Firebase-CLI, wie z. B. die Benutzeroberfläche der Emulator Suite.

Starten Sie Emulatoren

Sie können Emulatoren so starten, dass sie so lange ausgeführt werden, bis sie manuell beendet werden, oder dass sie für die Dauer eines bestimmten Testskripts ausgeführt werden und dann automatisch heruntergefahren werden.

Befehl Beschreibung

Emulatoren:Start

Starten Sie Emulatoren für die in firebase.json konfigurierten Firebase-Produkte. Emulatorprozesse werden weiter ausgeführt, bis sie explizit gestoppt werden. Durch den Aufruf von emulators:start werden die Emulatoren nach ~/.cache/firebase/emulators/ heruntergeladen, sofern sie noch nicht installiert sind.

Flagge	Beschreibung
`--only`	Optional. Beschränken Sie, welche Emulatoren gestartet werden. Geben Sie eine durch Kommas getrennte Liste von Emulatornamen an, die eines oder mehrere von „auth“, „database“, „firestore“, „functions“, „hosting“ oder „pubsub“ angeben.
`--inspect-functions` `debug_port`	Optional. Verwenden Sie es mit dem Cloud Functions-Emulator, um das Breakpoint-Debugging von Funktionen am angegebenen Port (oder am Standardport 9229, wenn das Argument weggelassen wird) zu aktivieren. Beachten Sie, dass der Cloud Functions-Emulator bei Angabe dieses Flags in einen speziellen serialisierten Ausführungsmodus wechselt, in dem Funktionen in einem einzelnen Prozess in sequentieller Reihenfolge (FIFO) ausgeführt werden. Dies vereinfacht das Funktionsdebuggen, obwohl sich das Verhalten von der parallelen Ausführung von Funktionen in der Cloud mit mehreren Prozessen unterscheidet.
`--export-on-exit=`	Optional. Verwendung mit dem Authentifizierungs-, Cloud Firestore-, Realtime Database- oder Cloud Storage for Firebase-Emulator. Weisen Sie den/die Emulator(en) an, beim Herunterfahren Daten in ein Verzeichnis zu exportieren, wie für den Befehl `emulators:export` beschrieben. Das Exportverzeichnis kann mit diesem Flag angegeben werden: `firebase emulators:start --export-on-exit=./saved-data` . Wenn `--import` verwendet wird, ist der Exportpfad standardmäßig derselbe; zum Beispiel: `firebase emulators:start --import=./data-path --export-on-exit` . Übergeben Sie schließlich, falls gewünscht, unterschiedliche Verzeichnispfade an die Flags `--import` und `--export-on-exit` .
`--import=` `import_directory`	Optional. Verwendung mit dem Authentifizierungs-, Cloud Firestore-, Realtime Database- oder Cloud Storage for Firebase-Emulator. Importieren Sie Daten, die mit der Startoption `--export-on-exit` oder dem Befehl `emulators:export` gespeichert wurden, in eine laufende Emulatorinstanz für Authentifizierung, Cloud Firestore, Echtzeitdatenbank oder Cloud Storage für Firebase. Alle derzeit im Emulatorspeicher befindlichen Daten werden überschrieben.

Emulatoren:exec scriptpath

Führen Sie das Skript unter scriptpath aus, nachdem Sie die Emulatoren für die in firebase.json konfigurierten Firebase-Produkte gestartet haben. Emulatorprozesse werden automatisch gestoppt, wenn die Ausführung des Skripts abgeschlossen ist.

Flagge	Beschreibung
`--only`	Optional. Beschränken Sie, welche Emulatoren gestartet werden. Geben Sie eine durch Kommas getrennte Liste von Emulatornamen an, die eines oder mehrere von „Firestore“, „Datenbank“, „Funktionen“, „Hosting“ oder „Pubsub“ angeben.
`--inspect-functions` `debug_port`	Optional. Verwenden Sie es mit dem Cloud Functions-Emulator, um das Breakpoint-Debugging von Funktionen am angegebenen Port (oder am Standardport 9229, wenn das Argument weggelassen wird) zu aktivieren. Beachten Sie, dass der Cloud Functions-Emulator bei Angabe dieses Flags in einen speziellen serialisierten Ausführungsmodus wechselt, in dem Funktionen in einem einzelnen Prozess in sequentieller Reihenfolge (FIFO) ausgeführt werden. Dies vereinfacht das Funktionsdebuggen, obwohl sich das Verhalten von der parallelen Ausführung von Funktionen in der Cloud mit mehreren Prozessen unterscheidet.
`--export-on-exit=`	Optional. Verwendung mit dem Authentifizierungs-, Cloud Firestore-, Realtime Database- oder Cloud Storage for Firebase-Emulator. Weisen Sie den/die Emulator(en) an, beim Herunterfahren Daten in ein Verzeichnis zu exportieren, wie für den Befehl `emulators:export` beschrieben. Das Exportverzeichnis kann mit diesem Flag angegeben werden: `firebase emulators:start --export-on-exit=./saved-data` . Wenn `--import` verwendet wird, ist der Exportpfad standardmäßig derselbe; zum Beispiel: `firebase emulators:start --import=./data-path --export-on-exit` . Übergeben Sie schließlich, falls gewünscht, unterschiedliche Verzeichnispfade an die Flags `--import` und `--export-on-exit` .
`--import=` `import_directory`	Optional. Verwendung mit dem Authentifizierungs-, Cloud Firestore-, Realtime Database- oder Cloud Storage for Firebase-Emulator. Importieren Sie Daten, die mit der Startoption `--export-on-exit` oder dem Befehl `emulators:export` gespeichert wurden, in eine laufende Emulatorinstanz für Authentifizierung, Cloud Firestore, Echtzeitdatenbank oder Cloud Storage für Firebase. Alle derzeit im Emulatorspeicher befindlichen Daten werden überschrieben.
`--ui`	Optional. Führen Sie während der Ausführung die Emulator-Benutzeroberfläche aus.

Die firebase emulators:exec Methode eignet sich im Allgemeinen besser für kontinuierliche Integrationsworkflows.

Emulatordaten exportieren und importieren

Sie können Daten aus den Emulatoren Authentifizierung, Cloud Firestore, Echtzeitdatenbank und Cloud Storage für Firebase exportieren, um sie als gemeinsam nutzbaren, gemeinsamen Basisdatensatz zu verwenden. Diese Datensätze können wie oben beschrieben mit dem Flag --import importiert werden.

Emulatoren:export export_directory

Authentifizierung, Cloud Firestore, Echtzeitdatenbank oder Cloud-Speicher für Firebase-Emulator . Exportieren Sie Daten aus einer laufenden Cloud Firestore-, Realtime Database- oder Cloud Storage for Firebase-Emulatorinstanz. Das angegebene export_directory wird erstellt, sofern es noch nicht vorhanden ist. Wenn das angegebene Verzeichnis vorhanden ist, werden Sie aufgefordert zu bestätigen, dass die vorherigen Exportdaten überschrieben werden sollen. Sie können diese Eingabeaufforderung mit dem Flag --force überspringen. Das Exportverzeichnis enthält eine Datenmanifestdatei, firebase-export-metadata.json .

Sie können die Emulatoren anweisen, Daten beim Herunterfahren automatisch zu exportieren, indem Sie die oben beschriebenen Flags --export-on-exit verwenden.

Integrieren Sie es in Ihr CI-System

Ausführen von Container-Emulator Suite-Images

Die Installation und Konfiguration der Emulator Suite mit Containern in einem typischen CI-Setup ist unkompliziert.

Es sind einige Probleme zu beachten:

JAR-Dateien werden unter ~/.cache/firebase/emulators/ installiert und zwischengespeichert.
- Möglicherweise möchten Sie diesen Pfad zu Ihrer CI-Cache-Konfiguration hinzufügen, um wiederholte Downloads zu vermeiden.
Wenn Sie keine Datei firebase.json in Ihrem Repository haben, müssen Sie dem Befehl emulators:start oder emulators:exec ein Befehlszeilenargument hinzufügen, um anzugeben, welche Emulatoren gestartet werden sollen. Zum Beispiel,
--only functions,firestore .

Generieren Sie ein Authentifizierungstoken (nur Hosting-Emulator)

Wenn Ihre kontinuierlichen Integrationsworkflows auf Firebase Hosting basieren, müssen Sie sich mit einem Token anmelden, um firebase emulators:exec auszuführen. Für die anderen Emulatoren ist keine Anmeldung erforderlich.

Um ein Token zu generieren, führen Sie firebase login:ci in Ihrer lokalen Umgebung aus. Dies sollte nicht über ein CI-System erfolgen. Befolgen Sie die Anweisungen zur Authentifizierung. Sie sollten diesen Schritt nur einmal pro Projekt ausführen müssen, da das Token für alle Builds gültig ist. Das Token sollte wie ein Passwort behandelt werden; Stellen Sie sicher, dass es geheim gehalten wird.

Wenn Ihre CI-Umgebung die Angabe von Umgebungsvariablen ermöglicht, die in den Build-Skripten verwendet werden können, erstellen Sie einfach eine Umgebungsvariable mit dem Namen FIREBASE_TOKEN , wobei der Wert die Zugriffstokenzeichenfolge ist. Die Firebase-CLI übernimmt automatisch die Umgebungsvariable FIREBASE_TOKEN und die Emulatoren werden ordnungsgemäß gestartet.

Als letzten Ausweg können Sie das Token einfach in Ihr Build-Skript einbinden, aber stellen Sie sicher, dass nicht vertrauenswürdige Parteien keinen Zugriff haben. Für diesen hartcodierten Ansatz können Sie --token "YOUR_TOKEN_STRING_HERE" zum Befehl firebase emulators:exec hinzufügen.

Verwenden Sie die Emulator Hub-REST-API

Liste der ausgeführten Emulatoren auf

Um die aktuell ausgeführten Emulatoren aufzulisten, senden Sie eine GET Anfrage an den /emulators Endpunkt des Emulator Hub.

curl localhost:4400/emulators

Das Ergebnis ist ein JSON-Objekt, das alle laufenden Emulatoren und ihre Host-/Port-Konfiguration auflistet, zum Beispiel:

{
  "hub":{
    "name": "hub",
    "host": "localhost",
    "port": 4400
  },
  "functions": {
    "name": "functions",
    "host": "localhost",
    "port": 5001
  }
  "firestore": {
    "name": "firestore",
    "host": "localhost",
    "port": 8080
  }
}

Hintergrundfunktionsauslöser aktivieren/deaktivieren

In manchen Situationen müssen Sie lokale Funktions- und Erweiterungsauslöser vorübergehend deaktivieren. Beispielsweise möchten Sie möglicherweise alle Daten im Cloud Firestore-Emulator löschen, ohne onDelete Funktionen auszulösen, die in den Cloud Functions- oder Extensions-Emulatoren ausgeführt werden.

Um lokale Funktionsauslöser vorübergehend zu deaktivieren, senden Sie eine PUT Anfrage an den Endpunkt /functions/disableBackgroundTriggers des Emulator Hub.

curl -X PUT localhost:4400/functions/disableBackgroundTriggers

Das Ergebnis ist ein JSON-Objekt, das den aktuellen Status detailliert beschreibt.

{
  "enabled": false
}

Um lokale Funktionsauslöser zu aktivieren, nachdem sie deaktiviert wurden, senden Sie eine PUT Anfrage an den Endpunkt /functions/enableBackgroundTriggers des Emulator Hub.

curl -X PUT localhost:4400/functions/enableBackgroundTriggers

Das Ergebnis ist ein JSON-Objekt, das den aktuellen Status detailliert beschreibt.

{
  "enabled": true
}

Emulator-SDK-Integrationen

Die Tabellen in diesem Abschnitt geben an, welche Emulatoren von Client- und Admin-SDKs unterstützt werden. Zukunft bedeutet, dass Emulatorunterstützung geplant, aber noch nicht verfügbar ist.

Verfügbarkeit des Client-SDK

	Android	Apple-Plattformen	Netz	Firebase-Benutzeroberfläche Android	Firebase-Benutzeroberfläche iOS	Firebase-Benutzeroberfläche Netz
Echtzeitdatenbank	19.4.0	7.2.0	8.0.0	6.4.0	Zukunft	N / A
Cloud Firestore	21.6.0	7.2.0	8.0.0	6.4.0	Zukunft	N / A
Authentifizierung	20.0.0	7.0.0	8.0.0	7.0.0	Zukunft	4.7.2
Cloud-Speicher für Firebase	20.0.0	8.0.0	8.4.0	7.0.0	11.0.0	N / A
Cloud-Funktionen	19.1.0	7.2.0	8.0.0	N / A	N / A	N / A
Hosting	N / A	N / A	N / A	N / A	N / A	N / A
Erweiterungen	N / A	N / A	N / A	N / A	N / A	N / A

Verfügbarkeit des Admin-SDK

	Knoten	Java	Python	Gehen
Echtzeitdatenbank	8.6.0	6.10.0	2.18.0	Zukunft
Cloud Firestore	8.0.0	6.10.0	3.0.0	1.0.0
Authentifizierung	9.3.0	7.2.0	5.0.0	4.2.0
Cloud-Speicher für Firebase	9.8.0	Zukunft	Zukunft	Zukunft
Cloud-Funktionen	N / A	N / A	N / A	N / A
Hosting	N / A	N / A	N / A	N / A
Erweiterungen	N / A	N / A	N / A	N / A