Membuat Struktur Data untuk Konsistensi Kuat

Datastore memberikan ketersediaan, skalabilitas, dan ketahanan tinggi dengan mendistribusikan data ke banyak mesin dan menggunakan replikasi sinkron tanpa master di area geografis yang luas. Namun, konsekuensi dari desain ini adalah throughput operasi tulis untuk satu entity group dibatasi pada sekitar satu commit per detik. Ada juga batasan pada kueri atau transaksi yang mencakup beberapa entity group. Halaman ini menjelaskan batasan tersebut secara lebih mendetail dan membahas praktik terbaik dalam menyusun struktur data untuk mendukung konsistensi yang kuat sambil tetap memenuhi persyaratan throughput operasi tulis aplikasi Anda.

Tingkat konsistensi

Kueri Datastore dapat memberikan hasilnya pada salah satu dari dua tingkat konsistensi:

• Kueri Sangat konsisten menjamin hasil terbaru, tetapi mungkin memerlukan waktu lebih lama untuk diselesaikan atau mungkin tidak didukung dalam kasus tertentu.
• Kueri Konsistensi tertunda umumnya berjalan lebih cepat, tetapi terkadang dapat menampilkan hasil yang sudah tidak relevan.

Dalam kueri yang memiliki konsistensi tertunda, indeks yang digunakan untuk mengumpulkan hasil juga diakses dengan konsistensi tertunda. Akibatnya, kueri tersebut terkadang dapat menampilkan entity yang tidak lagi cocok dengan kriteria kueri, dan juga dapat menghilangkan entity yang cocok dengan kriteria kueri. Kueri yang sangat konsisten bersifat konsisten secara transaksional, yang berarti hasilnya didasarkan pada satu snapshot data yang konsisten.

Jaminan konsistensi

Kueri menampilkan hasilnya dengan tingkat jaminan konsistensi yang berbeda, bergantung pada sifat kueri:

• Kueri ancestor (yang dijalankan terhadap entity group) memiliki konsistensi kuat secara default, tetapi dapat memiliki konsistensi tertunda dengan menetapkan kebijakan baca Datastore (dibahas di bawah).
• Kueri global (yang tidak dijalankan terhadap grup entity) selalu memiliki konsistensi tertunda.

Di banyak aplikasi, Anda dapat menggunakan konsistensi pada akhirnya (yaitu, kueri global yang mencakup beberapa grup entity, yang terkadang dapat menampilkan data yang sedikit tidak terbaru) saat mendapatkan tampilan luas data yang tidak terkait, lalu menggunakan konsistensi yang kuat (kueri ancestor, atau pencarian satu entity) saat melihat atau mengedit satu set data yang sangat terkait. Dalam penerapan semacam itu, sebaiknya Anda menempatkan data yang sangat terkait dalam entity group. Jumlah grup entity yang lebih tinggi akan meningkatkan throughput, sedangkan jumlah grup entity yang lebih rendah akan meningkatkan volume entity yang dapat dibaca dalam satu kueri turunan. Aplikasi harus mempertimbangkan hal ini untuk menentukan keseimbangan throughput dan konsistensi yang tepat.

Kebijakan baca Datastore

Untuk meningkatkan performa, Anda dapat menetapkan kebijakan baca kueri sehingga hasilnya memiliki konsistensi tertunda. (Datastore API juga memungkinkan Anda menetapkan kebijakan konsistensi kuat secara eksplisit, tetapi setelan ini tidak memiliki dampak praktis karena kueri global selalu memiliki konsistensi tertunda, terlepas dari kebijakannya.)

Anda dapat mengaktifkan pembacaan yang konsisten pada akhirnya melalui opsi baca objek kueri:

Query query = new Query("Task")
{
    Filter = Filter.HasAncestor(_db.CreateKeyFactory("TaskList")
        .CreateKey(keyName))
};
var results = _db.RunQuery(query,
    ReadOptions.Types.ReadConsistency.Eventual);

ancestor := datastore.NameKey("TaskList", "default", nil)
query := datastore.NewQuery("Task").Ancestor(ancestor).EventualConsistency()

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            PropertyFilter.hasAncestor(
                datastore.newKeyFactory().setKind("TaskList").newKey("default")))
        .build();
datastore.run(query, ReadOption.eventualConsistency());

const ancestorKey = datastore.key(['TaskList', 'default']);
const query = datastore.createQuery('Task').hasAncestor(ancestorKey);

