Kurs NestJS · Moduł 8: Cache i wydajność
Redis Integration - szybkie magazyny tributów
W tej lekcji5
Cache w pamięci procesu poznałeś w poprzedniej lekcji i działa doskonale - dopóki masz jeden serwer. Uruchom drugą instancję aplikacji za load balancerem, a każda zbuduje własny cache. Użytkownik trafia raz na jedną, raz na drugą i dostaje różne dane. Gorzej: unieważnienie wpisu na pierwszej instancji nie usunie go z drugiej.
Legion nie trzymał zapasów w plecaku każdego żołnierza. Miał wspólny magazyn, do którego wszyscy sięgali. Redis jest takim magazynem - i to jest jego główna zaleta nad cache w pamięci: współdzielenie między wieloma instancjami aplikacji.
Nie chodzi o to, że jest zawsze szybszy - cache w pamięci procesu bywa szybszy, bo nie wymaga przejścia przez sieć. Chodzi o to, że wszystkie instancje widzą to samo.
Cztery zastosowania
Redis w NestJS przydaje się do czterech rzeczy naraz: cache, sessions, pub/sub i queue.
Cache to zastosowanie, od którego zwykle się zaczyna. Sessions - sesje użytkowników, które poznałeś przy uwierzytelnianiu; dzięki wspólnemu magazynowi zalogowanie na jednej instancji obowiązuje na wszystkich. Pub/sub - rozgłaszanie zdarzeń między serwisami. Queue - kolejki zadań, do których wracaliśmy przy posłańcach Imperium.
To dlatego Redis pojawia się niemal w każdym stosie: jedna usługa pokrywa cztery potrzeby, które inaczej wymagałyby czterech osobnych narzędzi.
Cztery kroki konfiguracji
Podłączenie Redisa jako magazynu cache przebiega zawsze tak samo:
- Zainstaluj pakiety:
cache-manager-redis-store. - Skonfiguruj
CacheModulez Redis store. - Wstrzyknij
CACHE_MANAGERw serwisie. - Używaj
cache.get()icache.set()z kluczami.
Krok drugi wygląda tak:
@Module({
imports: [
CacheModule.registerAsync({
isGlobal: true,
useFactory: (config: ConfigService) => ({
store: redisStore,
host: config.get('REDIS_HOST'),
port: config.get('REDIS_PORT'),
ttl: 300000,
}),
inject: [ConfigService],
}),
],
})
export class AppModule {}Zwróć uwagę na jedno pole: store. To ono zamienia domyślny cache w pamięci na Redisa - reszta konfiguracji opisuje już tylko, gdzie ten Redis stoi. Cała aplikacja korzysta z tego samego interfejsu; podmiana magazynu nie dotyka ani jednej linii w serwisach.
ttl: 300000 to domyślny czas życia wpisu w milisekundach - pięć minut. Po tym czasie Redis usuwa go sam.
Użycie w serwisie
Kroki trzeci i czwarty to już zwykły kod:
@Injectable()
export class LegionService {
constructor(
@Inject(CACHE_MANAGER) private cache: Cache,
private repo: LegionRepository,
) {}
async findOne(id: number) {
const key = `legion:${id}`;
const cached = await this.cache.get<Legion>(key);
if (cached) {
return cached;
}
const legion = await this.repo.findOne(id);
await this.cache.set(key, legion, 600000);
return legion;
}
}@Inject(CACHE_MANAGER) to wstrzyknięcie po tokenie - ten sam mechanizm, który poznałeś przy providerach bez typu klasy.
Sam schemat nazywa się cache-aside: najpierw pytamy cache, przy trafieniu zwracamy od razu, przy pudle idziemy do bazy i dopiero potem zapisujemy wynik. Trzeci argument set nadpisuje domyślny TTL dla tego jednego wpisu.
Klucz warto budować z prefiksem, jak legion:42. Bez tego prędzej czy później dwa różne byty zaczną używać tej samej liczby jako klucza, a błąd wyjdzie w najgorszym możliwym momencie.
Write-Through - inna strategia
Cache-aside zapisuje do cache dopiero po odczycie z bazy. Istnieje odwrotne podejście, write-through, w którym cache jest zapisywany przy każdym zapisie danych, a nie przy odczycie. Kolejność jest tu ustalona i warto ją znać:
- Aplikacja wysyła zapis.
- Cache zapisuje dane.
- Cache synchronicznie zapisuje do bazy.
- Potwierdzenie zwrócone do aplikacji.
Kluczowe jest słowo synchronicznie w kroku trzecim: aplikacja czeka, aż dane trafią i do cache, i do bazy. Dzięki temu cache nigdy nie jest nieaktualny - ale zapis trwa dłużej niż sam zapis do bazy.
Wybór między strategiami sprowadza się do tego, czego bardziej potrzebujesz. Cache-aside jest tańszy przy zapisach i wystarcza, gdy dane rzadko się zmieniają albo chwilowa nieaktualność nie szkodzi. Write-through kosztuje przy każdym zapisie, ale gwarantuje spójność - i to on ma sens tam, gdzie stary odczyt oznacza realny problem, jak przy saldzie czy stanie magazynu.
Podsumowanie
Wspólny magazyn stoi, wszystkie instancje sięgają do tego samego:
- główną zaletą Redisa nad cache w pamięci jest współdzielenie cache między wieloma instancjami aplikacji - nie to, że jest zawsze szybszy,
- Redis w NestJS służy do czterech rzeczy: cache, sessions, pub/sub i queue,
- konfiguracja w czterech krokach: zainstaluj
cache-manager-redis-store→ skonfigurujCacheModulez Redis store → wstrzyknijCACHE_MANAGER→ używajcache.get()icache.set(), - pole
storezamienia domyślny cache w pamięci na Redisa; serwisy nie zmieniają się wcale, ttlto czas życia wpisu w milisekundach, a trzeci argumentsetnadpisuje go dla jednego klucza,- cache-aside: zapytaj cache, przy pudle idź do bazy i dopiero potem zapisz wynik,
- klucze buduj z prefiksem (
legion:42), żeby dwa byty nie zaczęły używać tej samej liczby, - write-through w kolejności: aplikacja wysyła zapis → cache zapisuje dane → cache synchronicznie zapisuje do bazy → potwierdzenie do aplikacji,
- cache-aside jest tańszy przy zapisach, write-through gwarantuje spójność - wybieraj według tego, czy stary odczyt może zaszkodzić.
W następnej lekcji zajmiemy się optymalizacją samej aplikacji - tym, co przyspiesza ją zanim jeszcze pomyślisz o cache. A na razie zapamiętaj: cache w pamięci należy do procesu, Redis należy do wszystkich - i dopiero to sprawia, że druga instancja widzi to samo co pierwsza.
Kod do tej lekcji: src/redis-integration.ts
// Redis Integration - Szybkie Magazyny Tributyw
import { Injectable, Inject, Module } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { CacheModule } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';
// 1. Konfiguracja Redis jako store cache
// npm install cache-manager-redis-store redis
@Module({
imports: [
CacheModule.register({
// store: redisStore,
// host: process.env.REDIS_HOST || 'localhost',
// port: parseInt(process.env.REDIS_PORT) || 6379,
// password: process.env.REDIS_PASSWORD,
ttl: 300,
max: 1000,
isGlobal: true,
}),
],
})
export class RedisCacheModule {}
// 2. Konfiguracja async z ConfigService
// CacheModule.registerAsync({
// imports: [ConfigModule],
// inject: [ConfigService],
// useFactory: (config: ConfigService) => ({
// store: redisStore,
// host: config.get('REDIS_HOST'),
// port: config.get('REDIS_PORT'),
// ttl: config.get('CACHE_TTL'),
// }),
// })
// 3. Zaawansowany serwis Redis
@Injectable()
export class RedisCacheService {
constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}
// Cache-Aside Pattern
async getOrSet<T>(
key: string,
fetcher: () => Promise<T>,
ttl: number = 300
): Promise<T> {
let data = await this.cache.get<T>(key);
if (data) return data;
data = await fetcher();
await this.cache.set(key, data, ttl * 1000);
return data;
}
// Write-Through Pattern
async writeThrough<T>(
key: string,
data: T,
saveFn: (data: T) => Promise<void>,
ttl: number = 300
): Promise<void> {
await saveFn(data); // Zapisz do bazy
await this.cache.set(key, data, ttl * 1000); // Zapisz do cache
}
// Cache Warming - rozgrzewanie cache
async warmup(
keys: string[],
fetcher: (key: string) => Promise<any>
) {
const promises = keys.map(async (key) => {
const data = await fetcher(key);
await this.cache.set(key, data, 600000); // 10 minut
});
await Promise.all(promises);
console.log(`Cache rozgrzany: ${keys.length} kluczy`);
}
// Invalidacja po wzorcu
async invalidateByPrefix(prefix: string) {
// W Redis: KEYS prefix:* -> DEL
console.log(`Invalidacja kluczy: ${prefix}:*`);
// W rzeczywistej implementacji z Redis:
// const keys = await redis.keys(`${prefix}:*`);
// await Promise.all(keys.map(k => this.cache.del(k)));
}
}
// Redis wspiera dodatkowe struktury:
// - Strings (cache)
// - Lists (kolejki)
// - Sets (unikalne kolekcje)
// - Sorted Sets (rankingi)
// - Hashes (obiekty)
// - Pub/Sub (komunikacja)
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Redis w NestJS można użyć do:
2. Główna zaleta Redis nad in-memory cache to:
Zadania praktyczne w grze
- Edytor kodu
Podłącz Redis jako backend cache w CacheModule
- Układanie w pionie
Uporządkuj kroki konfiguracji Redis cache w NestJS:
- Układanie w pionie
Ułóż kroki strategii Write-Through cache: