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 bergantung pada data apa yang disimpan ke cache dan pola akses ke data tersebut. Misalnya, Anda kemungkinan tidak ingin menggunakan strategi yang sama untuk papan peringkat 10 teratas di situs game dan berita yang sedang tren. Selanjutnya, kita akan membahas strategi pemeliharaan cache umum beserta kelebihan dan kekurangannya.

Lazy loading

Seperti namanya, lazy loading 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 (database) yang diaksesnya. Setiap kali aplikasi Anda meminta data, pertama kali membuat permintaan ke ElastiCache cache. Jika data ada di cache dan saat ini, ElastiCache mengembalikan data ke aplikasi Anda. Jika data tidak ada 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 hit terjadi ketika data ada dalam cache dan tidak habis masa berlakunya:

1. Aplikasi Anda meminta data dari cache.

2. Cache mengembalikan data ke aplikasi.

Cache miss terjadi ketika data tidak ada dalam cache atau data sudah tidak berlaku:

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 lazy loading

Kelebihan dari lazy loading adalah sebagai berikut:

• Hanya data yang diminta yang disimpan ke cache.

  Karena sebagian besar data tidak pernah diminta, lazy loading menghindari mengisi cache dengan 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 cache miss menghasilkan kueri ke basis data. Pada saat yang sama, salinan data ditambahkan ke cache sehingga permintaan berikutnya diambil dari cache tersebut.

Kekurangan dari lazy loading adalah sebagai berikut:

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

  1. Permintaan awal untuk data dari cache

  2. Kueri basis data untuk data

  3. Menulis data ke cache

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

• Data yang usang.

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

Contoh kode semu lazy loading

Berikut adalah contoh kode semu logika lazy loading.

// *****************************************
// 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, data dalam cache selalu yang terbaru.

• Kerugian operasi tulis vs kerugian operasi baca.

  Setiap operasi tulis melibatkan dua proses:

  1. Operasi tulis ke cache

  2. Operasi 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 lazy loading dengan write-through.

• Churn Cache.

  Sebagian besar data tidak pernah dibaca, yang merupakan pemborosan sumber daya. Dengan menambahkan nilai time to live (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

Lazy loading 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 time to live (TTL) untuk setiap operasi tulis, Anda dapat memanfaatkan kelebihan dari setiap strategi. Pada saat yang sama, Anda dapat secara signifikan menghindari cache menjadi penuh karena data tambahan.

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

Untuk informasi selengkapnya, lihat perintah .

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 lazy loading 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 (Memcached)