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 de 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 Google Cloud existente.

  2. Abre tu proyecto en Firebase console. En el panel izquierdo, expande Compilación y, luego, selecciona Base de datos de Firestore.

  3. Haz clic en Crear base de datos.

  4. Selecciona una ubicación para tu base de datos.

    Si no puedes seleccionar una ubicación, significa que ya se configuró la "ubicación para los recursos predeterminados de Google Cloud" de tu proyecto. Algunos de los recursos de tu proyecto (como la instancia predeterminada de Cloud Firestore) comparten una dependencia de ubicación común, y su ubicación se puede establecer durante la creación del proyecto o en la configuración de otro servicio que comparte esta dependencia de ubicación.

  5. Selecciona un modo de inicio para tu Cloud Firestore Security Rules:

    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 Cloud Firestore Security Rules se aplicará tu base de datos de Cloud Firestore predeterminada. Si creas varias bases de datos para tu proyecto, puedes implementar Cloud Firestore Security Rules para cada una.

  6. Haz clic en Crear.

Cuando habilitas Cloud Firestore, también habilitas 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.

Web

  1. Sigue las instrucciones para agregar Firebase a tu app web.
  2. Agrega las bibliotecas de Firebase y Cloud Firestore a la app:
    <script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-app-compat.js"></script>
<script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-firestore-compat.js"></script>
     El SDK de Cloud Firestore también está disponible como un paquete npm.
    npm install firebase@11.0.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";

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@11.0.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
  3. Elige la biblioteca de Firestore.
  4. 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:33.6.0"))

    // Declare the dependency for the Cloud Firestore library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-firestore")
}

    Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

    (Alternativa) Declara las dependencias de la biblioteca de Firebase sin usar la BoM

    Si eliges no usar Firebase BoM, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

    Si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable 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:25.1.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 (al nivel de la 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.

Un emulador de Cloud Firestore forma 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).

El uso del emulador de Cloud Firestore solo requiere algunos pasos sencillos:

  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.

Hay una explicación detallada sobre Cloud Firestore y Cloud Functions disponible. También deberías consultar la introducción a Local Emulator Suite.

Inicializa Cloud Firestore

Inicializa una instancia de Cloud Firestore:

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.

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()
AppDelegate.swift
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];
AppDelegate.m

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
 
val db = Firebase.firestore
DocSnippets.kt

Java

// Access a Cloud Firestore instance from your Activity
 
FirebaseFirestore db = FirebaseFirestore.getInstance();
DocSnippets.java

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()
    firestore.py

    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()
    firestore.py
  • 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()
    firestore.py

    • 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()
    firestore_async.py

    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()
    firestore_async.py
  • 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()
    firestore_async.py
    • C++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();
    AppDelegate.mm
    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();

      index.js
    • 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();
      index.js
    • 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();

      index.js
    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 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);
    }
}
    setup_client_create.php
    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 Bibliotecas cliente de Cloud Firestore. 

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

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

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

    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);
});
    test.firestore.js
    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)")
}
    ViewController.swift
    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);
      }
    }];
    ViewController.m

    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)
    }
    DocSnippets.kt

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

    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}'));
    firestore.dart
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("alovelace")
doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py

    Python

    doc_ref = db.collection("users").document("alovelace")
await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py
    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;
  }
});
    snippets.cpp
    Node.js
    const docRef = db.collection('users').doc('alovelace');

await docRef.set({
  first: 'Ada',
  last: 'Lovelace',
  born: 1815
});
    index.js
    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)
}
    main.go
    PHP

    PHP

    Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta 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);
    setup_dataset.php
    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);
    Program.cs
    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."
    quickstart.rb

    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.

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

    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);
});
    test.firestore.js
    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)")
}
    ViewController.swift
    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);
      }
    }];
    ViewController.m

    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)
    }
    DocSnippets.kt

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

    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}'));
    firestore.dart
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("aturing")
doc_ref.set({"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912})
    snippets.py

    Python

    doc_ref = db.collection("users").document("aturing")
await doc_ref.set(
    {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
)
    snippets.py
    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;
      }
    });
    snippets.cpp
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');

await aTuringRef.set({
  'first': 'Alan',
  'middle': 'Mathison',
  'last': 'Turing',
  'born': 1912
});
    index.js
    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)
}
    main.go
    PHP

    PHP

    Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta 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);
    setup_dataset.php
    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);
    Program.cs
    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."
    quickstart.rb

    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.

    Web

    import { collection, getDocs } from "firebase/firestore"; 

const querySnapshot = await getDocs(collection(db, "users"));
querySnapshot.forEach((doc) => {
  console.log(`${doc.id} => ${doc.data()}`);
});
    get_all_users.js

    Web

    db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});
    test.firestore.js
    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)")
}
    ViewController.swift
    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);
        }
      }
    }];
    ViewController.m

    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)
    }
    DocSnippets.kt

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

    Dart

    await db.collection("users").get().then((event) {
  for (var doc in event.docs) {
    print("${doc.id} => ${doc.data()}");
  }
});
    firestore.dart
    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"));
}
    Quickstart.java
    Python
    users_ref = db.collection("users")
docs = users_ref.stream()

for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py

    Python

    users_ref = db.collection("users")
docs = users_ref.stream()

async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py
    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;
  }
});
    snippets.cpp
    Node.js
    const snapshot = await db.collection('users').get();
snapshot.forEach((doc) => {
  console.log(doc.id, '=>', doc.data());
});
    index.js
    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())
}
    main.go
    PHP

    PHP

    Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta 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);
    setup_dataset_read.php
    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();
}
    Program.cs
    Ruby
    users_ref = firestore.col collection_path
users_ref.get do |user|
  puts "#{user.document_id} data: #{user.data}."
end
    quickstart.rb

    Protege los datos

    Si usas el SDK de Android, la Web o las plataformas de Apple, usa Firebase Authentication y Cloud Firestore Security Rules 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 to a document keyed by the user's UID
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{uid} {
      allow read, write: if request.auth != null && request.auth.uid == uid;
    }
  }
}

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

    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.