Concordo que seria ótimo carregar um "instantâneo" do banco de dados na inicialização. Atualmente, executo o firestore e os emuladores de funções localmente para desenvolvimento, mas quando eu semeio o banco de dados com dados de teste, vários gatilhos de função do firestore são executados. Isso é muito indesejável, então há planos para um recurso para ajudar a carregar os dados iniciais ou, melhor ainda, a persistência de dados do Firestore no disco?

Obrigado por levantar a questão sobre o desejo de propagar dados sem funções
disparando. Como uma medida paliativa, poderíamos definitivamente implementar uma maneira de "transformar
off "aciona as funções com uma chamada especial enquanto você carrega os dados.
também pode ser útil para certos testes. Você usaria isso?

Mas, a longo prazo, precisamos importar / exportar.

No sábado, 12 de outubro de 2019, 11h54, Wyatt Ades [email protected] escreveu:

Eu concordo que seria ótimo carregar um "instantâneo" do banco de dados no
inicialização. Atualmente, executo o firestore e os emuladores de funções
localmente para desenvolvimento, mas quando eu semeio o banco de dados com dados de teste, um monte
de gatilhos de função do firestore são executados. Isso é muito indesejável, então
existem planos para um recurso para ajudar no carregamento de dados iniciais ou,
melhor ainda, persistência de dados do firestore em disco?

-
Você está recebendo isto porque está inscrito neste tópico.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/firebase/firebase-tools/issues/1167?email_source=notifications&email_token=ACATB2VEE7BBI75HECFTE23QOIMOLA5CNFSM4G5NG5X2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEBCGBZA#issuecomment-541352164 ,
ou cancelar
https://github.com/notifications/unsubscribe-auth/ACATB2WHUTO43JISN54J4U3QOIMOLANCNFSM4G5NG5XQ
.

Sim, essa seria uma boa solução por agora, obrigado!

Então, ainda não há marcos definidos para isso? mas uma coisa que eu gosto agora sobre esta equipe aqui, parece ser mais ativa e ágil.

podem, por favor, adicionar banco de dados em tempo real também no escopo para isso, junto com o banco de dados firestore.

@anantanandgupta sem marcos ainda, mas sim, tentamos ser realmente abertos sobre o nosso progresso! E eu adicionei o emulador de banco de dados para estar no escopo também. Para o banco de dados, o problema é mais fácil (formato JSON), mas ainda precisamos ajudá-lo a "pausar" o Cloud Functions

Eu sei que estou em boas mãos. Mas para te dizer o quão crítico é, eu projetei esta plataforma enorme totalmente em torno do firebase e todos estavam contra isso sim, mas com meus esforços eu provei até agora que minha decisão de usar o firebase como a tecnologia não estava errada. Nesse ponto, ele se tornou tão grande que trabalhar em vários recursos por vários desenvolvedores com um banco de dados comum hospedado na nuvem tornou-se impossível. Portanto, se cada um de nós puder trabalhar em uma cópia local do banco de dados, será muito mais fácil e eficiente.

A capacidade de importar dados para o emulador Firestore (ou seja, inicializá-lo com dados "semente") deve sair na próxima versão. Será um pouco manual no início, vamos adicionar ferramentas melhores em versões subsequentes.

Analisar o que seria necessário para o emulador do Realtime Database.

@ryanpbrewster existe alguma documentação sobre como configurar os dados "seed"?

@SamyPesse isso foi implementado dentro do próprio Emulador JAR (como @ryanpbrewster disse), mas não firebase-tools para importar, então isso não é realmente algo que você possa usar ainda.

Você se importaria de compartilhar como você espera que isso funcione? Você prefere uma bandeira no comando firebase , um campo em firebase.json ou algo mais?

A importação e exportação de dados estão implementadas atualmente, mas ainda não descobrimos como facilitar o uso desses recursos. Portanto, lembre-se de que sabemos que essas instruções são básicas e estamos abertos a ideias sobre como melhorar isso:

Obtenha uma exportação

Você pode gerar uma exportação de sua instância de produção do Firestore ou do emulador local.

Exportação de emulador

Inicialize o emulador e preencha-o com os dados como desejar. Depois de ter seu banco de dados em um estado que você gosta, crie uma exportação:

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

que irá despejar a exportação em seu sistema de arquivos local em um diretório como firestore_export_1576524691/

Exportação de produção

