Implement data ops (Redis)

IMPORTANTE

Azure Managed Redis soporta standard Redis commands para data ops. Redis soporta varios tipos de datos más allá de strings.

Data type Ops
string operations String ops (SET, GET, MSET, MGET) funcionan con texto o datos serializados. ATENCIÓN: Al usar decode_responses=True en la conexión, Redis automáticamente convierte byte responses en strings. Para datos binarios como imágenes poner decode_responses=False para trabajar con raw bytes.
hash operations Redis Hashes (HSET, HGET, HGETALL) guarda pares clave-valor. Es ideal para representar datos estructurados. Los hashes son más memory-efficient que guardar cada campo como una key separada.
list operations Redis Lists (LPUSH/RPUSH, LPOP/RPOP, LRANGE) son colecciones ordenadas de strings, perfectas para queues, activity feeds o items recientes. Soporta ambos stack LIFO y queue FIFO.
numeric operations Redis proporciona incrementos y decrementos atómicos (INCR, DECR, INCRBY, DECRBY) que funcionan con string values numéricos. Al ser atómicos lo hace ideal para contadores, rate limits y distributed counting scenarios with race conditions. Los valores se guardan como strings pero Redis los trata como ints para estas operaciones

/IMPORTANTE

Usamos la librería redis-py. Soporta ambos sync y async ops.

Uso standard de Redis

import redis

# Create a Redis client
r = redis.Redis(
    host='your-redis-instance',
    port=10000,
    ssl=True,
    decode_responses=True,  # Convert byte responses to strings automatically
    password='your-access-key'
)

Para PROD podemos usar Entra ID con redis-entraid

import redis
from azure.identity import DefaultAzureCredential
from redis_entraid.cred_provider import create_from_default_azure_credential

# Create credential provider using DefaultAzureCredential
credential_provider = create_from_default_azure_credential(
    ("https://redis.azure.com/.default",),
)

# Create a Redis client with Azure Entra ID authentication
r = redis.Redis(
    host='your-redis-instance',
    port=10000,
    ssl=True,
    decode_responses=True,  # Convert byte responses to strings automatically
    credential_provider=credential_provider
)

Basic data ops

Get and Set ops

obtener y guardar valores

# Store a value
result = r.set('user:1001:name', 'Alice Smith')
print(f"SET operation successful: {result}")  # Returns True

# Retrieve the value
name = r.get('user:1001:name')
print(f"Retrieved name: {name}")  # Output: Alice Smith

Los Hashes guardan multiples pares clave-valor en una sola key. Ideal para estructuras como user profiles

# Store multiple fields in a hash
r.hset('user:1001', mapping={
    'name': 'Alice Smith',
    'email': 'alice@example.com',
    'age': '28'
})

# Retrieve a single field
name = r.hget('user:1001', 'name')
print(f"Name: {name}")  # Output: Alice Smith

# Retrieve all fields
user_data = r.hgetall('user:1001')
print(f"User data: {user_data}")  # Returns dict with all fields

Multiple key ops

Cuando necesitas trabajar con multiples string keys de manera simultanea usa MSET y MGET para mejor performance.

# Set multiple keys at once
r.mset({
    'user:1001:name': 'Alice Smith',
    'user:1001:email': 'alice@example.com',
    'user:1001:age': '28'
})

# Get multiple values at once
values = r.mget('user:1001:name', 'user:1001:email', 'user:1001:age')
print(f"User data: {values}")  # Returns list of values

Para Hash ops, multiple key ops puede involucrar trabajar con multiple hash keys

# Using pipeline for multiple hash operations (efficient)
pipe = r.pipeline()
pipe.hgetall('user:1001')
pipe.hgetall('user:1002')
results = pipe.execute()
# Returns list of dicts, one for each hash

# Or retrieve specific fields from multiple hashes
pipe = r.pipeline()
pipe.hget('user:1001', 'name')
pipe.hget('user:1002', 'name')
names = pipe.execute()
# Returns list of names: ['Alice Smith', 'Bob Jones', 'Carol White']

Check Key existence

Antes de sacar o actualizar datos verificar que existen con EXISTS - se puede usar con todos los tipos de datos

# Check if a key exists
if r.exists('user:1001:name'):
    print("Key exists")

# Check multiple keys
count = r.exists('user:1001:name', 'user:1001:email', 'user:9999:name')
print(f"Number of existing keys: {count}")  # Returns 2

Delete ops

Borramos keys de la cache con DELETE cuando los datos ya no se necesitan o se vuelven obsoletos. DELETE funciona para todos los tipos de data types. Borra la key y sus datos asociados.

# Delete a single key
result = r.delete('user:1001:name')
print(f"Keys deleted: {result}")  # Returns count of deleted keys

# Delete multiple keys
result = r.delete('user:1001:email', 'user:1001:age')
print(f"Keys deleted: {result}")

Working with expiration

Es crucial poner expiration times para que se invaliden automaticamente. EXPIRE, SETEX, TTL funcionan con todos los data types.

Set value with expiration

