0Pricing
Caching Strategies: Redis + CDN + Edge Computing · Lesson

TTL and Expiration in Redis

Learn how Redis handles key expiration: setting TTLs, the EXPIRE and SETEX commands, how lazy and active expiry work, and how the maxmemory eviction policies interact with TTLs.

TTL and Expiration in Redis is a free Caching Strategies: Redis + CDN + Edge Computing lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Caching Strategies: Redis + CDN + Edge Computing learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Expire Cache Keys?

Cached data goes stale. Time To Live (TTL) lets Redis automatically remove a key after a set duration, so your cache stays reasonably fresh without manual cleanup.

Setting a TTL with EXPIRE

The EXPIRE command sets a timeout in seconds on an existing key. After that time, Redis deletes the key automatically.

SET user:1 "Alice"
EXPIRE user:1 60
TTL user:1

SET with EX in One Step

You can set a value and its TTL together. SET key value EX seconds (or the older SETEX) avoids a race between writing and expiring.

SET session:abc "data" EX 300

Checking Remaining TTL

The TTL command returns seconds left. PTTL returns milliseconds. Special return values matter:

  • -1: key exists but has no expiry
  • -2: key does not exist
def interpret_ttl(value):
    if value == -1:
        return 'no expiry set'
    if value == -2:
        return 'key does not exist'
    return str(value) + 's remaining'

print(interpret_ttl(-2))
print(interpret_ttl(45))

Removing an Expiry

The PERSIST command removes the TTL from a key, making it permanent again. Useful when a value should stop expiring after some condition is met.

PERSIST user:1

Lazy Expiration

Redis does not check every key constantly. With lazy expiry, an expired key is only removed when someone tries to access it. Until then it lingers in memory.

Active Expiration

To reclaim memory from keys nobody touches, Redis also runs a background sampler that periodically removes a batch of expired keys. This is active expiry. Together with lazy expiry it keeps memory in check.

TTL vs Eviction

TTL is voluntary removal at a set time. Eviction happens when Redis hits its maxmemory limit and must drop keys to make room. They are different mechanisms that often work together.

volatile vs allkeys Policies

Eviction policies decide what to drop under memory pressure:

  • volatile-lru: evict least-recently-used keys that have a TTL
  • allkeys-lru: evict LRU among all keys

For a pure cache, allkeys policies are common.

Choosing TTL Values

Pick TTLs from the data's tolerance for staleness: seconds for fast-changing prices, hours for catalogs, days for rarely-changing config. Add jitter to avoid synchronized mass expiry.

import random
base = 3600
print('TTL:', base + random.randint(0, 300), 'seconds')

Common Pitfall: No TTL

Forgetting to set a TTL turns a cache into an ever-growing store that eventually exhausts memory. For cache use cases, almost every key should have an expiry or rely on an allkeys eviction policy.

Quick Check

What does the Redis command TTL mykey return if the key exists but has no expiration set?

Recap

You learned TTL and expiration in Redis:

  • EXPIRE / SET ... EX set timeouts; TTL/PTTL inspect them; PERSIST removes them.
  • Redis uses lazy plus active expiration.
  • Eviction policies (volatile vs allkeys) handle memory pressure.
  • Always set TTLs (or an allkeys policy) for cache keys.

Good expiration keeps a cache both fresh and bounded.

Frequently asked questions

Is the “TTL and Expiration in Redis” lesson free?

Yes — the full text of “TTL and Expiration in Redis” is free to read here on the web, and the Caching Strategies: Redis + CDN + Edge Computing course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Caching Strategies: Redis + CDN + Edge Computing course, upgrade to CoddyKit PRO.

What will I learn in “TTL and Expiration in Redis”?

Learn how Redis handles key expiration: setting TTLs, the EXPIRE and SETEX commands, how lazy and active expiry work, and how the maxmemory eviction policies interact with TTLs. You practise Caching Strategies: Redis + CDN + Edge Computing with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Caching Strategies: Redis + CDN + Edge Computing?

No prior experience is required. Caching Strategies: Redis + CDN + Edge Computing on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “TTL and Expiration in Redis” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Caching Strategies: Redis + CDN + Edge Computing lesson?

Yes. Every Caching Strategies: Redis + CDN + Edge Computing lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Redis Caching
  2. Redis Data Structures for Cache
  3. Basic Redis Cache Operations
  4. TTL and Expiration in Redis
← Back to Caching Strategies: Redis + CDN + Edge Computing