Você precisará de um intervalo do Google Cloud Storage. Usarei o depósito padrão do AppEngine do meu projeto de teste ryanpbrewster-test.appspot.com . Corre

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

e o Firestore despejará uma cópia completa de seus dados de produção no Google Cloud Storage. Se desejar, você pode usar o sinalizador --collection-ids para limitar a exportação a um conjunto específico de coleções.

Uma vez feito isso, você pode copiá-lo em seu sistema de arquivos local (observe que isso não vai dar certo se você tiver um banco de dados enorme):

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

Importar dados

Por enquanto, a única maneira de importar dados para o emulador é por meio de uma sinalização de linha 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

Se tudo correr bem, o emulador será inicializado e terá todos os seus dados nele.

Observe que o caminho esperado é a localização do arquivo .overall_export_metadata , que deve estar no nível superior do diretório de exportação.

Consegui emular os dados do firestore da exportação. Agora, se eu tentar iniciar o terno do emulador Firebase. O emulador do Firestore não está funcionando porque o emulador já está sendo executado na porta. Eu tentei até mesmo definir a variável FIRESTORE_EMULATOR_HOST ela não está reconhecendo. Se o caminho da semente também puder ser passado junto com o comando ao iniciar o emulador, será muito mais útil e reduzirá muito o tempo de desenvolvimento, como firebase emulators:start --firestore_seed_from_export = \path\to\seed\file

+1 para a sugestão de

@prgwar obrigado por sua sugestão, estamos atualmente trabalhando para decidir a API para especificar importação / exportação do comando firebase . Usar o jar diretamente é apenas uma solução alternativa e não algo que realmente esperamos que os desenvolvedores façam a longo prazo.

@ srolfe26 seu problema parece diferente, você está executando o emulador do Cloud Functions, mas não o emulador do Firestore. Tente executar firebase init emulators para inicializar o emulador Firestore e, em seguida, execute firebase emulators:start novamente.

Para qualquer outro usuário WSL (1 ou 2) lá fora, você pode ter problemas para se conectar ao emulador de seu navegador. Eu adicionei um sinalizador --host 0.0.0.0 ao comando acima e isso resolveu o 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

Seria @prgwar 's sugestão de usar --firestore_seed_from_export =ser aceitável?

Nesse caso, estou disposto a fazer um PR. De que outra forma posso ajudar a dar o pontapé de saída?

Eu também adoraria se a mesma funcionalidade seed_from_export pudesse ser implementada no emulador do Realtime Database.

@spencerwhyte obrigado pela oferta! Estou ativamente lidando com isso agora, trabalhando em algo que dará suporte ao Firestore e ao RTDB e também a quaisquer emuladores futuros.

Como você se sentiria sobre este fluxo geral:

• Um "backup" é uma pasta que contém:
  
  
  
  • Vários backups de emuladores individuais em seus formatos canônicos
  
  
  • Um único arquivo metadata.json que os descreve
  
  
• Para iniciar os emuladores com uma semente, você faz: firebase emulators:start --import="./folder-with-backup"
• Para fazer um backup dos emuladores em execução, você abre um novo terminal enquanto eles estão em execução e faz firebase emulators:export

É nisso que estou trabalhando atualmente, acho que é a coisa mais flexível, mas estou muito aberto a comentários

@samtstern É ótimo ouvir isso!

Este design parece perfeito, contanto que o formato de exportação / backup do emulador seja algo com o qual possamos trabalhar. Se for o mesmo formato dos backups em produção, basta. Precisamos importar uma grande quantidade de dados para nossos testes de integração sem disparar nossos gatilhos. Atualmente, temos sobrevivido fazendo algumas verificações que desabilitam gatilhos quando em teste, no entanto, adoraríamos evitar essa complexidade. Este suporte para --import nos permitirá simplificar as coisas.

Usamos firebase emulators:exec para nossos testes, então, desde que funcione com exec também, ficaremos felizes.

@spencerwhyte

1) Sim, definitivamente manteremos os mesmos formatos de produção sempre que possível. Portanto, para o Firestore ofereceremos suporte ao formato de importação / exportação e para o RTDB será apenas um arquivo json gigante.
2) Sim, apoiaremos emulators:exec --import

Obrigado pelo feedback!

PR # 1968 implementa este recurso (para Firestore apenas no momento, Realtime Database em breve) e será incluído na próxima versão CLI (provavelmente 7.14.0 )

Este recurso acaba de ser lançado em 7.14.0 ... experimente e diga-nos o que você achou! No momento, é apenas Firestore, mas o Realtime Database é o próximo.

