O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Primeiros passos com o Cloud Firestore

Veja neste guia de início rápido como configurar o Cloud Firestore, adicionar dados e ver os dados adicionados no Firebase console.

Criar um banco de dados do Cloud Firestore

  1. Crie um projeto do Firebase, se você ainda não fez isso: no Console do Firebase (em inglês), clique em Adicionar projeto e siga as instruções na tela para criar um projeto ou adicionar serviços do Firebase a um projeto do GCP.

  2. Acesse a seção Banco de dados do Console do Firebase. Você será solicitado a escolher um projeto existente do Firebase. Siga o fluxo de trabalho de criação do banco de dados.

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

    Modo de teste

    Ideal para dar os primeiros passos com as bibliotecas de cliente de dispositivos móveis e Web. No entanto, esse modo permite que qualquer pessoa leia e modifique os dados. Depois do teste, revise a seção Proteger seus dados.

    Selecione o modo de teste para começar a usar o SDK para Android, iOS ou da Web.

    Modo bloqueado

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

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

  4. Selecione um local para seu banco de dados.

    • Essa configuração de localização é o local padrão dos recursos do Google Cloud Platform (GCP) no seu projeto. Esse local será usado para serviços do GCP no projeto que exigem uma configuração de local, especificamente o intervalo padrão do Cloud Storage e o aplicativo do App Engine que é obrigatório se você usa o Cloud Scheduler.

    • Se você não conseguir selecionar um local, isso significa que seu projeto já tem um local padrão dos recursos do GCP. Ele foi definido durante a criação do projeto ou na configuração de outro serviço que exigia uma configuração de local.

  5. Clique em Concluído.

Quando você ativa o Cloud Firestore, ele ativa a API no Gerenciador de APIs do Cloud.

Configurar o ambiente de desenvolvimento

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

Web
  1. Siga as instruções para adicionar o Firebase ao seu app da Web.
  2. Adicione as bibliotecas do Firebase e do Cloud Firestore ao seu app:
    <script src="https://www.gstatic.com/firebasejs/7.14.4/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/7.14.4/firebase-firestore.js"></script>
    O Cloud Firestore SDK também está disponível como um pacote npm.
    npm install firebase@7.14.4 --save
    
    Você precisará requisitar manualmente o Firebase e o Cloud Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    
iOS
  1. Siga as instruções para adicionar o Firebase ao seu app para iOS.
  2. Adicione o pod do Cloud Firestore ao seu Podfile
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Salve o arquivo e execute pod install

Java

  1. Siga as instruções para adicionar o Firebase ao seu app para Android.
  2. No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.
  3. Adicione a biblioteca Android do Cloud Firestore ao arquivo Gradle do módulo (nível do aplicativo) (geralmente app/build.gradle):
    implementation 'com.google.firebase:firebase-firestore:21.4.3'

Kotlin+KTX

  1. Siga as instruções para adicionar o Firebase ao seu app para Android.
  2. No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.
  3. Adicione a biblioteca Android do Cloud Firestore ao arquivo Gradle do módulo (nível do aplicativo), geralmente app/build.gradle:
    implementation 'com.google.firebase:firebase-firestore-ktx:21.4.3'
Java
  1. Adicione o SDK Admin do Firebase ao seu app:
    • Com o Gradle:
      compile 'com.google.firebase:firebase-admin:6.13.0'
      
    • Com o Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>6.13.0</version>
      </dependency>
           
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais apropriadas no seu ambiente.
Python
  1. Adicione o SDK Admin do Firebase ao seu app para Python:
    pip install --upgrade firebase-admin
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais apropriadas no seu ambiente.
C++
  1. Siga as instruções para adicionar o Firebase ao seu projeto do C++.
  2. Interface C ++ para Android.
    • Dependências do Gradle. Adicione o seguinte ao seu 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 receber as dependências binárias é adicionar o seguinte ao 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 de área de trabalho, consulte Adicionar o Firebase ao seu projeto em C ++.
Unity
  1. Siga as instruções para adicionar o Firebase ao seu projeto do Unity.
  2. Interface do Unity para Android.
  3. Ao criar a versão para Android, ative o ProGuard para evitar o limite de DEX do Android. Para fazer isso, no editor do Unity:

    1. Selecione "Arquivo" > "Configurações do build".
    2. Alterne "Plataforma" para "Android" e clique em "Alternar plataforma"
    3. Clique em "Configurações do jogador".
    4. Na IU principal do Unity, em "Configurações para Android", selecione "Configurações de publicação"
    5. Na seção "Minificar", altere as configurações de lançamento e depuração de "Nenhum" para "ProGuard"
