Lewati ke konten utama

Python Redis: Panduan Pemula

Pelajari cara menggunakan Python untuk Redis dalam panduan pemula ini.

Jelajahi bersama AI

Menggunakan Redis dengan Python adalah kombinasi yang kuat bagi engineer data yang ingin membangun sistem berkinerja tinggi, terukur, dan mudah dipelihara. Baik Anda mengoptimalkan lapisan cache, mengelola aliran peristiwa real-time, atau menerapkan penguncian terdistribusi, Redis menyediakan solusi yang fleksibel dan efisien.

Dalam panduan ini, kami akan membahas dasar-dasar penggunaan Redis dengan Python untuk membantu Anda mengintegrasikannya secara mulus ke dalam alur kerja rekayasa data Anda.

Apa itu Python Redis?

redis

Redis adalah penyimpanan struktur data in-memory open-source yang digunakan sebagai database, cache, dan message broker. Nama Redis merupakan singkatan dari Remote Dictionary Server dan awalnya dirancang sebagai sistem penyimpanan key-value dengan waktu akses yang cepat.

Redis mendukung berbagai struktur data seperti string, hash, list, set, dan sorted set dengan kueri rentang. Redis juga menyediakan fitur lanjutan seperti transaksi, pesan pub/sub, skrip Lua, serta kemampuan replikasi dan klaster bawaan untuk ketersediaan dan skalabilitas yang lebih baik.

Kasus penggunaan Redis yang umum

Potensi kasus penggunaan Redis sangat luas dan beragam.

Beberapa kasus penggunaan paling umum dalam rekayasa data meliputi: 

  • Caching: Mempercepat kueri database dan respons API.
  • Antrian pesan: Mendukung arsitektur berbasis peristiwa dan pipeline pemrosesan job.
  • Analitik real-time: Memproses dan menganalisis data streaming dengan latensi minimal.
  • Leaderboard: Mengurutkan dan mengambil entitas berperingkat teratas secara efisien.
  • Penyimpanan sesi: Memelihara manajemen state sesi yang cepat dan terukur.
  • Manajemen antrian job: Memastikan penjadwalan dan eksekusi tugas yang efisien.
  • Pengindeksan geospasial: Menyimpan dan melakukan kueri data berbasis lokasi.

Redis juga umum digunakan bersama teknologi lain seperti web server (mis. NGINX), database (mis. MySQL), dan sistem messaging (mis. Kafka) untuk mengoptimalkan kinerja dan skalabilitas.

Mengapa menggunakan Redis dengan Python?

Python adalah bahasa dominan dalam rekayasa data karena fleksibilitas, ekosistem yang luas, dan kemudahan integrasi dengan teknologi big data. 

Menggabungkannya dengan Redis dapat menghadirkan banyak manfaat bagi aplikasi Anda:

  • Performa cepat: Karena Redis menyimpan data di memori, ia menawarkan waktu akses yang jauh lebih cepat dibandingkan database tradisional yang menyimpan data di disk. Ini ideal untuk kasus yang memerlukan kinerja tinggi, seperti caching dan aplikasi real-time.
  • Skalabilitas: Redis dirancang dengan mempertimbangkan skalabilitas, sehingga mudah menangani data dalam jumlah besar tanpa mengorbankan kinerja.
  • Kemudahan penggunaan: Sintaks Python yang sederhana dan ekosistem pustaka yang kaya memudahkan bekerja dengan Redis. Pustaka klien resmi Redis-py juga menyediakan antarmuka yang ramah pengguna untuk berinteraksi dengan Redis dari kode Python Anda.

Apa itu Redis-py?

Redis-py adalah pustaka klien resmi Redis untuk Python. Pustaka ini menyediakan antarmuka yang mudah digunakan untuk berkomunikasi dengan Redis dari dalam kode Python Anda.

Beberapa fitur utamanya meliputi:

  • Dukungan untuk semua tipe data Redis
  • Dukungan pipeline dan transaksi untuk operasi yang efisien dan atomik
  • Dukungan pesan pub/sub
  • Enkode/dekode otomatis data ke/dari bytes, string, dan tipe Python lainnya
  • Dukungan mode klaster untuk bekerja dengan klaster Redis

Menyiapkan Redis untuk Pengembangan Python

Mari kita lihat cara menyiapkan Redis menggunakan Python.

