Começar a usar a edição Enterprise do Cloud Firestore

Neste guia de início rápido, mostramos como configurar o Cloud Firestore Enterprise Edition, adicionar dados e usar operações principais ou de pipeline para consultar os dados que você acabou de adicionar no console do Firebase.

O Cloud Firestore oferece suporte a SDKs para dispositivos móveis ou Web e a bibliotecas de cliente do servidor.

  • O Cloud Firestore é compatível com SDKs para Android, iOS, Web e muito mais. Os SDKs para dispositivos móveis e Web associados ao Cloud Firestore Security Rules e ao Firebase Authentication oferecem suporte a arquiteturas de apps sem servidor em que os clientes se conectam diretamente ao seu banco de dados do Cloud Firestore.

  • O Cloud Firestore oferece suporte a bibliotecas de cliente do servidor para Java, Node.js e Python. Use essas bibliotecas de cliente para configurar ambientes de servidor privilegiados com acesso total ao seu banco de dados. Saiba mais sobre essas bibliotecas no Guia de início rápido para bibliotecas de cliente do servidor.

Criar um banco de dados da edição Enterprise 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 do Firebase ou para adicionar serviços do Firebase a um projeto do Google Cloud.

  2. Abra seu projeto no console do Firebase. No painel à esquerda, expanda Build e selecione Banco de dados do Firestore.

  3. Clique em Criar banco de dados.

  4. Selecione Enterprise para o modo de banco de dados.

  5. Selecione Firestore no modo nativo para o modo de operação, que é compatível com operações principais e de pipeline.

  6. Selecione um local para seu banco de dados.

  7. Selecione um modo inicial para as Cloud Firestore Security Rules:

    Modo de teste

    Ideal para começar a usar 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 as plataformas Apple, da Web ou o SDK do Android.

    Modo de produção

    Nega todas as leituras e gravações de clientes de dispositivos móveis e Web. Seus servidores de aplicativos autenticados (Python) ainda podem acessar seu banco de dados.

    O conjunto inicial de Cloud Firestore Security Rules será aplicado ao banco de dados padrão do Cloud Firestore. Se você criar vários bancos de dados para seu projeto, poderá implantar Cloud Firestore Security Rules para cada um deles.

  8. Clique em Criar.

Quando você ativa a edição Enterprise do Cloud Firestore, a API no Cloud API Manager também é ativada.

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. O SDK do Cloud Firestore SDK está disponível como um pacote npm. 
    npm install firebase@12.8.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 app da Apple.

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

  1. Com seu projeto do app aberto no Xcode, acesse File > Swift Packages > Add Package Dependency.
  2. Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:
    3.   https://github.com/firebase/firebase-ios-sdk
  3. Escolha a biblioteca do Firestore.
  4. Quando terminar, o Xcode vai começar a resolver e fazer o download das dependências em segundo plano automaticamente.
Android
  1. Siga as instruções para adicionar o Firebase ao seu app Android.
  2. Ao usar a BoM do Firebase para Android, declare a dependência da biblioteca do Cloud Firestore para Android no Arquivo Gradle do módulo (nível do app) (geralmente app/build.gradle.kts ou app/build.gradle).
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.7.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")
}

    Usando a BoM do Firebase para Android, seu app sempre usará versões compatíveis das bibliotecas do Firebase para Android.

    (Alternativa) Declare as dependências das bibliotecas do Firebase sem usar o BoM

    Se você preferir não usar a BoM do Firebase BoM, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

    Caso você use várias bibliotecas do Firebase no seu app, recomendamos usar a BoM para gerenciar as versões delas e garantir a compatibilidade de todas.

    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:26.0.2")
}

    Está procurando um módulo de biblioteca específico do Kotlin? A partir da versão de outubro de 2023, os desenvolvedores Kotlin e Java podem depender do módulo da biblioteca principal. Para mais detalhes, consulte as Perguntas frequentes sobre isso iniciativa).

Inicializar o Cloud Firestore

Inicialize uma instância do Cloud Firestore:

Web

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


// When initializing Firestore, remember to use the name of the database you created earlier:
const db = initializeFirestore(app, {}, 'your-new-enterprise-database');

Substitua FIREBASE_CONFIGURATION pelo firebaseConfig do seu app da Web.

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

Swift
import FirebaseCore
import FirebaseFirestore

FirebaseApp.configure()

// When initializing Firestore, remember to use the name of the database you created earlier:
let db = Firestore.firestore(database: "your-new-enterprise-database")

