Comience con Cloud Firestore

Este inicio rápido le muestra cómo configurar Cloud Firestore, agregar datos y luego ver los datos que acaba de agregar en Firebase console.

Crear una base de datos de Cloud Firestore

  1. Si aún no lo has hecho, crea un proyecto de Firebase: 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.

  2. Navegue a la sección Cloud Firestore de Firebase console . Se te pedirá que selecciones un proyecto de Firebase existente. Siga el flujo de trabajo de creación de la base de datos.

  3. Seleccione un modo de inicio para sus reglas de seguridad de Cloud Firestore:

    Modo de prueba

    Bueno para comenzar con las bibliotecas de clientes web y móviles, pero permite que cualquiera 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 Apple o el SDK de Android, seleccione el modo de prueba.

    Modo bloqueado

    Niega todas las lecturas y escrituras desde clientes web y móviles. 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.

    Su conjunto inicial de reglas de seguridad de Cloud Firestore se aplicará a su base de datos predeterminada de Cloud Firestore. Si crea varias bases de datos para su proyecto, puede implementar reglas de seguridad de Cloud Firestore para cada base de datos.

  4. 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 puedes seleccionar una ubicación, entonces tu 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.

  5. 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 cliente a su aplicación.

Web namespaced API

  1. Siga las instrucciones para agregar Firebase a su aplicación web .
  2. Agregue las bibliotecas de Firebase y Cloud Firestore a su aplicación:
    <script src="https://www.gstatic.com/firebasejs/10.8.1/firebase-app-compat.js"></script>
    <script src="https://www.gstatic.com/firebasejs/10.8.1/firebase-firestore-compat.js"></script>
    El SDK de Cloud Firestore también está disponible como paquete npm.
    npm install firebase@10.8.1 --save
    
    Deberá solicitar manualmente tanto Firebase como Cloud Firestore.
    import firebase from "firebase/compat/app";
    // Required for side-effects
    import "firebase/firestore";
    

Web modular API

  1. Siga las instrucciones para agregar Firebase a su aplicación web .
  2. El SDK de Cloud Firestore está disponible como paquete npm.
    npm install firebase@10.8.1 --save
    
    Deberá importar Firebase y Cloud Firestore.
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";
    
iOS+

Sigue las instrucciones para agregar Firebase a tu aplicación de Apple .

Utilice Swift Package Manager para instalar y administrar las dependencias de Firebase.

  1. En Xcode, con el proyecto de su aplicación abierto, navegue hasta Archivo > Paquetes Swift > Agregar dependencia del paquete .
  2. Cuando se le solicite, agregue el repositorio SDK de las plataformas Firebase Apple:
  3.   https://github.com/firebase/firebase-ios-sdk
      
  4. Elija la biblioteca de Firestore.
  5. Cuando termine, Xcode comenzará automáticamente a resolver y descargar sus dependencias en segundo plano.
Androide
  1. Siga las instrucciones para agregar Firebase a su aplicación de Android .
  2. Usando Firebase Android BoM , declara la dependencia de la biblioteca Cloud Firestore para Android en tu archivo Gradle de módulo (nivel de aplicación) (generalmente app/build.gradle.kts o app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.3"))
    
        // 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 dependencias de la biblioteca de Firebase sin usar la BoM

    Si elige no utilizar la BoM de Firebase, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

    Tenga en cuenta que si utiliza varias bibliotecas de Firebase en su aplicación, le recomendamos encarecidamente utilizar la 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.10.3")
    }
    

    ¿Busca 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 biblioteca principal (para obtener más detalles, consulte las preguntas frecuentes sobre esta iniciativa ).

Dart

  1. Si aún no lo has hecho, configura e inicializa Firebase en tu aplicación Flutter.
  2. Desde la raíz de su proyecto Flutter, ejecute el siguiente comando para instalar el complemento:
    flutter pub add cloud_firestore
  3. Una vez completado, reconstruya su aplicación Flutter:
    flutter run
  4. 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 do target 'Runner' do en su 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

    Reemplace IOS_SDK_VERSION con la versión del SDK de Firebase iOS especificada en el archivo firebase_core 's firebase_sdk_version.rb . Si no estás usando la última versión de firebase_core , busca este archivo en la caché de tu paquete Pub local (generalmente ~/.pub-cache ).

    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
  1. Agrega el SDK de administrador de Firebase a tu 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>
           
  2. Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
Pitón
  1. Agregue el SDK de administrador de Firebase a su aplicación Python:
    pip install --upgrade firebase-admin
  2. Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
C++
  1. Siga las instrucciones para agregar Firebase a su proyecto C++ .
  2. Interfaz C++ para Android.
    • Dependencias de Gradle. Agregue lo siguiente al archivo Gradle de su 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}")
              
  3. Para configurar la integración de escritorio , consulte Agregar Firebase a su proyecto de C++ .
Unidad
  1. Siga las instrucciones para agregar Firebase a su proyecto de Unity .
  2. Utilice la interfaz de Unity para configurar su proyecto para minimizar las compilaciones de Android.
  3. Debe minimizar la compilación para evitar el mensaje Error while merging dex archives .

    • La opción se puede encontrar en Configuración del reproductor > Android > Configuración de publicación > Minificar .
    • Las opciones pueden diferir en diferentes versiones de Unity, así que consulte la documentación oficial de Unity y la Guía de depuración de Firebase Unity Build .
    • Si, después de habilitar la minificación, la cantidad de métodos referenciados aún excede el límite, otra opción es habilitar multidex en:
      • mainTemplate.gradle si la plantilla Gradle personalizada en Configuración del reproductor está habilitada
      • o el archivo build.gradle a nivel de módulo, si usa Android Studio para compilar el proyecto exportado.
Nodo.js
  1. Agregue el SDK de administrador de Firebase a su aplicación:
    npm install firebase-admin --save
  2. Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
Ir
  1. Agregue el SDK de administrador de Firebase a su aplicación Go:
    go get firebase.google.com/go
    
  2. Siga las instrucciones a continuación para inicializar Cloud Firestore con las credenciales adecuadas en su entorno.
PHP
  1. Las bibliotecas cliente del servidor 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 de 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 .
  2. Instale y habilite la extensión gRPC para PHP, que necesitará para usar la biblioteca cliente.
  3. Agregue la biblioteca PHP de Cloud Firestore a su aplicación:
    composer require google/cloud-firestore
C#
  1. Las bibliotecas cliente del servidor 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 de 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 .
  2. 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>
  3. Agregue lo siguiente a su archivo Program.cs :
    using Google.Cloud.Firestore;
Rubí
  1. Las bibliotecas cliente del servidor 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 de 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 .
  2. Agregue la biblioteca Ruby de Cloud Firestore a su aplicación en su Gemfile :
    gem "google-cloud-firestore"
  3. Instale dependencias desde su Gemfile usando:
    bundle install

(Opcional) Prototipo y prueba con Firebase Local Emulator Suite

Para los desarrolladores de dispositivos móviles, antes de hablar sobre cómo su aplicación escribe y lee desde Cloud Firestore, presentemos un conjunto de herramientas que pueden 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 Cloud Firestore implica solo unos pocos pasos:

  1. Agregar una línea de código a la configuración de prueba de su aplicación para conectarse al emulador.
  2. Desde la raíz del directorio de su proyecto local, ejecute firebase emulators:start .
  3. Realizar llamadas desde el código prototipo de tu aplicación utilizando un SDK de la plataforma Cloud Firestore como de costumbre.

Está disponible un tutorial detallado sobre Cloud Firestore y Cloud Functions . También deberías echar un vistazo a la introducción a Local Emulator Suite .

Inicializar Cloud Firestore

Inicialice una instancia de Cloud Firestore:

Web modular API

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 la conexión, consulte la documentación Habilitar datos sin conexión .

Web namespaced API

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 la conexión, consulte la documentación Habilitar datos sin conexión .

