nodejs高大上的部署方式-PM2
　今天坐在右边的同事忽然欣喜的跟我说：嘿，推荐你个好东西，用PM2试试，比forever高端多了。表示一向落后于时尚的科技前沿的我认真的回答：什么？PM2.5还这么严重，PM2又出来了！
　　要不是都已习惯了我的二，这气氛还真要囧好一会儿~~呵呵&&
　　先说说平时我都是怎么部署程序的吧
　　1、最常用的属nohup了，其实就是在后台执行进程，末尾加个&
[zhoujie@ops-dev ~]$ nohup node /home/zhoujie/ops/app.js &
[1] 31490nohup: ignoring input and appending output to `nohup.out'
即此时程序已启动，直接访问即可，原程序的的标准输出被自动改向到当前目录下的nohup.out文件，起到了log的作用。该命令可以在你退出帐户/关闭终端之后继续运行相应的进程。nohup就是不挂起的意思( no hang up)。
该命令的一般形式为：nohup command &
　　这个不太靠谱的样子，经常默默的进程在后台就挂了
　　2、用screen另开一个屏幕，这种方式可以直接在屏幕上看到程序运行情况
给该应用程序开个screen，如：screen -r ops ，用npm start启动，
退出该后台：ctrl + a，再按d，可不能直接ctrl +c，否则就退出了
这种方式很不专业，呵呵，不过方便看在生产环境的操作。
这个本质上用的forever，package.json里配置的：
& &scripts&: {
& & &start&: &forever app.js&,
& & &test&: &supervisor app.js&
　　3、PM2
使用它要先安装它，用root账号和全局模式安装一下：
npm install -g pm2
用它来启动程序（在当前目录下可以直接启动，pm2 start app.js --name uops）
[zhoujie@ops-dev uops]$ pm2 start app.js&
[PM2] Spawning PM2 daemon
[PM2] Success
[PM2] Process app.js launched
┌──────────┬────┬──────┬─────┬────────┬───────────┬────────┬─────────────┬──────────┐
│ App name │ id │ mode │ PID │ status │ restarted │ uptime │ & & &memory │ watching │
├──────────┼────┼──────┼─────┼────────┼───────────┼────────┼─────────────┼──────────┤
│ app & & &│ 0 &│ fork │ 308 │ online │ & & & & 0 │ 0s & & │ 21.879 MB & │ disabled │
└──────────┴────┴──────┴─────┴────────┴───────────┴────────┴─────────────┴──────────┘
&Use `pm2 info &id|name&` to get more details about an app
[zhoujie@ops-dev uops]$
看，它显示了Success，程序已经默默的成功的启动了，可以实时监控程序的运行，比如执行个pm2 restart，则上述restarted那栏变成1，可以显示程序运行了多长时间、占用内存大小，实在是太赞啦！
终止程序也很简单：pm2 stop&
列举出所有用pm2启动的程序：pm2 list
[zhoujie@ops-dev uops]$ pm2 list
┌──────────┬────┬──────┬─────┬────────┬───────────┬────────┬─────────────┬──────────┐
│ App name │ id │ mode │ PID │ status │ restarted │ uptime │ & & &memory │ watching │
├──────────┼────┼──────┼─────┼────────┼───────────┼────────┼─────────────┼──────────┤
│ app & & &│ 0 &│ fork │ 984 │ online │ & & & & 1 │ 3s & & │ 64.141 MB & │ disabled │
└──────────┴────┴──────┴─────┴────────┴───────────┴────────┴─────────────┴──────────┘
&Use `pm2 info &id|name&` to get more details about an app
查看启动程序的详细信息：pm2 describe id
[zhoujie@ops-dev uops]$ pm2 desc 0
Describing process with pid 0 - name app
┌───────────────────┬─────────────────────────────────────────┐
│ status & & & & & &│ online & & & & & & & & & & & & & & & & &│
│ name & & & & & & &│ app & & & & & & & & & & & & & & & & & & │
│ id & & & & & & & &│ 0 & & & & & & & & & & & & & & & & & & & │
│ path & & & & & & &│ /home/zhoujie/uops/app.js & & & & & & & │
│ args & & & & & & &│ & & & & & & & & & & & & & & & & & & & & │
│ exec cwd & & & & &│ /home/zhoujie/uops & & & & & & & & & & &│
│ error log path & &│ /home/zhoujie/.pm2/logs/app-error-0.log │
│ out log path & & &│ /home/zhoujie/.pm2/logs/app-out-0.log & │
│ pid path & & & & &│ /home/zhoujie/.pm2/pids/app-0.pid & & & │
│ mode & & & & & & &│ fork_mode & & & & & & & & & & & & & & & │
│ node v8 arguments │ & & & & & & & & & & & & & & & & & & & & │
│ watch & reload & &│ ✘ & & & & & & & & & & & & & & & & & & & │
│ interpreter & & & │ node & & & & & & & & & & & & & & & & & &│
│ restarts & & & & &│ 1 & & & & & & & & & & & & & & & & & & & │
│ unstable restarts │ 0 & & & & & & & & & & & & & & & & & & & │
│ uptime & & & & & &│ 93s & & & & & & & & & & & & & & & & & & │
│ created at & & & &│ T09:41:25.672Z & & & & & & & &│
└───────────────────┴─────────────────────────────────────────┘
[zhoujie@ops-dev uops]$&
通过pm2 list命令来观察所有运行的进程以及它们的状态已经足够好了.但是怎么来追踪它们的资源消耗呢?别担心,用这个命令:pm2 monit
可以得到进程(以及集群)的CPU的使用率和内存占用(ctrl +c 退出)
实时集中log处理：pm2 logs
强大API： pm2 web
你想要监控所有被PM2管理的进程,而且同时还想监控运行这些进程的机器的状态，
[zhoujie@ops-dev uops]$ pm2 web
Launching web interface on port 9615
[PM2] Process /usr/local/node/lib/node_modules/pm2/lib/HttpInterface.js launched
[PM2] Process launched
┌────────────────────┬────┬──────┬──────┬────────┬───────────┬────────┬─────────────┬──────────┐
│ App name & & & & & │ id │ mode │ PID &│ status │ restarted │ uptime │ & & &memory │ watching │
├────────────────────┼────┼──────┼──────┼────────┼───────────┼────────┼─────────────┼──────────┤
│ app & & & & & & & &│ 0 &│ fork │ 984 &│ online │ & & & & 1 │ 9m & & │ 74.762 MB & │ disabled │
│ pm2-http-interface │ 1 &│ fork │ 1878 │ online │ & & & & 0 │ 0s & & │ 15.070 MB & │ disabled │
└────────────────────┴────┴──────┴──────┴────────┴───────────┴────────┴─────────────┴──────────┘
&Use `pm2 info &id|name&` to get more details about an app
启动程序的时候顺便在访问：https://localhost:9615
擦，我眼睛被亮瞎了，这么炫酷，竟然把部署的服务器的信息和程序的信息都显示出来了：
这东西对程序运行的监控页面的开发实在是太有帮助了，呵呵~~
　　好吧，我承认我有点失控了，前面说的有点混乱，我愿意重新把命令整理一遍：
安装：npm install -g pm2
启动程序：pm2 start &app_name|id|all&
列举进程：pm2 list
退出程序：pm2 stop &app_name|id|all&
重起应用：pm2 restart
程序信息：pm2 describe id|all
监控：pm2 monit
实时集中log处理: pm2 logs
API:pm2 web (端口：9615 )最近在项目中使用了Node，在程序部署的时候直接使用命令：node app.js ，这样我们的程序就可以host起来了，但是只要dos窗口关掉之后node就关闭了，这使得我们很不方便，于是乎发现了pm2这个东东，这到底是个什么东东呢，请看下面介绍：
pm2 是一个带有负载均衡功能的Node应用的进程管理器.当你要把你的独立代码利用全部的服务器上的所有CPU，并保证进程永远都活着，0秒的重载， PM2是完美的。
主要特性：内建负载均衡（使用Node cluster 集群模块）后台运行0秒停机重载，我理解大概意思是维护升级的时候不需要停机.具有Ubuntu和CentOS 的启动脚本停止不稳定的进程（避免无限循环）控制台检测提供 HTTP API远程控制和实时的接口API ( Nodejs 模块,允许和PM2进程管理器交互 )测试过Nodejs v0.11 v0.10 v0.8版本，兼容CoffeeScript,基于Linux 和MacOS.安装npm install -g pm2用法$ npm install pm2 -g
# 命令行安装 pm2 $ pm2 start app.js -i 4 #后台运行pm2，启动4个app.js &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&# 也可以把'max' 参数传递给 start&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&# 正确的进程数目依赖于Cpu的核心数目$ pm2 start app.js --name my-api # 命名进程$ pm2 list
# 显示所有进程状态$ pm2 monit
# 监视所有进程$ pm2 logs
显示所有进程日志$ pm2 stop all
# 停止所有进程$ pm2 restart all
# 重启所有进程$ pm2 reload all
# 0秒停机重载进程 (用于 NETWORKED 进程)$ pm2 stop 0
# 停止指定的进程$ pm2 restart 0
# 重启指定的进程$ pm2 startup
# 产生 init 脚本 保持进程活着$ pm2 web
# 运行健壮的 computer API endpoint ()$ pm2 delete 0
# 杀死指定的进程$ pm2 delete all
# 杀死全部进程运行进程的不同方式：$ pm2 start app.js -i max
# 根据有效CPU数目启动最大进程数目$ pm2 start app.js -i 3
# 启动3个进程$ pm2 start app.js -x
#用fork模式启动 app.js 而不是使用 cluster$ pm2 start app.js -x -- -a 23
# 用fork模式启动 app.js 并且传递参数 (-a 23)$ pm2 start app.js --name serverone
# 启动一个进程并把它命名为 serverone$ pm2 stop serverone
# 停止 serverone 进程$ pm2 start app.json
# 启动进程, 在 app.json里设置选项$ pm2 start app.js -i max -- -a 23
#在--之后给 app.js 传递参数$ pm2 start app.js -i max -e err.log -o out.log
# 启动 并 生成一个配置文件你也可以执行用其他语言编写的app
( fork 模式):$ pm2 start my-bash-script.sh
-x --interpreter bash$ pm2 start my-python-script.py -x --interpreter python
常用命令执行之后界面如下：
pm2 start app.js
重启：pm2 restart app.js
　　　　　　　　　　　　　　　　
pm2 list列出由pm2管理的所有进程信息，还会显示一个进程会被启动多少次，因为没处理的异常。
pm2 monit监视每个node进程的CPU和内存的使用情况。
顺便整理几个常用的dos命令：
在Windows环境下，用netstat命令查看某个端口号是否占用，为哪个进程所占用.
操作：操作分为两步：
（1）查看该端口被那个PID所占用;方法一：有针对性的查看端口，使用命令
Netstat &ano|findstr &&端口号&&,如图，最后一列为PID。图中的端口号为1068，所对应的PID为3840。
（2）查看该PID对应的进程名称。
& &用命令查找，tasklist|findstr &&PID号&&
&然后找到进程号执行：taskkill /pid 1688 /F
&成功: 已终止 PID 为 1688 的进程。
阅读(...) 评论()& 解读Nodejs多核处理模块cluster
解读Nodejs多核处理模块cluster
，将介绍如何利Javascript做为服务端脚本，通过Nodejs框架web开发。Nodejs框架是基于V8的引擎，是目前速度最快的Javascript引擎。chrome浏览器就基于V8，同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express，可以帮助我们迅速建立web站点，比起PHP的开发效率更高，而且学习曲线更低。非常适合小型网站，个性化网站，我们自己的Geek网站！！
张丹(Conan), 程序员Java,R,PHP,Javascript
weibo：@Conan_Z
转载请注明出处：
大家都知道nodejs是一个单进程单线程的服务器引擎，不管有多么的强大硬件，只能利用到单个CPU进行计算。所以，有人开发了第三方的cluster，让node可以利用多核CPU实现并行。
随着nodejs的发展，让nodejs上生产环境，就必须是支持多进程多核处理！在V0.6.0版本，Nodejs内置了cluster的特性。自此，Nodejs终于可以作为一个独立的应用开发解决方案，映入大家眼帘了。
cluster介绍
cluster的简单使用
cluster的工作原理
cluster的API
master和worker的通信
用cluster实现负载均衡(Load Balance) — win7失败
用cluster实现负载均衡(Load Balance) — ubuntu成功
cluster负载均衡策略的测试
1. cluster介绍
cluster是一个nodejs内置的模块，用于nodejs多核处理。cluster模块，可以帮助我们简化多进程并行化程序的开发难度，轻松构建一个用于负载均衡的集群。
2. cluster的简单使用
我的系统环境
win7 64bit
Nodejs:v0.10.5
Npm:1.2.19
在win的环境中，我们通过cluster启动多核的node提供web服务。
新建工程目录：
~ D:\workspace\javascript>mkdir nodejs-cluster && cd nodejs-cluster
新建文件：app.js
~ vi app.js
var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().
if (cluster.isMaster) {
console.log("master start...");
// Fork workers.
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
cluster.on('listening',function(worker,address){
console.log('listening: worker ' + worker.process.pid +', Address: '+address.address+":"+address.port);
cluster.on('exit', function(worker, code, signal) {
console.log('worker ' + worker.process.pid + ' died');
http.createServer(function(req, res) {
res.writeHead(200);
res.end("hello world\n");
}).listen(0);
在控制台启动node程序
~ D:\workspace\javascript\nodejs-cluster>node app.js
master start...
listening: worker 2368, Address: 0.0.0.0:57132
listening: worker 1880, Address: 0.0.0.0:57132
listening: worker 1384, Address: 0.0.0.0:57132
listening: worker 1652, Address: 0.0.0.0:57132
master是总控节点，worker是运行节点。然后根据CPU的数量，启动worker。我本地是双核双通道的CPU，所以被检测为4核，启动了4个worker。
3. cluster的工作原理
每个worker进程通过使用child_process.fork()函数，基于IPC（Inter-Process Communication，进程间通信），实现与master进程间通信。
当worker使用server.listen（...）函数时 ，将参数序列传递给master进程。如果master进程已经匹配workers，会将传递句柄给工人。如果master没有匹配好worker，那么会创建一个worker，再传递并句柄传递给worker。
在边界条件，有3个有趣的行为：
注：下面server.listen()，是对底层“http.Server-->net.Server”类的调用。
1. server.listen({fd: 7}):在master和worker通信过程，通过传递文件，master会监听“文件描述为7”，而不是传递“文件描述为7”的引用。
2. server.listen(handle):master和worker通信过程，通过handle函数进行通信，而不用进程联系
3. server.listen(0):在master和worker通信过程，集群中的worker会打开一个随机端口共用，通过socket通信，像上例中的57132
当多个进程都在 accept() 同样的资源的时候，操作系统的负载均衡非常高效。Node.js没有路由逻辑，worker之间没有共享状态。所以，程序要设计得简单一些，比如基于内存的session。
因为workers都是独力运行的，根据程序的需要，它们可以被独立删除或者重启，worker并不相互影响。只要还有workers存活，则master将继续接收连接。Node不会自动维护workers的数目。我们可以建立自己的连接池。
4. cluster的API
官网地址：
cluster对象
cluster的各种属性和函数
cluster.setttings:配置集群参数对象
cluster.isMaster:判断是不是master节点
cluster.isWorker:判断是不是worker节点
Event: 'fork': 监听创建worker进程事件
Event: 'online': 监听worker创建成功事件
Event: 'listening': 监听worker向master状态事件
Event: 'disconnect': 监听worker断线事件
Event: 'exit': 监听worker退出事件
Event: 'setup': 监听setupMaster事件
cluster.setupMaster([settings]): 设置集群参数
cluster.fork([env]): 创建worker进程
cluster.disconnect([callback]): 关闭worket进程
cluster.worker: 获得当前的worker对象
cluster.workers: 获得集群中所有存活的worker对象
worker对象
worker的各种属性和函数：可以通过cluster.workers, cluster.worket获得。
worker.id: 进程ID号
worker.process: ChildProcess对象
worker.suicide: 在disconnect()后，判断worker是否自杀
worker.send(message, [sendHandle]): master给worker发送消息。注：worker给发master发送消息要用process.send(message)
worker.kill([signal='SIGTERM']): 杀死指定的worker，别名destory()
worker.disconnect(): 断开worker连接，让worker自杀
Event: 'message': 监听master和worker的message事件
Event: 'online': 监听指定的worker创建成功事件
Event: 'listening': 监听master向worker状态事件
Event: 'disconnect': 监听worker断线事件
Event: 'exit': 监听worker退出事件
5. master和worker的通信
实现cluster的API，让master和worker相互通信。
新建文件: cluster.js
~ vi cluster.js
var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().
if (cluster.isMaster) {
console.log('[master] ' + "start master...");
for (var i = 0; i < numCPUs; i++) {
var wk = cluster.fork();
wk.send('[master] ' + 'hi worker' + wk.id);
cluster.on('fork', function (worker) {
console.log('[master] ' + 'fork: worker' + worker.id);
cluster.on('online', function (worker) {
console.log('[master] ' + 'online: worker' + worker.id);
cluster.on('listening', function (worker, address) {
console.log('[master] ' + 'listening: worker' + worker.id + ',pid:' + worker.process.pid + ', Address:' + address.address + ":" + address.port);
cluster.on('disconnect', function (worker) {
console.log('[master] ' + 'disconnect: worker' + worker.id);
cluster.on('exit', function (worker, code, signal) {
console.log('[master] ' + 'exit worker' + worker.id + ' died');
function eachWorker(callback) {
for (var id in cluster.workers) {
callback(cluster.workers[id]);
setTimeout(function () {
eachWorker(function (worker) {
worker.send('[master] ' + 'send message to worker' + worker.id);
Object.keys(cluster.workers).forEach(function(id) {
cluster.workers[id].on('message', function(msg){
console.log('[master] ' + 'message ' + msg);
} else if (cluster.isWorker) {
console.log('[worker] ' + "start worker ..." + cluster.worker.id);
process.on('message', function(msg) {
console.log('[worker] '+msg);
process.send('[worker] worker'+cluster.worker.id+' received!');
http.createServer(function (req, res) {
res.writeHead(200, {"content-type": "text/html"});
res.end('worker'+cluster.worker.id+',PID:'+process.pid);
}).listen(3000);
控制台日志：
~ D:\workspace\javascript\nodejs-cluster>node cluster.js
[master] start master...
[worker] start worker ...1
[worker] [master] hi worker1
[worker] start worker ...2
[worker] [master] hi worker2
[master] fork: worker1
[master] fork: worker2
[master] fork: worker3
[master] fork: worker4
[master] online: worker1
[master] online: worker2
[master] message [worker] worker1 received!
[master] message [worker] worker2 received!
[master] listening: worker1,pid:6068, Address:0.0.0.0:3000
[master] listening: worker2,pid:1408, Address:0.0.0.0:3000
[master] online: worker3
[worker] start worker ...3
[worker] [master] hi worker3
[master] message [worker] worker3 received!
[master] listening: worker3,pid:3428, Address:0.0.0.0:3000
[master] online: worker4
[worker] start worker ...4
[worker] [master] hi worker4
[master] message [worker] worker4 received!
[master] listening: worker4,pid:6872, Address:0.0.0.0:3000
[worker] [master] send message to worker1
[worker] [master] send message to worker2
[worker] [master] send message to worker3
[worker] [master] send message to worker4
[master] message [worker] worker1 received!
[master] message [worker] worker2 received!
[master] message [worker] worker3 received!
[master] message [worker] worker4 received!
6. 用cluster实现负载均衡(Load Balance) -- win7失败
新建文件: server.js
~ vi server.js
var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().
if (cluster.isMaster) {
console.log('[master] ' + "start master...");
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
cluster.on('listening', function (worker, address) {
console.log('[master] ' + 'listening: worker' + worker.id + ',pid:' + worker.process.pid + ', Address:' + address.address + ":" + address.port);
} else if (cluster.isWorker) {
console.log('[worker] ' + "start worker ..." + cluster.worker.id);
http.createServer(function (req, res) {
console.log('worker'+cluster.worker.id);
res.end('worker'+cluster.worker.id+',PID:'+process.pid);
}).listen(3000);
启动服务器：
~ D:\workspace\javascript\nodejs-cluster>node server.js
[master] start master...
[worker] start worker ...1
[worker] start worker ...2
[master] listening: worker1,pid:1536, Address:0.0.0.0:3000
[master] listening: worker2,pid:5920, Address:0.0.0.0:3000
[worker] start worker ...3
[master] listening: worker3,pid:7156, Address:0.0.0.0:3000
[worker] start worker ...4
[master] listening: worker4,pid:2868, Address:0.0.0.0:3000
用curl工具访问
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
C:\Users\Administrator>curl localhost:3000
worker4,PID:2868
我们发现了cluster在win中的bug，只用到worker4。果断切换到Linux测试。
7. 用cluster实现负载均衡(Load Balance) -- ubuntu成功
Linux的系统环境
Linux: Ubuntu 12.04.2 64bit Server
Node: v0.11.2
Npm: 1.2.21
构建项目:不多解释
~ cd :/home/conan/nodejs/
~ mkdir nodejs-cluster && cd nodejs-cluster
~ vi server.js
var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().
if (cluster.isMaster) {
console.log('[master] ' + "start master...");
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
cluster.on('listening', function (worker, address) {
console.log('[master] ' + 'listening: worker' + worker.id + ',pid:' + worker.process.pid + ', Address:' + address.address + ":" + address.port);
} else if (cluster.isWorker) {
console.log('[worker] ' + "start worker ..." + cluster.worker.id);
http.createServer(function (req, res) {
console.log('worker'+cluster.worker.id);
res.end('worker'+cluster.worker.id+',PID:'+process.pid);
}).listen(3000);
启动服务器
conan@conan-deskop:~/nodejs/nodejs-cluster$ node server.js
[master] start master...
[worker] start worker ...1
[master] listening: worker1,pid:2925, Address:0.0.0.0:3000
[worker] start worker ...3
[master] listening: worker3,pid:2931, Address:0.0.0.0:3000
[worker] start worker ...4
[master] listening: worker4,pid:2932, Address:0.0.0.0:3000
[worker] start worker ...2
[master] listening: worker2,pid:2930, Address:0.0.0.0:3000
用curl工具访问
C:\Users\Administrator>curl 192.168.1.20:3000
worker4,PID:2932
C:\Users\Administrator>curl 192.168.1.20:3000
worker2,PID:2930
C:\Users\Administrator>curl 192.168.1.20:3000
worker1,PID:2925
C:\Users\Administrator>curl 192.168.1.20:3000
worker3,PID:2931
C:\Users\Administrator>curl 192.168.1.20:3000
worker4,PID:2932
C:\Users\Administrator>curl 192.168.1.20:3000
worker2,PID:2930
C:\Users\Administrator>curl 192.168.1.20:3000
worker1,PID:2925
在Linux环境中，cluster是运行正确的！！！
8. cluster负载均衡策略的测试
我们在Linux下面，完成测试，用过测试软件： siege
~ sudo apt-get install siege
启动node cluster
~ node server.js > server.log
运行siege启动命令,每秒50个并发请求。
~ sudo siege -c 50 http://localhost:3000
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.01 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.01 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.02 secs:
16 bytes ==> /
HTTP/1.1 200
0.00 secs:
16 bytes ==> /
HTTP/1.1 200
0.02 secs:
16 bytes ==> /
HTTP/1.1 200
0.01 secs:
16 bytes ==> /
HTTP/1.1 200
0.01 secs:
16 bytes ==> /
Lifting the server siege...
Transactions:
Availability:
Elapsed time:
39.66 secs
Data transferred:
Response time:
Transaction rate:
94.81 trans/sec
Throughput:
0.00 MB/sec
Concurrency:
Successful transactions:
Failed transactions:
Longest transaction:
Shortest transaction:
FILE: /var/siege.log
You can disable this annoying message by editing
the .siegerc file in change
the directive 'show-logfile' to false.
我们统计结果，执行3760次请求，消耗39.66秒，每秒处理94.81次请求。
查看server.log文件,
-rw-rw-r-- 1 conan conan
9月 28 15:48 server.js
-rw-rw-r-- 1 conan conan 50313
9月 28 16:26 server.log
~ tail server.log
最后，用R语言分析一下:server.log
> df summary(df)
worker1:1559
worker2:1579
worker3:1570
worker4:1535
我们看到，请求被分配到worker数据量相当。所以，cluster的负载均衡的策略，应该是随机分配的。
好了，我们又学了一个很有用的技能！利用cluster可以构建出多核应用，充分的利用多CPU带业的性能吧！！
转载请注明出处：
This entry was posted in ,
Pingback: ()
Designed by