Firebase Firestore — mi ez, dokumentumok és NoSQL gyűjtemények

Mi az a Firebase Firestore

A Firebase Firestore egy felhőalapú NoSQL adatbázis, amelyet a Google 2019-ben indított a Realtime Database utódjaként. A Firestore a Google Cloud Spanner és a Google Cloud Datastore infrastruktúrájára épül, szigorú adatkonzisztenciát biztosítva egy tranzakción belül és automatikus több régiós replikációt. Az SDK támogatja az Android, iOS, Web (JavaScript), Flutter, Kotlin Multiplatform és Unity platformokat.

Evolúció a Realtime Database-től

A Firestore-t a Google I/O 2017-en jelentették be „Cloud Firestore” néven — egy olyan megoldásként, amely kiküszöböli a Realtime Database fő korlátait: az összetett lekérdezések támogatásának hiányát, az adatok több csomóponton történő skálázásának képtelenségét és a gyenge konzisztenciát. A Google (2026) adatai szerint a Firestore naponta több mint 1 billió lekérdezést dolgoz fel, és az új Firebase-projektek 80%-ának alapértelmezett adatbázisa. A Realtime Database azonban továbbra is releváns az ultra-alacsony késleltetésű forgatókönyvekben (játékok, közös szerkesztés) az egyszerű JSON-struktúrának köszönhetően.

A Firestore ingyenes korlátai

A Firestore pay-as-you-go modellben érhető el, bőkezű ingyenes korlátokkal a Spark csomagban: 1 GB tárhely, 10 GB hálózati forgalom havonta, 50 ezer olvasási művelet, 20 ezer írási művelet és 20 ezer törlési művelet naponta. A Blaze csomagban mindez ingyenes, a túllépések pedig díjkötelesek: $0.06 / 100 ezer olvasási művelet, $0.18 / 100 ezer írási művelet. A Google (2026) adatai szerint a projektek 90%-a nem lépi túl az ingyenes korlátot.

Adatmodell: gyűjtemények, dokumentumok és mezők

A Firestore adatmodellje hierarchikusan szerveződik: a gyökér gyűjteményeket tartalmaz, minden gyűjtemény dokumentumokat tartalmaz, minden dokumentum mezőket (primitív típusok, tömbök, Map) és beágyazott gyűjteményeket (subcollections) tartalmaz. A gyűjtemények beágyazási mélysége nem korlátozott, de egy dokumentum nem tartalmazhat közvetlenül másik dokumentumot — csak referencián (Reference type) keresztül.

Gyűjtemények és dokumentumok

A gyűjtemény dokumentumok konténere automatikusan generált vagy megadott azonosítókkal. Minden dokumentum egy JSON-szerű objektum, legfeljebb 1 MiB méretben. A dokumentum mezői lehetnek karakterláncok, számok, logikai értékek, tömbök, Map, időbélyegek (Timestamp), földrajzi pontok (GeoPoint) és hivatkozások más dokumentumokra (Reference). A dokumentum mérete az összes mezőnévvel együtt legfeljebb 1 MiB lehet.

Kötegelt írás és tranzakciók

A Firestore támogatja az atomi tranzakciókat az adatbázis szintjén. Egy tranzakció több dokumentumot is olvashat és írhat — a Commit atomi módon alkalmazza az összes változtatást vagy egyiket sem. Maximum 500 művelet tranzakciónként, 60 másodperces időtúllépés. A kötegelt írás (batch write) egy nem-tranzakciós atomi írási művelet olvasási fázis nélkül. A tranzakciók kritikus fontosságúak a pénzügyi műveletek, helyfoglalások és leltározás szempontjából.

A Firestore és a Realtime Database összehasonlítása

A Firestore és a Realtime Database közötti választás a projekt követelményeitől függ. Mindkét adatbázis a Firebase ökoszisztéma része, valós idejű szinkronizációt biztosít, és minden platformon elérhető, de alapvetően különböznek az adatmodellben, a skálázásban és az árképzésben.

Fő különbségek

