Firebase Firestore: apa itu, NoSQL dan cara kerjanya

Apa itu Firebase Firestore?

Firebase Firestore adalah database NoSQL yang fleksibel dan skalabel, diluncurkan oleh Google pada tahun 2019 sebagai evolusi dari Firebase Realtime Database. Database ini menyimpan data dalam bentuk koleksi dokumen, di mana setiap dokumen berisi sepasang key-value. Berbeda dengan database relasional tradisional, Firestore tidak memerlukan skema yang ditentukan sebelumnya — struktur data terbentuk secara dinamis berdasarkan dokumen yang ditulis.

Perbedaan utama Firestore dari database cloud klasik adalah sinkronisasi real-time bawaan. Ketika data berubah di server, semua klien yang terhubung menerima pembaruan melalui koneksi WebSocket permanen. Ini menghilangkan kebutuhan polling server manual dan memungkinkan pembangunan aplikasi dengan pembaruan langsung: chat, feed aktivitas, editor kolaboratif, dan sistem monitoring.

Database ini tersedia di semua platform utama: Android, iOS, Web (JavaScript) dan bahasa server melalui Admin SDK. Firestore menyediakan SDK untuk Swift, Kotlin, JavaScript, Python, Go, Java, dan Node.js. Menurut data Google, Firestore memproses lebih dari 100 miliar kueri per hari di seluruh ekosistem Firebase, yang menegaskan keandalannya sebagai basis untuk aplikasi produksi.

Konsep dasar: koleksi dan dokumen

Di Firestore, data diorganisasikan dalam struktur hierarkis. Koleksi adalah wadah dokumen, mirip dengan tabel di SQL, tetapi tanpa skema tetap. Dokumen adalah record yang berisi field dari berbagai tipe: string, angka, nilai boolean, array, objek bersarang, dan titik geo. Dokumen dapat berisi subkoleksi, memungkinkan pembangunan struktur data bersarang dengan kedalaman berapa pun.

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", "Dokumen ditambahkan dengan ID: ${docRef.id}")
    }

Setiap dokumen dalam koleksi memiliki pengidentifikasi unik yang dapat dihasilkan secara otomatis atau diatur secara manual. Firestore secara otomatis mengindeks semua field dokumen, memungkinkan eksekusi kueri kompleks dengan pemfilteran, pengurutan, dan pembatasan jumlah hasil tanpa konfigurasi indeks sebelumnya.

Firebase Firestore vs Realtime Database: perbandingan

Firestore dan Firebase Realtime Database adalah dua database cloud real-time dari Google. Meskipun keduanya menyediakan sinkronisasi real-time, keduanya memiliki perbedaan mendasar dalam model data, penskalaan, dan harga. Memahami perbedaan ini sangat penting saat memilih database yang tepat untuk proyek tertentu.

Perbedaan arsitektur utama adalah model data. Realtime Database menyimpan semuanya dalam satu pohon JSON besar, yang mempersulit kueri dengan tingkatan bersarang. Firestore menggunakan koleksi dan dokumen, yang memungkinkan eksekusi kueri kompleks dengan beberapa kondisi. Selain itu, Firestore menyediakan konsistensi data yang kuat: setelah penulisan berhasil, semua pembacaan berikutnya dijamin mengembalikan data terkini.

Skalabilitas dan struktur data

Firestore menskala secara otomatis hingga jutaan koneksi simultan berkat arsitektur multi-regional. Realtime Database terbatas pada satu region dan maksimum 200.000 koneksi simultan. Untuk proyek yang merencanakan audiens global, Firestore lebih disukai karena data secara otomatis direplikasi di antara beberapa pusat data Google.

Struktur data di Firestore memungkinkan pembangunan model hierarkis kompleks dengan subkoleksi. Misalnya, pengguna dapat memiliki subkoleksi "pesanan", dan setiap pesanan memiliki subkoleksi "produk". Di Realtime Database, tingkatan bersarang yang dalam seperti itu menyebabkan masalah kinerja pada kueri, karena seluruh jalur dari root ke node yang diinginkan dimuat.

Bagaimana sinkronisasi data di Firestore bekerja

Firestore menggunakan koneksi WebSocket permanen antara klien dan server untuk sinkronisasi data real-time. Saat aplikasi berlangganan perubahan dokumen atau koleksi melalui snapshot listener, SDK membuat saluran komunikasi di mana server mengirimkan pembaruan pada setiap perubahan data. Klien hanya menerima dokumen yang diubah, bukan seluruh koleksi setiap saat.