Rápido
Nota: Este producto no está disponible en destinos watchOS y App Clip.
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
C objetivo
Nota: Este producto no está disponible en destinos watchOS y App Clip.
@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 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 Google Cloud
    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();
    
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administrador > 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 .
  • Inicializar en Google Cloud
    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 utilizar 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()
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administrador > 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 .
  • Inicializar en Google Cloud
    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 utilizar 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()
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administrador > 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, Filter } = require('firebase-admin/firestore');
      initializeApp();
      
      const db = getFirestore();
      
    • Inicializar 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();
    • Inicializar en su propio servidor

      Para usar el SDK de Firebase Admin en su propio servidor (o 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, Filter } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      initializeApp({
        credential: cert(serviceAccount)
      });
      
      const db = getFirestore();
      
    Ir
    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 Google Cloud
    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()
    
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin 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 .

    use Google\Cloud\Firestore\FirestoreClient;
    
    /**
     * Initialize Cloud Firestore with default project ID.
     */
    function setup_client_create(string $projectId = null)
    {
        // Create the Cloud Firestore client
        if (empty($projectId)) {
            // The `projectId` parameter is optional and represents which project the
            // client will act on behalf of. If not supplied, the client falls back to
            // the default project inferred from the environment.
            $db = new FirestoreClient();
            printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
        } else {
            $db = new FirestoreClient([
                'projectId' => $projectId,
            ]);
            printf('Created Cloud Firestore client with project ID: %s' . PHP_EOL, $projectId);
        }
    }
    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 .

    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Rubí
    require "google/cloud/firestore"
    
    # The `project_id` parameter is optional and represents which project the
    # client will act on behalf of. If not supplied, the client falls back to the
    # default project inferred from the environment.
    firestore = Google::Cloud::Firestore.new project_id: project_id
    
    puts "Created Cloud Firestore client with given project ID."

    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 agregas datos al documento. No es necesario crear colecciones o documentos explícitamente.

    Cree una nueva colección y un documento utilizando el siguiente código de ejemplo.

    Web modular API

    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 namespaced API

    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
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    // 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)")
    }
    C objetivo
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    // 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
    DocumentReference docRef = db.collection("users").document("alovelace");
    // Add document data  with id "alovelace" using a hashmap
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Ada");
    data.put("last", "Lovelace");
    data.put("born", 1815);
    //asynchronously write data
    ApiFuture<WriteResult> result = docRef.set(data);
    // ...
    // result.get() blocks on response
    System.out.println("Update time : " + result.get().getUpdateTime());
    Pitón
    doc_ref = db.collection("users").document("alovelace")
    doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})

    Python

    doc_ref = db.collection("users").document("alovelace")
    await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    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
    const docRef = db.collection('users').doc('alovelace');
    
    await docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
    Ir
    _, _, err := client.Collection("users").Add(ctx, map[string]interface{}{
    	"first": "Ada",
    	"last":  "Lovelace",
    	"born":  1815,
    })
    if err != nil {
    	log.Fatalf("Failed adding alovelace: %v", err)
    }
    PHP

    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 .

    $docRef = $db->collection('samples/php/users')->document('alovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    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#
    DocumentReference docRef = db.Collection("users").Document("alovelace");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Ada" },
        { "Last", "Lovelace" },
        { "Born", 1815 }
    };
    await docRef.SetAsync(user);
    Rubí
    doc_ref = firestore.doc "#{collection_path}/alovelace"
    
    doc_ref.set(
      {
        first: "Ada",
        last:  "Lovelace",
        born:  1815
      }
    )
    
    puts "Added data to the alovelace document in the users collection."

    Ahora agregue otro documento a la colección 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 modular API

    // 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 namespaced API

    // 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
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    // 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)")
    }
    C objetivo
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    // 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
    DocumentReference docRef = db.collection("users").document("aturing");
    // Add document data with an additional field ("middle")
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Alan");
    data.put("middle", "Mathison");
    data.put("last", "Turing");
    data.put("born", 1912);
    
    ApiFuture<WriteResult> result = docRef.set(data);
    System.out.println("Update time : " + result.get().getUpdateTime());
    Pitón
    doc_ref = db.collection("users").document("aturing")
    doc_ref.set({"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912})

    Python

    doc_ref = db.collection("users").document("aturing")
    await doc_ref.set(
        {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
    )
    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
    const aTuringRef = db.collection('users').doc('aturing');
    
    await aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
    Ir
    _, _, err = client.Collection("users").Add(ctx, map[string]interface{}{
    	"first":  "Alan",
    	"middle": "Mathison",
    	"last":   "Turing",
    	"born":   1912,
    })
    if err != nil {
    	log.Fatalf("Failed adding aturing: %v", err)
    }
    PHP

    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 .

    $docRef = $db->collection('samples/php/users')->document('aturing');
    $docRef->set([
        'first' => 'Alan',
        'middle' => 'Mathison',
        'last' => 'Turing',
        'born' => 1912
    ]);
    printf('Added data to the aturing document in the users collection.' . PHP_EOL);
    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#
    DocumentReference docRef = db.Collection("users").Document("aturing");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Alan" },
        { "Middle", "Mathison" },
        { "Last", "Turing" },
        { "Born", 1912 }
    };
    await docRef.SetAsync(user);
    Rubí
    doc_ref = firestore.doc "#{collection_path}/aturing"
    
    doc_ref.set(
      {
        first:  "Alan",
        middle: "Mathison",
        last:   "Turing",
        born:   1912
      }
    )
    
    puts "Added data to the aturing document in the users collection."

    leer datos

    Utilice el visor de datos en Firebase console para verificar rápidamente que haya agregado datos a Cloud Firestore.

    También puedes utilizar el método "get" para recuperar la colección completa.

    Web modular API

    import { collection, getDocs } from "firebase/firestore"; 
    
    const querySnapshot = await getDocs(collection(db, "users"));
    querySnapshot.forEach((doc) => {
      console.log(`${doc.id} => ${doc.data()}`);
    });

    Web namespaced API

    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });
    Rápido
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    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)")
    }
    C objetivo
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    [[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
    // asynchronously retrieve all users
    ApiFuture<QuerySnapshot> query = db.collection("users").get();
    // ...
    // query.get() blocks on response
    QuerySnapshot querySnapshot = query.get();
    List<QueryDocumentSnapshot> documents = querySnapshot.getDocuments();
    for (QueryDocumentSnapshot document : documents) {
      System.out.println("User: " + document.getId());
      System.out.println("First: " + document.getString("first"));
      if (document.contains("middle")) {
        System.out.println("Middle: " + document.getString("middle"));
      }
      System.out.println("Last: " + document.getString("last"));
      System.out.println("Born: " + document.getLong("born"));
    }
    Pitón
    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    for doc in docs:
        print(f"{doc.id} => {doc.to_dict()}")

    Python

    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    async for doc in docs:
        print(f"{doc.id} => {doc.to_dict()}")
    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
    const snapshot = await db.collection('users').get();
    snapshot.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
    Ir
    iter := client.Collection("users").Documents(ctx)
    for {
    	doc, err := iter.Next()
    	if err == iterator.Done {
    		break
    	}
    	if err != nil {
    		log.Fatalf("Failed to iterate: %v", err)
    	}
    	fmt.Println(doc.Data())
    }
    PHP

    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 .

    $usersRef = $db->collection('samples/php/users');
    $snapshot = $usersRef->documents();
    foreach ($snapshot as $user) {
        printf('User: %s' . PHP_EOL, $user->id());
        printf('First: %s' . PHP_EOL, $user['first']);
        if (!empty($user['middle'])) {
            printf('Middle: %s' . PHP_EOL, $user['middle']);
        }
        printf('Last: %s' . PHP_EOL, $user['last']);
        printf('Born: %d' . PHP_EOL, $user['born']);
        printf(PHP_EOL);
    }
    printf('Retrieved and printed out all documents from the users collection.' . PHP_EOL);
    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#
    CollectionReference usersRef = db.Collection("users");
    QuerySnapshot snapshot = await usersRef.GetSnapshotAsync();
    foreach (DocumentSnapshot document in snapshot.Documents)
    {
        Console.WriteLine("User: {0}", document.Id);
        Dictionary<string, object> documentDictionary = document.ToDictionary();
        Console.WriteLine("First: {0}", documentDictionary["First"]);
        if (documentDictionary.ContainsKey("Middle"))
        {
            Console.WriteLine("Middle: {0}", documentDictionary["Middle"]);
        }
        Console.WriteLine("Last: {0}", documentDictionary["Last"]);
        Console.WriteLine("Born: {0}", documentDictionary["Born"]);
        Console.WriteLine();
    }
    Rubí
    users_ref = firestore.col collection_path
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end

    Asegure sus datos

    Si utiliza el SDK de las plataformas web, Android o Apple, utilice Firebase Authentication y las reglas de seguridad de Cloud Firestore para proteger sus datos en Cloud Firestore.

    A continuación se muestran algunos conjuntos de reglas básicas que puede utilizar para comenzar. Puede modificar sus reglas de seguridad en la pestaña Reglas de la consola.

    Se requiere autenticación

    // 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 App Check .

    Si estás usando uno de los SDK del servidor, usa la administración de identidad y acceso (IAM) para proteger tus datos en Cloud Firestore.

    Ver un vídeo tutorial

    Para obtener orientación detallada sobre cómo comenzar a utilizar las bibliotecas de clientes móviles de Cloud Firestore, mire uno de los siguientes tutoriales en vídeo:

    Web
    iOS+
    Androide

    Puedes encontrar más vídeos en el canal de YouTube de Firebase.

    Próximos pasos

    Profundiza tus conocimientos con los siguientes temas:

    • Codelabs : aprenda a usar Cloud Firestore en una aplicación real siguiendo el codelab 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.