Firebase Firestore: o que é, NoSQL e como funciona

O que é Firebase Firestore?

Firebase Firestore é um banco de dados NoSQL flexível e escalável lançado pelo Google em 2019 como uma evolução do Firebase Realtime Database. Ele armazena dados em coleções de documentos, onde cada documento contém um conjunto de pares chave-valor. Ao contrário dos bancos de dados relacionais tradicionais, o Firestore não requer um esquema predefinido — a estrutura de dados é formada dinamicamente com base nos documentos que estão sendo escritos.

A principal diferença entre o Firestore e os bancos de dados em nuvem clássicos é a sincronização integrada em tempo real. Quando os dados mudam no servidor, todos os clientes conectados recebem atualizações através de uma conexão WebSocket persistente. Isso elimina a necessidade de sondagem manual do servidor e permite construir aplicações com atualizações ao vivo: chats, feeds de atividade, editores colaborativos e sistemas de monitoramento.

O banco de dados está disponível em todas as principais plataformas: Android, iOS, Web (JavaScript) e linguagens do lado do servidor através do Admin SDK. O Firestore fornece SDK para Swift, Kotlin, JavaScript, Python, Go, Java e Node.js. Segundo o Google, o Firestore processa mais de 100 bilhões de solicitações por dia em todo o ecossistema Firebase, confirmando sua confiabilidade como base para aplicações de produção.

Conceitos básicos: coleções e documentos

No Firestore, os dados são organizados em uma estrutura hierárquica. Uma coleção é um contêiner de documentos, semelhante a uma tabela em SQL, mas sem esquema fixo. Um documento é um registro contendo campos de vários tipos: strings, números, valores booleanos, arrays, objetos aninhados e geolocalizações. Os documentos podem conter subcoleções, permitindo construir estruturas de dados aninhadas de qualquer profundidade.

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 adicionado com ID: ${docRef.id}")
    }

Cada documento em uma coleção tem um identificador único, que pode ser gerado automaticamente ou definido manualmente. O Firestore indexa automaticamente todos os campos do documento, permitindo consultas complexas com filtragem, ordenação e limitação de resultados sem configuração manual de índices.

Firebase Firestore vs Realtime Database: comparação

Firestore e Firebase Realtime Database são dois bancos de dados em nuvem em tempo real do Google. Embora ambos forneçam sincronização em tempo real, eles têm diferenças fundamentais no modelo de dados, escalonamento e preços. Entender essas diferenças é crucial ao escolher o banco de dados certo para um projeto específico.

A principal diferença arquitetônica é o modelo de dados. O Realtime Database armazena tudo em uma grande árvore JSON, o que complica consultas com aninhamento profundo. O Firestore usa coleções e documentos, permitindo consultas complexas com múltiplas condições. Além disso, o Firestore fornece consistência forte de dados: após uma gravação bem-sucedida, todas as leituras subsequentes garantem retornar os dados mais recentes.

Escalabilidade e estrutura de dados

O Firestore escala automaticamente para milhões de conexões simultâneas graças à sua arquitetura multirregional. O Realtime Database é limitado a uma única região e um máximo de 200.000 conexões simultâneas. Para projetos com audiência global, o Firestore é preferível, pois os dados são automaticamente replicados entre vários data centers do Google.

A estrutura de dados no Firestore permite construir modelos hierárquicos complexos com subcoleções. Por exemplo, um usuário pode ter uma subcoleção "pedidos", e cada pedido uma subcoleção "itens". No Realtime Database, esse aninhamento profundo causa problemas de desempenho durante as consultas, pois todo o caminho da raiz até o nó necessário é carregado.

Como funciona a sincronização de dados no Firestore

O Firestore usa uma conexão WebSocket persistente entre o cliente e o servidor para sincronização de dados em tempo real. Quando uma aplicação se inscreve para alterações em um documento ou coleção através de um snapshot listener, o SDK estabelece um canal de comunicação através do qual o servidor envia atualizações sempre que os dados mudam. O cliente recebe apenas os documentos alterados, não um snapshot completo de toda a coleção a cada vez.

O mecanismo de sincronização é baseado em um fluxo de eventos: added (documento apareceu), modified (documento mudou) e removed (documento removido). O desenvolvedor pode lidar com cada evento separadamente, atualizando apenas os elementos de UI correspondentes. Isso garante alto desempenho mesmo com milhares de documentos, pois apenas os componentes alterados são renderizados novamente.

Acesso offline e cache

Uma das principais vantagens do Firestore é o suporte integrado ao modo offline. O SDK armazena automaticamente em cache todos os dados lidos no dispositivo e continua funcionando quando não há rede. Quando a aplicação grava dados no modo offline, eles são colocados em uma fila local e enviados ao servidor quando a conexão é restaurada. A estratégia last-write-wins é usada para resolução de conflitos.

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

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

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

O tamanho do cache pode ser configurado através do FirestoreSettings. O valor padrão é 100 MB, mas pode ser aumentado para aplicações com leitura intensiva de dados. Um modo de cache de disco persistente também está disponível, que sobrevive a reinicializações da aplicação. Para gerenciar a disponibilidade do modo offline, são usados os métodos enableNetwork e disableNetwork, que permitem desativar temporariamente a interação de rede.

Segurança e regras de acesso do Firestore

O Firestore Security Rules é uma linguagem de marcação declarativa para controlar o acesso aos dados no nível do servidor. As regras definem quem pode ler e escrever documentos e sob quais condições. Elas funcionam antes da execução da consulta e não requerem lógica de servidor separada para autorização. As regras são verificadas no lado do Firebase antes de cada leitura ou gravação de dados.

As regras de acesso são construídas com base no princípio de permissão (allow). Por padrão, todo o acesso é negado. O desenvolvedor abre sequencialmente o acesso para operações específicas (read, write, create, update, delete) sob determinadas condições. As condições podem verificar a autenticação do usuário através do request.auth, os dados da solicitação através do request.resource e os dados existentes através do resource.

// Regras de acesso do Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Usuário lê e escreve apenas seus próprios dados
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Qualquer usuário autenticado pode ler posts
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Validação de dados através de regras

Além do controle de acesso, as Security Rules permitem validar a estrutura e os tipos dos dados gravados. Por exemplo, pode-se verificar se o campo email corresponde a uma expressão regular, ou se a idade não excede 120 anos. A validação é realizada antes da gravação, evitando que dados incorretos sejam salvos no servidor. Para validação de campos, é usado o objeto request.resource.data que contém o documento completo que está sendo gravado.

O Firestore também suporta coleções acessíveis apenas para gravação do lado do servidor através do Admin SDK, sem acesso dos clientes. Isso é conveniente para armazenar informações de serviço, chaves de API e configurações que não devem ser visíveis aos usuários. Para isso, basta negar todas as operações do cliente nas coleções correspondentes nas regras, permitindo acesso apenas através do Admin SDK do lado do servidor.

Exemplo de uso do Firebase Firestore no Android

Vamos ver um exemplo de integração do Firestore em uma aplicação Android para criar uma lista de tarefas (todo). A aplicação lerá tarefas em tempo real, adicionará novas e marcará as concluídas. Para trabalho assíncrono, são usadas interfaces de callback do Firebase e corrotinas Kotlin.

Configuração do Firebase e adição de dependências

Antes de começar, é necessário conectar o projeto ao Firebase através do Firebase Console e adicionar o arquivo google-services.json ao módulo da aplicação. Em seguida, no build.gradle, adiciona-se a dependência firebase-firestore-ktx e o plugin google-services. A versão da biblioteca deve corresponder à versão atual do BoM Firebase para compatibilidade de todos os componentes Firebase entre si.

dependencies {
    // Firebase BoM — gerenciamento de versões
    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"
}

Após a configuração, é criado um modelo de dados Task e um repositório para trabalhar com o Firestore. O modelo contém os campos id, title, isCompleted e timestamp. O Firestore serializa automaticamente a data class em um documento, usando os nomes dos campos como chaves. Para ler dados, é usado um snapshot listener que retorna um Flow através da extensão 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))
    }
}

O ViewModel se inscreve no Flow do repositório e passa a lista de tarefas para o nível de UI. Ao adicionar uma nova tarefa, a função suspend do repositório é chamada através de um escopo de corrotina. O Firestore sincroniza automaticamente as alterações entre todos os clientes: se um usuário adiciona uma tarefa, os outros a veem em tempo real sem recarregar a tela.