NestJS Enterprise Backend APIs · Lezione

Strategie di caching (Redis)

Implementi diverse strategie di caching usando Redis per ridurre il carico sul database e migliorare i tempi di risposta dell'API.

Lezione 1 di 611 passaggi

Strategie di caching (Redis) è una lezione NestJS Enterprise Backend APIs gratuita su CoddyKit. Questa è la lezione 1 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento NestJS Enterprise Backend APIs, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso NestJS Enterprise Backend APIs include 6 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

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.

Rispondi nella lezione interattiva

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!

Gratis per iniziare

Impara TypeScript con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 20
Lezioni: 76

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Strategie di caching (Redis)» è gratuita?

Sì — il testo completo di «Strategie di caching (Redis)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso NestJS Enterprise Backend APIs, passa a CoddyKit PRO. Il corso NestJS Enterprise Backend APIs include 6 lezioni in totale.

Cosa imparerò in «Strategie di caching (Redis)»?

Implementi diverse strategie di caching usando Redis per ridurre il carico sul database e migliorare i tempi di risposta dell'API. Eserciti NestJS Enterprise Backend APIs con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare NestJS Enterprise Backend APIs?

Non è richiesta alcuna esperienza precedente. NestJS Enterprise Backend APIs su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 6.

Quanto tempo richiede la lezione «Strategie di caching (Redis)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione NestJS Enterprise Backend APIs?

Sì. Ogni lezione NestJS Enterprise Backend APIs include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Strategie di caching (Redis)
Monitoraggio delle prestazioni del database
Bilanciamento del carico e proxy
Strategie di ottimizzazione delle query
Deployment serverless
Scalabilità del progetto Supabase

← Torna a NestJS Enterprise Backend APIs