Rain9Rain9
首页
AI 岗位
AI 目录
前端
后端
桌面端
WebGL
Web3
  • 算法与面试
  • 面试八股
  • Vim 练级
  • Github
  • 掘金
  • 公众号《与 IT 有约》
首页
AI 岗位
AI 目录
前端
后端
桌面端
WebGL
Web3
  • 算法与面试
  • 面试八股
  • Vim 练级
  • Github
  • 掘金
  • 公众号《与 IT 有约》
  • 2026 · AI 时代

    • 程序员的出路:AI 时代的价值思考
    • 从零开始构建智能体(Hello-Agents 课程通俗笔记)

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),我们现在拥有了一个非常健壮的高并发处理架构:

  1. API 网关/控制器:接收到耗时的上传请求(upload-async),快速进行数据校验,并将任务推入 BullMQ 队列,立即返回 HTTP 200。
  2. 缓存拦截:核心处理逻辑执行前,先进行哈希计算,如果 Redis 中已有缓存结果,直接返回,跳过昂贵的大模型调用。
  3. 后台处理器 (Processor):独立于主 HTTP 线程,慢慢消化队列中的任务,调用大模型。
  4. 微服务 RPC (可选):如果系统规模进一步扩大,可以将 AI 处理逻辑完全剥离为独立的微服务集群,通过 Redis Transport 与 API 网关进行高效内部通信。

通过这套组合拳(Redis Caching + BullMQ + Microservices),我们的 AI Agent 后端已经具备了处理生产级别高并发、大数据量请求的能力。

最近更新: 2026/10/31 10:01