Comienza a usar la edición Enterprise de Cloud Firestore

En esta guía de inicio rápido, verás cómo configurar la edición Enterprise de Cloud Firestore, agregar datos y, luego, usar las operaciones de Core o de Pipeline para consultar los datos que acabas de agregar en Firebase console.

Cloud Firestore admite SDKs web o para dispositivos móviles, y bibliotecas cliente del servidor.

  • Cloud Firestore admite SDKs para Android, iOS, la Web y mucho más. Los SDKs web y para dispositivos móviles, junto con Cloud Firestore Security Rules y Firebase Authentication, admiten arquitecturas de apps sin servidores en las que los clientes pueden conectarse directamente con tu base de datos de Cloud Firestore.

  • Cloud Firestore admite bibliotecas cliente del servidor para Java, Node.js y Python. Puedes usarlas para configurar entornos de servidor con privilegios y acceso completo a tu base de datos. Obtén más información sobre estas bibliotecas en la guía de inicio rápido para las bibliotecas cliente del servidor.

Crea una base de datos de la edición Enterprise 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 Enterprise para el modo de base de datos.

  5. Selecciona Firestore en modo nativo para el modo de operación, que admite operaciones de Core y de Pipeline.

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

  7. 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 de producción

    Rechaza todas las lecturas y escrituras de clientes móviles y web. Tus servidores de aplicaciones autenticados (Python) aún pueden acceder a tu base de datos.

    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.

  8. Haz clic en Crear.

Cuando habilitas la edición Enterprise de 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.

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@12.8.0 --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:34.7.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:26.0.2")
}

    ¿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).

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


// When initializing Firestore, remember to use the name of the database you created earlier:
const db = initializeFirestore(app, {}, 'your-new-enterprise-database');

Reemplaza FIREBASE_CONFIGURATION por el firebaseConfig de tu aplicación web.

Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.

Swift
import FirebaseCore
import FirebaseFirestore

FirebaseApp.configure()

// When initializing Firestore, remember to use the name of the database you created earlier:
let db = Firestore.firestore(database: "your-new-enterprise-database")

Kotlin

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
val firestore = FirebaseFirestore.getInstance("your-new-enterprise-database")

Java

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
FirebaseFirestore firestore = FirebaseFirestore.getInstance("your-new-enterprise-database");

Agrega datos con las operaciones de Core

Para explorar las operaciones de Core y las operaciones de Pipeline para consultar datos, agrega datos a tu base de datos con las operaciones de Core.

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

Kotlin

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

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

Kotlin

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

Cómo leer datos con operaciones Core

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

Kotlin

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

Lee datos con operaciones de Pipeline

Ahora puedes comparar la experiencia de la consulta de Pipeline con la experiencia de consulta de Core.

Web

const readDataPipeline = db.pipeline()
  .collection("users");

// Execute the pipeline and handle the result
try {
  const querySnapshot = await execute(readDataPipeline);
  querySnapshot.results.forEach((result) => {
    console.log(`${result.id} => ${result.data()}`);
  });
} catch (error) {
    console.error("Error getting documents: ", error);
}
test.firestore.js
Swift
do {
  // Initialize a Firestore Pipeline instance and specify the "users" collection as the
  // input stage.
  let snapshot = try await db.pipeline()
    .collection("users")
    .execute() // Execute the pipeline to retrieve documents.

  // Iterate through the documents in the pipeline results, similar to a regular query
  // snapshot.
  for result in snapshot.results {
    print("\(result.id ?? "no ID") => \(result.data)")
  }
} catch {
  print("Error getting documents with pipeline: \(error)")
}
PipelineSnippets.swift

Kotlin

val readDataPipeline = db.pipeline()
    .collection("users")

// Execute the pipeline and handle the result
readDataPipeline.execute()
    .addOnSuccessListener { result ->
        for (document in result) {
            println("${document.getId()} => ${document.getData()}")
        }
    }
    .addOnFailureListener { exception ->
        println("Error getting documents: $exception")
    }
DocSnippets.kt

Java

Pipeline readDataPipeline = db.pipeline()
.collection("users");

readDataPipeline.execute()
.addOnSuccessListener(new OnSuccessListener<Pipeline.Snapshot>() {
    @Override
    public void onSuccess(Pipeline.Snapshot snapshot) {
        for (PipelineResult result : snapshot.getResults()) {
            System.out.println(result.getId() + " => " + result.getData());
        }
    }
})
.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        System.out.println("Error getting documents: " + e);
    }
});

Protege tus datos para los SDKs para dispositivos móviles y la Web

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 de producción

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

Próximos pasos

Profundiza tus conocimientos sobre las operaciones de Core y Pipeline con los siguientes temas: