Primeros pasos con Cloud Firestore

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

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.

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

  2. Haz clic en Crear base de datos.

  3. Selecciona Enterprise para el modo de base de datos.

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

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

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

  7. 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. El SDK de Cloud Firestore para la versión preliminar privada está disponible como un paquete npm.

    Usa el siguiente comando para instalar el SDK de Firestore en tu proyecto de npm.

    npm install --save firebase@eap-firestore-pipelines
iOS+
  1. Sigue las instrucciones para agregar Firebase a tu app para iOS.
  2. Clona el SDK de Firebase desde GitHub y consulta la rama de canalizaciones. Toma nota de la ubicación en la que lo clonaste, ya que la necesitarás en el siguiente paso: 
    git clone https://github.com/firebase/firebase-ios-sdk.git
# or git clone git@github.com:firebase/firebase-ios-sdk.git
cd firebase-ios-sdk

# check out pipeline feature branch
git fetch origin feat/pipeline/private-preview
git checkout feat/pipeline/private-preview
  3. Luego, agrega el directorio (firebase-iOS-sdk) como una dependencia local a tu proyecto de Xcode:
    1. En el menú Archivo, elige Agregar dependencias del paquete.
    2. Haz clic en el botón Agregar local… y, luego, busca el directorio firebase-ios-sdk con la rama de funciones que extrajiste.
Android
  1. Sigue las instrucciones para agregar Firebase a tu app para Android.
  2. Clona el SDK de Firebase desde GitHub, consulta la rama de canalizaciones y publícala en Maven local: 
    # Prerequisites before you start:
# Install Java 17
# Setup Android Development environments (having proper ANDROID_HOME, etc)

git clone https://github.com/firebase/firebase-android-sdk.git
# or git clone git@github.com:firebase/firebase-android-sdk.git
cd firebase-android-sdk

# check out pipeline feature branch
git fetch origin feat/pipeline/private-preview
git checkout feat/pipeline/private-preview

# publish firebase SDK (without crashlytics) to maven local
./gradlew publishToMavenLocal -x :firebase-crashlytics:publishToMavenLocal -x :firebase-crashlytics-ndk:publishToMavenLocal

# Optionally, if you want crashlytics built and published to mavel local
# Make sure you have Android NDK 21 installed
git submodule update --init --recursive
./gradlew publishToMavenLocal
  3. Agrega mavenLocal a settings.gradle.kts a nivel del proyecto: 
    dependencyResolutionManagement {
  repositories {
    mavenLocal() // Add this line
    ..
  }
}
  4. Luego, agrega la versión local del SDK: 
    ...
// Firestore 99.0.0-pipeline.preview.1 has pipelines
implementation("com.google.firebase:firebase-firestore:99.0.0-pipeline.preview.1")

// Firebase Authentication
implementation("com.google.firebase:firebase-auth")
...
Python
  1. Clona el SDK de Python de Firestore y verifica la rama de vista previa de la canalización: 
    git clone https://github.com/googleapis/python-firestore.git
# or git clone git@github.com:googleapis/python-firestore.git
cd python-firestore

# check out pipeline preview branch
git fetch origin pipeline-preview
git checkout pipeline-preview
  2. Instala el SDK del servidor local de python-firestore: 
    python -m pip install -e .
  3. Instala el SDK de Firebase Admin para Python de la manera habitual: 
    pip install --user firebase-admin

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

Autentícate con tu base de datos empresarial usando el SDK de Admin:

import firebase_admin
from firebase_admin import firestore

def main():
  default_app = firebase_admin.initialize_app()
  client = firestore.client(default_app, "your-new-enterprise-database")
  query = client.pipeline().database().limit(5)
  for result in query.execute():
    print(result.data())

if __name__ == "__main__":
    main()

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

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

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
Python
users_ref = db.collection("users")
docs = users_ref.stream()

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

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);
    }
});
Python
pipeline = client.pipeline().collection("users")
for result in pipeline.execute():
    print(f"{result.id} => {result.data()}")
firestore_pipelines.py

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