Ada tiga cara utama untuk menjalankan Redis:

  1. Docker (Disarankan untuk data engineer)
  2. Windows Subsystem for Linux (WSL)
  3. Build Pihak Ketiga (mis., Memurai, tporadowski/redis)

Metode A: Menggunakan Docker

Pertama, saat menggunakan Docker, Anda perlu memasang Docker Desktop di mesin Anda. Ini dapat diunduh dari situs DockerHub.

Setelah Docker terpasang, buka command prompt dan masukkan perintah berikut.

docker pull redis

Berikutnya, kita akan memulai container baru.

docker run --name my-redis -p 6379:6379 -d redis

docker pull redis mengunduh image resmi Redis terbaru. docker run --name my-redis -p 6379:6379 -d redis memulai container baru bernama my-redis. Parameter -p 6379:6379 memetakan port 6379 mesin lokal ke port 6379 container, sehingga Anda dapat terhubung ke Redis di localhost:6379. Flag -d menjalankan container di latar belakang (detached mode).

Untuk verifikasi, jalankan:

docker exec -it my-redis redis-cli ping

Seharusnya merespons dengan PONG.

Metode B: Menggunakan Windows Subsystem for Linux (WSL)

Untuk mesin Windows, metode lain yang memungkinkan adalah menggunakan Windows Subsystem for Linux. Proses pemasangan akan dilakukan melalui Linux.

wsl --install

Perintah ini memasang dan mengonfigurasi distribusi Ubuntu bawaan di WSL. Mulai ulang jika diperlukan.

Lalu, buka terminal Ubuntu Anda (dari Microsoft Store atau dengan mengetik wsl di PowerShell) dan jalankan:

sudo apt-get update
sudo apt-get install redis-server

Selanjutnya, mulai server Redis Anda.

sudo service redis-server start

Mari lakukan uji untuk memastikan server aktif berjalan.

redis-cli ping

Berikut penjelasan detail perintah yang kita gunakan di atas:

  • sudo apt-get update mengambil definisi paket terbaru.
  • sudo apt-get install redis-server memasang Redis di lingkungan Ubuntu.
  • sudo service redis-server start segera memulai layanan Redis.
  • redis-cli ping menguji konektivitas ke server Redis lokal, mengembalikan PONG jika berhasil.

Metode C: Build pihak ketiga

Solusi ini menyediakan binary Windows native. Setelah mengunduh dan memasang atau mengekstrak, jalankan:

redis-server.exe

Setelah dijalankan, redis-server.exe akan menampilkan log yang menunjukkan sedang mendengarkan pada 127.0.0.1:6379.

Anda dapat mengonfirmasi menggunakan CLI yang disertakan (jika ada):

redis-cli.exe ping

Anda akan mendapatkan hasil PONG jika berhasil.

Memasang pustaka redis-py

Selanjutnya, Anda perlu memasang pustaka redis-py agar dapat mengakses database menggunakan Python. Sebelum memasang pustaka, pastikan Anda telah memasang Python dan Redis secara terpisah.

pip install redis

Perintah ini mengunduh dan memasang pustaka klien Python Redis (redis-py) dari PyPI. Jika Anda menggunakan virtual environment, pastikan Anda mengaktifkannya sebelum menjalankan perintah ini.

Verifikasi dengan:

python -c "import redis; print(redis.__version__)"

Ini akan mencetak nomor versi (mis., 5.2.1).

Menyiapkan server Redis

Jika Anda mengikuti salah satu metode di atas (Docker, WSL, atau build pihak ketiga), sekarang Anda seharusnya memiliki server Redis yang berjalan di localhost:6379. Itu sudah cukup untuk pengembangan lokal di Windows.

Bekerja dengan Struktur Data Redis

Di bawah ini adalah contoh Python yang mendemonstrasikan cara terhubung dan memanipulasi berbagai tipe data Redis. Setiap blok kode menyertakan komentar penjelas tentang cara kerja metode atau perintahnya.

String di Redis

import redis

# Instantiate a Redis client, connecting to localhost on port 6379
r = redis.Redis(
    host='localhost',
    port=6379,
    db=0  # The default Redis database index
)

# 1. SET command: store a string under 'mykey'
r.set("mykey", "hello from Windows")

