Introducción

Si usas Redis en un entorno compartido — ya sea una instancia usada por múltiples microservicios, múltiples equipos o múltiples tenants — una única clave grande puede degradar el rendimiento de todos los demás consumidores al mismo tiempo. No es una exageración: es como funciona Redis internamente, e ignorar este comportamiento en producción sale caro.

El problema de las claves grandes (big keys) en Redis existe porque el servidor es single-threaded para las operaciones de datos. Cuando un comando accede o manipula una clave que contiene cientos de megabytes — sea una lista con 500 mil elementos, un hash con 200 mil campos o un string binario de 50 MB — todo el event loop queda bloqueado procesando esa operación. Todos los demás clientes, de servicios completamente diferentes, quedan esperando en la cola. En entornos compartidos esto es fatal.

En este artículo voy a mostrar qué caracteriza a una clave grande en Redis, por qué el impacto se amplifica en entornos multi-tenant, cómo detectar big keys en producción, y las estrategias concretas para eliminar o mitigar el problema — con ejemplos en C# usando StackExchange.Redis.

Qué es una “Big Key” en Redis

Redis no tiene un límite fijo que defina cuándo una clave es “grande”. La comunidad y la documentación oficial usan el término big key para describir claves cuyo costo de procesamiento o de memoria es desproporcionado en relación con el workload general de la instancia.

En la práctica, los límites que suelen surgir como referencia son:

Tipo de DatoConsiderado “grande” a partir de
String / Binary> 5 MB
List> 10.000 elementos o > 10 MB
Hash> 10.000 campos
Set> 10.000 miembros
Sorted Set> 10.000 miembros
Stream> 10.000 mensajes pendientes

Estos números no son absolutos — dependen del hardware, de la versión de Redis y del patrón de acceso. Pero son referencias sólidas para alertas de monitoreo.

ℹ️ Información: Redis 7.0+ introdujo mejoras en las estructuras de datos internas (como Listpack reemplazando a ZipList), lo que cambió ligeramente los umbrales a partir de los cuales las estructuras se “promueven” a representaciones mayores. El concepto de big key, sin embargo, sigue siendo el mismo.

Diferencia entre clave grande y clave caliente

Es común confundir big key con hot key. Son problemas diferentes:

  • Big key: clave con mucho volumen de datos — el problema es el costo de CPU/memoria para procesar el dato.
  • Hot key: clave accedida con altísima frecuencia — el problema es la contención en el slot de hash (relevante en Redis Cluster).

Una clave puede tener ambos problemas al mismo tiempo, pero las soluciones son distintas. Este artículo se enfoca en las big keys.

Cómo Procesa Redis los Comandos (y por qué importa)

Para entender el impacto de las big keys, es necesario entender cómo Redis ejecuta los comandos. Redis usa un event loop single-threaded para procesar las operaciones de datos. Esto significa:

  1. El servidor recibe un comando de un cliente.
  2. El event loop ejecuta el comando hasta el final antes de procesar cualquier otro.
  3. Solo después se procesa el siguiente comando de la cola.

Esta arquitectura es una de las razones por las que Redis es tan rápido para operaciones simples: sin locks, sin context switching entre threads. El costo es que una operación lenta lo bloquea todo.

1
2
3
4
Cliente A: GET user:123          → respuesta en 0,1ms ✅
Cliente B: LRANGE big-list 0 -1  → 2,3s procesando 500k elementos ⚠️
Cliente C: SET config:timeout 30  → esperando en la cola... ⌛
Cliente D: GET session:abc123     → esperando en la cola... ⌛

⚠️ Atención: Comandos como LRANGE key 0 -1, SMEMBERS key, HGETALL key y KEYS * son O(N) — el costo crece linealmente con el tamaño de la estructura. En una clave con 500 mil elementos, esto puede tardar segundos.

El modelo de I/O de Redis no es bloqueante — pero el procesamiento sí

Es importante separar dos conceptos:

  • I/O: Redis usa multiplexación de I/O (epoll/kqueue), por lo que aceptar conexiones y leer datos de red no es bloqueante.
  • Procesamiento de comandos: la ejecución del comando en sí es single-threaded y bloqueante para los demás clientes.