A Realtime Database az adatokat egyetlen JSON-fában tárolja, ami egyszerű struktúrák esetén kényelmes, de megnehezíti a skálázást 3 szintnél mélyebb beágyazásnál. A Firestore a gyűjtemény-dokumentum modellt használja automatikus shardinggal, ami lehetővé teszi a skálázást milliónyi dokumentumig a teljesítmény romlása nélkül. A Google (2026) adatai szerint a Firestore akár 10 ezer egyidejű kapcsolatot is támogat egy gyűjteményhez sebességveszteség nélkül, a Realtime Database — akár 200 ezer kapcsolatot egy példányhoz.

Árképzés

A Realtime Database az átvitt adatok mennyisége (letöltött bájtok) és az egyidejű kapcsolatok száma alapján díjszabott. A Firestore — a műveletek száma alapján (olvasás, írás, törlés). Gyakori kis frissítésekkel rendelkező alkalmazásokhoz (chat, értesítések) a Firestore általában kedvezőbb — minden írási művelet fix árat képvisel az adatmérettől függetlenül. Ritka, nagy mennyiségű adatot olvasó alkalmazásokhoz a Realtime Database olcsóbb lehet.

Google (2026) ajánlása: használja a Firestore-t alapértelmezett adatbázisként új projektekhez, a Realtime Database-t pedig játékokhoz és olyan alkalmazásokhoz, ahol a minimális késleltetés (50 ms alatt) kritikus, és az adatstruktúra lapos. Mindkét adatbázis egyidejűleg működhet egy projektben.

Lekérdezések, indexek és lapozás a Firestore-ban

A Firestore lekérdezései gyűjteményeken vagy gyűjteménycsoportokon futnak szűréssel, rendezéssel és korlátozással. Ellentétben a Realtime Database-szel, ahol minden lekérdezés a teljes JSON-fa bejárása szűréssel a kliens oldalon, a Firestore minden lekérdezést a szerveren hajt végre, előre létrehozott indexeket használva. Ez garantálja, hogy a lekérdezés összetettsége csak az eredmény méretétől függ, nem a gyűjtemény méretétől.

Lekérdezéstípusok

A Firestore támogatja a szűrést egy vagy több mezőre (equality, range, in, array-contains, array-contains-any), a növekvő és csökkenő rendezést, a korlátot és a kurzorokat a lapozáshoz. Korlátozások: az összetett lekérdezések különböző mezőkre történő szűréssel (where price > 10 AND where category == „books”) összetett indexet igényelnek; az OR lekérdezések tiltottak (helyette in és array-contains-any használatos) és a különböző mezőkre vonatkozó egyenlőtlenségi lekérdezések tiltottak.

data class Product(
    val name: String = "",
    val category: String = "",
    val price: Double = 0.0,
    val inStock: Boolean = false
)

suspend fun FirestoreRepository.queryProducts(): List<Product> {
    return firestore
        .collection("products")
        .whereEqualTo("category", "electronics")
        .whereGreaterThanOrEqualTo("price", 100.0)
        .whereLessThan("price", 500.0)
        .orderBy("price")
        .limit(20)
        .get()
        .await()
        .toObjects(Product::class.java)
}

Automatikus és összetett indexek

A Firestore automatikusan hoz létre indexeket az egyes mezőkhöz — az egy mezőre vonatkozó lekérdezések minden beállítás nélkül működnek. A két vagy több mezőt tartalmazó lekérdezésekhez (szűrés + rendezés) összetett indexek jönnek létre. Az első lekérdezés elküldésekor a Firestore hibát ad vissza a konzolra mutató hivatkozással, ahol az index egy kattintással létrehozható. Maximum 200 összetett index adatbázisonként. Az indexek exportálhatók és importálhatók a firebase CLI-n keresztül.

A Firestore integrációja Androidban

A Firestore csatlakoztatása egy Android-alkalmazáshoz szabványos módon, a Firebase BOM-on keresztül történik. A firebase-firestore-ktx függőség hozzáadása után a FirebaseFirestore objektum a getInstance()-en keresztül érhető el — további kulcsok vagy tokenek nélkül. A Firestore ugyanazt a Firebase-projektet használja, mint a többi szolgáltatás.

