Ich stimme zu, dass es großartig wäre, bei der Initialisierung einen Datenbank-"Schnappschuss" zu laden. Ich führe derzeit die Firestore- und Funktionsemulatoren lokal für die Entwicklung aus, aber wenn ich die Datenbank mit Testdaten ausfülle, werden eine Reihe von Firestore-Funktionstriggern ausgeführt. Dies ist ziemlich unerwünscht, gibt es also Pläne für eine Funktion, die beim Laden der Anfangsdaten oder noch besser, Firestore-Datenpersistenz auf die Festplatte hilft?

Vielen Dank, dass Sie den Punkt angesprochen haben, dass Sie Daten ohne Funktionen aussäen möchten
Brennen. Als Notlösung könnten wir auf jeden Fall einen Weg zum "Umdrehen" implementieren
off"-Funktionen werden mit einem speziellen Aufruf ausgelöst, während Sie Daten laden
kann auch für bestimmte Tests nützlich sein. Würdest du das benutzen?

Aber langfristig brauchen wir Import/Export.

Am Sa., 12. Okt. 2019, 11:54 Uhr schrieb Wyatt Ades [email protected] :

Ich stimme zu, dass es großartig wäre, einen Datenbank-"Schnappschuss" zu laden
Initialisierung. Ich betreibe derzeit die Firestore- und Funktionsemulatoren
lokal für die Entwicklung, aber wenn ich die DB mit Testdaten setze, eine Menge
der Firestore-Funktionstrigger werden ausgeführt. Das ist ziemlich unerwünscht, also
gibt es Pläne für ein Feature, das beim Laden der Anfangsdaten hilft oder,
noch besser, Firestore-Datenpersistenz auf Festplatte?

—
Sie erhalten dies, weil Sie diesen Thread abonniert haben.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/firebase/firebase-tools/issues/1167?email_source=notifications&email_token=ACATB2VEE7BBI75HECFTE23QOIMOLA5CNFSM4G5NG5X2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXZJKTDN5
oder abmelden
https://github.com/notifications/unsubscribe-auth/ACATB2WHUTO43JISN54J4U3QOIMOLANCNFSM4G5NG5XQ
.

Ja, das wäre jetzt eine gute Lösung, danke!

Es gibt also noch keine Meilensteine ​​dafür? Aber eines mag ich jetzt an diesem Team hier, es scheint aktiver und reaktionsschneller zu sein.

können Jungs bitte Realtime-DB auch im Rahmen dafür zusammen mit Firestore-DB hinzufügen.

@anantanandgupta noch keine Meilensteine, aber ja, wir versuchen wirklich offen über sprechen ! Und ich habe den Datenbank-Emulator hinzugefügt, um auch im Geltungsbereich zu sein. Bei Database ist das Problem einfacher (JSON-Format), aber wir müssen Ihnen trotzdem helfen, die Cloud Functions-Funktionen zu "pausieren".

Ich weiß, dass ich in guten Händen bin. Aber um die Kritik zu sagen, ich habe diese riesige Plattform komplett um Firebase herum entwickelt und alle waren dagegen, aber mit meinen Bemühungen habe ich bis jetzt bewiesen, dass meine Entscheidung, Firebase als Technologie zu verwenden, nicht falsch war. An diesem Punkt ist es so groß geworden, dass es unmöglich geworden ist, an mehreren Funktionen von mehreren Entwicklern mit einer gemeinsamen, in der Cloud gehosteten Datenbank zu arbeiten. Wenn also jeder von uns an einer lokalen Kopie der Datenbank arbeiten kann, wird es viel einfacher und effizienter.

Die Möglichkeit, Daten in den Firestore-Emulator zu importieren (dh mit "Seed"-Daten zu initialisieren) sollte mit der nächsten Version eingestellt werden. Es wird zunächst etwas manuell sein, wir werden in späteren Versionen bessere Tools hinzufügen.

Untersuchen Sie, was für den Realtime Database-Emulator erforderlich wäre.

@ryanpbrewster Gibt es eine Dokumentation zum Einrichten von "Seed"

