Este inicio rápido le muestra cómo configurar Cloud Firestore, agregar datos y luego ver los datos que acaba de agregar en la consola de Firebase.
Crear una base de datos de Cloud Firestore
Si aún no lo ha hecho, cree un proyecto de Firebase: en la consola de Firebase , haga clic en Agregar proyecto , luego siga las instrucciones en pantalla para crear un proyecto de Firebase o para agregar servicios de Firebase a un proyecto de GCP existente.
Vaya a la sección Cloud Firestore de Firebase console . Se le pedirá que seleccione un proyecto de Firebase existente. Siga el flujo de trabajo de creación de la base de datos.
Seleccione un modo de inicio para sus reglas de seguridad de Cloud Firestore:
- Modo de prueba
Bueno para comenzar con las bibliotecas de clientes móviles y web, pero permite que cualquier persona lea y sobrescriba sus datos. Después de la prueba, asegúrese de revisar la sección Proteja sus datos .
Para comenzar con la web, las plataformas de Apple o el SDK de Android, seleccione el modo de prueba.
- modo bloqueado
Niega todas las lecturas y escrituras de clientes móviles y web. Sus servidores de aplicaciones autenticados (C#, Go, Java, Node.js, PHP, Python o Ruby) aún pueden acceder a su base de datos.
Para comenzar con la biblioteca cliente del servidor C#, Go, Java, Node.js, PHP, Python o Ruby, seleccione el modo bloqueado.
Seleccione una ubicación para su base de datos.
Esta configuración de ubicación es la ubicación de recursos predeterminada de Google Cloud Platform (GCP) de su proyecto. Tenga en cuenta que esta ubicación se usará para los servicios de GCP en su proyecto que requieren una configuración de ubicación, específicamente, su depósito predeterminado de Cloud Storage y su aplicación App Engine (que es necesaria si usa Cloud Scheduler).
Si no puede seleccionar una ubicación, entonces su proyecto ya tiene una ubicación de recursos de GCP predeterminada. Se configuró durante la creación del proyecto o al configurar otro servicio que requiere una configuración de ubicación.
Haga clic en Listo .
Cuando habilita Cloud Firestore, también habilita la API en Cloud API Manager .
Configure su entorno de desarrollo
Agregue las dependencias requeridas y las bibliotecas de clientes a su aplicación.
Web version 8
- Siga las instrucciones para agregar Firebase a su aplicación web .
- Agregue las bibliotecas de Firebase y Cloud Firestore a su aplicación:
<script src="https://www.gstatic.com/firebasejs/8.10.1/firebase-app.js"></script> <script src="https://www.gstatic.com/firebasejs/8.10.1/firebase-firestore.js"></script>
El SDK de Cloud Firestore también está disponible como un paquete npm.npm install firebase@8.10.1 --save
Deberá requerir manualmente Firebase y Cloud Firestore.const firebase = require("firebase"); // Required for side-effects require("firebase/firestore");
Web version 9
- Siga las instrucciones para agregar Firebase a su aplicación web .
- El SDK de Cloud Firestore está disponible como paquete npm.
npm install firebase@9.16.0 --save
Deberá importar Firebase y Cloud Firestore.import { initializeApp } from "firebase/app"; import { getFirestore } from "firebase/firestore";
iOS+
Siga las instrucciones para agregar Firebase a su aplicación de Apple .
Use Swift Package Manager para instalar y administrar las dependencias de Firebase.
- En Xcode, con su proyecto de aplicación abierto, vaya a Archivo > Paquetes Swift > Agregar dependencia de paquete .
- Cuando se le solicite, agregue el repositorio del SDK de las plataformas Apple de Firebase:
- Elija la biblioteca de Firestore.
- Cuando termine, Xcode comenzará a resolver y descargar automáticamente sus dependencias en segundo plano.
https://github.com/firebase/firebase-ios-sdk
Kotlin+KTX
- Siga las instrucciones para agregar Firebase a su aplicación de Android .
- Con Firebase Android BoM , declare la dependencia de la biblioteca de Android de Cloud Firestore en el archivo Gradle de su módulo (a nivel de aplicación) (generalmente
app/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:31.2.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-ktx' }
Al usar Firebase Android BoM , su aplicación siempre usará versiones compatibles de las bibliotecas de Firebase Android.
(Alternativa) Declarar las dependencias de la biblioteca de Firebase sin usar BoM
Si elige no usar Firebase BoM, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.
Tenga en cuenta que si usa varias bibliotecas de Firebase en su aplicación, le recomendamos enfáticamente que use BoM para administrar las versiones de la biblioteca, 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-ktx:24.4.2' }
Java
- Siga las instrucciones para agregar Firebase a su aplicación de Android .
- Con Firebase Android BoM , declare la dependencia de la biblioteca de Android de Cloud Firestore en el archivo Gradle de su módulo (a nivel de aplicación) (generalmente
app/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:31.2.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' }
Al usar Firebase Android BoM , su aplicación siempre usará versiones compatibles de las bibliotecas de Firebase Android.
(Alternativa) Declarar las dependencias de la biblioteca de Firebase sin usar BoM
Si elige no usar Firebase BoM, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.
Tenga en cuenta que si usa varias bibliotecas de Firebase en su aplicación, le recomendamos enfáticamente que use BoM para administrar las versiones de la biblioteca, 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.4.2' }
Dart
- Si aún no lo ha hecho, configure e inicialice Firebase en su aplicación Flutter.
- Desde la raíz de su proyecto Flutter, ejecute el siguiente comando para instalar el complemento:
flutter pub add cloud_firestore
- Una vez completada, reconstruya su aplicación Flutter:
flutter run
- Opcional: mejore los tiempos de compilación de iOS y macOS al incluir el marco precompilado.
Actualmente, el SDK de Firestore para iOS depende de un código que puede tardar más de 5 minutos en compilarse en Xcode. Para reducir significativamente los tiempos de compilación, puede usar una versión precompilada agregando esta línea al bloque de
target 'Runner' do
en su Podfile:target 'Runner' do pod 'FirebaseFirestore', :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git', :tag => '8.15.0' # ... end
Además, asegúrese de haber actualizado CocoaPods a 1.9.1 o superior:
gem install cocoapods
Para obtener más información, consulte el problema en GitHub .
Java
- Agregue el SDK de administración de Firebase a su aplicación:
- 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 las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
Pitón
- Agregue el SDK de administración de Firebase a su aplicación de Python:
pip install --upgrade firebase-admin
- Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
C++
- Siga las instrucciones para agregar Firebase a su proyecto de C++ .
- Interfaz C++ para Android.
- Dependencias de Gradle. Agregue lo siguiente a su archivo Gradle de módulo (nivel de aplicación) (generalmente
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 }
- Dependencias binarias. De manera similar, la forma recomendada de obtener las dependencias binarias es agregar lo siguiente a su 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 de escritorio , consulte Agregar Firebase a su proyecto de C++ .
Unidad
- Siga las instrucciones para agregar Firebase a su proyecto de Unity .
- Interfaz de unidad para Android.
- Seleccione Archivo > Configuración de compilación
- Cambie 'Plataforma' a 'Android' y haga clic en 'Cambiar plataforma'
- Haga clic en 'Configuración del jugador...'
- En la interfaz de usuario principal de Unity, en 'Configuración para Android', seleccione 'Configuración de publicación'
- En la sección 'Minificar', cambie la configuración de versión y depuración de 'Ninguno' a 'ProGuard'
Al compilar para Android, habilite ProGuarding para evitar el límite de DEX de Android. Para hacerlo, en el editor de Unity:
Nodo.js
- Agregue el SDK de administración de Firebase a su aplicación:
npm install firebase-admin --save
- Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
Vamos
- Agregue el SDK de administrador de Firebase a su aplicación Go:
go get firebase.google.com/go
- Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
PHP
- Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) utilizan las credenciales predeterminadas de la aplicación de Google para la autenticación.
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de clave de cuenta de servicio JSON. Puede crear un archivo clave en la página Credenciales de la consola API .export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En su entorno de producción, no necesita autenticarse si ejecuta su aplicación en App Engine o Compute Engine, usando el mismo proyecto que usa para Cloud Firestore. De lo contrario, configure una cuenta de servicio .
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
- Instale y habilite la extensión gRPC para PHP, que necesitará para usar la biblioteca del cliente.
- Agregue la biblioteca PHP de Cloud Firestore a su aplicación:
composer require google/cloud-firestore
C#
- Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) utilizan las credenciales predeterminadas de la aplicación de Google para la autenticación.
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de clave de cuenta de servicio JSON. Puede crear un archivo clave en la página Credenciales de la consola API .export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En su entorno de producción, no necesita autenticarse si ejecuta su aplicación en App Engine o Compute Engine, usando el mismo proyecto que usa para Cloud Firestore. De lo contrario, configure una cuenta de servicio .
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
- Agregue la biblioteca C# de Cloud Firestore a su aplicación en su archivo
.csproj
:<ItemGroup> <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" /> </ItemGroup>
- Agregue lo siguiente a su archivo
Program.cs
:using Google.Cloud.Firestore;
Rubí
- Las bibliotecas cliente del servidor de Cloud Firestore (Java, Node.js, Python, Go, PHP, C# y Ruby) utilizan las credenciales predeterminadas de la aplicación de Google para la autenticación.
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
GOOGLE_APPLICATION_CREDENTIALS
para que apunte a un archivo de clave de cuenta de servicio JSON. Puede crear un archivo clave en la página Credenciales de la consola API .export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- En su entorno de producción, no necesita autenticarse si ejecuta su aplicación en App Engine o Compute Engine, usando el mismo proyecto que usa para Cloud Firestore. De lo contrario, configure una cuenta de servicio .
- Para autenticarse desde su entorno de desarrollo, configure la variable de entorno
- Agregue la biblioteca Cloud Firestore Ruby a su aplicación en su
Gemfile
:gem "google-cloud-firestore"
- Instale dependencias desde su
Gemfile
usando:bundle install
(Opcional) Realice prototipos y pruebas con Firebase Local Emulator Suite
Para los desarrolladores móviles, antes de hablar sobre cómo su aplicación escribe y lee desde Cloud Firestore, presentemos un conjunto de herramientas que puede usar para crear prototipos y probar la funcionalidad de Cloud Firestore: Firebase Local Emulator Suite. Si está probando diferentes modelos de datos, optimizando sus reglas de seguridad o trabajando para encontrar la forma más rentable de interactuar con el back-end, poder trabajar localmente sin implementar servicios en vivo puede ser una gran idea.
Un emulador de Cloud Firestore es parte de Local Emulator Suite, que permite que su aplicación interactúe con el contenido y la configuración de su base de datos emulada, así como, opcionalmente, con los recursos de su proyecto emulado (funciones, otras bases de datos y reglas de seguridad).
Usar el emulador de Cloud Firestore implica solo unos pocos pasos:
- Agregar una línea de código a la configuración de prueba de su aplicación para conectarse al emulador.
- Desde la raíz del directorio de tu proyecto local, ejecuta
firebase emulators:start
. - Hacer llamadas desde el código prototipo de su aplicación utilizando un SDK de la plataforma Cloud Firestore como de costumbre.
Hay disponible un tutorial detallado sobre Cloud Firestore y Cloud Functions . También debería echar un vistazo a la introducción de Local Emulator Suite .
Inicializar Cloud Firestore
Inicializa una instancia de Cloud Firestore:
Web version 9
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);
Reemplace FIREBASE_CONFIGURATION con firebaseConfig
de su aplicación web.
Para conservar los datos cuando el dispositivo pierde su conexión, consulte la documentación Habilitar datos sin conexión .
Web version 8
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();
Reemplace FIREBASE_CONFIGURATION con firebaseConfig
de su aplicación web.
Para conservar los datos cuando el dispositivo pierde su conexión, consulte la documentación Habilitar datos sin conexión .
Rápido
import FirebaseCore import FirebaseFirestore
FirebaseApp.configure() let db = Firestore.firestore()
C objetivo
@import FirebaseCore; @import FirebaseFirestore; // Use Firebase library to configure APIs [FIRApp configure];
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
Java
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
Kotlin+KTX
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Dart
db = FirebaseFirestore.instance;
Java
El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .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 Firebase Admin SDK en su propio servidor, use una cuenta de servicio .
Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use 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();
Pitón
El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .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 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 Firebase Admin SDK en su propio servidor, use una cuenta de servicio .
Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use 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 diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .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 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 Firebase Admin SDK en su propio servidor, use una cuenta de servicio .
Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use 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();
Nodo.js
El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .- Inicializar en Cloud Functions
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
initializeApp(); const db = getFirestore();
- Inicializar en Google Cloud
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
initializeApp({ credential: applicationDefault() }); const db = getFirestore();
- Inicializar en su propio servidor
Para usar el SDK de administración de Firebase en su propio servidor (o en cualquier otro entorno de Node.js), use una cuenta de servicio . Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
const serviceAccount = require('./path/to/serviceAccountKey.json'); initializeApp({ credential: cert(serviceAccount) }); const db = getFirestore();
Vamos
El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .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 Firebase Admin SDK en su propio servidor, use una cuenta de servicio .
Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use 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 cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .
Unidad
using Firebase.Firestore; using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C#
C#
Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .
Rubí
Agregar datos
Cloud Firestore almacena datos en Documentos, que se almacenan en Colecciones. Cloud Firestore crea colecciones y documentos implícitamente la primera vez que agrega datos al documento. No necesita crear colecciones o documentos explícitamente.
Cree una nueva colección y un documento con el siguiente código de ejemplo.
Web version 9
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); }
Web version 8
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); });
Rápido
// 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)") } }
C objetivo
// 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
Pitón
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; } });
Nodo.js
Vamos
PHP
PHP
Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .
Unidad
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#
Rubí
Ahora agregue otro documento a la colección de users
. Tenga en cuenta que este documento incluye un par clave-valor (segundo nombre) que no aparece en el primer documento. Los documentos de una colección pueden contener diferentes conjuntos de información.
Web version 9
// 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); }
Web version 8
// 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); });
Rápido
// 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)") } }
C objetivo
// 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
Pitón
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; } });
Nodo.js
Vamos
PHP
PHP
Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .
Unidad
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#
Rubí
Leer datos
Para verificar rápidamente que ha agregado datos a Cloud Firestore, use el visor de datos en la consola de Firebase .
También puede usar el método "obtener" para recuperar la colección completa.
Web version 9
import { collection, getDocs } from "firebase/firestore"; const querySnapshot = await getDocs(collection(db, "users")); querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); });
Web version 8
db.collection("users").get().then((querySnapshot) => { querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); }); });
Rápido
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())") } } }
C objetivo
[[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
Pitón
users_ref = db.collection(u'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; } });
Nodo.js
Vamos
PHP
PHP
Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .
Unidad
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#
Rubí
Proteja sus datos
Si usa el SDK de las plataformas Web, Android o Apple, use Firebase Authentication y Cloud Firestore Security Rules para proteger sus datos en Cloud Firestore.
Aquí hay algunos conjuntos de reglas básicas que puede usar para comenzar. Puede modificar sus reglas de seguridad en la pestaña Reglas de la consola.
Autorización requerida
// 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 su aplicación web, Android o iOS en producción, también tome medidas para asegurarse de que solo los clientes de su aplicación puedan acceder a sus datos de Cloud Firestore. Consulte la documentación de verificación de la aplicación .
Si usa uno de los SDK del servidor, use la administración de acceso e identidad (IAM) para proteger sus datos en Cloud Firestore.
Ver un videotutorial
Para obtener instrucciones detalladas sobre cómo comenzar con las bibliotecas de clientes móviles de Cloud Firestore, vea uno de los siguientes tutoriales en video:
Web
iOS+
Androide
Puedes encontrar más videos en el canal de YouTube de Firebase.
Próximos pasos
Profundiza tus conocimientos con los siguientes temas:
- Laboratorios de código: aprenda a usar Cloud Firestore en una aplicación real siguiendo el laboratorio de código para Android , iOS o Web .
- Modelo de datos : obtenga más información sobre cómo se estructuran los datos en Cloud Firestore, incluidos los datos jerárquicos y las subcolecciones.
- Agregar datos : obtenga más información sobre cómo crear y actualizar datos en Cloud Firestore.
- Obtener datos : obtenga más información sobre cómo recuperar datos.
- Realice consultas simples y compuestas : aprenda a ejecutar consultas simples y compuestas.
- Ordenar y limitar consultas Aprenda a ordenar y limitar los datos devueltos por sus consultas.