Usamos SETEX para hacer set de un string value y su fecha de expiracion en una sola operacion atomica. Para otros datos como Hashes o Listas primero se guardan los datos, luego se usa EXPIRE para añadir fecha de expiración.

# Set a key with 60-second expiration
r.setex('session:abc123', 60, 'user_data')

# Alternative: Set value with expiration in milliseconds
r.psetex('temp:data', 5000, 'temporary_value')  # Expires in 5000ms

Add expiration to existing keys

Añadimos fecha de expiracion a todas las keys que ya existen en cache. Usamos EXPIRE, PEXPIRE, EXPIREAT. Funcionan con todos los tipos de datos

# Set a key without expiration
r.set('user:1002:preferences', 'dark_mode')

# Add 3600-second (1 hour) expiration
r.expire('user:1002:preferences', 3600)

# Set expiration in milliseconds
r.pexpire('user:1002:preferences', 3600000)

# Set expiration at specific Unix timestamp
import time
expire_at = int(time.time()) + 7200  # 2 hours from now
r.expireat('user:1002:preferences', expire_at)

Check y manage TTL

Monitorizamos el TTL para saber cuando expiran las keys. TTL, PTTL, PERSIST funcionan con todos los tipos de datos.

# Get TTL in seconds
ttl = r.ttl('user:1002:preferences')
if ttl == -1:
    print("Key exists but has no expiration")
elif ttl == -2:
    print("Key does not exist")
else:
    print(f"Key expires in {ttl} seconds")

# Get TTL in milliseconds
ttl_ms = r.pttl('user:1002:preferences')
print(f"Key expires in {ttl_ms} milliseconds")

# Remove expiration (persist the key)
r.persist('user:1002:preferences')

Cache invalidation patterns

Una cache efectiva asegura que tu app sirve datos frescos y mantiene una buena performance.

Time-based invalidation

La manera más simple. Usamos TTL para expirar automaticamente los datos de la cache después de un tiempo.

def cache_database_query(query_key, query_function, ttl=300):
    """
    Cache database query results with automatic expiration.

    Args:
        query_key: Cache key for the query
        query_function: Function that executes the database query
        ttl: Time to live in seconds (default: 5 minutes)
    """
    # Check if result is cached
    cached_result = r.get(query_key)
    if cached_result:
        print("Cache hit")
        return cached_result

    # Execute query and cache result
    print("Cache miss - executing query")
    result = query_function()
    r.setex(query_key, ttl, result)
    return result

# Usage example
def get_product_details():
    # Simulate database query
    return "Product: Laptop, Price: $999"

product_data = cache_database_query('product:12345', get_product_details, ttl=600)

Manual invalidation on update

Cuando los datos cambian, hacemos update o remove de los datos en cache de manera explicita para mantener consistencia

def update_user_profile(user_id, new_data):
    """
    Update user profile and invalidate related cache entries.
    """
    # Update database (simulated)
    save_to_database(user_id, new_data)

    # Invalidate all related cache keys
    cache_keys = [
        f'user:{user_id}:profile',
        f'user:{user_id}:summary',
        f'dashboard:user:{user_id}'
    ]
    deleted = r.delete(*cache_keys)
    print(f"Invalidated {deleted} cache entries")

def save_to_database(user_id, data):
    # Placeholder for database operation
    pass

Cache-aside pattern with expiration

Implementar el patrón cache-aside (lazy loading) con expiración automática para optimal cache usage

def get_user_data(user_id, ttl=3600):
    """
    Retrieve user data using cache-aside pattern.

    Args:
        user_id: User identifier
        ttl: Cache expiration in seconds (default: 1 hour)
    """
    cache_key = f'user:{user_id}:data'

    # Try to get from cache
    cached_data = r.get(cache_key)
    if cached_data:
        return cached_data

    # Cache miss - fetch from database
    user_data = fetch_from_database(user_id)

    # Store in cache with expiration
    if user_data:
        r.setex(cache_key, ttl, user_data)

    return user_data

def fetch_from_database(user_id):
    # Placeholder for database query
    return f"User data for {user_id}"

Pattern-based invalidation

Borramos multiples keys relacionadas usando pattern matching con el comando SCAN (no KEYS, lo cual bloquea el server)

def invalidate_user_cache(user_id):
    """
    Invalidate all cache entries for a specific user.
    Uses SCAN for non-blocking pattern matching.
    """
    pattern = f'user:{user_id}:*'
    cursor = 0
    deleted_count = 0

    while True:
        cursor, keys = r.scan(cursor, match=pattern, count=100)
        if keys:
            deleted_count += r.delete(*keys)
        if cursor == 0:
            break

    print(f"Invalidated {deleted_count} keys for user {user_id}")

# Usage
invalidate_user_cache(1001)

Best practices

  • Use connection pooling: La libreria redis usa automaticamente connection pooling, pero es algo que se puede configurar
  • Handle errors gracefully
  • Choose appropiate TTL values
    • Frequent chaging data: 1-5 mins
    • Moderate change rate: 15-60 mins
    • Relative stable data: 1-24 hours
    • Static reference data: +24 hours