Как использовать Redis в NestJS приложении

Redis — это высокопроизводительная in-memory база данных, широко используемая для кэширования, хранения сессий, реализации очередей и управления состоянием в распределённых системах. В экосистеме NestJS, построенной на основе Node.js и архитектурных принципов, таких как внедрение зависимостей и модульность, интеграция Redis становится не просто полезной опцией, а стратегическим решением для повышения отзывчивости приложения. Благодаря поддержке IoC-контейнера и чёткой структуре модулей, NestJS позволяет легко интегрировать Redis через официальные или сторонние пакеты.

Зачем использовать Redis в NestJS

NestJS — это прогрессивный фреймворк для создания серверных приложений на Node.js, построенный с использованием TypeScript и принципов ООП, функционального и реактивного программирования. Он предоставляет мощную систему модулей, контроллеров, сервисов и внедрения зависимостей, что делает его идеальным кандидатом для масштабируемых backend-решений. Однако даже самая продуманная архитектура может столкнуться с задержками при частых обращениях к базе данных или внешним API.
Именно здесь на помощь приходит Redis. Как in-memory хранилище с поддержкой различных структур данных (строки, хэши, списки, множества), он позволяет значительно ускорить доступ к часто запрашиваемым данным. В сочетании с NestJS это даёт возможность реализовать кэширование ответов, хранение сессий пользователей, распределённые блокировки и обмен сообщениями между микросервисами.
Преимущества интеграции Redis в NestJS:

• Снижение нагрузки на основную базу данных за счёт кэширования.
• Поддержка горизонтального масштабирования приложений благодаря централизованному хранилищу состояний.
• Быстрая доставка событий между сервисами через pub/sub-паттерн.
• Гибкость в реализации бизнес-логики: от временных токенов до очередей задач.

Redis особенно эффективен в высоконагруженных приложениях, где время отклика критично. Например, интернет-магазин может кэшировать каталог товаров, а социальная сеть — данные профилей пользователей. При этом NestJS обеспечивает чистую и предсказуемую архитектуру, позволяя изолировать логику работы с Redis в отдельные модули и сервисы.

Установка и подключение Redis к NestJS

Первый шаг — установка необходимых пакетов. Хотя NestJS ранее предоставлял встроенный модуль `@nestjs/redis`, начиная с версии 10 он был помечен как устаревший. На текущий момент рекомендуется использовать пакет `ioredis` в связке с кастомным модулем или сторонними решениями, такими как `@liaoliaots/nestjs-redis`.
Для начала установите зависимости:

1. Выполните команду: npm install ioredis.
2. При необходимости добавьте типы: npm install --save-dev @types/ioredis.
3. Запустите локальный экземпляр Redis: docker run -d -p 6379:6379 redis:alpine.

Теперь создадим кастомный RedisModule. Создайте файл `redis.module.ts`:

@Module({
 imports: [],
 providers: [
 {
 provide: 'REDIS_CLIENT',
 useFactory: async () => {
 const client = new Redis({
 host: 'localhost',
 port: 6379,
 });
 client.on('error', (err) => console.error('Redis Client Error', err));
 return client;
 },
 },
 ],
 exports: ['REDIS_CLIENT'],
})
export class RedisModule {}

Этот модуль регистрирует Redis-клиент как провайдер с токеном `’REDIS_CLIENT’`. Используя `useFactory`, мы можем настраивать подключение динамически, например, на основе переменных окружения.
Чтобы использовать клиент в других сервисах, внедрите его через `@Inject()`:

@Injectable()
export class CacheService {
 constructor(@Inject('REDIS_CLIENT') private readonly redisClient: Redis) {}
 async set(key: string, value: string, ttl?: number): Promise {
 if (ttl) {
 await this.redisClient.setex(key, ttl, value);
 } else {
 await this.redisClient.set(key, value);
 }
 }
 async get(key: string): Promise {
 return this.redisClient.get(key);
 }
}

Не забудьте импортировать `RedisModule` в корневой `AppModule` или нужный функциональный модуль.

Конфигурация Redis для разных сред

В реальных проектах конфигурация Redis отличается между development, staging и production. Для этого можно использовать `ConfigModule` из `@nestjs/config` и динамические модули.
Установите и настройте:
npm install @nestjs/config
Создайте файл `.env`:

REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=
REDIS_TTL=3600
NODE_ENV=development

Обновите `RedisModule` для поддержки конфигурации:

@Global()
@Module({})
export class RedisModule {
 static forRoot(): DynamicModule {
 return {
 module: RedisModule,
 imports: [ConfigModule],
 providers: [
 {
 provide: 'REDIS_CLIENT',
 useFactory: async (configService: ConfigService) => {
 const client = new Redis({
 host: configService.get('REDIS_HOST'),
 port: configService.get('REDIS_PORT'),
 password: configService.get('REDIS_PASSWORD'),
 maxRetriesPerRequest: 3,
 enableOfflineQueue: false,
 });
 client.on('connect', () => console.log('Connected to Redis'));
 client.on('error', (err) => console.error('Redis error:', err));
 return client;
 },
 inject: [ConfigService],
 },
 ],
 exports: ['REDIS_CLIENT'],
 };
 }
}

Теперь импортируйте модуль с конфигурацией:

@Module({
 imports: [
 ConfigModule.forRoot({ isGlobal: true }),
 RedisModule.forRoot(),
 ],
 controllers: [AppController],
 providers: [AppService],
})
export class AppModule {}

Такой подход позволяет легко переключаться между окружениями без изменения кода. В production можно указать кластер Redis или TLS-подключение.

Кэширование с помощью Redis

Одно из самых распространённых применений Redis — кэширование HTTP-ответов. NestJS предоставляет декоратор `@CacheKey()` и `@CacheTTL()`, но для полноценной работы требуется кастомный `CacheModule`, использующий Redis.
Создадим `CachingService`:

@Injectable()
export class CachingService {
 constructor(@Inject('REDIS_CLIENT') private readonly client: Redis) {}
 async get(key: string): Promise {
 const data = await this.client.get(key);
 return data ? JSON.parse(data) : null;
 }
 async set(key: string, value: any, ttl: number = 300): Promise {
 await this.client.setex(key, ttl, JSON.stringify(value));
 }
 async invalidate(pattern: string): Promise {
 const keys = await this.client.keys(`${pattern}*`);
 if (keys.length > 0) {
 await this.client.del(...keys);
 }
 }
}

Теперь можно оборачивать медленные методы:

@Injectable()
export class ProductService {
 constructor(private readonly cachingService: CachingService) {}
 async getAllProducts(): Promise {
 const cacheKey = 'products:all';
 let products = await this.cachingService.get(cacheKey);
 if (!products) {
 products = await this.fetchFromDatabase();
 await this.cachingService.set(cacheKey, products, 600); // 10 минут
 }
 return products;
 }
}

Для автоматического кэширования через интерцепторы можно создать `CacheInterceptor`, который будет анализировать `@CacheKey()` и кэшировать результат.

Автоматическое кэширование с интерцептором

@Injectable()
export class CacheInterceptor implements NestInterceptor {
 constructor(private readonly cachingService: CachingService) {}
 async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
 const request = context.switchToHttp().getRequest();
 const key = this.generateKey(request);
 const cachedResponse = await this.cachingService.get(key);
 if (cachedResponse) {
 return of(cachedResponse);
 }
 return next.handle().pipe(
 tap((data) => this.cachingService.set(key, data)),
 );
 }
 private generateKey(request: Request): string {
 return `${request.method}:${request.url}`;
 }
}

Подключите интерцептор глобально или на уровне контроллера.

Работа с сессиями через Redis

В распределённых приложениях важно, чтобы состояние пользователя (сессия) было доступно во всех экземплярах приложения. Локальное хранение сессий не масштабируется. Redis решает эту проблему.
Используем `express-session` с хранилищем `connect-redis`:
npm install express-session connect-redis
Настройка в `main.ts`:

import session from 'express-session';
import RedisStore from 'connect-redis';
async function bootstrap() {
 const app = await NestFactory.create(AppModule);
 
 const redisClient = app.get('REDIS_CLIENT');
 const redisStore = new RedisStore({ client: redisClient });
 app.use(
 session({
 store: redisStore,
 secret: process.env.SESSION_SECRET || 'secret',
 resave: false,
 saveUninitialized: false,
 cookie: { maxAge: 3600000 }, // 1 час
 }),
 );
 await app.listen(3000);
}
bootstrap();

Теперь сессии будут сохраняться в Redis. Это позволяет масштабировать приложение на несколько инстансов без потери состояния.

Хранение JWT-токенов в Redis

Для повышения безопасности можно хранить активные JWT-токены в Redis, особенно если нужно реализовать их принудительное отключение.
Алгоритм:

1. При входе генерируйте refresh-токен и сохраняйте его хеш в Redis с TTL.
2. При выходе удаляйте токен из Redis.
3. При каждом запросе проверяйте наличие токена в Redis.

Это превращает JWT из stateless в semi-stateful, но даёт контроль над сессией.

Pub/Sub-механизмы в NestJS

Redis поддерживает паттерн «публикация-подписка», позволяя сервисам обмениваться сообщениями асинхронно. Это полезно для уведомлений, логирования, триггеров и микросервисной коммуникации.
Создадим простой публикатор и подписчик:

@Injectable()
export class RedisPublisher {
 private publisher: Redis;
 constructor() {
 this.publisher = new Redis();
 }
 async publish(channel: string, message: string): Promise {
 await this.publisher.publish(channel, message);
 }
}
@Injectable()
export class RedisSubscriber {
 private subscriber: Redis;
 constructor(
 private readonly someService: SomeService,
 ) {
 this.subscriber = new Redis();
 this.subscribeToChannels();
 }
 private subscribeToChannels() {
 this.subscriber.subscribe('notifications');
 this.subscriber.on('message', (channel, message) => {
 if (channel === 'notifications') {
 this.someService.handleNotification(message);
 }
 });
 }
}

Такой подход позволяет избежать жёсткой связанности между компонентами. Например, заказ в одном сервисе может публиковать событие, которое обрабатывается в сервисе уведомлений.

Использование Redis Streams

Redis Streams — более современная альтернатива pub/sub с поддержкой backpressure и гарантированной доставки. Подходит для систем, где нельзя терять сообщения.
Пример записи:

await client.xadd('orders-stream', '*', { orderId: '123', status: 'created' });

Чтение:

const messages = await client.xread('BLOCK', '5000', 'STREAMS', 'orders-stream', '0');

Streams обеспечивают надёжную очередь с возможностью подтверждения обработки.

Оптимизация производительности и типичные ошибки

Несмотря на высокую скорость Redis, неправильное использование может привести к проблемам.

Распространённые ошибки

• Отсутствие TTL у ключей: приводит к утечкам памяти. Всегда устанавливайте срок жизни, если данные временные.
• Слишком большие значения: хранение больших JSON-объектов снижает производительность. Разбивайте данные или используйте compression.
• Синхронные операции в цикле: вызовы GET в цикле лучше заменить на MGET.
• Игнорирование отказоустойчивости: не обрабатывайте ошибки Redis — приложение должно продолжать работать, пусть и с пониженной эффективностью.

Производительность

• Используйте пайплайны для группировки команд.
• Выбирайте подходящие структуры данных: хэши для объектов, списки для очередей.
• Мониторьте использование памяти: INFO memory.
• Настройте eviction policy: maxmemory-policy allkeys-lru.

Безопасность

• Не запускайте Redis без пароля в production.
• Ограничьте доступ по IP.
• Используйте TLS при передаче данных.
• Не храните чувствительные данные в открытом виде.

Экспертное мнение

Интеграция Redis в NestJS должна быть осознанной. Не стоит добавлять кэширование «на всякий случай». Начинайте с анализа узких мест: медленные эндпоинты, частые запросы к БД, состояние сессий.
При проектировании определите границы использования Redis. Кэшируйте только стабильные, дорогостоящие данные. Избегайте кэширования персонализированных ответов, если они не совместно используются.
Для микросервисов используйте Redis как шину событий, но учитывайте, что для сложных сценариев может потребоваться Kafka или RabbitMQ. Redis подходит для лёгких pub/sub и очередей с небольшим объёмом данных.
Модульность NestJS позволяет легко тестировать компоненты с Redis. Заглушайте клиент в unit-тестах, используя Jest и моки. В e2e-тестах поднимайте временный экземпляр Redis через Docker Compose.
Главный принцип: Redis — инструмент, а не решение. Он усиливает архитектуру, но не заменяет качественный дизайн.

Вопросы и ответы

Заключение

Интеграция Redis в NestJS открывает широкие возможности для оптимизации производительности, масштабирования и построения отказоустойчивых систем. Благодаря модульной архитектуре и поддержке DI, NestJS делает процесс подключения и использования Redis естественным и контролируемым.
Redis эффективен не только для кэширования, но и для управления сессиями, реализации pub/sub и организации очередей. Правильная настройка, учёт различий между средами и внимание к безопасности позволяют максимально использовать его потенциал.

• Используйте ioredis с кастомным модулем вместо устаревшего @nestjs/redis.
• Настройте конфигурацию через ConfigModule для разных окружений.
• Применяйте Redis для кэширования, сессий и pub/sub, но не злоупотребляйте.
• Обеспечьте отказоустойчивость: приложение должно работать без Redis.
• Тестируйте и мониторьте использование памяти и производительность.