如何通过NodeJS与后台Linux服务进程实现通信？

这是个很典型的进程间通信场景，结合你能完全控制两个进程的情况，我给你整理了几个靠谱的方案，按实现复杂度和适用场景分：

如果你的Linux进程原本就是通过标准输入读命令、标准输出返回响应的，那这个方案几乎不需要改进程代码，只需要调整它的启动方式：

1. 先创建两个命名管道（FIFO），用于进程和Node.js之间的双向通信：

   mkfifo /tmp/process_cmd_pipe /tmp/process_resp_pipe
   # 给两个进程都赋予读写权限
   chmod 666 /tmp/process_cmd_pipe /tmp/process_resp_pipe
   

2. 修改你的后台服务启动配置（比如systemd的.service文件），把进程的stdin/stdout重定向到这两个管道：

   # 示例systemd配置片段
   ExecStart=/path/to/your_linux_process < /tmp/process_cmd_pipe > /tmp/process_resp_pipe 2>&1
   

   如果是手动启动后台进程，直接用命令行重定向即可：

   /path/to/your_linux_process < /tmp/process_cmd_pipe > /tmp/process_resp_pipe 2>&1 &
   

3. Node.js侧通过文件流和管道交互：

   const fs = require('fs');
   const readline = require('readline');
   
   // 打开命令写入管道
   const cmdStream = fs.createWriteStream('/tmp/process_cmd_pipe');
   // 打开响应读取管道，用readline处理行输出（适配大多数命令行交互的换行分隔）
   const respReader = readline.createInterface({
     input: fs.createReadStream('/tmp/process_resp_pipe'),
     crlfDelay: Infinity
   });
   
   // 监听响应
   respReader.on('line', (line) => {
     console.log(`进程响应：${line}`);
     // 这里可以根据业务逻辑处理响应，比如匹配请求ID对应结果
   });
   
   // 发送命令的函数
   function sendCommand(cmd) {
     cmdStream.write(`${cmd}\n`); // 注意加换行，匹配进程原本的输入格式
   }
   
   // 示例：发送一个命令
   sendCommand('status');
   

如果需要更稳定的连接、避免FIFO可能出现的消息混杂问题，Unix域套接字是更好的选择——它是面向连接的IPC机制，和TCP套接字API几乎一致，但性能更高（不需要走网络协议栈）。

1. 修改你的Linux进程，添加UDS监听逻辑：
   以C语言为例（核心逻辑）：

   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   #include <unistd.h>
   #include <sys/socket.h>
   #include <sys/un.h>
   
   #define SOCKET_PATH "/tmp/process_uds"
   
   int main() {
     int sockfd, connfd;
     struct sockaddr_un addr;
     char buf[1024];
     ssize_t n;
   
     // 创建UDS套接字
     sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
     // 绑定路径
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path)-1);
     unlink(SOCKET_PATH); // 先删除旧的套接字文件
     bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
     // 监听连接
     listen(sockfd, 5);
   
     while(1) {
       // 接受Node.js的连接
       connfd = accept(sockfd, NULL, NULL);
       // 读取命令
       n = read(connfd, buf, sizeof(buf)-1);
       if(n > 0) {
         buf[n] = '\0';
         printf("收到命令：%s\n", buf);
         // 处理命令，生成响应
         char* resp = "命令执行成功";
         // 发送响应
         write(connfd, resp, strlen(resp));
       }
       close(connfd);
     }
     close(sockfd);
     unlink(SOCKET_PATH);
     return 0;
   }
   

2. Node.js侧通过net模块连接UDS：

   const net = require('net');
   
   const client = net.createConnection({ path: '/tmp/process_uds' });
   
   client.on('connect', () => {
     console.log('已连接到进程');
     // 发送命令
     client.write('get_config');
   });
   
   client.on('data', (data) => {
     console.log(`收到响应：${data.toString()}`);
     // 可以在这里关闭连接，或者保持连接发送多个命令
     // client.end();
   });
   
   client.on('error', (err) => {
     console.error('连接出错：', err);
   });
   

如果你不想折腾底层IPC细节，用Redis做消息中转是最省心的选择——两个进程通过Redis的列表发布/订阅来传递命令和响应，不需要改太多代码：

1. 确保你的Linux进程能调用Redis客户端（比如用hiredis库，或者直接通过system()调用redis-cli），Node.js侧安装redis包：

   npm install redis
   

2. Linux进程逻辑：
   循环从process_cmd_list列表取出命令，执行后把响应存入process_resp_list（最好给每个请求加ID，对应响应）：

   // 伪代码示例
   while(1) {
     // 从Redis取出命令（阻塞式）
     char* cmd_with_id = redis_blpop("process_cmd_list", 0);
     // 拆分ID和命令
     char* req_id = strtok(cmd_with_id, ":");
     char* cmd = strtok(NULL, ":");
     // 执行命令，生成响应
     char* resp = execute_cmd(cmd);
     // 把响应存入对应列表，格式：req_id:resp
     redis_rpush("process_resp_list", strcat(req_id, ":", resp));
     sleep(1);
   }
   

3. Node.js侧逻辑：

   const { createClient } = require('redis');
   
   const client = createClient();
   client.connect();
   
   // 生成唯一请求ID
   function generateReqId() {
     return Date.now() + '-' + Math.random().toString(36).substr(2, 9);
   }
   
   async function sendCommand(cmd) {
     const reqId = generateReqId();
     // 发送带ID的命令到Redis列表
     await client.rPush('process_cmd_list', `${reqId}:${cmd}`);
     // 阻塞等待对应ID的响应
     while(true) {
       const [, respWithId] = await client.blPop('process_resp_list', 0);
       const [respId, resp] = respWithId.split(':');
       if(respId === reqId) {
         return resp;
       }
       // 如果不是当前请求的响应，放回列表
       await client.rPush('process_resp_list', respWithId);
     }
   }
   
   // 示例调用
   sendCommand('restart_service').then(resp => {
     console.log('响应：', resp);
     client.quit();
   });
   

• 权限问题：不管用哪种方案，都要确保两个进程对通信载体（FIFO、UDS文件、Redis）有读写权限，避免Permission Denied错误。
• 数据格式：建议用JSON序列化命令和响应（比如JSON.stringify({id: 'xxx', cmd: 'xxx'})），避免解析混乱，尤其是带空格或特殊字符的命令。
• 错误处理：要考虑进程崩溃、连接断开的情况，比如Node.js侧添加重连逻辑，Linux进程添加看门狗机制。
• 并发安全：如果有多个请求同时发送，一定要用请求ID来绑定请求和响应，避免响应错乱。

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