Node.js文件上传unlink失败如何处理？定时清理方案是否可行？

我正在学习Node.js后端开发，目前实现文件上传功能的流程是：用multer接收文件并存储到服务器磁盘，再将本地文件上传至Cloudinary，无论上传成功或失败都会尝试用fs/promises删除本地文件，但遇到unlink本地文件失败的问题。我编写了定时清理临时目录的代码，想咨询该方案是否可行，或是有其他更好的处理方式。

现有实现代码 #

Cloudinary上传模块 #

import { v2 as cloudinary } from "cloudinary";
import fs from "fs/promises";

cloudinary.config({
    cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
    api_key: process.env.CLOUDINARY_API_KEY,
    api_secret: process.env.CLOUDINARY_API_SECRET,
});

const uploadToCloudinary = async (localFilePath) => {
    const uploadResult = { status: "error", uploadedFileDetails: {} };

    if (!localFilePath || typeof localFilePath !== "string") {
        console.error("Invalid local file path provided");
        return uploadResult;
    }

    try {
        await fs.access(localFilePath, fs.constants.F_OK);
    } catch (accessError) {
        console.error(
            `Local file does not exist or inaccessible : ${accessError.name} \n${accessError.message}`
        );
        return uploadResult;
    }

    try {
        const cloudinaryUploadResponse = await cloudinary.uploader.upload(
            localFilePath,
            { resource_type: "auto" }
        );
        uploadResult.status = "success";
        uploadResult.uploadedFileDetails.publicId =
            cloudinaryUploadResponse.public_id;
        uploadResult.uploadedFileDetails.url =
            cloudinaryUploadResponse.secure_url;
    } catch (error) {
        console.error(
            `Error occurred while uploading the file to cloudinary : ${error}`
        );
    } finally {
        try {
            await fs.unlink(localFilePath);
        } catch (unlinkingError) {
            console.error(
                `Error occurred while unlinking the local file : ${unlinkingError.name} \n${unlinkingError.message}`
            );
        }
    }

    return uploadResult;
};

const deleteFromCloudinary = async (publicId, resourceType = "image") => {
    const deleteResult = { status: "error" };

    if (!publicId || typeof publicId !== "string") {
        console.error("Invalid public ID provided");
        return deleteResult;
    }

    try {
        const cloudinaryDeleteResponse = await cloudinary.uploader.destroy(
            publicId,
            { resource_type: resourceType }
        );
        if (cloudinaryDeleteResponse.result === "ok") {
            deleteResult.status = "success";
        } else {
            console.error("Cloudinary deletion failed");
        }
    } catch (error) {
        console.error(
            `Error occurred while deleting the file from cloudinary : ${error}`
        );
    }

    return deleteResult;
};

export { uploadToCloudinary, deleteFromCloudinary };

定时清理临时目录模块 #

import fs from "fs/promises";
import path from "path";

const cleanupTempFiles = async () => {
    try {
        const TEMP_DIR = "./public/temp";
        const files = await fs.readdir(TEMP_DIR);
        const now = Date.now();
        const twentyFourHours = 24 * 60 * 60 * 1000;

        for (const file of files) {
            const filePath = path.join(TEMP_DIR, file);
            const fileStat = await fs.stat(filePath);
            if (
                file !== ".gitkeep" &&
                now - fileStat.birthtimeMs >= twentyFourHours
            ) {
                await fs.unlink(filePath);
            }
        }
    } catch (error) {
        console.error(`Error occurred during cleanup: ${error}`);
    }
};

const scheduleCleanup = async () => {
    try {
        console.log("Clean up start");
        await cleanupTempFiles();
        console.log("Clean up end");
    } catch (error) {
        console.error(
            `Error occurred while periodic cleanup : ${error.name} \n${error.message}`
        );
    }
    finally {
        setTimeout(scheduleCleanup, 24 * 60 * 60 * 1000);
    }
};

export { scheduleCleanup };

定时清理方案的可行性分析 #

定时清理方案是完全可行的，它可以作为兜底机制解决unlink失败导致的临时文件堆积问题：

• 24小时的清理周期在大多数场景下合理，既不会因频繁执行消耗服务器资源，也能及时清理过期的无效文件，避免磁盘空间被占用。
• 但可以针对现有代码做几个细节优化：
  • 替换相对路径为绝对路径：用path.resolve(__dirname, 'public/temp')生成绝对路径，避免因进程启动目录不同导致找不到临时目录的问题。
  • 优化文件时间判断：birthtimeMs在部分文件系统中可能存在精度问题，可考虑使用ctimeMs（文件状态最后变更时间）作为替代，更准确反映文件的实际可用状态。
  • 增强错误处理：当前仅打印错误日志，建议将错误信息写入专门的日志文件，方便后续排查清理失败的原因。

其他优化方案 #

1. 给unlink增加重试机制 #

很多时候unlink失败是临时的（比如文件被其他进程短暂占用），加入有限次数的重试逻辑可以提升删除成功率：

// 修改uploadToCloudinary函数中的finally块
finally {
  const maxRetries = 3;
  let retryCount = 0;
  const tryUnlink = async () => {
    try {
      await fs.unlink(localFilePath);
    } catch (unlinkingError) {
      if (retryCount < maxRetries) {
        retryCount++;
        setTimeout(tryUnlink, 100 * retryCount); // 每次重试间隔递增
      } else {
        console.error(`Failed to unlink file after ${maxRetries} retries: ${unlinkingError.message}`);
      }
    }
  };
  await tryUnlink();
}

2. 跳过本地存储，直接上传至Cloudinary #

使用multer-storage-cloudinary中间件，直接将multer接收的文件上传到Cloudinary，完全跳过本地磁盘存储，从根源上避免本地文件删除的问题：

import { CloudinaryStorage } from 'multer-storage-cloudinary';
import multer from 'multer';
import { v2 as cloudinary } from 'cloudinary';

cloudinary.config({
  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
  api_key: process.env.CLOUDINARY_API_KEY,
  api_secret: process.env.CLOUDINARY_API_SECRET,
});

const storage = new CloudinaryStorage({
  cloudinary: cloudinary,
  params: {
    folder: 'uploads', // 自定义Cloudinary中的存储文件夹
    resource_type: 'auto', // 自动识别文件类型
  },
});

const upload = multer({ storage: storage });

// 在路由中使用示例：
// app.post('/upload', upload.single('file'), (req, res) => {
//   res.json({
//     url: req.file.path,
//     publicId: req.file.filename
//   });
// });

这种方式简化了流程，无需处理本地文件的存储和删除，也避免了磁盘空间占用的问题。

内容的提问来源于stack exchange，提问作者Bhomik Ranjan