Comece a usar o Cloud Firestore

Este guia de início rápido mostra como configurar o Cloud Firestore, adicionar dados e visualizar os dados que você acabou de adicionar no console do Firebase.

Crie um banco de dados Cloud Firestore

  1. Crie um projeto do Firebase, caso ainda não o tenha feito: no console do Firebase , clique em Adicionar projeto e siga as instruções na tela para criar um projeto do Firebase ou adicionar serviços do Firebase a um projeto existente do GCP.

  2. Navegue até a seção Cloud Firestore do console do Firebase . Você será solicitado a selecionar um projeto existente do Firebase. Siga o fluxo de trabalho de criação de banco de dados.

  3. Selecione um modo inicial para suas regras de segurança do Cloud Firestore:

    Modo de teste

    Bom para começar a usar as bibliotecas de cliente móvel e web, mas permite que qualquer pessoa leia e substitua seus dados. Após o teste, certifique-se de revisar a seção Proteja seus dados .

    Para começar a usar a Web, as plataformas Apple ou o Android SDK, selecione o modo de teste.

    Modo bloqueado

    Nega todas as leituras e gravações de clientes móveis e da Web. Seus servidores de aplicativos autenticados (C#, Go, Java, Node.js, PHP, Python ou Ruby) ainda podem acessar seu banco de dados.

    Para começar a usar a biblioteca cliente do servidor C#, Go, Java, Node.js, PHP, Python ou Ruby, selecione o modo bloqueado.

    Seu conjunto inicial de regras de segurança do Cloud Firestore será aplicado ao seu banco de dados padrão do Cloud Firestore. Se você criar vários bancos de dados para seu projeto, poderá implantar regras de segurança do Cloud Firestore para cada banco de dados.

  4. Selecione um local para seu banco de dados.

    • Esta configuração de local é o local de recurso padrão do Google Cloud Platform (GCP) do seu projeto. Observe que esse local será usado para serviços do GCP no seu projeto que exigem uma configuração de local, especificamente, seu intervalo padrão do Cloud Storage e seu aplicativo do App Engine (o que é necessário se você usar o Cloud Scheduler).

    • Se você não conseguir selecionar um local, seu projeto já terá um local de recurso padrão do GCP. Foi definido durante a criação do projeto ou durante a configuração de outro serviço que requer uma configuração de localização.

  5. Clique em Concluído .

Ao ativar o Cloud Firestore, ele também ativa a API no Cloud API Manager .

Configure seu ambiente de desenvolvimento

Adicione as dependências e bibliotecas de cliente necessárias ao seu aplicativo.

Web namespaced API

  1. Siga as instruções para adicionar o Firebase ao seu aplicativo Web .
  2. Adicione as bibliotecas Firebase e Cloud Firestore ao seu aplicativo:
    <script src="https://www.gstatic.com/firebasejs/10.9.0/firebase-app-compat.js"></script>
    <script src="https://www.gstatic.com/firebasejs/10.9.0/firebase-firestore-compat.js"></script>
    O SDK do Cloud Firestore também está disponível como um pacote npm.
    npm install firebase@10.9.0 --save
    
    Você precisará exigir manualmente o Firebase e o Cloud Firestore.
    import firebase from "firebase/compat/app";
    // Required for side-effects
    import "firebase/firestore";
    

Web modular API

  1. Siga as instruções para adicionar o Firebase ao seu aplicativo Web .
  2. O SDK do Cloud Firestore está disponível como um pacote npm.
    npm install firebase@10.9.0 --save
    
    Você precisará importar o Firebase e o Cloud Firestore.
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";
    
iOS+

Siga as instruções para adicionar o Firebase ao seu aplicativo Apple .

Use o Swift Package Manager para instalar e gerenciar dependências do Firebase.

  1. No Xcode, com o projeto do seu aplicativo aberto, navegue até File > Swift Packages > Add Package Dependency .
  2. Quando solicitado, adicione o repositório SDK das plataformas Apple do Firebase:
  3.   https://github.com/firebase/firebase-ios-sdk
      
  4. Escolha a biblioteca Firestore.
  5. Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.
Android
  1. Siga as instruções para adicionar o Firebase ao seu aplicativo Android .
  2. Usando o Firebase Android BoM , declare a dependência da biblioteca Cloud Firestore para Android no arquivo Gradle do módulo (nível do aplicativo) (geralmente app/build.gradle.kts ou app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.8.0"))
    
        // Declare the dependency for the Cloud Firestore library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-firestore")
    }
    

    Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

    (Alternativa) Declarar dependências da biblioteca Firebase sem usar o BoM

    Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

    Observe que se você usa várias bibliotecas do Firebase em seu aplicativo, é altamente recomendável usar a BoM para gerenciar versões de bibliotecas, o que garante que todas as versões sejam compatíveis.

    dependencies {
        // Declare the dependency for the Cloud Firestore library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-firestore:24.11.0")
    }
    

    Procurando um módulo de biblioteca específico para Kotlin? A partir da versão de outubro de 2023 , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).

