> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Elasticache Overview
> Overview of Amazon ElastiCache, in-memory caching benefits, use cases, and guidance on choosing Redis or Memcached for performance, durability, and scalability.
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.
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.
Cache lookup pattern (high level):
1. Application queries the cache.
2. If the data exists (cache hit) — return it immediately.
3. 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)
```js theme={null}
// 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.
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.).
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
* [Amazon ElastiCache documentation](https://docs.aws.amazon.com/elasticache/)
* [Redis](https://redis.io/)
* [Memcached](https://memcached.org/)