0Pricing
NestJS Enterprise Backend APIs · Lektion

Caching-Strategien (Redis)

Implementieren Sie verschiedene Caching-Strategien mit Redis, um die Datenbanklast zu reduzieren und API-Antwortzeiten zu verbessern.

Caching-Strategien (Redis) ist eine kostenlose NestJS Enterprise Backend APIs-Lektion auf CoddyKit. Dies ist Lektion 1 von 6. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des NestJS Enterprise Backend APIs-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 6 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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!

Häufig gestellte Fragen

Ist die Lektion „Caching-Strategien (Redis)“ kostenlos?

Ja — der vollständige Text von „Caching-Strategien (Redis)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des NestJS Enterprise Backend APIs-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 6 Lektionen.

Was lerne ich in „Caching-Strategien (Redis)“?

Implementieren Sie verschiedene Caching-Strategien mit Redis, um die Datenbanklast zu reduzieren und API-Antwortzeiten zu verbessern. Du übst NestJS Enterprise Backend APIs mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um NestJS Enterprise Backend APIs zu starten?

Keine Vorkenntnisse erforderlich. NestJS Enterprise Backend APIs auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 6.

Wie lange dauert die Lektion „Caching-Strategien (Redis)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser NestJS Enterprise Backend APIs-Lektion Code schreiben und ausführen?

Ja. Jede NestJS Enterprise Backend APIs-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Caching-Strategien (Redis)
  2. Datenbankleistung überwachen
  3. Load-Balancing und Proxys
  4. Strategien zur Abfrageoptimierung
  5. Serverless-Bereitstellung
  6. Ihr Supabase-Projekt skalieren
← Zurück zu NestJS Enterprise Backend APIs