NestJS Enterprise Backend APIs · Lesson

Caching Strategies (Redis)

Implement various caching strategies using Redis to reduce database load and improve API response times.

Caching Strategies (Redis) is a free NestJS Enterprise Backend APIs lesson on CoddyKit — lesson 1 of 6. 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 NestJS Enterprise Backend APIs learning path, one of 6 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Boosting API Performance with Caching

Welcome to Caching Strategies with Redis! In this lesson, we'll explore how to drastically improve your NestJS API's performance and responsiveness.

Caching is a technique where frequently accessed data is stored temporarily in a faster-access memory layer. This helps avoid repeated, expensive operations like database queries or complex computations.

Why Caching Matters

Imagine an API endpoint that fetches popular products. Every time a user requests this data, your server might perform a database query, which can be slow and resource-intensive.

Reduced Latency: Users get data faster.
Lower Database Load: Your database works less, preventing bottlenecks.
Improved Scalability: Your application can handle more users without slowing down.

Caching acts as a buffer, serving data quickly from memory instead of always hitting the primary data source.

Meet Redis: Your In-Memory Cache

Redis (Remote Dictionary Server) is a popular open-source, in-memory data structure store. It's often used as a database, cache, and message broker.

Speed: Redis stores data in RAM, making read/write operations incredibly fast.
Versatility: It supports various data structures like strings, hashes, lists, sets, and more.
Persistence: While primarily in-memory, Redis can persist data to disk for durability.

For caching, Redis's speed and simple key-value model make it an ideal choice.

Redis Basics: Key-Value Operations

Redis stores data as simple key-value pairs. You assign a unique key to a piece of data, then use that key to retrieve it later. Here's how it looks conceptually using the Redis CLI:

# Connect to Redis CLI
redis-cli

# Store a value with a key
SET myapi:users:123 '{"name":"Alice"}'

# Retrieve the value using its key
GET myapi:users:123

# Set a value with an expiration time (10 seconds)
SETEX myapi:temp:data 10 'Expires Soon'

NestJS CacheModule Setup

NestJS provides a flexible CacheModule to integrate various caching solutions. To use Redis, we'll install @nestjs/cache-manager and cache-manager-redis-store.

First, install the packages:

npm install @nestjs/cache-manager cache-manager-redis-store cache-manager

Then, configure your AppModule to use Redis:

import { Module, CacheModule } from '@nestjs/common';
import * as redisStore from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: 'localhost',
      port: 6379,
      ttl: 300 // default time-to-live in seconds
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

Automatic Caching with CacheInterceptor

For simple GET endpoints, NestJS offers the CacheInterceptor. This interceptor automatically caches the response of a method and serves it from the cache on subsequent requests.

You can apply it globally or to specific controllers/methods using decorators:

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { CacheInterceptor, CacheKey, CacheTTL } from '@nestjs/cache-manager';

@Controller('products')
@UseInterceptors(CacheInterceptor) // Apply to all methods in this controller
export class ProductsController {

  @Get()
  @CacheKey('all_products') // Unique key for this cache entry
  @CacheTTL(60) // Cache for 60 seconds (overrides module default)
  async findAll() {
    // In a real app, this would fetch from a database
    console.log('Fetching all products from DB...');
    return [{ id: 1, name: 'Laptop' }, { id: 2, name: 'Mouse' }];
  }
}

Understanding CacheKey and CacheTTL

When using CacheInterceptor, two key decorators help you control caching:

@CacheKey('your_key_name'): This decorator defines the unique key under which the response data will be stored in Redis. If not provided, NestJS generates one based on the request path.
@CacheTTL(seconds): This sets the Time-To-Live for the cached entry in seconds. After this duration, the cached data expires and will be re-fetched from the original source. If omitted, it uses the default ttl from CacheModule.register().

These allow you to fine-tune how long specific data remains cached.

Manual Caching with CacheManager

Sometimes, you need more control than what CacheInterceptor offers, for example, caching parts of a response or invalidating cache entries programmatically.

You can inject the CacheManager service and use its methods directly:

import { Controller, Get, Post, Inject, Param } from '@nestjs/common';
import { Cache } from 'cache-manager';
import { CACHE_MANAGER } from '@nestjs/cache-manager';

@Controller('users')
export class UsersController {
  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}

  @Get(':id')
  async findOne(@Param('id') id: string) {
    const cacheKey = `user_${id}`;
    const cachedUser = await this.cacheManager.get(cacheKey);

    if (cachedUser) {
      console.log('Serving from cache!');
      return cachedUser;
    }

    // Simulate fetching from DB
    const user = { id, name: `User ${id}`, email: `user${id}@example.com` };
    await this.cacheManager.set(cacheKey, user, 600); // Cache for 10 mins

    console.log('Serving from DB and caching...');
    return user;
  }

  @Post('clear-all')
  async clearAllCache() {
    await this.cacheManager.reset(); // Clear all cache entries
    return 'Cache cleared!';
  }
}

Cache Invalidation Strategies

A critical aspect of caching is ensuring data freshness. Stale data can lead to incorrect information being served.

Time-To-Live (TTL): The simplest strategy, data expires automatically after a set time.
Cache-Aside: Application code explicitly fetches from cache, then DB if not found, and updates cache.
Write-Through: Data is written to cache and then to the database simultaneously.
Write-Back: Data is written to cache, then asynchronously written to the database.
Event-Driven Invalidation: When data changes in the database, an event is triggered to invalidate or update the corresponding cache entry.

Choosing the right strategy depends on your application's consistency requirements.

Quick Check: Caching Benefits

Consider a NestJS API endpoint that frequently fetches a list of popular products from a database. This database call is slow due to complex joins and large data volumes.

Caching with Redis: Recap

Great job! You've learned the fundamentals of caching with Redis in NestJS:

Caching significantly boosts API performance, reduces database load, and improves scalability.
Redis is an excellent choice for an in-memory cache due to its speed and versatility.
NestJS's CacheModule simplifies Redis integration using cache-manager-redis-store.
You can use the @CacheInterceptor with @CacheKey and @CacheTTL for automatic caching on controller methods.
For more control, inject CACHE_MANAGER to manually interact with Redis.
Understanding cache invalidation strategies is crucial for maintaining data freshness.

Start implementing caching to make your NestJS applications blazing fast!

Frequently asked questions

Is the “Caching Strategies (Redis)” lesson free?

Yes — the full text of “Caching Strategies (Redis)” is free to read here on the web, and the NestJS Enterprise Backend APIs course includes 6 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the NestJS Enterprise Backend APIs course, upgrade to CoddyKit PRO.

What will I learn in “Caching Strategies (Redis)”?

Implement various caching strategies using Redis to reduce database load and improve API response times. You practise NestJS Enterprise Backend APIs 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 NestJS Enterprise Backend APIs?

No prior experience is required. NestJS Enterprise Backend APIs on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 6, so you can start here or from the beginning and move at your own pace.

How long does the “Caching Strategies (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 NestJS Enterprise Backend APIs lesson?

Yes. Every NestJS Enterprise Backend APIs 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

← Back to NestJS Enterprise Backend APIs