Mekanisme sinkronisasi didasarkan pada aliran peristiwa: added (dokumen muncul), modified (dokumen berubah), dan removed (dokumen dihapus). Pengembang dapat memproses setiap peristiwa secara terpisah, hanya memperbarui elemen UI yang sesuai. Ini memastikan kinerja tinggi bahkan dengan ribuan dokumen, karena hanya komponen yang berubah yang digambar ulang.

Akses offline dan caching

Salah satu keunggulan utama Firestore adalah dukungan bawaan untuk mode offline. SDK secara otomatis menyimpan cache semua data yang dibaca di perangkat dan terus bekerja tanpa jaringan. Saat aplikasi menulis data dalam mode offline, data tersebut ditempatkan dalam antrian lokal dan dikirim ke server saat koneksi dipulihkan. Untuk menyelesaikan konflik, digunakan strategi last-write-wins.

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

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

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

Ukuran cache dapat dikonfigurasi melalui FirestoreSettings. Secara default, nilai 100 MB digunakan, tetapi untuk aplikasi dengan pembacaan data intensif dapat ditingkatkan. Juga tersedia mode persistent disk cache yang bertahan dari restart aplikasi. Untuk mengelola ketersediaan mode offline, digunakan metode enableNetwork dan disableNetwork, yang memungkinkan penonaktifan sementara komunikasi jaringan.

Keamanan dan aturan akses Firestore

Firestore Security Rules adalah bahasa markup deklaratif untuk mengontrol akses data di tingkat server. Aturan menentukan siapa dan dalam kondisi apa dapat membaca dan menulis dokumen. Aturan bekerja sebelum eksekusi kueri dan tidak memerlukan logika server terpisah untuk otorisasi. Aturan diperiksa di sisi Firebase sebelum setiap pembacaan atau penulisan data.

Aturan akses dibangun berdasarkan prinsip akses yang diizinkan (allow). Secara default, semua akses dilarang. Pengembang secara bertahap membuka akses untuk operasi tertentu (read, write, create, update, delete) dalam kondisi tertentu. Kondisi dapat memeriksa autentikasi pengguna melalui request.auth, data kueri melalui request.resource, dan data yang ada melalui resource.

// Aturan akses Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Pengguna membaca dan menulis hanya datanya sendiri
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Setiap pengguna terautentikasi dapat membaca postingan
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Validasi data melalui aturan

Selain kontrol akses, Security Rules memungkinkan validasi struktur dan tipe data yang ditulis. Misalnya, dapat diperiksa apakah field email cocok dengan ekspresi reguler, atau apakah usia tidak melebihi 120 tahun. Validasi dilakukan sebelum penulisan, mencegah penyimpanan data yang salah di server. Untuk memeriksa field, digunakan objek request.resource.data yang berisi seluruh dokumen yang akan ditulis.

Firestore juga mendukung koleksi yang hanya dapat diakses untuk penulisan server melalui Admin SDK, tanpa akses dari sisi klien. Ini berguna untuk menyimpan informasi layanan, kunci API, dan konfigurasi yang tidak boleh terlihat oleh pengguna. Untuk ini, dalam aturan cukup melarang semua operasi klien pada koleksi yang sesuai, hanya mengizinkan akses melalui Admin SDK di sisi server.

Contoh penggunaan Firebase Firestore di Android

Mari kita lihat contoh integrasi Firestore dalam aplikasi Android untuk membuat daftar tugas (todo). Aplikasi akan membaca tugas secara real-time, menambahkan yang baru, dan menandai yang selesai. Untuk kerja asinkron, digunakan antarmuka callback Firebase dan coroutine Kotlin.

Konfigurasi Firebase dan menambahkan dependensi

Sebelum memulai, perlu menghubungkan proyek ke Firebase melalui Firebase Console dan menambahkan file google-services.json ke modul aplikasi. Kemudian di build.gradle ditambahkan dependensi firebase-firestore-ktx dan plugin google-services. Versi pustaka harus sesuai dengan versi BoM Firebase saat ini untuk kompatibilitas semua komponen Firebase.

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

Setelah konfigurasi, dibuat model data Task dan repositori untuk bekerja dengan Firestore. Model berisi field id, title, isCompleted, dan timestamp. Firestore secara otomatis men-serialize data class menjadi dokumen, menggunakan nama field sebagai kunci. Untuk membaca data, digunakan snapshot listener yang mengembalikan Flow melalui ekstensi 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 berlangganan ke Flow dari repositori dan meneruskan daftar tugas ke tingkat UI. Saat menambahkan tugas baru, fungsi suspend repositori dipanggil melalui coroutine scope. Firestore secara otomatis menyinkronkan perubahan di antara semua klien: jika satu pengguna menambahkan tugas, pengguna lain melihatnya secara real-time tanpa memuat ulang layar.