Estoy de acuerdo en que sería genial cargar una "instantánea" de la base de datos en la inicialización. Actualmente ejecuto los emuladores de funciones y firestore localmente para el desarrollo, pero cuando siembro la base de datos con datos de prueba, se ejecutan un montón de activadores de funciones de firestore. Esto es bastante indeseable, entonces, ¿hay algún plan para una función que ayude a cargar los datos iniciales o, mejor aún, la persistencia de los datos de Firestore en el disco?

Gracias por plantear el tema de querer sembrar datos sin funciones
disparo. Como medida provisional, definitivamente podríamos implementar una forma de "convertir
off "se activa con una llamada especial mientras carga datos. Eso
también podría ser útil para ciertas pruebas. ¿Usarías eso?

Pero a largo plazo necesitamos importar / exportar.

El sábado 12 de octubre de 2019 a las 11:54 a.m., Wyatt Ades [email protected] escribió:

Estoy de acuerdo en que sería fantástico cargar una "instantánea" de la base de datos en
inicialización. Actualmente ejecuto los emuladores de funciones y firestore
localmente para el desarrollo, pero cuando siembro la base de datos con datos de prueba, un montón
de los desencadenantes de la función de incendio se ejecutan. Esto es bastante indeseable, así que
¿Existe algún plan para una función que ayude a cargar los datos iniciales o,
aún mejor, ¿persistencia de datos de Firestore en disco?

-
Estás recibiendo esto porque estás suscrito a este hilo.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/firebase/firebase-tools/issues/1167?email_source=notifications&email_token=ACATB2VEE7BBI75HECFTE23QOIMOLA5CNFSM4G5NG5X2YY3PNVWWK3TUL52HS4DFVREXG43VMDVBWBC54 ,
o darse de baja
https://github.com/notifications/unsubscribe-auth/ACATB2WHUTO43JISN54J4U3QOIMOLANCNFSM4G5NG5XQ
.

Sí, esa sería una buena solución por ahora, ¡gracias!

Entonces, ¿aún no se han establecido hitos para esto? pero una cosa que me gusta ahora de este equipo aquí, parece ser más activo y receptivo.

¿Pueden agregar db en tiempo real también en el alcance de esto junto con firestore db?

@anantanandgupta aún no hay hitos, pero sí, ¡tratamos de ser realmente abiertos sobre nuestro progreso! Y también agregué el emulador de base de datos para que esté dentro del alcance. Para la base de datos, el problema es más fácil (formato JSON), pero aún necesitamos ayudarlo a "pausar" las funciones de la nube.

Sé que estoy en buenas manos. Pero para decirles la importancia, he diseñado esta enorme plataforma completamente alrededor de la base de fuego y todos estaban en contra de esto hace un año atrás, pero con mis esfuerzos he demostrado hasta ahora que mi decisión de usar la base de fuego como tecnología no fue incorrecta. En este punto, se ha vuelto tan grande que trabajar en múltiples funciones por parte de múltiples desarrolladores con una base de datos común alojada en la nube se ha vuelto imposible. Entonces, si cada uno de nosotros puede trabajar en una copia local de la base de datos, será mucho más fácil y eficiente.

La capacidad de importar datos al emulador de Firestore (es decir, inicializarlos con datos "semilla") debería desaparecer en la próxima versión. Será un poco manual al principio, agregaremos mejores herramientas en versiones posteriores.

Investigando qué sería necesario para el emulador de Realtime Database.

@ryanpbrewster ¿hay alguna documentación sobre cómo configurar los datos "semilla"?

@SamyPesse esto se ha implementado dentro del propio Emulator JAR (como dijo @ryanpbrewster ) pero en realidad no hemos expuesto una API a través de firebase-tools para realizar la importación, por lo que esto no es realmente algo que pueda usar todavía.

¿Le importaría compartir cómo espera que funcione esto? ¿Preferiría una bandera en el comando firebase , un campo en firebase.json o algo más?

La importación y exportación de datos está actualmente implementada, pero aún no hemos descubierto cómo facilitar el uso de estas funciones. Por lo tanto, tenga en cuenta que sabemos que estas instrucciones son aproximadas y estamos abiertos a ideas sobre cómo mejorar esto:

Obtener una exportación

Puede generar una exportación desde su instancia de producción de Firestore o desde el emulador local.

Exportación del emulador

Inicie el emulador y rellénelo con datos como desee. Una vez que tenga su base de datos en un estado que le guste, cree una exportación:

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

que volcará la exportación en su sistema de archivos local en un directorio como firestore_export_1576524691/

Exportación de producción

Necesitará un depósito de Google Cloud Storage. Usaré el depósito de AppEngine predeterminado de mi proyecto de prueba ryanpbrewster-test.appspot.com . Correr

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

y Firestore volcará una copia completa de sus datos de producción en Google Cloud Storage. Si lo desea, puede usar la bandera --collection-ids para limitar la exportación a un conjunto específico de colecciones.

Una vez hecho esto, puede copiarlo en su sistema de archivos local (tenga en cuenta que esto no funcionará bien si tiene una base de datos enorme):

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

Datos de importacion

Por ahora, la única forma de importar datos al emulador es a través de una marca de línea de comando:

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

Si todo va bien, el emulador se iniciará y tendrá todos sus datos en él.

Tenga en cuenta que la ruta que espera es la ubicación del archivo .overall_export_metadata , que debería estar en el nivel superior del directorio de exportación.

Pude emular los datos de Firestore de la exportación. Ahora, si trato de iniciar el juego del emulador de base de fuego. El emulador de Firestore no funciona porque el emulador ya se está ejecutando en el puerto. Intenté incluso configurar la variable FIRESTORE_EMULATOR_HOST que no reconoce. Si la ruta semilla también se puede pasar a lo largo del comando mientras se inicia el emulador, será mucho más útil y reducirá mucho tiempo de desarrollo como firebase emulators:start --firestore_seed_from_export = \path\to\seed\file

+1 por la sugerencia de @prgwar . ¿Cómo puedo hacer que el conjunto de emuladores se ejecute usando este firestore de inicio? Las funciones del emulador usan producción porque "⚠ funciones: el emulador de Cloud Firestore no se está ejecutando, por lo que las llamadas a Firestore afectarán la producción".

@prgwar gracias por su sugerencia, actualmente estamos trabajando para decidir la API para especificar la importación / exportación desde el comando firebase . Usar el jar directamente es solo una solución y no es algo que realmente esperamos que hagan los desarrolladores a largo plazo.

@ srolfe26, tu problema parece diferente, estás ejecutando el emulador de Cloud Functions pero no el emulador de Firestore. Intente ejecutar firebase init emulators para inicializar el emulador Firestore y luego ejecute firebase emulators:start nuevamente.

Para cualquier otro usuario de WSL (1 o 2), es posible que tenga problemas para conectarse al emulador desde su navegador. Agregué una bandera --host 0.0.0.0 al comando anterior y eso solucionó el problema.

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

¿ Sería la sugerencia de @prgwar de usar --firestore_seed_from_export =¿estar bien visto?

Si es así, estoy dispuesto a poner un PR. ¿De qué otra manera puedo ayudar a que la pelota ruede?

También me encantaría que se pudiera implementar la misma funcionalidad seed_from_export en el emulador de Realtime Database.

@spencerwhyte ¡ gracias por la oferta! Estoy abordando esto activamente en este momento, trabajando en algo que sea compatible con Firestore y RTDB y también con cualquier emulador futuro.

¿Cómo te sentirías con este flujo general?

• Una "copia de seguridad" es una carpeta que contiene:
  
  
  
  • Un montón de copias de seguridad de emuladores individuales en sus formatos canónicos
  
  
  • Un solo archivo metadata.json que los describe
  
  
• Para iniciar los emuladores con una semilla, haz lo siguiente: firebase emulators:start --import="./folder-with-backup"
• Para realizar una copia de seguridad de los emuladores en ejecución, abra una nueva terminal mientras se ejecutan y haga firebase emulators:export

En eso estoy trabajando actualmente, creo que es lo más flexible, pero estoy muy abierto a recibir comentarios.

@samtstern ¡ Es genial escucharlo!

Este diseño suena perfecto, siempre y cuando el formato de exportación / formato de copia de seguridad del emulador sea algo con lo que podamos trabajar. Si tiene el mismo formato que las copias de seguridad en producción, será suficiente. Tenemos la necesidad de importar una gran cantidad de datos para nuestras pruebas de integración sin activar nuestros activadores. Actualmente, hemos sobrevivido haciendo algunas comprobaciones que desactivan los activadores cuando están bajo prueba, sin embargo, nos encantaría evitar esa complejidad. Este soporte para --import nos permitirá simplificar las cosas.

Usamos firebase emulators:exec para nuestras pruebas, así que siempre que funcione con exec también, estaremos felices.

@spencerwhyte

1) Sí, definitivamente nos ceñiremos a los mismos formatos que la producción siempre que sea posible. Entonces, para Firestore admitiremos el formato de importación / exportación y para RTDB será solo un archivo json gigante.
2) Sí, apoyaremos emulators:exec --import

¡Gracias por la respuesta!

PR # 1968 implementa esta función (para Firestore solo por el momento, Realtime Database próximamente) y se incluirá en la próxima versión de CLI (probablemente 7.14.0 )

Esta función se acaba de lanzar en 7.14.0 ... ¡pruébalo y cuéntanos lo que piensas! En este momento es solo Firestore, pero la base de datos en tiempo real es la siguiente.

¿Está esto documentado en alguna parte? Además, ¿hay alguna forma de exportar los datos de producción sin un depósito de Google Cloud Storage (que no tengo)?
Tener dificultades para realizar pruebas se activa localmente sin que los datos se hayan replicado desde el almacén de datos en la nube.

@shaimo, lo siento, estamos un poco atrasados ​​con los documentos, ¡pero deberían estar disponibles en los próximos días!

Para exportar desde producción, necesita un depósito de Cloud Storage. Esto se debe a que la exportación es una operación "administrada", lo que significa que ocurre en un servidor de Google en algún lugar. No podemos ejecutar una operación como esa contra su sistema de archivos local, necesitamos un destino en la nube.

Si tiene un proyecto de Firebase, en realidad tiene un depósito de Cloud Storage predeterminado que puede usar e incluye una cuota gratuita. Simplemente navegue hasta la sección Almacenamiento de la consola de Firebase para verificarlo.

@samtstern Como la documentación puede llevar algo de tiempo, ¿puede darnos un breve resumen sobre cómo importar / exportar a la instancia del emulador?

Ahora tenemos algo de documentación sobre las nuevas banderas aquí:
https://firebase.google.com/docs/emulator-suite/install_and_configure#startup

Pero déjame darte un ejemplo de todos modos. Para usar la importación / exportación, necesitará dos ventanas de terminal, así que llamémoslas Terminal 1 y Terminal 2

Primero inicie los emuladores

Terminal 1

$ firebase emulators:start
# ...

Una vez que haya acumulado algunos datos en ellos que le gustaría guardar, ejecute el comando de exportación en otra terminal:

Terminal 2

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

Ahora tiene una exportación en ./mydirectory . La próxima vez que inicie los emuladores, dígales que importen desde allí:

Terminal 1

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

¡Y eso es!

@samtstern ¿Podemos importar desde una exportación de producción usando el comando firebase emulators: start --import?
Veo que emuladores: start --import está buscando firebase-export-metadata.json pero tengo firestore-export / firestore-export.overall_export_metadata

@landonj puedes, pero es un poco complicado en este momento. Lo más sencillo es ejecutar emulators:export una vez y luego modificar los archivos JSON para que apunten a su exportación de producción en lugar de a la local.

¿Algo sobre la siembra de RTDB para el emulador todavía?

@FergyKay nada todavía, pero puedes seguir aquí:
https://github.com/firebase/firebase-tools/issues/2079

Esto es muy necesario

Estoy tratando de hacer exactamente lo mismo que @landonj ..

e intenté lo que dijo @samtstern ... pero recibo un error ...

¿Qué estoy haciendo mal?

bdw .. ¡el archivo existe!

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: no se pudo analizar el archivo de metadatos de exportación general
en com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile (ExportImportUtil.java:225)
en com.google.cloud.datastore.emulator.impl.ExportImportUtil.fetchEntities (ExportImportUtil.java:54)
en com.google.cloud.datastore.emulator.firestore.CloudFirestore.main (CloudFirestore.java:89)
{"metadata": {"emulator": {"name": "firestore"}, "message": "com.google.cloud.datastore.core.exception.DatastoreException: no se pudo analizar el archivo de metadatos de exportación general \ 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) \ tat com.google.cloud.datastore.emulator.firestore.CloudFirestore.main (CloudFirestore.java:89) \ n "}}
[2020-05-31T13: 31: 23.602Z] Causado por: 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 (No existe tal archivo o directorio)
{"metadata": {"emulator": {"name": "firestore"}, "message": "Causado por: 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 (No existe tal archivo o directorio) \ n "}}
[2020-05-31T13: 31: 23.603Z] en java.base / java.io.FileInputStream.open0 (método nativo)
en java.base / java.io.FileInputStream.open (FileInputStream.java:213)
en java.base / java.io.FileInputStream.(FileInputStream.java:155)
en com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile (ExportImportUtil.java:215)
... 2 más
{"metadata": {"emulator": {"name": "firestore"}, "message": "\ tat java.base / java.io.FileInputStream.open0 (método nativo) \ 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 más \ n "}}

Error: firestore: el emulador de Firestore ha salido con el código: 1

@landonj puedes, pero es un poco complicado en este momento. Lo más sencillo es ejecutar emulators:export una vez y luego modificar los archivos JSON para que apunten a su exportación de producción en lugar de a la local.

¿Puedes ampliar esto? ¿Puedo apuntar directamente al depósito de gcloud? ¿O primero debo descargar el contenido de la exportación localmente? ¿Qué archivos necesito modificar?

Lo siguiente es lo que he intentado:

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