query.run({consistency: 'eventual'});

$query = $datastore->query()
    ->kind('Task')
    ->hasAncestor($datastore->key('TaskList', 'default'));
$result = $datastore->runQuery($query, ['readConsistency' => 'EVENTUAL']);

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query = client.query(kind="Task")
query.fetch(eventual=True)

# task_list_name = "default"
ancestor_key = datastore.key "TaskList", task_list_name

query = datastore.query("Task")
                 .ancestor(ancestor_key)

tasks = datastore.run query, consistency: :eventual

Pertimbangan transaksi dan konsistensi

Penerapan Datastore bersifat transaksional, yang berarti terjadi dalam konteks transaksi dan kumpulan mutasi transaksi semuanya diterapkan atau tidak diterapkan sama sekali, atau non-transaksional, yang berarti kumpulan mutasi mungkin tidak diterapkan semuanya atau tidak sama sekali.

Satu transaksi dapat mencakup sejumlah mutasi pembuatan, pembaruan, atau penghapusan. Untuk menjaga konsistensi data, transaksi tersebut memastikan bahwa semua mutasi yang ada di dalamnya diterapkan ke Datastore sebagai unit atau, jika salah satu mutasi gagal, tidak ada satu pun mutasi yang diterapkan. Selain itu, semua pembacaan dengan konsistensi kuat (kueri ancestor atau operasi lookup) yang dilakukan dalam transaksi yang sama mengandalkan satu snapshot data yang konsisten. Kueri yang sangat konsisten harus menentukan filter ancestor. Kueri yang berpartisipasi dalam transaksi selalu memiliki konsistensi kuat. Transaksi dapat melibatkan maksimal 25 entity group. Operasi baca yang konsisten pada akhirnya tidak memiliki batasan tersebut, dan cukup memadai dalam banyak kasus. Dengan menggunakan operasi baca yang konsisten, Anda dapat mendistribusikan data ke lebih banyak entity group, sehingga Anda dapat memperoleh throughput operasi tulis yang lebih besar dengan mengeksekusi commit secara paralel pada entity group yang berbeda. Namun, Anda perlu memahami karakteristik operasi baca yang konsisten agar dapat menentukan apakah operasi baca tersebut cocok untuk aplikasi Anda:

• Hasil dari operasi baca ini mungkin tidak mencerminkan transaksi terbaru. Hal ini dapat terjadi karena operasi baca ini tidak memastikan bahwa replika tempatnya berjalan sudah yang terbaru. Sebagai gantinya, model ini menggunakan data apa pun yang tersedia di replika tersebut pada saat mengeksekusi kueri.
• Transaksi yang di-commit dan mencakup beberapa entity group mungkin terlihat telah diterapkan ke beberapa entity dan tidak untuk entity yang lainnya. Namun, perlu diperhatikan bahwa transaksi tidak akan pernah diterapkan sebagian dalam satu entity.
• Hasil kueri dapat menyertakan entity yang seharusnya tidak disertakan sesuai dengan kriteria filter, dan dapat mengecualikan entity yang seharusnya disertakan. Hal ini dapat terjadi karena versi snapshot yang digunakan untuk membaca indeks mungkin berbeda dengan versi snapshot yang digunakan untuk membaca entity.

Menyusun data untuk konsistensi

Untuk memahami cara menyusun data Anda demi konsistensi yang kuat, bandingkan dua pendekatan yang berbeda untuk aplikasi daftar tugas yang sederhana. Pendekatan pertama membuat setiap entity dalam grup entity barunya sendiri (yaitu, setiap entity adalah entity root):

Entity task = new Entity()
{
    Key = _db.CreateKeyFactory("Task").CreateKey("sampleTask"),
    ["category"] = "Personal",
    ["done"] = false,
    ["priority"] = 4,
    ["description"] = "Learn Cloud Datastore"
};

type Task struct {
	Category        string
	Done            bool
	Priority        float64
	Description     string `datastore:",noindex"`
	PercentComplete float64
	Created         time.Time
}
task := &Task{
	Category:        "Personal",
	Done:            false,
	Priority:        4,
	Description:     "Learn Cloud Datastore",
	PercentComplete: 10.0,
	Created:         time.Now(),
}

