SDXL 1.0电影级绘图工坊：Node.js后端服务开发与性能优化
最近在折腾AI绘画，特别是SDXL 1.0这个模型，生成的效果确实惊艳，电影感十足。但问题来了，如果只是自己用用还好，要是想做成一个服务，让更多人能方便地使用，就得好好设计一下后端了。
我花了些时间，用Node.js搭了一套SDXL 1.0的后端服务，中间踩了不少坑，也总结了一些性能优化的经验。今天就跟大家分享一下，怎么从零开始，搭建一个稳定、高效、能扛得住一定压力的AI绘图后端服务。
1. 环境准备与项目初始化
开始之前，得先把基础环境搭好。这里我用的是Node.js 18+的版本，因为这个版本对ES模块的支持比较完善，而且性能也不错。
1.1 Node.js安装与环境配置
如果你还没装Node.js，可以去官网下载安装包，或者用nvm来管理多个版本。我个人推荐用nvm，切换版本比较方便。
# 用nvm安装Node.js 18 nvm install 18 nvm use 18 # 检查安装是否成功 node --version npm --version装好Node.js后，创建一个新的项目目录，初始化一下：
mkdir sdxl-backend cd sdxl-backend npm init -y1.2 安装核心依赖
SDXL 1.0的推理需要用到一些专门的库，这里我选择了几个比较成熟的：
# 安装Express作为Web框架 npm install express # 用于处理HTTP请求的客户端 npm install axios # 处理图片相关的库 npm install sharp # 环境变量管理 npm install dotenv # 日志记录 npm install winston # 开发依赖 npm install --save-dev nodemon typescript @types/node @types/express1.3 项目结构设计
一个好的项目结构能让后续开发轻松很多。我是这样组织的：
sdxl-backend/ ├── src/ │ ├── controllers/ # 控制器 │ ├── services/ # 业务逻辑 │ ├── models/ # 数据模型 │ ├── routes/ # 路由定义 │ ├── middleware/ # 中间件 │ ├── utils/ # 工具函数 │ └── app.ts # 应用入口 ├── config/ # 配置文件 ├── logs/ # 日志文件 ├── tests/ # 测试文件 ├── package.json └── tsconfig.json2. 核心API设计与实现
API设计是后端服务的核心，得考虑清楚用户怎么用、怎么传参数、怎么返回结果。
2.1 基础API路由设计
我设计了几个主要的API端点，覆盖了常用的功能：
// src/routes/api.ts import express from 'express'; import { generateImage, getJobStatus, batchGenerate } from '../controllers/imageController'; const router = express.Router(); // 单张图片生成 router.post('/generate', generateImage); // 批量图片生成 router.post('/batch-generate', batchGenerate); // 查询任务状态 router.get('/status/:jobId', getJobStatus); // 获取历史记录 router.get('/history', getHistory); // 删除任务 router.delete('/job/:jobId', deleteJob); export default router;2.2 图片生成接口实现
图片生成是最核心的功能，这里需要考虑参数验证、异步处理、错误处理等多个方面。
// src/controllers/imageController.ts import { Request, Response } from 'express'; import { v4 as uuidv4 } from 'uuid'; import { generateImageService } from '../services/imageService'; import { validatePrompt, validateParameters } from '../utils/validation'; export const generateImage = async (req: Request, res: Response) => { try { const { prompt, negative_prompt = '', width = 1024, height = 1024, steps = 20, guidance_scale = 7.5, seed = null, style = 'realistic' } = req.body; // 参数验证 if (!validatePrompt(prompt)) { return res.status(400).json({ error: 'Invalid prompt', message: 'Prompt must be between 1 and 1000 characters' }); } const validationResult = validateParameters({ width, height, steps, guidance_scale }); if (!validationResult.valid) { return res.status(400).json({ error: 'Invalid parameters', details: validationResult.errors }); } // 生成任务ID const jobId = uuidv4(); // 立即返回任务ID，让客户端可以轮询状态 res.status(202).json({ jobId, message: 'Image generation started', statusUrl: `/api/status/${jobId}` }); // 异步处理图片生成 generateImageService({ jobId, prompt, negative_prompt, width, height, steps, guidance_scale, seed, style }).catch(error => { console.error(`Job ${jobId} failed:`, error); // 这里可以更新任务状态为失败 }); } catch (error) { console.error('Generate image error:', error); res.status(500).json({ error: 'Internal server error', message: 'Failed to start image generation' }); } };2.3 任务状态查询接口
因为图片生成比较耗时，所以采用了异步处理的方式。用户提交任务后，可以通过任务ID查询状态。
// src/controllers/imageController.ts export const getJobStatus = async (req: Request, res: Response) => { try { const { jobId } = req.params; // 这里可以从数据库或缓存中获取任务状态 const jobStatus = await getJobStatusFromStore(jobId); if (!jobStatus) { return res.status(404).json({ error: 'Job not found', message: `Job with ID ${jobId} does not exist` }); } const response: any = { jobId, status: jobStatus.status, createdAt: jobStatus.createdAt }; // 如果任务完成，返回图片URL if (jobStatus.status === 'completed' && jobStatus.imageUrl) { response.imageUrl = jobStatus.imageUrl; response.metadata = jobStatus.metadata; } // 如果任务失败，返回错误信息 if (jobStatus.status === 'failed') { response.error = jobStatus.error; } res.json(response); } catch (error) { console.error('Get job status error:', error); res.status(500).json({ error: 'Internal server error', message: 'Failed to get job status' }); } };3. 与SDXL 1.0模型集成
这是最核心的部分，怎么让Node.js后端调用SDXL 1.0模型。根据部署方式的不同，有几种不同的集成方案。
3.1 通过HTTP API调用
如果SDXL模型部署在另一个服务上（比如用Python的FastAPI部署），可以通过HTTP调用的方式。
// src/services/sdxlService.ts import axios from 'axios'; class SDXLService { private apiUrl: string; private apiKey: string; constructor() { this.apiUrl = process.env.SDXL_API_URL || 'http://localhost:8000'; this.apiKey = process.env.SDXL_API_KEY || ''; } async generateImage(params: GenerateParams): Promise<GenerateResult> { try { const response = await axios.post( `${this.apiUrl}/generate`, params, { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` }, timeout: 300000 // 5分钟超时 } ); return { success: true, imageData: response.data.image, metadata: response.data.metadata }; } catch (error: any) { console.error('SDXL API error:', error.message); return { success: false, error: error.response?.data?.error || 'SDXL service error', retryable: this.isRetryableError(error) }; } } private isRetryableError(error: any): boolean { // 网络错误、超时等可以重试 if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT' || error.response?.status === 502 || error.response?.status === 503) { return true; } return false; } async batchGenerate(params: BatchGenerateParams): Promise<BatchGenerateResult> { // 批量生成逻辑 const promises = params.prompts.map(prompt => this.generateImage({ ...params, prompt }) ); const results = await Promise.allSettled(promises); return { total: results.length, succeeded: results.filter(r => r.status === 'fulfilled').length, failed: results.filter(r => r.status === 'rejected').length, results: results.map((result, index) => ({ prompt: params.prompts[index], status: result.status, data: result.status === 'fulfilled' ? result.value : undefined, error: result.status === 'rejected' ? result.reason : undefined })) }; } } export default new SDXLService();3.2 使用ONNX Runtime直接推理
如果希望更紧密地集成，也可以考虑用ONNX Runtime在Node.js中直接运行模型。
// src/services/onnxService.ts import { InferenceSession, Tensor } from 'onnxruntime-node'; class ONNXService { private session: InferenceSession | null = null; private isInitialized = false; async initialize() { if (this.isInitialized) return; try { // 加载ONNX模型 this.session = await InferenceSession.create( './models/sdxl-1.0.onnx', { executionProviders: ['CUDAExecutionProvider', 'CPUExecutionProvider'], graphOptimizationLevel: 'all' } ); this.isInitialized = true; console.log('ONNX model loaded successfully'); } catch (error) { console.error('Failed to load ONNX model:', error); throw error; } } async generateImage(params: GenerateParams): Promise<GenerateResult> { if (!this.session) { await this.initialize(); } try { // 准备输入tensor const promptTensor = new Tensor('string', [params.prompt]); const negativePromptTensor = new Tensor('string', [params.negative_prompt]); const sizeTensor = new Tensor('int64', [params.width, params.height]); // 执行推理 const feeds = { prompt: promptTensor, negative_prompt: negativePromptTensor, size: sizeTensor, steps: new Tensor('int64', [params.steps]), guidance_scale: new Tensor('float32', [params.guidance_scale]) }; const results = await this.session!.run(feeds); // 处理输出 const imageTensor = results.image; const imageData = this.tensorToImageData(imageTensor); return { success: true, imageData, metadata: { inferenceTime: results.metadata?.inference_time || 0, memoryUsage: results.metadata?.memory_usage || 0 } }; } catch (error: any) { console.error('ONNX inference error:', error); return { success: false, error: error.message }; } } private tensorToImageData(tensor: Tensor): Buffer { // 将tensor转换为图片数据 // 这里需要根据模型的实际输出格式来处理 return Buffer.from(tensor.data); } } export default new ONNXService();4. 性能优化策略
AI图片生成对性能要求比较高，特别是并发量大的时候。下面是我实践过的一些优化方法。
4.1 请求队列与限流
为了防止服务被大量请求压垮，需要实现请求队列和限流机制。
// src/services/queueService.ts import Queue from 'bull'; import { Job } from 'bull'; class QueueService { private imageQueue: Queue; private maxConcurrent: number; constructor() { this.imageQueue = new Queue('image-generation', { redis: { host: process.env.REDIS_HOST || 'localhost', port: parseInt(process.env.REDIS_PORT || '6379') }, limiter: { max: 10, // 最大并发数 duration: 1000 } }); this.maxConcurrent = parseInt(process.env.MAX_CONCURRENT_JOBS || '3'); this.setupWorker(); } private setupWorker() { // 设置工作进程 this.imageQueue.process(this.maxConcurrent, async (job: Job) => { const { params } = job.data; try { const result = await this.processImageJob(params); // 更新任务状态 await this.updateJobStatus(job.id.toString(), 'completed', { imageUrl: result.imageUrl, metadata: result.metadata }); return result; } catch (error: any) { // 更新任务状态为失败 await this.updateJobStatus(job.id.toString(), 'failed', { error: error.message }); throw error; } }); // 处理队列事件 this.imageQueue.on('completed', (job: Job, result: any) => { console.log(`Job ${job.id} completed in ${result.duration}ms`); }); this.imageQueue.on('failed', (job: Job, error: Error) => { console.error(`Job ${job.id} failed:`, error.message); }); } async addJob(params: any): Promise<string> { const job = await this.imageQueue.add({ params, timestamp: Date.now() }, { attempts: 3, // 重试3次 backoff: { type: 'exponential', delay: 5000 }, timeout: 300000 // 5分钟超时 }); // 初始状态 await this.updateJobStatus(job.id.toString(), 'pending'); return job.id.toString(); } private async processImageJob(params: any): Promise<any> { // 调用SDXL服务生成图片 const startTime = Date.now(); const result = await sdxlService.generateImage(params); if (!result.success) { throw new Error(result.error); } // 保存图片到存储 const imageUrl = await this.saveImage(result.imageData, params); const duration = Date.now() - startTime; return { imageUrl, metadata: { ...result.metadata, duration, params } }; } private async saveImage(imageData: Buffer, params: any): Promise<string> { // 保存图片到文件系统或对象存储 const filename = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}.png`; const filepath = `./generated/${filename}`; // 使用sharp处理图片 const sharp = require('sharp'); await sharp(imageData) .png({ quality: 95 }) .toFile(filepath); // 返回访问URL return `/generated/${filename}`; } private async updateJobStatus(jobId: string, status: string, data?: any) { // 更新任务状态到Redis或数据库 const redis = require('redis'); const client = redis.createClient(); await client.connect(); const statusData = { jobId, status, updatedAt: Date.now(), ...data }; await client.set(`job:${jobId}`, JSON.stringify(statusData), { EX: 3600 // 1小时过期 }); await client.quit(); } async getJobStatus(jobId: string): Promise<any> { const redis = require('redis'); const client = redis.createClient(); await client.connect(); const data = await client.get(`job:${jobId}`); await client.quit(); return data ? JSON.parse(data) : null; } } export default new QueueService();4.2 图片缓存与CDN
生成的图片可以缓存起来，避免重复生成，同时用CDN加速访问。
// src/services/cacheService.ts import NodeCache from 'node-cache'; class CacheService { private imageCache: NodeCache; private promptCache: NodeCache; constructor() { // 图片缓存：键为参数哈希，值为图片URL this.imageCache = new NodeCache({ stdTTL: 3600, // 1小时 checkperiod: 600, useClones: false }); // 提示词缓存：避免重复处理相似提示词 this.promptCache = new NodeCache({ stdTTL: 1800, checkperiod: 300 }); } generateCacheKey(params: any): string { // 根据参数生成缓存键 const { prompt, width, height, steps, guidance_scale, seed, style } = params; const keyData = { prompt: this.normalizePrompt(prompt), width, height, steps, guidance_scale: Math.round(guidance_scale * 10) / 10, // 保留一位小数 seed, style }; return require('crypto') .createHash('md5') .update(JSON.stringify(keyData)) .digest('hex'); } private normalizePrompt(prompt: string): string { // 标准化提示词：去除多余空格、转换为小写等 return prompt .toLowerCase() .replace(/\s+/g, ' ') .trim(); } async getCachedImage(params: any): Promise<string | null> { const cacheKey = this.generateCacheKey(params); // 先检查图片缓存 const imageUrl = this.imageCache.get<string>(cacheKey); if (imageUrl) { console.log(`Cache hit for key: ${cacheKey}`); return imageUrl; } // 检查提示词缓存，避免重复生成相似图片 const normalizedPrompt = this.normalizePrompt(params.prompt); const similarResults = this.findSimilarInCache(normalizedPrompt, params); if (similarResults.length > 0) { // 返回最相似的缓存结果 console.log(`Found ${similarResults.length} similar cached images`); return similarResults[0].imageUrl; } return null; } private findSimilarInCache(prompt: string, params: any): Array<{imageUrl: string, similarity: number}> { const results: Array<{imageUrl: string, similarity: number}> = []; // 获取所有缓存键 const keys = this.imageCache.keys(); for (const key of keys) { const cachedData = this.imageCache.get<any>(key); if (cachedData && cachedData.params) { const similarity = this.calculatePromptSimilarity( prompt, this.normalizePrompt(cachedData.params.prompt) ); // 如果相似度超过阈值，且其他参数相同 if (similarity > 0.8 && this.areParamsSimilar(params, cachedData.params)) { results.push({ imageUrl: cachedData.imageUrl, similarity }); } } } // 按相似度排序 return results.sort((a, b) => b.similarity - a.similarity); } private calculatePromptSimilarity(prompt1: string, prompt2: string): number { // 简单的相似度计算：Jaccard相似度 const words1 = new Set(prompt1.split(' ')); const words2 = new Set(prompt2.split(' ')); const intersection = new Set([...words1].filter(x => words2.has(x))); const union = new Set([...words1, ...words2]); return intersection.size / union.size; } private areParamsSimilar(params1: any, params2: any): boolean { // 检查除prompt外的其他参数是否相同 const keys = ['width', 'height', 'steps', 'guidance_scale', 'style']; for (const key of keys) { if (params1[key] !== params2[key]) { return false; } } return true; } cacheImage(params: any, imageUrl: string): void { const cacheKey = this.generateCacheKey(params); this.imageCache.set(cacheKey, { imageUrl, params, cachedAt: Date.now() }); // 同时缓存提示词 const normalizedPrompt = this.normalizePrompt(params.prompt); this.promptCache.set(normalizedPrompt, cacheKey); } async preloadCommonPrompts(): Promise<void> { // 预加载常用提示词对应的图片 const commonPrompts = [ 'a beautiful sunset over mountains, cinematic lighting', 'a futuristic city at night, neon lights, cyberpunk style', 'a cute anime character, detailed eyes, vibrant colors', 'a realistic portrait of a person, professional photography', 'a fantasy landscape with dragons and castles' ]; for (const prompt of commonPrompts) { const params = { prompt, width: 1024, height: 1024, steps: 20, guidance_scale: 7.5, style: 'realistic' }; // 异步预生成，不阻塞主线程 setTimeout(async () => { try { const result = await sdxlService.generateImage(params); if (result.success) { const imageUrl = await this.saveImageForPreload(result.imageData, params); this.cacheImage(params, imageUrl); console.log(`Preloaded image for prompt: ${prompt.substring(0, 50)}...`); } } catch (error) { console.error(`Failed to preload for prompt: ${prompt}`, error); } }, Math.random() * 10000); // 随机延迟，避免同时发起大量请求 } } } export default new CacheService();4.3 内存管理与垃圾回收
Node.js的内存管理需要特别注意，特别是处理大量图片数据时。
// src/utils/memoryManager.ts class MemoryManager { private maxMemoryUsage: number; private cleanupThreshold: number; private cleanupInterval: NodeJS.Timeout | null = null; constructor() { // 最大内存使用量（MB） this.maxMemoryUsage = parseInt(process.env.MAX_MEMORY_MB || '2048'); // 清理阈值（百分比） this.cleanupThreshold = parseFloat(process.env.CLEANUP_THRESHOLD || '0.8'); } startMonitoring(): void { // 定期检查内存使用情况 this.cleanupInterval = setInterval(() => { this.checkAndCleanup(); }, 60000); // 每分钟检查一次 // 监听进程信号 process.on('SIGTERM', () => this.cleanup()); process.on('SIGINT', () => this.cleanup()); } private checkAndCleanup(): void { const memoryUsage = process.memoryUsage(); const usedMB = memoryUsage.heapUsed / 1024 / 1024; const totalMB = memoryUsage.heapTotal / 1024 / 1024; const usagePercentage = usedMB / this.maxMemoryUsage; console.log(`Memory usage: ${usedMB.toFixed(2)}MB / ${totalMB.toFixed(2)}MB (${(usagePercentage * 100).toFixed(1)}%)`); if (usagePercentage > this.cleanupThreshold) { console.log('Memory usage high, starting cleanup...'); this.performCleanup(); } } private performCleanup(): void { // 1. 清理缓存 cacheService.clearExpired(); // 2. 建议垃圾回收（需要启动时加上--expose-gc参数） if (global.gc) { console.log('Running garbage collection...'); global.gc(); } // 3. 清理临时文件 this.cleanupTempFiles(); // 4. 记录内存状态 this.logMemoryStats(); } private cleanupTempFiles(): void { const fs = require('fs').promises; const path = require('path'); const tempDir = './temp'; fs.readdir(tempDir) .then(files => { const now = Date.now(); const maxAge = 3600000; // 1小时 const cleanupPromises = files.map(async (file) => { const filePath = path.join(tempDir, file); const stats = await fs.stat(filePath); if (now - stats.mtimeMs > maxAge) { await fs.unlink(filePath); console.log(`Cleaned up temp file: ${file}`); } }); return Promise.all(cleanupPromises); }) .catch(error => { if (error.code !== 'ENOENT') { console.error('Failed to cleanup temp files:', error); } }); } private logMemoryStats(): void { const memoryUsage = process.memoryUsage(); console.log('Memory statistics after cleanup:'); console.log(` Heap Used: ${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`); console.log(` Heap Total: ${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`); console.log(` RSS: ${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`); console.log(` External: ${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB`); } registerLargeBuffer(buffer: Buffer, description: string): void { // 注册大内存对象，便于跟踪 const sizeMB = buffer.length / 1024 / 1024; if (sizeMB > 10) { // 大于10MB的buffer需要特别关注 console.log(`Large buffer allocated: ${description} (${sizeMB.toFixed(2)}MB)`); // 设置超时自动释放 setTimeout(() => { if (buffer) { // 帮助垃圾回收 (buffer as any) = null; console.log(`Large buffer released: ${description}`); } }, 300000); // 5分钟后释放 } } cleanup(): void { if (this.cleanupInterval) { clearInterval(this.cleanupInterval); this.cleanupInterval = null; } this.performCleanup(); console.log('Memory manager cleaned up'); } } export default new MemoryManager();5. 错误处理与监控
稳定的服务需要有完善的错误处理和监控机制。
5.1 全局错误处理
// src/middleware/errorHandler.ts import { Request, Response, NextFunction } from 'express'; import { ValidationError } from 'joi'; import { ApiError } from '../utils/errors'; export const errorHandler = ( error: Error, req: Request, res: Response, next: NextFunction ) => { console.error('Error:', { message: error.message, stack: error.stack, path: req.path, method: req.method, timestamp: new Date().toISOString() }); // 验证错误 if (error instanceof ValidationError) { return res.status(400).json({ error: 'Validation Error', message: error.message, details: error.details }); } // 自定义API错误 if (error instanceof ApiError) { return res.status(error.statusCode).json({ error: error.name, message: error.message, ...(error.details && { details: error.details }) }); } // 数据库错误 if (error.name === 'MongoError' || error.name === 'SequelizeError') { return res.status(500).json({ error: 'Database Error', message: 'A database error occurred', referenceId: req.headers['x-request-id'] }); } // 默认错误响应 res.status(500).json({ error: 'Internal Server Error', message: 'An unexpected error occurred', referenceId: req.headers['x-request-id'], ...(process.env.NODE_ENV === 'development' && { stack: error.stack }) }); }; // 404处理 export const notFoundHandler = (req: Request, res: Response) => { res.status(404).json({ error: 'Not Found', message: `Cannot ${req.method} ${req.path}` }); };5.2 健康检查与监控
// src/routes/health.ts import express from 'express'; import os from 'os'; const router = express.Router(); router.get('/health', (req, res) => { const health = { status: 'healthy', timestamp: new Date().toISOString(), uptime: process.uptime(), memory: process.memoryUsage(), cpu: os.loadavg(), queue: { waiting: queueService.getWaitingCount(), active: queueService.getActiveCount(), completed: queueService.getCompletedCount() }, cache: { hits: cacheService.getHitCount(), misses: cacheService.getMissCount(), size: cacheService.getSize() } }; res.json(health); }); router.get('/ready', (req, res) => { // 检查所有依赖服务是否就绪 const checks = { redis: checkRedis(), database: checkDatabase(), sdxlService: checkSDXLService(), storage: checkStorage() }; Promise.all(Object.values(checks)) .then(results => { const allReady = results.every(result => result.ready); if (allReady) { res.json({ status: 'ready', checks }); } else { res.status(503).json({ status: 'not ready', checks, message: 'Some services are not ready' }); } }) .catch(error => { res.status(503).json({ status: 'error', message: 'Failed to check readiness', error: error.message }); }); }); router.get('/metrics', async (req, res) => { const metrics = { requests: { total: getRequestCount(), byEndpoint: getRequestsByEndpoint(), byStatus: getRequestsByStatus() }, generation: { total: getGenerationCount(), averageTime: getAverageGenerationTime(), successRate: getSuccessRate() }, performance: { averageResponseTime: getAverageResponseTime(), p95ResponseTime: getP95ResponseTime(), errorRate: getErrorRate() } }; res.json(metrics); }); async function checkRedis(): Promise<{ready: boolean, latency?: number}> { const start = Date.now(); try { const redis = require('redis'); const client = redis.createClient(); await client.connect(); await client.ping(); await client.quit(); const latency = Date.now() - start; return { ready: true, latency }; } catch (error) { return { ready: false }; } } // 其他检查函数类似... export default router;5.3 日志记录
// src/utils/logger.ts import winston from 'winston'; import DailyRotateFile from 'winston-daily-rotate-file'; const logger = winston.createLogger({ level: process.env.LOG_LEVEL || 'info', format: winston.format.combine( winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.errors({ stack: true }), winston.format.splat(), winston.format.json() ), defaultMeta: { service: 'sdxl-backend' }, transports: [ // 控制台输出 new winston.transports.Console({ format: winston.format.combine( winston.format.colorize(), winston.format.printf( ({ timestamp, level, message, service, ...meta }) => { return `${timestamp} [${service}] ${level}: ${message} ${ Object.keys(meta).length ? JSON.stringify(meta) : '' }`; } ) ) }), // 按天轮转的文件日志 new DailyRotateFile({ filename: 'logs/application-%DATE%.log', datePattern: 'YYYY-MM-DD', zippedArchive: true, maxSize: '20m', maxFiles: '30d' }), // 错误日志单独文件 new DailyRotateFile({ filename: 'logs/error-%DATE%.log', datePattern: 'YYYY-MM-DD', zippedArchive: true, maxSize: '20m', maxFiles: '30d', level: 'error' }) ] }); // 请求日志中间件 export const requestLogger = (req: any, res: any, next: any) => { const start = Date.now(); // 记录请求开始 logger.info('Request started', { method: req.method, url: req.url, ip: req.ip, userAgent: req.get('User-Agent') }); // 响应完成后记录 res.on('finish', () => { const duration = Date.now() - start; logger.info('Request completed', { method: req.method, url: req.url, status: res.statusCode, duration, contentLength: res.get('Content-Length') }); }); next(); }; // 图片生成日志 export const logGeneration = ( jobId: string, params: any, result: any, duration: number ) => { logger.info('Image generated', { jobId, prompt: params.prompt?.substring(0, 100), // 只记录前100字符 width: params.width, height: params.height, steps: params.steps, duration, success: result.success, cacheHit: result.cacheHit || false }); }; export default logger;6. 部署与配置
6.1 环境配置
// config/config.js require('dotenv').config(); module.exports = { server: { port: process.env.PORT || 3000, host: process.env.HOST || '0.0.0.0', env: process.env.NODE_ENV || 'development' }, sdxl: { apiUrl: process.env.SDXL_API_URL, apiKey: process.env.SDXL_API_KEY, timeout: parseInt(process.env.SDXL_TIMEOUT || '300000'), maxRetries: parseInt(process.env.SDXL_MAX_RETRIES || '3') }, redis: { host: process.env.REDIS_HOST || 'localhost', port: parseInt(process.env.REDIS_PORT || '6379'), password: process.env.REDIS_PASSWORD, db: parseInt(process.env.REDIS_DB || '0') }, queue: { maxConcurrent: parseInt(process.env.MAX_CONCURRENT_JOBS || '3'), maxJobsPerSecond: parseInt(process.env.MAX_JOBS_PER_SECOND || '10') }, cache: { ttl: parseInt(process.env.CACHE_TTL || '3600'), maxSize: parseInt(process.env.CACHE_MAX_SIZE || '1000') }, storage: { type: process.env.STORAGE_TYPE || 'local', // local, s3, oss localPath: process.env.LOCAL_STORAGE_PATH || './generated', maxFileSize: parseInt(process.env.MAX_FILE_SIZE || '10485760') // 10MB }, security: { rateLimit: { windowMs: parseInt(process.env.RATE_LIMIT_WINDOW || '900000'), // 15分钟 max: parseInt(process.env.RATE_LIMIT_MAX || '100') }, apiKeys: process.env.API_KEYS ? process.env.API_KEYS.split(',') : [] }, monitoring: { enabled: process.env.MONITORING_ENABLED === 'true', sentryDsn: process.env.SENTRY_DSN, metricsPort: parseInt(process.env.METRICS_PORT || '9090') } };6.2 Docker部署
# Dockerfile FROM node:18-alpine WORKDIR /app # 安装系统依赖 RUN apk add --no-cache \ python3 \ make \ g++ \ git \ curl \ && rm -rf /var/cache/apk/* # 复制package文件 COPY package*.json ./ # 安装依赖 RUN npm ci --only=production # 复制源代码 COPY . . # 创建必要的目录 RUN mkdir -p logs generated temp # 设置权限 RUN chown -R node:node /app USER node # 健康检查 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD node health-check.js EXPOSE 3000 CMD ["node", "src/app.js"]# docker-compose.yml version: '3.8' services: app: build: . ports: - "3000:3000" environment: - NODE_ENV=production - REDIS_HOST=redis - SDXL_API_URL=${SDXL_API_URL} volumes: - ./logs:/app/logs - ./generated:/app/generated depends_on: - redis restart: unless-stopped networks: - sdxl-network redis: image: redis:7-alpine ports: - "6379:6379" volumes: - redis-data:/data command: redis-server --appendonly yes restart: unless-stopped networks: - sdxl-network nginx: image: nginx:alpine ports: - "80:80" - "443:443" volumes: - ./nginx.conf:/etc/nginx/nginx.conf - ./ssl:/etc/nginx/ssl - ./generated:/var/www/generated depends_on: - app restart: unless-stopped networks: - sdxl-network volumes: redis-data: networks: sdxl-network: driver: bridge7. 总结
整体用下来，用Node.js搭建SDXL 1.0的后端服务还是挺顺畅的。Express的生态很成熟，各种中间件和工具都很齐全，开发效率比较高。性能方面，通过队列、缓存、连接池这些优化，基本上能满足中小规模的使用需求。
不过也有些需要注意的地方。比如内存管理要特别小心，图片数据比较大，处理不好容易内存泄漏。还有错误处理要做得细致一些，AI服务的不确定性比较大，各种奇怪的错误都可能出现。
如果你也打算做类似的项目，建议先从简单的版本开始，把核心的图片生成功能跑通，然后再逐步添加队列、缓存、监控这些功能。测试的时候要多模拟一些并发场景，看看服务的表现怎么样。
部署方面，Docker确实方便，把环境打包好，到哪里都能跑。配合Nginx做反向代理和负载均衡，稳定性会好很多。
当然，这只是个起点。后面还可以考虑加更多功能，比如用户系统、计费、模型微调这些。或者做更深入的性能优化，比如用WebSocket实现实时进度通知，用更智能的缓存策略等等。
获取更多AI镜像
想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。
