# 2026'da Flutter ve Firebase: Kimlik Doğrulama, Firestore ve Mülakat Soruları

> Flutter ve Firebase entegrasyonu hakkında kapsamlı rehber — kimlik doğrulama, Firestore CRUD işlemleri, gerçek zamanlı senkronizasyon ve en sık sorulan mülakat soruları.

- Published: 2026-06-10
- Updated: 2026-06-10
- Author: SharpSkill
- Tags: flutter, firebase, kimlik doğrulama, firestore, dart, mobil geliştirme
- Reading time: 12 min

---

Flutter Firebase entegrasyonu, 2026 yılında Flutter uygulamaları için en popüler backend seçeneği olmaya devam ediyor. Milyonlarca uygulamada kimlik doğrulama, gerçek zamanlı veritabanları ve bulut fonksiyonları sağlayan bu ekosistem, FlutterFire SDK v4.15 ile önemli ölçüde olgunlaştı — `flutterfire configure` ile basitleştirilen kurulumdan Firestore Pipelines ve Firebase Admin Dart SDK için yerel desteğe kadar.

> **FlutterFire SDK v4.15 (2026)**
>
> FlutterFire'ın en son sürümü firebase_auth v6.1.2 ve cloud_firestore v6.4.1 içermektedir. Firestore Pipelines desteği, macOS'ta TOTP kimlik doğrulama ve parola politikalarını uygulamak için validatePassword API'si ile birlikte gelir.

## Flutter Projesinde Firebase Kurulumu

Herhangi bir Firebase kodu yazmadan önce projenin doğru şekilde başlatılması gerekir. FlutterFire CLI, platform kaydını otomatikleştirir ve Android, iOS, web ve macOS için yapılandırma dosyalarını oluşturur.

```dart
// main.dart
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  // Initialize Firebase with platform-specific config
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(const MyApp());
}
```

`firebase_options.dart` dosyası `flutterfire configure` komutu çalıştırıldığında otomatik olarak oluşturulur. API anahtarlarını, proje kimliklerini ve platforma özel tanımlayıcıları içerir — Firebase konsolundan manuel kopyalama gerektirmez.

## Firebase Kimlik Doğrulama: E-posta, Google ve Çok Faktörlü Doğrulama

Firebase Authentication, minimum şablon koduyla kullanıcı kimliğini yönetir. `firebase_auth` paketi e-posta/parola, OAuth sağlayıcıları (Google, Apple, GitHub), telefon tabanlı SMS doğrulama ve çok faktörlü kimlik doğrulamayı (MFA) destekler.

### E-posta ve Parola ile Kayıt

En yaygın akış e-posta/parola ile başlar. `createUserWithEmailAndPassword` metodu, kimlik doğrulanmış `User` nesnesini içeren bir `UserCredential` döndürür.

```dart
// auth_service.dart
import 'package:firebase_auth/firebase_auth.dart';

class AuthService {
  final FirebaseAuth _auth = FirebaseAuth.instance;

  // Register with email and password
  Future<User?> register(String email, String password) async {
    try {
      final credential = await _auth.createUserWithEmailAndPassword(
        email: email,
        password: password,
      );
      return credential.user;
    } on FirebaseAuthException catch (e) {
      // Handle specific error codes
      switch (e.code) {
        case 'email-already-in-use':
          throw Exception('This email is already registered');
        case 'weak-password':
          throw Exception('Password must be at least 6 characters');
        default:
          throw Exception('Registration failed: ${e.message}');
      }
    }
  }

  // Sign in with existing credentials
  Future<User?> signIn(String email, String password) async {
    final credential = await _auth.signInWithEmailAndPassword(
      email: email,
      password: password,
    );
    return credential.user;
  }

  // Reactive auth state stream
  Stream<User?> get authStateChanges => _auth.authStateChanges();
}
```

`authStateChanges()` akışı, uygulama genelinde oturum durumunu izlemenin önerilen yoludur. Abone olunduğunda mevcut `User` nesnesini yayar ve her giriş veya çıkış olayında tekrar tetiklenir.

### Google ile Giriş Entegrasyonu

OAuth sağlayıcıları ek bir paket gerektirir. Google ile giriş, yerel hesap seçiciyi tetikler ve ardından jetonu Firebase ile değiştirir.

```dart
// google_auth.dart
import 'package:firebase_auth/firebase_auth.dart';
import 'package:google_sign_in/google_sign_in.dart';

Future<UserCredential> signInWithGoogle() async {
  // Trigger the native Google Sign-In flow
  final googleUser = await GoogleSignIn().signIn();
  if (googleUser == null) throw Exception('Sign-in cancelled');

  // Obtain auth details from the Google account
  final googleAuth = await googleUser.authentication;

  // Create a Firebase credential from the Google tokens
  final credential = GoogleAuthProvider.credential(
    accessToken: googleAuth.accessToken,
    idToken: googleAuth.idToken,
  );

  // Sign in to Firebase with the Google credential
  return FirebaseAuth.instance.signInWithCredential(credential);
}
```

Bu kalıp tüm OAuth sağlayıcıları için geçerlidir: sağlayıcı jetonunu elde etmek, Firebase kimlik bilgisi içine sarmak ve ardından `signInWithCredential` çağırmak.

> **Parola Politikası Doğrulaması**
>
> Firebase Auth v6.1+ sunucu taraflı parola politikası uygulaması sağlayan `validatePassword` API'sini içerir. Politikalar minimum uzunluk, büyük harf, küçük harf, rakam ve özel karakter gerektirebilir — tümü Firebase konsolundan yapılandırılabilir.

## Firestore CRUD İşlemleri ve Veri Modelleme

Cloud Firestore, verileri koleksiyonlar ve belgeler halinde düzenler. SQL veritabanlarının aksine Firestore şemasızdır — her belge farklı alanlar içerebilir. Bu esneklik Flutter uygulamalarına iyi uyar, ancak performans sorunlarından kaçınmak için disiplinli veri modelleme gerektirir.

### Belge Yazma ve Okuma

Firestore işlemleri `cloud_firestore` paketiyle basittir. Her okuma ve yazma işlemi belirli bir belge yolunu hedefler.

```dart
// firestore_service.dart
import 'package:cloud_firestore/cloud_firestore.dart';

class TaskService {
  final _db = FirebaseFirestore.instance;
  final String _collection = 'tasks';

  // Create a new document with auto-generated ID
  Future<String> createTask(String userId, String title) async {
    final doc = await _db.collection(_collection).add({
      'userId': userId,
      'title': title,
      'completed': false,
      'createdAt': FieldValue.serverTimestamp(),
    });
    return doc.id;
  }

  // Read a single document by ID
  Future<Map<String, dynamic>?> getTask(String taskId) async {
    final snapshot = await _db.collection(_collection).doc(taskId).get();
    return snapshot.data();
  }

  // Update specific fields without overwriting the entire document
  Future<void> toggleComplete(String taskId, bool completed) async {
    await _db.collection(_collection).doc(taskId).update({
      'completed': completed,
      'updatedAt': FieldValue.serverTimestamp(),
    });
  }

  // Delete a document
  Future<void> deleteTask(String taskId) async {
    await _db.collection(_collection).doc(taskId).delete();
  }
}
```

`FieldValue.serverTimestamp()`, istemci saati yerine Firestore sunucu saatini kullanarak tüm cihazlarda tutarlı zaman damgaları sağlar.

### snapshots() ile Gerçek Zamanlı Akışlar

Firestore, gerçek zamanlı senkronizasyon konusunda öne çıkar. `snapshots()` metodu, temel belgeler değiştiğinde yeni verileri yayan bir `Stream` döndürür — yoklama gerekmez.

```dart
// real_time_tasks.dart
import 'package:cloud_firestore/cloud_firestore.dart';

class TaskStream {
  final _db = FirebaseFirestore.instance;

  // Stream all tasks for a specific user, ordered by creation date
  Stream<List<Map<String, dynamic>>> userTasks(String userId) {
    return _db
        .collection('tasks')
        .where('userId', isEqualTo: userId)
        .orderBy('createdAt', descending: true)
        .snapshots()
        .map((snapshot) => snapshot.docs.map((doc) {
              final data = doc.data();
              data['id'] = doc.id; // Include document ID
              return data;
            }).toList());
  }
}
```

Bir Flutter widget'ında bu akış, her veritabanı değişikliğinde arayüzü yeniden oluşturmak için doğrudan `StreamBuilder` ile entegre olur. Firestore bağlantı yönetimi, önbellekleme ve çevrimdışı kalıcılık işlemlerini otomatik olarak yönetir.

## Flutter Uygulamaları için Firestore Güvenlik Kuralları

Güvenlik kuralları Firestore sunucusunda çalışır ve belge düzeyinde okuma/yazma erişimini kontrol eder. Uygun kurallar olmadan, kimlik doğrulanmış herhangi bir kullanıcı herhangi bir belgeyi okuyabilir veya değiştirebilir.

```javascript
// firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Users can only access their own profile
    match /users/{userId} {
      allow read, update: if request.auth != null
                          && request.auth.uid == userId;
      allow create: if request.auth != null;
      allow delete: if false; // Prevent self-deletion
    }

    // Tasks belong to the user who created them
    match /tasks/{taskId} {
      allow read, write: if request.auth != null
                         && resource.data.userId == request.auth.uid;
      allow create: if request.auth != null
                    && request.resource.data.userId == request.auth.uid;
    }
  }
}
```

`request.auth.uid` değişkeni, Firebase Auth'tan kimlik doğrulanmış kullanıcının kimliğini içerir. `resource.data`'ya referans veren kurallar mevcut belge alanlarını kontrol ederken, `request.resource.data` gelen yazma verilerini doğrular.

> **Güvenlik Kuralları İsteğe Bağlı Değildir**
>
> Firestore, üretim modunda varsayılan olarak tüm erişimi reddeder. Her koleksiyon açık kurallara ihtiyaç duyar. Flutter projelerinde sık yapılan bir hata: test modu kurallarıyla (`allow read, write: if true`) geliştirme yapmak ve üretim dağıtımı öncesinde kilitlemeyi unutmak.

## Çevrimdışı Kalıcılık ve Önbellekleme Stratejisi

Firestore, mobil platformlarda varsayılan olarak çevrimdışı kalıcılığı etkinleştirir. Cihaz bağlantı kaybettiğinde, okuma işlemleri önbellekteki verileri döndürür ve yazma işlemleri bağlantı yeniden kurulana kadar yerel olarak kuyruğa alınır.

Bu davranış Flutter kodu için şeffaftır — aynı `get()` ve `snapshots()` çağrıları çevrimdışı çalışır. Ancak üretim uygulamaları için iki husus önemlidir:

- **Önbellek boyutu**: Firestore, istemcinin okuduğu tüm belgeleri önbelleğe alır. Veri yoğun uygulamalar için `Settings(cacheSizeBytes: Settings.CACHE_SIZE_UNLIMITED)` yapılandırılabilir veya belirli bir sınır belirlenebilir. v6.4.1 sürümü, sınırlandırılmamış önbelleğin iOS'ta doğru uygulanmadığı bir hatayı düzeltmiştir.
- **Bekleyen yazma göstergesi**: `SnapshotMetadata.hasPendingWrites` kullanılarak yerel değişikliklerin henüz sunucuya senkronize edilmediği kullanıcılara gösterilebilir.

```dart
// offline_aware_widget.dart
StreamBuilder<DocumentSnapshot>(
  stream: FirebaseFirestore.instance
      .collection('tasks')
      .doc(taskId)
      .snapshots(),
  builder: (context, snapshot) {
    if (!snapshot.hasData) return const CircularProgressIndicator();

    final data = snapshot.data!;
    final isPending = data.metadata.hasPendingWrites;

    return Row(
      children: [
        Text(data['title']),
        if (isPending) const Icon(Icons.cloud_upload, size: 16),
      ],
    );
  },
)
```

## Üretim Flutter Firebase Uygulama Mimarisi

Ölçeklenebilir bir mimari, Firebase mantığını kullanıcı arayüzü kodundan ayırır. Repository deseni, test etmeyi ve gelecekteki backend geçişlerini kolaylaştıran temiz bir soyutlama katmanı sağlar.