Redis 6.0 introdujo threads de I/O para la lectura y escritura de red, pero la ejecución de los comandos sigue siendo single-threaded en el thread principal. El problema de las big keys no se resolvió con ese cambio.

Impacto en Entornos Compartidos

En un entorno donde una única instancia de Redis sirve a múltiples microservicios o a múltiples tenants de un SaaS, el impacto de una big key se amplifica porque:

1. La latencia afecta a todos, no solo al culpable

Si el servicio de informes lee una clave con 300 mil registros cada hora, eso introduce picos de latencia para el servicio de autenticación, el servicio de notificaciones y cualquier otro que comparta la misma instancia — aunque esos servicios estén funcionando perfectamente.

2. El consumo de memoria se disputa

Redis mantiene todos los datos en memoria. Una big key que ocupa 500 MB reduce el espacio disponible para todos los demás tenants. Cuando Redis alcanza maxmemory, inicia la política de eviction (expulsión de claves), que puede descartar datos críticos de otros servicios.

3. Las operaciones de snapshot y replicación se vuelven más lentas

Cuando Redis genera un snapshot RDB (persistencia) o replica datos a una réplica, las big keys aumentan el tiempo del fork() y el tamaño del archivo. En instancias cloud (AWS ElastiCache, Azure Cache for Redis), esto puede causar fallos de replicación o penalizaciones de rendimiento durante la sincronización.

Diagrama del impacto de las big keys en un entorno Redis compartido con múltiples servicios bloqueados

4. Dificultad de depuración y trazabilidad

En un entorno compartido, identificar quién creó la big key y qué servicio es el responsable exige una instrumentación cuidadosa. Sin un namespacing adecuado en las claves, rastrear el origen del problema puede llevar horas.

Cómo Detectar Big Keys en Producción

Redis ofrece herramientas nativas para detectar big keys. Estos son los enfoques principales:

redis-cli –bigkeys

El comando más simple para un escaneo inicial:

1
2
3
4
5
# Escaneo completo — úsalo con cuidado en producción (puede ser lento)
redis-cli --bigkeys

# Con host y puerto específicos
redis-cli -h redis.example.com -p 6379 --bigkeys

La salida muestra las claves más grandes por tipo de dato. El problema es que este comando usa SCAN internamente y puede tardar en instancias grandes. En producción, prefiere ejecutarlo en horarios de menor carga.

MEMORY USAGE — verificación puntual

Para comprobar el tamaño de una clave específica:

1
2
3
4
5
# Devuelve el tamaño en bytes, incluido el overhead de metadatos
MEMORY USAGE minha-chave

# Con nested sampling (para estructuras complejas)
MEMORY USAGE minha-chave SAMPLES 10

SCAN + MEMORY USAGE — escaneo automatizado en C#

Para un monitoreo programático con StackExchange.Redis:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class RedisBigKeyScanner
{
    private const long LimiarBigKeyBytes = 10 * 1024 * 1024; // 10 MB
    private readonly IDatabase _db;
    private readonly IServer _server;
    private readonly ILogger<RedisBigKeyScanner> _logger;

    public RedisBigKeyScanner(IConnectionMultiplexer redis, ILogger<RedisBigKeyScanner> logger)
    {
        _db = redis.GetDatabase();
        _server = redis.GetServer(redis.GetEndPoints().First());
        _logger = logger;
    }

    public async Task VarrerBigKeysAsync(string padrao = "*", int tamanhoPagina = 100,
        CancellationToken ct = default)
    {
        // SCAN no es bloqueante — itera en lotes (tamanhoPagina cada vez)
        await foreach (var key in _server.KeysAsync(pattern: padrao, pageSize: tamanhoPagina)
                                         .WithCancellation(ct))
        {
            var sizeBytes = await _db.ExecuteAsync("MEMORY", "USAGE", key, "SAMPLES", "5");
            if (sizeBytes.IsNull) continue;

            var size = (long)sizeBytes;
            if (size >= LimiarBigKeyBytes)
                _logger.LogWarning("Big key: {Key} | {SizeMB:F2} MB", key, size / (1024.0 * 1024.0));
        }
    }
}

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Cache/Redis/

