Firebase Firestore: Was es ist, NoSQL und wie es funktioniert

Was ist Firebase Firestore?

Firebase Firestore ist eine flexible, skalierbare NoSQL-Datenbank, die Google 2019 als Weiterentwicklung der Firebase Realtime Database eingeführt hat. Sie speichert Daten in Collections von Dokumenten, wobei jedes Dokument eine Reihe von Schlüssel-Wert-Paaren enthält. Im Gegensatz zu traditionellen relationalen Datenbanken benötigt Firestore kein vordefiniertes Schema — die Datenstruktur wird dynamisch auf Basis der geschriebenen Dokumente gebildet.

Der Hauptunterschied zwischen Firestore und klassischen Cloud-Datenbanken ist die integrierte Echtzeitsynchronisation. Wenn sich Daten auf dem Server ändern, erhalten alle verbundenen Clients Updates über eine persistente WebSocket-Verbindung. Dies macht manuelles Server-Polling überflüssig und ermöglicht die Erstellung von Anwendungen mit Live-Updates: Chats, Aktivitätsfeeds, kollaborative Editoren und Überwachungssysteme.

Die Datenbank ist auf allen wichtigen Plattformen verfügbar: Android, iOS, Web (JavaScript) und serverseitige Sprachen über Admin SDK. Firestore bietet SDK für Swift, Kotlin, JavaScript, Python, Go, Java und Node.js. Laut Google verarbeitet Firestore täglich über 100 Milliarden Anfragen im gesamten Firebase-Ökosystem, was seine Zuverlässigkeit als Grundlage für Produktionsanwendungen bestätigt.

Grundkonzepte: Collections und Dokumente

In Firestore werden Daten in einer hierarchischen Struktur organisiert. Eine Collection ist ein Container für Dokumente, ähnlich einer Tabelle in SQL, aber ohne festes Schema. Ein Dokument ist ein Datensatz mit Feldern verschiedener Typen: Zeichenketten, Zahlen, boolesche Werte, Arrays, verschachtelte Objekte und Geopunkte. Dokumente können Untercollections enthalten, was den Aufbau verschachtelter Datenstrukturen beliebiger Tiefe ermöglicht.

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", "Dokument mit ID hinzugefügt: ${docRef.id}")
    }

Jedes Dokument in einer Collection hat eine eindeutige ID, die automatisch generiert oder manuell festgelegt werden kann. Firestore indiziert automatisch alle Dokumentfelder, was komplexe Abfragen mit Filterung, Sortierung und Ergebnisbegrenzung ohne manuelle Indexkonfiguration ermöglicht.

Firebase Firestore vs Realtime Database: Vergleich

Firestore und Firebase Realtime Database sind zwei Cloud-Echtzeitdatenbanken von Google. Obwohl beide Echtzeitsynchronisation bieten, gibt es grundlegende Unterschiede im Datenmodell, der Skalierung und der Preisgestaltung. Das Verständnis dieser Unterschiede ist bei der Wahl der richtigen Datenbank für ein bestimmtes Projekt von entscheidender Bedeutung.

Der Hauptarchitekturunterschied ist das Datenmodell. Die Realtime Database speichert alles in einem großen JSON-Baum, was Abfragen mit tiefer Verschachtelung erschwert. Firestore verwendet Collections und Dokumente, was komplexe Abfragen mit mehreren Bedingungen ermöglicht. Darüber hinaus bietet Firestore starke Datenkonsistenz: Nach einem erfolgreichen Schreiben garantieren alle nachfolgenden Lesevorgänge die Rückgabe der aktuellsten Daten.

Skalierbarkeit und Datenstruktur

Firestore skaliert dank seiner Multi-Region-Architektur automatisch auf Millionen gleichzeitiger Verbindungen. Die Realtime Database ist auf eine einzelne Region und maximal 200.000 gleichzeitige Verbindungen beschränkt. Für Projekte mit globaler Zielgruppe ist Firestore vorzuziehen, da Daten automatisch über mehrere Google-Rechenzentren repliziert werden.

Die Datenstruktur in Firestore ermöglicht den Aufbau komplexer hierarchischer Modelle mit Untercollections. Beispielsweise kann ein Benutzer eine Untercollection „Bestellungen" haben und jede Bestellung eine Untercollection „Artikel". In der Realtime Database führt eine solche tiefe Verschachtelung zu Leistungsproblemen bei Abfragen, da der gesamte Pfad von der Wurzel bis zum benötigten Knoten geladen wird.

Wie die Datensynchronisation in Firestore funktioniert

Firestore verwendet eine persistente WebSocket-Verbindung zwischen Client und Server zur Echtzeit-Datensynchronisation. Wenn eine Anwendung Änderungen an einem Dokument oder einer Collection über einen Snapshot-Listener abonniert, richtet das SDK einen Kommunikationskanal ein, über den der Server bei jeder Datenänderung Updates sendet. Der Client erhält nur geänderte Dokumente, nicht jedes Mal eine vollständige Momentaufnahme der gesamten Collection.

Der Synchronisationsmechanismus basiert auf einem Ereignisstrom: added (Dokument erschienen), modified (Dokument geändert) und removed (Dokument gelöscht). Der Entwickler kann jedes Ereignis separat behandeln und nur die entsprechenden UI-Elemente aktualisieren. Dies gewährleistet hohe Leistung selbst bei tausenden von Dokumenten, da nur geänderte Komponenten neu gerendert werden.

Offline-Zugriff und Caching

Einer der Hauptvorteile von Firestore ist die integrierte Unterstützung des Offline-Modus. Das SDK speichert automatisch alle gelesenen Daten auf dem Gerät zwischen und arbeitet auch ohne Netzwerk weiter. Wenn die Anwendung Daten im Offline-Modus schreibt, werden sie in eine lokale Warteschlange gestellt und bei Wiederherstellung der Verbindung an den Server gesendet. Zur Konfliktlösung wird die Last-Write-Wins-Strategie verwendet.

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

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Fehler beim Lauschen", error)
        return@addSnapshotListener
    }

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

Die Cache-Größe kann über FirestoreSettings konfiguriert werden. Der Standardwert beträgt 100 MB, kann aber für Anwendungen mit intensivem Datenlesen erhöht werden. Ein persistenter Datenträger-Cache-Modus ist ebenfalls verfügbar, der Anwendungsneustarts übersteht. Zur Verwaltung der Verfügbarkeit des Offline-Modus werden die Methoden enableNetwork und disableNetwork verwendet, die eine vorübergehende Deaktivierung der Netzwerkinteraktion ermöglichen.

Firestore-Sicherheit und Zugriffsregeln

Firestore Security Rules ist eine deklarative Auszeichnungssprache zur Steuerung des Datenzugriffs auf Serverebene. Die Regeln legen fest, wer unter welchen Bedingungen Dokumente lesen und schreiben darf. Sie arbeiten vor der Abfrageausführung und benötigen keine separate Serverlogik für die Autorisierung. Die Regeln werden vor jedem Lese- oder Schreibzugriff auf der Firebase-Seite überprüft.

Die Zugriffsregeln basieren auf dem Erlaubnisprinzip (allow). Standardmäßig ist der gesamte Zugriff verweigert. Der Entwickler öffnet sequenziell den Zugriff für bestimmte Operationen (read, write, create, update, delete) unter bestimmten Bedingungen. Bedingungen können die Benutzerauthentifizierung über request.auth, Anfragedaten über request.resource und vorhandene Daten über resource prüfen.

// Firestore-Zugriffsregeln
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Benutzer liest und schreibt nur eigene Daten
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Jeder authentifizierte Benutzer kann Beiträge lesen
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Datenvalidierung durch Regeln

Neben der Zugriffskontrolle ermöglichen die Security Rules die Validierung der Struktur und Typen der geschriebenen Daten. Beispielsweise kann überprüft werden, ob das E-Mail-Feld einem regulären Ausdruck entspricht oder ob das Alter 120 Jahre nicht überschreitet. Die Validierung erfolgt vor dem Schreiben und verhindert das Speichern fehlerhafter Daten auf dem Server. Zur Feldvalidierung wird das Objekt request.resource.data verwendet, das das gesamte zu schreibende Dokument enthält.

Firestore unterstützt auch Collections, die nur über Admin SDK auf der Serverseite beschreibbar sind, ohne Client-Zugriff. Dies ist praktisch für die Speicherung von Dienstinformationen, API-Schlüsseln und Konfigurationen, die für Benutzer nicht sichtbar sein sollen. Dazu reicht es, in den Regeln alle Client-Operationen auf den entsprechenden Collections zu verbieten und den Zugriff nur über Admin SDK von der Serverseite aus zu erlauben.

Beispiel der Verwendung von Firebase Firestore in Android

Betrachten wir ein Beispiel der Integration von Firestore in eine Android-Anwendung zur Erstellung einer Aufgabenliste (Todo). Die Anwendung liest Aufgaben in Echtzeit, fügt neue hinzu und markiert erledigte. Für asynchrone Arbeit werden Firebase-Callback-Schnittstellen und Kotlin-Koroutinen verwendet.

Firebase-Einrichtung und Hinzufügen von Abhängigkeiten

Vor Beginn muss das Projekt über die Firebase Console mit Firebase verbunden und die Datei google-services.json zum Anwendungsmodul hinzugefügt werden. Anschließend wird in build.gradle die Abhängigkeit firebase-firestore-ktx und das google-services-Plugin hinzugefügt. Die Bibliotheksversion muss der aktuellen Firebase-BoM-Version entsprechen, um die Kompatibilität aller Firebase-Komponenten untereinander zu gewährleisten.

dependencies {
    // Firebase BoM — Versionsverwaltung
    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"
}

Nach der Einrichtung werden ein Task-Datenmodell und ein Repository für die Arbeit mit Firestore erstellt. Das Modell enthält die Felder id, title, isCompleted und timestamp. Firestore serialisiert die Data Class automatisch in ein Dokument, wobei die Feldnamen als Schlüssel verwendet werden. Zum Lesen von Daten wird ein Snapshot-Listener verwendet, der über die Erweiterung snapshotFlow einen Flow zurückgibt.

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

Das ViewModel abonniert den Flow aus dem Repository und übergibt die Aufgabenliste an die UI-Ebene. Beim Hinzufügen einer neuen Aufgabe wird die Suspend-Funktion des Repositorys über einen Koroutinen-Scope aufgerufen. Firestore synchronisiert Änderungen automatisch zwischen allen Clients: Wenn ein Benutzer eine Aufgabe hinzufügt, sehen andere sie in Echtzeit ohne Bildschirmaktualisierung.