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 mengetren. 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 ElastiCache cache. 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 ada di dalam cache atau data sudah 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.

Kekurangan 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 data ke basis data

  3. Menulis data ke cache

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

• Data yang basi.

  Jika data ditulis ke cache hanya bila ada cache meleset, maka data di dalam cache dapat menjadi basi. 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 Tulis-semua (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)

Tulis-semua (write-through)

Strategi tulis-semua menambahkan data atau pembaruan data ke dalam cache setiap kali data ditulis ke basis data.

Kelebihan dan kekurangan dari tulis-semua

Kelebihan dari tulis-semua adalah sebagai berikut:

• Data dalam cache tidak pernah basi.

  Karena data dalam cache diperbarui setiap kali data itu ditulis ke basis data, maka data dalam cache selalu 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 tulis-semua adalah sebagai berikut:

• Data yang hilang.

  Jika Anda membuat simpul baru, dengan alasan kegagalan simpul atau untuk penskalaan keluar, 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 tulis-semua.

• Menyegarkan 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 tulis-semua

Berikut adalah contoh kode semu dari logika tulis-semua.

// *****************************************
// 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 basi tetapi tidak gagal dalam memastikan simpul selalu terisi. Tulis-semua 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 sebagian 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 basi. Namun, itu menjaga data agar tidak terlalu basi dan mensyaratkan nilai di dalam cache agar kadang-kadang disegarkan kembali dari basis data.

Untuk informasi lain, lihat perintah set Redis .

Contoh kode semu TTL

Berikut adalah contoh kode semu dari logika tulis-semua 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

• Penyimpanan Data Dalam Memori

• Memilih Mesin dan Versi

• Penskalaan ElastiCache untuk klaster Redis