# 2. GET command: retrieve the value stored at 'mykey'
value = r.get("mykey")
print(value)   # Output is b'hello from Windows', since redis-py returns bytes.

# 3. Convert bytes to string
print(value.decode())  # prints "hello from Windows"

# 4. DEL command: remove 'mykey' from Redis
r.delete("mykey")

Kita membuat objek Redis yang terhubung ke server Redis lokal.

  • r.set("mykey", "hello from Windows") menyimpan string "hello from Windows" di bawah key "mykey".
  • r.get("mykey") mengambil nilai yang disimpan di mykey. Redis mengembalikan bytes, jadi kita decode untuk output yang mudah dibaca manusia.
  • r.delete("mykey") menghapus key mykey sepenuhnya.

Contoh: Menyimpan dan mengambil sesi pengguna

Berikut contoh kode manajemen sesi pengguna:

import uuid

def store_user_session(user_id):
    """
    Generates a unique session token (UUID) for a user and stores it in Redis.
    The session is stored under the key pattern: user:{user_id}:session
    """
    session_key = f"user:{user_id}:session"
    token = str(uuid.uuid4())   # Generate a random UUID as a session token
    r.set(session_key, token)   # Store token in Redis
    return token

def get_user_session(user_id):
    """
    Retrieves the stored session token for the given user_id.
    Returns None if the session does not exist or is expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

def delete_user_session(user_id):
    """
    Deletes the session entry from Redis for the specified user_id.
    """
    session_key = f"user:{user_id}:session"
    r.delete(session_key)

# Usage demonstration
session_token = store_user_session(1001)
print(f"Stored session token: {session_token}")

retrieved_token = get_user_session(1001)
print(f"Retrieved session token: {retrieved_token}")

delete_user_session(1001)
print(f"Session after delete: {get_user_session(1001)}")  # Should be None or empty

store_user_session(user_id): Membuat ID unik global melalui uuid.uuid4() dan menyimpannya di bawah key spesifik pengguna. get_user_session(user_id): Membaca kembali token sesi. Jika None, sesi tidak ada atau telah kedaluwarsa. delete_user_session(user_id): Menghapus key sesi dari Redis, sehingga pengguna efektif keluar.

List di Redis

List Redis adalah urutan string yang terurut. List mendukung operasi di kedua ujungnya, sehingga cocok untuk antrian, stack, atau log.

# LPUSH: Push an element to the head (left) of the list
r.lpush("task_queue", "task1")

# RPUSH: Push an element to the tail (right) of the list
r.rpush("task_queue", "task2")
r.rpush("task_queue", "task3")

# LPOP: Pop (remove and return) the element at the head
task = r.lpop("task_queue")
print(task)  # b'task1'

# Optional: RPOP removes and returns the element at the tail
task = r.rpop("task_queue")
print(task)  # b'task3'

lpush("task_queue", "task1") menambahkan "task1" ke sisi kiri list bernama "task_queue". rpush("task_queue", "task2") dan rpush("task_queue", "task3") menambahkan tugas ke sisi kanan. lpop("task_queue") dan rpop("task_queue") menghapus dan mengembalikan item dari masing-masing ujung list.

Contoh: Menerapkan antrian sederhana berbasis Redis

def enqueue_task(queue_name, task):
    """
    Appends a task to the end (right) of the Redis list named queue_name.
    """
    r.rpush(queue_name, task)

def dequeue_task(queue_name):
    """
    Removes a task from the front (left) of the Redis list named queue_name.
    Returns the task as a string, or None if the queue is empty.
    """
    task = r.lpop(queue_name)
    return task.decode('utf-8') if task else None

# Example usage:
enqueue_task("my_queue", "send_email")
enqueue_task("my_queue", "generate_report")

while True:
    task = dequeue_task("my_queue")
    if not task:
        print("No more tasks in queue.")
        break
    print(f"Processing task: {task}")

enqueue_task selalu menambahkan tugas baru ke akhir list, yang meniru antrian FIFO tradisional. dequeue_task menghapus tugas dari depan. Jika list kosong, fungsi ini mengembalikan None.

While-loop memproses tugas hingga antrian kosong, lalu berhenti.

Hash di Redis

Hash mirip dengan kamus (dictionary) Python tetapi disimpan di Redis. Hash sangat cocok untuk mengelompokkan field terkait (mis., detail pengguna).

# HSET: Store 'name' and 'email' fields for a user hash key
r.hset("user:1001", "name", "Alice")
r.hset("user:1001", "email", "[email protected]")

# HGET: Retrieve a single field from the hash
email = r.hget("user:1001", "email")
print(email.decode('utf-8'))  # [email protected]

# HDEL: Remove a field from the hash
r.hdel("user:1001", "email")

hset("user:1001", "name", "Alice") menetapkan field "name" bernilai "Alice" di dalam hash pada key "user:1001". hget("user:1001", "email") mengambil field "email". hdel("user:1001", "email") menghapus field "email" dari hash tersebut.

Contoh: Menyimpan dan mengakses profil pengguna terstruktur

def create_user_profile(user_id, name, email):
    """
    Creates a user profile in Redis under the key 'user:{user_id}'.
    'name' and 'email' are stored as separate fields in the hash.
    """
    user_key = f"user:{user_id}"
    r.hset(user_key, mapping={"name": name, "email": email})

def get_user_profile(user_id):
    """
    Retrieves and returns all fields in the user profile hash
    as a Python dictionary. Keys and values are decoded from bytes.
    """
    user_key = f"user:{user_id}"
    profile_data = r.hgetall(user_key)
    return {k.decode('utf-8'): v.decode('utf-8') for k, v in profile_data.items()}

def delete_user_profile(user_id):
    """
    Deletes the entire user profile key from Redis.
    """
    user_key = f"user:{user_id}"
    r.delete(user_key)

# Usage demonstration
create_user_profile(1002, "Bob", "[email protected]")
print(get_user_profile(1002))  # e.g. {'name': 'Bob', 'email': '[email protected]'}
delete_user_profile(1002)

Kita menyimpan nama dan email pengguna di dalam hash. mapping={"name": name, "email": email} memanfaatkan kemampuan redis-py untuk menetapkan beberapa field sekaligus. r.hgetall(user_key) mengambil semua field dan nilai, dikembalikan sebagai dictionary berisi bytes mentah yang kita decode menjadi string. delete_user_profile menghapus seluruh key hash.

Set dan Sorted Set

Data di Redis dapat dikelola menggunakan set atau sorted set. 

Set adalah koleksi nilai unik, sedangkan sorted set adalah koleksi pasangan key-nilai dengan skor terkait pada setiap nilai. Struktur data ini menyediakan cara yang efisien untuk menyimpan dan mengambil data, sehingga berguna untuk aplikasi yang memerlukan pencarian cepat.

Set

Set di Redis mirip dengan himpunan matematika – berisi kumpulan elemen unik, dan tidak diperbolehkan ada duplikat. Set dapat digunakan untuk memodelkan hubungan antar entitas, seperti pengguna yang menyukai sebuah posting di media sosial.

Berikut demonstrasi set:

# SADD: Add multiple members to a set
r.sadd("tags:python", "redis", "windows", "backend")

# SMEMBERS: Retrieve all unique members in the set
tags = r.smembers("tags:python")
print(tags)  # {b'redis', b'windows', b'backend'}

Set Redis memastikan keunikan anggota. Upaya menambahkan anggota duplikat tidak akan berpengaruh.

Hasil smembers adalah set Python berisi bytes.

Sorted set

Sorted set di Redis mirip dengan set biasa, tetapi setiap anggotanya juga memiliki skor terkait. Ini memungkinkan operasi pengurutan dan pemeringkatan yang efisien pada set.

Sorted set sering digunakan untuk leaderboard, di mana skor merepresentasikan peringkat atau poin pemain.

Berikut demonstrasi sorted set:

# ZADD: Add members with scores
r.zadd("leaderboard", {"player1": 10, "player2": 20})

# ZRANGE: Retrieve members in ascending order of score
leaders = r.zrange("leaderboard", 0, -1, withscores=True)
print(leaders)  # [(b'player1', 10.0), (b'player2', 20.0)]

Sorted set menyimpan anggota dalam urutan tertentu yang ditentukan oleh skor numeriknya. zrange("leaderboard", 0, -1, withscores=True) mengembalikan semua anggota dari peringkat 0 hingga akhir, termasuk skornya.

Contoh: Mengelola tag atau leaderboard

Penggunaan sorted set dapat membantu dalam mengelola tag atau membuat leaderboard. 

def add_tag(post_id, tag):
    """
    Adds a 'tag' to the set of tags belonging to a specific post.
    Each post has its own set under 'post:{post_id}:tags'.
    """
    r.sadd(f"post:{post_id}:tags", tag)

def get_tags(post_id):
    """
    Retrieves all tags for a specific post, decoding the bytes into strings.
    """
    raw_tags = r.smembers(f"post:{post_id}:tags")
    return {tag.decode('utf-8') for tag in raw_tags}

def update_leaderboard(player, score):
    """
    Updates or inserts a player's score in the 'game:leaderboard' sorted set.
    A higher score indicates a better position if sorting descending.
    """
    r.zadd("game:leaderboard", {player: score})

def get_leaderboard():
    """
    Returns an ascending list of (player, score) tuples from the leaderboard.
    To invert the sorting (highest first), you'd use ZREVRANGE.
    """
    entries = r.zrange("game:leaderboard", 0, -1, withscores=True)
    return [(player.decode('utf-8'), score) for player, score in entries]

# Usage demonstration
add_tag(123, "python")
add_tag(123, "redis")
print(get_tags(123))

update_leaderboard("Alice", 300)
update_leaderboard("Bob", 450)
print(get_leaderboard())

add_tag dan get_tags mendemonstrasikan sistem tagging one-to-many, menyimpan tag dalam Set. update_leaderboard dan get_leaderboard menunjukkan cara mengimplementasikan leaderboard gim.

Fitur Redis dalam Aplikasi Python

Redis memiliki beberapa fitur yang menjadikannya pilihan populer untuk penyimpanan data dalam aplikasi Python: antrian, penguncian, dan caching. 

Berikut implementasinya dalam Python:

Redis sebagai antrian (dengan blocking)

Mari jelajahi penggunaan Redis sebagai antrian dengan blocking menggunakan BLPOP.

BLPOP adalah operasi blocking yang menunggu hingga elemen tersedia dalam list.

def blocking_consumer(queue_name):
    """
    Continuously listens to the specified queue (Redis list) using BLPOP,
    which blocks until new items are pushed. Once an item arrives,
    it is removed from the queue and processed.
    """
    print(f"Waiting on queue: {queue_name}")
    while True:
        result = r.blpop(queue_name)
        if result:
            list_name, task_bytes = result
            task = task_bytes.decode('utf-8')
            print(f"Received task: {task}")
        else:
            print("Queue is empty or an error occurred.")
            break

def enqueue_task(queue_name, task):
    """
    Pushes a task to the end of a Redis list (queue).
    """
    r.rpush(queue_name, task)

# Example usage:
enqueue_task("blocking_queue", "task_block_1")
enqueue_task("blocking_queue", "task_block_2")

# In a real application, the consumer might run in a separate thread or process
blocking_consumer("blocking_queue")

blocking_consumer menggunakan blpop dalam loop. Jika list kosong, blpop akan menunggu hingga item lain didorong masuk.

Setelah item diterima, item dihapus dari list dan dicetak.

Pendekatan ini ideal untuk pola produsen-konsumen di mana worker mengonsumsi tugas saat muncul.

Menerapkan lock di Redis

Lock terdistribusi mencegah beberapa klien atau proses secara bersamaan memodifikasi sumber daya yang sama. Redis dapat membantu menghindari race condition di lingkungan terdistribusi.

import time
from redis.exceptions import LockError

def process_critical_section():
    """
    Acquires a lock named 'resource_lock' with a timeout of 10 seconds.
    The lock automatically expires after 10 seconds to prevent deadlocks.
    """
    lock = r.lock("resource_lock", timeout=10)
    try:
        # Attempt to acquire the lock, wait for up to 5 seconds if another process holds it
        acquired = lock.acquire(blocking=True, blocking_timeout=5)
        if acquired:
            print("Lock acquired; performing critical operation...")
            time.sleep(3)  # Simulate some operation
        else:
            print("Failed to acquire lock within 5 seconds.")
    except LockError:
        print("A LockError occurred, possibly releasing already released lock.")
    finally:
        # Always release the lock in a finally block to ensure cleanup
        lock.release()
        print("Lock released.")

# Usage demonstration
process_critical_section()

Kita membuat lock dengan timeout=10, artinya jika lock tidak dirilis secara manual, Redis akan otomatis menghapusnya dalam 10 detik untuk mencegah blocking tanpa batas (deadlock). lock.acquire(blocking=True, blocking_timeout=5) mencoba memperoleh lock selama 5 detik sebelum menyerah. Setelah selesai, lock.release() membebaskan sumber daya untuk proses lain.

Caching dengan Redis

Caching adalah skenario penggunaan umum: menyimpan data yang sering diakses di memori, mengurangi beban pada database atau API eksternal.

import requests
import json

def get_user_data(user_id):
    """
    Retrieves user data from a hypothetical API endpoint.
    If the data is found in Redis (cache), use that. Otherwise, call the API,
    store the response in Redis with a 60-second expiration, and return it.
    """
    cache_key = f"user_data:{user_id}"
    cached_data = r.get(cache_key)
    if cached_data:
        print("Cache hit!")
        return json.loads(cached_data)

    print("Cache miss. Fetching from API...")
    response = requests.get(f"https://api.example.com/users/{user_id}")
    user_info = response.json()

    # Store in Redis for 60 seconds
    r.setex(cache_key, 60, json.dumps(user_info))
    return user_info

# Usage
user = get_user_data(42)  # First call => cache miss
user_again = get_user_data(42)  # Subsequent call => cache hit

Kita memeriksa apakah user_data:{user_id} ada di Redis. Jika ada, itu cache hit, dan kita melewati pemanggilan API. Jika tidak, kita ambil dari API jarak jauh, lalu setex (set + kedaluwarsa) selama 60 detik. Panggilan berikutnya dalam rentang waktu tersebut akan mengambil data dari cache, menurunkan latensi.

Topik Lanjutan di Redis

Sudah merasa cukup paham Redis? Mari bahas beberapa topik yang lebih lanjut.

Menggunakan Pub/Sub dengan Redis

Pub/Sub (Publish/Subscribe) adalah pola messaging populer untuk komunikasi real-time. Publisher mengirim pesan ke sebuah kanal, dan semua subscriber kanal tersebut menerima pesan.

import threading

def subscriber(r, channel_name):
    """
    Subscribes to the given Redis channel and listens for messages.
    When a new message is published on that channel, it is printed.
    """
    pubsub = r.pubsub()
    pubsub.subscribe(channel_name)
    print(f"Subscribed to {channel_name}")

    # pubsub.listen() yields messages from the subscribed channel(s) in real time
    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"Received message: {message['data'].decode('utf-8')}")

def publisher(r, channel_name, message):
    """
    Publishes a message to the specified Redis channel.
    All subscribers to this channel immediately receive the message.
    """
    r.publish(channel_name, message)

# Example usage
channel = "updates"

# Start subscriber in a separate thread to avoid blocking the main thread
sub_thread = threading.Thread(target=subscriber, args=(r, channel))
sub_thread.start()

# Publish messages
publisher(r, channel, "Hello from Windows!")
publisher(r, channel, "Another update!")

pubsub = r.pubsub() membuat objek PubSub. pubsub.subscribe(channel_name) menginstruksikan Redis untuk mengirim pesan dari kanal tersebut ke objek PubSub. pubsub.listen() adalah iterator tak terbatas, menghasilkan pesan saat datang. r.publish(channel_name, message) mengirim pesan ke semua subscriber channel_name.

Masa berlaku (expiry) key di Redis

Redis mendukung time-to-live (TTL). Ini penting untuk data sementara seperti sesi atau cache berumur pendek.

# EXPIRE: Set a 30-second expiration on a key
r.set("temp_key", "some value")
r.expire("temp_key", 30)

# SETEX: Combined set + expire in one command
r.setex("temp_key2", 60, "another value")

r.expire("temp_key", 30) menetapkan TTL 30 detik. Setelah 30 detik, temp_key otomatis dihapus. r.setex("temp_key2", 60, "another value") adalah jalan pintas yang menetapkan key dan masa berlaku sekaligus.

Contoh: Kedaluwarsa sesi

Berikut contoh bagaimana Anda dapat menggunakan key yang kedaluwarsa untuk menetapkan sesi berakhir setelah durasi waktu tertentu.

def store_session_with_expiry(user_id, token, ttl=3600):
    """
    Stores a session token for a specific user with a time-to-live (TTL).
    By default, the session expires after 1 hour (3600 seconds).
    """
    session_key = f"user:{user_id}:session"
    r.setex(session_key, ttl, token)

def get_session_with_expiry(user_id):
    """
    Retrieves the session token for the user. Returns None if the key doesn't exist
    or if it has expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

