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
redisusa 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