Kotlin

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
val firestore = FirebaseFirestore.getInstance("your-new-enterprise-database")

Java

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
FirebaseFirestore firestore = FirebaseFirestore.getInstance("your-new-enterprise-database");

Adicionar dados usando operações principais

Para explorar as operações principais e de pipeline para consultar dados, adicione dados ao seu banco de dados usando as operações principais.

O Cloud Firestore armazena dados nos documentos, que são armazenados nas coleções. O Firestore cria coleções e documentos de modo implícito na primeira vez que você adiciona dados ao documento.Cloud Firestore Não é necessário criar coleções ou documentos explicitamente.

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

Web

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);
}
add_ada_lovelace.js

Web

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);
});
test.firestore.js
Swift
Observação: esse produto não está disponível para destinos watchOS e de clipes de apps. 
// 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)")
}
ViewController.swift

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)
    }
DocSnippets.kt

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);
            }
        });
DocSnippets.java

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.
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);
}
add_alan_turing.js

Web

// 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);
});
test.firestore.js
Swift
Observação: esse produto não está disponível para destinos watchOS e de clipes de apps. 
// 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)")
}
ViewController.swift

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)
    }
DocSnippets.kt

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);
            }
        });
DocSnippets.java

Ler dados usando operações principais

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

É possível usar o método "get" para recuperar toda a coleção.

Web

import { collection, getDocs } from "firebase/firestore"; 

const querySnapshot = await getDocs(collection(db, "users"));
querySnapshot.forEach((doc) => {
  console.log(`${doc.id} => ${doc.data()}`);
});
get_all_users.js

Web

db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});
test.firestore.js
Swift
Observação: esse produto não está disponível para destinos watchOS e de clipes de apps. 
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)")
}
ViewController.swift

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)
    }
DocSnippets.kt

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

Ler dados usando operações de pipeline

Agora é possível comparar a experiência de consulta do pipeline com a experiência de consulta do Core.

Web

const readDataPipeline = db.pipeline()
  .collection("users");

// Execute the pipeline and handle the result
try {
  const querySnapshot = await execute(readDataPipeline);
  querySnapshot.results.forEach((result) => {
    console.log(`${result.id} => ${result.data()}`);
  });
} catch (error) {
    console.error("Error getting documents: ", error);
}
test.firestore.js
Swift
do {
  // Initialize a Firestore Pipeline instance and specify the "users" collection as the
  // input stage.
  let snapshot = try await db.pipeline()
    .collection("users")
    .execute() // Execute the pipeline to retrieve documents.

  // Iterate through the documents in the pipeline results, similar to a regular query
  // snapshot.
  for result in snapshot.results {
    print("\(result.id ?? "no ID") => \(result.data)")
  }
} catch {
  print("Error getting documents with pipeline: \(error)")
}
PipelineSnippets.swift

Kotlin

val readDataPipeline = db.pipeline()
    .collection("users")

// Execute the pipeline and handle the result
readDataPipeline.execute()
    .addOnSuccessListener { result ->
        for (document in result) {
            println("${document.getId()} => ${document.getData()}")
        }
    }
    .addOnFailureListener { exception ->
        println("Error getting documents: $exception")
    }
DocSnippets.kt

Java

Pipeline readDataPipeline = db.pipeline()
.collection("users");

readDataPipeline.execute()
.addOnSuccessListener(new OnSuccessListener<Pipeline.Snapshot>() {
    @Override
    public void onSuccess(Pipeline.Snapshot snapshot) {
        for (PipelineResult result : snapshot.getResults()) {
            System.out.println(result.getId() + " => " + result.getData());
        }
    }
})
.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        System.out.println("Error getting documents: " + e);
    }
});

Proteja seus dados para SDKs para dispositivos móveis e Web

Se você estiver usando o SDK para Web, Android ou plataformas Apple, utilize o Firebase Authentication e o Cloud Firestore Security Rules para proteger seus dados no Cloud Firestore.

Veja a seguir alguns conjuntos de regras básicas que podem ser usadas para começar. É possível modificar as regras de segurança na guia Regras do console.

Autenticação obrigató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 de produção

// 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 o app da Web, Android ou iOS para produção, tome algumas medidas para garantir que somente seus clientes do app possam acessar os dados do Cloud Firestore. Consulte a documentação do App Check.

Se você estiver usando um dos SDKs do servidor, utilize o Identity and Access Management (IAM) para proteger os dados no Cloud Firestore.

Próximas etapas

Aprofunde seu conhecimento sobre operações principais e de pipeline com os seguintes tópicos: