Firebase Firestore: co to je, NoSQL a jak funguje

Co je Firebase Firestore?

Firebase Firestore je flexibilní, škálovatelná NoSQL databáze, kterou Google spustil v roce 2019 jako evoluci Firebase Realtime Database. Ukládá data ve formě kolekcí dokumentů, kde každý dokument obsahuje sadu párů klíč-hodnota. Na rozdíl od tradičních relačních databází Firestore nevyžaduje předem definované schéma — struktura dat se vytváří dynamicky na základě zapisovaných dokumentů.

Klíčový rozdíl Firestore od klasických cloudových databází je vestavěná synchronizace v reálném čase. Když se data na serveru změní, všichni připojení klienti obdrží aktualizace prostřednictvím trvalého WebSocket připojení. To eliminuje nutnost ručního dotazování serveru a umožňuje vytvářet aplikace s živými aktualizacemi: chaty, kanály aktivit, společné editory a monitorovací systémy.

Databáze je dostupná na všech hlavních platformách: Android, iOS, Web (JavaScript) a serverových jazycích přes Admin SDK. Firestore poskytuje SDK pro Swift, Kotlin, JavaScript, Python, Go, Java a Node.js. Podle údajů Google Firestore zpracovává více než 100 miliard dotazů denně v celém ekosystému Firebase, což potvrzuje jeho spolehlivost jako základu pro produkční aplikace.

Základní pojmy: kolekce a dokumenty

V Firestore jsou data organizována v hierarchické struktuře. Kolekce je kontejner dokumentů, podobný tabulce v SQL, ale bez pevného schématu. Dokument je záznam obsahující pole různých typů: řetězce, čísla, booleovské hodnoty, pole, vnořené objekty a geobody. Dokumenty mohou obsahovat podkolekce, což umožňuje vytvářet vnořené datové struktury libovolné hloubky.

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 přidán s ID: ${docRef.id}")
    }

Každý dokument v kolekci má jedinečný identifikátor, který může být vygenerován automaticky nebo nastaven ručně. Firestore automaticky indexuje všechna pole dokumentu, což umožňuje provádět složité dotazy s filtrováním, řazením a omezením počtu výsledků bez předchozí konfigurace indexů.

Firebase Firestore vs Realtime Database: srovnání

Firestore a Firebase Realtime Database jsou dvě cloudové databáze v reálném čase od Google. Ačkoli obě poskytují synchronizaci v reálném čase, mají zásadní rozdíly v datovém modelu, škálování a cenách. Pochopení těchto rozdílů je klíčové při výběru vhodné databáze pro konkrétní projekt.

Hlavní architektonický rozdíl je datový model. Realtime Database ukládá vše v jednom velkém JSON stromu, což komplikuje dotazy s hlubokým vnořením. Firestore používá kolekce a dokumenty, což umožňuje provádět složité dotazy s více podmínkami. Kromě toho Firestore zajišťuje silnou konzistenci dat: po úspěšném zápisu všechna následná čtení garantovaně vracejí aktuální data.

Škálovatelnost a struktura dat

Firestore se automaticky škáluje až na miliony současných připojení díky multi-regionální architektuře. Realtime Database je omezena na jeden region a maximálně 200 000 současných připojení. Pro projekty plánující globální publikum je Firestore výhodnější, protože data jsou automaticky replikována mezi několika datovými centry Google.

Struktura dat v Firestore umožňuje vytvářet složité hierarchické modely s podkolekcemi. Například uživatel může mít podkolekci „objednávky" a každá objednávka podkolekci „produkty". V Realtime Database takové hluboké vnoření vede k problémům s výkonem při dotazech, protože se načítá celá cesta od kořene k požadovanému uzlu.

Jak funguje synchronizace dat v Firestore

Firestore používá trvalé WebSocket připojení mezi klientem a serverem pro synchronizaci dat v reálném čase. Když se aplikace přihlásí ke změnám dokumentu nebo kolekce prostřednictvím snapshot listeneru, SDK vytvoří komunikační kanál, přes který server odesílá aktualizace při každé změně dat. Klient obdrží pouze změněné dokumenty, ne celou kolekci pokaždé.

Mechanismus synchronizace je založen na toku událostí: added (dokument se objevil), modified (dokument se změnil) a removed (dokument byl smazán). Vývojář může každou událost zpracovat samostatně a aktualizovat pouze odpovídající prvky UI. To zajišťuje vysoký výkon i při tisících dokumentech, protože se překreslují pouze změněné komponenty.

Offline přístup a ukládání do mezipaměti

Jednou z klíčových výhod Firestore je vestavěná podpora offline režimu. SDK automaticky ukládá všechna přečtená data do mezipaměti na zařízení a pokračuje v práci bez sítě. Když aplikace zapisuje data v offline režimu, jsou umístěna do místní fronty a odeslána na server po obnovení připojení. Pro řešení konfliktů se používá strategie last-write-wins.

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

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Chyba naslouchání", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Aktuální data: ${snapshot.data}")
    }
}

Velikost mezipaměti lze nastavit prostřednictvím FirestoreSettings. Ve výchozím nastavení se používá 100 MB, ale pro aplikace s intenzivním čtením dat lze zvýšit. K dispozici je také režim persistentní diskové mezipaměti, který přežije restart aplikace. Pro správu dostupnosti offline režimu se používají metody enableNetwork a disableNetwork, které umožňují dočasně vypnout síťovou komunikaci.

Bezpečnost a pravidla přístupu Firestore

Firestore Security Rules je deklarativní značkovací jazyk pro řízení přístupu k datům na úrovni serveru. Pravidla určují, kdo a za jakých podmínek může číst a zapisovat dokumenty. Fungují před provedením dotazu a nevyžadují samostatnou serverovou logiku pro autorizaci. Pravidla jsou kontrolována na straně Firebase před každým čtením nebo zápisem dat.

Pravidla přístupu jsou postavena na principu povoleného přístupu (allow). Ve výchozím nastavení je veškerý přístup zakázán. Vývojář postupně otevírá přístup pro konkrétní operace (read, write, create, update, delete) za určitých podmínek. Podmínky mohou ověřovat autentizaci uživatele prostřednictvím request.auth, data dotazu prostřednictvím request.resource a existující data prostřednictvím resource.

// Pravidla přístupu Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Uživatel čte a zapisuje pouze svá data
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Jakýkoli autentizovaný uživatel může číst příspěvky
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Validace dat prostřednictvím pravidel

Kromě řízení přístupu umožňuje Security Rules validovat strukturu a typy zapisovaných dat. Například lze zkontrolovat, zda pole email odpovídá regulárnímu výrazu nebo zda věk nepřesahuje 120 let. Validace se provádí před zápisem, což brání ukládání nesprávných dat na server. Pro kontrolu polí se používá objekt request.resource.data obsahující celý zapisovaný dokument.

Firestore také podporuje kolekce přístupné pouze pro serverový zápis přes Admin SDK, bez přístupu ze strany klientů. To je vhodné pro ukládání servisních informací, API klíčů a konfigurací, které by neměly být viditelné pro uživatele. K tomu v pravidlech stačí zakázat všechny klientské operace na příslušných kolekcích a povolit přístup pouze přes Admin SDK na straně serveru.

Příklad použití Firebase Firestore v Androidu

Podívejme se na příklad integrace Firestore v Android aplikaci pro vytvoření seznamu úkolů (todo). Aplikace bude číst úkoly v reálném čase, přidávat nové a označovat hotové. Pro asynchronní práci se používají callback rozhraní Firebase a Kotlin korutiny.

Nastavení Firebase a přidání závislostí

Před zahájením práce je třeba připojit projekt k Firebase přes Firebase Console a přidat soubor google-services.json do modulu aplikace. Poté se do build.gradle přidá závislost firebase-firestore-ktx a plugin google-services. Verze knihovny by měla odpovídat aktuální verzi Firebase BoM pro kompatibilitu všech komponent Firebase mezi sebou.

dependencies {
    // Firebase BoM — správa verzí
    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"
}

Po nastavení se vytvoří datový model Task a repozitář pro práci s Firestore. Model obsahuje pole id, title, isCompleted a timestamp. Firestore automaticky serializuje data class do dokumentu s použitím názvů polí jako klíčů. Pro čtení dat se používá snapshot listener, který vrací Flow prostřednictvím rozšíření 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))
    }
}

View-model se přihlásí k odběru Flow z repozitáře a předá seznam úkolů do vrstvy UI. Při přidávání nového úkolu se zavolá suspend funkce repozitáře přes korutinový scope. Firestore automaticky synchronizuje změny mezi všemi klienty: pokud jeden uživatel přidá úkol, ostatní ho vidí v reálném čase bez obnovení obrazovky.