Node.js群集工作程序内的http代理

我在NodeJS中构建了一个示例代码

var cluster = require("cluster"),
    http = require("http"),
    express = require('express'),
    port = parseInt(process.argv[2]||8001),
    servers =  ['http://127.0.0.1:800821', 'http://127.0.0.1:800831'];;

if (cluster.isMaster) {

  console.log('Master ' + process.pid + ' has started.');
     var numWorkers = require('os').cpus().length;

    console.log('Master cluster setting up ' + numWorkers + ' workers...');

    for(var i = 0; i < 1; i++) {
        cluster.fork();
    }

    cluster.on('online', function(worker) {
        console.log('Worker ' + worker.process.pid + ' is online');
    });

    cluster.on('exit', function(worker, code, signal) {
        console.log('Worker ' + worker.process.pid + ' died with code: ' + code + ', and signal: ' + signal);
        console.log('Starting a new worker');
        cluster.fork();
    });
} else {
    var httpProxy = require('http-proxy');
    var proxy = httpProxy.createProxyServer();
    var count = 0;
    // Workers share the TCP connection in this server
    var app = express();
    app.get('/', function (req, res) {
        console.log('Cluster => ' + process.pid);
        loadBalanceProxy(req,res);
    }).listen(port);

    var currentServer = 1;
    function loadBalanceProxy(req, res){
        var cur = currentServer%servers.length;
        currentServer++;
        var target = servers[cur];
        console.log("Proxy => " + target);
        proxy.web(req, res, {
            target: target
        });
    }
}

http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.write('request successfully proxied to: ' + req.url + '\n' + JSON.stringify(req.headers, true, 2));
  res.end();
}).listen(800831);

http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.write('request successfully proxied to: ' + req.url + '\n' + JSON.stringify(req.headers, true, 2));
  res.end();
}).listen(800821);

var cluster=require（“集群”），
http=require（“http”），
express=require（'express'），
port=parseInt（process.argv[2]| | 8001），
服务器=['http://127.0.0.1:800821', 'http://127.0.0.1:800831'];;
if（cluster.isMaster）{
log（'Master'+process.pid+'已启动'）；
var numWorkers=require（'os'）.cpus（）.length；
log（'主集群设置'+numWorkers+'workers…'）；
对于（变量i=0；i<1；i++）{
cluster.fork（）；
}
cluster.on（'online'，函数（worker）{
log（'Worker'+Worker.process.pid+'处于联机状态'）；
});
集群打开（'exit'，功能（工作者、代码、信号）{
console.log（'Worker'+Worker.process.pid+'死亡，代码为'+code+'，信号为'+signal'）；
log（“启动一个新的工作程序”）；
cluster.fork（）；
});
}否则{
var httpProxy=require（'http-proxy'）；
var proxy=httpProxy.createProxyServer（）；
var计数=0；
//工作人员在此服务器中共享TCP连接
var-app=express（）；
app.get（'/'，函数（req，res）{
log（'Cluster=>'+process.pid）；
loadBalanceProxy（请求、回复）；
}).监听（端口）；
var currentServer=1；
函数loadBalanceProxy（请求、恢复）{
var cur=currentServer%servers.length；
currentServer++；
var target=服务器[cur]；
log（“Proxy=>”+目标）；
proxy.web（请求、回复、{
目标：目标
});
}
}
http.createServer（函数（req，res）{
res.writeHead（200，{'Content-Type'：'text/plain'}）；
res.write（'请求成功代理到：'+req.url+'\n'+JSON.stringify（req.headers，true，2））；
res.end（）；
}).听（800831）；
http.createServer（函数（req，res）{
res.writeHead（200，{'Content-Type'：'text/plain'}）；
res.write（'请求成功代理到：'+req.url+'\n'+JSON.stringify（req.headers，true，2））；
res.end（）；
}).听（800821）；

在这个示例中，我想在集群工作进程内创建代理服务器，这给了我错误

bind-EADDRINUSE-null:800831

我想知道我是否可以在集群工作者内部创建http代理。如果我做不到这一点，那么就有一个解决方案来实现机器之间的负载平衡了吗？

我在集群内创建了一个反向代理，并在另一个文件中创建了3台服务器，这对我来说很有效（别忘了分别运行服务器，例如在windows上，您在4 cmd中启动服务器，1 cmd用于代理，其他（3 cmd）用于服务器）

//var https=require（'https'）；浮渣
var http=require（'http'）；
var proxy=require（'http-proxy'）；
var cluster=require（'cluster'）；
var fs=需要（'fs'）；
var请求=要求（“请求”）；
//const numpus=require（'os'）.cpus（）.length；
var numpus=4；
if（cluster.isMaster）{
对于（变量i=0；i{
console.log（'worker'+worker.process.pid）；
});
集群打开（'exit'，功能（工作者、代码、信号）{
console.log（'Worker'+Worker.process.pid+'死亡，代码为'+code+'，信号为'+signal'）；
log（“启动一个新的工作程序”）；
cluster.fork（）；
});
}否则{
startProxyReverse（）；
}
函数startProxyReverse（）{
http.globalAgent.maxSockets=10240；
//定义服务器以实现负载平衡。
var服务器=[{
主持人：“127.0.0.1”，
端口：8001
}, {
主持人：“127.0.0.1”，
港口：8003
}, {
主持人：“127.0.0.1”，
港口：8002
}];
var failoverTimer=[]；
//加载SSL证书
//var ca=[
//fs.readFileSync（'./certs/PositiveSSLCA2.crt'），
//fs.readFileSync（'./certs/AddTrustExternalCARoot.crt'）
// ];
//变量选项={
//ca:ca，
//key:fs.readFileSync（'./certs/example_wild.key'），
//证书：fs.readFileSync（'./certs/STAR\u example\u com.crt'）
// };
//为每个目标创建代理对象。
var proxies=servers.map（函数（目标）{
返回新的proxy.createProxyServer({
目标：目标
//ws：是的，
//是的，
//ssl:opts，
//唐：错
});
});
/**
*选择要代理的随机服务器。如果设置了“服务器”cookie，请使用该cookie
*作为粘性会话，因此用户留在同一服务器上（有利于ws回退）。
*@param{Object}req HTTP请求数据
*@param{Object}res HTTP响应
*@return{Number}要使用的代理的索引。
*/
var selectServer=功能（请求、恢复）{
var指数=-1；
var i=0；
//检查是否有饼干。
if（req.headers&&req.headers.cookie&&req.headers.cookie.length>1）{
var cookies=req.headers.cookie.split（“；”）；
对于（i=0；i=0？索引：0；
//将服务器索引存储为粘性会话。
如果（res）{
res.setHeader（'Set-Cookie'，'server='+index+'；path=/'）；
}
收益指数；
};
/**
*当请求出现错误时激发。
*设置10秒的间隔以ping主机，直到主机重新联机。
*在请求开始被阻止到此主机之前，有一个10秒的缓冲区。
*代理数组中的@param{Number}索引。