Elasticache Overview

This lesson explains Amazon ElastiCache and how in-memory caching improves application performance and scalability. You’ll learn common caching patterns, typical use cases (like database caching and session stores), and how to choose between Redis and Memcached for your workloads. First, consider an application that relies only on a disk-backed database with no caching. Every user request produces a database query, increasing disk I/O and latency as traffic grows. As read volume rises, the database becomes a bottleneck and overall response times suffer.

A slide titled "ElastiCache" showing four colored tiles with icons labeled: High Load, Disk-Based Storage, Performance Impact, and Scalability Issues.

Caching solves these problems by storing frequently accessed or transient data in fast, in-memory stores. When you offload read-heavy traffic to a cache you:

Reduce the number of database reads
Decrease latency for end users
Improve application responsiveness and scalability

Cache lookup follows a simple pattern: check the cache first, then fall back to the database on misses.

A simple ElastiCache architecture diagram showing a client using an e-commerce website that queries a cache (with "Cache Hit" and "Cache Miss" paths) and falls back to a database. The flow arrows illustrate requests between client, website, cache, and database.

Cache lookup pattern (high level):

Application queries the cache.
If the data exists (cache hit) — return it immediately.
If the data does not exist (cache miss) — query the database, return the result, and optionally store it back in the cache.

Example: simple cache-get pseudo-code (Node.js style)

// Pseudocode: cache-first lookup
async function getUserProfile(userId) {
  const cached = await cache.get(`user:${userId}`);
  if (cached) {
    return JSON.parse(cached); // cache hit
  }
  const profile = await db.queryUser(userId); // cache miss -> DB
  if (profile) {
    await cache.set(`user:${userId}`, JSON.stringify(profile), { ttl: 3600 });
  }
  return profile;
}

Caching is also ideal for session stores: storing short-lived session state (login tokens, shopping cart) in-memory is faster and simpler than persisting that data to disk.

An ElastiCache infographic showing two use cases: "Database Caching" on the left (to decrease read-heavy database loads) and "Session Store" on the right (to manage session information for web applications).

Amazon ElastiCache is AWS’s managed in-memory caching service. Key benefits include:

Managed provisioning, engine and OS patching, and monitoring
Built-in failure recovery and automated maintenance operations
Support for Redis and Memcached as drop-in engines
Backup/restore for Redis (Memcached is ephemeral)
Scaling options (scale out/in via clusters or scale up/down instance types)
High availability features (Multi-AZ replication and automatic failover for Redis depending on configuration)

When choosing between Redis and Memcached, consider the following differences. Use this to map engine capabilities to your application requirements (durability, data structures, replication, etc.).

A slide titled "ElastiCache" showing a two-column comparison of Redis (left) and Memcached (right) with rows listing differences such as data structures, persistence, replication/failover, Multi-AZ support, backups, partitioning, and threading.

Feature comparison (high-level)

Feature	Redis	Memcached
Data model	Rich data types (strings, hashes, lists, sets, sorted sets)	Simple key-value
Persistence	Optional persistence; ElastiCache supports snapshots/backups	No persistence; data is ephemeral
Replication and failover	Built-in replication, Multi-AZ, and automatic failover for replication groups	No built-in replication or automatic failover
Backups	Snapshot and restore supported	No backups
Partitioning / sharding	Cluster mode provides sharding	Client-side partitioning; lacks centralized cluster sharding
Concurrency	Single-threaded per shard/process (good for atomic ops and complex data types)	Multi-threaded (can use multiple CPU cores)

When to choose Redis vs. Memcached

Choose Redis if you need:
- Advanced data structures (lists, sets, sorted sets, hashes)
- Persistence or backup/restore capabilities
- Built-in replication, automatic failover, and Multi-AZ high availability
- Atomic operations and server-side scripting (Lua)
Choose Memcached if you need:
- A simple high-throughput, ephemeral cache
- Multi-threaded performance to utilize multiple CPU cores
- Lightweight key-value caching without persistence or replication concerns

Redis is a better fit when you need advanced data structures, durability, replication, or backups. Memcached can be preferable for simple, high-performance ephemeral caching where multi-threaded CPU utilization matters.

Summary

Amazon ElastiCache is a fully managed, in-memory caching service that supports Redis and Memcached.
Use caching to reduce database load, lower latency, and improve application scalability.
Select Redis for durability and complex data structures; select Memcached for simple, high-throughput ephemeral caches.

Links and references

AWS Databases - Part 1

AWS Databases - Part 2

Migrations & Security

Introduction

Elasticache Overview

Watch Video