Key taskKey = datastore.newKeyFactory().setKind("Task").newKey("sampleTask");
Entity task =
    Entity.newBuilder(taskKey)
        .set("category", "Personal")
        .set("done", false)
        .set("priority", 4)
        .set("description", "Learn Cloud Datastore")
        .build();

const task = {
  category: 'Personal',
  done: false,
  priority: 4,
  description: 'Learn Cloud Datastore',
};

$task = $datastore->entity('Task', [
    'category' => 'Personal',
    'done' => false,
    'priority' => 4,
    'description' => 'Learn Cloud Datastore'
]);

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

task = datastore.Entity(client.key("Task"))
task.update(
    {
        "category": "Personal",
        "done": False,
        "priority": 4,
        "description": "Learn Cloud Datastore",
    }
)

task = datastore.entity "Task" do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 4
  t["description"] = "Learn Cloud Datastore"
end

Kemudian, kueri dilakukan pada jenis entity Task untuk tugas yang belum selesai dengan prioritas lebih besar dari atau sama dengan 4, yang diurutkan dalam urutan menurun berdasarkan prioritas:

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.Equal("done", false),
        Filter.GreaterThanOrEqual("priority", 4)),
    Order = { { "priority", PropertyOrder.Types.Direction.Descending } }
};

query := datastore.NewQuery("Task").
	FilterField("Done", "=", false).
	FilterField("Priority", ">=", 4).
	Order("-Priority")

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.eq("done", false), PropertyFilter.ge("priority", 4)))
        .setOrderBy(OrderBy.desc("priority"))
        .build();

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('done', '=', false),
      new PropertyFilter('priority', '>=', 4),
    ]),
  )
  .order('priority', {
    descending: true,
  });

$query = $datastore->query()
    ->kind('Task')
    ->filter('done', '=', false)
    ->filter('priority', '>=', 4)
    ->order('priority', Query::ORDER_DESCENDING);

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("done", "=", False))
query.add_filter(filter=datastore.query.PropertyFilter("priority", ">=", 4))
query.order = ["-priority"]

query = datastore.query("Task")
                 .where("done", "=", false)
                 .where("priority", ">=", 4)
                 .order("priority", :desc)

Namun, karena kita menggunakan kueri yang konsisten pada akhirnya (bukan kueri ancestor), hasil kueri mungkin tidak berisi entity baru. Meskipun demikian, hampir semua operasi tulis akan tersedia untuk kueri konsistensi tertunda segera setelah commit. Untuk banyak aplikasi, solusi yang memberikan hasil kueri dengan konsistensi tertunda dalam konteks perubahan pengguna saat ini biasanya akan cukup untuk membuat latensi tersebut dapat diterima sepenuhnya.

Untuk mencapai konsistensi yang kuat, pendekatan yang lebih baik adalah membuat entitas dengan jalur ancestor. Jalur ancestor mengidentifikasi root entity umum tempat entity yang dibuat dikelompokkan. Contoh ini menggunakan jalur ancestor jenis TaskList bernama default:

Key taskListKey = _db.CreateKeyFactory("TaskList").CreateKey(TestUtil.RandomName());
Key taskKey = new KeyFactory(taskListKey, "Task").CreateKey("sampleTask");
Entity task = new Entity()
{
    Key = taskKey,
    ["category"] = "Personal",
    ["done"] = false,
    ["priority"] = 4,
    ["description"] = "Learn Cloud Datastore"
};

parentKey := datastore.NameKey("TaskList", "default", nil)
key := datastore.IncompleteKey("Task", parentKey)

task := Task{
	Category:    "Personal",
	Done:        false,
	Priority:    4,
	Description: "Learn Cloud Datastore",
}

// A complete key is assigned to the entity when it is Put.
var err error
key, err = client.Put(ctx, key, &task)

Key taskKey =
    datastore
        .newKeyFactory()
        .addAncestors(PathElement.of("TaskList", "default"))
        .setKind("Task")
        .newKey("sampleTask");
Entity task =
    Entity.newBuilder(taskKey)
        .set("category", "Personal")
        .set("done", false)
        .set("priority", 4)
        .set("description", "Learn Cloud Datastore")
        .build();

const taskKey = datastore.key([
  'TaskList',
  'default',
  'Task',
  'sampleTask',
]);

const task = {
  key: taskKey,
  data: {
    category: 'Personal',
    done: false,
    priority: 4,
    description: 'Learn Cloud Datastore',
  },
};

