Crea una base de datos de Firestore con una biblioteca cliente web o para dispositivos móviles

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

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 versión 9

  1. Sigue las instrucciones para agregar Firebase a tu app web.
  2. Importa Firebase y Firestore:
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";

Web versión 8

  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.10.1/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/8.10.1/firebase-firestore.js"></script>
    El SDK de Firestore también está disponible como un paquete npm.
    npm install firebase@8.10.1 --save
    Deberás solicitar de forma manual Firebase y Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
Plataformas de Apple

Sigue las instrucciones para agregar Firebase a tu app para Apple.

Usa Swift Package Manager para instalar y administrar las dependencias de Firebase.

  1. Abre el proyecto de tu app y, en Xcode, navega a File > Swift Packages > Add Package Dependency.
  2. Cuando se te solicite, agrega el repositorio del SDK de Firebase para plataformas de Apple:
  3.   https://github.com/firebase/firebase-ios-sdk
      
  4. Elige la biblioteca de Firestore.
  5. Cuando termines, Xcode comenzará a resolver y descargar automáticamente tus dependencias en segundo plano.
Android
  1. Sigue las instrucciones para agregar Firebase a tu app para Android.
  2. Declara la dependencia de la biblioteca de Firestore para Android en el archivo Gradle de tu módulo (nivel de app) (generalmente app/build.gradle.kts o app/build.gradle):
    implementation("com.google.firebase:firebase-firestore:25.1.0")

    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.

    ¿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 y, luego, 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
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 > En proceso de publicación Configuración > Reducir
    • Las opciones pueden variar en distintas versiones de Unity, así que consulta el la documentación oficial de Unity Guía de depuración de Firebase Unity Build.
    • Si, después de habilitar la reducción, la cantidad de métodos a los que se hace referencia sigue 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.

Inicializar Firestore

Inicializa una instancia de Firestore:

Web versión 9

// Initialize Firestore through Firebase
import { initializeApp } from "firebase/app"
import { getFirestore } from "firebase/firestore"
const firebaseApp = initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

const db = getFirestore();
Los valores de “inicializaApp” se pueden encontrar en el `firebaseConfig` de tu app web. Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.

Web versión 8

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

var db = firebase.firestore();
Los valores de “inicializaApp” se pueden encontrar en el `firebaseConfig` de tu app web. Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
Swift
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
import FirebaseCore
import FirebaseFirestore

FirebaseApp.configure()

let db = Firestore.firestore()
Objective‑C
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
@import FirebaseCore;
@import FirebaseFirestore;

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

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

Dart

db = FirebaseFirestore.instance;
C++
// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();
Unity
using Firebase.Firestore;
using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;

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 versión 9

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

Web versión 8

db.collection("users").add({
    first: "Ada",
    last: "Lovelace",
    born: 1815
})
.then((docRef) => {
    console.log("Document written with ID: ", docRef.id);
})
.catch((error) => {
    console.error("Error adding document: ", error);
});
Swift
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
// Add a new document with a generated ID
do {
  let ref = try await db.collection("users").addDocument(data: [
    "first": "Ada",
    "last": "Lovelace",
    "born": 1815
  ])
  print("Document added with ID: \(ref.documentID)")
} catch {
  print("Error adding document: \(error)")
}
Objective‑C
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
// Add a new document with a generated ID
__block FIRDocumentReference *ref =
    [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
      @"first": @"Ada",
      @"last": @"Lovelace",
      @"born": @1815
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error adding document: %@", error);
      } else {
        NSLog(@"Document added with ID: %@", ref.documentID);
      }
    }];
Kotlin+KTX
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)
    }
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);
            }
        });

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

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 versión 9

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

Web versión 8

// Add a second document with a generated ID.
db.collection("users").add({
    first: "Alan",
    middle: "Mathison",
    last: "Turing",
    born: 1912
})
.then((docRef) => {
    console.log("Document written with ID: ", docRef.id);
})
.catch((error) => {
    console.error("Error adding document: ", error);
});
Swift
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
// Add a second document with a generated ID.
do {
  let ref = try await db.collection("users").addDocument(data: [
    "first": "Alan",
    "middle": "Mathison",
    "last": "Turing",
    "born": 1912
  ])
  print("Document added with ID: \(ref.documentID)")
} catch {
  print("Error adding document: \(error)")
}
Objective‑C
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
// Add a second document with a generated ID.
__block FIRDocumentReference *ref =
    [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
      @"first": @"Alan",
      @"middle": @"Mathison",
      @"last": @"Turing",
      @"born": @1912
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error adding document: %@", error);
      } else {
        NSLog(@"Document added with ID: %@", ref.documentID);
      }
    }];
Kotlin+KTX
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)
    }
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);
            }
        });

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

Lee datos

Usa el visor de datos de Firebase console para verificar rápidamente que agregaste datos a Firestore.

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

Web versión 9

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

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

Web versión 8

db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});
Swift
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
do {
  let snapshot = try await db.collection("users").getDocuments()
  for document in snapshot.documents {
    print("\(document.documentID) => \(document.data())")
  }
} catch {
  print("Error getting documents: \(error)")
}
Objective‑C
Nota: Este producto no se encuentra disponible en los destinos de watchOS ni de App Clips.
[[self.db collectionWithPath:@"users"]
    getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                 NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error getting documents: %@", error);
      } else {
        for (FIRDocumentSnapshot *document in snapshot.documents) {
          NSLog(@"%@ => %@", document.documentID, document.data);
        }
      }
    }];
Kotlin+KTX
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)
    }
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());
                }
            }
        });

Dart

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

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

Antes de implementar tu app web, para Android o iOS en la producción, también toma las medidas necesarias a fin de asegurarte de que solo tus clientes de apps puedan acceder a los datos de Firestore. Consulta la documentación de Verificación de aplicaciones.

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