Cache-strategier med Redis

import redis.asyncio as redis
import asyncio

async def connect_to_redis():
    # Connect to Redis server (default host/port)
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    try:
        # Ping to check connection
        await r.ping()
        print("Successfully connected to Redis!")
    except redis.exceptions.ConnectionError as e:
        print(f"Could not connect to Redis: {e}")
    finally:
        # Close the connection when done
        await r.close()

if __name__ == "__main__":
    # Run the async function
    asyncio.run(connect_to_redis())

import redis.asyncio as redis
import asyncio

async def basic_cache_example():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    key = "app:greeting"
    value = "Hello from your Redis cache!"

    # Store a value with a key
    await r.set(key, value)
    print(f"Set key '{key}' with value: '{value}'")

    # Retrieve the value using its key
    cached_value = await r.get(key)
    print(f"Retrieved value for '{key}': '{cached_value}'")

    await r.close()

if __name__ == "__main__":
    asyncio.run(basic_cache_example())

import redis.asyncio as redis
import asyncio
import json

async def cache_json_object_example():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    
    user_id = "user_456"
    user_profile = {"name": "Alice", "email": "alice@example.com", "age": 30}
    
    # Convert Python dict to JSON string
    json_profile = json.dumps(user_profile)
    
    # Store the JSON string in Redis
    await r.set(f"user:{user_id}", json_profile)
    print(f"Cached user profile for {user_id}")
    
    # Retrieve the JSON string from Redis
    cached_json = await r.get(f"user:{user_id}")
    if cached_json:
        # Convert JSON string back to Python dict
        retrieved_profile = json.loads(cached_json)
        print(f"Retrieved user name: {retrieved_profile['name']}")
    
    await r.close()

if __name__ == "__main__":
    asyncio.run(cache_json_object_example())

from fastapi import FastAPI, Depends
import redis.asyncio as redis
import asyncio
import json

app = FastAPI()

# Dependency to get a Redis client instance
async def get_redis_client():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    try:
        yield r # Provide the client
    finally:
        await r.close() # Ensure client is closed after request

@app.get("/products/{product_id}")
async def read_product(product_id: str, redis_client: redis.Redis = Depends(get_redis_client)):
    cache_key = f"product:{product_id}"
    
    # 1. Try to get data from cache
    cached_data = await redis_client.get(cache_key)
    if cached_data:
        print(f"Cache hit for {product_id}!")
        return json.loads(cached_data)
    
    # 2. If not in cache, simulate fetching from database
    print(f"Cache miss for {product_id}. Fetching from DB...")
    await asyncio.sleep(1) # Simulate I/O delay for DB call
    product_data = {"id": product_id, "name": f"Product {product_id}", "price": 99.99}
    
    # 3. Store in cache with 60-second TTL
    await redis_client.set(cache_key, json.dumps(product_data), ex=60)
    
    return product_data

# To run this example:
# 1. Ensure a Redis server is running (e.g., `redis-server` in your terminal).
# 2. Save this code as `main.py`.
# 3. Run Uvicorn: `uvicorn main:app --reload`.
# 4. Access in your browser: `http://127.0.0.1:8000/products/123`.
#    Refresh the page to see 'Cache hit' messages after the first request.