キャッシュ戦略（Redis）
Redisを使ってさまざまなキャッシュ戦略を実装し、データベースの負荷を軽減してAPIの応答時間を改善します。
「キャッシュ戦略（Redis）」はCoddyKit上の無料NestJS Enterprise Backend APIsレッスンです。 これはレッスン1/6です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはNestJS Enterprise Backend APIs学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 NestJS Enterprise Backend APIsコースには全6レッスンが含まれています。
このレッスンの一部はまだ翻訳されておらず、英語で表示されています。
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-managerThen, 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 defaultttlfromCacheModule.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
CacheModulesimplifies Redis integration usingcache-manager-redis-store. - You can use the
@CacheInterceptorwith@CacheKeyand@CacheTTLfor automatic caching on controller methods. - For more control, inject
CACHE_MANAGERto manually interact with Redis. - Understanding cache invalidation strategies is crucial for maintaining data freshness.
Start implementing caching to make your NestJS applications blazing fast!
よくある質問
「キャッシュ戦略（Redis）」レッスンは無料ですか？
はい。「キャッシュ戦略（Redis）」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、NestJS Enterprise Backend APIsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 NestJS Enterprise Backend APIsコースには全6レッスンが含まれています。
「キャッシュ戦略（Redis）」で何を学びますか？
Redisを使ってさまざまなキャッシュ戦略を実装し、データベースの負荷を軽減してAPIの応答時間を改善します。 ブラウザで直接実行するハンズオンコードでNestJS Enterprise Backend APIsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
NestJS Enterprise Backend APIsを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのNestJS Enterprise Backend APIsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン1/6です。
「キャッシュ戦略（Redis）」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このNestJS Enterprise Backend APIsレッスンでコードを書いて実行できますか？
はい。すべてのNestJS Enterprise Backend APIsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。