IT序号网

node 集群与稳定知识解答

flyfish 2021年05月25日 编程语言 148 0

node集群搭建好之后,还需要考虑一些细节问题。

  • 性能问题
  • 多个工作进程的存活状态管理
  • 工作进程的平滑重启
  • 配置或者静态数据的动态重新载入
  • 其它细节

1 进程事件

Node子进程对象除了send()方法和messge事件外,还有如下事件:

  • error: 当子进程无法被复制创建、无法被杀死、无法发送消息时会触发改事件。
  • exit:子进程退出时触发改事件,子进程如果是正常退出,这个事件的第一个参数为退出码,否则为null。如果进程是通过kill方法被杀死的,会得到第二个参数,它表示杀死进程时
    的信号。
  • close:在子进程的标准输入输出流中止时触发该事件,参数与exit相同。
  • disconnect:在父进程或子进程中调用disconnect()方法时触发该事件,在调用该方法时将关闭监听IPC通道。

上述这些事件是在父进程能监听到的与子进程相关的事件。除了send()外,还能通过kill()方法给子进程发送消息。kill()方法并不能真正的将通过IPC相连的子进程杀死,它只是给子进程发送
了一个系统信号。默认情况下,父进程将通过kill()方法给子进程发送一个SIGTERM信号。它与进程默认的kill()方法类似。

// 子进程 
child.kill([signal]); 
 
// 当前进程 
process.kill(pid, [signal]);

2 自动重启

有了父子进程之间的相关事件后,就可以在这些关系之间创建出需要的机机制了。监听子进程的exit事件来获知其退出的信息,并在主进程中加入一些子进程管理的机制,比如重新启用一个

新的工作进程来继续服务。

实现代码如下所示:

master.js

var fork = require('child_process').fork; 
var cpus = require('os').cpus(); 
 
var server = require('net').createServer(); 
server.listen(1337, () => { 
    console.log('server listen at port 1337'); 
}) 
 
var workers = {}; 
var createWorker = function() { 
    var worker = fork(__dirname + '/worker.js'); 
    // 退出时重新启动新的进程 
    worker.on('exit', () => { 
        console.log('Worker ' + worker.pid + ' exited'); 
        delete workers[worker.pid]; 
        createWorker(); 
    }) 
    // 句柄转发 
    worker.send('server', server); 
    workers[worker.pid] = worker; 
    console.log('Create worker. pid: ' + worker.pid); 
} 
 
for (var i = 0; i < cpus.length; i++) { 
    createWorker(); 
} 
 
 
// 进程自己退出时,让所有工作进程退出 
process.on('exit', () => { 
    for (var pid in workers) { 
        workers[pid].kill(); 
    } 
})

worker.js

var http = require('http'); 
var server = http.createServer((req, res) => { 
    res.writeHead(200, { 
        'Content-Type': 'text/plain' 
    }); 
    res.end('handled by child, pid is ' + process.pid + '\n'); 
}); 
 
var worker; 
process.on('message', (m, tcp) => { 
    if (m === 'server') { 
        worker = tcp; 
        worker.on('connection', (socket) => { 
            server.emit('connection', socket); 
        }) 
    } 
}) 
 
process.on('uncaughtException', () => { 
    // 停止接受新的连接 
    worker.close(() => { 
        //所有已有的链接断开后,退出进程 
        process.exit(1); 
    }); 
})

上述代码的处理流程是,一旦有未捕获的异常出现,工作进程就会立即停止接收新的连接;当所有连接断开后,退出进程。主进程在侦听到工作进程的exit后,将会立即启动新的进程服务,以此

保证整个集群中总是有进程在为用户服务的。

2.1 自杀信号

  上述代码存在的问题是要等到所有连接断开后进程才退出,在极端情况下,所有工作进程都停止接收新的连接,全处在等待退出的状态。但在等到进程完全退出才重启的过程中,所有新来的请求

可能存在没有工作进程为新用户服务的情景,这会丢掉大部分请求。

  为此需要改进这个过程,不能等到工作进程退出后才重启新的工作进程。当然也不能暴力退出进程,因为这样会导致已连接的用户直接断开。于是在退出的流程中增加一个自杀连接,当所有的连接断开后才退出。主进程在接收到自杀信号后,立即创建新的工作进程服务。代码改动如下:

// worker.js 
process.on('uncaughtException', () => { 
    process.send({act: 'suicide'}); 
    // 停止接受新的连接 
    worker.close(() => { 
        //所有已有的链接断开后,退出进程 
        process.exit(1); 
    }); 
}) 
 
// master.js 
var createWorker = function() { 
    var worker = fork(__dirname + '/worker.js'); 
    // 启动新的进程 
    worker.on('message', (message) => { 
        if (message.act === 'suicide') { 
            createWorker(); 
        } 
    }); 
    // 退出时重新启动新的进程 
    worker.on('exit', () => { 
        console.log('Worker ' + worker.pid + ' exited'); 
        delete workers[worker.pid]; 
    }) 
    // 句柄转发 
    worker.send('server', server); 
    workers[worker.pid] = worker; 
    console.log('Create worker. pid: ' + worker.pid); 
}

至此我们完成了进程的平滑重启,一旦有异常出现,主进程就会创建新的工作进程来为用户服务,旧的进程一旦处理完了已有连接就自动断开。整个过程使得我们的应用稳定性和健壮性大大提高。

