最后更新于 .

最近需要给一个现网server增加过载保护的功能,借此机会也思考了很多,简单谈谈我对这两个概念的理解和实现方法。
一.负载均衡
简单来说,就是按照目标server的参数进行合理分配,这个参数可以是失败率,也可以是响应时间,也可以是请求量,甚至是随机数。
我们来按照从简单到复杂逐个看一下几种实现。
1.轮询式
逻辑比较简单,直接看代码:


vector vecServer;
while(1)
{
Server* server = vecServer[curIndex % vecServer.size()];
curIndex ++;
}

如上代码就是一个简单的轮询式分配方法,这种方法优点实现简单,cpu计算少,缺点就是无法动态判断server的状态,当后端有一台server挂掉的时候,会至少1/vecServer.size()的请求。(最为严重的情况是由于单台后端server的超时导致前段全部挂死)。而且这种分配方法有一个bug,就是当每次请求结束后就释放内存,那么curIndex永远都只会为0,即每次都请求第一个server。

2.定死权重式

这种方式适用于那种需要实现就规定后端server的权重,比如A比Bserver的响应速度快,我们希望A接受的请求比B多。


//假设A,B, C server的权重分别为 10 5 2
typedef struct _serverinfo
{
//server 指针
Server* server;
//权重
int weight;
}ServerInfo;

vector vecServer;
vecServer.push_back(A);
vecServer.push_back(B);
vecServer.push_back(C);

vector vecWeight;
for (unsigned i = 0; i < vecServer.size(); i++)
{
vecWeight.insert(vecWeight.end(),vecServer[i]->weight,i);
}
while(1)
{
index = vecWeight[random() % vecWeight.size()];
Server* server = vecServer[index].server;
}


上面的代码也比较好理解,一共有两个数组,一个是server信息数组vecServer,一个是权重数组vecWeight。在分配server时,先通过权重数组vecWeight获取到server信息数组的下标,然后分配server。

这样的做法在我1年半写的一个项目是有使用的,经过统计效果是很不错的,基本是访问量是严格按照权重比分配的。这样做的cpu消耗也不高,但是缺点也是显而易见的,就是还是没有办法动态调整权重,需要人为去修改。所以我们接下来看第三种。

3.动态调整权重

要讨论这种方法前,我们先要明确几个希望使用他的原因:


1.我们希望server能够自动按照运行状态进行按照权重的选择
2.我们不希望手工去配置权重变化

然后是我们实现方法,很明显,我们需要一个基准来告诉我们这台server是否是正常的。这个基准是什么,是历史累计的平均值。比如如果是按照响应时间分配权重,那么就是所有后端server历史累计的平均响应时间,如果是错误率也是如此。

那么一旦调整了权重,我们什么时候来调整权重呢,调整比例是怎样呢?按照我的经验,一般是隔一段固定时间才进行调整,如果正常但是权重过低,那么就按照20%的比例恢复;如果server不正常,那么直接按照当前server响应时间/历史平均响应时间进行降权。这里的逻辑之所以不一样是有原因的,因为服务出现问题的时候,我们是能够知道这坏的程度有多少的,就是当前server响应时间/历史平均响应时间进行降权;但是要恢复的时候,你并不能保证server能够支撑到多大的访问量,所以只能按照20%放量来试。也避免滚雪球效应的发生。

我们来看一下代码。

typedef struct _serverinfo
{
unsigned _svr_ip; //目标主机
float _cfg_wt; //配置的权重
float _cur_wt; //当前实际权重
int _req_count; //请求数
float _rsp_time; //请求总响应时间
float _rsp_avg_time; //请求平均响应时间
int _rsp_error; //请求错误数
}ServerInfo;

vector vecServer;
int total_rsp_time = 0;
int total_req_count = 0;

unsigned int comWeight = 100;
unsigned int MaxWeight = 1000;
while(1)
{
//按照文中第二种方式进行server分配
serverInfo._req_count++;
serverInfo._rsp_time+=rsp_time;//响应时间

total_req_count++;
total_rsp_time += rsp_time;

if(! 需要重建权重)
{
continue;
}

float total_rsp_avg_time = (float)total_rsp_time / (float)total_req_count;
for(vector::iterator it = vecServer.begin();it!=vecServer.end();++it)
{
it->_rsp_avg_time = (float)it->_rsp_time / (float)it->_req_count;
if(it->_rsp_avg_time > total_rsp_avg_time)
{
it->_cur_wt = int(comWeight*total_rsp_avg_time/it->_rsp_avg_time);
}
else
{
it->_cur_wt *= 1.2;
}
it->_cur_wt = it->_cur_wt < MaxWeight ? it->_cur_wt : MaxWeight;
}

//按照文中第二种方式重建权重数组
}

以上基本展示了动态调整的过程,代码可能只是起演示作用,很多比如越界的检测都没有做,大家参照就好~

OK,到这里我们基本就结束了负载均衡的讨论了,但是还有一个话题:过载保护。

二.过载保护

关于过载保护其实经常适合负载均衡结合在一起使用的,但有两个问题:


1.过载参照的基准是谁。
是上面代码中的total_rsp_avg_time吗?
不是,因为除非所有机器的正常性能完全一样,
否则不可以拿total_rsp_avg_time来作为某台机器的负载基准。
而能拿来做参照的,只有这台server自身的历史累计值。
2.怎么实现过载保护。其实很简单,我们定义两个值_cur_max_queue_cnt和_queue_req_cnt,
意义分别是这个server上在一段时间内允许分配的最多次数和当前已经排队的个数。
_cur_max_queue_cnt值是通过当前时间段响应时间和历史累计时间算出来的。
每次使用分配的server前,都要判断一下_queue_req_cnt是否达到了_cur_max_queue_cnt,
如果达到了,分配失败。否则分配成功并且_queue_req_cnt++。

代码如下:

typedef struct _serverinfo
{
unsigned _svr_ip; //目标主机
float _cfg_wt; //配置的权重
float _cur_wt; //当前实际权重
int _req_count; //请求数
float _rsp_time; //请求总响应时间
float _rsp_avg_time; //请求平均响应时间
int _rsp_error; //请求错误数

int _total_req_count; //总的请求数
float _total_rsp_avg_time; //总的请求平均响应时间
int _total_rsp_error; //总的请求错误数
float _total_rsp_time; //总的请求时间

float _cur_max_queue_cnt; //当前实际允许的最大排队请求数
int _queue_req_cnt; //当前排队请求数

}ServerInfo;

float comxQueueSize = 1000;
float maxQueueSize = 10000;
while(1)
{
//按照文中第二种方式进行server分配

if(serverInfo._queue_req_cnt > serverInfo._cur_max_queue_cnt)
{
//分配失败
continue;
}
serverInfo._queue_req_cnt ++;

serverInfo._req_count++;
serverInfo._rsp_time+=rsp_time;//响应时间

serverInfo._total_req_count++;
serverInfo._total_rsp_time+=rsp_time;//响应时间

total_req_count++;
total_rsp_time += rsp_time;

if(! 需要重建权重)
{
continue;
}

//按照第三种方法重新分配权重
//按照文中第二种方式重建权重数组

//其实和上面的循环合并成一个
for(vector::iterator it = vecServer.begin();it!=vecServer.end();++it)
{
it->_total_rsp_avg_time = (float)it->_total_rsp_time / (float)it->_total_req_count;
if(it->_rsp_avg_time > it->_total_rsp_avg_time)
{
it->_cur_max_queue_cnt = int(comxQueueSize*it->_total_rsp_avg_time/it->_rsp_avg_time);
}
else
{
it->_cur_max_queue_cnt *= 1.2;
}
it->_cur_max_queue_cnt = it->_cur_max_queue_cnt < maxQueueSize ? it->_cur_max_queue_cnt : maxQueueSize;
it->_queue_req_cnt = 0;
}

}


上面的代码为了演示方便,所以把两个for循环拆开了,实际上是应该合到一个里面写的。

OK,就是这样,大家如果有不同的想法欢迎提出。

Pingbacks

Pingbacks已打开。

Trackbacks

引用地址

评论

  1. hwywhywl

    hwywhywl on #

    博主帮忙看看
    "-------------.vimrc reload setting--------
    let mapleader = ','

    nmap ss :source ~/.vimrc

    nmap ee :ee ~/.vimrc

    autocmd! bufwritepost .vimrc source ~/.vimrc
    这几句 执行 ,ss ,ee
    vim 提示 E492: Not an editor command: ,ss

    Reply

    1. Dante

      Dante on #

      呃,你这是映射了
      ee 这个命令。。。
      不是,ee

      Reply

      1. hwywhywl

        hwywhywl on #

        都不行 ee 也还是出现类似得错误

        Reply

        1. Dante

          Dante on #

          nmap ee :ee ~/.vimrc
          这句你是想写:
          nmap ee :e ~/.vimrc
          吧?
          手误?

          Reply

          1. hwywhywl

            hwywhywl on #

            解决了!首先是一开始不大明白这句命令得语法,接着是手误。现在还不明白 nmap 与 map 有什么区别?

            Reply

            1. Dante

              Dante on #

              nmap是normal模式下的映射。
              而map在normal,virtual模式下都可以。

              Reply

  2. 张龙华

    张龙华 on #

    你好,请问下,如何用c++写负载均衡啊?或者有开源的项目推荐没?

    Reply

    1. 朱念洋

      朱念洋 on #

      之前都是在公司内部自己实现负载均衡的。不过基本思路就是我文章里面提到的。

      Reply

发表评论