App verbinden und mit dem Prototyping beginnen

Bevor Sie mit Firebase Local Emulator Suite beginnen, müssen Sie ein Firebase-Projekt erstellt, Ihre Entwicklungsumgebung eingerichtet und Firebase SDKs für Ihre Plattform gemäß den Themen unter Erste Schritte mit Firebase für Ihre Plattform ausgewählt und installiert haben: Apple, Android oder Web.

Prototyping und testen

Das Local Emulator Suite enthält mehrere Produktemulatoren, wie unter Einführung in Firebase Local Emulator Suite beschrieben. Sie können Prototypen erstellen und mit einzelnen Emulatoren sowie Kombinationen von Emulatoren testen, je nachdem, welche Firebase-Produkte Sie in der Produktion verwenden.

In diesem Thema wird der Local Emulator Suite-Workflow vorgestellt. Nehmen wir an, Sie arbeiten an einer App, die eine typische Kombination von Produkten verwendet: eine Firebase-Datenbank und Cloud Functions-Funktionen, die durch Vorgänge in dieser Datenbank ausgelöst werden.

Nachdem Sie Ihr Firebase-Projekt lokal initialisiert haben, umfasst der Entwicklungszyklus mit Local Emulator Suite in der Regel drei Schritte:

1. Funktionen interaktiv mit den Emulatoren und Emulator Suite UI prototypisieren.

2. Wenn Sie einen Datenbankemulator oder den Cloud Functions-Emulator verwenden, müssen Sie Ihre Anwendung einmalig mit den Emulatoren verbinden.

3. Automatisieren Sie Ihre Tests mit den Emulatoren und benutzerdefinierten Skripts.

Firebase-Projekt lokal initialisieren

Installieren Sie die Befehlszeile oder aktualisieren Sie sie auf die aktuelle Version.

curl -sL firebase.tools | bash

Falls noch nicht geschehen, initialisieren Sie das aktuelle Arbeitsverzeichnis als Firebase-Projekt. Folgen Sie dazu den Aufforderungen auf dem Bildschirm, um anzugeben, dass Sie Cloud Functions und entweder Cloud Firestore oder Realtime Database verwenden:

firebase init

Ihr Projektverzeichnis enthält jetzt Firebase-Konfigurationsdateien, eine Firebase Security Rules-Definitionsdatei für die Datenbank, ein functions-Verzeichnis mit Cloud Functions-Code und andere unterstützende Dateien.

Interaktives Prototyping

Local Emulator Suite wurde entwickelt, damit Sie schnell Prototypen für neue Funktionen erstellen können. Die integrierte Benutzeroberfläche der Suite ist eines der nützlichsten Tools für die Prototyperstellung. Das ist ein bisschen so, als würde die Firebase-Konsole lokal ausgeführt.

Mit Emulator Suite UI können Sie das Design einer Datenbank iterieren, verschiedene Datenflüsse mit Cloud Functions ausprobieren, Änderungen an Sicherheitsregeln bewerten, Logs prüfen, um die Leistung Ihrer Back-End-Dienste zu bestätigen, und vieles mehr. Wenn Sie dann von vorn beginnen möchten, löschen Sie einfach Ihre Datenbank und fangen Sie mit einer neuen Designidee an.

All dies ist verfügbar, wenn Sie Local Emulator Suite mit Folgendem starten:

firebase emulators:start

Um einen Prototyp unserer hypothetischen App zu erstellen, richten wir eine einfache Cloud-Funktion ein und testen sie. Mit dieser Funktion werden Texteinträge in einer Datenbank geändert. Außerdem erstellen und füllen wir diese Datenbank in der Emulator Suite UI, um die Funktion auszulösen.

1. Erstellen Sie eine Cloud Functions-Funktion, die durch Datenbankschreibvorgänge ausgelöst wird, indem Sie die Datei functions/index.js in Ihrem Projektverzeichnis bearbeiten. Ersetzen Sie den Inhalt der vorhandenen Datei durch das folgende Snippet. Diese Funktion wartet auf Änderungen an Dokumenten in der Sammlung messages, wandelt den Inhalt des Felds original eines Dokuments in Großbuchstaben um und speichert das Ergebnis im Feld uppercase dieses Dokuments.

  const functions = require('firebase-functions/v1');

  exports.makeUppercase = functions.firestore.document('/messages/{documentId}')
      .onCreate((snap, context) => {
        const original = snap.data().original;
        console.log('Uppercasing', context.params.documentId, original);
        const uppercase = original.toUpperCase();
        return snap.ref.set({uppercase}, {merge: true});
      });
  

2. Starten Sie Local Emulator Suite mit firebase emulators:start. Die Emulatoren für Cloud Functions und die Datenbank werden gestartet und automatisch für die Interoperabilität konfiguriert.
3. Rufen Sie die Benutzeroberfläche in Ihrem Browser unter http://localhost:4000 auf. Port 4000 ist der Standardport für die Benutzeroberfläche. Prüfen Sie jedoch die Terminalnachrichten, die von der Firebase-Befehlszeile ausgegeben werden. Beachten Sie den Status der verfügbaren Emulatoren. In unserem Fall werden die Emulatoren Cloud Functions und Cloud Firestore ausgeführt.
   Hauptseite der Benutzeroberfläche aufrufen