Node.js
  1. Adicione o SDK Admin do Firebase ao seu app:
    npm install firebase-admin --save
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais apropriadas no seu ambiente.
Go
  1. Adicione o SDK Admin do Firebase ao seu app para Go:
    go get firebase.google.com/go
    
  2. Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais apropriadas no seu ambiente.
PHP
  1. As bibliotecas de cliente do servidor do Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam o Application Default Credentials do Google para realizar a autenticação.
    • Para realizar a autenticação do seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para indicar um arquivo de chave de conta do serviço JSON. É possível criar um arquivo de chave na página Credenciais, do Console de APIs.
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, não é necessário fazer a autenticação quando o aplicativo é executado no App Engine ou no Compute Engine usando o mesmo projeto utilizado para o Cloud Firestore. Caso contrário, configure uma conta de serviço.
  2. Instale e ative a extensão gRPC para PHP, necessária para usar a biblioteca de cliente.
  3. Adicione a biblioteca PHP do Cloud Firestore ao aplicativo:
    composer require google/cloud-firestore
C#
  1. As bibliotecas de cliente do servidor do Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam o Application Default Credentials do Google para realizar a autenticação.
    • Para realizar a autenticação do seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para indicar um arquivo de chave de conta do serviço JSON. É possível criar um arquivo de chave na página Credenciais, do Console de APIs.
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, não é necessário fazer a autenticação quando o aplicativo é executado no App Engine ou no Compute Engine usando o mesmo projeto utilizado para o Cloud Firestore. Caso contrário, configure uma conta de serviço.
  2. Adicione a biblioteca C# do Cloud Firestore ao arquivo .csproj:
    <ItemGroup>
      <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
    </ItemGroup>
  3. Adicione a instrução a seguir ao seu arquivo Program.cs:
    using Google.Cloud.Firestore;
Ruby
  1. As bibliotecas de cliente do servidor do Cloud Firestore (Java, Node.js, Python, Go, PHP, C# e Ruby) usam o Application Default Credentials do Google para realizar a autenticação.
    • Para realizar a autenticação do seu ambiente de desenvolvimento, defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para indicar um arquivo de chave de conta do serviço JSON. É possível criar um arquivo de chave na página Credenciais, do Console de APIs.
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • No seu ambiente de produção, não é necessário fazer a autenticação quando o aplicativo é executado no App Engine ou no Compute Engine usando o mesmo projeto utilizado para o Cloud Firestore. Caso contrário, configure uma conta de serviço.
  2. Adicione a biblioteca Ruby do Cloud Firestore ao aplicativo no Gemfile:
    gem "google-cloud-firestore"
  3. Instale as dependências do seu Gemfile usando:
    bundle install

Inicializar o Cloud Firestore

Inicialize uma instância do Cloud Firestore:

Web
// Initialize Cloud Firestore through Firebase
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

var db = firebase.firestore();
Os valores de `initializeApp` podem ser encontrados no `firebaseConfig` do seu aplicativo da Web. Para manter os dados se o dispositivo perder a conexão, consulte a documentação Ativar dados off-line.
Swift
import Firebase

FirebaseApp.configure()

let db = Firestore.firestore()
Objective-C
@import Firebase;

// Use Firebase library to configure APIs
[FIRApp configure];

FIRFirestore *defaultFirestore = [FIRFirestore firestore];
  

Java

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

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Java
O SDK do Cloud Firestore é inicializado de diferentes maneiras, dependendo do seu ambiente. Veja abaixo os métodos mais comuns. Para uma referência completa, consulte Inicializar o SDK Admin.
  • Inicializar no Google Cloud Platform
    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();
    
  • Inicializar no seu próprio servidor

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

    Acesse IAM e administrador > Contas de serviço (em inglês) no Console do Cloud Platform. 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();
    
  • Python
    O SDK do Cloud Firestore é inicializado de diferentes maneiras, dependendo do seu ambiente. Veja abaixo os métodos mais comuns. Para uma referência completa, consulte Inicializar o SDK Admin.
  • Inicializar no Google Cloud Platform
    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, {
      'projectId': project_id,
    })
    
    db = firestore.client()
    
  • Inicializar no seu próprio servidor

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

    Acesse IAM e administrador > Contas de serviço (em inglês) no Console do Cloud Platform. 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')
    firebase_admin.initialize_app(cred)
    
    db = firestore.client()
    
  • C++
    using firebase::App;
    using firebase::firestore::Firestore;
    // Make sure this call 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. Veja abaixo os métodos mais comuns. Para uma referência completa, consulte Inicializar o SDK Admin.
    • Inicializar no Cloud Functions
      const admin = require('firebase-admin');
      const admin = require('firebase-admin');
      admin.initializeApp();
      
      let db = admin.firestore();
      
      
    • Inicializar no Google Cloud Platform
      const admin = require('firebase-admin');
      
      admin.initializeApp({
        credential: admin.credential.applicationDefault()
      });
      
      const db = admin.firestore();
      // ...
      
      
    • Inicializar no seu próprio servidor

      Para usar o SDK Admin do Firebase mo 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 (em inglês) no Console do Cloud Platform. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

      const admin = require('firebase-admin');
      
      let serviceAccount = require('./path/to/serviceAccountKey.json');
      
      admin.initializeApp({
        credential: admin.credential.cert(serviceAccount)
      });
      
      let db = admin.firestore();
      
      
    Go
    O SDK do Cloud Firestore é inicializado de diferentes maneiras, dependendo do seu ambiente. Veja abaixo os métodos mais comuns. Para uma referência completa, consulte Inicializar o SDK Admin.
  • Inicializar no Google Cloud Platform
    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()
    
  • Inicializar no seu próprio servidor

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

    Acesse IAM e administrador > Contas de serviço (em inglês) no Console do Cloud Platform. 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
    use Google\Cloud\Firestore\FirestoreClient;
    
    /**
     * Initialize Cloud Firestore with default project ID.
     * ```
     * initialize();
     * ```
     */
    function initialize()
    {
        // Create the Cloud Firestore client
        $db = new FirestoreClient();
        printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
    }
    
    Unity
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    
    C#
    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    
    Ruby
    require "google/cloud/firestore"
    
    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 nos Documentos que são armazenados nas Coleções. O Cloud Firestore cria coleções e documentos de modo implícito na primeira vez que você adiciona dados ao documento. Não é necessário criar coleções ou documentos explicitamente.

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

    Web
    db.collection("users").add({
        first: "Ada",
        last: "Lovelace",
        born: 1815
    })
    .then(function(docRef) {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch(function(error) {
        console.error("Error adding document: ", error);
    });
    
    Swift
    // Add a new document with a generated ID
    var ref: DocumentReference? = nil
    ref = db.collection("users").addDocument(data: [
        "first": "Ada",
        "last": "Lovelace",
        "born": 1815
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    
    Objective-C
    // 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);
          }
        }];
      

    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);
                }
            });
    

    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
    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());
      
    Python
    doc_ref = db.collection(u'users').document(u'alovelace')
    doc_ref.set({
        u'first': u'Ada',
        u'last': u'Lovelace',
        u'born': 1815
    })
      
    C++
    // Add a new document with a generated ID
    Future<DocumentReference> user_ref =
        db->Collection("users").Add({{"first", FieldValue::FromString("Ada")},
                                     {"last", FieldValue::FromString("Lovelace")},
                                     {"born", FieldValue::FromInteger(1815)}});
    
    user_ref.OnCompletion([](const Future<DocumentReference>& future) {
      if (future.error() == Error::Ok) {
        std::cout << "DocumentSnapshot added with ID: " << future.result()->id()
                  << '\n';
      } else {
        std::cout << "Error adding document: " << future.error_message() << '\n';
      }
    });
      
    Node.js
    let docRef = db.collection('users').doc('alovelace');
    
    let setAda = docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
      
    Go
    _, _, 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
    $docRef = $db->collection('users')->document('lovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
      
    Unity
    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);
      
    Ruby
    doc_ref = firestore.doc "users/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 esse documento inclui um par de valores-chave (nome do meio) que não aparece no primeiro documento. Os documentos em uma coleção podem conter diferentes conjuntos de informações.

    Web
    // Add a second document with a generated ID.
    db.collection("users").add({
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
    })
    .then(function(docRef) {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch(function(error) {
        console.error("Error adding document: ", error);
    });
    
    Swift
    // Add a second document with a generated ID.
    ref = db.collection("users").addDocument(data: [
        "first": "Alan",
        "middle": "Mathison",
        "last": "Turing",
        "born": 1912
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    
    Objective-C
    // 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);
          }
        }];
      

    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);
                }
            });
    

    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
    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());
      
    Python
    doc_ref = db.collection(u'users').document(u'aturing')
    doc_ref.set({
        u'first': u'Alan',
        u'middle': u'Mathison',
        u'last': u'Turing',
        u'born': 1912
    })
      
    C++
    db->Collection("users")
        .Add({{"first", FieldValue::FromString("Alan")},
              {"middle", FieldValue::FromString("Mathison")},
              {"last", FieldValue::FromString("Turing")},
              {"born", FieldValue::FromInteger(1912)}})
        .OnCompletion([](const Future<DocumentReference>& future) {
          if (future.error() == Error::Ok) {
            std::cout << "DocumentSnapshot added with ID: "
                      << future.result()->id() << '\n';
          } else {
            std::cout << "Error adding document: " << future.error_message()
                      << '\n';
          }
        });
      
    Node.js
    let aTuringRef = db.collection('users').doc('aturing');
    
    let setAlan = aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
      
    Go
    _, _, 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
    $docRef = $db->collection('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);
      
    Unity
    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);
      
    Ruby
    doc_ref = firestore.doc "users/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

    Para verificar rapidamente se você adicionou dados ao Cloud Firestore, use o visualizador de dados no Console do Firebase.

    Você também pode usar o método "get" para recuperar toda a coleção.

    Web
    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });
    
    Swift
    db.collection("users").getDocuments() { (querySnapshot, err) in
        if let err = err {
            print("Error getting documents: \(err)")
        } else {
            for document in querySnapshot!.documents {
                print("\(document.documentID) => \(document.data())")
            }
        }
    }
    
    Objective-C
    [[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);
            }
          }
        }];
      

    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());
                    }
                }
            });
    

    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
    // 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"));
    }
      
    Python
    users_ref = db.collection(u'users')
    docs = users_ref.stream()
    
    for doc in docs:
        print(u'{} => {}'.format(doc.id, doc.to_dict()))
      
    C++
    Future<QuerySnapshot> users = db->Collection("users").Get();
    users.OnCompletion([](const Future<QuerySnapshot>& future) {
      if (future.error() == Error::Ok) {
        for (const DocumentSnapshot& document : future.result()->documents()) {
          std::cout << document << '\n';
        }
      } else {
        std::cout << "Error getting documents: " << future.error_message()
                  << '\n';
      }
    });
      
    Node.js
    db.collection('users').get()
      .then((snapshot) => {
        snapshot.forEach((doc) => {
          console.log(doc.id, '=>', doc.data());
        });
      })
      .catch((err) => {
        console.log('Error getting documents', err);
      });
      
    Go
    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
    $usersRef = $db->collection('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);
      
    Unity
    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();
    }
      
    Ruby
    users_ref = firestore.col "users"
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end
      

    Proteger seus dados

    Se você estiver usando o SDK para Android, iOS ou Web, utilize o Firebase Authentication e as Regras de segurança do Cloud Firestore para proteger seus dados no Cloud Firestore.

    Veja a seguir alguns conjuntos de regras básicas que é possível usar para dar os primeiros passos. É possível modificar as regras de segurança na guia Regras do console.

    Autenticação obrigatória

    // Allow read/write access on all documents to any user signed in to the application
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if request.auth.uid != null;
        }
      }
    }
    

    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;
        }
      }
    }
    

    Modo de teste

    // Allow read/write access to all users under any conditions
    // Warning: **NEVER** use this rule set in production; it allows
    // anyone to overwrite your entire database.
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if true;
        }
      }
    }
    

    Se você estiver usando um dos SDKs do servidor, utilize o Gerenciamento de identidade e acesso (IAM, na sigla em inglês) para proteger seus dados no Cloud Firestore.

    Assistir a um tutorial em vídeo

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

    Web
    iOS
    Android

    Para encontrar mais vídeos sobre o Firebase, acesse o canal do Firebase no YouTube.

    Próximas etapas

    Aprofunde seu conhecimento com os seguintes tópicos: