Strategi Caching: Pemuatan Malas dan Tulis Langsung
Terapkan pemuatan malas untuk mengisi cache saat terjadi cache miss, serta tulis langsung untuk menjaga konsistensi cache pada setiap penulisan basis data.
Strategi Caching: Pemuatan Malas dan Tulis Langsung adalah pelajaran AWS Solutions Architect gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AWS Solutions Architect, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AWS Solutions Architect mencakup 4 pelajaran total.
Mengapa Strategi Caching Penting
Menempatkan cache di antara aplikasi dan basis data memerlukan strategi caching — seperangkat aturan yang menentukan kapan data dimasukkan ke cache, kapan data dibaca dari cache, dan kapan data dikeluarkan. Memilih strategi yang salah dapat menyebabkan data usang (cache mengembalikan Value yang sudah kedaluwarsa), cache miss dingin (cache kosong dan setiap permintaan mengakses basis data), atau cache stampede (banyak permintaan simultan untuk Key yang sama-sama tidak tersedia semuanya mengakses basis data secara bersamaan). Dua strategi dasar tersebut adalah pemuatan malas dan write-through.
Pemuatan Malas (Cache-Aside): Cara Kerjanya
Pemuatan malas (juga disebut cache-aside) adalah pola caching yang paling umum. Aplikasi memeriksa cache terlebih dahulu. Saat terjadi cache hit, data langsung dikembalikan dari cache — jalur cepat. Saat terjadi cache miss, aplikasi mengambil data dari basis data, menulis hasilnya ke cache dengan TTL, lalu mengembalikannya kepada pemanggil. Cache hanya diisi dengan data yang benar-benar diminta — itulah alasan pola ini disebut "malas". Permintaan berikutnya untuk Key yang sama akan menemukannya di cache.
# Lazy loading pattern (Python with redis-py)
def get_user(user_id, redis_client, db):
cache_key = f'user:{user_id}'
# 1. Check cache
cached = redis_client.get(cache_key)
if cached:
return json.loads(cached) # Cache HIT
# 2. Cache MISS: fetch from DB
user = db.query('SELECT * FROM users WHERE id = %s', user_id)
# 3. Populate cache with TTL of 300 seconds
redis_client.setex(cache_key, 300, json.dumps(user))
return userPemuatan Malas: Kelebihan
Pemuatan malas memiliki tiga kelebihan utama: hanya data yang diminta yang di-cache — cache tidak dipenuhi data yang tidak pernah dibaca, sehingga memori digunakan secara efisien. Cache dingin tidak membuat aplikasi berhenti — saat terjadi cache miss, aplikasi menggunakan basis data sebagai cadangan, sehingga meskipun ElastiCache dimulai ulang atau sebuah node mengalami kegagalan, aplikasi tetap berfungsi (dengan latensi yang lebih tinggi). Cache selalu pada akhirnya konsisten dengan basis data karena data usang kedaluwarsa melalui TTL meskipun beberapa pembaruan terlewat.
Pemuatan Malas: Kekurangan
Pemuatan malas memiliki tiga kekurangan utama: cache miss membutuhkan biaya besar — tiga operasi (pemeriksaan cache, pembacaan basis data, dan penulisan cache) dibandingkan satu operasi untuk cache hit, sehingga menyebabkan latensi lebih tinggi pada permintaan saat cache dingin. Data usang — setelah pembaruan basis data, cache masih menyajikan Value lama sampai TTL kedaluwarsa atau Key dibatalkan validasinya secara eksplisit (jendela inkonsistensi cache). Cache stampede — jika Key yang populer kedaluwarsa, banyak permintaan simultan mengalami cache miss dan mengakses basis data secara bersamaan, yang berpotensi membebani basis data secara berlebihan.
# Mitigating cache stampede with a probabilistic early expiration
# (Refresh the key before it expires to avoid simultaneous misses)
def get_with_stampede_protection(key, redis_client, db_fetch_fn, ttl=300):
value = redis_client.get(key)
ttl_remaining = redis_client.ttl(key)
# Probabilistically refresh before expiry
if value is None or (ttl_remaining < 30 and random.random() < 0.1):
value = db_fetch_fn()
redis_client.setex(key, ttl, json.dumps(value))
return json.loads(value)Write-Through: Cara Kerjanya
Dalam strategi write-through, setiap penulisan ke basis data juga ditulis ke cache secara bersamaan. Aplikasi menulis ke cache dan basis data sebagai bagian dari operasi yang sama (atau basis data memicu pembaruan cache). Karena itu, cache selalu sinkron dengan basis data — tidak ada jendela data usang. Write-through menjamin bahwa data di cache selalu terbaru, sehingga pembacaan berikutnya selalu menjadi cache hit untuk data yang baru saja ditulis.
# Write-through pattern (Python)
def update_user(user_id, user_data, redis_client, db):
# 1. Write to database FIRST
db.execute('UPDATE users SET name=%s WHERE id=%s',
(user_data['name'], user_id))
# 2. Update cache immediately (write-through)
cache_key = f'user:{user_id}'
redis_client.setex(cache_key, 3600, json.dumps(user_data))
return user_data
# Every read is now a cache hit for recently updated dataWrite-Through: Kelebihan
Kelebihan write-through: data cache selalu terbaru — tidak ada data usang karena cache diperbarui pada setiap penulisan. Pembacaan selalu cepat — data populer yang sering ditulis selalu tersedia di cache. Tidak ada cache stampede saat membaca — karena data diisi terlebih dahulu sebelum dibaca, tidak ada cache miss dingin untuk data yang baru ditulis. Strategi ini ideal untuk beban kerja yang didominasi pembacaan dengan pembaruan yang sering, seperti katalog product, sistem harga, atau cache profil User.
Write-Through: Kekurangan
Kekurangan write-through: penalti penulisan — setiap penulisan memerlukan dua operasi (basis data + cache), sehingga menambah latensi penulisan. Polusi cache — data di-cache meskipun tidak pernah dibaca lagi (ditulis sekali dan tidak pernah diminta), sehingga memboroskan memori cache. Mulai ulang cache berarti cache dingin — jika klaster cache dimulai ulang, semua data yang ditulis secara proaktif akan hilang dan cache harus diisi ulang melalui penulisan atau proses pemanasan cache. Gabungkan write-through dengan TTL untuk mencegah pertumbuhan tanpa batas data cache yang jarang dibaca.
Menggabungkan Pemuatan Malas dan Write-Through
Dalam praktiknya, banyak sistem produksi menggabungkan kedua strategi: gunakan write-through untuk data yang sering diperbarui dan sering dibaca (seperti sesi User atau harga saat ini), dan pemuatan malas untuk data yang jarang diperbarui tetapi sering dibaca (seperti deskripsi product atau isi artikel). Tetapkan TTL yang sesuai untuk keduanya: Key write-through mendapatkan TTL panjang karena datanya selalu terbaru; Key yang dimuat secara malas mendapatkan TTL lebih pendek untuk membatasi jendela data usang. Pendekatan Hybrid ini memaksimalkan rasio cache hit sekaligus meminimalkan data yang usang.
# Hybrid: write-through for sessions, lazy loading for product data
# Write-through for session data (always fresh, critical)
def save_session(session_id, data, redis_client, db):
db.upsert('sessions', session_id, data)
redis_client.setex(f'session:{session_id}', 3600, json.dumps(data))
# Lazy loading for product catalog (infrequent updates OK)
def get_product(product_id, redis_client, db):
cached = redis_client.get(f'product:{product_id}')
if cached:
return json.loads(cached)
product = db.query('SELECT * FROM products WHERE id=%s', product_id)
redis_client.setex(f'product:{product_id}', 86400, json.dumps(product))
return productPrinsip Perancangan TTL
Time-To-Live (TTL) pada data yang di-cache mengendalikan durasi maksimum jendela data usang dan jejak memori cache. Rancang TTL berdasarkan: frekuensi pembaruan data (data sesi sering berubah → TTL pendek; konten statis jarang berubah → TTL panjang), toleransi terhadap data usang (harga finansial → sangat pendek; teks kiriman blog → berjam-jam atau berhari-hari), dan kapasitas memori cache (memori rendah → TTL lebih pendek agar data usang dikeluarkan lebih cepat). Selalu tetapkan TTL — jangan pernah menyimpan data tanpa masa kedaluwarsa, atau cache pada akhirnya akan dipenuhi data usang.
# TTL examples by data type
# API rate limit counter: 60 seconds
redis_client.setex(f'ratelimit:{ip}', 60, count)
# User session: 30 minutes
redis_client.setex(f'session:{id}', 1800, json.dumps(session))
# Product catalog: 24 hours
redis_client.setex(f'product:{id}', 86400, json.dumps(product))
# Stock price: 10 seconds
redis_client.setex(f'price:{symbol}', 10, price)
# Static site content: 7 days
redis_client.setex(f'page:{slug}', 604800, html_content)Pembatalan Validasi Cache saat Pembaruan
Selain hanya mengandalkan kedaluwarsa TTL, Anda dapat membatalkan validasi (menghapus) Key cache secara eksplisit ketika data dasarnya berubah. Ini sepenuhnya menghilangkan jendela data usang. Pola yang umum: penghapusan saat penulisan (hapus Key cache setelah setiap pembaruan basis data — pembacaan berikutnya mengisinya kembali melalui pemuatan malas), pembatalan validasi berbasis peristiwa (DynamoDB Streams atau pengambilan perubahan RDS memicu Lambda yang menghapus Key yang terdampak). Pembatalan validasi cache adalah salah satu masalah tersulit dalam sistem terdistribusi; semakin sederhana logika pembatalan validasi, semakin andal cache Anda.
# Delete-on-write invalidation pattern
def update_product(product_id, new_data, redis_client, db):
# Update the database
db.execute('UPDATE products SET ... WHERE id=%s', (product_id,))
# Invalidate the cache key
redis_client.delete(f'product:{product_id}')
# Also invalidate any list/search caches that may include this product
redis_client.delete('products:list:page:1')
redis_client.delete(f'products:category:{new_data["category_id"]}')
# Next read will trigger lazy loading with fresh dataCaching Write-Behind (Write-Back)
Pola yang lebih jarang digunakan tetapi kuat adalah write-behind (write-back): aplikasi hanya menulis ke cache, lalu cache secara asinkron mengalirkan data ke basis data di Background. Pola ini menghasilkan penulisan yang sangat cepat (hanya di memori), tetapi berisiko kehilangan data jika cache gagal sebelum melakukan pengaliran. Write-behind sesuai untuk penulisan berfrekuensi tinggi dan bervolume besar ketika data dapat direkonstruksi atau kehilangan kecil masih dapat diterima — misalnya penghitung hit, peristiwa analitik, atau pembaruan skor permainan. ElastiCache tidak mendukung write-behind secara native; pola ini harus diterapkan pada lapisan aplikasi.
# Write-behind pattern: write to cache, flush to DB asynchronously
# Application writes:
# redis_client.incr('post:42:views') # fast, in-memory only
# Background job (runs every 60 seconds):
def flush_view_counts(redis_client, db):
for key in redis_client.scan_iter('post:*:views'):
count = redis_client.getdel(key) # atomic get-and-delete
post_id = key.split(':')[1]
db.execute('UPDATE posts SET views = views + %s WHERE id = %s',
(int(count), post_id))Pemeriksaan Singkat
Uji pemahaman Anda tentang konsep AWS Solutions Architect (SAA-C03) dari pelajaran ini.
Rangkuman Pelajaran
Dalam pelajaran ini Anda mempelajari bahwa pemuatan malas mengisi cache saat terjadi cache miss pada pembacaan dan menggunakan memori secara efisien, tetapi dapat menyajikan data usang sampai TTL kedaluwarsa; write-through memperbarui cache pada setiap penulisan sehingga tidak ada data usang, tetapi memboroskan memori untuk data yang tidak dibaca; dan pembatalan validasi eksplisit menghapus Key cache saat basis data diperbarui untuk menghilangkan jendela data usang. Selanjutnya, kita akan membahas penyimpanan sesi dan pola papan peringkat dengan ElastiCache.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Strategi Caching: Pemuatan Malas dan Tulis Langsung” gratis?
Ya — teks lengkap “Strategi Caching: Pemuatan Malas dan Tulis Langsung” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AWS Solutions Architect, upgrade ke CoddyKit PRO. Kursus AWS Solutions Architect mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Strategi Caching: Pemuatan Malas dan Tulis Langsung”?
Terapkan pemuatan malas untuk mengisi cache saat terjadi cache miss, serta tulis langsung untuk menjaga konsistensi cache pada setiap penulisan basis data. Kamu berlatih AWS Solutions Architect dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AWS Solutions Architect?
Tidak diperlukan pengalaman sebelumnya. AWS Solutions Architect di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Strategi Caching: Pemuatan Malas dan Tulis Langsung” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AWS Solutions Architect ini?
Ya. Setiap pelajaran AWS Solutions Architect menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Redis vs Memcached: Memilih Mesin yang Tepat
- Grup Replikasi Redis ElastiCache dan Mode Klaster
- Strategi Caching: Pemuatan Malas dan Tulis Langsung
- Penyimpanan Sesi dan Pola Papan Peringkat