Docker容器无法接收主机转发的SNMP陷阱（Node.js、UDP）

我在主机上运行Node.js应用，通过UDP 162端口接收物理设备（如192.168.1.18）的SNMP陷阱，需转发至Docker容器模拟处理。使用dgram.send()转发时遇到两个核心问题：

• 转发至127.0.0.1或容器IP时，陷阱回环到主机监听器，无法到达容器；
• 容器获取到的源IP为主机IP，而非设备真实IP，导致设备匹配逻辑失效。

环境说明：Windows Docker Desktop搭配Linux容器，无法使用主机网络模式。

现有配置与代码 #

Docker Compose配置 #

services:
  comserver:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "162:162/udp"
    cap_add:
      - NET_BIND_SERVICE
    environment:
      - SNMP_PORT=162

容器内SNMP陷阱接收代码 #

if (isSNMP) {
  const dgram = require("dgram");
  const trapd = dgram.createSocket("udp4");

  const SNMP_PORT = 162;
  this.snmpDevices = {};
  
  for (let key in this.drivers) {
    console.log(`[ SNMP ] - Drivers`);
    const driver = this.drivers[key];
    if (driver instanceof MoxaIoLogik || driver instanceof AxisMotDet) {
      console.log(driver.IP);
      this.snmpDevices[driver.IP] = {
        id: driver.id,
        mapName: driver.mapName,
        type: driver instanceof MoxaIoLogik ? "ioLogik" : "axisMotDet",
      };
    }
  }
  console.log(`[ SNMP ] - SNMP devices: ${JSON.stringify(this.snmpDevices)}`);
  trapd.on("message", (msg, rinfo) => {
    console.log(`[ SNMP ] - Data received: ${JSON.stringify(rinfo)}`);
    console.log(`[ SNMP ] - Msg: ${msg}`);
    const srcIP = rinfo.address; 
    if (!this.snmpDevices[srcIP]) {
      console.log(`[ ${this.constructor.name} ][ SNMP ] - received trap from unknown device: ${srcIP}`);
      return;
    }

    const device = this.snmpDevices[srcIP];

    if (device.type === "ioLogik") {
      try {
        const buf = msg;    
        const typeByte = buf[buf.length - 5];
        const channel = buf[buf.length - 4] - 1;
        const value = buf[buf.length - 1];

        if (typeByte === 21) {
          console.log(`[ ${this.constructor.name} ][ SNMP ] - Change iologik ${srcIP} output, ${channel}, value, ${value}`);
          return;
        }

        console.log(`[ ${this.constructor.name} ][ SNMP ] - Change iologik ${srcIP} input, ${channel}, value, ${value}`);

        this.drivers[device.id].newSNMPTrap(channel, value);
      } catch (e) {
        console.log(`[ ${this.constructor.name} ][ SNMP ] - ${e}`);
      }
    } else if (device.type === "axisMotDet") {
      console.log(`[ ${this.constructor.name} ][ SNMP ] - Change modet CAM ${srcIP}`);
      this.drivers[device.id].newSNMPTrap(msg);
    }
  });

  trapd.on("error", (err) => {
    console.error(`[ ${this.constructor.name} ][ SNMP ] - Trap listener error: ${err.message}`);
    trapd.close();
    for (let dev in this.snmpDevices) {
      this.onIncidence("DEVICE", this.snmpDevices[dev].id, this.snmpDevices[dev].mapName, "software", true, "error initializing trap listening: " + err.message, false, this.lanes);
    }
  });

  trapd.bind(SNMP_PORT, () => {
    console.log(`[ ${this.constructor.name} ][ SNMP ] - Listening for traps on port ${SNMP_PORT}`);
  });
}

主机转发代码 #

private listen() {
  this.trapSocket.on("message", (msg, rinfo) => {
    const srcIP = rinfo.address;
    // 忽略回环的转发陷阱
    if (srcIP === "127.0.0.1") {
      console.warn(`[SNMP] Avoiding trap loop: ${srcIP}`);
      return;
    }

    const device = this.snmpDevices[srcIP];

    if (!device) {
      console.warn(`[SNMP] Unknown trap source IP: ${srcIP}`);
      return;
    }

    console.log(`[SNMP] Trap from ${srcIP}. Forwarding to container.`);

    // 拼接真实IP与原陷阱数据
    const ipBuffer = Buffer.from(srcIP);
    const separator = Buffer.from("|");
    const payload = Buffer.concat([ipBuffer, separator, msg]);

    // 转发至容器
    this.forwardSocket.send(payload, 162, "127.0.0.1", (err) => {
        if (err) {
          console.error(`[SNMP] Error forwarding trap: ${err.message}`);
        }
      }
    );
  });

  this.trapSocket.bind(this.listenPort, () => {
    console.log(`[SNMP] Listening for traps on port ${this.listenPort}`);
  });
}

解决方案 #

1. 解决陷阱回环问题 #

问题根源：主机UDP 162端口同时被主机Node应用和Docker端口映射占用，转发请求被本地监听器拦截，无法到达容器。

解决步骤：

• 修改Docker Compose端口映射，使用非冲突的主机端口（如10162）映射到容器162端口：

  services:
    comserver:
      # 其他配置不变
      ports:
        - "10162:162/udp"
  

• 更新主机转发代码的目标端口为10162：

  this.forwardSocket.send(payload, 10162, "127.0.0.1", (err) => {
      // 错误处理逻辑不变
  });
  

• 保持主机Node应用监听162端口，容器内部监听162端口，两者端口不再冲突，避免回环。

2. 保留设备真实源IP问题 #

问题根源：UDP转发时源IP会被替换为主机IP，容器无法直接获取设备真实地址。以下提供两种可行方案：

方案A：嵌入真实IP到Payload（兼容现有架构）

沿用你当前的IP嵌入思路，调整容器接收逻辑解析真实IP：

• 主机转发代码保持现有Payload拼接逻辑不变；
• 修改容器内接收代码，从Payload中提取真实设备IP：

  trapd.on("message", (msg, rinfo) => {
    // 解析真实设备IP
    const separatorIndex = msg.indexOf("|");
    if (separatorIndex === -1) {
      console.log(`[ SNMP ] - Invalid payload format`);
      return;
    }
    const srcIP = msg.slice(0, separatorIndex).toString();
    const originalMsg = msg.slice(separatorIndex + 1); // 获取原陷阱数据
    
    // 后续逻辑使用srcIP（真实设备IP）而非rinfo.address
    if (!this.snmpDevices[srcIP]) {
      console.log(`[ ${this.constructor.name} ][ SNMP ] - received trap from unknown device: ${srcIP}`);
      return;
    }
    
    // 处理陷阱数据时使用originalMsg
    if (device.type === "ioLogik") {
      try {
        const buf = originalMsg; // 替换为解析后的原数据
        // 后续处理逻辑不变
      } catch (e) {
        // 错误处理逻辑不变
      }
    }
    // 其他设备类型处理逻辑不变
  });
  

方案B：直接使用Docker端口映射转发（需关闭主机监听器）

若无需保留主机Node应用的转发逻辑，可直接让设备陷阱发送到主机局域网IP:162，由Docker端口映射转发到容器，此时容器能获取设备真实IP：

• 关闭主机上监听162端口的Node应用；
• 保持Docker Compose端口映射为"162:162/udp"；
• 配置设备将陷阱发送到主机的局域网IP（而非127.0.0.1）。

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