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
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.
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.
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.
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.
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.
- Siga as instruções para adicionar o Firebase ao seu aplicativo Web .
- Adicione as bibliotecas Firebase e Cloud Firestore ao seu aplicativo:
O SDK do Cloud Firestore também está disponível como um pacote npm.<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> Você precisará exigir manualmente o Firebase e o Cloud Firestore.npm install firebase@10.9.0 --save
import firebase from "firebase/compat/app";
// Required for side-effects
import "firebase/firestore";
- Siga as instruções para adicionar o Firebase ao seu aplicativo Web .
- O SDK do Cloud Firestore está disponível como um pacote npm.
Você precisará importar o Firebase e o Cloud Firestore.npm install firebase@10.9.0 --save
import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";
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.
- No Xcode, com o projeto do seu aplicativo aberto, navegue até File > Swift Packages > Add Package Dependency .
- Quando solicitado, adicione o repositório SDK das plataformas Apple do Firebase:
- Escolha a biblioteca Firestore.
- Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.
https://github.com/firebase/firebase-ios-sdk
- Siga as instruções para adicionar o Firebase ao seu aplicativo Android .
- 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
ouapp/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 ).
- Se ainda não o fez, configure e inicialize o Firebase em seu aplicativo Flutter.
- Na raiz do seu projeto Flutter, execute o seguinte comando para instalar o plugin:
flutter pub add cloud_firestore
- Depois de concluído, reconstrua seu aplicativo Flutter:
flutter run
- 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 endSubstitua IOS_SDK_VERSION pela versão do SDK do Firebase para iOS especificada no arquivo
firebase_sdk_version.rb
defirebase_core
. Se você não estiver usando a versão mais recente dofirebase_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 .
- 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>
- Usando Gradle:
- Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
- Adicione o SDK Admin do Firebase ao seu aplicativo Python:
pip install --upgrade firebase-admin
- Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
- Siga as instruções para adicionar o Firebase ao seu projeto C++ .
- 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}")
- Para configurar a integração com desktop , consulte Adicionar o Firebase ao seu projeto C++ .
- Siga as instruções para adicionar o Firebase ao seu projeto Unity .
- Use a interface do Unity para configurar seu projeto para reduzir compilações do Android.
- 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.
-
Você deve reduzir a compilação para evitar a mensagem Error while merging dex archives
.
- Adicione o SDK Admin do Firebase ao seu aplicativo:
npm install firebase-admin --save
- Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
- Adicione o SDK Admin do Firebase ao seu aplicativo Go:
go get firebase.google.com/go
- Siga as instruções abaixo para inicializar o Cloud Firestore com as credenciais adequadas em seu ambiente.
- 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 .
- Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente
- Instale e habilite a extensão gRPC para PHP, que você precisará para usar a biblioteca cliente.
- Adicione a biblioteca PHP do Cloud Firestore ao seu aplicativo:
composer require google/cloud-firestore
- 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 .
- Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente
- Adicione a biblioteca Cloud Firestore C# ao seu aplicativo no arquivo
.csproj
:<ItemGroup>
<PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
</ItemGroup> - Adicione o seguinte ao seu arquivo
Program.cs
:using Google.Cloud.Firestore;
- 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 .
- Para autenticar em seu ambiente de desenvolvimento, defina a variável de ambiente
- Adicione a biblioteca Cloud Firestore Ruby ao seu aplicativo em seu
Gemfile
:gem "google-cloud-firestore"
- 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:
- Adicionando uma linha de código à configuração de teste do seu aplicativo para conectar-se ao emulador.
- Na raiz do diretório local do projeto, executando
firebase emulators:start
. - 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:
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 .
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 .
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()
let db = Firestore.firestore()
@import FirebaseCore;
@import FirebaseFirestore;
// Use Firebase library to configure APIs
[FIRApp configure];
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
db = FirebaseFirestore.instance;
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();
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();
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()
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()
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()
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()
// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();
- 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();
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()
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
Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .
using Firebase.Firestore;
using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C#
Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .
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.
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);
}
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);
});
// 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)")
}
// 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);
}
}];
// 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)
}
// 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);
}
});
// 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}'));
// 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;
}
});
PHP
Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .
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.");
});
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.
// 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 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);
});
// 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)")
}
// 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);
}
}];
// 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)
}
// 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);
}
});
// 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}'));
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;
}
});
PHP
Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .
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.");
});
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.
import { collection, getDocs } from "firebase/firestore";
const querySnapshot = await getDocs(collection(db, "users"));
querySnapshot.forEach((doc) => {
console.log(`${doc.id} => ${doc.data()}`);
});
db.collection("users").get().then((querySnapshot) => {
querySnapshot.forEach((doc) => {
console.log(`${doc.id} => ${doc.data()}`);
});
});
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)")
}
[[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);
}
}
}];
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)
}
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());
}
}
});
await db.collection("users").get().then((event) {
for (var doc in event.docs) {
print("${doc.id} => ${doc.data()}");
}
});
users_ref = db.collection("users")
docs = users_ref.stream()
for doc in docs:
print(f"{doc.id} => {doc.to_dict()}")
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;
}
});
PHP
Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .
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.");
});
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.
// 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;
}
}
}
// 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:
Você pode encontrar mais vídeos no canal do Firebase no YouTube .
Próximos passos
Aprofunde seus conhecimentos com os seguintes temas:
- Codelabs : aprenda a usar o Cloud Firestore em um aplicativo real seguindo o codelab para Android , iOS ou Web .
- Modelo de dados — Saiba mais sobre como os dados são estruturados no Cloud Firestore, incluindo dados hierárquicos e subcoleções.
- Adicionar dados — Saiba mais sobre como criar e atualizar dados no Cloud Firestore.
- Obter dados — Saiba mais sobre como recuperar dados.
- Execute consultas simples e compostas — Aprenda como executar consultas simples e compostas.
- Ordenar e limitar consultas Aprenda como ordenar e limitar os dados retornados pelas suas consultas.