Dart

  1. Se ainda não o fez, configure e inicialize o Firebase em seu aplicativo Flutter.
  2. Na raiz do seu projeto Flutter, execute o seguinte comando para instalar o plugin:
    flutter pub add cloud_firestore
  3. Depois de concluído, reconstrua seu aplicativo Flutter:
    flutter run
  4. Opcional: melhore os tempos de compilação do iOS e macOS incluindo a estrutura pré-compilada.

    Atualmente, o SDK do Firestore para iOS depende de um código que pode levar mais de 5 minutos para ser compilado no Xcode. Para reduzir significativamente o tempo de compilação, você pode usar uma versão pré-compilada adicionando esta linha ao bloco target 'Runner' do em seu Podfile:

    target 'Runner' do
      use_frameworks!
      use_modular_headers!
    
      pod 'FirebaseFirestore',
        :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git',
        :tag => 'IOS_SDK_VERSION'
    
      flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
      target 'RunnerTests' do
        inherit! :search_paths
      end
    end

    Substitua IOS_SDK_VERSION pela versão do SDK do Firebase para iOS especificada no arquivo firebase_sdk_version.rb de firebase_core . Se você não estiver usando a versão mais recente do firebase_core , procure esse arquivo no cache local do pacote Pub (geralmente ~/.pub-cache ).

    Além disso, certifique-se de ter atualizado o CocoaPods para 1.9.1 ou superior:

    gem install cocoapods

    Para obter mais informações, consulte o problema no GitHub .

Java
  1. Adicione o SDK Admin do Firebase ao seu aplicativo:
    • Usando Gradle:
      compile 'com.google.firebase:firebase-admin:1.32.0'
      
    • Usando Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>1.32.0</version>
      </dependency>
           
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
Pitão
  1. Adicione o SDK Admin do Firebase ao seu aplicativo Python:
    pip install --upgrade firebase-admin
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
C++
  1. Siga as instruções para adicionar o Firebase ao seu projeto C++ .
  2. Interface C++ para Android.
    • Dependências do Gradle. Adicione o seguinte ao arquivo Gradle do módulo (nível do aplicativo) (geralmente app/build.gradle ):
              android.defaultConfig.externalNativeBuild.cmake {
                arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir"
              }
      
              apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle"
              firebaseCpp.dependencies {
                // earlier entries
                auth
                firestore
              }
              
    • Dependências binárias. Da mesma forma, a maneira recomendada de obter as dependências binárias é adicionar o seguinte ao seu arquivo CMakeLists.txt :
              add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)
              set(firebase_libs firebase_auth firebase_firestore firebase_app)
              # Replace the target name below with the actual name of your target,
              # for example, "native-lib".
              target_link_libraries(${YOUR_TARGET_NAME_HERE} "${firebase_libs}")
              
  3. Para configurar a integração com desktop , consulte Adicionar o Firebase ao seu projeto C++ .
Unidade
  1. Siga as instruções para adicionar o Firebase ao seu projeto Unity .
  2. Use a interface do Unity para configurar seu projeto para reduzir compilações do Android.
  3. Você deve reduzir a compilação para evitar a mensagem Error while merging dex archives .

    • A opção pode ser encontrada em Configurações do Player > Android > Configurações de Publicação > Minify .
    • As opções podem diferir em diferentes versões do Unity, portanto, consulte a documentação oficial do Unity e o Guia de depuração do Firebase Unity Build .
    • Se, após habilitar a minificação, o número de métodos referenciados ainda ultrapassar o limite, outra opção é habilitar multidex em:
      • mainTemplate.gradle se o modelo personalizado do Gradle nas configurações do player estiver ativado
      • ou o arquivo build.gradle no nível do módulo, se você usar o Android Studio para criar o projeto exportado.
Node.js
  1. Adicione o SDK Admin do Firebase ao seu aplicativo:
    npm install firebase-admin --save
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
Ir
  1. Adicione o SDK Admin do Firebase ao seu aplicativo Go:
    go get firebase.google.com/go
    
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
PHP
  1. As bibliotecas cliente do servidor Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam Google Application Default Credentials para autenticação.
    • Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para apontar para um arquivo de chave de conta de serviço JSON. Você pode criar um arquivo de chave na página Credenciais do Console de API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, você não precisará autenticar se executar seu aplicativo no App Engine ou no Compute Engine usando o mesmo projeto usado no Cloud Firestore. Caso contrário, configure uma conta de serviço .
  2. Instale e habilite a extensão gRPC para PHP, que você precisará para usar a biblioteca cliente.
  3. Adicione a biblioteca PHP do Cloud Firestore ao seu aplicativo:
    composer require google/cloud-firestore
C#
  1. As bibliotecas cliente do servidor Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam Google Application Default Credentials para autenticação.
    • Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para apontar para um arquivo de chave de conta de serviço JSON. Você pode criar um arquivo de chave na página Credenciais do Console de API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, você não precisará autenticar se executar seu aplicativo no App Engine ou no Compute Engine usando o mesmo projeto usado no Cloud Firestore. Caso contrário, configure uma conta de serviço .
  2. Adicione a biblioteca Cloud Firestore C# ao seu aplicativo no arquivo .csproj :
    <ItemGroup>
      <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
    </ItemGroup>
  3. Adicione o seguinte ao seu arquivo Program.cs :
    using Google.Cloud.Firestore;
Rubi
  1. As bibliotecas cliente do servidor Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam Google Application Default Credentials para autenticação.
    • Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para apontar para um arquivo de chave de conta de serviço JSON. Você pode criar um arquivo de chave na página Credenciais do Console de API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, você não precisará autenticar se executar seu aplicativo no App Engine ou no Compute Engine usando o mesmo projeto usado no Cloud Firestore. Caso contrário, configure uma conta de serviço .
  2. Adicione a biblioteca Cloud Firestore Ruby ao seu aplicativo em seu Gemfile :
    gem "google-cloud-firestore"
  3. Instale dependências do seu Gemfile usando:
    bundle install

(Opcional) Protótipo e teste com Firebase Local Emulator Suite

Para desenvolvedores móveis, antes de falar sobre como seu aplicativo grava e lê no Cloud Firestore, vamos apresentar um conjunto de ferramentas que você pode usar para prototipar e testar a funcionalidade do Cloud Firestore: Firebase Local Emulator Suite. Se você estiver experimentando diferentes modelos de dados, otimizando suas regras de segurança ou trabalhando para encontrar a maneira mais econômica de interagir com o back-end, poder trabalhar localmente sem implantar serviços ativos pode ser uma ótima ideia.

Um emulador do Cloud Firestore faz parte do Local Emulator Suite, que permite que seu aplicativo interaja com o conteúdo e a configuração do banco de dados emulado, bem como, opcionalmente, com os recursos do projeto emulado (funções, outros bancos de dados e regras de segurança).

Usar o emulador Cloud Firestore envolve apenas algumas etapas:

  1. Adicionando uma linha de código à configuração de teste do seu aplicativo para conectar-se ao emulador.
  2. Na raiz do diretório local do projeto, executando firebase emulators:start .
  3. Fazer chamadas a partir do código do protótipo do seu app usando um SDK da plataforma Cloud Firestore normalmente.

Um passo a passo detalhado envolvendo Cloud Firestore e Cloud Functions está disponível. Você também deve dar uma olhada na introdução do Local Emulator Suite .

Inicializar o Cloud Firestore

Inicialize uma instância do Cloud Firestore:

Web modular API

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = getFirestore(app);

Substitua FIREBASE_CONFIGURATION pelo firebaseConfig do seu aplicativo da web.

Para persistir os dados quando o dispositivo perder a conexão, consulte a documentação Ativar dados off-line .

Web namespaced API

import firebase from "firebase/app";
import "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
firebase.initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = firebase.firestore();

Substitua FIREBASE_CONFIGURATION pelo firebaseConfig do seu aplicativo da web.

Para persistir os dados quando o dispositivo perder a conexão, consulte a documentação Ativar dados off-line .

Rápido
Observação: este produto não está disponível em destinos watchOS e App Clip.
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
Objetivo-C
Observação: este produto não está disponível em destinos watchOS e App Clip.
@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];
  
