Strategi Pembuatan Cache - Amazon ElastiCache untuk Redis

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Strategi Pembuatan Cache

Pada topik berikut ini, Anda dapat menemukan strategi untuk mengisi dan memelihara cache Anda.

Strategi yang akan diterapkan untuk mengisi dan memelihara cache Anda akan tergantung pada data apa yang dibuat cache dan pola akses ke data itu. Misalnya, Anda kemungkinan tidak ingin menggunakan strategi yang sama untuk papan peringkat 10 teratas di situs game dan berita yang sedang tren. Di bagian yang tersisa dari bagian ini, kita akan membahas strategi pemeliharaan cache yang umum dengan kelebihan dan kekurangannya.

Pemuatan malas

Seperti namanya, pemuatan malas adalah strategi pembuatan cache yang memuat data ke dalam cache hanya jika diperlukan. Cara kerjanya adalah seperti dijelaskan berikut.

Amazon ElastiCache adalah penyimpanan nilai-kunci dalam memori yang berada di antara aplikasi Anda dan penyimpanan data (basis data) yang diaksesnya. Setiap kali aplikasi Anda meminta data, aplikasi pertama-tama akan membuat permintaan ke cache ElastiCache. Jika data terdapat di dalam cache dan data itu masih baru, maka ElastiCache mengembalikan data itu ke aplikasi Anda. Jika data tidak ada di dalam cache atau telah kedaluwarsa, maka aplikasi Anda akan meminta data dari penyimpanan data Anda. Penyimpanan data Anda kemudian mengembalikan data ke aplikasi Anda. Aplikasi Anda selanjutnya menulis data yang diterima dari penyimpanan ke cache. Dengan cara ini, data dapat lebih cepat diambil jika diminta lagi pada waktu berikutnya.

Cache kena terjadi ketika data ada di dalam cache dan tidak kedaluwarsa:

  1. Aplikasi Anda meminta data dari cache.

  2. Cache mengembalikan data ke aplikasi.

Cache meleset terjadi ketika data tidak berada di dalam cache dan kedaluwarsa:

  1. Aplikasi Anda meminta data dari cache.

  2. Cache tidak memiliki data yang diminta, sehingga mengembalikan null.

  3. Aplikasi Anda meminta dan menerima data dari basis data.

  4. Aplikasi Anda memperbarui cache dengan data baru.

Kelebihan dan kekurangan dari pemuatan malas

Kelebihan dari pemuatan malas adalah seperti berikut:

  • Hanya data yang diminta yang dibuat cache.

    Karena sebagian besar data tidak pernah diminta, pemuatan malas menghindari membuat cache terisi penuh oleh data yang tidak diminta.

  • Kegagalan simpul tidak menjadi fatal untuk aplikasi Anda.

    Ketika simpul gagal dan digantikan oleh simpul baru yang kosong, aplikasi Anda terus berfungsi, meskipun dengan peningkatan latensi. Karena permintaan dibuat ke simpul baru, setiap terjadi cache meleset mengakibatkan kueri ke basis data. Pada saat yang sama, salinan data ditambahkan ke cache sehingga permintaan berikutnya diambil dari cache.

Kelebihan dari pemuatan malas adalah seperti berikut:

  • Terjadi kerugian akibat cache meleset. Setiap cache meleset menyebabkan tiga perjalanan:

    1. Permintaan awal untuk data dari cache

    2. Kueri basis data untuk data

    3. Menulis data ke cache

    Kejadian meleset ini dapat menyebabkan penundaan yang terasa pada data yang masuk ke aplikasi.

  • Data yang usang.

    Jika data ditulis ke cache hanya bila ada cache meleset, maka data di dalam cache dapat menjadi usang. Hal ini terjadi karena ada tidak ada pembaruan pada cache ketika data berubah di dalam basis data. Untuk mengatasi masalah ini, Anda dapat menggunakan strategi Write-through dan Menambahkan TTL.

Contoh kode semu pemuatan malas

Berikut adalah contoh kode semu logika pemuatan malas.

// ***************************************** // function that returns a customer's record. // Attempts to retrieve the record from the cache. // If it is retrieved, the record is returned to the application. // If the record is not retrieved from the cache, it is // retrieved from the database, // added to the cache, and // returned to the application // ***************************************** get_customer(customer_id) customer_record = cache.get(customer_id) if (customer_record == null) customer_record = db.query("SELECT * FROM Customers WHERE id = {0}", customer_id) cache.set(customer_id, customer_record) return customer_record

Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.

customer_record = get_customer(12345)

Write-through

Strategi write-through menambahkan data atau pembaruan data ke dalam cache setiap kali data ditulis ke basis data.