4. Klicken Sie in der Benutzeroberfläche auf dem Tab Firestore > Daten auf Sammlung starten und folgen Sie den Aufforderungen, um ein neues Dokument in einer messages-Sammlung mit dem Feldnamen original und dem Wert test zu erstellen. Dadurch wird unsere Cloud Functions-Funktion ausgelöst. Nach kurzer Zeit wird ein neues uppercase-Feld mit dem String „TEST“ angezeigt.
   Anleitung zum Erstellen einer Sammlung ansehen Updates der Funktion ansehen
5. Prüfen Sie auf dem Tab Firestore > Anfragen die Anfragen, die an Ihre emulierte Datenbank gesendet wurden, einschließlich aller Firebase Security Rules-Auswertungen, die im Rahmen der Erfüllung dieser Anfragen durchgeführt wurden.
6. Prüfen Sie auf dem Tab Logs, ob beim Aktualisieren der Datenbank Fehler aufgetreten sind.

Sie können ganz einfach zwischen Ihrem Cloud Functions-Code und interaktiven Datenbankbearbeitungen wechseln, bis Sie den gewünschten Datenfluss erhalten, ohne den Datenbankzugriffscode in der App zu ändern, Test-Suites neu zu kompilieren und noch einmal auszuführen.

App mit den Emulatoren verbinden

Wenn Sie mit dem interaktiven Prototyping gute Fortschritte gemacht und sich für ein Design entschieden haben, können Sie Ihrer App mit dem entsprechenden SDK Datenbankzugriffscode hinzufügen. Sie verwenden weiterhin den Datenbank-Tab und für Funktionen den Tab Logs in Emulator Suite UI, um zu prüfen, ob sich Ihre Anwendung richtig verhält.

Denken Sie daran, dass die Local Emulator Suite ein lokales Entwicklungstool ist. Schreibvorgänge in Ihre Produktionsdatenbanken lösen keine Funktionen aus, für die Sie lokal Prototypen erstellen.

Wenn Sie Ihre App so umstellen möchten, dass sie in die Datenbank schreibt, müssen Sie Ihre Testklassen oder die In-App-Konfiguration auf den Cloud Firestore-Emulator verweisen.

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
val firestore = Firebase.firestore
firestore.useEmulator("10.0.2.2", 8080)

firestore.firestoreSettings = firestoreSettings {
    isPersistenceEnabled = false
}
EmulatorSuite.kt

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
FirebaseFirestore firestore = FirebaseFirestore.getInstance();
firestore.useEmulator("10.0.2.2", 8080);

FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setPersistenceEnabled(false)
        .build();
firestore.setFirestoreSettings(settings);
EmulatorSuite.java

let settings = Firestore.firestore().settings
settings.host = "127.0.0.1:8080"
settings.cacheSettings = MemoryCacheSettings()
settings.isSSLEnabled = false
Firestore.firestore().settings = settings
ViewController.swift

FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
// Connects to the Firestore Emulator running on port 8080
db.Settings.Host = "127.0.0.1:8080";
db.Settings.SslEnabled = false;

import { getFirestore, connectFirestoreEmulator } from "firebase/firestore";

// firebaseApps previously initialized using initializeApp()
const db = getFirestore();
connectFirestoreEmulator(db, '127.0.0.1', 8080);
fs_emulator_connect.js

// Firebase previously initialized using firebase.initializeApp().
var db = firebase.firestore();
if (location.hostname === "localhost") {
  db.useEmulator("127.0.0.1", 8080);
}
emulator-suite.js

Tests mit benutzerdefinierten Skripts automatisieren

Jetzt zum letzten Schritt des gesamten Workflows. Nachdem Sie einen Prototyp Ihrer Funktion in der App erstellt haben und dieser auf allen Plattformen vielversprechend aussieht, können Sie mit der endgültigen Implementierung und dem Testen beginnen. Für Unittests und CI-Workflows können Sie mit dem Befehl exec in einem einzigen Aufruf Emulatoren starten, skriptbasierte Tests ausführen und Emulatoren herunterfahren:

firebase emulators:exec "./testdir/test.sh"

Einzelne Emulatoren genauer untersuchen

Nachdem Sie nun den grundlegenden clientseitigen Workflow kennengelernt haben, können Sie sich mit den Details zu den einzelnen Emulatoren in der Suite vertraut machen, einschließlich der Verwendung für die serverseitige App-Entwicklung:

• Authentication-Emulator zu Ihren Prototyping-Workflows hinzufügen
• Detaillierte Informationen zu den Funktionen des Realtime Database-Emulators
• Detaillierte Informationen zu den Funktionen des Cloud Storage for Firebase-Emulators
• Detaillierte Informationen zu den Funktionen des Cloud Firestore-Emulators
• App mit dem Cloud Functions-Emulator verbinden
• Firebase Extensions mit dem Extensions-Emulator bewerten und gleichzeitig die Abrechnungskosten minimieren

Nächste Schritte

Lesen Sie sich die oben verlinkten Themen zu bestimmten Emulatoren durch. Gehen Sie anschließend so vor:

• Eine Auswahl an Videos und detaillierte Anleitungen finden Sie in der Playlist mit Schulungen zu Firebase-Emulatoren.
• Erweiterte Anwendungsfälle mit Tests von Sicherheitsregeln und dem Firebase Test SDK: Sicherheitsregeln testen (Cloud Firestore), Sicherheitsregeln testen (Realtime Database) und Sicherheitsregeln testen (Cloud Storage for Firebase).