DialogFlow集成AWS EC2上MongoDB遇端口占用问题求助

你遇到的核心问题是每次请求都创建固定端口的SSH隧道，导致重复请求时端口被占用，再加上原代码嵌套过多、异步处理不规范，进一步放大了问题。下面是具体的解决思路和修改后的代码：

问题根源分析 #

1. 硬指定localPort:24800，第一次请求后端口被占用，后续请求直接抛出EADDRINUSE错误；
2. 代码把agent.handleRequest嵌套在MongoDB连接回调里，异步操作（比如find().toArray）的时序混乱，容易导致逻辑执行失败；
3. Firebase Functions是无状态服务，同一实例重复请求时，固定端口必然冲突。

解决方案步骤 #

1. 移除固定本地端口，让系统自动分配 #

删掉config里的localPort配置，tunnel-ssh会自动选择可用的本地端口，从根源避免端口冲突。

2. 重构代码结构，用async/await规范异步逻辑 #

将回调式的隧道创建、MongoDB操作转为Promise+async/await，确保逻辑顺序执行，同时在请求结束后主动关闭资源。

3. 修正MongoDB更新逻辑 #

原代码中find().toArray是异步操作，直接用doc = docs后执行update会导致doc为空，改用updateOne直接根据条件更新，避免时序问题。

修改后的完整代码 #

var tunnel = require('tunnel-ssh');
var mongoLib = require('mongodb');
const functions = require('firebase-functions');
const {WebhookClient} = require('dialogflow-fulfillment');

process.env.DEBUG = 'dialogflow:debug';

exports.dialogflowFirebaseFulfillment = functions.https.onRequest(async (request, response) => {
  const agent = new WebhookClient({request, response});
  console.log('Dialogflow Request headers: ' + JSON.stringify(request.headers));
  console.log('Dialogflow Request body: ' + JSON.stringify(request.body));

  let sshTunnel = null;
  let mongoClient = null;

  try {
    // 1. 创建SSH隧道，不指定localPort，自动分配可用端口
    const config = {
      username: 'ubuntu',
      host: '<my-host-ip-address>',
      port: 22,
      privateKey: '<my-aws-instance-private-key>',
      dstHost: '127.0.0.1',
      dstPort: 27017
    };

    // 用Promise封装隧道创建，适配async/await
    sshTunnel = await new Promise((resolve, reject) => {
      tunnel(config, (error, server) => {
        if (error) reject(error);
        resolve(server);
      });
    });

    // 2. 获取隧道实际使用的本地端口，连接MongoDB
    const localPort = sshTunnel.address().port;
    mongoClient = await mongoLib.MongoClient.connect(
      `mongodb://127.0.0.1:${localPort}/`,
      {useUnifiedTopology: true}
    );
    const db = mongoClient.db('test_db');

    // 3. 定义Intent处理函数，用async/await确保操作完成
    async function welcome(agent) {
      agent.add(`Welcome to my agent!`);
    }

    async function fallback(agent) {
      agent.add(`I didn't understand`);
      agent.add(`I'm sorry, can you try again?`);
    }

    async function handleOn(agent) {
      const state = agent.parameters.on;
      if (state == 1) {
        // 替换为你的文档查询条件，比如固定_id
        await db.collection('light').updateOne(
          {_id: '<你的文档ID>'},
          {$set: {lightState: 1}},
          {upsert: true} // 文档不存在则自动创建
        );
        agent.add('Light turned on successfully!');
      }
    }

    async function handleOff(agent) {
      const state = agent.parameters.off;
      if (state == 1) {
        await db.collection('light').updateOne(
          {_id: '<你的文档ID>'},
          {$set: {lightState: 0}},
          {upsert: true}
        );
        agent.add('Light turned off successfully!');
      }
    }

    // 4. 绑定Intent并处理请求
    let intentMap = new Map();
    intentMap.set('Default Welcome Intent', welcome);
    intentMap.set('Default Fallback Intent', fallback);
    intentMap.set('light_On', handleOn);
    intentMap.set('light_Off', handleOff);
    await agent.handleRequest(intentMap);

  } catch (error) {
    console.error('Error:', error);
    agent.add('Sorry, there was an error processing your request.');
  } finally {
    // 5. 无论请求成功失败，都关闭资源
    if (mongoClient) await mongoClient.close();
    if (sshTunnel) sshTunnel.close();
  }
});

关键优化点说明 #

• 自动分配端口：移除固定端口后，每次请求都会使用系统分配的空闲端口，彻底解决EADDRINUSE问题；
• 资源自动释放：在finally块中关闭MongoDB连接和SSH隧道，避免资源泄漏；
• 异步逻辑规范：用async/await替代嵌套回调，代码可读性和执行可靠性大幅提升；
• 更新逻辑修正：直接用updateOne根据条件更新，避免异步find导致的空值问题，upsert参数确保文档存在。

这样修改后，每次请求都会创建独立的SSH隧道，请求完成后立即释放资源，就不会再出现端口占用的问题了。

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