AWS Solutions Architect · Pelajaran

Storan Sesi dan Corak Papan Pendahulu

Gunakan ElastiCache untuk memindahkan keadaan sesi HTTP daripada pelayan aplikasi anda, dan laksanakan papan pendahulu masa nyata dengan set tersusun Redis.

Pelajaran 4 daripada 413 langkah

Storan Sesi dan Corak Papan Pendahulu ialah pelajaran AWS Solutions Architect percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran AWS Solutions Architect, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus AWS Solutions Architect merangkumi sejumlah 4 pelajaran.

Masalah dengan Sesi pada Pelayan

Aplikasi web tradisional menyimpan data sesi dalam memori pada pelayan. Ini berfungsi dengan satu pelayan tetapi gagal apabila anda melakukan penskalaan mendatar — jika permintaan seterusnya pengguna dihalakan ke tika EC2 yang berbeza, tika tersebut tidak mengetahui sesi pengguna dan pengguna akan dilog keluar. Sesi melekat (keafinan sesi pada pengimbang beban) menyelesaikan sebahagian masalah ini tetapi mengurangkan keberkesanan pengimbangan beban. Penyelesaian yang boleh diskala ialah memindahkan keadaan sesi ke stor dikongsi yang berkependaman rendah yang boleh dicapai oleh semua tika — dan inilah yang disediakan oleh ElastiCache Redis.

Redis untuk Penyimpanan Sesi

Menyimpan sesi dalam Redis memberikan anda: bacaan sesi submilisaat merentasi semua pelayan aplikasi, TTL terbina dalam untuk tamat tempoh sesi secara automatik, kemas kini sesi atomik bagi mengelakkan keadaan perlumbaan, serta keupayaan untuk membatalkan sesi dengan segera dengan memadam Key. Aplikasi menyimpan ID sesi dalam kuki; bagi setiap permintaan, aplikasi mencari ID sesi dalam Redis untuk mendapatkan data sesi. Semua pelayan aplikasi berkongsi Redis yang sama, jadi mana-mana pelayan boleh mengendalikan permintaan mana-mana pengguna.

# 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 Tamat Tempoh Gelongsor

TTL tetap bermaksud sesi tamat N saat selepas penciptaan tanpa mengira aktiviti. TTL gelongsor (memanjangkan tamat tempoh pada setiap capaian) lebih mesra pengguna — sesi tamat N saat selepas capaian terakhir. Dalam Redis, laksanakan TTL gelongsor dengan memanggil EXPIRE (atau EXPIREAT) pada Key sesi bagi setiap bacaan sesi yang berjaya untuk menetapkan semula kira detik tamat tempoh. Ini memastikan pengguna aktif tidak dilog keluar tanpa dijangka, manakala sesi tidak aktif tamat tempoh secara automatik 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

Troli Beli-belah dalam Redis

Troli beli-belah e-dagang amat sesuai untuk Redis. Setiap troli disimpan sebagai Hash Redis, dengan medan berupa SKU produk dan nilai berupa kuantiti. Operasi Hash seperti HINCRBY dan HDEL membolehkan kemas kini atomik tanpa mendapatkan semula dan menulis semula keseluruhan troli. Digabungkan dengan TTL (untuk meluputkan troli yang ditinggalkan selepas 24 jam), Redis menyediakan stor troli yang pantas dan berterusan tanpa overhed pangkalan data hubungan bagi setiap peristiwa tambah ke troli.

# 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)

Seni Bina Papan Pendahulu

Papan pendahulu masa nyata ialah kes penggunaan Redis klasik yang didayakan oleh Sorted Sets (ZSETs). Setiap entri pemain mempunyai skor; set tersusun mengekalkan ahli dalam susunan skor menaik pada setiap masa. Pertanyaan papan pendahulu (N pemain teratas, kedudukan pemain, pemain dalam julat skor) ialah O(log n) atau O(log n + m) — amat pantas walaupun untuk berjuta-juta pemain. Set tersusun Redis menjadi asas bagi banyak ciri pemeringkatan permainan, kecergasan dan sosial tanpa memerlukan pertanyaan pangkalan data yang kompleks atau pengiraan semula kedudukan pada setiap paparan 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)

Kedudukan Pemain dan Pemain Berdekatan

Dua ciri papan pendahulu yang lazim selain daripada 'paparkan 10 teratas' ialah memaparkan kedudukan pemain dan memaparkan pemain yang berdekatan dengan pemain tertentu. Kedua-duanya mudah dilaksanakan dengan set tersusun Redis. ZREVRANK mengembalikan kedudukan berindeks 0 bagi seorang pemain dalam susunan skor menurun. Untuk memaparkan 5 pemain di atas dan di bawah seseorang pemain, dapatkan kedudukan mereka, kemudian gunakan ZREVRANGE daripada kedudukan-5 hingga kedudukan+5. Ini memberikan paparan papan pendahulu diperibadikan dengan dua arahan Redis — tiada fungsi tetingkap SQL yang kompleks diperlukan.

# 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)

Pengehadan Kadar dengan Redis

Pengehadan kadar (mengehadkan bilangan permintaan yang boleh dibuat oleh klien dalam tempoh masa tertentu) ialah satu lagi kes penggunaan Redis yang bernilai tinggi. Algoritma tetingkap gelongsor menggunakan set tersusun yang setiap ahlinya ialah cap masa permintaan. Bagi setiap permintaan: keluarkan ahli yang lebih lama daripada tempoh tetingkap, kira ahli yang tinggal, tolak permintaan jika kiraan melebihi had, kemudian tambah cap masa baharu. Ini melaksanakan pengehad kadar tetingkap gelongsor yang tepat dengan ketepatan milisaat — jauh lebih tepat berbanding pembilang tetingkap tetap dan tanpa beban pangkalan 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 Teragih dengan Redis