# Usage
store_session_with_expiry(2001, "session_token_abc", 3600)
retrieved_token = get_session_with_expiry(2001)
print(f"Retrieved token: {retrieved_token}")

store_session_with_expiry menggunakan setex di balik layar untuk menyimpan user:{user_id}:session dengan TTL tertentu. Jika Anda tidak menetapkan TTL, key dapat bertahan tanpa batas.

Saat TTL berakhir, Redis akan menghapus key secara otomatis, sehingga sesi tidak dapat diambil lagi.

Praktik Terbaik Menggunakan Redis dengan Python

Mengelola Redis memerlukan beberapa pertimbangan dan praktik terbaik untuk memastikan kinerja optimal dan menghindari jebakan umum.

Beberapa kiat yang perlu diingat meliputi:

  • Konfigurasikan opsi persistensi dengan tepat demi keamanan data.
  • Pantau penggunaan memori untuk mencegah error kehabisan memori.
  • Gunakan pipelining untuk operasi batch yang efisien.
  • Perhatikan latensi jaringan karena dapat berdampak pada kinerja saat bekerja dengan server Redis jarak jauh.
  • Amankan koneksi Redis dengan kata sandi dan firewall.

Kesimpulan

Redis adalah alat yang kuat dan serbaguna untuk mengelola data dalam aplikasi Python. Menggunakan Python dengan Redis dapat menghadirkan banyak aplikasi dan use case, mulai dari caching data hingga mengelola antrian. 

