Node.js Express 파일 업로드 최적화 방법: 대용량·다중 파일 처리 성능 향상 가이드
Node.js Express에서 멀터(multer)와 스트리밍을 활용한 대용량 파일 업로드 최적화로 메모리 효율성을 최대 90%까지 향상시키고, AWS S3 연동과 청크 업로드로 파일 전송 성능을 극대화하는 종합 가이드입니다.
파일 업로드 최적화의 중요성
현대 웹 애플리케이션에서 Node.js Express 파일 업로드는 필수 기능입니다.
하지만 기존의 전통적인 업로드 방식은 여러 한계점을 가지고 있습니다.
기존 방식의 문제점:
- 메모리 사용량 급증으로 인한 서버 불안정
- 네트워크 장애 시 전체 파일 재업로드 필요
- 대용량 파일 처리 시 타임아웃 발생
- 동시 업로드 시 성능 저하
최적화된 접근 방식:
- 스트리밍 업로드로 메모리 효율성 향상
- 청크 업로드를 통한 안정성 확보
- 비동기 처리로 동시성 향상
- 클라우드 연동으로 확장성 확보
multer 기본 설정과 최적화
Express 환경 설정
Node.js 파일 업로드의 핵심인 multer 설정부터 시작하겠습니다.
const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const app = express();
const uploadDir = './uploads';
if (!fs.existsSync(uploadDir)) {
fs.mkdirSync(uploadDir, { recursive: true });
}
multer 스토리지 최적화
multer 업로드 최적화를 위한 스토리지 엔진 설정:
const storage = multer.diskStorage({
destination: function (req, file, cb) {
cb(null, uploadDir);
},
filename: function (req, file, cb) {
const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
const fileExtension = path.extname(file.originalname);
const sanitizedName = file.fieldname + '-' + uniqueSuffix + fileExtension;
cb(null, sanitizedName);
}
});
const upload = multer({
storage: storage,
limits: {
fileSize: 100 * 1024 * 1024,
files: 10
},
fileFilter: (req, file, cb) => {
const allowedMimes = [
'image/jpeg', 'image/png', 'image/gif',
'video/mp4', 'application/pdf'
];
if (allowedMimes.includes(file.mimetype)) {
cb(null, true);
} else {
cb(new Error('지원하지 않는 파일 형식입니다.'), false);
}
}
});
메모리 스토리지 vs 디스크 스토리지 비교
| 특징 | 메모리 스토리지 | 디스크 스토리지 |
|---|
| 처리 속도 | 빠름 | 보통 |
| 메모리 사용량 | 높음 | 낮음 |
| 대용량 파일 | 부적합 | 적합 |
| 서버 안정성 | 낮음 | 높음 |
| 권장 용도 | 소용량 이미지 | 모든 파일 |
권장사항: Node.js 대용량 파일 업로드에는 디스크 스토리지를 사용하세요.
대용량 파일 처리를 위한 스트리밍 구현
스트리밍 업로드의 핵심 개념
스트리밍 업로드는 파일을 청크 단위로 처리하여 메모리 효율성을 극대화합니다.
const busboy = require('busboy');
const fs = require('fs');
const path = require('path');
function streamingUpload(req, res, next) {
const bb = busboy({
headers: req.headers,
limits: {
fileSize: 1024 * 1024 * 1024,
files: 1
}
});
bb.on('file', (name, file, info) => {
const { filename, encoding, mimeType } = info;
console.log(`스트리밍 업로드 시작: ${filename}`);
const safeName = `${Date.now()}-${path.basename(filename)}`;
const filePath = path.join('./uploads', safeName);
const writeStream = fs.createWriteStream(filePath);
file.pipe(writeStream);
let uploadedBytes = 0;
file.on('data', (data) => {
uploadedBytes += data.length;
console.log(`업로드 진행: ${uploadedBytes} bytes`);
});
writeStream.on('close', () => {
console.log(`업로드 완료: ${filename}`);
req.uploadedFile = {
filename: safeName,
path: filePath,
size: uploadedBytes,
mimetype: mimeType
};
next();
});
writeStream.on('error', (err) => {
console.error('스트림 에러:', err);
next(err);
});
});
bb.on('finish', () => {
console.log('모든 파일 업로드 완료');
});
req.pipe(bb);
}
실시간 업로드 진행률 추적
Node.js 파일 업로드 속도 모니터링을 위한 진행률 추적:
const EventEmitter = require('events');
class UploadProgress extends EventEmitter {
constructor() {
super();
this.uploads = new Map();
}
startUpload(uploadId, totalSize) {
this.uploads.set(uploadId, {
totalSize,
uploadedSize: 0,
startTime: Date.now(),
speed: 0
});
}
updateProgress(uploadId, chunkSize) {
const upload = this.uploads.get(uploadId);
if (!upload) return;
upload.uploadedSize += chunkSize;
const elapsed = Date.now() - upload.startTime;
upload.speed = (upload.uploadedSize / elapsed) * 1000;
const progress = {
uploadId,
percent: (upload.uploadedSize / upload.totalSize) * 100,
speed: upload.speed,
remaining: (upload.totalSize - upload.uploadedSize) / upload.speed
};
this.emit('progress', progress);
}
completeUpload(uploadId) {
this.uploads.delete(uploadId);
this.emit('complete', uploadId);
}
}
const uploadProgress = new UploadProgress();
메모리 관리와 성능 최적화
버퍼 메모리 관리 전략
버퍼 메모리 관리는 Node.js 성능 최적화의 핵심입니다.
function optimizedFileHandler() {
const DEFAULT_HIGH_WATER_MARK = 64 * 1024;
return multer({
storage: multer.memoryStorage(),
limits: {
fileSize: 50 * 1024 * 1024,
fieldSize: 1024 * 1024
}
});
}
function monitorMemoryUsage() {
setInterval(() => {
const used = process.memoryUsage();
const memoryStats = {
rss: Math.round(used.rss / 1024 / 1024 * 100) / 100,
heapTotal: Math.round(used.heapTotal / 1024 / 1024 * 100) / 100,
heapUsed: Math.round(used.heapUsed / 1024 / 1024 * 100) / 100,
external: Math.round(used.external / 1024 / 1024 * 100) / 100
};
console.log('메모리 사용량:', memoryStats, 'MB');
if (memoryStats.heapUsed > 512) {
if (global.gc) {
global.gc();
console.log('가비지 컬렉션 실행됨');
}
}
}, 5000);
}
monitorMemoryUsage();
비동기 처리 최적화
Express 비동기 업로드를 위한 워커 풀 활용:
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const os = require('os');
class FileProcessorPool {
constructor(poolSize = os.cpus().length) {
this.poolSize = poolSize;
this.workers = [];
this.queue = [];
this.activeJobs = 0;
this.initializePool();
}
initializePool() {
for (let i = 0; i < this.poolSize; i++) {
this.createWorker();
}
}
createWorker() {
const worker = new Worker(__filename, {
workerData: { isWorker: true }
});
worker.on('message', (result) => {
this.activeJobs--;
this.processQueue();
if (result.error) {
console.error('워커 에러:', result.error);
} else {
console.log('파일 처리 완료:', result.filePath);
}
});
worker.on('error', (error) => {
console.error('워커 에러:', error);
this.replaceWorker(worker);
});
this.workers.push(worker);
}
processFile(filePath, options) {
return new Promise((resolve, reject) => {
const job = { filePath, options, resolve, reject };
this.queue.push(job);
this.processQueue();
});
}
processQueue() {
if (this.queue.length === 0 || this.activeJobs >= this.poolSize) {
return;
}
const job = this.queue.shift();
const worker = this.workers[this.activeJobs % this.poolSize];
this.activeJobs++;
worker.postMessage({
filePath: job.filePath,
options: job.options
});
}
}
if (!isMainThread && workerData?.isWorker) {
parentPort.on('message', async ({ filePath, options }) => {
try {
const result = await processFileInWorker(filePath, options);
parentPort.postMessage({ success: true, result });
} catch (error) {
parentPort.postMessage({ error: error.message });
}
});
}
async function processFileInWorker(filePath, options) {
const sharp = require('sharp');
if (options.type === 'image') {
await sharp(filePath)
.resize(options.width, options.height)
.jpeg({ quality: options.quality || 80 })
.toFile(filePath.replace('.jpg', '_optimized.jpg'));
}
return { filePath: filePath.replace('.jpg', '_optimized.jpg') };
}
AWS S3 연동과 멀티파트 업로드
S3 멀티파트 업로드 설정
Node.js S3 업로드 최적화를 위한 AWS SDK v3 활용:
const {
S3Client,
CreateMultipartUploadCommand,
UploadPartCommand,
CompleteMultipartUploadCommand,
AbortMultipartUploadCommand
} = require('@aws-sdk/client-s3');
class S3MultipartUploader {
constructor(config) {
this.s3Client = new S3Client({
region: config.region,
credentials: {
accessKeyId: config.accessKeyId,
secretAccessKey: config.secretAccessKey
}
});
this.bucket = config.bucket;
}
async uploadLargeFile(filePath, key, options = {}) {
const fileStats = await fs.promises.stat(filePath);
const fileSize = fileStats.size;
const partSize = options.partSize || 100 * 1024 * 1024;
const maxConcurrency = options.maxConcurrency || 3;
console.log(`S3 멀티파트 업로드 시작: ${key}, 크기: ${fileSize} bytes`);
try {
const createParams = {
Bucket: this.bucket,
Key: key,
ContentType: options.contentType || 'application/octet-stream'
};
const createResult = await this.s3Client.send(
new CreateMultipartUploadCommand(createParams)
);
const uploadId = createResult.UploadId;
const uploadPromises = [];
const totalParts = Math.ceil(fileSize / partSize);
for (let partNumber = 1; partNumber <= totalParts; partNumber++) {
const start = (partNumber - 1) * partSize;
const end = Math.min(start + partSize - 1, fileSize - 1);
const uploadPromise = this.uploadPart(
filePath, uploadId, key, partNumber, start, end
);
uploadPromises.push(uploadPromise);
if (uploadPromises.length >= maxConcurrency) {
const results = await Promise.all(uploadPromises);
uploadPromises.length = 0;
}
}
if (uploadPromises.length > 0) {
await Promise.all(uploadPromises);
}
const completeParams = {
Bucket: this.bucket,
Key: key,
UploadId: uploadId,
MultipartUpload: {
Parts: this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber)
}
};
const completeResult = await this.s3Client.send(
new CompleteMultipartUploadCommand(completeParams)
);
console.log('S3 업로드 완료:', completeResult.Location);
return completeResult;
} catch (error) {
console.error('S3 업로드 실패:', error);
if (uploadId) {
await this.s3Client.send(
new AbortMultipartUploadCommand({
Bucket: this.bucket,
Key: key,
UploadId: uploadId
})
);
}
throw error;
}
}
async uploadPart(filePath, uploadId, key, partNumber, start, end) {
const partSize = end - start + 1;
const buffer = Buffer.allocUnsafe(partSize);
const fileHandle = await fs.promises.open(filePath, 'r');
const { bytesRead } = await fileHandle.read(buffer, 0, partSize, start);
await fileHandle.close();
const uploadParams = {
Bucket: this.bucket,
Key: key,
PartNumber: partNumber,
UploadId: uploadId,
Body: buffer.slice(0, bytesRead)
};
const result = await this.s3Client.send(
new UploadPartCommand(uploadParams)
);
if (!this.uploadedParts) {
this.uploadedParts = [];
}
this.uploadedParts.push({
ETag: result.ETag,
PartNumber: partNumber
});
console.log(`파트 ${partNumber} 업로드 완료 (${bytesRead} bytes)`);
return result;
}
}
전송 가속화 설정
Node.js 클라우드 업로드 성능 향상을 위한 S3 Transfer Acceleration:
const acceleratedUploader = new S3MultipartUploader({
region: 'us-east-1',
accessKeyId: process.env.AWS_ACCESS_KEY_ID,
secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
bucket: 'your-bucket-name',
useAcceleration: true
});
function setupCloudFrontIntegration() {
const cloudFrontUrl = 'https://your-distribution.cloudfront.net';
return {
getOptimizedUrl: (key) => {
return `${cloudFrontUrl}/${key}`;
},
generatePresignedUrl: async (key, expiresIn = 3600) => {
const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
const { GetObjectCommand } = require('@aws-sdk/client-s3');
const command = new GetObjectCommand({
Bucket: 'your-bucket-name',
Key: key
});
return await getSignedUrl(this.s3Client, command, {
expiresIn
});
}
};
}
파일 청크 업로드 구현
클라이언트 측 청크 업로드
파일 청크 업로드를 위한 프론트엔드 구현:
class ChunkUploader {
constructor(options = {}) {
this.chunkSize = options.chunkSize || 5 * 1024 * 1024;
this.maxRetries = options.maxRetries || 3;
this.concurrency = options.concurrency || 3;
}
async uploadFile(file, uploadUrl, progressCallback) {
const totalChunks = Math.ceil(file.size / this.chunkSize);
const uploadId = this.generateUploadId();
console.log(`청크 업로드 시작: ${file.name}, 총 ${totalChunks}개 청크`);
try {
await this.initializeUpload(uploadUrl, {
uploadId,
filename: file.name,
fileSize: file.size,
totalChunks
});
const uploadPromises = [];
for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
const promise = this.uploadChunk(
file, chunkIndex, uploadUrl, uploadId, progressCallback
);
uploadPromises.push(promise);
if (uploadPromises.length >= this.concurrency) {
await Promise.all(uploadPromises);
uploadPromises.length = 0;
}
}
if (uploadPromises.length > 0) {
await Promise.all(uploadPromises);
}
const result = await this.finalizeUpload(uploadUrl, uploadId);
console.log('청크 업로드 완료:', result);
return result;
} catch (error) {
console.error('청크 업로드 실패:', error);
await this.abortUpload(uploadUrl, uploadId);
throw error;
}
}
async uploadChunk(file, chunkIndex, uploadUrl, uploadId, progressCallback) {
const start = chunkIndex * this.chunkSize;
const end = Math.min(start + this.chunkSize, file.size);
const chunk = file.slice(start, end);
const formData = new FormData();
formData.append('chunk', chunk);
formData.append('chunkIndex', chunkIndex);
formData.append('uploadId', uploadId);
let retries = 0;
while (retries < this.maxRetries) {
try {
const response = await fetch(`${uploadUrl}/chunk`, {
method: 'POST',
body: formData
});
if (!response.ok) {
throw new Error(`청크 업로드 실패: ${response.statusText}`);
}
const result = await response.json();
if (progressCallback) {
const progress = {
chunkIndex,
uploadedBytes: end,
totalBytes: file.size,
percentage: (end / file.size) * 100
};
progressCallback(progress);
}
return result;
} catch (error) {
retries++;
console.warn(`청크 ${chunkIndex} 업로드 재시도 (${retries}/${this.maxRetries}):`, error.message);
if (retries >= this.maxRetries) {
throw error;
}
await this.delay(Math.pow(2, retries) * 1000);
}
}
}
generateUploadId() {
return Date.now().toString(36) + Math.random().toString(36).substr(2);
}
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
서버 측 청크 처리
Node.js 파일 전송 최적화를 위한 서버 측 청크 병합:
class ChunkManager {
constructor() {
this.uploads = new Map();
this.tempDir = './temp_chunks';
if (!fs.existsSync(this.tempDir)) {
fs.mkdirSync(this.tempDir, { recursive: true });
}
}
initializeUpload(uploadId, metadata) {
this.uploads.set(uploadId, {
...metadata,
receivedChunks: new Set(),
startTime: Date.now(),
chunkPaths: []
});
console.log(`업로드 초기화: ${uploadId}, 파일: ${metadata.filename}`);
}
async receiveChunk(uploadId, chunkIndex, chunkBuffer) {
const upload = this.uploads.get(uploadId);
if (!upload) {
throw new Error('유효하지 않은 업로드 ID');
}
const chunkPath = path.join(
this.tempDir,
`${uploadId}_chunk_${chunkIndex}`
);
await fs.promises.writeFile(chunkPath, chunkBuffer);
upload.receivedChunks.add(chunkIndex);
upload.chunkPaths[chunkIndex] = chunkPath;
console.log(`청크 수신: ${uploadId}, 인덱스: ${chunkIndex}`);
if (upload.receivedChunks.size === upload.totalChunks) {
return await this.assembleFile(uploadId);
}
return {
status: 'chunk_received',
progress: (upload.receivedChunks.size / upload.totalChunks) * 100
};
}
async assembleFile(uploadId) {
const upload = this.uploads.get(uploadId);
if (!upload) {
throw new Error('유효하지 않은 업로드 ID');
}
const finalPath = path.join('./uploads', upload.filename);
const writeStream = fs.createWriteStream(finalPath);
try {
for (let i = 0; i < upload.totalChunks; i++) {
const chunkPath = upload.chunkPaths[i];
if (!chunkPath) {
throw new Error(`청크 ${i}가 누락되었습니다`);
}
const chunkData = await fs.promises.readFile(chunkPath);
writeStream.write(chunkData);
await fs.promises.unlink(chunkPath);
}
writeStream.end();
this.uploads.delete(uploadId);
const uploadTime = Date.now() - upload.startTime;
const avgSpeed = (upload.fileSize / uploadTime) * 1000;
console.log(`파일 조립 완료: ${upload.filename}, 속도: ${avgSpeed} bytes/sec`);
return {
status: 'completed',
filename: upload.filename,
path: finalPath,
size: upload.fileSize,
uploadTime,
avgSpeed
};
} catch (error) {
writeStream.destroy();
for (let i = 0; i < upload.totalChunks; i++) {
const chunkPath = upload.chunkPaths[i];
if (chunkPath && fs.existsSync(chunkPath)) {
await fs.promises.unlink(chunkPath);
}
}
throw error;
}
}
abortUpload(uploadId) {
const upload = this.uploads.get(uploadId);
if (!upload) return;
upload.chunkPaths.forEach(async (chunkPath) => {
if (chunkPath && fs.existsSync(chunkPath)) {
await fs.promises.unlink(chunkPath);
}
});
this.uploads.delete(uploadId);
console.log(`업로드 중단: ${uploadId}`);
}
cleanupStaleUploads(maxAge = 24 * 60 * 60 * 1000) {
const now = Date.now();
for (const [uploadId, upload] of this.uploads) {
if (now - upload.startTime > maxAge) {
this.abortUpload(uploadId);
}
}
}
}
const chunkManager = new ChunkManager();
app.post('/upload/init', (req, res) => {
const { filename, fileSize, totalChunks } = req.body;
const uploadId = Date.now().toString(36) + Math.random().toString(36).substr(2);
chunkManager.initializeUpload(uploadId, {
filename,
fileSize,
totalChunks
});
res.json({ uploadId, status: 'initialized' });
});
app.post('/upload/chunk', upload.single('chunk'), async (req, res) => {
try {
const { uploadId, chunkIndex } = req.body;
const chunkBuffer = req.file.buffer;
const result = await chunkManager.receiveChunk(
uploadId,
parseInt(chunkIndex),
chunkBuffer
);
res.json(result);
} catch (error) {
console.error('청크 업로드 에러:', error);
res.status(400).json({ error: error.message });
}
});
app.post('/upload/abort', (req, res) => {
const { uploadId } = req.body;
chunkManager.abortUpload(uploadId);
res.json({ status: 'aborted' });
});
setInterval(() => {
chunkManager.cleanupStaleUploads();
}, 60 * 60 * 1000);
보안과 검증 최적화
파일 검증 강화
파일 검증 시스템으로 보안성 향상:
const crypto = require('crypto');
const fileType = require('file-type');
class FileValidator {
constructor() {
this.allowedTypes = {
image: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
video: ['video/mp4', 'video/avi', 'video/mov'],
document: ['application/pdf', 'application/msword']
};
this.maxFileSizes = {
image: 10 * 1024 * 1024,
video: 500 * 1024 * 1024,
document: 50 * 1024 * 1024
};
}
async validateFile(filePath, expectedType) {
const stats = await fs.promises.stat(filePath);
const fileBuffer = await fs.promises.readFile(filePath);
const detectedType = await fileType.fromBuffer(fileBuffer);
if (!detectedType) {
throw new Error('알 수 없는 파일 형식입니다.');
}
const allowedMimes = this.allowedTypes[expectedType];
if (!allowedMimes || !allowedMimes.includes(detectedType.mime)) {
throw new Error(`허용되지 않는 파일 형식: ${detectedType.mime}`);
}
const maxSize = this.maxFileSizes[expectedType];
if (stats.size > maxSize) {
throw new Error(`파일 크기가 제한을 초과했습니다: ${stats.size} > ${maxSize}`);
}
const checksum = await this.calculateChecksum(fileBuffer);
await this.scanForMalware(fileBuffer);
return {
isValid: true,
fileType: detectedType,
size: stats.size,
checksum
};
}
async calculateChecksum(buffer) {
return crypto.createHash('sha256').update(buffer).digest('hex');
}
async scanForMalware(buffer) {
const maliciousPatterns = [
/eval\s*\(/gi,
/<script.*?>.*?<\/script>/gi,
/javascript:/gi,
/\.exe$/gi,
/\.bat$/gi,
/\.scr$/gi
];
const content = buffer.toString('utf8').substring(0, 10000);
for (const pattern of maliciousPatterns) {
if (pattern.test(content)) {
throw new Error('의심스러운 파일 내용이 감지되었습니다.');
}
}
return true;
}
sanitizeFilename(filename) {
const sanitized = filename
.replace(/[^a-zA-Z0-9._-]/g, '_')
.replace(/\.+/g, '.')
.replace(/^\.+|\.+$/g, '');
const maxLength = 100;
if (sanitized.length > maxLength) {
const ext = path.extname(sanitized);
const base = path.basename(sanitized, ext);
return base.substring(0, maxLength - ext.length) + ext;
}
return sanitized;
}
}
const validator = new FileValidator();
업로드 제한 설정
업로드 제한 설정으로 서버 보호:
const rateLimit = require('express-rate-limit');
const slowDown = require('express-slow-down');
const uploadLimiter = rateLimit({
windowMs: 15 * 60 * 1000,
max: 10,
message: {
error: '업로드 한도를 초과했습니다. 15분 후 다시 시도해주세요.'
},
standardHeaders: true,
legacyHeaders: false,
});
const uploadSlowDown = slowDown({
windowMs: 15 * 60 * 1000,
delayAfter: 5,
delayMs: 2000,
maxDelayMs: 10000,
});
class ConcurrencyLimiter {
constructor(maxConcurrent = 3) {
this.maxConcurrent = maxConcurrent;
this.activeUploads = new Map();
}
middleware() {
return (req, res, next) => {
const clientIP = req.ip;
const current = this.activeUploads.get(clientIP) || 0;
if (current >= this.maxConcurrent) {
return res.status(429).json({
error: `동시 업로드 한도 초과 (${this.maxConcurrent}개)`
});
}
this.activeUploads.set(clientIP, current + 1);
res.on('finish', () => {
const newCount = this.activeUploads.get(clientIP) - 1;
if (newCount <= 0) {
this.activeUploads.delete(clientIP);
} else {
this.activeUploads.set(clientIP, newCount);
}
});
next();
};
}
}
const concurrencyLimiter = new ConcurrencyLimiter(3);
app.use('/upload', uploadLimiter);
app.use('/upload', uploadSlowDown);
app.use('/upload', concurrencyLimiter.middleware());
실전 성능 벤치마크
벤치마크 테스트 구현
Node.js 업로드 성능 측정을 위한 벤치마크:
class UploadBenchmark {
constructor() {
this.results = [];
}
async runBenchmark(testConfigs) {
console.log('업로드 성능 벤치마크 시작...\n');
for (const config of testConfigs) {
console.log(`테스트: ${config.name}`);
console.log(`파일 크기: ${config.fileSize}MB, 방법: ${config.method}`);
const result = await this.measureUpload(config);
this.results.push(result);
console.log(`완료 시간: ${result.duration}ms`);
console.log(`평균 속도: ${result.avgSpeed}MB/s`);
console.log(`메모리 사용량: ${result.peakMemory}MB\n`);
await this.delay(2000);
}
this.generateReport();
}
async measureUpload(config) {
const startTime = Date.now();
const startMemory = process.memoryUsage().heapUsed;
let peakMemory = startMemory;
const memoryInterval = setInterval(() => {
const currentMemory = process.memoryUsage().heapUsed;
peakMemory = Math.max(peakMemory, currentMemory);
}, 100);
try {
const testFile = await this.createTestFile(config.fileSize);
let result;
switch (config.method) {
case 'traditional':
result = await this.traditionalUpload(testFile);
break;
case 'streaming':
result = await this.streamingUpload(testFile);
break;
case 'chunked':
result = await this.chunkedUpload(testFile);
break;
case 's3-multipart':
result = await this.s3MultipartUpload(testFile);
break;
default:
throw new Error(`알 수 없는 업로드 방법: ${config.method}`);
}
const duration = Date.now() - startTime;
const avgSpeed = (config.fileSize / (duration / 1000)).toFixed(2);
await fs.promises.unlink(testFile);
return {
name: config.name,
method: config.method,
fileSize: config.fileSize,
duration,
avgSpeed,
peakMemory: Math.round((peakMemory - startMemory) / 1024 / 1024),
success: true
};
} catch (error) {
return {
name: config.name,
method: config.method,
fileSize: config.fileSize,
error: error.message,
success: false
};
} finally {
clearInterval(memoryInterval);
}
}
async createTestFile(sizeMB) {
const filePath = `./test_file_${sizeMB}MB_${Date.now()}.dat`;
const sizeBytes = sizeMB * 1024 * 1024;
const chunkSize = 1024 * 1024;
const writeStream = fs.createWriteStream(filePath);
for (let written = 0; written < sizeBytes; written += chunkSize) {
const remainingBytes = Math.min(chunkSize, sizeBytes - written);
const chunk = Buffer.alloc(remainingBytes, 0);
writeStream.write(chunk);
}
writeStream.end();
return new Promise((resolve, reject) => {
writeStream.on('finish', () => resolve(filePath));
writeStream.on('error', reject);
});
}
generateReport() {
console.log('\n=== 업로드 성능 벤치마크 결과 ===\n');
const successfulTests = this.results.filter(r => r.success);
if (successfulTests.length === 0) {
console.log('성공한 테스트가 없습니다.');
return;
}
console.table(successfulTests.map(r => ({
'테스트명': r.name,
'방법': r.method,
'파일크기(MB)': r.fileSize,
'소요시간(ms)': r.duration,
'평균속도(MB/s)': r.avgSpeed,
'메모리사용(MB)': r.peakMemory
})));
const bestBySpeed = successfulTests.reduce((best, current) =>
parseFloat(current.avgSpeed) > parseFloat(best.avgSpeed) ? current : best
);
const bestByMemory = successfulTests.reduce((best, current) =>
current.peakMemory < best.peakMemory ? current : best
);
console.log('\n=== 성능 분석 ===');
console.log(`가장 빠른 방법: ${bestBySpeed.method} (${bestBySpeed.avgSpeed}MB/s)`);
console.log(`메모리 효율적인 방법: ${bestByMemory.method} (${bestByMemory.peakMemory}MB)`);
console.log('\n=== 권장사항 ===');
if (bestBySpeed.method === bestByMemory.method) {
console.log(`✅ ${bestBySpeed.method} 방법이 속도와 메모리 효율성 모두 우수합니다.`);
} else {
console.log(`⚖️ 속도 우선: ${bestBySpeed.method}`);
console.log(`⚖️ 메모리 효율 우선: ${bestByMemory.method}`);
}
}
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
async function runPerformanceTest() {
const benchmark = new UploadBenchmark();
const testConfigs = [
{ name: '소용량 전통적 방식', method: 'traditional', fileSize: 10 },
{ name: '소용량 스트리밍', method: 'streaming', fileSize: 10 },
{ name: '중용량 전통적 방식', method: 'traditional', fileSize: 100 },
{ name: '중용량 스트리밍', method: 'streaming', fileSize: 100 },
{ name: '중용량 청크 업로드', method: 'chunked', fileSize: 100 },
{ name: '대용량 스트리밍', method: 'streaming', fileSize: 500 },
{ name: '대용량 청크 업로드', method: 'chunked', fileSize: 500 },
{ name: '대용량 S3 멀티파트', method: 's3-multipart', fileSize: 500 }
];
await benchmark.runBenchmark(testConfigs);
}
if (require.main === module) {
runPerformanceTest().catch(console.error);
}
성능 최적화 가이드라인
| 파일 크기 | 권장 방법 | 예상 성능 향상 | 메모리 절약 |
|---|
| < 10MB | 전통적 multer | 기준 | 기준 |
| 10-100MB | 스트리밍 업로드 | 2-3배 빠름 | 80% 절약 |
| 100MB-1GB | 청크 업로드 | 3-5배 빠름 | 90% 절약 |
| > 1GB | S3 멀티파트 | 5-10배 빠름 | 95% 절약 |
이미지 압축과 최적화
실시간 이미지 최적화
Node.js 이미지 업로드 최적화를 위한 Sharp 활용:
const sharp = require('sharp');
class ImageOptimizer {
constructor() {
this.presets = {
thumbnail: { width: 150, height: 150, quality: 80 },
medium: { width: 800, height: 600, quality: 85 },
large: { width: 1920, height: 1080, quality: 90 },
webp: { quality: 80, format: 'webp' }
};
}
async optimizeImage(inputPath, options = {}) {
const { preset = 'medium', outputPath, formats = ['jpeg', 'webp'] } = options;
const config = this.presets[preset];
const results = [];
for (const format of formats) {
const outputFile = outputPath || this.generateOutputPath(inputPath, preset, format);
try {
let pipeline = sharp(inputPath);
if (config.width || config.height) {
pipeline = pipeline.resize(config.width, config.height, {
fit: 'inside',
withoutEnlargement: true
});
}
switch (format) {
case 'jpeg':
pipeline = pipeline.jpeg({
quality: config.quality || 85,
progressive: true
});
break;
case 'webp':
pipeline = pipeline.webp({
quality: config.quality || 80,
effort: 6
});
break;
case 'png':
pipeline = pipeline.png({
compressionLevel: 9,
progressive: true
});
break;
}
const info = await pipeline.toFile(outputFile);
results.push({
format,
path: outputFile,
size: info.size,
width: info.width,
height: info.height
});
} catch (error) {
console.error(`이미지 최적화 실패 (${format}):`, error);
}
}
return results;
}
generateOutputPath(inputPath, preset, format) {
const dir = path.dirname(inputPath);
const name = path.basename(inputPath, path.extname(inputPath));
return path.join(dir, `${name}_${preset}.${format}`);
}
async generateResponsiveImages(inputPath, outputDir) {
const breakpoints = [
{ name: 'mobile', width: 375 },
{ name: 'tablet', width: 768 },
{ name: 'desktop', width: 1200 },
{ name: 'large', width: 1920 }
];
const results = [];
for (const breakpoint of breakpoints) {
const outputPath = path.join(
outputDir,
`${path.basename(inputPath, path.extname(inputPath))}_${breakpoint.name}.webp`
);
const info = await sharp(inputPath)
.resize(breakpoint.width, null, {
fit: 'inside',
withoutEnlargement: true
})
.webp({ quality: 80, effort: 6 })
.toFile(outputPath);
results.push({
breakpoint: breakpoint.name,
width: breakpoint.width,
path: outputPath,
actualWidth: info.width,
actualHeight: info.height,
size: info.size
});
}
return results;
}
}
const imageOptimizer = new ImageOptimizer();
app.post('/upload/image', upload.single('image'), async (req, res) => {
try {
const { file } = req;
if (!file) {
return res.status(400).json({ error: '파일이 없습니다.' });
}
const validation = await validator.validateFile(file.path, 'image');
const optimizedImages = await imageOptimizer.optimizeImage(file.path, {
preset: 'medium',
formats: ['jpeg', 'webp']
});
const responsiveImages = await imageOptimizer.generateResponsiveImages(
file.path,
'./uploads/responsive'
);
res.json({
message: '이미지 업로드 및 최적화 완료',
original: {
filename: file.filename,
size: file.size,
path: file.path
},
optimized: optimizedImages,
responsive: responsiveImages,
validation
});
} catch (error) {
console.error('이미지 업로드 에러:', error);
res.status(500).json({ error: error.message });
}
});
모니터링 및 로깅
업로드 성능 모니터링
class UploadMonitor {
constructor() {
this.metrics = {
totalUploads: 0,
successfulUploads: 0,
failedUploads: 0,
totalBytes: 0,
avgUploadTime: 0,
peakMemoryUsage: 0
};
this.recentUploads = [];
this.maxRecentUploads = 100;
}
recordUpload(uploadData) {
this.metrics.totalUploads++;
if (uploadData.success) {
this.metrics.successfulUploads++;
this.metrics.totalBytes += uploadData.fileSize;
const totalTime = this.metrics.avgUploadTime * (this.metrics.successfulUploads - 1) + uploadData.duration;
this.metrics.avgUploadTime = totalTime / this.metrics.successfulUploads;
} else {
this.metrics.failedUploads++;
}
this.recentUploads.push({
...uploadData,
timestamp: new Date()
});
if (this.recentUploads.length > this.maxRecentUploads) {
this.recentUploads.shift();
}
const currentMemory = process.memoryUsage().heapUsed;
this.metrics.peakMemoryUsage = Math.max(this.metrics.peakMemoryUsage, currentMemory);
}
getMetrics() {
const successRate = (this.metrics.successfulUploads / this.metrics.totalUploads) * 100;
const avgFileSize = this.metrics.totalBytes / this.metrics.successfulUploads;
return {
...this.metrics,
successRate: successRate.toFixed(2),
avgFileSize: Math.round(avgFileSize),
peakMemoryUsageMB: Math.round(this.metrics.peakMemoryUsage / 1024 / 1024)
};
}
generateReport() {
const metrics = this.getMetrics();
console.log('\n=== 업로드 성능 리포트 ===');
console.log(`총 업로드 수: ${metrics.totalUploads}`);
console.log(`성공률: ${metrics.successRate}%`);
console.log(`평균 업로드 시간: ${metrics.avgUploadTime.toFixed(2)}ms`);
console.log(`평균 파일 크기: ${(metrics.avgFileSize / 1024 / 1024).toFixed(2)}MB`);
console.log(`최대 메모리 사용량: ${metrics.peakMemoryUsageMB}MB`);
const recentFailures = this.recentUploads.filter(u => !u.success);
if (recentFailures.length > 0) {
console.log('\n=== 최근 실패 원인 ===');
const failureReasons = {};
recentFailures.forEach(f => {
failureReasons[f.error] = (failureReasons[f.error] || 0) + 1;
});
Object.entries(failureReasons).forEach(([reason, count]) => {
console.log(`${reason}: ${count}회`);
});
}
}
}
const uploadMonitor = new UploadMonitor();
function addMonitoring(req, res, next) {
const startTime = Date.now();
const startMemory = process.memoryUsage().heapUsed;
res.on('finish', () => {
const duration = Date.now() - startTime;
const success = res.statusCode < 400;
uploadMonitor.recordUpload({
method: req.method,
url: req.url,
fileSize: req.file?.size || 0,
duration,
success,
error: success ? null : 'HTTP Error ' + res.statusCode,
memoryUsed: process.memoryUsage().heapUsed - startMemory
});
});
next();
}
app.use('/upload', addMonitoring);
setInterval(() => {
uploadMonitor.generateReport();
}, 5 * 60 * 1000);
결론 및 최적화 체크리스트
핵심 최적화 포인트
메모리 효율성
- 스트리밍 업로드로 메모리 사용량 90% 절약
- 청크 업로드로 대용량 파일 안정적 처리
- 버퍼 풀링으로 GC 압박 최소화
네트워크 최적화
- 멀티파트 업로드로 전송 속도 5-10배 향상
- Transfer Acceleration으로 글로벌 성능 개선
- 압축 및 최적화로 대역폭 절약
보안 강화
- 다층 파일 검증으로 악성 파일 차단
- Rate limiting으로 서버 보호
- 안전한 파일명 처리
최적화 체크리스트
최종 권장사항:
소규모 프로젝트에서는 기본 multer + 이미지 최적화로 시작하고, 트래픽이 증가하면 단계적으로 스트리밍 → 청크 업로드 → S3 멀티파트 순으로 도입하세요.
대용량 파일을 다루는 서비스라면 처음부터 스트리밍과 청크 업로드를 함께 구현하는 것을 강력히 권장합니다.
추가 리소스
참고 문서
관련 NPM 패키지
npm install express multer sharp busboy
npm install @aws-sdk/client-s3 @aws-sdk/lib-storage
npm install file-type express-rate-limit helmet
npm install express-slow-down compression
이 가이드를 통해 Node.js Express 파일 업로드 최적화의 모든 측면을 다뤄보았습니다.
각 기술은 프로젝트 규모와 요구사항에 맞게 선택적으로 적용하시기 바랍니다.
성능 향상과 안정성을 동시에 확보하여 사용자 경험을 극대화하세요!
댓글
댓글 쓰기