Kunci teragih menyelaraskan akses eksklusif kepada sumber yang dikongsi merentasi beberapa pelayan aplikasi. Arahan Redis SET key value NX EX ttl menyediakan pemerolehan kunci secara atomik — ia menetapkan kunci hanya jika kunci tersebut belum wujud (NX = Not eXists) dan menetapkan TTL untuk mencegah kebuntuan jika pemegang kunci terhenti. Apabila operasi selesai, pemegang kunci memadam kunci tersebut. Algoritma Redlock (yang menggunakan beberapa nod Redis untuk kuorum) menyediakan kunci teragih yang lebih teguh, walaupun ia menambahkan kerumitan. Bagi kebanyakan kes penggunaan, kunci nod Redis tunggal 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 berbanding DynamoDB

Kedua-dua ElastiCache Redis dan DynamoDB boleh menyimpan data sesi, tetapi kedua-duanya mempunyai pertukaran yang berbeza. ElastiCache Redis: kependaman mikrosaat, dalam memori (tidak kekal melainkan ketekalan didayakan), model data yang lebih ringkas, memerlukan VPC. DynamoDB: kependaman milisaat satu digit (DAX boleh menyamai Redis), diurus sepenuhnya tanpa kluster untuk diselenggara, tahan lama secara lalai, boleh diakses secara global dengan Global Tables, tanpa pelayan dengan kapasiti atas permintaan. Untuk peperiksaan SAA-C03: jika soalan menekankan kependaman mikrosaat atau operasi kompleks dalam memori, pilih Redis. Jika soalan menekankan ketahanan data, tanpa pelayan atau skala global, pertimbangkan DynamoDB.

Pengindeksan Geospatial dengan Redis

Redis mempunyai jenis data geospatial terbina dalam (arahan GEO) yang menyimpan koordinat latitud/longitud dan membolehkan pertanyaan jarak berdekatan. Dengan menggunakan GEOADD, GEODIST dan GEORADIUS (kini GEOSEARCH dalam Redis 6.2), anda boleh mencari semua lokasi dalam jejari tertentu dari sesuatu titik dalam masa O(n + log n). Kes penggunaan: mencari pemandu berdekatan (perkongsian kenderaan), mencari restoran dalam jarak 5 km, dan menyusun hasil carian mengikut jarak. Ini mengelakkan keperluan pangkalan data geospatial berasingan serta mengekalkan pertanyaan lokasi pada kelajuan 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 Mengira Pelawat Unik

HyperLogLog ialah struktur data kebarangkalian yang menganggarkan kiraan elemen unik dalam set menggunakan jumlah memori tetap (12 KB dalam Redis), tanpa mengira bilangan item unik yang ditambahkan. Ia memberikan ralat piawai kira-kira 0.81%. Gunakan PFADD untuk menambah elemen dan PFCOUNT untuk mendapatkan anggaran. Ini amat sesuai untuk mengira pengguna aktif harian yang unik, paparan halaman unik atau alamat IP unik apabila kiraan tepat tidak diperlukan dan kecekapan memori penting. Menyimpan berjuta-juta ID pengguna unik sebagai Set Redis akan menggunakan 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}')

Semakan Pantas

Uji pemahaman anda tentang konsep AWS Solutions Architect (SAA-C03) daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini anda telah mempelajari bahawa: penyimpanan sesi Redis membolehkan penskalaan mendatar tanpa keadaan dengan memberikan semua instance akses kepada keadaan sesi yang dikongsi dengan kependaman kurang daripada satu milisaat, set tersusun Redis menyokong papan pendahulu masa nyata dengan pertanyaan kedudukan O(log n), dan jenis data Redis khusus (HyperLogLog untuk kiraan unik, GEO untuk jarak berdekatan, serta kunci teragih) menyelesaikan masalah seni bina lazim dengan cekap. Ini melengkapkan kursus Caching dengan ElastiCache — seterusnya kita akan meneroka Ketersediaan Tinggi dan Seni Bina Tahan Kegagalan.

Percuma untuk bermula

Pelajari AWS Solutions Architect dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Storan Sesi dan Corak Papan Pendahulu” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran AWS Solutions Architect, termasuk “Storan Sesi dan Corak Papan Pendahulu”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus AWS Solutions Architect merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Storan Sesi dan Corak Papan Pendahulu”?

Gunakan ElastiCache untuk memindahkan keadaan sesi HTTP daripada pelayan aplikasi anda, dan laksanakan papan pendahulu masa nyata dengan set tersusun Redis. Anda berlatih AWS Solutions Architect menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan AWS Solutions Architect?

Tiada pengalaman terdahulu diperlukan. Pembelajaran AWS Solutions Architect di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Storan Sesi dan Corak Papan Pendahulu” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran AWS Solutions Architect ini?

Ya. Setiap pelajaran AWS Solutions Architect menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Redis berbanding Memcached: Memilih Enjin yang Sesuai
Kumpulan Replikasi Redis ElastiCache dan Mod Kluster
Strategi Caching: Pemuatan Malas dan Tulis Terus
Storan Sesi dan Corak Papan Pendahulu

← Kembali ke AWS Solutions Architect