0Pricing
Cloud & IT Cert Prep · Pelajaran

Penyimpanan Sesi dan Pola Papan Peringkat

Gunakan ElastiCache untuk memindahkan pengelolaan status sesi HTTP dari server aplikasi, lalu buat papan peringkat waktu nyata dengan set terurut Redis.

Penyimpanan Sesi dan Pola Papan Peringkat adalah pelajaran Cloud & IT Cert Prep gratis di CoddyKit. Ini adalah pelajaran 4 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 Cloud & IT Cert Prep, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Cloud & IT Cert Prep mencakup 4 pelajaran total.

Masalah dengan Sesi di Sisi Server

Aplikasi web tradisional menyimpan data sesi di memori server. Cara ini berfungsi pada satu server, tetapi bermasalah saat Anda melakukan penskalaan horizontal — jika permintaan berikutnya dari User diarahkan ke instans EC2 yang berbeda, instans tersebut tidak mengetahui sesi User dan User akan keluar dari sistem. Sesi lengket (afinitas sesi pada penyeimbang beban) hanya menyelesaikan sebagian masalah, tetapi mengurangi efektivitas penyeimbangan beban. Solusi yang dapat diskalakan adalah memindahkan status sesi ke penyimpanan bersama berlatensi rendah yang dapat diakses semua instans — dan itulah yang disediakan ElastiCache Redis.

Redis untuk Penyimpanan Sesi

Menyimpan sesi di Redis memberi Anda: pembacaan sesi dalam hitungan submilidetik di semua server aplikasi, TTL bawaan untuk kedaluwarsa sesi otomatis, pembaruan sesi atomik untuk mencegah kondisi balapan, serta kemampuan untuk segera membatalkan validasi sesi dengan menghapus Key. Aplikasi menyimpan ID sesi dalam cookie; pada setiap permintaan, aplikasi mencari ID sesi tersebut di Redis untuk mengambil data sesi. Semua server aplikasi menggunakan Redis yang sama, sehingga server mana pun dapat menangani permintaan User mana pun.

# Session storage with Redis (Python Flask example)
import redis, json, uuid
from datetime import timedelta

redis_client = redis.Redis(host='prod-redis-primary', port=6379)
SESSION_TTL = int(timedelta(hours=8).total_seconds())

def create_session(user_id):
    session_id = str(uuid.uuid4())
    session_data = {'user_id': user_id, 'logged_in': True}
    redis_client.setex(f'session:{session_id}', SESSION_TTL, json.dumps(session_data))
    return session_id

def get_session(session_id):
    data = redis_client.get(f'session:{session_id}')
    return json.loads(data) if data else None

TTL Sesi dan Kedaluwarsa Bergeser

TTL tetap berarti sesi kedaluwarsa N detik setelah dibuat, terlepas dari aktivitasnya. TTL bergeser (memperpanjang kedaluwarsa setiap kali diakses) lebih ramah bagi User — sesi kedaluwarsa N detik setelah akses terakhir. Di Redis, terapkan TTL bergeser dengan memanggil EXPIRE (atau EXPIREAT) pada Key sesi setiap kali pembacaan sesi berhasil untuk mengatur ulang hitung mundur kedaluwarsa. Dengan demikian, User aktif tidak akan tiba-tiba dikeluarkan, sedangkan sesi yang tidak aktif akan kedaluwarsa secara otomatis dan membebaskan memori.

# Sliding TTL session implementation
def get_session_with_sliding_ttl(session_id, redis_client, ttl_seconds=1800):
    session_key = f'session:{session_id}'

    # Pipeline: GET + EXPIRE in one round trip
    pipe = redis_client.pipeline()
    pipe.get(session_key)
    pipe.expire(session_key, ttl_seconds)  # Reset TTL on access
    results = pipe.execute()

    data = results[0]
    if data:
        return json.loads(data)
    return None   # Session expired or not found

Keranjang Belanja di Redis

