Python Redis: Yeni Başlayanlar İçin Kılavuz

Redis’i Python ile kullanmak, yüksek performanslı, ölçeklenebilir ve bakımı kolay sistemler kurmak isteyen veri mühendisleri için güçlü bir bileşimdir. Önbellek katmanlarını optimize etmek, gerçek zamanlı olay akışlarını yönetmek veya dağıtılmış kilitleme uygulamak isteyin, Redis esnek ve verimli bir çözüm sunar.

Bu kılavuzda, veri mühendisliği iş akışlarınıza sorunsuzca entegre edebilmeniz için Python ile Redis kullanımının temellerini ele alacağız.

Python Redis nedir?

Redis, veritabanı, önbellek ve ileti aracısı olarak kullanılan açık kaynaklı, bellek içi bir veri yapısı deposudur. Remote Dictionary Server’ın kısaltmasıdır ve başlangıçta hızlı erişim sürelerine sahip bir anahtar-değer depolama sistemi olarak tasarlanmıştır.

Çeşitli veri yapılarını destekler; örneğin string’ler, hash’ler, listeler, kümeler ve aralık sorgularını destekleyen sıralı kümeler. Redis ayrıca daha iyi erişilebilirlik ve ölçeklenebilirlik için işlemler, pub/sub mesajlaşma, Lua betikleme ve yerleşik çoğaltma ile kümeleme gibi gelişmiş özellikler sunar.

Yaygın Redis kullanım alanları

Redis’in potansiyel kullanım alanları geniş ve çeşitlidir.

Veri mühendisliğinde en yaygın kullanım alanlarından bazıları şunlardır: 

• Önbellekleme: Veritabanı sorgularını ve API yanıtlarını hızlandırın.
• Mesaj kuyrukları: Olay güdümlü mimarileri ve işleme hatlarını besleyin.
• Gerçek zamanlı analitik: Akış verilerini minimum gecikmeyle işleyin ve analiz edin.
• Liderlik tabloları: En yüksek puanlı varlıkları verimli şekilde sıralayın ve alın.
• Oturum depolama: Hızlı ve ölçeklenebilir oturum durumu yönetin.
• İş kuyruğu yönetimi: Görev zamanlama ve yürütmeyi verimli kılın.
• Coğrafi uzamsal indeksleme: Konuma dayalı verileri saklayın ve sorgulayın.

Redis ayrıca performans ve ölçeklenebilirliği optimize etmek için web sunucuları (örn. NGINX), veritabanları (örn. MySQL) ve mesajlaşma sistemleri (örn. Kafka) gibi diğer teknolojilerle birlikte de sıkça kullanılır.

Neden Redis’i Python ile kullanmalı?

Python, esnekliği, geniş ekosistemi ve büyük veri teknolojileriyle kolay entegrasyonu sayesinde veri mühendisliğinde baskın bir dildir. 

Onu Redis ile birleştirmek uygulamalarınıza pek çok fayda sağlayabilir:

• Hızlı performans: Redis verileri bellekte tuttuğu için, verileri diskte saklayan geleneksel veritabanlarına kıyasla çok daha hızlı erişim süreleri sunabilir. Bu da onu önbellekleme ve gerçek zamanlı uygulamalar gibi yüksek performans gerektiren senaryolar için ideal kılar.
• Ölçeklenebilirlik: Redis, ölçeklenebilirlik gözetilerek tasarlanmıştır; performanstan ödün vermeden büyük miktarda veriyi yönetmeyi kolaylaştırır.
• Kullanım kolaylığı: Python’un yalın sözdizimi ve zengin kütüphane ekosistemi, Redis ile çalışmayı kolaylaştırır. Resmi Redis-py istemci kütüphanesi de Python kodunuzdan Redis ile etkileşim kurmak için kullanıcı dostu bir arayüz sağlar.

Redis-py nedir?

Redis-py Python için resmi Redis istemci kütüphanesidir. Python kodunuzdan Redis ile iletişim kurmak için kullanıcı dostu bir arayüz sağlar.

