Ir para o console

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, clique em Adicionar projeto e siga as instruções na tela para criar um projeto ou adicionar serviços do Firebase a um projeto atual do GCP.

  2. No painel de navegação do console, selecione Banco de dados e clique em Criar banco de dados para o Cloud Firestore.

  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. Após o teste, lembre-se de rever 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 é o local padrão dos recursos do Google Cloud Platform (GCP) do seu projeto. 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 (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 ao configurar outro serviço que requer uma configuração de local.

  5. Clique em Concluído.

Quando você ativa o Cloud Firestore, ele também ativa a API no Cloud API Manager.

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/6.2.4/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/6.2.4/firebase-firestore.js"></script>
    O Cloud Firestore SDK também está disponível como um pacote npm.
    npm install firebase@6.2.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/Core'
    pod 'Firebase/Firestore'
  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 seu arquivo de nível de projeto build.gradle, inclua o repositório Maven do Google, tanto nas seções buildscript e allprojects.
  3. Adicione a biblioteca Android do Cloud Firestore ao arquivo app/build.gradle:
    implementation 'com.google.firebase:firebase-firestore:20.1.0'
Kotlin
  1. Siga as instruções para adicionar o Firebase ao seu app para Android.
  2. No seu arquivo de nível de projeto build.gradle, inclua o repositório Maven do Google, tanto nas seções buildscript e allprojects.
  3. Adicione a biblioteca Android do Cloud Firestore ao arquivo app/build.gradle:
    implementation 'com.google.firebase:firebase-firestore:20.1.0'
Java
  1. Adicione o SDK Admin do Firebase ao seu app:
    • Com o Gradle:
      compile 'com.google.firebase:firebase-admin:6.8.1'
      
    • Com o Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>6.8.1</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.
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 autenticar a partir 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. Você pode 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 autenticar a partir 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. Você pode 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.0.0-beta19" />
    </ItemGroup>
  3. Adicione o seguinte ao 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 autenticar a partir 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. Você pode 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 Gemfile usando o seguinte:
    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();
Para manter os dados quando 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
// Access a Cloud Firestore instance from your Activity
val db = FirebaseFirestore.getInstance()
Java
O Cloud Firestore SDK é 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.
  • Inicialize 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();
    
  • 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 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 Cloud Firestore SDK é 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.
  • Inicialize 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()
    
  • 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 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()
    
  • Node.js
    O Cloud Firestore SDK é 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.
    • Inicialize no Cloud Functions
      const admin = require('firebase-admin');const functions = require('firebase-functions');
      
      admin.initializeApp(functions.config().firebase);
      
      let db = admin.firestore();
      
      
    • Inicialize no Google Cloud Platform
      const admin = require('firebase-admin');
      admin.initializeApp({
        credential: admin.credential.applicationDefault()
      });
      
      const db = admin.firestore();
      // ...
      
      
    • 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 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 Cloud Firestore SDK é 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.
  • Inicialize 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()
    
  • 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 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);
    }
    
    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
    // 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
    })
      
    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);
      
    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
    // 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
    })
      
    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);
      
    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 Firebase console.

    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
    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.get()
    
    for doc in docs:
        print(u'{} => {}'.format(doc.id, doc.to_dict()))
      
    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);
      
    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 da 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

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

    Próximas etapas

    Aprofunde seu conhecimento com os seguintes tópicos: