Firebase Firestore: qué es, NoSQL y cómo funciona

¿Qué es Firebase Firestore?

Firebase Firestore es una base de datos NoSQL flexible y escalable lanzada por Google en 2019 como evolución de Firebase Realtime Database. Almacena datos en colecciones de documentos, donde cada documento contiene un conjunto de pares clave-valor. A diferencia de las bases de datos relacionales tradicionales, Firestore no requiere un esquema predefinido: la estructura de datos se forma dinámicamente según los documentos que se escriben.

La diferencia clave entre Firestore y las bases de datos en la nube clásicas es la sincronización incorporada en tiempo real. Cuando los datos cambian en el servidor, todos los clientes conectados reciben actualizaciones a través de una conexión WebSocket persistente. Esto elimina la necesidad de sondear manualmente el servidor y permite crear aplicaciones con actualizaciones en vivo: chats, feeds de actividad, editores colaborativos y sistemas de monitoreo.

La base de datos está disponible en todas las plataformas principales: Android, iOS, Web (JavaScript) y lenguajes del lado del servidor a través de Admin SDK. Firestore proporciona SDK para Swift, Kotlin, JavaScript, Python, Go, Java y Node.js. Según Google, Firestore procesa más de 100 mil millones de solicitudes por día en todo el ecosistema de Firebase, lo que confirma su fiabilidad como base para aplicaciones en producción.

Conceptos básicos: colecciones y documentos

En Firestore, los datos se organizan en una estructura jerárquica. Una colección es un contenedor de documentos, similar a una tabla en SQL pero sin esquema fijo. Un documento es un registro que contiene campos de varios tipos: cadenas, números, valores booleanos, arreglos, objetos anidados y geolocalizaciones. Los documentos pueden contener subcolecciones, lo que permite construir estructuras de datos anidadas de cualquier profundidad.

val db = FirebaseFirestore.getInstance()

val user = hashMapOf(
    "name" to "Anna Petrova",
    "email" to "anna@example.com",
    "age" to 28,
    "isActive" to true
)

db.collection("users")
    .add(user)
    .addOnSuccessListener { docRef ->
        Log.d("TAG", "Documento agregado con ID: ${docRef.id}")
    }

Cada documento en una colección tiene un identificador único, que puede generarse automáticamente o establecerse manualmente. Firestore indexa automáticamente todos los campos del documento, lo que permite realizar consultas complejas con filtrado, ordenación y limitación de resultados sin configurar índices manualmente.

Firebase Firestore vs Realtime Database: comparación

Firestore y Firebase Realtime Database son dos bases de datos en la nube en tiempo real de Google. Si bien ambas proporcionan sincronización en tiempo real, tienen diferencias fundamentales en el modelo de datos, escalado y precios. Comprender estas diferencias es fundamental al elegir la base de datos adecuada para un proyecto específico.

La principal diferencia arquitectónica es el modelo de datos. Realtime Database almacena todo en un gran árbol JSON, lo que complica las consultas con anidamiento profundo. Firestore utiliza colecciones y documentos, lo que permite consultas complejas con múltiples condiciones. Además, Firestore proporciona una fuerte consistencia de datos: después de una escritura exitosa, todas las lecturas posteriores garantizan devolver los datos más recientes.

Escalabilidad y estructura de datos

Firestore escala automáticamente a millones de conexiones simultáneas gracias a su arquitectura multirregional. Realtime Database está limitada a una sola región y un máximo de 200,000 conexiones simultáneas. Para proyectos con audiencia global, Firestore es preferible, ya que los datos se replican automáticamente entre múltiples centros de datos de Google.

La estructura de datos en Firestore permite construir modelos jerárquicos complejos con subcolecciones. Por ejemplo, un usuario puede tener una subcolección "pedidos", y cada pedido una subcolección "productos". En Realtime Database, tal anidamiento profundo causa problemas de rendimiento en las consultas, ya que se carga toda la ruta desde la raíz hasta el nodo necesario.

Cómo funciona la sincronización de datos en Firestore

Firestore utiliza una conexión WebSocket persistente entre el cliente y el servidor para la sincronización de datos en tiempo real. Cuando una aplicación se suscribe a cambios en un documento o colección mediante un snapshot listener, el SDK establece un canal de comunicación a través del cual el servidor envía actualizaciones cada vez que los datos cambian. El cliente recibe solo los documentos modificados, no una instantánea completa de toda la colección cada vez.

El mecanismo de sincronización se basa en un flujo de eventos: added (documento apareció), modified (documento cambió) y removed (documento eliminado). El desarrollador puede manejar cada evento por separado, actualizando solo los elementos de UI correspondientes. Esto garantiza un alto rendimiento incluso con miles de documentos, ya que solo se vuelven a renderizar los componentes modificados.

Acceso sin conexión y almacenamiento en caché

Una de las ventajas clave de Firestore es el soporte integrado para el modo sin conexión. El SDK almacena automáticamente en caché todos los datos leídos en el dispositivo y continúa funcionando cuando no hay red. Cuando la aplicación escribe datos en modo sin conexión, se colocan en una cola local y se envían al servidor cuando se restablece la conexión. Se utiliza la estrategia last-write-wins para la resolución de conflictos.

val docRef = db.collection("cities").document("SF")

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Error de escucha", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Datos actuales: ${snapshot.data}")
    }
}

El tamaño de la caché se puede configurar a través de FirestoreSettings. El valor predeterminado es 100 MB, pero se puede aumentar para aplicaciones con lectura intensiva de datos. También está disponible el modo de caché de disco persistente que sobrevive a los reinicios de la aplicación. Para gestionar la disponibilidad del modo sin conexión, se utilizan los métodos enableNetwork y disableNetwork, que permiten desactivar temporalmente la interacción en red.

Seguridad y reglas de acceso de Firestore

Firestore Security Rules es un lenguaje de marcado declarativo para controlar el acceso a los datos a nivel de servidor. Las reglas definen quién puede leer y escribir documentos y bajo qué condiciones. Funcionan antes de la ejecución de la consulta y no requieren lógica de servidor separada para la autorización. Las reglas se verifican en el lado de Firebase antes de cada lectura o escritura de datos.

Las reglas de acceso se construyen según el principio de acceso permitido (allow). De forma predeterminada, todo el acceso está denegado. El desarrollador abre secuencialmente el acceso para operaciones específicas (read, write, create, update, delete) bajo ciertas condiciones. Las condiciones pueden verificar la autenticación del usuario mediante request.auth, los datos de la solicitud mediante request.resource y los datos existentes mediante resource.

// Reglas de acceso de Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // El usuario solo lee y escribe sus propios datos
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Cualquier usuario autenticado puede leer publicaciones
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Validación de datos mediante reglas

Además del control de acceso, Security Rules permiten validar la estructura y los tipos de los datos escritos. Por ejemplo, se puede verificar que el campo email coincida con una expresión regular, o que la edad no supere los 120 años. La validación se realiza antes de la escritura, evitando que se guarden datos incorrectos en el servidor. Para la verificación de campos se utiliza el objeto request.resource.data que contiene el documento completo que se está escribiendo.

Firestore también admite colecciones accesibles solo para escritura del lado del servidor a través de Admin SDK, sin acceso desde los clientes. Esto es útil para almacenar información de servicio, claves de API y configuraciones que no deben ser visibles para los usuarios. Para ello, basta con denegar todas las operaciones de cliente en las colecciones correspondientes en las reglas, permitiendo el acceso solo a través de Admin SDK desde el lado del servidor.

Ejemplo de uso de Firebase Firestore en Android

Veamos un ejemplo de integración de Firestore en una aplicación Android para crear una lista de tareas (todo). La aplicación leerá tareas en tiempo real, agregará nuevas y marcará las completadas. Para el trabajo asíncrono se utilizan interfaces de callback de Firebase y corrutinas de Kotlin.

Configuración de Firebase y adición de dependencias

Antes de comenzar, es necesario conectar el proyecto a Firebase a través de Firebase Console y agregar el archivo google-services.json al módulo de la aplicación. Luego, en build.gradle se agrega la dependencia firebase-firestore-ktx y el plugin google-services. La versión de la biblioteca debe corresponder a la versión actual de BoM de Firebase para la compatibilidad de todos los componentes de Firebase entre sí.

dependencies {
    // Firebase BoM — gestión de versiones
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-firestore-ktx"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
}

Después de la configuración, se crea un modelo de datos Task y un repositorio para trabajar con Firestore. El modelo contiene los campos id, title, isCompleted y timestamp. Firestore serializa automáticamente la data class en un documento, usando los nombres de los campos como claves. Para leer datos se utiliza un snapshot listener que devuelve un Flow a través de la extensión snapshotFlow.

data class Task(
    val id: String = "",
    val title: String = "",
    val isCompleted: Boolean = false,
    val createdAt: Timestamp? = null
)

class TaskRepository {
    private val tasksRef = FirebaseFirestore
        .getInstance()
        .collection("tasks")

    fun getTasks(): Flow<List<Task>> = tasksRef
        .orderBy("createdAt", Query.Direction.DESCENDING)
        .snapshotFlow()
        .map { snapshot ->
            snapshot?.toObjects(Task::class.java) ?: emptyList()
        }

    suspend fun addTask(title: String) {
        tasksRef.add(Task(title = title))
    }
}

La ViewModel se suscribe al Flow del repositorio y pasa la lista de tareas al nivel de UI. Al agregar una nueva tarea, se llama a la función suspend del repositorio a través de un ámbito de corrutina. Firestore sincroniza automáticamente los cambios entre todos los clientes: si un usuario agrega una tarea, los demás la ven en tiempo real sin recargar la pantalla.