📝 Ejemplo: En un entorno con 2 millones de claves, un escaneo con pageSize = 500 y pattern = "relatorio:*" limita el alcance solo al namespace problemático, reduciendo el tiempo de escaneo de horas a minutos.

Redis Latency Monitoring

Para detectar el impacto en tiempo real, activa el monitoreo de latencia:

1
2
3
4
5
6
# Activar en redis.conf o vía CONFIG SET
CONFIG SET latency-monitor-threshold 100

# Ver eventos de latencia
LATENCY LATEST
LATENCY HISTORY command

Estrategias para Evitar Big Keys

Detectar el problema es el primer paso. Resolverlo es más interesante. Existen cuatro enfoques principales:

1. Fragmentación de datos (Sharding)

En lugar de una única clave grande, distribuir los datos en múltiples claves más pequeñas usando un campo de particionamiento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class RedisHashSharded
{
    private readonly IDatabase _db;
    private const int QuantidadeShards = 16; // potencia de 2 para una distribución uniforme

    public RedisHashSharded(IConnectionMultiplexer redis) => _db = redis.GetDatabase();

    private string ObterChaveShard(string chaveBase, string campo)
    {
        var indiceShard = Math.Abs(campo.GetHashCode()) % QuantidadeShards;
        return $"{chaveBase}:shard:{indiceShard}";
    }

    public async Task GravarAsync(string chaveBase, string campo, string valor)
    {
        var chaveShard = ObterChaveShard(chaveBase, campo);
        await _db.HashSetAsync(chaveShard, campo, valor);
    }

    public async Task<string?> LerAsync(string chaveBase, string campo)
    {
        var chaveShard = ObterChaveShard(chaveBase, campo);
        var resultado = await _db.HashGetAsync(chaveShard, campo);
        return resultado.HasValue ? resultado.ToString() : null;
    }

    // LerTodosAsync paraleliza la lectura de los QuantidadeShards shards — código completo en el repositorio
}

2. Serialización eficiente con compresión

Uno de los mayores culpables de los strings grandes es la serialización ingenua de objetos complejos. Cambiar JSON por un formato binario + compresión reduce drásticamente el tamaño:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static class RedisSerializerExtensions
{
    public static async Task GravarComprimidoAsync<T>(
        this IDatabase db, string chave, T valor, TimeSpan? expiracao = null)
    {
        using var stream = new MemoryStream();
        await using (var gzip = new GZipStream(stream, CompressionLevel.Optimal))
            await JsonSerializer.SerializeAsync(gzip, valor);

        await db.StringSetAsync(chave, stream.ToArray(), expiracao);
    }

    public static async Task<T?> LerComprimidoAsync<T>(this IDatabase db, string chave)
    {
        var valor = await db.StringGetAsync(chave);
        if (!valor.HasValue) return default;

        using var stream = new MemoryStream((byte[])valor!);
        await using var gzip = new GZipStream(stream, CompressionMode.Decompress);
        return await JsonSerializer.DeserializeAsync<T>(gzip);
    }
}

💡 Consejo: La compresión GZip típica reduce los payloads JSON entre un 60 y un 80%. Un objeto de 5 MB puede bajar a 800 KB — lo que lo saca de la clasificación de “big key” hacia un tamaño manejable. Pero atención: la compresión tiene un costo de CPU, evalúa el trade-off para datos accedidos con alta frecuencia.

3. TTL obligatorio para las claves de caché

Las claves sin TTL en entornos compartidos tienden a acumular datos indefinidamente. Implementa una política de TTL obligatoria:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public class RedisCacheComPoliticaTtl
{
    private readonly IDatabase _db;
    private static readonly TimeSpan TtlPadrao = TimeSpan.FromHours(1);
    private static readonly TimeSpan TtlMaximo = TimeSpan.FromHours(24);

    public RedisCacheComPoliticaTtl(IConnectionMultiplexer redis)
        => _db = redis.GetDatabase();

    public async Task GravarAsync(string chave, string valor, TimeSpan? ttl = null)
    {
        // Nunca permite un TTL nulo — usa el predeterminado si no se especifica
        var ttlEfetivo = ttl.HasValue
            ? TimeSpan.FromTicks(Math.Min(ttl.Value.Ticks, TtlMaximo.Ticks))
            : TtlPadrao;

        await _db.StringSetAsync(chave, valor, ttlEfetivo);
    }
}