$parentKey = $datastore->key('TaskList', 'default');
$key = $datastore->key('Task')->ancestorKey($parentKey);
$task = $datastore->entity(
    $key,
    [
        'Category' => 'Personal',
        'Done' => false,
        'Priority' => 4,
        'Description' => 'Learn Cloud Datastore'
    ]
);

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

key_with_parent = client.key("TaskList", "default", "Task", "sampleTask")

task = datastore.Entity(key=key_with_parent)

task.update(
    {
        "category": "Personal",
        "done": False,
        "priority": 4,
        "description": "Learn Cloud Datastore",
    }
)

# task_list_name = "default"
# task_name = "sampleTask"
task_key = datastore.key [["TaskList", task_list_name], ["Task", task_name]]

task = datastore.entity task_key do |t|
  t["category"] = "Personal"
  t["done"] = false
  t["priority"] = 4
  t["description"] = "Learn Cloud Datastore"
end

Selanjutnya, Anda dapat menjalankan kueri ancestor yang sangat konsisten dalam entity group yang diidentifikasi oleh root entity umum:

Query query = new Query("Task")
{
    Filter = Filter.HasAncestor(_db.CreateKeyFactory("TaskList")
        .CreateKey(keyName))
};

ancestor := datastore.NameKey("TaskList", "default", nil)
query := datastore.NewQuery("Task").Ancestor(ancestor)

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            PropertyFilter.hasAncestor(
                datastore.newKeyFactory().setKind("TaskList").newKey("default")))
        .build();

const ancestorKey = datastore.key(['TaskList', 'default']);

const query = datastore.createQuery('Task').hasAncestor(ancestorKey);

$ancestorKey = $datastore->key('TaskList', 'default');
$query = $datastore->query()
    ->kind('Task')
    ->hasAncestor($ancestorKey);

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

# Query filters are omitted in this example as any ancestor queries with a
# non-key filter require a composite index.
ancestor = client.key("TaskList", "default")
query = client.query(kind="Task", ancestor=ancestor)

# task_list_name = "default"
ancestor_key = datastore.key "TaskList", task_list_name

query = datastore.query("Task")
                 .ancestor(ancestor_key)

Pendekatan ini mencapai konsistensi yang kuat dengan melakukan operasi tulis ke satu entity group per daftar tugas, tetapi juga membatasi perubahan pada daftar tugas agar tidak lebih dari 1 operasi tulis per detik (batas yang didukung untuk entity group). Jika aplikasi Anda kemungkinan akan mengalami penggunaan penulisan yang lebih berat, Anda mungkin perlu mempertimbangkan untuk menggunakan cara lain. Misalnya, jika aplikasi Anda adalah buku tamu yang memungkinkan pengguna memposting pesan ke papan pesan publik, Anda dapat menempatkan postingan terbaru di memcache dengan masa berlaku dan menampilkan campuran postingan terbaru dari memcache dan Datastore, atau Anda dapat menyimpan postingan tersebut dalam cookie, menempatkan beberapa status di URL, atau hal lainnya. Tujuannya adalah untuk menemukan solusi penyimpanan data ke dalam cache yang menyediakan data untuk pengguna saat ini ketika mereka memposting ke aplikasi Anda. Ingat, jika Anda melakukan lookup, kueri ancestor (dengan asumsi kebijakan baca tidak disetel ke konsistensi tertunda), atau operasi apa pun dalam transaksi, Anda akan selalu melihat data tertulis terbaru.

Untuk contoh tambahan tentang cara menggunakan transaksi, buka di sini.

Batasan grup entitas pada transaksi

Pengaturan data ke dalam entity group dapat membatasi transaksi yang dapat dilakukan:

• Semua data yang diakses oleh transaksi harus berada dalam maksimal 25 entity group.
• Jika Anda ingin menggunakan kueri dalam transaksi, data Anda harus diatur ke dalam entity group sedemikian rupa sehingga Anda dapat menentukan filter ancestor yang akan cocok dengan data yang tepat.
• Ada batas throughput operasi tulis sekitar satu transaksi per detik untuk satu entity group. Batasan ini diberikan karena Datastore melakukan replikasi sinkron tanpa master untuk setiap entity group di area geografis yang luas guna memberikan keandalan dan fault tolerance yang tinggi.

Untuk mengetahui informasi selengkapnya tentang cara entity dan indeks diperbarui, lihat artikel Transaction Isolation.