FIRFirestore *defaultFirestore = [FIRFirestore firestore];

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore

Java

// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();

Dart

db = FirebaseFirestore.instance;
Java
O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;
    
    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;
    
    // Use the application default credentials
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    FirebaseOptions options = new FirebaseOptions.Builder()
        .setCredentials(credentials)
        .setProjectId(projectId)
        .build();
    FirebaseApp.initializeApp(options);
    
    Firestore db = FirestoreClient.getFirestore();
    
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;
    
    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;
    
    // Use a service account
    InputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json");
    GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount);
    FirebaseOptions options = new FirebaseOptions.Builder()
        .setCredentials(credentials)
        .build();
    FirebaseApp.initializeApp(options);
    
    Firestore db = FirestoreClient.getFirestore();
    
  • Pitão
    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import firebase_admin
    from firebase_admin import firestore
    
    # Application Default credentials are automatically created.
    app = firebase_admin.initialize_app()
    db = firestore.client()

    Uma credencial padrão do aplicativo existente também pode ser usada para inicializar o SDK.

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore
    
    # Use the application default credentials.
    cred = credentials.ApplicationDefault()
    
    firebase_admin.initialize_app(cred)
    db = firestore.client()
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore
    
    # Use a service account.
    cred = credentials.Certificate('path/to/serviceAccount.json')
    
    app = firebase_admin.initialize_app(cred)
    
    db = firestore.client()
  • Python

    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import firebase_admin
    from firebase_admin import firestore_async
    
    # Application Default credentials are automatically created.
    app = firebase_admin.initialize_app()
    db = firestore_async.client()

    Uma credencial padrão do aplicativo existente também pode ser usada para inicializar o SDK.

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async
    
    # Use the application default credentials.
    cred = credentials.ApplicationDefault()
    
    firebase_admin.initialize_app(cred)
    db = firestore_async.client()
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async
    
    # Use a service account.
    cred = credentials.Certificate('path/to/serviceAccount.json')
    
    app = firebase_admin.initialize_app(cred)
    
    db = firestore_async.client()
  • C++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    Node.js
    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
    • Inicializar no Cloud Functions
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp();
      
      const db = getFirestore();
      
    • Inicializar no Google Cloud
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp({
        credential: applicationDefault()
      });
      
      const db = getFirestore();
    • Inicialize em seu próprio servidor

      Para usar o SDK Admin do Firebase em seu próprio servidor (ou em qualquer outro ambiente Node.js), use uma conta de serviço . Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      initializeApp({
        credential: cert(serviceAccount)
      });
      
      const db = getFirestore();
      
    Ir
    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import (
      "log"
    
      firebase "firebase.google.com/go"
      "google.golang.org/api/option"
    )
    
    // Use the application default credentials
    ctx := context.Background()
    conf := &firebase.Config{ProjectID: projectID}
    app, err := firebase.NewApp(ctx, conf)
    if err != nil {
      log.Fatalln(err)
    }
    
    client, err := app.Firestore(ctx)
    if err != nil {
      log.Fatalln(err)
    }
    defer client.Close()
    
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import (
      "log"
    
      firebase "firebase.google.com/go"
      "google.golang.org/api/option"
    )
    
    // Use a service account
    ctx := context.Background()
    sa := option.WithCredentialsFile("path/to/serviceAccount.json")
    app, err := firebase.NewApp(ctx, nil, sa)
    if err != nil {
      log.Fatalln(err)
    }
    
    client, err := app.Firestore(ctx)
    if err != nil {
      log.Fatalln(err)
    }
    defer client.Close()
    
  • PHP

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    use Google\Cloud\Firestore\FirestoreClient;
    
    /**
     * Initialize Cloud Firestore with default project ID.
     */
    function setup_client_create(string $projectId = null)
    {
        // Create the Cloud Firestore client
        if (empty($projectId)) {
            // The `projectId` parameter is optional and represents which project the
            // client will act on behalf of. If not supplied, the client falls back to
            // the default project inferred from the environment.
            $db = new FirestoreClient();
            printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
        } else {
            $db = new FirestoreClient([
                'projectId' => $projectId,
            ]);
            printf('Created Cloud Firestore client with project ID: %s' . PHP_EOL, $projectId);
        }
    }
    Unidade
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    C#

    C#

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Rubi
    require "google/cloud/firestore"
    
    # The `project_id` parameter is optional and represents which project the
    # client will act on behalf of. If not supplied, the client falls back to the
    # default project inferred from the environment.
    firestore = Google::Cloud::Firestore.new project_id: project_id
    
    puts "Created Cloud Firestore client with given project ID."

    Adicionar dados

    O Cloud Firestore armazena dados em Documentos, que são armazenados em Coleções. O Cloud Firestore cria coleções e documentos implicitamente na primeira vez que você adiciona dados ao documento. Você não precisa criar coleções ou documentos explicitamente.

    Crie uma nova coleção e um documento usando o código de exemplo a seguir.

    Web modular API

    import { collection, addDoc } from "firebase/firestore"; 
    
    try {
      const docRef = await addDoc(collection(db, "users"), {
        first: "Ada",
        last: "Lovelace",
        born: 1815
      });
      console.log("Document written with ID: ", docRef.id);
    } catch (e) {
      console.error("Error adding document: ", e);
    }

    Web namespaced API

    db.collection("users").add({
        first: "Ada",
        last: "Lovelace",
        born: 1815
    })
    .then((docRef) => {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
        console.error("Error adding document: ", error);
    });
    Rápido
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // Add a new document with a generated ID
    do {
      let ref = try await db.collection("users").addDocument(data: [
        "first": "Ada",
        "last": "Lovelace",
        "born": 1815
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    Objetivo-C
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // Add a new document with a generated ID
    __block FIRDocumentReference *ref =
        [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
          @"first": @"Ada",
          @"last": @"Lovelace",
          @"born": @1815
        } completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error adding document: %@", error);
          } else {
            NSLog(@"Document added with ID: %@", ref.documentID);
          }
        }];

    Kotlin+KTX

    // Create a new user with a first and last name
    val user = hashMapOf(
        "first" to "Ada",
        "last" to "Lovelace",
        "born" to 1815,
    )
    
    // Add a new document with a generated ID
    db.collection("users")
        .add(user)
        .addOnSuccessListener { documentReference ->
            Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "Error adding document", e)
        }

    Java

    // Create a new user with a first and last name
    Map<String, Object> user = new HashMap<>();
    user.put("first", "Ada");
    user.put("last", "Lovelace");
    user.put("born", 1815);
    
    // Add a new document with a generated ID
    db.collection("users")
            .add(user)
            .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
                @Override
                public void onSuccess(DocumentReference documentReference) {
                    Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error adding document", e);
                }
            });

    Dart

    // Create a new user with a first and last name
    final user = <String, dynamic>{
      "first": "Ada",
      "last": "Lovelace",
      "born": 1815
    };
    
    // Add a new document with a generated ID
    db.collection("users").add(user).then((DocumentReference doc) =>
        print('DocumentSnapshot added with ID: ${doc.id}'));
    Java
    DocumentReference docRef = db.collection("users").document("alovelace");
    // Add document data  with id "alovelace" using a hashmap
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Ada");
    data.put("last", "Lovelace");
    data.put("born", 1815);
    //asynchronously write data
    ApiFuture<WriteResult> result = docRef.set(data);
    // ...
    // result.get() blocks on response
    System.out.println("Update time : " + result.get().getUpdateTime());
    Pitão
    doc_ref = db.collection("users").document("alovelace")
    doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})

    Python

    doc_ref = db.collection("users").document("alovelace")
    await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    C++
    // Add a new document with a generated ID
    Future<DocumentReference> user_ref =
        db->Collection("users").Add({{"first", FieldValue::String("Ada")},
                                     {"last", FieldValue::String("Lovelace")},
                                     {"born", FieldValue::Integer(1815)}});
    
    user_ref.OnCompletion([](const Future<DocumentReference>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot added with ID: " << future.result()->id()
                  << std::endl;
      } else {
        std::cout << "Error adding document: " << future.error_message() << std::endl;
      }
    });
    Node.js
    const docRef = db.collection('users').doc('alovelace');
    
    await docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
    Ir
    _, _, err := client.Collection("users").Add(ctx, map[string]interface{}{
    	"first": "Ada",
    	"last":  "Lovelace",
    	"born":  1815,
    })
    if err != nil {
    	log.Fatalf("Failed adding alovelace: %v", err)
    }
    PHP

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $docRef = $db->collection('samples/php/users')->document('alovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    Unidade
    DocumentReference docRef = db.Collection("users").Document("alovelace");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
    	{ "First", "Ada" },
    	{ "Last", "Lovelace" },
    	{ "Born", 1815 },
    };
    docRef.SetAsync(user).ContinueWithOnMainThread(task => {
    	Debug.Log("Added data to the alovelace document in the users collection.");
    });
    C#
    DocumentReference docRef = db.Collection("users").Document("alovelace");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Ada" },
        { "Last", "Lovelace" },
        { "Born", 1815 }
    };
    await docRef.SetAsync(user);
    Rubi
    doc_ref = firestore.doc "#{collection_path}/alovelace"
    
    doc_ref.set(
      {
        first: "Ada",
        last:  "Lovelace",
        born:  1815
      }
    )
    
    puts "Added data to the alovelace document in the users collection."

    Agora adicione outro documento à coleção users . Observe que este documento inclui um par chave-valor (nome do meio) que não aparece no primeiro documento. Os documentos de uma coleção podem conter diferentes conjuntos de informações.

    Web modular API

    // Add a second document with a generated ID.
    import { addDoc, collection } from "firebase/firestore"; 
    
    try {
      const docRef = await addDoc(collection(db, "users"), {
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
      });
    
      console.log("Document written with ID: ", docRef.id);
    } catch (e) {
      console.error("Error adding document: ", e);
    }

    Web namespaced API

    // Add a second document with a generated ID.
    db.collection("users").add({
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
    })
    .then((docRef) => {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
        console.error("Error adding document: ", error);
    });
    Rápido
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // Add a second document with a generated ID.
    do {
      let ref = try await db.collection("users").addDocument(data: [
        "first": "Alan",
        "middle": "Mathison",
        "last": "Turing",
        "born": 1912
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    Objetivo-C
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // Add a second document with a generated ID.
    __block FIRDocumentReference *ref =
        [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
          @"first": @"Alan",
          @"middle": @"Mathison",
          @"last": @"Turing",
          @"born": @1912
        } completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error adding document: %@", error);
          } else {
            NSLog(@"Document added with ID: %@", ref.documentID);
          }
        }];

    Kotlin+KTX

    // Create a new user with a first, middle, and last name
    val user = hashMapOf(
        "first" to "Alan",
        "middle" to "Mathison",
        "last" to "Turing",
        "born" to 1912,
    )
    
    // Add a new document with a generated ID
    db.collection("users")
        .add(user)
        .addOnSuccessListener { documentReference ->
            Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "Error adding document", e)
        }

    Java

    // Create a new user with a first, middle, and last name
    Map<String, Object> user = new HashMap<>();
    user.put("first", "Alan");
    user.put("middle", "Mathison");
    user.put("last", "Turing");
    user.put("born", 1912);
    
    // Add a new document with a generated ID
    db.collection("users")
            .add(user)
            .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
                @Override
                public void onSuccess(DocumentReference documentReference) {
                    Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error adding document", e);
                }
            });

    Dart

    // Create a new user with a first and last name
    final user = <String, dynamic>{
      "first": "Alan",
      "middle": "Mathison",
      "last": "Turing",
      "born": 1912
    };
    
    // Add a new document with a generated ID
    db.collection("users").add(user).then((DocumentReference doc) =>
        print('DocumentSnapshot added with ID: ${doc.id}'));
    Java
    DocumentReference docRef = db.collection("users").document("aturing");
    // Add document data with an additional field ("middle")
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Alan");
    data.put("middle", "Mathison");
    data.put("last", "Turing");
    data.put("born", 1912);
    
    ApiFuture<WriteResult> result = docRef.set(data);
    System.out.println("Update time : " + result.get().getUpdateTime());
    Pitão
    doc_ref = db.collection("users").document("aturing")
    doc_ref.set({"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912})

    Python

    doc_ref = db.collection("users").document("aturing")
    await doc_ref.set(
        {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
    )
    C++
    db->Collection("users")
        .Add({{"first", FieldValue::String("Alan")},
              {"middle", FieldValue::String("Mathison")},
              {"last", FieldValue::String("Turing")},
              {"born", FieldValue::Integer(1912)}})
        .OnCompletion([](const Future<DocumentReference>& future) {
          if (future.error() == Error::kErrorOk) {
            std::cout << "DocumentSnapshot added with ID: "
                      << future.result()->id() << std::endl;
          } else {
            std::cout << "Error adding document: " << future.error_message()
                      << std::endl;
          }
        });
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');
    
    await aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
    Ir
    _, _, err = client.Collection("users").Add(ctx, map[string]interface{}{
    	"first":  "Alan",
    	"middle": "Mathison",
    	"last":   "Turing",
    	"born":   1912,
    })
    if err != nil {
    	log.Fatalf("Failed adding aturing: %v", err)
    }
    PHP

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $docRef = $db->collection('samples/php/users')->document('aturing');
    $docRef->set([
        'first' => 'Alan',
        'middle' => 'Mathison',
        'last' => 'Turing',
        'born' => 1912
    ]);
    printf('Added data to the aturing document in the users collection.' . PHP_EOL);
    Unidade
    DocumentReference docRef = db.Collection("users").Document("aturing");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
    	{ "First", "Alan" },
    	{ "Middle", "Mathison" },
    	{ "Last", "Turing" },
    	{ "Born", 1912 }
    };
    docRef.SetAsync(user).ContinueWithOnMainThread(task => {
    	Debug.Log("Added data to the aturing document in the users collection.");
    });
    C#
    DocumentReference docRef = db.Collection("users").Document("aturing");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Alan" },
        { "Middle", "Mathison" },
        { "Last", "Turing" },
        { "Born", 1912 }
    };
    await docRef.SetAsync(user);
    Rubi
    doc_ref = firestore.doc "#{collection_path}/aturing"
    
    doc_ref.set(
      {
        first:  "Alan",
        middle: "Mathison",
        last:   "Turing",
        born:   1912
      }
    )
    
    puts "Added data to the aturing document in the users collection."

    Ler dados

    Use o visualizador de dados no Console do Firebase para verificar rapidamente se você adicionou dados ao Cloud Firestore.

    Você também pode usar o método “get” para recuperar a coleção inteira.

    Web modular API

    import { collection, getDocs } from "firebase/firestore"; 
    
    const querySnapshot = await getDocs(collection(db, "users"));
    querySnapshot.forEach((doc) => {
      console.log(`${doc.id} => ${doc.data()}`);
    });

    Web namespaced API

    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });
    Rápido
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    do {
      let snapshot = try await db.collection("users").getDocuments()
      for document in snapshot.documents {
        print("\(document.documentID) => \(document.data())")
      }
    } catch {
      print("Error getting documents: \(error)")
    }
    Objetivo-C
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    [[self.db collectionWithPath:@"users"]
        getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                     NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error getting documents: %@", error);
          } else {
            for (FIRDocumentSnapshot *document in snapshot.documents) {
              NSLog(@"%@ => %@", document.documentID, document.data);
            }
          }
        }];

    Kotlin+KTX

    db.collection("users")
        .get()
        .addOnSuccessListener { result ->
            for (document in result) {
                Log.d(TAG, "${document.id} => ${document.data}")
            }
        }
        .addOnFailureListener { exception ->
            Log.w(TAG, "Error getting documents.", exception)
        }

    Java

    db.collection("users")
            .get()
            .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                @Override
                public void onComplete(@NonNull Task<QuerySnapshot> task) {
                    if (task.isSuccessful()) {
                        for (QueryDocumentSnapshot document : task.getResult()) {
                            Log.d(TAG, document.getId() + " => " + document.getData());
                        }
                    } else {
                        Log.w(TAG, "Error getting documents.", task.getException());
                    }
                }
            });

    Dart

    await db.collection("users").get().then((event) {
      for (var doc in event.docs) {
        print("${doc.id} => ${doc.data()}");
      }
    });
    Java
    // asynchronously retrieve all users
    ApiFuture<QuerySnapshot> query = db.collection("users").get();
    // ...
    // query.get() blocks on response
    QuerySnapshot querySnapshot = query.get();
    List<QueryDocumentSnapshot> documents = querySnapshot.getDocuments();
    for (QueryDocumentSnapshot document : documents) {
      System.out.println("User: " + document.getId());
      System.out.println("First: " + document.getString("first"));
      if (document.contains("middle")) {
        System.out.println("Middle: " + document.getString("middle"));
      }
      System.out.println("Last: " + document.getString("last"));
      System.out.println("Born: " + document.getLong("born"));
    }
    Pitão
    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    for doc in docs:
        print(f"{doc.id} => {doc.to_dict()}")

    Python

    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    async for doc in docs:
        print(f"{doc.id} => {doc.to_dict()}")
    C++
    Future<QuerySnapshot> users = db->Collection("users").Get();
    users.OnCompletion([](const Future<QuerySnapshot>& future) {
      if (future.error() == Error::kErrorOk) {
        for (const DocumentSnapshot& document : future.result()->documents()) {
          std::cout << document << std::endl;
        }
      } else {
        std::cout << "Error getting documents: " << future.error_message()
                  << std::endl;
      }
    });
    Node.js
    const snapshot = await db.collection('users').get();
    snapshot.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
    Ir
    iter := client.Collection("users").Documents(ctx)
    for {
    	doc, err := iter.Next()
    	if err == iterator.Done {
    		break
    	}
    	if err != nil {
    		log.Fatalf("Failed to iterate: %v", err)
    	}
    	fmt.Println(doc.Data())
    }
    PHP

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $usersRef = $db->collection('samples/php/users');
    $snapshot = $usersRef->documents();
    foreach ($snapshot as $user) {
        printf('User: %s' . PHP_EOL, $user->id());
        printf('First: %s' . PHP_EOL, $user['first']);
        if (!empty($user['middle'])) {
            printf('Middle: %s' . PHP_EOL, $user['middle']);
        }
        printf('Last: %s' . PHP_EOL, $user['last']);
        printf('Born: %d' . PHP_EOL, $user['born']);
        printf(PHP_EOL);
    }
    printf('Retrieved and printed out all documents from the users collection.' . PHP_EOL);
    Unidade
    CollectionReference usersRef = db.Collection("users");
    usersRef.GetSnapshotAsync().ContinueWithOnMainThread(task =>
    {
      QuerySnapshot snapshot = task.Result;
      foreach (DocumentSnapshot document in snapshot.Documents)
      {
        Debug.Log(String.Format("User: {0}", document.Id));
        Dictionary<string, object> documentDictionary = document.ToDictionary();
        Debug.Log(String.Format("First: {0}", documentDictionary["First"]));
        if (documentDictionary.ContainsKey("Middle"))
        {
          Debug.Log(String.Format("Middle: {0}", documentDictionary["Middle"]));
        }
    
        Debug.Log(String.Format("Last: {0}", documentDictionary["Last"]));
        Debug.Log(String.Format("Born: {0}", documentDictionary["Born"]));
      }
    
      Debug.Log("Read all data from the users collection.");
    });
    C#
    CollectionReference usersRef = db.Collection("users");
    QuerySnapshot snapshot = await usersRef.GetSnapshotAsync();
    foreach (DocumentSnapshot document in snapshot.Documents)
    {
        Console.WriteLine("User: {0}", document.Id);
        Dictionary<string, object> documentDictionary = document.ToDictionary();
        Console.WriteLine("First: {0}", documentDictionary["First"]);
        if (documentDictionary.ContainsKey("Middle"))
        {
            Console.WriteLine("Middle: {0}", documentDictionary["Middle"]);
        }
        Console.WriteLine("Last: {0}", documentDictionary["Last"]);
        Console.WriteLine("Born: {0}", documentDictionary["Born"]);
        Console.WriteLine();
    }
    Rubi
    users_ref = firestore.col collection_path
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end

    Proteja seus dados

    Se você estiver usando o SDK das plataformas Web, Android ou Apple, use o Firebase Authentication e as regras de segurança do Cloud Firestore para proteger seus dados no Cloud Firestore.

    Aqui estão alguns conjuntos de regras básicas que você pode usar para começar. Você pode modificar suas regras de segurança na guia Regras do console.

    Autenticação necessária

    // Allow read/write access to a document keyed by the user's UID
    service cloud.firestore {
      match /databases/{database}/documents {
        match /users/{uid} {
          allow read, write: if request.auth != null && request.auth.uid == uid;
        }
      }
    }
    

    Modo bloqueado

    // Deny read/write access to all users under any conditions
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if false;
        }
      }
    }
    

    Antes de implantar seu aplicativo Web, Android ou iOS em produção, tome também medidas para garantir que apenas os clientes do seu aplicativo possam acessar os dados do Cloud Firestore. Consulte a documentação do App Check .

    Se você estiver usando um dos SDKs de servidor, use o gerenciamento de identidade e acesso (IAM) para proteger seus dados no Cloud Firestore.

    Assista a um tutorial em vídeo

    Para obter orientações detalhadas sobre como começar a usar as bibliotecas de cliente móvel do Cloud Firestore, assista a um dos seguintes tutoriais em vídeo:

    Rede
    iOS+
    Android

    Você pode encontrar mais vídeos no canal do Firebase no YouTube .

    Próximos passos

    Aprofunde seus conhecimentos com os seguintes temas: