5.1 Nest.js 后端性能优化与微服务架构
当我们的 AI Agent 平台开始服务于真实的企业客户时,并发量的增加和庞大文本数据的分析请求会让单体架构(Monolith)面临严峻挑战。大模型(如 OpenAI、Claude)API 的调用通常是耗时且昂贵的。
为了提升系统的响应速度、降低 API 成本,并为未来的水平扩展做好准备,本节我们将结合现有项目,深入探讨并实战 Redis 缓存优化 与 Nest.js 微服务架构。
1. 性能优化:引入 Redis 缓存机制
在数据分析场景中,用户可能会多次请求分析相同或高度相似的数据。如果每次都直接调用 LLM,不仅会导致用户面临漫长的等待,还会产生大量的重复 Token 消耗。
优化方案:基于内容的哈希缓存
在我们的项目中,我们通过引入 @nestjs/cache-manager 和 cache-manager-redis-yet,结合现有的 Redis 基础设施,实现了一套高效的缓存层。
1.1 全局缓存模块配置
首先,在 app.module.ts 中,我们利用 ConfigService 异步注册了全局的 CacheModule,并将其连接到 Redis:
// backend/src/app.module.ts
import { CacheModule } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-yet';
@Module({
imports: [
// ... 其他模块
CacheModule.registerAsync({
isGlobal: true,
inject: [ConfigService],
useFactory: async (configService: ConfigService) => {
const store = await redisStore({
socket: {
host: configService.get('REDIS_HOST', 'localhost'),
port: Number(configService.get('REDIS_PORT', 6379)),
},
});
return {
store,
ttl: 3600000, // 默认 1 小时缓存 (ms)
};
},
}),
],
})
export class AppModule {}
1.2 核心业务的缓存拦截
在 AnalysisService 中,我们为核心的 analyzeText 方法添加了缓存逻辑。为了确保缓存键的唯一性和长度可控,我们对预处理后的长文本计算 SHA-256 哈希值作为 Redis Key。
// backend/src/analysis/analysis.service.ts
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import type { Cache } from 'cache-manager'; // 注意:使用 type-only import 避免编译报错
import * as crypto from 'crypto';
@Injectable()
export class AnalysisService {
constructor(
@Inject('LLM_SERVICE') private readonly llmService: ILLMService,
@Inject(CACHE_MANAGER) private cacheManager: Cache,
) {}
private generateHash(content: string): string {
return crypto.createHash('sha256').update(content).digest('hex');
}
async analyzeText(rawContent: string): Promise<string> {
const cleanContent = this.preprocessText(rawContent);
// 1. 生成基于内容哈希的缓存 Key
const cacheKey = `analysis:text:${this.generateHash(cleanContent)}`;
// 2. 检查缓存是否命中
const cachedResult: string | undefined = await this.cacheManager.get(cacheKey);
if (cachedResult) {
this.logger.log(`🎯 命中缓存,直接返回之前的分析结果!Key: ${cacheKey}`);
return cachedResult;
}
// 3. 缓存未命中,调用大模型
const prompt = `你是一个专业的数据分析专家... \n\n"""\n${cleanContent}\n"""`;
const aiResult = await this.llmService.chat(prompt);
// 4. 将结果存入 Redis,设置过期时间
await this.cacheManager.set(cacheKey, aiResult, 3600000);
this.logger.log(`💾 结果已存入缓存。Key: ${cacheKey}`);
return aiResult;
}
}
通过这套机制,相同的分析请求响应时间将从几秒、十几秒骤降至几毫秒,极大地提升了用户体验并节省了成本。
2. 架构演进:走向微服务 (Microservices)
目前我们的 backend 是一个单体应用,所有的模块(分析、网关、数据库连接、后台任务)都在一个进程里运行。随着业务发展,特别是 AI 分析这种 CPU 和网络 I/O 密集型的任务,很容易拖垮整个系统的 HTTP 响应能力。
Nest.js 原生支持 @nestjs/microservices。我们可以将系统改造为混合应用 (Hybrid Application),即同时监听 HTTP 请求和微服务消息。
2.1 开启微服务监听 (Redis 传输层)
在我们的项目中,为了不引入额外的中间件负担,我们复用了现有的 Redis 作为微服务之间的消息传输层 (Transport)。在 main.ts 中,我们配置并启动了微服务:
// backend/src/main.ts
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
async function bootstrap() {
const app = await NestFactory.create(AppModule, { /* ... */ });
const configService = app.get(ConfigService);
// 开启微服务监听 (混合应用模式)
app.connectMicroservice<MicroserviceOptions>({
transport: Transport.REDIS,
options: {
host: configService.get<string>('REDIS_HOST', 'localhost'),
port: Number(configService.get<number>('REDIS_PORT', 6379)),
},
});
// ... 其他 HTTP 配置 (CORS, Pipes 等)
await app.startAllMicroservices(); // 启动微服务
new Logger('Bootstrap').log(`Microservice is listening via Redis transport`);
await app.listen(port);
}
2.2 暴露微服务接口
在 Controller 层,我们不仅可以暴露 @Post、@Get 等 HTTP 装饰器,还可以使用 @MessagePattern 来暴露微服务接口。这意味着其他服务(如独立部署的 API 网关)可以通过 Redis 向我们的 AI 分析服务发送指令,而无需走 HTTP 协议。
// backend/src/analysis/analysis.controller.ts
import { MessagePattern, Payload } from '@nestjs/microservices';
@Controller('analysis')
export class AnalysisController {
constructor(private readonly analysisService: AnalysisService) {}
// 原有的 HTTP 接口
@Post('text')
async analyzeText(@Body() analyzeTextDto: AnalyzeTextDto) {
return {
success: true,
data: await this.analysisService.analyzeText(analyzeTextDto.content),
};
}
// 新增的微服务接口 (Redis Transport)
// 其他微服务可以通过 ClientProxy.send({ cmd: 'analyze_text_microservice' }, data) 进行 RPC 调用
@MessagePattern({ cmd: 'analyze_text_microservice' })
async handleAnalyzeTextMicroservice(@Payload() data: { content: string }) {
Logger.log(`收到微服务调用请求: analyze_text_microservice`);
const result = await this.analysisService.analyzeText(data.content);
return {
success: true,
data: result,
};
}
}
3. 结合消息队列 (Message Queues) 的全景架构
结合我们在之前章节实现的 BullMQ 异步队列 (@nestjs/bullmq),我们现在拥有了一个非常健壮的高并发处理架构:
- API 网关/控制器:接收到耗时的上传请求(
upload-async),快速进行数据校验,并将任务推入 BullMQ 队列,立即返回 HTTP 200。 - 缓存拦截:核心处理逻辑执行前,先进行哈希计算,如果 Redis 中已有缓存结果,直接返回,跳过昂贵的大模型调用。
- 后台处理器 (Processor):独立于主 HTTP 线程,慢慢消化队列中的任务,调用大模型。
- 微服务 RPC (可选):如果系统规模进一步扩大,可以将 AI 处理逻辑完全剥离为独立的微服务集群,通过 Redis Transport 与 API 网关进行高效内部通信。
通过这套组合拳(Redis Caching + BullMQ + Microservices),我们的 AI Agent 后端已经具备了处理生产级别高并发、大数据量请求的能力。