@SamyPesse dies wurde im Emulator-JAR selbst implementiert (wie @ryanpbrewster sagte), aber wir haben nicht wirklich eine API über firebase-tools bereitgestellt , um den Import

Würde es Ihnen etwas ausmachen, uns mitzuteilen, wie dies Ihrer Meinung nach funktionieren würde? Bevorzugen Sie ein Flag im Befehl firebase , ein Feld in firebase.json oder etwas anderes?

Das Importieren und Exportieren von Daten ist derzeit implementiert, aber wir haben noch nicht ganz herausgefunden, wie man diese Funktionen einfach nutzen kann. Denken Sie also daran, dass wir wissen, dass diese Anweisungen grob sind, und wir sind offen für Ideen, wie Sie dies verbessern können:

Holen Sie sich einen Export

Sie können einen Export aus Ihrer Firestore-Produktionsinstanz oder aus dem lokalen Emulator generieren.

Emulatorexport

Starten Sie den Emulator und füllen Sie ihn mit Daten, wie Sie möchten. Sobald Sie Ihre Datenbank in einem gewünschten Zustand haben, erstellen Sie einen Export:

curl "localhost:8080/emulator/v1/projects/ryanpbrewster-test:export" \
  -d '{"database": "projects/ryanpbrewster-test/databases/(default)","export_directory":"."}' \
  -H "Content-Type: application/json

was den Export auf Ihr lokales Dateisystem in einem Verzeichnis wie firestore_export_1576524691/

Produktionsexport

Sie benötigen einen Google Cloud Storage-Bucket. Ich verwende den standardmäßigen AppEngine-Bucket ryanpbrewster-test.appspot.com meines Testprojekts. Lauf

gcloud firestore export gs://ryanpbrewster-test.appspot.com/firestore-export

und Firestore speichert eine vollständige Kopie Ihrer Produktionsdaten in Google Cloud Storage. Wenn Sie möchten, können Sie den Export mit dem Flag --collection-ids auf eine bestimmte Sammlung von Sammlungen beschränken.

Sobald es fertig ist, können Sie es auf Ihr lokales Dateisystem kopieren (beachten Sie, dass dies schlecht funktioniert, wenn Sie eine große Datenbank haben):

gsutil cp -r gs://ryanpbrewster-test.appspot.com/firestore-export .

Daten importieren

Im Moment ist die einzige Möglichkeit, Daten in den Emulator zu importieren, über ein Befehlszeilen-Flag:

java -jar ~/.cache/firebase/emulators/cloud-firestore-emulator-v1.10.2.jar \
  --seed_from_export=firestore_export_1576524691/firestore_export_1576524691.overall_export_metadata

Wenn alles gut geht, startet der Emulator und enthält alle Ihre Daten.

Beachten Sie, dass der erwartete Pfad der Speicherort der Datei .overall_export_metadata ist, die sich auf der obersten Ebene des Exportverzeichnisses befinden sollte.

Ich konnte die Firestore-Daten aus dem Export emulieren. Wenn ich jetzt versuche, den Firebase-Emulator-Anzug zu starten. Der Firestore-Emulator funktioniert nicht, da der Emulator bereits im Port ausgeführt wird. Ich habe sogar versucht, die Variable FIRESTORE_EMULATOR_HOST einzustellen, die sie nicht erkennt. Wenn der Seed-Pfad beim Starten des Emulators auch entlang des Befehls übergeben werden kann, ist dies viel hilfreicher und reduziert viel Entwicklungszeit wie firebase emulators:start --firestore_seed_from_export = \path\to\seed\file

+1 für den Vorschlag von @prgwar . Wie kann ich die Emulator-Suite mit diesem Start-Firestore zum Laufen bringen? Funktionen im Emulator verwenden die Produktion, weil "⚠ Funktionen: Der Cloud Firestore-Emulator wird nicht ausgeführt, daher wirken sich Aufrufe an Firestore auf die Produktion aus."

@prgwar vielen Dank für Ihren Vorschlag, wir arbeiten derzeit daran, die API für die Angabe von Import/Export über den Befehl firebase festzulegen. Die direkte Verwendung von jar ist nur ein Workaround und wird von Entwicklern auf lange Sicht nicht erwartet.