Ingin mempelajari lebih lanjut tentang Redis? Introduction to NoSQL kami dapat membantu Anda mempelajari cara menangani data key-value. Tertarik dengan Python? Maka Python Data Fundamentals skill track kami mungkin menjadi tempat terbaik untuk mulai.

Python Redis FAQs

Mengapa menggunakan Python untuk Redis?

Python adalah bahasa pemrograman yang serbaguna dan populer yang memungkinkan manipulasi data secara efisien dan mudah, menjadikannya pilihan ideal untuk bekerja dengan database Redis.

Bisakah saya menggunakan bahasa lain selain Python dengan Redis?

Ya, Redis mendukung banyak bahasa seperti Java, JavaScript, PHP, dan lainnya. Namun, Python dikenal karena kesederhanaan dan fleksibilitasnya saat bekerja dengan Redis.

Apakah Redis sulit dipelajari bagi pemula?

Meskipun mungkin ada kurva pembelajaran di awal, sintaks Python yang jelas membuatnya relatif mudah dipelajari. Selain itu, banyak sumber daya daring tersedia untuk membantu pemula mempelajari cara menggunakan Redis.

Apa yang bisa saya lakukan dengan Python dan Redis?

Dengan Python dan Redis, Anda dapat melakukan berbagai tugas seperti manipulasi data, caching, messaging, dan lainnya. Anda juga dapat mengintegrasikan Redis dengan alat dan teknologi lain untuk meningkatkan aplikasi Anda.

Apa saja use case praktis menggunakan Python dan Redis bersama-sama?

Beberapa use case umum mencakup analitik real-time, manajemen sesi, antrian tugas, dan caching database. Selain itu, Anda dapat menggunakan Python dan Redis untuk membangun aplikasi web yang terukur, chatbot, dan model pembelajaran mesin.

Austin Chia

Penulis

Austin Chia

LinkedIn

Saya Austin, seorang blogger dan penulis teknologi dengan pengalaman bertahun-tahun sebagai data scientist dan analis data di bidang kesehatan. Memulai perjalanan teknologi dengan latar belakang biologi, kini saya membantu orang lain melakukan transisi yang sama melalui blog teknologi saya. Ketertarikan saya pada teknologi mendorong kontribusi tulisan saya untuk puluhan perusahaan SaaS, menginspirasi orang lain dan membagikan pengalaman saya.

Topik

PythonRekayasa Data

Terkait

blogs

Tutorial Korelasi di R

blogs

Spaghetti Plot dan Jalur Badai

blogs

40 Pertanyaan Wawancara DBMS Teratas di 2026

Lihat Selengkapnya →