Guía de inicio rápido a fin de usar una biblioteca cliente para dispositivos móviles o la Web

En esta guía de inicio rápido, se muestra cómo configurar Firestore, agregar datos y leerlos mediante la biblioteca cliente de Android, iOS o la Web.

Crea una base de datos de 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 a fin de crear un proyecto de Firebase o agregar servicios de Firebase a un proyecto de GCP existente.

  2. En el panel de navegación de Firebase console, selecciona Firestore y, luego, haz clic en Crear base de datos para Firestore.

  3. Selecciona Modo de prueba para las reglas de seguridad de 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.
  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 Firestore, también habilitas la API en el Administrador de API 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 Firestore a la app:
    <script src="https://www.gstatic.com/firebasejs/8.6.5/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/8.6.5/firebase-firestore.js"></script>
    El SDK de Firestore también está disponible como un paquete npm.
    npm install firebase@8.6.5 --save
    
    Deberás solicitar de forma manual Firebase y Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    
iOS
  1. Sigue las instrucciones para agregar Firebase a tu app para iOS.
  2. Agrega el pod de Firestore al Podfile.
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Guarda el archivo y ejecuta pod install.
Java
Android
  1. Sigue las instrucciones para agregar Firebase a tu app para Android.
  2. Declara la dependencia de la biblioteca de Android de Firestore en el archivo Gradle (generalmente app/build.gradle) de tu módulo (nivel de app):
    implementation 'com.google.firebase:firebase-firestore:23.0.1'

    Si tu app usa varias bibliotecas de Firebase, considera usar el BoM de Firebase para Android, que garantiza que las versiones de la biblioteca de Firebase de tu app sean siempre compatibles.

Kotlin+KTX
Android
  1. Sigue las instrucciones para agregar Firebase a tu app para Android.
  2. Declara la dependencia de la biblioteca de Android de Firestore en el archivo Gradle (generalmente app/build.gradle) de tu módulo (nivel de app):
    implementation 'com.google.firebase:firebase-firestore-ktx:23.0.1'

    Si tu app usa varias bibliotecas de Firebase, considera usar el BoM de Firebase para Android, que garantiza que las versiones de la biblioteca de Firebase de tu app sean siempre compatibles.

Inicializa Firestore

Inicializa una instancia de Firestore:

Web
// Initialize Firestore through Firebase
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

var db = firebase.firestore();
Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
Swift
import Firebase

FirebaseApp.configure()

let db = Firestore.firestore()
Objective-C
@import Firebase;

// Use Firebase library to configure APIs
[FIRApp configure];

FIRFirestore *defaultFirestore = [FIRFirestore firestore];
  
Java
Android
// Access a Firestore instance from your Activity
  FirebaseFirestore db = FirebaseFirestore.getInstance();
Kotlin+KTX
Android
  // Access a Firestore instance from your Activity
  val db = Firebase.firestore

Agrega datos

Firestore almacena datos en documentos, que se almacenan en colecciones. 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 v8

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

Web v9

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);
}
Swift
// Add a new document with a generated ID
var ref: DocumentReference? = nil
ref = db.collection("users").addDocument(data: [
    "first": "Ada",
    "last": "Lovelace",
    "born": 1815
]) { err in
    if let err = err {
        print("Error adding document: \(err)")
    } else {
        print("Document added with ID: \(ref!.documentID)")
    }
}
Objective-C
// 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);
      }
    }];
Java
Android
// 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);
            }
        });
Kotlin+KTX
Android
// 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)
    }

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 contener diferentes conjuntos de información.

Web v8

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

Web v9

// 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);
}
Swift
// Add a second document with a generated ID.
ref = db.collection("users").addDocument(data: [
    "first": "Alan",
    "middle": "Mathison",
    "last": "Turing",
    "born": 1912
]) { err in
    if let err = err {
        print("Error adding document: \(err)")
    } else {
        print("Document added with ID: \(ref!.documentID)")
    }
}
Objective-C
// 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);
      }
    }];
Java
Android
// 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);
            }
        });
Kotlin+KTX
Android
// 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)
    }

Leer datos

Para verificar de manera rápida que agregaste datos a Firestore, usa el visualizador de datos en Firebase console.

También puedes usar el método get para recuperar toda la colección.

Web v8

db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});

Web v9

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

const querySnapshot = await getDocs(collection(db, "users"));
querySnapshot.forEach((doc) => {
  console.log(`${doc.id} => ${doc.data()}`);
});
Swift
db.collection("users").getDocuments() { (querySnapshot, err) in
    if let err = err {
        print("Error getting documents: \(err)")
    } else {
        for document in querySnapshot!.documents {
            print("\(document.documentID) => \(document.data())")
        }
    }
}
Objective-C
[[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);
        }
      }
    }];
Java
Android
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());
                }
            }
        });
Kotlin+KTX
Android
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)
        }

Proteger los datos

Usa Firebase Authentication y las reglas de seguridad de Firestore para proteger los datos en 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 Firebase console.

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

Mira un video instructivo

A fin de obtener una orientación detallada sobre cómo comenzar con las bibliotecas cliente para dispositivos móviles y web de Firestore, mira uno de los siguientes videos instructivos:

Web v8

iOS
Android

Puedes encontrar más videos en el canal de YouTube de Firebase.

Pasos siguientes

Profundiza tus conocimientos con los siguientes temas:

  • Codelabs: Obtén información sobre cómo usar 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 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 Firestore.
  • Obtén datos: Obtén más información sobre cómo recuperar datos.
  • Haz consultas simples y compuestas: Obtén información sobre cómo ejecutar consultas simples y compuestas.
  • Ordena y limita consultas: Obtén información sobre cómo ordenar y limitar los datos que muestran las consultas.