@srolfe26 Ihr Problem klingt wie ein anderes. Sie führen den Cloud Functions-Emulator, aber nicht den Firestore-Emulator aus. Versuchen Sie, firebase init emulators auszuführen, um den Firestore-Emulator zu initialisieren, und führen Sie dann firebase emulators:start erneut aus.

Alle anderen WSL-Benutzer (1 oder 2) haben möglicherweise Probleme, sich von Ihrem Browser aus mit dem Emulator zu verbinden. Ich habe dem obigen Befehl ein --host 0.0.0.0 Flag hinzugefügt und das hat das Problem behoben.

java -jar ~/.cache/firebase/emulators/cloud-firestore-emulator-v1.10.2.jar \
  --seed_from_export=firestore_export_1576524691/firestore_export_1576524691.overall_export_metadata \
  --host 0.0.0.0

Wäre @prgwars Vorschlag, --firestore_seed_from_export= . zu verwendenakzeptabel sein?

Wenn ja, bin ich bereit, eine PR zu veröffentlichen. Wie kann ich sonst noch helfen, den Ball ins Rollen zu bringen?

Ich würde mich auch freuen, wenn die gleiche same_from_export-Funktionalität auf dem Realtime Database-Emulator implementiert werden könnte.

@spencerwhyte danke für das Angebot! Ich befasse mich gerade aktiv damit und arbeite an etwas, das Firestore und RTDB sowie alle zukünftigen Emulatoren unterstützen wird.

Wie würden Sie sich über diesen allgemeinen Ablauf fühlen:

• Ein "Backup" ist ein Ordner, der Folgendes enthält:
  
  
  
  • Eine Reihe einzelner Emulator-Backups in ihren kanonischen Formaten
  
  
  • Eine einzelne metadata.json Datei, die sie beschreibt
  
  
• Um die Emulatoren mit einem Seed zu starten, gehen Sie wie folgt vor: firebase emulators:start --import="./folder-with-backup"
• Um ein Backup der laufenden Emulatoren zu erstellen, öffnen Sie ein neues Terminal, während sie ausgeführt werden, und führen Sie firebase emulators:export

Daran arbeite ich gerade, ich finde es am flexibelsten aber ich bin sehr offen für Feedback

@samtstern Das ist

Dieses Design klingt perfekt, solange das Emulator-Exportformat / Backup-Format etwas ist, mit dem wir arbeiten können. Wenn es das gleiche Format wie die Backups in der Produktion hat, reicht das. Wir müssen eine große Datenmenge für unsere Integrationstests importieren, ohne unsere Trigger auszulösen. Derzeit haben wir überlebt, indem wir einige Prüfungen durchgeführt haben, die Trigger deaktivieren, wenn sie getestet werden, aber wir würden diese Komplexität gerne vermeiden. Diese Unterstützung für --import wird es uns ermöglichen, die Dinge zu vereinfachen.

Wir verwenden firebase emulators:exec für unsere Tests, also solange es auch mit exec funktioniert, wären wir glücklich.

@spencerwhyte

1) Ja, wir werden auf jeden Fall, wenn möglich, bei den gleichen Formaten wie bei der Produktion bleiben. Für Firestore werden wir also das Import/Export-Format unterstützen und für RTDB wird es nur eine riesige json Datei sein.
2) Ja, wir unterstützen emulators:exec --import

Danke für die Rückmeldung!

PR #1968 implementiert diese Funktion (derzeit nur für Firestore, Realtime Database in Kürze) und wird in der nächsten CLI-Version enthalten sein (wahrscheinlich 7.14.0 )

Diese Funktion wurde gerade in 7.14.0 ... probieren Sie es aus und teilen Sie uns Ihre Meinung mit! Im Moment ist es nur Firestore, aber Realtime Database ist als nächstes dran.