4. Namespacing y segregación por tenant

En entornos multi-tenant, usa prefijos obligatorios para identificar el origen de las claves. Esto facilita el diagnóstico y permite políticas de limpieza selectivas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// Patrón de clave: {ambiente}:{tenant}:{dominio}:{entidade}:{id}
// Ejemplo: prod:acme-corp:relatorio:mensal:2026-05

public static class RedisKeyBuilder
{
    public static string Construir(
        string tenant,
        string dominio,
        string entidade,
        string id,
        string ambiente = "prod")
    {
        return $"{ambiente}:{Sanitizar(tenant)}:{Sanitizar(dominio)}:{Sanitizar(entidade)}:{id}";
    }

    private static string Sanitizar(string segmento) =>
        segmento.ToLowerInvariant().Replace(" ", "-").Replace(":", "");
}

Ejemplo Práctico

Voy a mostrar un escenario real: un servicio de informes que cargaba todos los registros de transacciones del mes en una única clave de Redis como “caché” — y estaba hundiendo el rendimiento de los demás servicios del mismo clúster.

El problema original

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// ❌ CÓDIGO PROBLEMÁTICO — NO HAGAS ESTO
public async Task<List<Transacao>> ObterTransacoesMensaisAsync(
    int clienteId,
    int mes,
    int ano)
{
    var cacheKey = $"transacoes:{clienteId}:{mes}/{ano}";

    var cached = await _cache.StringGetAsync(cacheKey);
    if (cached.HasValue)
    {
        // Deserializa 300.000 transacciones en memoria de una sola vez
        return JsonSerializer.Deserialize<List<Transacao>>(cached!)!;
    }

    // Obtiene 300.000 registros de la base de datos
    var transacoes = await _db.Transacoes
        .Where(t => t.ClienteId == clienteId
                 && t.Data.Month == mes
                 && t.Data.Year == ano)
        .ToListAsync();

    // Serializa 300.000 objetos en un JSON de ~80 MB y lo guarda en Redis
    // Sin TTL → se queda para siempre
    await _cache.StringSetAsync(
        cacheKey,
        JsonSerializer.Serialize(transacoes));

    return transacoes;
}

Este código crea una clave que puede tener 80 MB en Redis, sin TTL, y que se lee entera en cada acceso. Cada lectura bloquea el event loop durante cientos de milisegundos.

La solución refactorizada

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// ✅ SOLUCIÓN CORRECTA — Caché paginada con TTL obligatorio

public class TransacaoCache
{
    private readonly IDatabase _redis;
    private const int TamanhoPagina = 100;
    private const string PrefixoChave = "tx";

    public TransacaoCache(IConnectionMultiplexer redis) => _redis = redis.GetDatabase();

    public async Task GravarPaginaAsync(int clienteId, int mes, int ano, int pagina,
        IEnumerable<Transacao> transacoes)
    {
        var chave = ConstruirChavePagina(clienteId, mes, ano, pagina);
        var json = JsonSerializer.Serialize(transacoes.Take(TamanhoPagina));
        // TTL de 30 minutos — un dato de informe no necesita ser eterno
        await _redis.StringSetAsync(chave, json, TimeSpan.FromMinutes(30));
    }

    public async Task<List<Transacao>?> ObterPaginaAsync(int clienteId, int mes, int ano, int pagina)
    {
        var chave = ConstruirChavePagina(clienteId, mes, ano, pagina);
        var cache = await _redis.StringGetAsync(chave);
        return cache.HasValue ? JsonSerializer.Deserialize<List<Transacao>>((string)cache!) : null;
    }

