Primeros pasos con Cloud Firestore

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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

  1. Sigue las instrucciones para agregar Firebase a tu app web.
  2. 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

  1. Sigue las instrucciones para agregar Firebase a tu app web.
  2. 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.

  1. Abre el proyecto de tu app y, en Xcode, navega a File > Swift Packages > Add Package Dependency.
  2. Cuando se te solicite, agrega el repositorio del SDK de Firebase para plataformas de Apple:
  3.   https://github.com/firebase/firebase-ios-sdk
      
  4. Elige la biblioteca de Firestore.
  5. Cuando termines, Xcode comenzará a resolver y descargar automáticamente tus dependencias en segundo plano.
Android
  1. Sigue las instrucciones para agregar Firebase a tu app para Android.
  2. 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 o app/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

  1. Si aún no lo has hecho, configura e inicializa Firebase en tu app de Flutter.
  2. Desde la raíz de tu proyecto de Flutter, ejecuta el siguiente comando para instalar el complemento:
    flutter pub add cloud_firestore
  3. Cuando termines, vuelve a compilar tu aplicación de Flutter:
    flutter run
  4. 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 de firebase_core. Si no usas la versión más reciente de firebase_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
  1. 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>
           
  2. Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
Python
  1. Agrega el SDK de Firebase Admin a tu app de Python:
    pip install --upgrade firebase-admin
  2. Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
C++
  1. Sigue las instrucciones para agregar Firebase a tu proyecto de C++.
  2. 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}")
              
  3. Para configurar la integración con el escritorio, consulta Agrega Firebase a tu proyecto de C++.
Unity
  1. Sigue las instrucciones para agregar Firebase a tu proyecto de Unity.
  2. Usa la interfaz de Unity para configurar tu proyecto para reducir las compilaciones de Android.
  3. Debes reducir la compilación para evitar el mensaje Error while merging dex archives.

    • 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.
Node.js
  1. Agrega el SDK de Firebase Admin a tu app:
    npm install firebase-admin --save
  2. Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
Go
  1. Agrega el SDK de Firebase Admin a tu app de Go:
    go get firebase.google.com/go
    
  2. Sigue las instrucciones que aparecen a continuación para inicializar Cloud Firestore con las credenciales apropiadas en tu entorno.
PHP
  1. 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.
  2. Instala y habilita la extensión de gRPC para PHP, que necesitarás para usar la biblioteca cliente.
  3. Agrega la biblioteca PHP de Cloud Firestore a tu app:
    composer require google/cloud-firestore
C#
  1. 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.
  2. 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>
  3. Agrega lo siguiente a tu archivo Program.cs:
    using Google.Cloud.Firestore;
Ruby
  1. 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.
  2. Agrega la biblioteca de Ruby para Cloud Firestore a tu app en el archivo Gemfile:
    gem "google-cloud-firestore"
  3. 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:

  1. Agrega una línea de código a la configuración de prueba de tu app para conectarte al emulador.
  2. Desde la raíz del directorio de tu proyecto local, ejecuta firebase emulators:start.
  3. 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
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
Objective‑C
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
@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.
  • Inicializa 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();
    
  • Inicializa en tu propio servidor

    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.
  • Inicializa 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 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()
  • Inicializa en tu propio servidor

    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.
  • Inicializa 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 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()
  • Inicializa en tu propio servidor

    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.
  • Inicializa 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()
    
  • Inicializa en tu propio servidor

    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.

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

    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Ruby
    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."

    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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    // 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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    // 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());
    Python
    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;
      }
    });
    Node.js
    const docRef = db.collection('users').doc('alovelace');
    
    await docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
    Go
    _, _, 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 la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente 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);
    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#
    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);
    Ruby
    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 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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    // 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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    // 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());
    Python
    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;
          }
        });
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');
    
    await aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
    Go
    _, _, 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 la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente 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);
    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#
    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);
    Ruby
    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."

    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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    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
    Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
    [[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"));
    }
    Python
    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;
      }
    });
    Node.js
    const snapshot = await db.collection('users').get();
    snapshot.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
    Go
    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 la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente 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);
    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#
    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();
    }
    Ruby
    users_ref = firestore.col collection_path
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end

    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.