精华内容
下载资源
问答
  • 负载均衡的简单探索(react+nginx+nodejs)
    2021-05-25 19:13:38

    1、首先我们先创建一个react项目,主要功能就是一个按钮,点击一下访问后端api。创建react项目的步骤之前有写到,可以翻翻前面我写的博客。这里贴出生成react模板之后,修改app.js的代码。

    import React, { Component } from 'react';
    import logo from './logo.svg';
    import './App.css';
    import axios from 'axios' ;
     
    import { Layout, Menu, Button,Breadcrumb, Icon } from 'antd';
     
    class App extends Component {
     
     
        constructor(props) {
            super(props)
            this.state = {
             list:[] }
             this.handleClick=this.handleClick.bind(this)
     
            }
     
    handleClick(){
      let  url="http://127.0.0.1:1818/getuserinfo/"
    axios.get(url)
      .then(function (response) {
        let data =response.data
        console.log(data);
      })
      .catch(function (error) {
        console.log(error);
      });
    }
     
     
      render() {
        return (
          <div className="App">
            <header className="App-header">
              <img src={logo} className="App-logo" alt="logo" />
              <h1 className="App-title">Welcome to React</h1>
            </header>
            <p className="App-intro">
              To get started, edit <code>src/App.js</code> and save to reload.
            </p>
            <Button onClick={this.handleClick}>测试调用接口</Button>
          </div>
        );
      }
    }
     
    export default App;
    

    2、然后我们安装一下nginx,这里网上也有很多的教程,大家可以去翻翻。这里贴出配置nginx.conf文件的代码。

    worker_processes  1;
    
    events {
        worker_connections  1024;
    }
    
    http {
        include       mime.types;
        default_type  application/octet-stream;
    
        sendfile        on;
       
        keepalive_timeout  65;
        upstream group1 {
          server 127.0.0.1:8081 weight=1;
          server 127.0.0.1:8082 weight=1;
        }
        server {
            listen       1818;
            server_name  localhost;
            default_type text/html;
    
            location /getuserinfo/ {
              proxy_pass http://group1/getuserinfo;
    
            }
            
    
          
        }
    
    }
    
    

    3、最后我们来编写nodejs的代码,在这里nodejs的作用主要是查数据库提供数据。我们要创建并运行两个nodejs服务,让他在两个端口不断地提供数据,供前端查询。

    具体创建nodejs项目的方法很简单,我们在桌面创建一个文件夹,server1,cmd进入该目录,需要npm install express以及npm install mysql。之后我们再创建一个server.js的文件。退出目录。将server1文件夹复制一份,命名为server2,依然放在桌面。更改server2文件夹中server.js的代码。大功告成。

    这里贴出server.js的代码,另一个只需要把端口号从8081改成8082就好。

    const express = require('express');
    const app = express();
    const mysql = require('mysql');
    
    const connection = mysql.createConnection({
        host: 'localhost',
        user: 'root',
        password: 'your password',     // 改成你自己的密码
        database: 'nodejstest'    // 改成你的数据库名称
    });
    
    connection.connect();
    
    // 下面是解决跨域请求问题
    app.all('*', function(req, res, next) {
        res.header("Access-Control-Allow-Origin", "*");
        res.header("Access-Control-Allow-Headers", "X-Requested-With");
        res.header("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS");
        res.header("X-Powered-By",' 3.2.1');
        res.header("Content-Type", "application/json;charset=utf-8");
        next();
     });
    
    // 这里就是主要要修改的地方,其实也就一行
    // 把 address 改成你自己定的地址,就是连接访问的那个地址
    app.get('/getuserinfo',function(err,res){
        const sql = 'select * from user'; // 写你需要的sql代码,你要是不会写那我就真的没办法了
        connection.query(sql,function(err,result){
            if(err){
                console.log('[SELECT ERROR] - ', err.message);
                return;
            }
            // result内放的就是返回的数据,res是api传数据
            // 返回的数据需要转换成JSON格式
            res.json(result); 
        }); 
    })    
    
    var server = app.listen(8081, '127.0.0.1', function () {
    
        var host = server.address().address;
        var port = server.address().port;
    
        console.log("地址为 http://%s:%s", host, port);
    })
    

    我们把nginx运行起来,它监听1818端口,把react运行起来,它监听3000端口,把两个nodejs运行起来,分别监听8081和8082端口。

    我们点击react页面上的按钮,它会向1818端口发送一个get请求,1818是nginx正在监听的,它将从8081和8082中选择一个转发这个get请求,最后目标端口将数据传回来。

    这个转发的过程就是简单的负载均衡。

    更多相关内容
  • 这一篇确实拖的比较久,上节《nodejs负载均衡(一):服务负载均衡》讲了服务负载均衡实现,但是如果需要调用远程服务,如何保证不是调用不会集中在一台服务上,如何确保远程服务调用的负载均衡?这就要实现Consumer...

    简介

    这一篇确实拖的比较久,上节《nodejs负载均衡(一):服务负载均衡》讲了服务负载均衡实现,但是如果需要调用远程服务, 如何保证不是调用不会集中在一台服务上,如何确保远程服务调用的负载均衡?这就要实现 Consumer 端调用rpc的负载均衡。所以本文章主要讲解 RPC负载均衡算法实现 。

     

     

    算法

    下面介绍几个主要的负载均衡算法如何实现,可以看下我写的NPM包 load-balancer-algorithm

    const LBA = require('load-balancer-algorithm');
    
    const weightRandomPool = [
      { host: "127.0.0.2", weight: 2 },
      { host: "127.0.0.1", weight: 3 },
      { host: "127.0.0.3", weight: 5 },
    ];
    const weightedList = []
    const loadBalance = new LBA.WeightedRoundRobin(weightRandomPool);
    
    for(let i = 0; i < 10; i++){
      const address = loadBalance.pick();
      weightedList.push(loadBalance.getWeight(address.host))
    }
    // [5, 5, 3, 5, 2, 3, 5, 2, 3, 5]
    console.log(weightedList)
    

    Round Robin

    轮询(Round robin) 算法,就是依次轮询服务队列的节点,周而复始,这个实现比较简单。

    • 消费端调用均衡
    • 通过当前下标+1对数据池长度数取模,获取到下一个节点下标

    缺点:

    • 要求服务提供节点性能一致

     

     

    Weighted Round Robin

    权重轮询(Weighted round robin) 算法,基于轮询添加权重判断,这样可以针对性能低服务节点减少流量。

    • 动态调整权重实时同步
    • 相对比较均衡的算法
    • 但是权重大服务节点会突然负载上升,所以又有出现 平滑权重轮询 (smooth Weighted Round Robin),就是平滑分布的获取节点
    [
      { host: "127.0.0.1", weight: 2 },
      { host: "127.0.0.2", weight: 3 },
      { host: "127.0.0.3", weight: 5 },
    ]
    // normal
    // [5, 5, 5, 5, 5, 3, 3, 3, 2, 2]
    // smooth
    // [5, 5, 3, 5, 2, 3, 5, 2, 3, 5]
    

     

     

    Source IP Hash

    Source IP hash (consistent hash)算法,为了将客户端IP请求固定分配给一台服务器,实现获取同一个 session ,看下 带虚拟节点一致性hash 实现,也目前主流推荐的。

    • 通过节点 IP 生成N个 hash ,然后通过 hash 获取N个虚拟节点的值,然后通过与请求数据(ip或参数)生成的 hash 比较最相近的节点
    • nodejs主要 sticky sessions 模式使用,确保访问的都是同一个服务上的 session

    缺点:

    • 相对其他算法,负载均衡性较低,性能也相对较低
    • 固定的IP服务挂了,用户 session 就会丢失,所以做好的方法还是 session 共享

    举例:如图每个节点生成2个虚拟节点,然后根据请求数据生成hash值比较哪个值最相近,决定访问哪个节点

     

     

    Random

    随机(Random) 算法,随机产生一个 pool 长度数范围内的整数,从而随机获取机器。

    • 碰撞率高,但是调用量越大分布越平均
    • 随机一个0~pool.length范围内的值

    Weighted Random

    权重随机(weighted random)算法,假如机器的性能不一致,这时候就要基于随机基础上添加权重计算。

    • 随机一个0~totalWeighted值,然后通过依次减去 pool 的节点权重,如果小于0,代表随机值落在当前权重范围中
    let offset = randomInteger(totalWeight);
    for (let i = 0; i < len; i++) {
      // 随机值减去权重,属于哪一个权重片段
      offset -= this.getWeight(pool[i]);
      if (offset < 0) {
        address = pool[i];
        break;
      }
    }
    

    Least Connections

    最少连接(Least connections) 算法,连接数最少服务节点优先调用。

    • 需要统计连接或请求数
    • 服务器性能一致

     

     

    Weighted Least Connections

    权重最少连接(Weighted least connections) 算法,基于最少连接服务节点增加权重判断。

     

    这篇文章也憋了很久,本来想一篇文章写完 rpc ,但是发现事情很多,想想还是分开写,后面再写一篇《nodejs负载均衡(三):RPC实现》

    更多细节查看 NPM包 load-balancer-algorithm

    展开全文
  • 什么是负载均衡 负载平衡(Load balancing)是一种计算机技术,用来在多个计算机(计算机集群)、网络连接、CPU、磁盘驱动器或其他资源中分配负载,以达到最优化资源使用、最大化吞吐率、最小化响应时间、同时避免...

    什么是负载均衡

    负载平衡(Load balancing)是一种 计算机技术,用来在多个计算机( 计算机集群)、网络连接、CPU、磁盘驱动器或其他资源中分配负载,以达到最优化资源使用、最大化吞吐率、最小化响应时间、同时避免过载的目的。 使用带有负载平衡的多个服务器组件,取代单一的组件,可以通过 冗余提高可靠性。负载平衡服务通常是由专用软件和硬件来完成。 主要作用是将大量作业合理地分摊到多个操作单元上进行执行,用于解决互联网架构中的 高并发高可用的问题。 - wiki

    负载均衡(Load Balance)是建立在网络协议分层上的,通过网络协议里面的处理将负载的作业合理的分摊到多个操作单元上。

     

     

    所以针对网络协议层有不同负载均衡策略 2/3/4/7层负载均衡 ,负载均衡的实现分 软/硬 ,顾名思义:

    • 一个是通过软件实现,成本低、灵活简单,缺点受服务器性能影响
    • 一个是通过硬件,性能优于软负载均衡,但是成本高

    nodejs能做哪些

    先看下面的请求链路图(举个例子,实现方式、策略、架构等有很多)

     

    1. DNS、VIP、Nginx服务的负载均衡底层服务(云)或者运维已经搭建好了,不需node开发过多关心
    2. Nginx负载均衡到web服务集群,可以使用 upstream 模块配置不同策略
    3. 重点node单个服务负载均衡,主进程分派到多个子进程,这是属于软负载均衡
    4. 假如node服务要通过RPC调用远程其他服务,为了不影响其他服务,需要将RPC均衡分派到其他服务的不同节点上

    结论:从上面看出3、4是nodejs服务可以做的,就是 服务负载均衡 和 rpc负载均衡

    服务负载均衡

    先了解一下nodejs cluster模块,下面是nodejs官方cluster例子代码

    app.js

    const cluster = require('cluster');
    const http = require('http');
    const numCPUs = require('os').cpus().length;
    
    if (cluster.isMaster) {
      console.log(`Master ${process.pid} is running`);
    
      // Fork workers.
      for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
      }
    
      cluster.on('exit', (worker, code, signal) => {
        console.log(`worker ${worker.process.pid} died`);
      });
    } else {
      // Workers can share any TCP connection
      // In this case it is an HTTP server
      http.createServer((req, res) => {
        res.writeHead(200);
        res.end('hello world\n');
      }).listen(8000);
    
      console.log(`Worker ${process.pid} started`);
    }
    
    1. 启动 app.js ,当前执行进程是主线程
    2. 然后会 fork 与cpu个数一样的worker进程
    3. worker进程默认执行 process.argv[1] 文件,即 app.js
    4. 当非 master 进程程启动 http server ,每个worker进程启动一个

    1.如何监听同一个端口

    第一个问题:为什么多个进程server可以监听同一个port?

    The first one (and the default one on all platforms except Windows), is the round-robin approach, where the master process listens on a port, accepts new connections and distributes them across the workers in a round-robin fashion, with some built-in smarts to avoid overloading a worker process. 第一种方法(也是除 Windows 外所有平台的默认方法)是循环法,由主进程负责监听端口,接收新连接后再将连接循环分发给工作进程,在分发中使用了一些内置技巧防止工作进程任务过载。
    The second approach is where the master process creates the listen socket and sends it to interested workers. The workers then accept incoming connections directly. 第二种方法是,主进程创建监听 socket 后发送给感兴趣的工作进程,由工作进程负责直接接收连接。
    The second approach should, in theory, give the best performance. In practice however, distribution tends to be very unbalanced due to operating system scheduler vagaries. Loads have been observed where over 70% of all connections ended up in just two processes, out of a total of eight. 理论上第二种方法应该是效率最佳的。 但在实际情况下,由于操作系统调度机制的难以捉摸,会使分发变得不稳定。 可能会出现八个进程中有两个分担了 70% 的负载。

    官方支持2种方法,其实都是主进程负责监听端口,子进程会fork一个handle句柄给主线,通过循环分发或监听发送与worker进程通信,交替处理任务。

    2.进程间如何通信

    第二个问题:进程间如何通信?

    1、主进程和子进程 主进程和子进程通过 IPC 通信

    app.js

    const cluster = require('cluster');
    const http = require('http');
    const numCPUs = require('os').cpus().length;
    
    if (cluster.isMaster) {
      console.log(`Master ${process.pid} is running`);
    
      // Fork workers.
      for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
      }
    
      cluster.on('exit', (worker, code, signal) => {
        console.log(`worker ${worker.process.pid} died`);
      });
    
      cluster.on('listening', (worker) => {
        // send to worker
        worker.send({message: 'from master'})
      });
    
      for (const id in cluster.workers) {
        cluster.workers[id].on('message', (data)=>{
          // receive by the worker
          console.log('master message: ', data)
        });
      }
    
    } else {
      // Workers can share any TCP connection
      // In this case it is an HTTP server
      http.createServer((req, res) => {
        res.writeHead(200);
        res.end('hello world\n');
      }).listen(8000);
    
      console.log(`Worker ${process.pid} started`);
    
      // send to master
      process.send({message: 'from worker'})
    
      process.on('message', (data)=>{
        // receive by the master
        console.log('worker message', data)
      })
    }
    

    这是通过node的原生ipc通信,ipc通信方式有很多种

    • node原先ipc channel
    • shell stdin/stdout
    • socket
    • pipe
    • message queues

    2、子进程与子进程

    • 一对多,可以通过父进程进行分发
    • 一对一,可以通过ipc通信

    3.如何做到进程负载均衡

    第三个问题:如何做到进程负载均衡?

    服务器集群的负载均衡通过上层已经处理了(Nginx、DNS、VIP等),那node服务怎么做的?cluster采用 round-robin 算法策略分发http请求到不同worker进程,关于负载均衡算法下一章《nodejs负载均衡(二):RPC负载均衡》里面会讲

    4.服务异常退出怎么办

    第四个问题:服务异常退出怎么办?

    1. 一般可以通过 try/catch 捕获异常错误,但是node里面如果遗漏异常捕获,可能导致整个进程崩溃
    2. 使用 try/catch 就够了吗?异常会冒泡到 event loop ,触发 uncaughtException 事件,这里可以阻止程序退出
    3. node异常默认情况是打印 stderr 并以代码1退出,触发 exit 事件
    4. 当异常退出时,主线程监听到worker死亡,可以refork一个新的worker
    Tips: 退出的事件还有  Signal Events

    现在来看下 graceful.js 大概实现,在下一节会有完整的代码,完整案例查看graceful-shutdown-example

    'use strict';
    
    module.exports = options => {
      const { processKillTimeout = 3000, server } = options;
    
      let throwErrorTimes = 0
    
      process.on('uncaughtException', function(err) {
        throwErrorTimes += 1;
        console.log('====uncaughtException====');
        console.error(err)
    
        if (throwErrorTimes > 1) {
          return;
        }
    
        close()
      });
    
      function close(){
        server.close(() => {
            // ...do something
        })
      }
    };
    

    5.如何平滑退出

    第五个问题:如何平滑退出?

    在发布时,多台机器分组发布,可以保证服务不会不可访问,但是:

    • 用户正在访问一台下线的服务,如何确保等待用户请求返回在下线?
    • 一个worker服务异常退出,如何平滑重启一个worker?

    一个平滑退出的大概流程:

    1. fork worker
    2. 监听worker状态
    3. worker异常退出refork
    4. 监听master signal退出信号
    5. master退出前kill所有worker
    6. worker退出前close server和worker的子进程
    // master.js
    'use strict';
    
    const cluster = require('cluster');
    const killTree = require('./kill-tree');
    const numCPUs = require('os').cpus().length;
    // const numCPUs = 1;
    
    let stopping = false;
    
    console.log(`Master ${process.pid} is running`);
    
    cluster.setupMaster({
      exec: 'worker.js',
      // silent: true,
    });
    
    // Fork workers.
    for (let i = 0; i < numCPUs; i++) {
      cluster.fork();
    }
    
    cluster.on('fork', worker => {
      worker.on('message', data => {
        // Receive by the worker
        console.log(`${worker.process.pid} master message: `, data);
      });
    });
    
    // Kill all workers
    async function onMasterSignal() {
      if (stopping) return;
      stopping = true;
    
      const killsCall = Object.keys(cluster.workers).map(id => {
        const worker = cluster.workers[id];
    
        return killTree(worker.process.pid);
      });
    
      await Promise.all(killsCall);
    }
    
    // kill(2) Ctrl-C
    // kill(3) Ctrl-\
    // kill(15) default
    // Master exit
    ['SIGINT', 'SIGQUIT', 'SIGTERM'].forEach(signal => {
      process.once(signal, onMasterSignal);
    });
    
    // Terminate the master process
    process.once('exit', () => {
      console.log(`Master about to exit`);
    });
    
    // Worker is listening
    cluster.on('listening', (worker, address) => {
      // Send to worker
      worker.send({ message: 'from master' });
    });
    
    cluster.on('disconnect', worker => {
      console.log(`${worker.id} disconnect`);
    });
    
    // Worker died
    cluster.on('exit', (worker, code, signal) => {
      console.log(
        `Worker ${worker.process.pid} died, code: ${code}, signal: ${signal}`
      );
    
      worker.removeAllListeners();
    
      // killTree(worker.process.pid, function(err) {
      //   console.log(err)
      // });
    
      // stopping server
      if (stopping) return;
    
      console.log('====Refork====');
      // refork a new worker
      cluster.fork();
    });
    
    setTimeout(() => {
      cluster.workers[1].send({
        action: 'throw error',
      });
    }, 600);
    
    // worker.js
    'use strict';
    
    const http = require('http');
    const { fork } = require('child_process');
    const graceful = require('./graceful');
    
    fork('./child');
    
    // Workers can share any TCP connection
    // In this case it is an HTTP server
    const server = http
      .createServer((req, res) => {
        // services excption
        try {
          throw new Error('Happened error');
        } catch (err) {
          res.writeHead(200);
          res.end(`${err.stack.toString()}`);
        }
        // console.log(res)
        // res.setHeader('Content-Type', 'application/json');
        // res.setHeader('Access-Control-Allow-Origin', '*');
        // res.writeHead(200);
        // res.end(JSON.stringify({ success: true }));
      })
      .listen(8000);
    
    graceful({
      server,
    });
    
    // Send to master
    process.send({
      message: 'from worker',
      // server
    });
    
    process.on('message', data => {
      // Receive by the master
      if (data.action && data.action === 'throw error') {
        // The process threw an exception
        throw new Error('Kill myself');
      }
      console.log('Worker message', data);
    });
    

     

    // graceful.js
    'use strict';
    
    const cluster = require('cluster');
    const killTree = require('./kill-tree');
    
    module.exports = options => {
      const { processKillTimeout = 3000, server } = options;
    
      let throwErrorTimes = 0
    
      process.on('SIGTERM', function onSigterm () {
        console.info(`Only graceful shutdown, worker ${process.pid}`)
        close()
      })
    
      process.on('uncaughtException', function(err) {
        throwErrorTimes += 1;
        console.log('====uncaughtException====');
        console.error(err)
    
        if (throwErrorTimes > 1) {
          return;
        }
    
        close()
      });
    
      function close(){
        server.on('request', (req, res) => {
          // closing the http request
          req.shouldKeepAlive = false;
          res.shouldKeepAlive = false;
          if (!res._header) {
            // closing the socket connection
            res.setHeader('Connection', 'close');
          }
        });
    
        if (processKillTimeout) {
          const timer = setTimeout(() => {
            // Kill all child process
            killTree(process.pid,()=>{
              // Worker process to exit
              process.exit(1);
            })
          }, processKillTimeout);
    
          timer.unref && timer.unref();
        }
    
        const worker = cluster.worker;
        if (worker) {
          try {
            server.close(() => {
              try {
                worker.send({ message: 'disconnect' });
                worker.disconnect();
              } catch (err) {
                console.error('Error on worker disconnect');
              }
            });
          } catch (err) {
            console.error('Error on server close');
          }
        }
      }
    };
    

    完整案例查看graceful-shutdown-example

    6.守护进程或主进程挂了怎么办

    第六个问题: 守护进程或主进程挂了怎么办?

    防止出现单点故障,提供主从备份服务器。

    7.主动停止服务

    1. 通过系统命令获取当前node进程信息
    2. 过滤停止脚本进程,获取启动脚本进程
    3. kill master进程,发送 SIGTERM
    4. 主进程监听到 SIGTERM ,开始kill workers,停止server
    // stop.js
    
    const main = async () => {
      const command = isWin
          ? 'wmic Path win32_process Where "Name = \'node.exe\'" Get CommandLine,ProcessId'
          : // command, cmd are alias of args, not POSIX standard, so we use args
            'ps -eo "pid,args" | grep node';
    }
    
    // ...
    main().then((result)=>{
      result.forEach((item)=>{
        process.kill(item.pid, 'SIGTERM')
        // killTree(item.pid)
      });
    })
    
    // master.js
    
    // kill(2) Ctrl-C
    // kill(3) Ctrl-\
    // kill(15) default
    // Master exit
    ['SIGINT', 'SIGQUIT', 'SIGTERM'].forEach(signal => {
      process.once(signal, onMasterSignal);
    });
    

    完整案例查看graceful-shutdown-example,真正要实现一个合理node负载均衡框架,还需要做好 worker 管理及 IPC 通信机制、不同系统兼容性、docker、sticky模式等等

    展开全文
  • 负载均衡可以把用户的请求分摊到多个服务器上进行处理,从而实现了对海量用户的访问支持。负载均衡的架构如图所示: 对于复杂的Web应用来说,用Nginx做前端负载均衡是理所当然的事。 下面,我们用Nginx做NodeJS应用...
  • 用Nginx做NodeJS应用的负载均衡

    千次阅读 2018-11-10 03:22:56
    用Nginx做NodeJS应用的负载均衡

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

    《用Nginx做NodeJS应用的负载均衡》

    作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs

    负载均衡可以把用户的请求分摊到多个服务器上进行处理,从而实现了对海量用户的访问支持。负载均衡的架构如图所示:


    对于复杂的Web应用来说,用Nginx做前端负载均衡是理所当然的事。

    下面,我们用Nginx做NodeJS应用的负载均衡。

    1、配置Nginx

    修改nginx.conf:

    ....        upstream sample {       server 127.0.0.1:3000;       server 127.0.0.1:3001;       keepalive 64;     }         server {         listen 80;         ....            server_name 127.0.0.1;         ....            location / {               proxy_redirect off;               proxy_set_header X-Real-IP $remote_addr;               proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;               proxy_set_header X-Forwarded-Proto $scheme;               proxy_set_header Host $http_host;               proxy_set_header X-NginX-Proxy true;               proxy_set_header Connection "";               proxy_http_version 1.1;               proxy_pass http://sample;           }        }
    这里在3000端口和3001端口各有一个Node.js服务器,这两个服务器在做同样的工作。在upstream节,配置了两个Node.js服务器。此外,我们还设置了proxy_pass http://sample做HTTP请求代理。

    2、构建NodeJS服务器

    var http = require('http');var morgan       = require('morgan');var server1 = http.createServer(function (req, res) {  console.log("Request for:  " + req.url + "-- port 3000 ");  res.writeHead(200, {'Content-Type': 'text/plain'});  res.end('Hello Node.js\n');}).listen(3000, "127.0.0.1");var server2 = http.createServer(function (req, res) {  console.log("Request for:  " + req.url + "-- port 3001 ");  res.writeHead(200, {'Content-Type': 'text/plain'});  res.end('Hello Node.js\n');}).listen(3001, "127.0.0.1");server1.once('listening', function() {  console.log('Server running at http://127.0.0.1:3000/');});server2.once('listening', function() {  console.log('Server running at http://127.0.0.1:3001/');});
    3、访问Nginx服务器

    现在我们可以访问http://127.0.0.1

    可以看到如下的输出:

      Server running at http://127.0.0.1:3000/  Server running at http://127.0.0.1:3001/  Request for:  /-- port 3001   Request for:  /favicon.ico-- port 3000   Request for:  /favicon.ico-- port 3001   Request for:  /-- port 3000   Request for:  /favicon.ico-- port 3001   Request for:  /favicon.ico-- port 3000   Request for:  /-- port 3001   Request for:  /favicon.ico-- port 3000   Request for:  /favicon.ico-- port 3001   Request for:  /-- port 3000   Request for:  /favicon.ico-- port 3001   Request for:  /favicon.ico-- port 3000 

               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • 单个进程处理多个请求 import { createServer } from 'http' const { pid } = process const server = createServer((req, res) => { let i = 1e7; while (i > 0) { i-- } console.log(`Handling
  • 什么是负载均衡负载平衡(Load balancing)是一种计算机技术,用来在多个计算机(计算机集群)、网络连接、CPU、磁盘驱动器或其他资源中分配负载,以达到最优化资源使用、最大化吞吐率、最小化响应时间、同时避免...
  • roundrobin,表示简单的轮询,这说,这负载均衡 基本都具备的; static-rr,表示根据权重,建议关注; leastconn,表示最少连接者先处理,建议关注; source,表示根据请求源IP,建议关注; uri...
  • 负载均衡,含义就是根据一定算法将负载(工作任务)进行平衡,分摊到多个操作单元上运行、执行,常见的为Web服务器、企业核心应用服务器和其他主要任务服务器等,从而协同完成工作任务。负载均衡在原有的网络结构上...
  • 使用nginx负载均衡nodejs

    千次阅读 2018-01-24 15:29:55
    主要是关于如何使用nginx做反向代理和负载均衡nodejs多个实例的配置流程,nodejs实例可以是分布在同一台主机上或者不同的主机上的多个实例。 主要内容有 在同一主机创建nodejs多个实例 详细讲解ngnix.conf文件...
  • 传统的 Web 服务器,每客户端连接作为一单独的进程或线程处理,需在切换任务时将 CPU 切换到新的任务并创建一新的运行时上下文,消耗额外的内存和 CPU 时间,当并发请求增加时,服务器响应变慢,从而对性能...
  • Nginx负载均衡实现一个服务器放n个nodejs程序 服务器使用 CentOS 7 添加 Nginx 到 YUM 源 sudo rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm ...
  • GRPC 负载均衡实现

    2021-11-12 11:24:06
    在产品环境,通常要部署多个RPC服务,已提高可用性,以及响应速度。但是 在负载均衡方面不如dubbo的组件那么丰富,但是其提供了服务发现的接口, 可以通过实现其接口,灵活实现负载均衡功能。 下面通过本地配置文件...
  • nginx+node的负载均衡

    2020-03-15 22:58:43
    负载均衡将特定的业务(网络服务、网络流量等)分担给多个服务器或网络设备,从而提高了业务处理能力,保证了业务的高可用性。 使用node配置了两个服务器,分别监听3000和3001端口。 var http=require('http') var ...
  • 参考资料 ... Maglev: A Fast and Reliable Software ...MGW——美团点评高性能四层负载均衡 - 美团技术团队 (meituan.com) Open-sourcing Katran, a scalable network load balancer - Engineering at Meta (fb.com)..
  • 一、 什么是负载均衡? 什么是负载均衡? 记得第一次接触 Nginx 是在实验室,...资源,相当于每个服务实例的执行操作单元,负载均衡就是将大量的数据处理操作分摊到多个操作单元进行执行,用来解决互联网分布式系统..
  • 之前项目中有一消息推送的模块,采用的是nodejs+socketio+redis的框架做的,打算用nginx去负载一下,结果在配置过程中发现客户端浏览器通过nginx与nodejs服务器建立的socket连接会一直中断重连,如此反复。...
  • Nginx能够配置代理台服务器。当一台服务器宕机之后。仍能保持系统可用。详细配置步骤例如以下: 1. 在http节点下,加入upstream节点。 upstream linuxidc { server 10.0.6.108:7080; server 10.0.0.85:8980; }...
  • 本文不会详细介绍 nginx 的安装与配置,本文只是介绍负载均衡这一内容 相关术语 仅仅是对本文而言,哈哈 节点:指一应用服务器 应用服务器:后端 spring 应用、tomcat、nodejs server 等等 网关:如果你的...
  • 所谓负载均衡,单从字面上的...由于没有服务器,所以本次测试直接host指定域名,服务器不够,我们用nodejs监听了三端口(8881,8882,8888)来模拟台服务器。nginx监听80端口作为主服务器。 var http = require('htt...
  • 到各种路由,负载均衡策略;再到故障隔离,熔断等高级功能,已逐渐发展成一高可扩展性,高性能,生产级的RPC框架。 二,模块划分 SOFARPC Node主要包含了四个子模块,分别是: 客户: RPC的客户端实现 服务器: ...
  • 1 cluster进程 cluster经过好几代的发展,现在已经比较好使了。利用cluster,可以自动完成子进程worker分配request的事情,就不再需要自己写代码在master进程中robin式给每worker分配任务了。 const ...
  • 负载均衡原理-原来发送到一台服务器的请求,经过负载均衡后,可以让多台服务器分担多个请求,减轻单台服务器的压力。单从字面上的意思来理解就可以解释N台服务器平均分担负载,不会因为某台服务器负载高宕机和某台...
  • 一、 什么是负载均衡? 什么是负载均衡? 记得第一次接触 Nginx 是在实验室,那时候在服务器部署网站需要用 ...用来在多个资源(一般是服务器)中分配负载,达到最优化资源使用,避免过载。 资源,相当于每...
  • 负载均衡建立在现有网络结构之上,它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力...用来在多个资源(一般是服务器)中分配负载,达到最优化资源使用,避免过载。 资

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,808
精华内容 2,723
关键字:

多个nodejs负载均衡