Verileri Kaydetme

Bu belgede, Firebase Realtime Database veritabanınıza veri yazmak için kullanabileceğiniz dört yöntem ele alınmaktadır: set, update, push ve işlem desteği.

Veri Tasarrufu Yapmanın Yolları

set	Tanımlı bir yola (ör. messages/users/<username>) veri yazma veya verileri değiştirme
update	Tüm verileri değiştirmeden, tanımlı bir yolun anahtarlarından bazılarını güncelleme
push	Veritabanındaki veri listesine ekleme Bir listeye her yeni düğüm eklediğinizde veritabanınız messages/users/<unique-user-id>/<username> gibi benzersiz bir anahtar oluşturur.
işlem	Eşzamanlı güncellemeler nedeniyle bozulabilecek karmaşık verilerle çalışırken işlemleri kullanma

Veri Tasarrufu

Temel veritabanı yazma işlemi, yeni verileri belirtilen veritabanı referansına kaydeden ve bu yoldaki mevcut verileri değiştiren bir kümedir. Set yöntemini anlamak için basit bir blog uygulaması oluşturacağız. Uygulamanızın verileri şu veritabanı referansında depolanır:

Java

final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");

Node.js

// Import Admin SDK
const { getDatabase } = require('firebase-admin/database');

// Get a database reference to our blog
const db = getDatabase();
const ref = db.ref('server/saving-data/fireblog');

Python

# Import database module.
from firebase_admin import db

# Get a database reference to our blog.
ref = db.reference('server/saving-data/fireblog')

Go

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our blog.
ref := client.NewRef("server/saving-data/fireblog")

Öncelikle bazı kullanıcı verilerini kaydedelim. Her kullanıcıyı benzersiz bir kullanıcı adıyla saklarız. Ayrıca kullanıcıların tam adını ve doğum tarihini de saklarız. Her kullanıcının benzersiz bir kullanıcı adı olacağından, anahtarınız zaten olduğu ve yeni bir anahtar oluşturmanız gerekmediği için burada push yöntemi yerine set yöntemini kullanmak mantıklıdır.

Öncelikle kullanıcı verileriniz için bir veritabanı referansı oluşturun. Ardından, kullanıcının kullanıcı adı, tam adı ve doğum günüyle birlikte bir kullanıcı nesnesini veritabanına kaydetmek için set() / setValue() kullanın. Dize, sayı, boole, null, dizi veya herhangi bir JSON nesnesi ayarlayabilirsiniz. null değerini iletmek, belirtilen konumdaki verileri kaldırır. Bu durumda bir nesne iletirsiniz:

Java

public static class User {

  public String date_of_birth;
  public String full_name;
  public String nickname;

  public User(String dateOfBirth, String fullName) {
    // ...
  }

  public User(String dateOfBirth, String fullName, String nickname) {
    // ...
  }

}

DatabaseReference usersRef = ref.child("users");

Map<String, User> users = new HashMap<>();
users.put("alanisawesome", new User("June 23, 1912", "Alan Turing"));
users.put("gracehop", new User("December 9, 1906", "Grace Hopper"));

usersRef.setValueAsync(users);

Node.js

const usersRef = ref.child('users');
usersRef.set({
  alanisawesome: {
    date_of_birth: 'June 23, 1912',
    full_name: 'Alan Turing'
  },
  gracehop: {
    date_of_birth: 'December 9, 1906',
    full_name: 'Grace Hopper'
  }
});

Python

users_ref = ref.child('users')
users_ref.set({
    'alanisawesome': {
        'date_of_birth': 'June 23, 1912',
        'full_name': 'Alan Turing'
    },
    'gracehop': {
        'date_of_birth': 'December 9, 1906',
        'full_name': 'Grace Hopper'
    }
})

Go

// User is a json-serializable type.
type User struct {
	DateOfBirth string `json:"date_of_birth,omitempty"`
	FullName    string `json:"full_name,omitempty"`
	Nickname    string `json:"nickname,omitempty"`
}

usersRef := ref.Child("users")
err := usersRef.Set(ctx, map[string]*User{
	"alanisawesome": {
		DateOfBirth: "June 23, 1912",
		FullName:    "Alan Turing",
	},
	"gracehop": {
		DateOfBirth: "December 9, 1906",
		FullName:    "Grace Hopper",
	},
})
if err != nil {
	log.Fatalln("Error setting value:", err)
}

Bir JSON nesnesi veritabanına kaydedildiğinde nesne özellikleri, otomatik olarak veritabanı alt konumlarıyla iç içe yerleştirilmiş şekilde eşlenir. Şimdi https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name URL'sine giderseniz "Alan Turing" değerini görürsünüz. Verileri doğrudan bir alt konuma da kaydedebilirsiniz:

Java

usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));

Node.js

const usersRef = ref.child('users');
usersRef.child('alanisawesome').set({
  date_of_birth: 'June 23, 1912',
  full_name: 'Alan Turing'
});
usersRef.child('gracehop').set({
  date_of_birth: 'December 9, 1906',
  full_name: 'Grace Hopper'
});

Python

users_ref.child('alanisawesome').set({
    'date_of_birth': 'June 23, 1912',
    'full_name': 'Alan Turing'
})
users_ref.child('gracehop').set({
    'date_of_birth': 'December 9, 1906',
    'full_name': 'Grace Hopper'
})

Go

if err := usersRef.Child("alanisawesome").Set(ctx, &User{
	DateOfBirth: "June 23, 1912",
	FullName:    "Alan Turing",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

if err := usersRef.Child("gracehop").Set(ctx, &User{
	DateOfBirth: "December 9, 1906",
	FullName:    "Grace Hopper",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

Yukarıdaki iki örnekte (her iki değeri aynı anda nesne olarak yazma ve alt konumlara ayrı ayrı yazma) veritabanınıza aynı veriler kaydedilir:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper"
    }
  }
}

İlk örnek, verileri izleyen istemcilerde yalnızca bir etkinliği tetiklerken ikinci örnek iki etkinliği tetikler. usersRef konumunda zaten veri varsa ilk yaklaşımın bu verilerin üzerine yazacağını, ikinci yöntemin ise yalnızca her bir alt düğümün değerini değiştirirken usersRef konumunun diğer alt düğümlerini değiştirmeyeceğini unutmayın.

Değer ayarlandığında, alt düğümler de dahil olmak üzere belirtilen konumdaki verilerin üzerine yazılır.

Kayıtlı Veriler Güncelleniyor

Diğer alt düğümlerin üzerine yazmadan bir veritabanı konumunun birden fazla alt düğümüne aynı anda yazmak istiyorsanız güncelleme yöntemini aşağıda gösterildiği gibi kullanabilirsiniz:

Java

DatabaseReference hopperRef = usersRef.child("gracehop");
Map<String, Object> hopperUpdates = new HashMap<>();
hopperUpdates.put("nickname", "Amazing Grace");

hopperRef.updateChildrenAsync(hopperUpdates);

Node.js

const usersRef = ref.child('users');
const hopperRef = usersRef.child('gracehop');
hopperRef.update({
  'nickname': 'Amazing Grace'
});

Python

hopper_ref = users_ref.child('gracehop')
hopper_ref.update({
    'nickname': 'Amazing Grace'
})

Go

hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

Bu işlem, Grace'in verilerini takma adını içerecek şekilde günceller. Burada update yerine set kullansaydınız hopperRef koleksiyonunuzdan hem full_name hem de date_of_birth silinirdi.

Firebase Realtime Database, çok yollu güncellemeleri de destekler. Bu, güncelleme işleminin artık veritabanınızdaki birden fazla konumda bulunan değerleri aynı anda güncelleyebileceği anlamına gelir. Bu güçlü özellik, verilerinizi normalleştirmenize yardımcı olur. Çok yollu güncellemeleri kullanarak hem Grace hem de Alan'a aynı anda takma ad ekleyebilirsiniz:

Java

Map<String, Object> userUpdates = new HashMap<>();
userUpdates.put("alanisawesome/nickname", "Alan The Machine");
userUpdates.put("gracehop/nickname", "Amazing Grace");

usersRef.updateChildrenAsync(userUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome/nickname': 'Alan The Machine',
  'gracehop/nickname': 'Amazing Grace'
});

Python

users_ref.update({
    'alanisawesome/nickname': 'Alan The Machine',
    'gracehop/nickname': 'Amazing Grace'
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome/nickname": "Alan The Machine",
	"gracehop/nickname":      "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Bu güncellemeden sonra hem Alan hem de Grace'in takma adları eklenir:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing",
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper",
      "nickname": "Amazing Grace"
    }
  }
}