Isso está documentado em algum lugar? Além disso, existe uma maneira de exportar os dados de produção sem um intervalo do Google Cloud Storage (que eu não tenho)?
O teste difícil é acionado localmente, sem dados replicados do armazenamento de dados em nuvem.

@shaimo, desculpe, estamos um pouco atrasados ​​com os documentos, mas eles devem sair nos próximos dias!

Para exportar da produção, você precisa de um intervalo do Cloud Storage. Isso ocorre porque a exportação é uma operação "gerenciada", o que significa que acontece em um servidor do Google em algum lugar. Não podemos executar uma operação como essa em seu sistema de arquivos local, precisamos de um destino na nuvem.

Se você tem um projeto do Firebase, na verdade tem um intervalo padrão do Cloud Storage que pode usar e inclui alguma cota gratuita. Basta navegar até a seção Armazenamento do Firebase console para conferir.

@samtstern Como a documentação pode levar algum tempo, você pode dar um breve resumo de como importar / exportar para a instância do emulador?

Agora temos alguma documentação sobre os novos sinalizadores aqui:
https://firebase.google.com/docs/emulator-suite/install_and_configure#startup

Mas deixe-me dar um exemplo de qualquer maneira. Para usar a importação / exportação, você precisará de duas janelas de terminal, então vamos chamá-las de Terminal 1 e Terminal 2

Primeiro inicie os emuladores

Terminal 1

$ firebase emulators:start
# ...

Depois de criar alguns dados que gostaria de salvar, execute o comando export em outro terminal:

Terminal 2

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

Agora você tem uma exportação em ./mydirectory . Da próxima vez que você iniciar os emuladores, diga a eles para importar de lá:

Terminal 1

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

E é isso!

@samtstern Podemos importar de uma exportação de produção usando os emuladores firebase start --import?
Vejo que os emuladores: start --import está procurando firebase-export-metadata.json, mas tenho firestore-export / firestore-export.overall_export_metadata

@landonj você pode, mas é um pouco complicado no momento. A coisa mais simples a fazer é executar emulators:export uma vez e, em seguida, modificar os arquivos JSON para apontar para sua exportação de produção em vez do local.

Alguma coisa sobre a propagação do RTDB para o emulador?

@FergyKay nada ainda, mas você pode acompanhar aqui:
https://github.com/firebase/firebase-tools/issues/2079

Isso é muito necessário

Estou tentando fazer exatamente a mesma coisa que @landonj ..

e tentei o que @samtstern disse ... mas estou recebendo um erro ...

O que estou fazendo de errado?

