Great question! The core TCP In node in Node-RED doesn't support dynamic configuration of the listening port via incoming messages out of the box—this is by design, as most core nodes are built with static startup configurations to maintain runtime stability. But don't worry, there are a couple of reliable workarounds to achieve your goal:

方案1：通过Node-RED API动态创建/销毁TCP In节点 #

You can leverage Node-RED's internal API (via the RED object available in function nodes) to programmatically create and tear down TCP In nodes whenever you receive a port configuration message. Here's a step-by-step implementation:

1. Add a Function node to your flow, and use the following code (adjust parameters like host or datamode to match your needs):

// Retrieve existing nodes from global context to clean up
const oldTcpNode = context.global.get('dynamicTcpIn');
const oldTcpConfig = context.global.get('dynamicTcpConfig');

// Clean up old nodes if they exist
if (oldTcpNode) {
    oldTcpNode.close();
    RED.nodes.removeNode(oldTcpNode.id);
}
if (oldTcpConfig) {
    RED.nodes.removeNode(oldTcpConfig.id);
}

// Extract target port from incoming message (adjust path if your msg uses a different key)
const targetPort = msg.payload.port;
if (!targetPort || isNaN(Number(targetPort)) || targetPort < 1 || targetPort > 65535) {
    node.error('Invalid port number provided in msg.payload.port');
    return null;
}

// Create TCP listener configuration node
const tcpConfig = RED.nodes.createNode(`tcp-config-${Date.now()}`, {
    type: 'tcp in listener',
    port: targetPort,
    host: '0.0.0.0', // Listen on all interfaces; change to specific IP if needed
    datamode: 'stream', // Options: 'stream', 'delimited', 'length'
    newline: '\n', // Only relevant for delimited mode
    base64: false
});

// Create the TCP In node itself
const tcpInNode = RED.nodes.createNode(`tcp-in-${Date.now()}`, {
    type: 'tcp in',
    server: tcpConfig.id,
    name: `Dynamic TCP Listener: ${targetPort}`
});

// Forward messages from the dynamic TCP In node to downstream nodes
tcpInNode.on('input', (tcpMsg) => {
    node.send(tcpMsg);
});

// Store references to new nodes in global context for future cleanup
context.global.set('dynamicTcpIn', tcpInNode);
context.global.set('dynamicTcpConfig', tcpConfig);

// Initialize the new nodes
tcpConfig.init();
tcpInNode.init();

return msg;

2. Connect a Inject node (or your dashboard input node) to this Function node, sending a payload like {"port": 12345} to trigger the port change.

Important notes for this approach:

• Ensure your Function node has access to the RED object (this is enabled by default in most Node-RED setups).
• Handle port conflicts gracefully—you can add error handling to catch "address in use" errors when initializing the new node.
• This method modifies your flow at runtime; if you redeploy the flow manually, the dynamic nodes will be lost unless you persist the configuration.

方案2：使用社区贡献的动态TCP节点 #

Several community-developed nodes are built specifically to support dynamic TCP port configuration via messages. These nodes eliminate the need for custom code:

• Search the Node-RED palette for keywords like "dynamic tcp in" or "runtime configurable tcp".
• These nodes typically expose input properties to accept a port number from msg.payload or another msg property, and automatically reconfigure their listening port when a new message arrives.

This is the simplest option if you don't want to write custom function code, as the nodes handle all the underlying lifecycle management for you.

补充：场景适配的替代思路 #

If your use case allows for some flexibility, you could also:

• Use a single static TCP In node with a fixed port, then implement message routing logic downstream to handle different client connections based on content or metadata.
• Deploy multiple pre-configured TCP In nodes for common ports, then use a switch node to route traffic based on your dashboard input (though this doesn't scale well for arbitrary port changes).

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