Başlıca özelliklerinden bazıları şunlardır:

• Tüm Redis veri tipleri için destek
• Verimli ve atomik işlemler için pipeline ve işlem desteği
• Pub/sub mesajlaşma desteği
• Bayt, string ve diğer Python türlerine otomatik kodlama/kod çözme
• Redis kümeleriyle çalışmak için küme modu desteği

Python Geliştirme için Redis’i Kurma

Hadi, Python kullanarak Redis’i kendimiz için nasıl kurabileceğimize bakalım.

Redis’i çalıştırmanın üç ana yolu vardır:

1. Docker (Veri mühendisleri için önerilir)
2. Windows için Linux Alt Sistemi (WSL)
3. Üçüncü Taraf Derlemeler (örn., Memurai, tporadowski/redis)

Yöntem A: Docker kullanma

Öncelikle, Docker kullanırken bilgisayarınızda Docker Desktop kurulu olmalıdır. Bunu DockerHub web sitesinden indirebilirsiniz.

Docker kurulduktan sonra komut istemini açın ve aşağıdaki komutu girin.

docker pull redisAltyapı:

Sırada yeni bir konteyner başlatacağız.

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

docker pull redis en güncel resmi Redis imajını indirir. docker run --name my-redis -p 6379:6379 -d redis my-redis adlı yeni bir konteyner başlatır. -p 6379:6379 parametresi yerel makinenizdeki 6379 portunu konteynerin 6379 portuna eşler; böylece localhost:6379 üzerinden Redis’e bağlanabilirsiniz. -d bayrağı konteyneri arka planda (detached modda) çalıştırır.

Doğrulamak için şunu çalıştırın:

docker exec -it my-redis redis-cli pingAltyapı:

Yanıt PONG olmalıdır.

Yöntem B: Windows için Linux Alt Sistemi (WSL) kullanma

Windows makineleri için bir diğer yöntem de kurulumda Windows Alt Sistemini kullanmaktır. Bu, kurulumu Linux üzerinden gerçekleştirecektir.

wsl --installAltyapı:

Bu komut, WSL içinde varsayılan Ubuntu dağıtımını kurar ve yapılandırır. Gerekirse yeniden başlatın.

Ardından, Ubuntu terminalinizi (Microsoft Store’dan veya PowerShell’de wsl yazarak) açın ve şunu çalıştırın:

sudo apt-get update
sudo apt-get install redis-serverAltyapı:

Sonra Redis sunucunuzu başlatın.

sudo service redis-server startAltyapı:

Sunucunun çalışıp çalışmadığını görmek için bir test yapalım.

redis-cli pingAltyapı:

Yukarıda kullandığımız komutların ayrıntılı açıklaması şöyledir:

• sudo apt-get update en son paket tanımlarını çeker.
• sudo apt-get install redis-server Ubuntu ortamına Redis’i kurar.
• sudo service redis-server start Redis hizmetini anında başlatır.
• redis-cli ping yerel Redis sunucusuna bağlantıyı test eder; başarılıysa PONG döndürür.

Yöntem C: Üçüncü taraf derlemeler

• Memurai: Memurai.com
• tporadowski/redis: GitHub sürümleri

Bu çözümler yerel Windows ikili dosyaları sağlar. İndirip kurduktan veya arşivi açtıktan sonra şunu çalıştırın:

redis-server.exeAltyapı:

Başlatıldıktan sonra, redis-server.exe 127.0.0.1:6379 üzerinde dinlediğini belirten günlükler yazdırmalıdır.

Sağlanan CLI’yı (varsa) kullanarak doğrulayabilirsiniz:

redis-cli.exe pingAltyapı:

Başarılıysa PONG sonucu beklemelisiniz.

redis-py Kütüphanesini Kurma

Sonraki adımda, veritabanına Python ile erişebilmek için redis-py kütüphanesini kurmanız gerekir. Kurulumdan önce hem Python’un hem de Redis’in ayrı ayrı kurulu olduğundan emin olun.

pip install redisAltyapı:

Bu komut, PyPI’dan Python Redis istemci kütüphanesini (redis-py) indirip kurar. Sanal ortam kullanıyorsanız, bu komutu çalıştırmadan önce etkinleştirdiğinizden emin olun.

Şununla doğrulayın:

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

Bu, bir sürüm numarası yazdırmalıdır (ör. 5.2.1).

Bir Redis sunucusu kurma

Yukarıdaki yöntemlerden herhangi birini (Docker, WSL veya üçüncü taraf derleme) izlediyseniz, artık localhost:6379 üzerinde çalışan bir Redis sunucunuz olmalıdır. Bu, Windows’ta yerel geliştirme için yeterlidir.

Redis Veri Yapılarıyla Çalışma

Aşağıda, farklı Redis veri tiplerine bağlanmayı ve bunları yönetmeyi gösteren Python örnekleri yer alır. Her kod bloğu, yöntemlerin veya komutların nasıl çalıştığını ayrıntılandıran açıklayıcı yorumlar içerir.

Redis’te String’ler

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")Altyapı:

Yerel Redis sunucusuna bağlanan bir Redis nesnesi oluşturuyoruz.

• r.set("mykey", "hello from Windows") "mykey" anahtarı altında "hello from Windows" string’ini depolar.
• r.get("mykey") mykey’de depolanan değeri getirir. Redis bayt döndürür, bu yüzden insan tarafından okunabilir çıktı için kod çözeriz.
• r.delete("mykey") mykey anahtarını tamamen siler.

Örnek: Kullanıcı oturumlarını depolama ve alma

İşte kullanıcı oturum yönetimine dair bir kod örneği:

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 emptyAltyapı:

store_user_session(user_id): uuid.uuid4() ile küresel olarak benzersiz bir kimlik oluşturur ve kullanıcıya özgü bir anahtar altında saklar. get_user_session(user_id): Oturum belirtecini okur. None ise oturum eksik ya da süresi dolmuştur. delete_user_session(user_id): Oturum anahtarını Redis’ten kaldırır ve kullanıcıyı fiilen oturumdan çıkarır.

Redis’te Listeler

Redis Listeleri sıralı string dizileridir. Her iki uçta da işlem yapmaya izin verir; bu da onları kuyruklar, yığınlar veya günlükler için kullanışlı kılar.

# 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'Altyapı:

lpush("task_queue", "task1") "task_queue" adlı listenin sol tarafına "task1" ekler. rpush("task_queue", "task2") ve rpush("task_queue", "task3") görevleri sağ tarafa ekler. lpop("task_queue") ve rpop("task_queue") listedeki öğeleri ilgili uçlardan kaldırıp döndürür.

Örnek: Basit bir Redis destekli kuyruk uygulama

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}")Altyapı:

enqueue_task her zaman yeni görevleri listenin sonuna ekler; bu da geleneksel bir FIFO kuyruğunu simüle eder. dequeue_task görevleri baştan kaldırır. Liste boşsa None döner.

While döngüsü, kuyruk boşalana kadar görevleri işler ve sonra durur.

Redis’te Hash’ler

Hash’ler, Python sözlüklerine benzer ancak Redis’te depolanır. İlgili alanları (örn. kullanıcı ayrıntıları) gruplamak için idealdir.

# 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")Altyapı:

hset("user:1001", "name", "Alice") "user:1001" anahtarındaki hash içinde "name" alanını "Alice" değerine ayarlar. hget("user:1001", "email") "email" alanını getirir. hdel("user:1001", "email") bu hash’ten "email" alanını siler.

Örnek: Yapılandırılmış kullanıcı profillerini depolama ve erişme

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)Altyapı:

Bir kullanıcının adını ve e-postasını bir hash içinde saklıyoruz. mapping={"name": name, "email": email} birden fazla alanı aynı anda ayarlamak için redis-py yeteneğini kullanır. r.hgetall(user_key) tüm alanları ve değerleri döndürür; bunlar bayt sözlüğü olarak gelir ve string’e kod çözme yaparız. delete_user_profile tüm hash anahtarını kaldırır.

Kümeler ve Sıralı Kümeler

Veriler Redis’te kümeler veya sıralı kümeler kullanılarak yönetilebilir. 

Kümeler benzersiz değerlerden oluşur; sıralı kümeler ise her değerle ilişkilendirilmiş bir puana sahip anahtar-değer çiftlerinden oluşur. Bu veri yapıları verileri verimli şekilde saklayıp almayı sağlar ve hızlı arama gerektiren uygulamalar için kullanışlıdır.

Kümeler

Redis’te bir küme matematiksel kümeye benzer – benzersiz öğelerden oluşur ve yinelenen öğelere izin verilmez. Kümeler, örneğin bir sosyal medya gönderisini beğenen kullanıcılar gibi farklı varlıklar arasındaki ilişkileri modellemek için kullanılabilir.

İşte kümelere bir örnek:

# 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'}Altyapı:

Redis Kümeleri, üyelerin benzersiz olmasını garanti eder. Yinelenen bir üye eklemeye çalışmak hiçbir etki yaratmaz.

smembers sonucı bir Python bayt kümesidir.

Sıralı kümeler

Redis’te sıralı kümeler normal kümelere benzer, ancak her üyenin karşılık gelen bir puanı vardır. Bu, küme üzerinde verimli sıralama ve derecelendirme işlemlerine olanak tanır.

Sıralı kümeler çoğunlukla oyuncunun sıralamasını veya puanını temsil eden skorların bulunduğu liderlik tablolarında kullanılır.

İşte sıralı kümelere bir örnek:

# 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)]Altyapı:

Sıralı kümeler üyeleri sayısal puanlarına göre belirlenen belirli bir sırada saklar. zrange("leaderboard", 0, -1, withscores=True) 0. sıradan sona kadar tüm üyeleri, skorlarıyla birlikte döndürür.

Örnek: Etiketleri veya liderlik tablolarını yönetme

Sıralı kümelerin kullanımı, etiketleri yönetmede veya liderlik tabloları oluşturmada yardımcı olabilir. 

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())Altyapı:

add_tag ve get_tags, Etiketleri bir Kümede saklayarak bire-çok etiketleme sistemini gösterir. update_leaderboard ve get_leaderboard bir oyun liderlik tablosunun nasıl uygulanabileceğini gösterir.

Python Uygulamalarında Redis Özellikleri

Redis’in Python uygulamalarında popüler olmasını sağlayan bir dizi özelliği vardır: kuyruklama, kilitleme ve önbellekleme. 

Aşağıda Python’daki uygulamalarını bulabilirsiniz:

Redis’i kuyruk olarak kullanma (bloklamalı)

Şimdi BLPOP kullanarak bloklamalı bir kuyruk olarak Redis kullanımını inceleyelim.

BLPOP, bir listede bir öğe mevcut olana kadar bekleyen bloklayıcı bir işlemdir.

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")Altyapı:

blocking_consumer, döngü içinde blpop kullanır. Liste boşsa blpop başka bir öğe itilene kadar bekler.

Bir öğe alındığında, listeden kaldırılır ve yazdırılır.

Bu yaklaşım, çalışanların görevleri ortaya çıktıkça tükettiği üretici-tüketici desenleri için idealdir.

Redis’te kilitleri uygulama

Dağıtılmış kilitler, aynı kaynağı aynı anda birden fazla istemci veya sürecin değiştirmesini engeller. Redis, dağıtık ortamlarda yaşanabilecek yarış durumlarını önlemeye yardımcı olabilir.

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()Altyapı:

timeout=10 ile bir kilit oluşturuyoruz; kilit manuel olarak serbest bırakılmazsa Redis, belirsiz süreli bloklanmayı (deadlock) önlemek için 10 saniye sonra otomatik olarak kaldırır. lock.acquire(blocking=True, blocking_timeout=5) kilidi edinmeyi 5 saniyeye kadar dener, sonra vazgeçer. İş bitince lock.release(), kaynağı diğer süreçlere açar.