Ist das irgendwo dokumentiert? Gibt es auch eine Möglichkeit, die Produktionsdaten ohne einen Google Cloud Storage-Bucket (den ich nicht habe) zu exportieren?
Wenn harte Tests lokal ausgelöst werden, ohne dass Daten aus dem Cloud-Datenspeicher repliziert werden.

@shaimo Entschuldigung, wir sind mit den Dokumenten etwas im Rückstand, aber sie sollten in den nächsten Tagen veröffentlicht werden!

Für den Export aus der Produktion benötigen Sie einen Cloud Storage-Bucket. Dies liegt daran, dass der Export ein "verwalteter" Vorgang ist, was bedeutet, dass er irgendwo auf einem Google-Server stattfindet. Wir können eine solche Operation nicht für Ihr lokales Dateisystem ausführen, wir benötigen ein Cloud-Ziel.

Wenn Sie ein Firebase-Projekt haben, haben Sie tatsächlich einen Cloud Storage-Standard-Bucket, den Sie verwenden können, und dieser enthält ein gewisses kostenloses Kontingent. Navigieren Sie einfach zum Abschnitt "Speicher" der Firebase-Konsole, um es auszuprobieren.

@samtstern Da die Dokumentation einige Zeit in

Wir haben jetzt eine Dokumentation zu den neuen Flaggen hier:
https://firebase.google.com/docs/emulator-suite/install_and_configure#startup

Aber lassen Sie mich Ihnen trotzdem ein Beispiel geben. Um den Import/Export zu verwenden, benötigen Sie zwei Terminalfenster, also nennen wir sie Terminal 1 und Terminal 2

Starten Sie zuerst die Emulatoren

Terminal 1

$ firebase emulators:start
# ...

Nachdem Sie einige Daten darin aufgebaut haben, die Sie speichern möchten, führen Sie den Exportbefehl in einem anderen Terminal aus:

Terminal 2

$ firebase emulators:export ./mydirectory
# ...

Jetzt haben Sie einen Export in ./mydirectory . Wenn Sie die Emulatoren das nächste Mal starten, weisen Sie sie an, von dort zu importieren:

Terminal 1

$ firebase emulators:start --import=./mydirectory
# ...

Und das ist es!

@samtstern Können wir mit dem Befehl Firebase Emulators:start --import aus einem Produktionsexport importieren?
Ich sehe, dass emulators :start --import nach firebase-export-metadata.json sucht, aber ich habe firestore-export/firestore-export.overall_export_metadata

@landonj kannst du, aber im Moment ist es etwas schwierig. Am einfachsten ist es, emulators:export einmal auszuführen und dann die JSON-Dateien so zu ändern, dass sie auf Ihren Produktionsexport statt auf den lokalen verweisen.

Irgendetwas über das Seeding von RTDB für den Emulator?

@FergyKay noch nichts, aber Sie können hier folgen:
https://github.com/firebase/firebase-tools/issues/2079

Das ist dringend nötig

Ich versuche genau das gleiche zu tun wie @landonj ..

und ich habe versucht, was @samtstern gesagt hat ... aber ich

Was mache ich falsch?

bdw.. die Datei existiert!

firebase emulators:start --debug --only firestore,functions --import=/Users/ridermansb/Projects/meve.ai/backups/emulator-data

[2020-05-31T13:31:23.601Z] com.google.cloud.datastore.core.Exception.DatastoreException: Fehler beim Analysieren der gesamten Export-Metadatendatei
unter com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile(ExportImportUtil.java:225)
unter com.google.cloud.datastore.emulator.impl.ExportImportUtil.fetchEntities(ExportImportUtil.java:54)
unter com.google.cloud.datastore.emulator.firestore.CloudFirestore.main(CloudFirestore.java:89)
{"metadata":{"emulator":{"name":"firestore"},"message":"com.google.cloud.datastore.core.exception.DatastoreException: Fehler beim Parsen der gesamten Export-Metadatendatei\n\tat com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile(ExportImportUtil.java:225)\n\tat com.google.cloud.datastore.emulator.impl.ExportImportUtil.fetchEntities(ExportImportUtil.java:54)\n \tat com.google.cloud.datastore.emulator.firestore.CloudFirestore.main(CloudFirestore.java:89)\n"}}
[2020-05-31T13:31:23.602Z] Verursacht durch: java.io.FileNotFoundException: /Users/ridermansb/Projects/meve.ai/backups/emulator-data/Users/ridermansb/Projects/meve.ai/backups/ 2020-05-31/2020-05-31/2020-05-31T13:19:28_6168.overall_export_metadata (keine solche Datei oder kein Verzeichnis)
{"metadata":{"emulator":{"name":"firestore"},"message":"Verursacht durch: java.io.FileNotFoundException: /Users/ridermansb/Projects/meve.ai/backups/emulator-data /Users/ridermansb/Projects/meve.ai/backups/2020-05-31/2020-05-31/2020-05-31T13:19:28_6168.overall_export_metadata (keine solche Datei oder kein solches Verzeichnis)\n"}}
[2020-05-31T13:31:23.603Z] unter java.base/java.io.FileInputStream.open0(native Methode)
unter java.base/java.io.FileInputStream.open(FileInputStream.java:213)
unter java.base/java.io.FileInputStream.(FileInputStream.java:155)
unter com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile(ExportImportUtil.java:215)
... 2 mehr
{"metadata":{"emulator":{"name":"firestore"},"message":"\tat java.base/java.io.FileInputStream.open0(Native Methode)\n\tat java.base/ java.io.FileInputStream.open(FileInputStream.java:213)\n\tat java.base/java.io.FileInputStream.(FileInputStream.java:155)\n\tat com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile(ExportImportUtil.java:215)\n\t... 2 weitere\n"}}

Fehler: Firestore: Firestore-Emulator wurde mit Code beendet: 1

@landonj kannst du, aber im Moment ist es etwas schwierig. Am einfachsten ist es, emulators:export einmal auszuführen und dann die JSON-Dateien so zu ändern, dass sie auf Ihren Produktionsexport statt auf den lokalen verweisen.

Können Sie das erweitern? Kann ich direkt auf den gcloud-Bucket verweisen? Oder muss ich den Inhalt des Exports zuerst lokal herunterladen? Welche Dateien muss ich ändern?

Folgendes habe ich versucht:

> firebase emulators:start
> firebase emulators:export ~/emulator-data/
> # close the emulator
> gcloud firestore export gs://xxxxx-xxxxx-xxxxx/emulator/
> gsutil cp -r gs://xxxxx-xxxxx-xxxxx/emulator ~/emulator-data/
> firebase emulators:start --only firestore --import /home/gugahoi/emulator-data/emulator/ --debug
[2020-06-01T10:04:36.492Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
[2020-06-01T10:04:36.493Z] > authorizing via signed-in user
i  emulators: Starting emulators: firestore {"metadata":{"emulator":{"name":"hub"},"message":"Starting emulators: firestore"}}
[2020-06-01T10:04:36.510Z] [hub] writing locator at /tmp/hub-flux-development.json
i  emulators: Shutting down emulators. {"metadata":{"emulator":{"name":"hub"},"message":"Shutting down emulators."}}
i  hub: Stopping emulator hub {"metadata":{"emulator":{"name":"hub"},"message":"Stopping emulator hub"}}
[2020-06-01T10:04:36.825Z] Error: ENOENT: no such file or directory, open '/home/gugahoi/emulator-data/emulator/firebase-export-metadata.json'
    at Object.openSync (fs.js:458:3)
    at Object.readFileSync (fs.js:360:35)
    at Object.<anonymous> (/home/gugahoi/.nvm/versions/node/v12.16.3/lib/node_modules/firebase-tools/lib/emulator/controller.js:183:44)
    at Generator.next (<anonymous>)
    at fulfilled (/home/gugahoi/.nvm/versions/node/v12.16.3/lib/node_modules/firebase-tools/lib/emulator/controller.js:5:58)
    at processTicksAndRejections (internal/process/task_queues.js:97:5)

Error: An unexpected error has occurred.

Da das obige nicht zu funktionieren schien, habe ich die Datei firebase-exports-metadata.json mit folgendem Inhalt aktualisiert:

> cat firebase-export-metadata.json
{"version":"8.4.1","firestore":{"version":"1.11.4","path":"emulator","metadata_file":"emulator/emulator.overall_export_metadata"}}

Nachfolgend die Verzeichnisstruktur:

gugahoi:~/emulator-data > tree .
.
├── emulator
│   ├── all_namespaces
│   │   └── all_kinds
│   │       ├── all_namespaces_all_kinds.export_metadata
│   │       ├── output-0
│   │       └── output-1
│   └── emulator.overall_export_metadata
├── firebase-export-metadata.json
├── firebase-export-metadata.json.bak
└── firestore_export
    └── firestore_export.overall_export_metadata

Ich habe jedoch immer noch keine Daten in der Emulator-Benutzeroberfläche.

Bearbeiten

Ich dachte nur, ich würde die endgültige Ausgabe des Emulators hinzufügen, es läuft ohne Fehler, aber ohne meine Daten:

> firebase emulators:start --only firestore --import /home/gugahoi/emulator-data/ --debug
[2020-06-01T11:31:34.256Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
[2020-06-01T11:31:34.257Z] > authorizing via signed-in user
i  emulators: Starting emulators: firestore {"metadata":{"emulator":{"name":"hub"},"message":"Starting emulators: firestore"}}
[2020-06-01T11:31:34.274Z] [hub] writing locator at /tmp/hub-flux-development.json
i  firestore: Importing data from /home/gugahoi/emulator-data/emulator/emulator.overall_export_metadata {"metadata":{"emulator":{"name":"firestore"},"message":"Importing data from /home/gugahoi/emulator-data/emulator/emulator.overall_export_metadata"}}
[2020-06-01T11:31:34.302Z] Ignoring unsupported arg: projectId {"metadata":{"emulator":{"name":"firestore"},"message":"Ignoring unsupported arg: projectId"}}
[2020-06-01T11:31:34.303Z] Ignoring unsupported arg: auto_download {"metadata":{"emulator":{"name":"firestore"},"message":"Ignoring unsupported arg: auto_download"}}
[2020-06-01T11:31:34.303Z] Starting Firestore Emulator with command {"binary":"java","args":["-Duser.language=en","-jar","/home/gugahoi/.cache/firebase/emulators/cloud-firestore-emulator-v1.11.4.jar","--host","localhost","--port",8080,"--seed_from_export","/home/gugahoi/emulator-data/emulator/emulator.overall_export_metadata","--rules","/home/gugahoi/projects/flux/flux/firestore.rules"],"optionalArgs":["port","webchannel_port","host","rules","functions_emulator","seed_from_export"],"joinArgs":false} {"metadata":{"emulator":{"name":"firestore"},"message":"Starting Firestore Emulator with command {\"binary\":\"java\",\"args\":[\"-Duser.language=en\",\"-jar\",\"/home/gugahoi/.cache/firebase/emulators/cloud-firestore-emulator-v1.11.4.jar\",\"--host\",\"localhost\",\"--port\",8080,\"--seed_from_export\",\"/home/gugahoi/emulator-data/emulator/emulator.overall_export_metadata\",\"--rules\",\"/home/gugahoi/projects/flux/flux/firestore.rules\"],\"optionalArgs\":[\"port\",\"webchannel_port\",\"host\",\"rules\",\"functions_emulator\",\"seed_from_export\"],\"joinArgs\":false}"}}
i  firestore: Firestore Emulator logging to firestore-debug.log {"metadata":{"emulator":{"name":"firestore"},"message":"Firestore Emulator logging to \u001b[1mfirestore-debug.log\u001b[22m"}}
[2020-06-01T11:31:35.197Z] API endpoint: http://localhost:8080
 {"metadata":{"emulator":{"name":"firestore"},"message":"API endpoint: http://localhost:8080\n"}}
[2020-06-01T11:31:35.198Z] If you are using a library that supports the FIRESTORE_EMULATOR_HOST environment variable, run:

   export FIRESTORE_EMULATOR_HOST=localhost:8080

Dev App Server is now running.

 {"metadata":{"emulator":{"name":"firestore"},"message":"If you are using a library that supports the FIRESTORE_EMULATOR_HOST environment variable, run:\n\n   export FIRESTORE_EMULATOR_HOST=localhost:8080\n\nDev App Server is now running.\n\n"}}
[2020-06-01T11:31:35.322Z] Ignoring unsupported arg: auto_download {"metadata":{"emulator":{"name":"ui"},"message":"Ignoring unsupported arg: auto_download"}}
[2020-06-01T11:31:35.322Z] Ignoring unsupported arg: port {"metadata":{"emulator":{"name":"ui"},"message":"Ignoring unsupported arg: port"}}
[2020-06-01T11:31:35.323Z] Starting Emulator UI with command {"binary":"node","args":["/home/gugahoi/.cache/firebase/emulators/ui-v1.0.0/server.bundle.js"],"optionalArgs":[],"joinArgs":false} {"metadata":{"emulator":{"name":"ui"},"message":"Starting Emulator UI with command {\"binary\":\"node\",\"args\":[\"/home/gugahoi/.cache/firebase/emulators/ui-v1.0.0/server.bundle.js\"],\"optionalArgs\":[],\"joinArgs\":false}"}}
i  ui: Emulator UI logging to ui-debug.log {"metadata":{"emulator":{"name":"ui"},"message":"Emulator UI logging to \u001b[1mui-debug.log\u001b[22m"}}
[2020-06-01T11:31:35.395Z] Web / API server started at http://localhost:4000
 {"metadata":{"emulator":{"name":"ui"},"message":"Web / API server started at http://localhost:4000\n"}}

┌───────────────────────────────────────────────────────────────────────┐
│ ✔  All emulators ready! View status and logs at http://localhost:4000 │
└───────────────────────────────────────────────────────────────────────┘

┌───────────┬────────────────┬─────────────────────────────────┐
│ Emulator  │ Host:Port      │ View in Emulator UI             │
├───────────┼────────────────┼─────────────────────────────────┤
│ Firestore │ localhost:8080 │ http://localhost:4000/firestore │
└───────────┴────────────────┴─────────────────────────────────┘
  Other reserved ports: 4400, 4500

Issues? Report them at https://github.com/firebase/firebase-tools/issues and attach the *-debug.log files.

@gugahoi dein Beitrag hat mir geholfen, eine Lösung zu finden: https://gist.github.com/bkuri/36cef71bcf30a5416b1c353cb81f38ed

Es ist ein kleines Bash-Skript, das Ihre Cloud-Storage-Emulator-Instanz auswertet. Es benötigt lediglich den Projektnamen und einen Zielpfad, um die exportierten Daten zu speichern. dh: ./seed-storage.sh my-project /tmp/export .

Übrigens, das obige Skript hängt von zwei sehr gebräuchlichen Tools ab ( lsof und screen ) zusätzlich zu den üblichen Verdächtigen ( firebase , gcloud und gsutil ), also stellen Sie sicher, dass Sie sie installiert haben.

Hoffe das hilft jemandem. :+1:

Wie auch immer, um das Auslösen von Firestore-Funktionen beim Importieren einer vorhandenen Datenbank zu vermeiden?

@bkuri danke für dieses Skript, ich denke, mit meinem Setup / meiner Installation ist etwas Seltsames abrufen kann, die in der Firestore-Emulatorkonsole angezeigt werden.

Dank @gugahoi konnte ich eine Sammlung aus der Produktion in den lokalen Emulator importieren.
Dazu habe ich folgende Schritte gemacht:

1. Gehen Sie zu meinem lokalen Firebase-Projektpfad.
2. Starten Sie die Emulatoren mit: firebase emulators:start
3. Erstellen Sie manuell einige Mockup-Daten mithilfe der GUI unter http://localhost :4000/firestore mit den bereitgestellten Schaltflächen: _+ Sammlung starten_ und _+ Dokument hinzufügen_.
4. Exportieren Sie diese Daten lokal mit: emulators:export ./mydirectory
5. Über die Projektdaten, die sich in _Firebase Database / Cloud Firestore_ befinden, habe ich eine einzelne Sammlung wie folgt exportiert: gcloud firestore export gs://my-project-bucket-id.appspot.com --collection-ids=myCollection Der Export befindet sich jetzt unter _Firebase Storage_ in einem Ordner mit einem Zeitstempel als Namen (ich habe kein Präfix verwendet für meinen Test)
6. Laden Sie diesen Ordner auf das lokale Laufwerk herunter mit: gsutil cp -r gs://my-project-bucket-id.appspot.com/myCollection ./production_data_export HINWEIS: Ich habe dies in einer Windows-Umgebung gemacht... _gsutil_ löst diesen Fehler aus: _"OSerror: Der Dateiname, Verzeichnisname oder die Syntax der Datenträgerbezeichnung ist falsch"_ wenn der Ordner ungültige Zeichen für einen Ordnernamen in Windows enthält (zB Doppelpunkte) oder dieser Fehler: _"OSError: Invalid argument.9.0 B]"_ wenn auch eine innere Datei im Ordner ungültige Zeichen enthält. Um den Export lokal herunterladen zu können, benennen Sie diese in einen gültigen Windows-Namen um (dh entfernen Sie die Doppelpunkte) wie folgt: gsutil mv gs://my-project-bucket-id.appspot.com/2020-05-22T02:01:06_86152 gs://my-project-bucket-id.appspot.com/myCollection
7. Nach dem Herunterladen imitieren Sie die lokale Exportstruktur, benennen den Ordner in firestore_export und kopieren die Datei firebase-export-metadata.json aus dem lokalen Exportordner. Nur um visuell zu sein, hier ist die Struktur, die ich habe:

$ tree .
.
├── local_data_export
│   ├── firebase-export-metadata.json
│   └── firestore_export
│       ├── all_namespaces
│       │   └── all_kinds
│       │       ├── all_namespaces_all_kinds.export_metadata
│       │       └── output-0
│       └── firestore_export.overall_export_metadata
└── production_data_export
    ├── firebase-export-metadata.json
    └── firestore_export
        ├── all_namespaces
        │   └── kind_myCollection
        │       ├── all_namespaces_kind_myCollection.export_metadata
        │       ├── output-0
        │       └── output-1
        └── firestore_export.overall_export_metadata

8 directories, 9 files

1. Starten Sie abschließend den lokalen Emulator, der auf diese zu importierenden Produktionsdaten verweist: firebase emulators:start --import=./mock_up_data/production_data_export/
2. Sie sollten die importierten Daten sehen unter: http://localhost :4000/firestore/

Ich wünschte, diese Anweisungen wären klar genug, um hilfreich zu sein. Ich hoffe, dies wird jemandem helfen, während wir auf eine robustere Lösung der Firebase-Leute warten.

Nur als kurzes Update: Als ich die Anweisungen aus dem obigen Kommentar gepostet habe, habe ich es in WSL2 gemacht und sie schienen nicht zu funktionieren, aber die gleichen Schritte in Ubuntu scheinen in Ordnung zu sein. Ich vermute, dass etwas in WSL2 stört .

Ich möchte dies umgekehrt tun, ich möchte meine Emulatordaten in die Produktion importieren, ich muss meinem Firestore 7000 Google-Blattzeilen hinzufügen und ich konnte dies tun, indem ich eine Funktion bearbeitete, wenn ich versuche, dies in der Produktion zu tun Speicherlimit wird überschritten, auch wenn etwas in der Funktion schief geht, kann ich mit doppelten Daten enden. Ich habe den Exportimport bemerkt und bemerkt, dass ich einen Export meiner Firestore-Daten des lokalen Emulators durchführen kann. Aber wie wäre es mit dem Importieren meines lokalen Backups in die Produktion?

@nvanhosel die Import-/Exportformate sind in der Produktion und in den Emulatoren gleich. Dies ist jedoch ein ungewöhnlicher Anwendungsfall, sodass Sie selbst einige Arbeiten ausführen müssen, um den Emulatorexport in Google Cloud Storage zu erhalten, damit Firestore ihn ordnungsgemäß importieren kann.