```dart
// task_repository.dart
abstract class TaskRepository {
  Future<String> create(String userId, String title);
  Stream<List<Task>> watchAll(String userId);
  Future<void> update(String id, Map<String, dynamic> fields);
  Future<void> delete(String id);
}

// firebase_task_repository.dart
class FirebaseTaskRepository implements TaskRepository {
  final _db = FirebaseFirestore.instance;

  @override
  Future<String> create(String userId, String title) async {
    final doc = await _db.collection('tasks').add({
      'userId': userId,
      'title': title,
      'completed': false,
      'createdAt': FieldValue.serverTimestamp(),
    });
    return doc.id;
  }

  @override
  Stream<List<Task>> watchAll(String userId) {
    return _db
        .collection('tasks')
        .where('userId', isEqualTo: userId)
        .orderBy('createdAt', descending: true)
        .snapshots()
        .map((s) => s.docs.map(Task.fromFirestore).toList());
  }

  // ... update and delete implementations
}
```

Bu desenle Riverpod veya BLoC gibi durum yönetimi çözümleri, Firestore hakkında bilgi sahibi olmadan repository arayüzünü tüketir. Birim testleri, önceden tanımlanmış veriler döndüren sahte bir repository'yi ikame edebilir.

## Sık Sorulan Flutter Firebase Mülakat Soruları

Mülakatlar sıklıkla hem kavramsal anlayışı hem de Firebase hizmetlerinin pratik uygulamasını test eder. Aşağıdaki sorular 2026 yılında Flutter geliştirici mülakatlarında düzenli olarak ortaya çıkar.

**`authStateChanges()` ile `idTokenChanges()` ve `userChanges()` arasındaki fark nedir?**

`authStateChanges()` yalnızca giriş ve çıkış olaylarında tetiklenir. `idTokenChanges()` ayrıca kimlik jetonunun yenilenmesinde (yaklaşık her 60 dakikada) tetiklenir. `userChanges()` yukarıdakilerin tümünü ve `updateDisplayName()` gibi profil güncellemelerini yakalar. Çoğu navigasyon koruması için `authStateChanges()` yeterlidir.

**Cihaz çevrimdışıyken bir Firestore yazma işlemi gerçekleştiğinde ne olur?**

Yazma işlemi yerel önbellekte ve bekleyen yazmalar kuyruğunda saklanır. `snapshots()` dinleyicileri güncellenmiş verileri `metadata.hasPendingWrites == true` ile hemen alır. Bağlantı yeniden kurulduğunda, Firestore bekleyen yazmaları alan düzeyinde son yazan kazanır çatışma çözümlemesi kullanarak otomatik olarak senkronize eder.

**Bir sohbet uygulaması için Firestore veri modeli nasıl tasarlanmalıdır?**

Yaygın bir yaklaşım: her belgenin meta veri içerdiği (katılımcılar, son mesaj zaman damgası) bir `chats` koleksiyonu ve her sohbet belgesi altında bir `messages` alt koleksiyonu. Bu yapı, her konuşmadaki mesajları sayfalandırırken bir kullanıcının sohbet listesinin verimli bir şekilde sorgulanmasına olanak tanır. Liste görünümü için alt koleksiyonu okumaktan kaçınmak için son mesaj üst belgeye denormalize edilmelidir.

**`FieldValue.serverTimestamp()` neden `DateTime.now()` yerine tercih edilmelidir?**

`DateTime.now()` cihaz saatini kullanır ve bu saat yanlış veya manipüle edilmiş olabilir. `FieldValue.serverTimestamp()` Firestore sunucu saatini kullanarak tüm istemcilerde tutarlı sıralama garantiler. Bu, mesaj sıralama, etkinlik akışları ve denetim günlükleri gibi özellikler için önemlidir.

**Firestore'da bileşik sorgular nasıl işlenir ve dizin gereksinimleri nelerdir?**

Firestore, birden fazla alanı `where` ve `orderBy` yan tümceleriyle birleştiren sorgular için bileşik dizin gerektirir. Tek alanlı dizinler otomatik olarak oluşturulur, ancak bileşik dizinler `firestore.indexes.json` dosyasında veya Firebase konsolu aracılığıyla manuel olarak tanımlanmalıdır. Bir sorgu başarısız olduğunda, Firestore eksik dizini oluşturmak için doğrudan bir bağlantı kaydeder.

[Flutter ve Firebase mülakat hazırlığı](/technologies/flutter/interview-questions/firebase-integration) için daha fazla pratik malzemesi, bu konuları ayrıntılı açıklamalarla birlikte kapsayan interaktif modüllerde mevcuttur.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/flutter/flutter-firebase-authentication-firestore-2026