Esta guía de inicio rápido te muestra cómo configurar Cloud Firestore, agregar datos y luego verlos en Firebase console.
Crea una base de datos Cloud Firestore
Si aún no lo hiciste, crea un proyecto de Firebase. Para ello, en Firebase console, haz clic en Agregar proyecto y, luego, sigue las instrucciones en pantalla para crear un proyecto de Firebase o agregar servicios de Firebase a un proyecto de GCP existente.
Ve a la sección Cloud Firestore de Firebase console. Se te pedirá que selecciones un proyecto de Firebase existente. Sigue el flujo de trabajo para crear la base de datos.
Selecciona uno de los siguientes modos de inicio para las reglas de seguridad de Cloud Firestore:
- Modo de prueba
Es el modo recomendado si recién comienzas a usar las bibliotecas cliente para dispositivos móviles y la Web, pero permite que todos lean y reemplacen tus datos. Después de realizar las pruebas, asegúrate de revisar la sección Protege tus datos.
Si quieres comenzar a usar la Web, las plataformas de Apple o el SDK de Android, selecciona el modo de prueba.
- Modo bloqueado
Rechaza todas las lecturas y escrituras de clientes móviles y web. Los servidores de aplicación autenticados (C#, Go, Java, Node.js, PHP, Python o Ruby) aún pueden acceder a tu base de datos.
Para comenzar con la biblioteca cliente de servidor C#, Go, Java, Node.js, PHP, Python o Ruby, selecciona el modo bloqueado.
El conjunto inicial de reglas de seguridad de Cloud Firestore se aplicará a tu base de datos predeterminada de Cloud Firestore. Si creas varias bases de datos para tu proyecto, puedes implementar reglas de seguridad de Cloud Firestore para cada base de datos.
Selecciona una ubicación para tu base de datos.
Esta configuración es la ubicación predeterminada de los recursos de Google Cloud Platform (GCP) del proyecto. Ten en cuenta que esta ubicación se usará para los servicios de GCP del proyecto que requieren una configuración de ubicación. Específicamente, el bucket predeterminado de Cloud Storage y la app de App Engine (que es obligatoria si usas Cloud Scheduler).
Si no puedes seleccionar una ubicación, el proyecto ya tiene una ubicación predeterminada para los recursos de GCP. Esta se definió durante la creación del proyecto o cuando configuraste otro servicio que requería una configuración de ubicación.
Haz clic en Listo.
Cuando habilitas Cloud Firestore, también se habilita la API en el Administrador de APIs de Cloud.
Configura tu entorno de desarrollo
Agrega las dependencias y las bibliotecas cliente necesarias a tu app.
API con espacio de nombres web
- Sigue las instrucciones para agregar Firebase a tu app web.
- Agrega las bibliotecas de Firebase y Cloud Firestore a tu app:
<script src="https://www.gstatic.com/firebasejs/10.7.2/firebase-app-compat.js"></script> <script src="https://www.gstatic.com/firebasejs/10.7.2/firebase-firestore-compat.js"></script>
El SDK de Cloud Firestore también está disponible como paquete npm.npm install firebase@10.7.2 --save
Deberás solicitar de forma manual Firebase y Cloud Firestore.import firebase from "firebase/compat/app"; // Required for side-effects import "firebase/firestore";
API modular web
- Sigue las instrucciones para agregar Firebase a tu app web.
-
El SDK de Cloud Firestore está disponible como un paquete npm.
npm install firebase@10.7.2 --save
Deberás importar Firebase y Cloud Firestore.import { initializeApp } from "firebase/app"; import { getFirestore } from "firebase/firestore";
iOS+
Sigue las instrucciones para agregar Firebase a tu app para Apple.
Usa Swift Package Manager para instalar y administrar las dependencias de Firebase.
- Abre el proyecto de tu app y, en Xcode, navega a File > Swift Packages > Add Package Dependency.
- Cuando se te solicite, agrega el repositorio del SDK de Firebase para plataformas de Apple:
- Elige la biblioteca de Firestore.
- Cuando termines, Xcode comenzará a resolver y descargar automáticamente tus dependencias en segundo plano.
https://github.com/firebase/firebase-ios-sdk
Android
- Sigue las instrucciones para agregar Firebase a tu app para Android.
- Usa la BoM de Firebase para Android a fin de declarar la dependencia de la biblioteca Cloud Firestore para Android en el archivo Gradle del módulo (nivel de app) (generalmente
app/build.gradle.kts
oapp/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:32.7.1")) // 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") }
Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.
Como alternativa, puedes declarar las dependencias de la biblioteca de Firebase sin usar la BoM.
Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.
Ten en cuenta que, si usas varias bibliotecas de Firebase en tu app, te recomendamos que utilices la BoM para administrar las versiones de las bibliotecas, lo que garantiza que todas las versiones sean compatibles.
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.10.1") }
¿Buscas un módulo de biblioteca específico de Kotlin? A partir de la versión de octubre de 2023, tanto los desarrolladores de Kotlin como los de Java pueden depender del módulo de la biblioteca principal (para obtener más información, consulta las Preguntas frecuentes sobre esta iniciativa).
Dart
- Si aún no lo has hecho, configura e inicializa Firebase en tu app de Flutter.
- Desde la raíz de tu proyecto de Flutter, ejecuta el siguiente comando para
instalar el complemento:
flutter pub add cloud_firestore
- Cuando termines, vuelve a compilar tu aplicación de Flutter:
flutter run
- Opcional: Mejora el tiempo de compilación en iOS y macOS mediante la inclusión
del framework compilado previamente.
Actualmente, el SDK de Firestore para iOS depende de código que puede tardar hasta 5 minutos en compilarse en Xcode. Para reducir significativamente los tiempos de compilación, puedes usar una versión precompilada agregando esta línea al bloque
target 'Runner' do
de tu Podfile:target 'Runner' do use_frameworks! use_modular_headers! pod 'FirebaseFirestore', :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git', :tag => 'IOS_SDK_VERSION' flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) target 'RunnerTests' do inherit! :search_paths end end
Reemplaza IOS_SDK_VERSION por la versión del SDK de Firebase iOS que se especifica en el archivo
firebase_sdk_version.rb
defirebase_core
. Si no usas la versión más reciente defirebase_core
, busca este archivo en la caché de tu paquete de Pub local (por lo general,~/.pub-cache
).Además, asegúrate de haber actualizado CocoaPods a la versión 1.9.1 o superior:
gem install cocoapods
Para obtener más información, consulta el problema en GitHub.
Java
- Agrega el SDK de Firebase Admin a tu app:
-
Con Gradle:
compile 'com.google.firebase:firebase-admin:1.32.0'
-
Con Maven:
<dependency> <groupId>com.google.firebase</groupId> <artifactId>firebase-admin</artifactId> <version>1.32.0</version> </dependency>
-
Con Gradle:
- Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
Python
- Agrega el SDK de Firebase Admin a tu app de Python:
pip install --upgrade firebase-admin
- Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
C++
- Sigue las instrucciones para agregar Firebase a tu proyecto de C++.
- Interfaz C++ para Android.
- Dependencias de Gradle. Agrega lo siguiente al archivo Gradle
(generalmente
app/build.gradle
) de tu módulo (nivel de app):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 }
- Dependencias binarias. De manera similar, la forma recomendada de obtener
las dependencias binarias es agregar lo siguiente a tu
archivo
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 la integración con el escritorio, consulta Agrega Firebase a tu proyecto de C++.
Unity
- Sigue las instrucciones para agregar Firebase a tu proyecto de Unity.
- Usa la interfaz de Unity para configurar tu proyecto para reducir las compilaciones de Android.
- Esta opción se encuentra en Player Settings > Android > Publishing Settings > Minify.
- Las opciones pueden variar según la versión de Unity, por lo que debes consultar la documentación oficial de Unity y la guía de depuración de compilación de Firebase Unity.
-
Si, después de habilitar la reducción, la cantidad de métodos a los que se hace referencia aún excede el límite, otra opción es habilitar
multidex
en:-
mainTemplate.gradle
si está habilitada la Custom Gradle Template en Player Settings. -
o el archivo
build.gradle
de nivel de módulo, si usas Android Studio para compilar el proyecto exportado.
-
Debes reducir la compilación para evitar el mensaje Error while merging dex archives
.
Node.js
-
Agrega el SDK de Firebase Admin a tu app:
npm install firebase-admin --save
- Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
Go
- Agrega el SDK de Firebase Admin a tu app de Go:
go get firebase.google.com/go
- Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
PHP
-
Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) usan credenciales predeterminadas de la aplicación de Google para la autenticación.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de claves de cuenta de servicio JSON. Puedes crear un archivo de claves en la página de credenciales de la Consola de APIs.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En tu entorno de producción, no es necesario que te autentiques si ejecutas tu aplicación en App Engine o Compute Engine con el mismo proyecto que usas para Cloud Firestore. De lo contrario, configura una cuenta de servicio.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
- Instala y habilita la extensión de gRPC para PHP, que necesitarás para usar la biblioteca cliente.
-
Agrega la biblioteca PHP de Cloud Firestore a tu app:
composer require google/cloud-firestore
C#
-
Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) usan credenciales predeterminadas de la aplicación de Google para la autenticación.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de claves de cuenta de servicio JSON. Puedes crear un archivo de claves en la página de credenciales de la Consola de APIs.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En tu entorno de producción, no es necesario que te autentiques si ejecutas tu aplicación en App Engine o Compute Engine con el mismo proyecto que usas para Cloud Firestore. De lo contrario, configura una cuenta de servicio.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
- Agrega la biblioteca de C# para Cloud Firestore a tu app en el archivo
.csproj
:<ItemGroup> <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" /> </ItemGroup>
-
Agrega lo siguiente a tu archivo
Program.cs
:using Google.Cloud.Firestore;
Ruby
-
Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) usan credenciales predeterminadas de la aplicación de Google para la autenticación.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de claves de cuenta de servicio JSON. Puedes crear un archivo de claves en la página de credenciales de la Consola de APIs.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En tu entorno de producción, no es necesario que te autentiques si ejecutas tu aplicación en App Engine o Compute Engine con el mismo proyecto que usas para Cloud Firestore. De lo contrario, configura una cuenta de servicio.
-
Para autenticar desde tu entorno de desarrollo, configura la
variable de entorno
- Agrega la biblioteca de Ruby para Cloud Firestore a tu app en el archivo
Gemfile
:gem "google-cloud-firestore"
-
Instala las dependencias del
Gemfile
con el siguiente comando:bundle install
Crea prototipos y realiza pruebas con Firebase Local Emulator Suite (opcional)
En el caso de los desarrolladores de aplicaciones para dispositivos móviles, antes de explicar cómo la app escribe o lee datos de Cloud Firestore, veremos un conjunto de herramientas que puedes usar para crear prototipos y probar la funcionalidad de Cloud Firestore: Firebase Local Emulator Suite. Si quieres probar diferentes modelos de datos, optimizar tus reglas de seguridad o encontrar la forma más rentable de interactuar con el backend, trabajar de forma local sin implementar servicios en ejecución puede ser una excelente idea.
Los emuladores de Cloud Firestore forman parte de Local Emulator Suite, lo que permite que tu app interactúe con el contenido y la configuración emulados de la base de datos y, si lo deseas, con los recursos emulados del proyecto (funciones, otras bases de datos y reglas de seguridad).
Para usar el emulador de Cloud Firestore, solo debes seguir algunos pasos:
- Agrega una línea de código a la configuración de prueba de tu app para conectarte al emulador.
- Desde la raíz del directorio de tu proyecto local, ejecuta
firebase emulators:start
. - Realiza llamadas desde el código prototipo de tu app con un SDK de la plataforma de Cloud Firestore como de costumbre.
Visita este vínculo para ver una explicación detallada sobre Cloud Firestore y Cloud Functions. También deberías consultar la Introducción a Local Emulator Suite.
Inicializa Cloud Firestore
Inicializa una instancia de Cloud Firestore:
API modular 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); // Initialize Cloud Firestore and get a reference to the service const db = getFirestore(app);
Reemplaza FIREBASE_CONFIGURATION por el firebaseConfig
de tu aplicación web.
Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
API con espacio de nombres web
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();
Reemplaza FIREBASE_CONFIGURATION por el firebaseConfig
de tu aplicación web.
Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
Swift
import FirebaseCore import FirebaseFirestore
FirebaseApp.configure() let db = Firestore.firestore()
Objective‑C
@import FirebaseCore; @import FirebaseFirestore; // Use Firebase library to configure APIs [FIRApp configure];
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
Kotlin+KTX
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Java
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
Dart
db = FirebaseFirestore.instance;
Java
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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 el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa el archivo para inicializar el 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
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.import firebase_admin from firebase_admin import firestore # Application Default credentials are automatically created. app = firebase_admin.initialize_app() db = firestore.client()
También se puede usar una credencial predeterminada de la aplicación existente para inicializar el 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 el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa el archivo para inicializar el SDK:
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore # Use a service account. cred = credentials.Certificate('path/to/serviceAccount.json') app = firebase_admin.initialize_app(cred) db = firestore.client()
Python
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.import firebase_admin from firebase_admin import firestore_async # Application Default credentials are automatically created. app = firebase_admin.initialize_app() db = firestore_async.client()
También se puede usar una credencial predeterminada de la aplicación existente para inicializar el 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 el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa el archivo para inicializar el SDK:
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore_async # Use a service account. cred = credentials.Certificate('path/to/serviceAccount.json') app = firebase_admin.initialize_app(cred) db = firestore_async.client()
C++
// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance(). App::Create(); Firestore* db = Firestore::GetInstance();
Node.js
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.-
Inicializa en Cloud Functions
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
initializeApp(); const db = getFirestore();
- Inicializa en 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();
-
Inicializa en tu propio servidor
Para usar el SDK de Firebase Admin en tu propio servidor (o cualquier otro entorno de Node.js), usa una cuenta de servicio. En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa el archivo para inicializar el 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();
Go
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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 el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa el archivo para inicializar el SDK:
import ( "log" firebase "firebase.google.com/go" "google.golang.org/api/option" ) // Use a service account ctx := context.Background() sa := option.WithCredentialsFile("path/to/serviceAccount.json") app, err := firebase.NewApp(ctx, nil, sa) if err != nil { log.Fatalln(err) } client, err := app.Firestore(ctx) if err != nil { log.Fatalln(err) } defer client.Close()
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
using Firebase.Firestore; using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C#
C#
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Ruby
Agrega datos
Cloud Firestore almacena datos en documentos, que se almacenan en colecciones. Cloud Firestore crea colecciones y documentos de forma implícita la primera vez que agregas datos al documento. No es necesario que crees colecciones o documentos de forma explícita.
Crea una colección nueva y un documento con el siguiente código de ejemplo.
API modular 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); }
API con espacio de nombres 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); });
Swift
// 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)") }
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); } }];
Kotlin+KTX
// Create a new user with a first and last name val user = hashMapOf( "first" to "Ada", "last" to "Lovelace", "born" to 1815, ) // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener { documentReference -> Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}") } .addOnFailureListener { e -> Log.w(TAG, "Error adding document", e) }
Java
// Create a new user with a first and last name Map<String, Object> user = new HashMap<>(); user.put("first", "Ada"); user.put("last", "Lovelace"); user.put("born", 1815); // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener(new OnSuccessListener<DocumentReference>() { @Override public void onSuccess(DocumentReference documentReference) { Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId()); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error adding document", e); } });
Dart
// Create a new user with a first and last name final user = <String, dynamic>{ "first": "Ada", "last": "Lovelace", "born": 1815 }; // Add a new document with a generated ID db.collection("users").add(user).then((DocumentReference doc) => print('DocumentSnapshot added with ID: ${doc.id}'));
Java
Python
Python
C++
// Add a new document with a generated ID Future<DocumentReference> user_ref = db->Collection("users").Add({{"first", FieldValue::String("Ada")}, {"last", FieldValue::String("Lovelace")}, {"born", FieldValue::Integer(1815)}}); user_ref.OnCompletion([](const Future<DocumentReference>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot added with ID: " << future.result()->id() << std::endl; } else { std::cout << "Error adding document: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
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#
Ruby
Ahora agrega otro documento a la colección users
. Observa que este documento incluye un par clave-valor (segundo nombre) que no aparece en el primer documento. Los documentos de una colección pueden tener diferentes conjuntos de información.
API modular 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); }
API con espacio de nombres 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); });
Swift
// 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)") }
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); } }];
Kotlin+KTX
// Create a new user with a first, middle, and last name val user = hashMapOf( "first" to "Alan", "middle" to "Mathison", "last" to "Turing", "born" to 1912, ) // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener { documentReference -> Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}") } .addOnFailureListener { e -> Log.w(TAG, "Error adding document", e) }
Java
// Create a new user with a first, middle, and last name Map<String, Object> user = new HashMap<>(); user.put("first", "Alan"); user.put("middle", "Mathison"); user.put("last", "Turing"); user.put("born", 1912); // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener(new OnSuccessListener<DocumentReference>() { @Override public void onSuccess(DocumentReference documentReference) { Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId()); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error adding document", e); } });
Dart
// Create a new user with a first and last name final user = <String, dynamic>{ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912 }; // Add a new document with a generated ID db.collection("users").add(user).then((DocumentReference doc) => print('DocumentSnapshot added with ID: ${doc.id}'));
Java
Python
Python
C++
db->Collection("users") .Add({{"first", FieldValue::String("Alan")}, {"middle", FieldValue::String("Mathison")}, {"last", FieldValue::String("Turing")}, {"born", FieldValue::Integer(1912)}}) .OnCompletion([](const Future<DocumentReference>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot added with ID: " << future.result()->id() << std::endl; } else { std::cout << "Error adding document: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
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#
Ruby
Lee datos
Usa el visor de datos de Firebase console para verificar rápidamente que agregaste datos a Cloud Firestore.
También puedes utilizar el método “get” para recuperar toda la colección.
API modular web
import { collection, getDocs } from "firebase/firestore"; const querySnapshot = await getDocs(collection(db, "users")); querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); });
API con espacio de nombres web
db.collection("users").get().then((querySnapshot) => { querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); }); });
Swift
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)") }
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); } } }];
Kotlin+KTX
db.collection("users") .get() .addOnSuccessListener { result -> for (document in result) { Log.d(TAG, "${document.id} => ${document.data}") } } .addOnFailureListener { exception -> Log.w(TAG, "Error getting documents.", exception) }
Java
db.collection("users") .get() .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() { @Override public void onComplete(@NonNull Task<QuerySnapshot> task) { if (task.isSuccessful()) { for (QueryDocumentSnapshot document : task.getResult()) { Log.d(TAG, document.getId() + " => " + document.getData()); } } else { Log.w(TAG, "Error getting documents.", task.getException()); } } });
Dart
await db.collection("users").get().then((event) { for (var doc in event.docs) { print("${doc.id} => ${doc.data()}"); } });
Java
Python
users_ref = db.collection("users") docs = users_ref.stream() for doc in docs: print(f"{doc.id} => {doc.to_dict()}")
Python
C++
Future<QuerySnapshot> users = db->Collection("users").Get(); users.OnCompletion([](const Future<QuerySnapshot>& future) { if (future.error() == Error::kErrorOk) { for (const DocumentSnapshot& document : future.result()->documents()) { std::cout << document << std::endl; } } else { std::cout << "Error getting documents: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
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#
Ruby
Protege los datos
Si usas el SDK de Android, la Web o las plataformas de Apple, utiliza Firebase Authentication y las reglas de seguridad de Cloud Firestore para proteger tus datos almacenados en Cloud Firestore.
A continuación, te presentamos algunos conjuntos de reglas básicas que puedes usar para comenzar. Puedes modificar tus reglas de seguridad en la pestaña Reglas de la consola.
Auth obligatoria
// 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 != 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 prueba
// 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;
}
}
}
Antes de implementar tu app web, para Android o para iOS en la producción, también toma las medidas necesarias para asegurarte de que solo tus clientes de apps puedan acceder a los datos de Cloud Firestore. Consulta la documentación de Verificación de aplicaciones.
Si usas uno de los SDK del servidor, usa Identity and Access Management (IAM) para proteger tus datos en Cloud Firestore.
Mira un video instructivo
Si buscas orientación detallada para comenzar a usar las bibliotecas cliente para dispositivos móviles de Cloud Firestore, mira uno de los siguientes videos instructivos:
Web
iOS+
Android
Puedes encontrar más videos en el canal de YouTube de Firebase.
Próximos pasos
Profundiza tus conocimientos con los siguientes temas:
- Codelabs: Obtén información sobre cómo usar Cloud Firestore en una app real con el codelab para Android, iOS o la Web.
- Modelo de datos: Obtén más información sobre cómo se estructuran los datos en Cloud Firestore, incluidos los datos jerárquicos y las subcolecciones.
- Agrega datos: Obtén más información sobre la creación y la actualización de datos en Cloud Firestore.
- Obtén datos: Obtén más información para recuperar datos.
- Haz consultas simples y compuestas: Obtén información para ejecutar consultas simples y compuestas.
- Ordena y limita consultas: Obtén información para ordenar y limitar los datos que muestran tus consultas.