Como lo anterior no parecía funcionar, actualicé el archivo firebase-exports-metadata.json con el siguiente contenido:

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

A continuación se muestra la estructura del directorio:

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

Sin embargo, todavía no tengo datos en la interfaz de usuario del emulador.

Editar

Solo pensé en agregar la salida final del emulador, se ejecuta sin errores pero sin mis datos:

> 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, tu publicación me ayudó a encontrar una solución: https://gist.github.com/bkuri/36cef71bcf30a5416b1c353cb81f38ed

Es un pequeño script bash que inicia su instancia de emulador de almacenamiento en la nube. Todo lo que necesita es el nombre del proyecto y una ruta de destino para guardar los datos exportados. es decir: ./seed-storage.sh my-project /tmp/export .

Por cierto, el script anterior depende de dos herramientas muy comunes ( lsof y screen ) además de los sospechosos habituales ( firebase , gcloud y gsutil ), así que asegúrese de tenerlos instalados.

Espero que esto ayude a alguien. : +1:

De todos modos, ¿para evitar la activación de funciones de firestore al importar una base de datos existente?

@bkuri gracias por ese script, supongo que algo extraño está sucediendo con mi configuración / instalación ya que todavía no puedo obtener ningún dato para que aparezca en la consola del emulador de Firestore.

Gracias a @gugahoi pude importar una colección de producción al emulador local.
Para ello hice los siguientes pasos:

1. Ve a la ruta de mi proyecto de Firebase local.
2. Inicie los emuladores usando: firebase emulators:start
3. Cree manualmente algunos datos de la maqueta usando la GUI en http: // localhost : 4000 / firestore usando los botones provistos: _ + Iniciar colección_ y _ + Agregar documento_.
4. Exporte estos datos localmente usando: emulators:export ./mydirectory
5. Acerca de los datos del proyecto ubicados en _Firebase Database / Cloud Firestore_, exporté una sola colección como esta: gcloud firestore export gs://my-project-bucket-id.appspot.com --collection-ids=myCollection La exportación ahora se encuentra en _Firebase Storage_ en una carpeta con una marca de tiempo como nombre (no usé un prefijo para mi prueba)
6. Descargue esta carpeta en la unidad local con: gsutil cp -r gs://my-project-bucket-id.appspot.com/myCollection ./production_data_export NOTA: Hice esto en un entorno Windows ... _gsutil_ arrojará este error: _ "OSError: El nombre del archivo, el nombre del directorio o la sintaxis de la etiqueta del volumen es incorrecta" _ si la carpeta tiene caracteres inválidos para un nombre de carpeta en Windows (es decir, dos puntos) o este error: _ "OSError: Invalid argument.9.0 B]" _ si un archivo interno en la carpeta también tiene caracteres inválidos. Para poder descargar la exportación localmente, cambie el nombre de estos con un nombre válido de Windows (es decir, elimine los dos puntos) como este: gsutil mv gs://my-project-bucket-id.appspot.com/2020-05-22T02:01:06_86152 gs://my-project-bucket-id.appspot.com/myCollection
7. Una vez descargado, imite la estructura de exportación local cambiando el nombre de la carpeta a firestore_export y copiando el archivo firebase-export-metadata.json de la carpeta de exportación local. Solo para ser visual, aquí está la estructura que obtuve:

$ 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. Finalmente, inicie el emulador local apuntando a estos datos de producción que se importarán: firebase emulators:start --import=./mock_up_data/production_data_export/
2. Debería ver los datos importados en: http: // localhost : 4000 / firestore /

Desearía que estas instrucciones fueran lo suficientemente claras para ser útiles. Espero que esto ayude a alguien mientras esperamos una solución más sólida de la gente de Firebase.

Solo como una breve actualización: cuando publiqué las instrucciones del comentario anterior, lo estaba haciendo en WSL2 y no parecían funcionar, pero los mismos pasos en Ubuntu parecen estar bien. Sospecho que podría haber algo en WSL2 interfiriendo .

Quiero hacer esto al revés, quiero importar los datos de mi emulador a producción, necesito agregar 7000 filas de hojas de Google a mi firestore y pude hacerlo editando una función, sin embargo, cuando intento hacerlo en producción, mi El límite de memoria se excede también cuando algo sale mal dentro de la función, puedo terminar con datos duplicados. Me di cuenta de la importación de exportación y me di cuenta de que puedo exportar los datos de mi emulador local firestore. Pero, ¿qué hay de importar mi copia de seguridad local a producción?

@nvanhoesel los formatos de importación / exportación son los mismos en producción y en los emuladores. Pero el suyo es un caso de uso poco común, por lo que deberá trabajar un poco para obtener la exportación del emulador a Google Cloud Storage para que Firestore pueda importarlo correctamente.