Yolları dahil edilmiş nesneleri yazarak nesneleri güncellemeye çalışmanın farklı bir davranışla sonuçlanacağını unutmayın. Bunun yerine Grace ve Alan'ı şu şekilde güncellemeye çalışırsanız ne olacağına bakalım:

Java

Map<String, Object> userNicknameUpdates = new HashMap<>();
userNicknameUpdates.put("alanisawesome", new User(null, null, "Alan The Machine"));
userNicknameUpdates.put("gracehop", new User(null, null, "Amazing Grace"));

usersRef.updateChildrenAsync(userNicknameUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome': {
    'nickname': 'Alan The Machine'
  },
  'gracehop': {
    'nickname': 'Amazing Grace'
  }
});

Python

users_ref.update({
    'alanisawesome': {
        'nickname': 'Alan The Machine'
    },
    'gracehop': {
        'nickname': 'Amazing Grace'
    }
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome": &User{Nickname: "Alan The Machine"},
	"gracehop":      &User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Bu durum, farklı bir davranışa neden olur. Yani tüm /users düğümünün üzerine yazılır:

{
  "users": {
    "alanisawesome": {
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "nickname": "Amazing Grace"
    }
  }
}

İç içe yerleştirilmiş verileri güncelleme

alanisawesome gibi tek bir anahtar yolu verildiğinde yalnızca ilk alt düzeydeki veriler güncellenir ve ilk alt düzeyden sonra iletilen tüm veriler bir küme işlemi olarak değerlendirilir. Çoklu yol davranışı, verilerin üzerine yazılmadan daha uzun yolların (alanisawesome/nickname gibi) kullanılmasına olanak tanır. İlk örneğin ikinci örnekten farklı olmasının nedeni budur.

Tamamlama Geri Çağırması Ekleme

Node.js ve Java Admin SDK'larında, verilerinizin ne zaman kaydedildiğini öğrenmek istiyorsanız bir tamamlama geri çağırma işlevi ekleyebilirsiniz. Bu SDK'lardaki hem set hem de update yöntemleri, yazma işlemi veritabanına kaydedildiğinde çağrılan isteğe bağlı bir tamamlama geri çağırma işlevi alır. Çağrı herhangi bir nedenle başarısız olursa geri çağırmaya, hatanın nedenini belirten bir hata nesnesi iletilir. Python ve Go Admin SDK'larında tüm yazma yöntemleri engellenir. Yani yazma yöntemleri, yazma işlemleri veritabanına kaydedilene kadar sonuç döndürmez.

Java

DatabaseReference dataRef = ref.child("data");
dataRef.setValue("I'm writing data", new DatabaseReference.CompletionListener() {
  @Override
  public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
    if (databaseError != null) {
      System.out.println("Data could not be saved " + databaseError.getMessage());
    } else {
      System.out.println("Data saved successfully.");
    }
  }
});

Node.js

dataRef.set('I\'m writing data', (error) => {
  if (error) {
    console.log('Data could not be saved.' + error);
  } else {
    console.log('Data saved successfully.');
  }
});

Veri Listelerini Kaydetme

Veri listeleri oluştururken çoğu uygulamanın çok kullanıcılı yapısını göz önünde bulundurmanız ve liste yapınızı buna göre ayarlamanız önemlidir. Yukarıdaki örneği genişleterek uygulamanıza blog yayınları ekleyelim. İlk olarak, çocukları otomatik olarak artan tam sayı dizinleriyle depolamak için set kullanmayı düşünebilirsiniz. Örneğin:

// NOT RECOMMENDED - use push() instead!
{
  "posts": {
    "0": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "1": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

Push ve işlem karşılaştırması

Veri listeleriyle çalışırken push(), benzersiz ve kronolojik bir anahtar sağlar. Kendi anahtarlarınızı oluşturmak için işlem kullanmak isteyebilirsiniz ancak push çok daha iyi bir seçenektir. İşlemler daha yavaş ve daha karmaşıktır. Sunucuya bir veya daha fazla gidiş dönüş gerektirirler. İstemcide `push()` tarafından oluşturulan bir anahtar, çevrimdışıyken çalışır ve performans için optimize edilmiştir.

Kullanıcı yeni bir yayın eklerse bu yayın /posts/2 olarak depolanır. Bu yöntem, yalnızca tek bir yazar yayın ekliyorsa işe yarar. Ancak ortak çalışmaya dayalı blog uygulamanızda birçok kullanıcı aynı anda yayın ekleyebilir. İki yazar aynı anda /posts/2 dosyasına yazarsa yayınlardan biri diğeri tarafından silinir.

Bu sorunu çözmek için Firebase istemcileri, her yeni alt öğe için benzersiz bir anahtar oluşturan bir push() işlevi sağlar. Benzersiz alt anahtarlar kullanıldığında, birden fazla istemci yazma çakışmaları konusunda endişelenmeden aynı konuma aynı anda alt öğeler ekleyebilir.

Java

public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

DatabaseReference postsRef = ref.child("posts");

DatabaseReference newPostRef = postsRef.push();
newPostRef.setValueAsync(new Post("gracehop", "Announcing COBOL, a New Programming Language"));

// We can also chain the two calls together
postsRef.push().setValueAsync(new Post("alanisawesome", "The Turing Machine"));

Node.js

const newPostRef = postsRef.push();
newPostRef.set({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});

// we can also chain the two calls together
postsRef.push().set({
  author: 'alanisawesome',
  title: 'The Turing Machine'
});

Python

posts_ref = ref.child('posts')

new_post_ref = posts_ref.push()
new_post_ref.set({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

# We can also chain the two calls together
posts_ref.push().set({
    'author': 'alanisawesome',
    'title': 'The Turing Machine'
})

Go

// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

postsRef := ref.Child("posts")

newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

if err := newPostRef.Set(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, &Post{
	Author: "alanisawesome",
	Title:  "The Turing Machine",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

Benzersiz anahtar, zaman damgasına dayalı olduğundan liste öğeleri otomatik olarak kronolojik sıraya göre sıralanır. Firebase her blog yayını için benzersiz bir anahtar oluşturduğundan, birden fazla kullanıcı aynı anda yayın eklese bile yazma çakışması olmaz. Veritabanı verileriniz artık şu şekilde görünür:

{
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "-JRHTHaKuITFIhnj02kE": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

JavaScript, Python ve Go'da push() işlevini ve hemen ardından set() işlevini çağırma kalıbı o kadar yaygındır ki Firebase SDK'sı, ayarlanacak verileri doğrudan push() işlevine aşağıdaki gibi ileterek bu iki işlevi birleştirmenize olanak tanır:

Java

// No Java equivalent

Node.js

// This is equivalent to the calls to push().set(...) above
postsRef.push({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});;

Python

# This is equivalent to the calls to push().set(...) above
posts_ref.push({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

Go

if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

push() tarafından oluşturulan benzersiz anahtarı alma

push() çağrısı, yeni veri yoluna bir referans döndürür. Bu referansı, anahtarı almak veya anahtara veri ayarlamak için kullanabilirsiniz. Aşağıdaki kod, yukarıdaki örnekle aynı verileri döndürür ancak bu kez oluşturulan benzersiz anahtara erişebiliriz:

Java

// Generate a reference to a new location and add some data using push()
DatabaseReference pushedPostRef = postsRef.push();

// Get the unique ID generated by a push()
String postId = pushedPostRef.getKey();

Node.js

// Generate a reference to a new location and add some data using push()
const newPostRef = postsRef.push();

// Get the unique key generated by push()
const postId = newPostRef.key;

Python

# Generate a reference to a new location and add some data using push()
new_post_ref = posts_ref.push()

# Get the unique key generated by push()
post_id = new_post_ref.key

Go

// Generate a reference to a new location and add some data using Push()
newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

// Get the unique key generated by Push()
postID := newPostRef.Key

Gördüğünüz gibi, benzersiz anahtarın değerini push() referansınızdan alabilirsiniz.

Veri Alma ile ilgili bir sonraki bölümde, bu verileri Firebase veritabanından nasıl okuyacağımızı öğreneceğiz.

İşlem Verilerini Kaydetme

SDK, artımlı sayaçlar gibi eşzamanlı değişiklikler nedeniyle bozulabilecek karmaşık verilerle çalışırken bir işlem operasyonu sağlar.

Java ve Node.js'de işlem operasyonuna iki geri çağırma verirsiniz: bir güncelleme işlevi ve isteğe bağlı bir tamamlama geri çağırması. Python ve Go'da işlem, engelleme işlemi olduğundan yalnızca güncelleme işlevini kabul eder.

Güncelleme işlevi, verilerin mevcut durumunu bağımsız değişken olarak alır ve yazmak istediğiniz yeni durumu döndürür. Örneğin, belirli bir blog yayınındaki olumlu oy sayısını artırmak istiyorsanız aşağıdaki gibi bir işlem yazarsınız:

Java

DatabaseReference upvotesRef = ref.child("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.runTransaction(new Transaction.Handler() {
  @Override
  public Transaction.Result doTransaction(MutableData mutableData) {
    Integer currentValue = mutableData.getValue(Integer.class);
    if (currentValue == null) {
      mutableData.setValue(1);
    } else {
      mutableData.setValue(currentValue + 1);
    }

    return Transaction.success(mutableData);
  }

  @Override
  public void onComplete(
      DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) {
    System.out.println("Transaction completed");
  }
});

Node.js

const upvotesRef = db.ref('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes');
upvotesRef.transaction((current_value) => {
  return (current_value || 0) + 1;
});

Python

def increment_votes(current_value):
    return current_value + 1 if current_value else 1

upvotes_ref = db.reference('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes')
try:
    new_vote_count = upvotes_ref.transaction(increment_votes)
    print('Transaction completed')
except db.TransactionAbortedError:
    print('Transaction failed to commit')

Go

fn := func(t db.TransactionNode) (interface{}, error) {
	var currentValue int
	if err := t.Unmarshal(&currentValue); err != nil {
		return nil, err
	}
	return currentValue + 1, nil
}

ref := client.NewRef("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes")
if err := ref.Transaction(ctx, fn); err != nil {
	log.Fatalln("Transaction failed to commit:", err)
}

Yukarıdaki örnekte, varsayılan değer yazılmamışsa işlemler null ile çağrılabileceğinden sayacın null olup olmadığı veya henüz artırılıp artırılmadığı kontrol edilir.

Yukarıdaki kod bir işlem işlevi olmadan çalıştırılsaydı ve iki istemci aynı anda değeri artırmaya çalışsaydı her ikisi de yeni değer olarak 1 yazardı. Bu da iki artış yerine bir artışla sonuçlanırdı.

İşlem İşlevi Birden Fazla Kez Çağrılıyor

İşlem işleyiciniz birden çok kez çağrılır ve null verilerini işleyebilmelidir. Veritabanınızda mevcut veriler olsa bile işlem işlevi çalıştırıldığında bu veriler yerel olarak önbelleğe alınmayabilir.

Ağ Bağlantısı ve Çevrimdışı Yazma

Node.js ve Java'da bir istemcinin ağ bağlantısı kesilirse uygulamanız düzgün şekilde çalışmaya devam eder. Python ve Go Admin SDK'ları, veritabanı sunucusuyla iletişim kurmak için Firebase REST API'yi kullandığından ağ bağlantısı gerektirir. Ağ bağlantısı olmadan Python veya Go Admin SDK'larında veritabanı işlemlerini çağırmak istisnalara neden olur.

Firebase Node.js ve Java istemcileri, etkin verilerin kendi dahili sürümlerini korur. Veriler yazıldığında önce bu yerel sürüme yazılır. İstemci daha sonra bu verileri veritabanıyla ve diğer istemcilerle "en iyi çaba" temelinde senkronize eder.

Sonuç olarak, veritabanına yapılan tüm yazma işlemleri, veritabanına herhangi bir veri yazılmadan önce yerel etkinlikleri hemen tetikler. Yani Firebase kullanarak bir uygulama yazdığınızda uygulamanız, ağ gecikmesi veya internet bağlantısı ne olursa olsun yanıt vermeye devam eder.

Bağlantı yeniden kurulduğunda, istemcinin herhangi bir özel kod yazmak zorunda kalmadan mevcut sunucu durumunu "yakalaması" için uygun etkinlik grubunu alırız.

Verilerinizin Güvenliğini Sağlama

Firebase Realtime Database, verilerinizin farklı düğümlerine hangi kullanıcıların okuma ve yazma erişimi olduğunu tanımlamanıza olanak tanıyan bir güvenlik diline sahiptir. Bu konu hakkında daha fazla bilgiyi Verilerinizi Güvende Tutma başlıklı makalede bulabilirsiniz.