    // Cada clave contiene solo TamanhoPagina transacciones (~30 KB)
    private static string ConstruirChavePagina(int clienteId, int mes, int ano, int pagina) =>
        $"{PrefixoChave}:{clienteId}:{mes}-{ano}:p{pagina}";
}

Con este enfoque, cada clave pasa de 80 MB a ~30 KB. El event loop se libera en microsegundos, y los demás servicios compartidos dejan de sufrir latencia por culpa del servicio de informes.

Consejos y Buenas Prácticas

  • Define umbrales de alerta en el CI/CD: antes de un deploy, verifica si los nuevos patrones de clave respetan los límites de tamaño. Un pipeline de pruebas de carga con redis-cli --bigkeys puede prevenir el problema antes de que llegue a producción.

  • Usa TTL en absolutamente todas las claves: en entornos compartidos, una clave sin TTL es una clave que crecerá indefinidamente. Configura maxmemory-policy allkeys-lru en Redis para que, aunque alguna clave escape sin TTL, Redis pueda descartarla cuando sea necesario.

  • Nunca uses KEYS * en producción: el comando KEYS bloquea Redis mientras recorre todo el keyspace. Usa siempre SCAN con MATCH y COUNT para escaneos iterativos y no bloqueantes. StackExchange.Redis expone este comportamiento a través de IServer.KeysAsync().

  • Monitorea redis-cli --latency-history: latencias recurrentes por encima de 50ms son señal de big keys o hot keys. Configura alertas de latencia en Redis y correlaciónalas con los patrones de clave que se están accediendo en ese momento.

  • Separa workloads en instancias distintas cuando sea posible: si un servicio de informes inevitablemente necesita claves grandes, aíslalo en una instancia de Redis dedicada. El costo de una instancia extra es mucho menor que el impacto de latencia en los servicios críticos de un entorno compartido.

  • Prefiere las estructuras nativas de Redis en lugar de strings JSON grandes: un HASH con 1.000 campos es más eficiente que un STRING con un JSON de 1.000 propiedades. Redis puede acceder a campos individuales del hash sin deserializar toda la estructura, ahorrando CPU y memoria.

  • Revisa el diseño al usar Redis como base de datos: Redis es excelente como caché de corta duración, pub/sub y contadores. Cuando empieza a recibir colecciones completas de entidades para “persistencia temporal”, es señal de que el diseño necesita revisión — probablemente una base de datos relacional o documental es la herramienta adecuada para ese dato.

Resumen Objetivo

  • Big key en Redis — clave cuyo volumen de datos es desproporcionado respecto al workload; los límites prácticos son 5 MB para strings y 10.000 elementos para listas/hashes/sets. A partir de esos valores, las operaciones O(N) bloquean el event loop durante cientos de milisegundos.
  • Event loop single-threaded — Redis procesa un comando a la vez en el thread principal (incluso en Redis 6.0+ con I/O threads). Una big key bloquea a todos los demás clientes de la instancia mientras se procesa.
  • Entornos compartidos — en instancias de Redis usadas por múltiples microservicios o tenants, una big key creada por un único servicio introduce latencia para todos los demás, independientemente de su comportamiento.
  • Comandos O(N) peligrosos — LRANGE key 0 -1, SMEMBERS key, HGETALL key, KEYS * y SUNIONSTORE son los principales vectores de bloqueo cuando se aplican a claves grandes. Prefiere variantes paginadas como HSCAN, SSCAN y ZSCAN.
  • Detección en producción — redis-cli --bigkeys realiza un escaneo por tipo; MEMORY USAGE key SAMPLES N devuelve el tamaño exacto en bytes incluido el overhead; LATENCY LATEST identifica comandos con latencia anómala.
  • Fragmentación como solución — dividir una big key en múltiples claves más pequeñas usando sharding por campo elimina el bloqueo y permite paralelismo en la lectura. Un hash con 100.000 campos puede dividirse en 16 shards de ~6.250 campos cada uno.
  • TTL obligatorio — toda clave en un entorno compartido debe tener expiración. La ausencia de TTL es la principal causa de acumulación de big keys en producción. Configura maxmemory-policy allkeys-lru como red de seguridad.

Lee También

Referencias