Node.js后端子进程10分钟响应浏览器超时问题求助

你遇到的核心问题是浏览器本身以及中间网络节点（比如代理、CDN）对HTTP请求有默认的超时限制——哪怕你已经设置了axios的timeout和后端超时，这些外部限制依然会导致请求在2分钟左右被断开。下面给你分步骤拆解解决方案：

1. 先排查基础配置问题（快速验证） #

首先确认你的axios配置和后端链路没有隐性限制：

• 检查axios全局配置：如果之前设置过全局超时，会覆盖单个请求的设置，比如：

  // 若有这个全局配置，会覆盖你单个请求的timeout
  axios.defaults.timeout = 30000; 
  

  可以要么修改全局超时为1000*60*10（10分钟），要么在单个请求里明确确保配置生效。
• 检查中间网关超时：如果你的后端前面有Nginx、Apache这类反向代理，一定要修改它们的超时设置。比如Nginx的默认proxy_read_timeout是60秒，必须调整为10分钟以上：

  location / {
      proxy_read_timeout 600s;  # 10分钟
      proxy_connect_timeout 600s;
      proxy_send_timeout 600s;
  }
  

2. 更可靠的方案：异步处理+轮询/WebSocket #

长时间挂起的HTTP请求天生容易被各种网络节点断开，这是HTTP短连接优先的设计导致的。对于10分钟级别的长任务，更合理的做法是拆分流程，不用让请求一直挂着：

方案A：任务提交+轮询状态（实现简单） #

后端修改：接收任务后立即返回任务ID，后台执行任务

const { v4: uuidv4 } = require('uuid'); // 需要安装uuid包
const runningTasks = new Map(); // 临时存储任务状态（生产环境建议用数据库）

app.post('/execute', (req, res) => {
  const fileName = req.body.fileName;
  const taskId = uuidv4();
  
  // 启动子进程执行任务，不等待完成
  exec('sleep 200 && ls', (err, stdout, stderr) => {
    if (err) {
      runningTasks.set(taskId, { status: 'failed', error: err.message });
    } else {
      runningTasks.set(taskId, { status: 'success', result: stdout });
    }
    // 任务完成1小时后清理，避免内存泄漏
    setTimeout(() => runningTasks.delete(taskId), 3600000);
  });
  
  // 立即返回任务ID，让前端去轮询状态
  res.send({ taskId });
});

// 添加查询任务状态的接口
app.get('/task-status/:taskId', (req, res) => {
  const taskId = req.params.taskId;
  const task = runningTasks.get(taskId);
  
  if (!task) {
    return res.status(404).send({ message: '任务不存在或已过期' });
  }
  
  res.send(task);
});

前端修改：提交任务后定期轮询状态

export const executeFile = (fileName) => {
  return (dispatch) => {
    // 第一步：提交任务，获取任务ID
    axios.post(`/execute`, { fileName })
      .then(res => {
        const taskId = res.data.taskId;
        // 每30秒轮询一次任务状态
        const pollInterval = setInterval(() => {
          axios.get(`/task-status/${taskId}`)
            .then(statusRes => {
              const { status, result, error } = statusRes.data;
              if (status === 'success') {
                clearInterval(pollInterval);
                dispatch({ type: 'EXECUTE_FILE', payload: result });
              } else if (status === 'failed') {
                clearInterval(pollInterval);
                console.error('任务执行失败:', error);
              }
              // 任务仍在运行，继续轮询
            })
            .catch(err => {
              console.error('查询任务状态失败:', err);
              clearInterval(pollInterval);
            });
        }, 30000);
      })
      .catch(err => console.log(err));
  };
};

方案B：WebSocket实时推送（体验更优） #

如果觉得轮询不够高效，可以用WebSocket建立长连接，任务完成后后端主动推送结果给前端：

后端WebSocket示例（使用ws包）

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

// 存储客户端连接与ID的映射
const clientMap = new Map();

wss.on('connection', (ws, req) => {
  const clientId = req.url.split('clientId=')[1];
  clientMap.set(clientId, ws);
  
  ws.on('close', () => clientMap.delete(clientId));
});

app.post('/execute', (req, res) => {
  const fileName = req.body.fileName;
  const clientId = req.headers['client-id'];
  
  exec('sleep 200 && ls', (err, stdout, stderr) => {
    const ws = clientMap.get(clientId);
    if (ws && ws.readyState === WebSocket.OPEN) {
      if (err) {
        ws.send(JSON.stringify({ status: 'failed', error: err.message }));
      } else {
        ws.send(JSON.stringify({ status: 'success', result: stdout }));
      }
    }
  });
  
  res.send({ message: '任务已启动' });
});

前端WebSocket连接示例

import { v4 as uuidv4 } from 'uuid';

export const executeFile = (fileName) => {
  return (dispatch) => {
    const clientId = uuidv4();
    const ws = new WebSocket(`ws://localhost:8080?clientId=${clientId}`);
    
    ws.onopen = () => {
      // 提交任务，带上客户端ID
      axios.post(`/execute`, { fileName }, { headers: { 'client-id': clientId } })
        .catch(err => console.log(err));
    };
    
    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      if (data.status === 'success') {
        dispatch({ type: 'EXECUTE_FILE', payload: data.result });
      } else {
        console.error('任务失败:', data.error);
      }
      ws.close();
    };
    
    ws.onerror = (err) => {
      console.error('WebSocket连接出错:', err);
      ws.close();
    };
  };
};

总结 #

直接让浏览器等待10分钟的HTTP请求稳定性极差，任何中间网络节点都可能主动断开连接。最可靠的方式是把长任务改成异步处理，用轮询或WebSocket获取结果，这样既解决了超时问题，还能给用户展示任务进度，提升体验。

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