Redis ile önbellekleme

Önbellekleme yaygın bir kullanım senaryosudur: sık erişilen verileri bellekte tutarak veritabanları veya harici API’ler üzerindeki yükü azaltır.

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 hitAltyapı:

Redis’te user_data:{user_id} olup olmadığını kontrol ediyoruz. Varsa, bu bir önbellek isabetidir ve API çağrısını atlarız. Yoksa, uzak API’dan getirir ve 60 saniyelik süreyle setex kullanarak saklarız. Bu süre içinde yapılacak sonraki çağrılar önbellekten dönecek ve gecikmeyi azaltacaktır.

Redis’te İleri Konular

Redis’e hâkim olduğunuzu mu düşünüyorsunuz? Biraz daha ileri konulara göz atalım.

Redis ile Pub/Sub kullanma

Pub/Sub (Yayınla/Abone Ol), gerçek zamanlı iletişim için popüler bir mesajlaşma modelidir. Yayıncılar bir kanala mesaj gönderir ve o kanala abone olan herkes bu mesajları alır.

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!")Altyapı:

pubsub = r.pubsub() bir PubSub nesnesi oluşturur. pubsub.subscribe(channel_name), Redis’e o kanaldaki mesajları PubSub nesnesine yönlendirmesini söyler. pubsub.listen() gelen mesajları sunduğu sonsuz bir yineliyicidir. r.publish(channel_name, message) channel_namein tüm abonelerine bir mesaj gönderir.

Redis’te anahtarların sona ermesi

Redis, time-to-live (TTL) desteğine sahiptir. Bu, oturumlar veya kısa ömürlü önbellekler gibi geçici veriler için gereklidir.

# 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")Altyapı:

r.expire("temp_key", 30) 30 saniyelik bir TTL ayarlar. 30 saniye sonra temp_key otomatik olarak silinir. r.setex("temp_key2", 60, "another value") anahtar ve son kullanımı aynı anda ayarlayan kısayoldur.

Örnek: Oturum süresi sonlandırma

Aşağıda, anahtarların süresini ayarlayarak bir oturumu belirli bir sürenin ardından nasıl sonlandırabileceğinize dair bir örnek bulabilirsiniz.

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}")Altyapı:

store_session_with_expiry, belirlenmiş bir TTL ile setex kullanarak user:{user_id}:session’ı saklar. TTL vermezseniz anahtar süresiz kalabilir.

TTL dolduğunda, Redis anahtarı otomatik olarak kaldırır ve oturumu almak imkânsız hale gelir.

Python ile Redis Kullanımı için En İyi Uygulamalar

Redis’i kullanırken, en iyi performansı sağlamak ve yaygın tuzaklardan kaçınmak için bazı hususları ve en iyi uygulamaları göz önünde bulundurmak gerekir.

Aklınızda tutmanız gereken bazı ipuçları şunlardır:

• Veri güvenliği için kalıcılık seçeneklerini doğru yapılandırın.
• Bellek kullanımını izleyin; bellek taşmalarını önleyin.
• Toplu işlemler için pipelining kullanın.
• Uzak bir Redis sunucusuyla çalışırken ağ gecikmesini takip edin; performansı etkileyebilir.
• Redis bağlantılarını parolalar ve güvenlik duvarlarıyla güvenceye alın.

Sonuç

Redis, Python uygulamalarında verileri yönetmek için güçlü ve çok yönlü bir araçtır. Python ile Redis kullanımı, verileri önbelleğe almaktan kuyrukları yönetmeye kadar pek çok uygulama ve kullanım alanı sunar. 

Redis hakkında daha fazla bilgi edinmek ister misiniz? NoSQL’e Giriş kursumuz, anahtar-değer verilerini nasıl yöneteceğinizi öğrenmenize yardımcı olabilir. Python ile ilgileniyorsanız, o halde Python Veri Temelleri beceri yolumuz başlamak için en iyi yer olabilir.