dependencies {
    implementation(platform("com.google.firebase:firebase-bom:33.1.0"))
    implementation("com.google.firebase:firebase-firestore-ktx")
}

// Inicializálás
val db = FirebaseFirestore.getInstance()

Adatok olvasása és írása

A Firestore két olvasási módot kínál: egyszeri (get) és valós idejű (addSnapshotListener). Az egyszeri olvasás egyszer kéri le a dokumentumot — hasznos beállításokhoz és konfigurációhoz. A figyelő feliratkozik a változásokra — a dokumentum bármely frissítése automatikusan eljuttatja a frissített adatokat az összes csatlakoztatott klienshez valós időben. A set() létrehozza vagy felülírja a dokumentumot, az update() csak a megadott mezőket módosítja a teljes dokumentum felülírása nélkül.

A Google (2026) adatai szerint a közepes méretű alkalmazások (100 ezer DAU) valós idejű Firestore-ral körülbelül 5-10 GB kimenő forgalmat generálnak havonta. Az offline gyorsítótár (Persistence Cache) használata 60-70%-kal csökkenti az ismételt letöltések mennyiségét, mivel az SDK a kapcsolat helyreállításakor csak a megváltozott dokumentumokat tölti le.

Offline mód

A Persistence Cache a Firestore beépített mechanizmusa az internet nélküli munkához. Az SDK automatikusan gyorsítótárazza az összes olvasott dokumentumot az eszközön (Androidon akár 500 MiB-ig). A kapcsolat megszakadásakor az olvasás a gyorsítótárból folytatódik, az írás sorba kerül. A kapcsolat helyreállításakor az összes halasztott művelet elküldésre kerül a szerverre, és a gyorsítótár szinkronizálódik a szerverrel. Az ütközések kezeléséhez a snapshot-metadata.hasPendingWrites és a setOptions(ServerTimestampBehavior) használható.

Biztonsági szabályok és adatérvényesítés

A Security Rules egy deklaratív nyelv a Firestore-hoz való hozzáférés korlátozására, amely a Google szerverén fut le minden olvasási vagy írási művelet előtt. A Rules nem igényel szerverkódot — a Firebase konzolban vagy a firebase CLI-n keresztül írhatók, és Git-en keresztül verziókezelhetők. Minden művelet ellenőrzésre kerül a szabályoknak való megfelelés szempontjából, és megsértés esetén PERMISSION_DENIED hiba kerül visszaadásra.

A szabályok szerkezete

A Firestore Security Rules szabályai match blokkokból és allow kifejezésekből állnak. A match meghatározza a gyűjteményhez vagy dokumentumhoz vezető útvonalat, az allow megadja az engedélyezett műveleteket (read, write, create, update, delete) és a feltételt — egy JavaScript-szerű kifejezést, amely logikai értéket ad vissza. A szabályok ellenőrizhetik a hitelesítést (request.auth), a kérés adatait (request.resource.data), a meglévő adatokat (resource.data), az időt (request.time) és az útvonalat (request.path).

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId} {
      allow read: if request.auth != null;
      allow write: if request.auth.uid == userId;
    }

    match /products/{productId} {
      allow read: if true;
      allow create: if request.auth.token.role == "admin";
      allow update: if resource.data.authorId == request.auth.uid;
    }
  }
}

Adatérvényesítés

A Security Rules támogatja a típusok és értékek érvényesítését a szerver oldalon. Megtiltható az írás, ha az ár negatív vagy a név üres. Minden ellenőrzés a Google szerverén történik az írás előtt — ez garantálja az adatok konzisztenciáját a klienstől (Android, iOS, Web, Admin SDK) függetlenül. A Rules nem véd a rosszindulatú Admin SDK ellen — az definíció szerint megkerüli a szabályokat. A teljes védelem érdekében használja a Transaction Functions és Firebase Extensions szolgáltatásokat.