这里存在问题的是有可能我们的连接是长连接,不是HTTP服务的这种短连接,等待长时间断开可能需要较久的时间。为此为已有连接的断开设置一个超时时间是必要的,在限定时间里强制退出。

// worker.js 
process.on('uncaughtException', () => { 
    process.send({act: 'suicide'}); 
    // 停止接受新的连接 
    worker.close(() => { 
        //所有已有的链接断开后,退出进程 
        process.exit(1); 
    }); 
    // 5秒后退出 
    setTimeout(() => { 
        process.exit(1); 
    }, 5000) 
})

进程中如果出现未能捕获的异常,就意味着有那么一段代码在健壮性上是不合格的。为此退出进程前,通过日志记录下问题所在是必须要做的事情,它可以帮我们很好地定位和追踪代码异常出现的位置,如下所示:

process.on('uncaughtException', (err) => { 
    // 记录日志 
    logger.error(err); 
    process.send({act: 'suicide'}); 
    // 停止接受新的连接 
    worker.close(() => { 
        //所有已有的链接断开后,退出进程 
        process.exit(1); 
    }); 
    // 5秒后退出 
    setTimeout(() => { 
        process.exit(1); 
    }, 5000) 
})

2.2 限量重启

通过自杀信号告知主进程可以使得新连接总是有进程服务,但是依然还是有极端的情况。工作进程不能无限制的被重启,如果启动的过程中就发生了错误,或者启动后接到连接就收到错误,

会导致工作进程被频繁重启,这种频繁重启不属于我们捕捉未知异常的情况,因为这种短时间内频繁重启已经不符合预期的设置,极有可能是程序编写的错误。

为了消除这种无意义的重启,在满足一定规则的限制下,不应当反复重启。比如在单位时间内规定只能重启多少次,超过限制就触发giveup事件,告知放弃重启工作进程这个重要事情。

为了完成限量重启的统计,引入一个队列来做标记,在每次重启工作进程之间进行打点并判断重启是否太过频繁,如下所示:

var fork = require('child_process').fork; 
var cpus = require('os').cpus(); 
 
var server = require('net').createServer(); 
server.listen(1337, () => { 
    console.log('server listen at port 1337'); 
}) 
 
// 重启次数 
var limit = 10; 
// 时间单位 
var during = 60000; 
var restart = []; 
var isTooFrequently = function() { 
    // 记录重启时间 
    var time = Date.now(); 
    var length = restart.push(time); 
    if (length > limit) { 
        // 取出最后10个记录 
        restart = restart.slice(limit * -1); 
    } 
    //最后一次重启到前10次重启之间的时间间隔 
    return restart.length >= limit && restart[restart.length - 1] - restart[0] < during; 
} 
 
var workers = {}; 
var createWorker = function() { 
    // 检查是否太过频繁 
    if (isTooFrequently()) { 
        // 触发giveup事件后,不再重启 
        process.emit('giveip', length, during); 
        return; 
    }  
    var worker = fork(__dirname + '/worker.js'); 
    // 启动新的进程 
    worker.on('message', (message) => { 
        if (message.act === 'suicide') { 
            createWorker(); 
        } 
    }); 
    // 退出时重新启动新的进程 
    worker.on('exit', () => { 
        console.log('Worker ' + worker.pid + ' exited'); 
        delete workers[worker.pid]; 
    }) 
    // 句柄转发 
    worker.send('server', server); 
    workers[worker.pid] = worker; 
    console.log('Create worker. pid: ' + worker.pid); 
} 
 
for (var i = 0; i < cpus.length; i++) { 
    createWorker(); 
} 
 
 
// 进程自己退出时,让所有工作进程退出 
process.on('exit', () => { 
    for (var pid in workers) { 
        workers[pid].kill(); 
    } 
})

giveup事件是比uncaughtException更严重的异常事件。uncaughtException只代表集群中某个工作进程退出,在整体性保证下,不会出现用户得不到服务的情况,但是这个giveup事件则表示

集群中没有任何进程服务了,十分危险。为了健壮性了考虑,我们应在giveup事件中添加重要日志,并让监控系统监视到这个严重错误,进而报警等。

3 负载均衡

  在多进程之间监听相同的接口,使得请求能够分散到多个进程上进行处理,这带来的好处是可以将CPU资源都调用起来。Node默认提供的机制是采用操作系统的抢占式策略。所谓的抢占式就是

在一堆工作进程中,闲着的进程对到来的请求进行争抢,谁抢到谁服务。

  一般而言,这种抢占式策略对大家是公平的,各个进程可以根据自己的繁忙度来进行抢占。但是对于node而言,需要分清的是它的繁忙是有CPU、I/O两个部分构成的,影响抢占的是CPU的繁忙度。对于不同的业务,可能存在I/O繁忙,而CPU较为空闲的情况,这可能造成某个进程能够抢到较多请求,形成负载不均衡的情况。

  为此Node在v0.11中提供了一种新的策略使得负载均衡更合理,这种新的策略叫Round-Robin,又叫轮叫调度轮叫调度的工作方式是由主进程接受连接,将其一次分发给工作进程。分发的策略

是在N个工作进程中,每次选择第i = ( i + 1 ) mod n个进程来发送连接。

  Round-Robin非常简单,可以避免CPU和I/O繁忙差异导致的负载不均衡。Round-Robin策略也可以通过代理服务来实现,但是它会导致服务器上消耗的文件描述符是平常方式的两倍。


发布评论
IT序号网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

node child_process模块知识解答
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。