bdw .. o arquivo 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: falha ao analisar o arquivo de metadados de exportação geral
em com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile (ExportImportUtil.java:225)
em com.google.cloud.datastore.emulator.impl.ExportImportUtil.fetchEntities (ExportImportUtil.java:54)
em com.google.cloud.datastore.emulator.firestore.CloudFirestore.main (CloudFirestore.java:89)
{"metadata": {"emulator": {"name": "firestore"}, "message": "com.google.cloud.datastore.core.exception.DatastoreException: falha ao analisar o arquivo de metadados de exportação geral \ 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] 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 (Não existe esse arquivo ou diretório)
{"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 (Não existe esse arquivo ou diretório) \ n "}}
[2020-05-31T13: 31: 23.603Z] em java.base / java.io.FileInputStream.open0 (método nativo)
em java.base / java.io.FileInputStream.open (FileInputStream.java:213)
em java.base / java.io.FileInputStream.(FileInputStream.java:155)
em com.google.cloud.datastore.emulator.impl.ExportImportUtil.parseOverallMetadataFile (ExportImportUtil.java:215)
... mais 2
{"metadados": {"emulador": {"nome": "firestore"}, "mensagem": "\ 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 ... mais 2 \ n "}}

Erro: firestore: o emulador Firestore saiu com o código: 1

@landonj você pode, mas é um pouco complicado no momento. A coisa mais simples a fazer é executar emulators:export uma vez e, em seguida, modificar os arquivos JSON para apontar para sua exportação de produção em vez do local.

Você pode expandir isso? Posso apontar diretamente para o intervalo gcloud? Ou devo primeiro baixar o conteúdo da exportação localmente? Quais arquivos eu preciso modificar?

O seguinte é o que eu tentei:

> 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 o procedimento acima não funcionou, atualizei o arquivo firebase-exports-metadata.json com o seguinte conteúdo:

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

Abaixo está a estrutura do diretório:

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

No entanto, ainda não tenho dados na IU do emulador.

Editar

Pensei apenas em adicionar a saída final do emulador, ele é executado sem erros, mas sem meus dados:

> 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, sua postagem me ajudou a encontrar uma solução: https://gist.github.com/bkuri/36cef71bcf30a5416b1c353cb81f38ed

É um pequeno script bash que semeia sua instância do emulador de armazenamento em nuvem. Tudo o que precisa é o nome do projeto e um caminho de destino para salvar os dados exportados. ou seja: ./seed-storage.sh my-project /tmp/export .

BTW, o script acima depende de duas ferramentas muito comuns ( lsof e screen ), além das suspeitas usuais ( firebase , gcloud e gsutil ), portanto, certifique-se de instalá-los.

Espero que isso ajude alguém. : +1:

Qualquer maneira de evitar o acionamento de funções do firestore na importação de um banco de dados existente?

@bkuri obrigado por esse script, acho que há algo estranho acontecendo com minha configuração / instalação, pois ainda não consigo obter nenhum dado para aparecer no console do emulador do firestore.

Graças a @gugahoi , consegui importar uma coleção da produção para o emulador local.
Para fazer isso, executei as seguintes etapas:

1. Vá para o caminho do meu projeto Firebase local.
2. Inicie os emuladores usando: firebase emulators:start
3. Crie manualmente alguns dados de maquete usando a GUI em http: // localhost : 4000 / firestore usando os botões fornecidos: _ + Iniciar coleção_ e _ + Adicionar documento_.
4. Exporte esses dados localmente usando: emulators:export ./mydirectory
5. Sobre os dados do projeto localizados em _Firebase Database / Cloud Firestore_, exportei uma única coleção como esta: gcloud firestore export gs://my-project-bucket-id.appspot.com --collection-ids=myCollection A exportação agora está localizada em _Firebase Storage_ em uma pasta com um carimbo de data / hora como nome (não usei um prefixo para o meu teste)
6. Baixe esta pasta para a unidade local com: gsutil cp -r gs://my-project-bucket-id.appspot.com/myCollection ./production_data_export NOTA: Eu fiz isso em um ambiente Windows ... _gsutil_ gerará este erro: _ "OSError: O nome do arquivo, o nome do diretório ou a sintaxe do rótulo do volume está incorreta" _ se a pasta tiver caracteres inválidos para um nome de pasta no Windows (ou seja, dois pontos) ou este erro: _ "OSError: Argumento inválido.9.0 B]" _ se um arquivo interno na pasta também tiver caracteres inválidos. Para poder baixar a exportação localmente, renomeie-os com um nome válido do Windows (ou seja, removendo os dois pontos) 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. Uma vez baixado, imite a estrutura de exportação local renomeando a pasta para firestore_export e copiando o arquivo firebase-export-metadata.json da pasta de exportação local. Apenas para ser visual, aqui está a estrutura que obtive:

$ 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 o emulador local apontando para estes dados de produção a serem importados: firebase emulators:start --import=./mock_up_data/production_data_export/
2. Você deve ver os dados importados em: http: // localhost : 4000 / firestore /

Gostaria que essas instruções fossem claras o suficiente para serem úteis. Espero que isso ajude alguém enquanto esperamos por uma solução mais robusta do pessoal do Firebase.

Apenas como uma breve atualização: quando postei as instruções do comentário acima, estava fazendo isso no WSL2 e elas não parecem funcionar, mas as mesmas etapas no Ubuntu parecem estar bem. Suspeito que pode haver algo interferindo no WSL2 .

Quero fazer isso ao contrário, quero importar os dados do meu emulador para a produção, preciso adicionar 7000 linhas de planilha do google ao meu firestore e consegui fazer isso editando uma função, mas ao tentar fazê-lo na produção meu o limite de memória também é excedido quando algo dá errado dentro da função i pode acabar com dados duplicados. Percebi a importação de exportação e percebi que posso fazer uma exportação dos dados firestore do meu emulador local. Mas que tal importar meu backup local para a produção?

@nvanhoesel os formatos de importação / exportação são os mesmos na produção e nos emuladores. Mas o seu é um caso de uso incomum, então você precisa fazer algum trabalho para obter a exportação do emulador para o Google Cloud Storage para que o Firestore possa importá-lo corretamente.