¿Cómo funciona la expiración de claves (TTL) en Redis?

Question

Accepted Answer

Redis permite que las claves **expiren automáticamente** después de un tiempo establecido (**TTL** — Time To Live) — después del cual se eliminan. Esto es fundamental para cachés (expirar datos obsoletos), sesiones, y cualquier dato temporal, y es una de las características más utilizadas de Redis.

## Por qué es importante

La expiración de claves (TTL) es una de las características más importantes y frecuentemente utilizadas de Redis, por lo que entenderla es esencial para usar Redis de manera efectiva, especialmente para cachés.

La capacidad central — las claves **se eliminan automáticamente después de un tiempo establecido** — es fundamental para los casos de uso más comunes de Redis: **cachés** (entradas de caché con un TTL para que los datos obsoletos expiren automáticamente y se refresquen — central para prácticamente cualquier estrategia de cachés), **sesiones** (expirando después de inactividad, refrescando el TTL con actividad), **limitación de velocidad** (un contador con un TTL implementando "N solicitudes por ventana de tiempo"), y cualquier **dato temporal** (OTPs, tokens, bloqueos) que debe auto-limpiarse.

Comprender cómo establecer TTLs (`EX`/`PX` al crear, `EXPIRE` después), verificarlos (`TTL`, con sus convenciones de retorno `-1`/`-2`), y administrarlos (`PERSIST`) es conocimiento práctico cotidiano.

Comprender **cómo Redis expira claves** (una combinación de expiración perezosa cuando se accede y muestreo activo en segundo plano para recuperar memoria incluso de claves nunca accedidas) explica cómo ocurre la limpieza.

El valor clave es que TTL significa que **Redis administra la limpieza automáticamente** — no se necesita código de eliminación manual, los datos se expiran solos — lo que hace que Redis sea tan conveniente para cachés y datos temporales.

Ya que cachés, sesiones, limitación de velocidad, y datos temporales están entre los usos más comunes de Redis, y ya que TTL es el mecanismo que permite la expiración automática central para todos ellos, entender la expiración de claves — establecer/verificar/administrar TTLs, cómo funciona la expiración, y sus usos comunes — es conocimiento esencial de Redis, frecuentemente aplicado, una característica que usarás constantemente y uno de los aspectos más prácticamente importantes de trabajar con Redis.

```bash
SET session:abc "data" EX 3600    # expire in 3600 seconds (1 hour)
SET key "value" PX 5000            # expire in 5000 milliseconds

# or set expiry on an existing key
SET cache:user:1 "..."
EXPIRE cache:user:1 300           # expire in 300 seconds
EXPIREAT key 1735689600           # expire at a specific Unix timestamp
```

Estableces un TTL al crear una clave (`EX`/`PX`) o agregas uno después (`EXPIRE`). Después de que el TTL vence, Redis elimina automáticamente la clave.

## Verificar y administrar TTL

```bash
TTL session:abc        # => seconds remaining (e.g. 3540), -1 if no expiry, -2 if gone
PTTL session:abc       # remaining time in milliseconds
PERSIST session:abc    # remove the expiry → make the key permanent
```

`TTL` muestra el tiempo restante (`-1` = sin expiración establecida, `-2` = la clave no existe); `PERSIST` elimina la expiración.

## Cómo Redis expira claves

```text
Redis uses a combination of:
  LAZY expiration → when a key is accessed, if expired, it's deleted then
  ACTIVE expiration → a background process periodically samples and removes expired keys
→ So expired keys are cleaned up even if never accessed again (memory is reclaimed).
```

## Usos comunes de TTL

```text
✓ CACHING — cache data with a TTL so it auto-refreshes (stale data expires)
✓ SESSIONS — sessions expire after inactivity (set/refresh TTL on activity)
✓ RATE LIMITING — a counter with a TTL (e.g. "max 100 requests per minute")
✓ TEMPORARY data — OTPs, tokens, locks that should auto-clean
→ TTL means Redis manages cleanup automatically — no manual deletion needed.
```