Kelebihan dan kekurangan dari write-through

Kelebihan dari write-through adalah sebagai berikut:

  • Data dalam cache tidak pernah usang.

    Karena data dalam cache diperbarui setiap kali data itu ditulis ke basis data, maka data dalam cache selalu yang terbaru.

  • Kerugian tulis vs kerugian baca.

    Setiap proses tulis menyangkut dua perjalanan:

    1. Tulis ke cache

    2. Tulis ke basis data

    Yang menambahkan latensi pada proses. Namun, pengguna akhir umumnya lebih toleran terhadap latensi saat memperbarui data daripada saat mengambil data. Ada perasaan yang melekat bahwa memperbarui membutuhkan upaya lebih banyak dan karena itu memakan waktu lebih lama.

Kekurangan dari write-through adalah sebagai berikut:

  • Data yang hilang.

    Jika Anda membuat simpul baru, dengan alasan kegagalan simpul atau untuk penskalaan ke luar, maka akan ada data yang hilang. Data ini tetap hilang hingga ditambahkan atau diperbarui pada basis data. Anda dapat meminimalkan ini dengan menerapkan pemuatan malas dengan write-through.

  • Churn Cache.

    Sebagian besar data tidak pernah dibaca, yang merupakan pemborosan sumber daya. Dengan menambahkan nilai waktu untuk tayang (TTL), Anda dapat meminimalkan ruang penyimpanan yang terbuang.

Contoh kode semu Write-through

Berikut adalah contoh kode semu dari logika write-through.

// ***************************************** // function that saves a customer's record. // ***************************************** save_customer(customer_id, values) customer_record = db.query("UPDATE Customers WHERE id = {0}", customer_id, values) cache.set(customer_id, customer_record) return success

Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.

save_customer(12345,{"address":"123 Main"})

Menambahkan TTL

Pemuatan malas memungkinkan data menjadi usang tetapi tidak gagal dengan simpul kosong. Write-through memastikan data selalu segar, tetapi dapat gagal dengan simpul kosong dan dapat mengisi cache dengan data berlebihan yang tidak berguna. Dengan menambahkan nilai waktu untuk tayang (TTL) untuk setiap proses tulis, Anda dapat memiliki kelebihan dari setiap strategi. Pada saat yang sama, Anda dapat dan secara garis besar berhasil menghindari cache menjadi penuh dengan data tambahan.

Waktu untuk tayang (TTL) adalah nilai integer yang menentukan jumlah detik hingga kunci kedaluwarsa. Redis dapat menentukan detik atau milidetik untuk nilai ini. Ketika sebuah aplikasi mencoba untuk membaca kunci yang kedaluwarsa, maka perlakuannya adalah seolah-olah kunci itu tidak ditemukan. Terjadi kueri ke basis data untuk meminta kunci dan cache yang diperbarui. Pendekatan ini tidak menjamin sebuah nilai tidak menjadi usang. Namun, itu menjaga data agar tidak terlalu usang dan mensyaratkan nilai di dalam cache agar kadang-kadang disegarkan kembali dari basis data.

Untuk informasi selengkapnya, lihat perintah set Redis .

Contoh kode semu TTL

Berikut adalah contoh kode semu dari logika write-through dengan TTL.

// ***************************************** // function that saves a customer's record. // The TTL value of 300 means that the record expires // 300 seconds (5 minutes) after the set command // and future reads will have to query the database. // ***************************************** save_customer(customer_id, values) customer_record = db.query("UPDATE Customers WHERE id = {0}", customer_id, values) cache.set(customer_id, customer_record, 300) return success

Berikut adalah contoh kode semu logika pemuatan malas dengan TTL.

// ***************************************** // function that returns a customer's record. // Attempts to retrieve the record from the cache. // If it is retrieved, the record is returned to the application. // If the record is not retrieved from the cache, it is // retrieved from the database, // added to the cache, and // returned to the application. // The TTL value of 300 means that the record expires // 300 seconds (5 minutes) after the set command // and subsequent reads will have to query the database. // ***************************************** get_customer(customer_id) customer_record = cache.get(customer_id) if (customer_record != null) if (customer_record.TTL < 300) return customer_record // return the record and exit function // do this only if the record did not exist in the cache OR // the TTL was >= 300, i.e., the record in the cache had expired. customer_record = db.query("SELECT * FROM Customers WHERE id = {0}", customer_id) cache.set(customer_id, customer_record, 300) // update the cache return customer_record // return the newly retrieved record and exit function

Untuk contoh ini, kode aplikasi yang mengambil data adalah sebagai berikut.

save_customer(12345,{"address":"123 Main"})
customer_record = get_customer(12345)

Topik terkait