Kurs NestJS · Moduł 8: Cache i wydajność

Redis Integration - szybkie magazyny tributów

5 min czytania ·
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:

  1. Zainstaluj pakiety: cache-manager-redis-store.
  2. Skonfiguruj CacheModule z Redis store.
  3. Wstrzyknij CACHE_MANAGER w serwisie.
  4. Używaj cache.get() i cache.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ć:

  1. Aplikacja wysyła zapis.
  2. Cache zapisuje dane.
  3. Cache synchronicznie zapisuje do bazy.
  4. 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 → skonfiguruj CacheModule z Redis store → wstrzyknij CACHE_MANAGER → używaj cache.get() i cache.set(),
  • pole store zamienia domyślny cache w pamięci na Redisa; serwisy nie zmieniają się wcale,
  • ttl to czas życia wpisu w milisekundach, a trzeci argument set nadpisuje 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. 1. Redis w NestJS można użyć do:

  2. 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:

  1. PytanieZalety Redis jako cache store
  2. PytanieIn-memory vs Redis cache
  3. Zadanie z kodemPraktyka: Konfiguracja Redis cache
  4. Ułóż w kolejnościKonfiguracja Redis
  5. Ułóż w kolejnościStrategie cache: Write-Through vs Write-Behind

Przydatne artykuły