Keranjang belanja e-commerce sangat cocok disimpan di Redis. Setiap keranjang disimpan sebagai Redis Hash, dengan field berupa SKU product dan Value berupa jumlahnya. Operasi Hash seperti HINCRBY dan HDEL memungkinkan pembaruan atomik tanpa mengambil dan menulis ulang seluruh keranjang. Jika digabungkan dengan TTL (untuk menghapus keranjang yang ditinggalkan setelah 24 jam), Redis menyediakan penyimpanan keranjang yang cepat dan persisten tanpa beban basis data relasional untuk setiap peristiwa penambahan ke keranjang.

# Shopping cart operations using Redis Hash
cart_key = f'cart:{user_id}'

# Add item (or increase quantity)
# HINCRBY cart:user42 SKU-001 2
redis_client.hincrby(cart_key, 'SKU-001', 2)

# Remove item
# HDEL cart:user42 SKU-001
redis_client.hdel(cart_key, 'SKU-001')

# Get all items in cart
# HGETALL cart:user42
cart = redis_client.hgetall(cart_key)  # {b'SKU-001': b'2', b'SKU-002': b'1'}

# Set TTL for cart abandonment (24 hours)
redis_client.expire(cart_key, 86400)

Arsitektur Papan Peringkat

Papan peringkat waktu nyata adalah kasus penggunaan klasik Redis yang didukung oleh Sorted Sets (ZSETs). Setiap entri pemain memiliki skor; sorted set selalu mempertahankan anggotanya dalam urutan skor menaik. Kueri papan peringkat (N pemain teratas, peringkat pemain, pemain dalam rentang skor tertentu) memiliki kompleksitas O(log n) atau O(log n + m) — sangat cepat bahkan untuk jutaan pemain. Sorted set Redis menjadi dasar bagi berbagai fitur peringkat dalam gim, kebugaran, dan jejaring sosial tanpa memerlukan kueri basis data yang rumit atau menghitung ulang peringkat pada setiap tampilan halaman.

# Real-time leaderboard with Redis Sorted Set

# Add or update a player's score
# ZADD game:weekly:leaderboard 15750 'player:alice'
redis_client.zadd('game:weekly:leaderboard', {'player:alice': 15750})

# Increment score (atomic)
# ZINCRBY game:weekly:leaderboard 500 'player:alice'
redis_client.zincrby('game:weekly:leaderboard', 500, 'player:alice')

# Get top 10 players (highest scores first)
# ZREVRANGE game:weekly:leaderboard 0 9 WITHSCORES
top_10 = redis_client.zrevrange('game:weekly:leaderboard', 0, 9, withscores=True)

Peringkat Pemain dan Pemain di Sekitarnya

Dua fitur papan peringkat umum selain "menampilkan 10 teratas" adalah menampilkan peringkat seorang pemain dan menampilkan pemain di sekitar pemain tertentu. Keduanya mudah dilakukan dengan sorted set Redis. ZREVRANK mengembalikan peringkat berbasis indeks 0 seorang pemain dalam urutan skor menurun. Untuk menampilkan 5 pemain di atas dan di bawah seorang pemain, dapatkan peringkatnya, lalu gunakan ZREVRANGE dari peringkat-5 hingga peringkat+5. Dengan demikian, Anda mendapatkan tampilan papan peringkat yang dipersonalisasi hanya dengan dua perintah Redis — tanpa memerlukan fungsi jendela SQL yang rumit.

# Get Alice's rank (0-indexed, so add 1 for display)
# ZREVRANK game:weekly:leaderboard 'player:alice'
rank = redis_client.zrevrank('game:weekly:leaderboard', 'player:alice')
print(f'Alice is rank #{rank + 1}')

# Get 5 players above and below Alice
start = max(0, rank - 5)
end = rank + 5
nearby = redis_client.zrevrange(
    'game:weekly:leaderboard', start, end, withscores=True
)
print('Players near Alice:', nearby)

Pembatasan Laju dengan Redis

Pembatasan laju (membatasi jumlah permintaan yang dapat dibuat klien dalam suatu jendela waktu) adalah kasus penggunaan Redis bernilai tinggi lainnya. Algoritme sliding window menggunakan sorted set yang setiap anggotanya merupakan stempel waktu permintaan. Pada setiap permintaan: hapus anggota yang lebih lama daripada jendela, hitung anggota yang tersisa, tolak permintaan jika jumlahnya melebihi batas, lalu tambahkan stempel waktu baru. Cara ini menerapkan pembatasan laju sliding window yang presisi dengan resolusi milidetik — jauh lebih akurat daripada penghitung fixed window dan tanpa beban tambahan dari basis data.

# Sliding window rate limiter (100 requests per 60 seconds)
import time

def is_rate_limited(user_id, redis_client, limit=100, window_seconds=60):
    key = f'ratelimit:{user_id}'
    now = time.time()
    window_start = now - window_seconds

    pipe = redis_client.pipeline()
    pipe.zremrangebyscore(key, '-inf', window_start)  # Remove old
    pipe.zcard(key)                                    # Count current
    pipe.zadd(key, {str(now): now})                   # Add this request
    pipe.expire(key, window_seconds)
    results = pipe.execute()

    request_count = results[1]
    return request_count >= limit  # True = rate limited

Penguncian Terdistribusi dengan Redis

Distributed locks mengoordinasikan akses eksklusif ke sumber daya bersama di beberapa server aplikasi. Perintah Redis SET key value NX EX ttl menyediakan akuisisi kunci atomik — perintah ini hanya menetapkan kunci jika kunci tersebut belum ada (NX = tidak ada) dan menetapkan TTL untuk mencegah kebuntuan jika pemegang kunci mengalami kerusakan. Setelah operasi selesai, pemegang kunci menghapus kunci tersebut. Algoritme Redlock (yang menggunakan beberapa node Redis untuk mencapai kuorum) menyediakan kunci terdistribusi yang lebih tangguh, meskipun menambah kompleksitas. Untuk sebagian besar kasus penggunaan, kunci pada satu node Redis sudah memadai.

# Distributed lock with Redis SET NX EX
import uuid

def acquire_lock(redis_client, resource, ttl_seconds=30):
    lock_id = str(uuid.uuid4())  # Unique ID to identify this lock holder
    key = f'lock:{resource}'
    acquired = redis_client.set(key, lock_id, nx=True, ex=ttl_seconds)
    return lock_id if acquired else None

def release_lock(redis_client, resource, lock_id):
    key = f'lock:{resource}'
    # Only delete if we still own the lock (Lua script for atomicity)
    lua = 'if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end'
    redis_client.eval(lua, 1, key, lock_id)

Penyimpanan Sesi: ElastiCache vs DynamoDB

Baik ElastiCache Redis maupun DynamoDB dapat menyimpan data sesi, tetapi keduanya memiliki kelebihan dan kekurangan yang berbeda. ElastiCache Redis: latensi mikrodetik, tersimpan di memori (volatile kecuali persistensi diaktifkan), model data lebih sederhana, dan memerlukan VPC. DynamoDB: latensi milidetik satu digit (DAX dapat menyamai Redis), dikelola sepenuhnya tanpa klaster yang perlu dipelihara, tahan lama secara default, dapat diakses secara global dengan Global Tables, dan tanpa server dengan kapasitas sesuai permintaan. Untuk ujian SAA-C03: jika pertanyaan menekankan latensi mikrodetik atau operasi kompleks dalam memori, pilih Redis. Jika menekankan ketahanan data, tanpa server, atau skala global, pertimbangkan DynamoDB.

Pengindeksan Geospasial dengan Redis

Redis memiliki jenis data geospasial bawaan (perintah GEO) yang menyimpan koordinat lintang/bujur dan memungkinkan kueri kedekatan. Dengan menggunakan GEOADD, GEODIST, dan GEORADIUS (sekarang GEOSEARCH di Redis 6.2), Anda dapat menemukan semua lokasi dalam radius tertentu dari suatu titik dengan waktu O(n + log n). Kasus penggunaan: menemukan pengemudi di sekitar (berbagi tumpangan), menemukan restoran dalam jarak 5 km, dan mengurutkan hasil pencarian berdasarkan jarak. Cara ini menghindari basis data geospasial terpisah dan mempertahankan kueri lokasi pada kecepatan dalam memori.

# Store driver locations
# GEOADD drivers 13.361389 38.115556 'driver:001'
# GEOADD drivers 15.087269 37.502669 'driver:002'

# Find all drivers within 10 km of a point
# GEOSEARCH drivers FROMLONLAT 13.5 38.1 BYRADIUS 10 km ASC COUNT 5 WITHCOORD

# Result: sorted list of driver IDs within 10 km with coordinates

HyperLogLog untuk Menghitung Pengunjung Unik

HyperLogLog adalah struktur data probabilistik yang memperkirakan jumlah elemen unik dalam suatu set dengan menggunakan jumlah memori tetap (12 KB di Redis), terlepas dari jumlah item unik yang ditambahkan. Struktur ini memberikan galat standar sekitar 0,81%. Gunakan PFADD untuk menambahkan elemen dan PFCOUNT untuk mendapatkan perkiraannya. Ini sangat cocok untuk menghitung pengguna aktif harian yang unik, tampilan halaman unik, atau alamat IP unik ketika jumlah yang tepat tidak diperlukan dan efisiensi memori penting. Menyimpan jutaan ID pengguna unik sebagai Redis Set akan menghabiskan GB; HyperLogLog hanya menggunakan 12 KB.

# Count unique daily visitors using HyperLogLog
date = '2024-01-15'
hll_key = f'unique_visitors:{date}'

# Track a visitor (PFADD is idempotent for the same user)
# PFADD unique_visitors:2024-01-15 'user:12345'
redis_client.pfadd(hll_key, 'user:12345')
redis_client.pfadd(hll_key, 'user:67890')
redis_client.pfadd(hll_key, 'user:12345')  # Duplicate — not counted again

# Get estimated unique visitor count
# PFCOUNT unique_visitors:2024-01-15
count = redis_client.pfcount(hll_key)
print(f'Unique visitors today (estimate): {count}')

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep AWS Solutions Architect (SAA-C03) dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa: penyimpanan sesi Redis memungkinkan penskalaan horizontal tanpa status dengan memberikan semua instans akses ke status sesi bersama dengan latensi di bawah satu milidetik, sorted set Redis mendukung papan peringkat waktu nyata dengan kueri peringkat O(log n), dan jenis data Redis khusus (HyperLogLog untuk jumlah unik, GEO untuk kedekatan, serta kunci terdistribusi) menyelesaikan masalah arsitektur umum secara efisien. Kursus Caching dengan ElastiCache ini selesai — selanjutnya kita akan mempelajari Ketersediaan Tinggi dan Arsitektur Tahan Kesalahan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penyimpanan Sesi dan Pola Papan Peringkat” gratis?

Ya — teks lengkap “Penyimpanan Sesi dan Pola Papan Peringkat” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Cloud & IT Cert Prep, upgrade ke CoddyKit PRO. Kursus Cloud & IT Cert Prep mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penyimpanan Sesi dan Pola Papan Peringkat”?

Gunakan ElastiCache untuk memindahkan pengelolaan status sesi HTTP dari server aplikasi, lalu buat papan peringkat waktu nyata dengan set terurut Redis. Kamu berlatih Cloud & IT Cert Prep 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 Cloud & IT Cert Prep?

Tidak diperlukan pengalaman sebelumnya. Cloud & IT Cert Prep 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 4 dari 4.

Berapa lama pelajaran “Penyimpanan Sesi dan Pola Papan Peringkat” 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 Cloud & IT Cert Prep ini?

Ya. Setiap pelajaran Cloud & IT Cert Prep 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

  1. Redis vs Memcached: Memilih Mesin yang Tepat
  2. Grup Replikasi Redis ElastiCache dan Mode Klaster
  3. Strategi Caching: Pemuatan Malas dan Tulis Langsung
  4. Penyimpanan Sesi dan Pola Papan Peringkat
← Kembali ke Cloud & IT Cert Prep