NodeJS使用Nginx配置单物理机多端口负载均衡

    Nginx (engine x) 是一个高性能的HTTP和反向代理服务器,也是一个IMAP/POP3/SMTP服务器。可以利用它的反向代理在内部网络做路由均衡。

    主要配置是conf/niginx.conf内:


     

    #user nobody;
    worker_processes 8; #一般配置与CPU核心数一致,可获得最大性能

    #error_log logs/error.log;
    #error_log logs/error.log notice;
    #error_log logs/error.log info;

    #pid logs/nginx.pid;

    ##工作模式以及连接数上限
    events {
    worker_connections 1024;#单个后台woker_process进程的最大并发链接数
    }
    http {
    include mime.types;
    default_type application/octet-stream;

    #log_format main ‘$remote_addr – $remote_user [$time_local] “$request” ‘
    # ‘$status $body_bytes_sent “$http_referer” ‘
    # ‘”$http_user_agent” “$http_x_forwarded_for”‘;

    #access_log logs/access.log main;

    sendfile on;
    #tcp_nopush on;

    #keepalive_timeout 0;
    keepalive_timeout 65;

    #gzip on;
    gzip on;
    gzip_disable “MSIE [1-6]\.(?!.*SV1)”;
    include chicken.conf;#把对服务器的配置写在一个独立的文件里,在nginx主配置文件里加载一下


     

    这边我们把部署配置在单独的一个chicken.conf文件中:

    这边测试使用两台局域网的8核处理去均衡HTTP的访问配置内容如下:


     

    #负载均衡到不同的端口
    upstream sample{

    #配置负载权重
    #ip_hash; —ip_hash与backup down weight 权重分配不能同时使用
    #max_fails :允许请求失败的次数默认为1.当超过最大次数时,返回proxy_next_upstream 模块定义的错误
    #fail_timeout:max_fails次失败后,暂停的时间

    #本机物理负载
    server 127.0.0.1:6969 weight=1 max_fails=3 fail_timeout=5s; # weight默认为1.weight越大,负载的权重就越大; max_fails最大请求失败次数,fail_timeout超过最大失败请求次数后宕机时间
    server 127.0.0.1:6970 weight=1 max_fails=3 fail_timeout=5s;
    server 127.0.0.1:6971 weight=1 max_fails=3 fail_timeout=5s;
    server 127.0.0.1:6972 weight=3 max_fails=3 fail_timeout=10s;
    server 127.0.0.1:6973 weight=3 max_fails=3 fail_timeout=10s;
    server 127.0.0.1:6974 weight=3 max_fails=3 fail_timeout=10s;
    server 127.0.0.1:6975 weight=1 max_fails=3 fail_timeout=20s;
    server 127.0.0.1:6976 weight=1 max_fails=3 fail_timeout=20s;

    #多个物理机负载
    server 192.168.50.181:6969 backup;#其它所有的非backup机器down或者忙的时候,请求backup机器
    server 192.168.50.181:6970 backup;
    server 192.168.50.181:6971 backup;
    server 192.168.50.181:6972 down; # 表示当前的server暂时不参与负载
    server 192.168.50.181:6973 down;
    server 192.168.50.181:6974 down;
    server 192.168.50.181:6975 down;
    server 192.168.50.181:6976 down;
    }

    #第一个服务
    server {
    listen 80;#监听80端口
    server_name 127.0.0.1;#请求的头包含10.10.10.10
    location /
    {
    #配置地址映射,对/进行配置的话就将所有请求进行转发
    proxy_pass http://sample; #目标地址我将原有在10机80端口的WEB应用改到8800端口服务,当然也可以是其他局域网能够访问的地址
    proxy_redirect off;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
    }
    #第二个服务
    # server {
    # listen 80;#监听80端口#对于server_name,需要将多个域名的请求进行反向代理,所以可以配置多个server_name来满足要求
    # server_name 127.0.0.1;
    # location /
    # {
    # #同样将所有地址进行方向代理,如果应用的规模大,还可以将注册划到一个服务器上处理、登录划到一个服务器处理、静态划到一个服务器处理等等
    # proxy_pass http://127.0.0.1:6970;#系统的服务地址,局域网地址,我还是用10的机器做,也可以配置到局域网内的其他地址上去
    # proxy_redirect off;
    # proxy_set_header Host $host;
    # proxy_set_header X-Real-IP $remote_addr;
    # proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    # }
    # }


     

    服务器端多进程测试,利用nodejs代码创建一个集群在两台局域网机内运行:

    //单服务进程集群
    var config = require(‘./Common/Config’);
    const cluster = require(‘cluster’);
    const http = require(‘http’);
    const url = require(‘url’);
    const path = require(‘path’);
    const fs = require(‘fs’);
    //路由表
    var routeArray = {};
    //进程列表
    var workerArray = {};
    //进程数量
    var clusterNum;
    //开启集群服务
    var startClusterServer = function()
    {
    //判断是否是主进程
    if(cluster.isMaster)
    {
    for(leti=0; i<config.numCPUs; i++)
    {
    //创建子进程
    constwork=cluster.fork();
    //监听子进程是否上线
    work.on(‘online’, ()=>{
    console.log(`子进程上线`);
    //主进程发送消息到子进程
    letport=6969+i;
    work.send({cmd:’initProcess’, portcmd:port});
    });
    //监听子进程消息
    work.on(‘message’, (msg)=>{
    if(msg.cmd&&msg.cmd==’initmsg’)
    {
    console.log(`主进程收到子进程数据: ${msg.cmd}`);
    }
    });
    }
    //存储子进程服务
    workerArray=cluster.workers;
    //监听回调
    cluster.on(‘exit’, (worker, code, signal)=>{
    console.log(`worker${worker.process.pid} died`);
    });
    }
    else
    {
    //子进程初始化
    console.log(`进程服务端口:${process.pid}`);
    process.on(‘message’,(msg)=>{
    if(msg.cmd&&msg.cmd==’initProcess’)
    {
    letport=msg.portcmd;
    console.log(`子进程接受到主进程数据: ${msg.cmd}—-${msg.portcmd} `);
    constserver=http.createServer((req, res) => {
    res.writeHeader(200, {‘Content-Type’:’text/javascript;charset=UTF-8′}); //状态码+响应头属性
    // 解析 url 参数
    varparams=url.parse(req.url, true).query; //parse将字符串转成对象,req.url=”/?url=123&name=321″,true表示params是{url:”123″,name:”321″},false表示params是url=123&name=321
    res.write(“网站名:”+params.name);
    console.log(params.name);
    res.write(“\n”);
    res.write(“网站 URL:”+params.url);
    console.log(params.url);
    console.log(`接收到客户端(—${config.localIp}—-${port})的访问`);
    res.end(`\nlisten sucessful—${config.localIp}—-${port}`);
    }).listen(port);
    //测试单个端口服务进程宕机
    if(port==6969)
    {
    for(leti=0; i<99999999999999; i++)
    {
    }
    }
    if(port==6970)
    {
    for(leti=0; i<99999999999999; i++)
    {
    }
    }
    if(port==6971)
    {
    for(leti=0; i<99999999999999; i++)
    {
    }
    }
    }
    });
    process.send({cmd:’initmsg’});
    // console.log(`进程服务端口:${config.LOGIN_PORT}`);
    // http.createServer((req, res) => {
    // res.writeHead(200);
    // res.end(‘hello world\n’);
    // }).listen(8000);
    // console.log(`Worker ${process.pid} started`);
    }
    }
    module.exports = {startClusterServer}
     
    这样通过前端http://127.0.0.1访问可以测试具体访问到哪个进程,就可以看到负载均衡的实现了
    有帮助就分享一下吧!

    转载请注明:少狼 – 敬畏知识的顽皮狗 » NodeJS使用Nginx配置单物理机多端口负载均衡

    喜欢 0

*

还没有人抢沙发呢~