nginx添加nginx-module-vts模块

nginx-module-vts模块主要用来监控nginx的一些流量信息

vts: vhost_traffic_status(主机运行状态)

本例子中，假定 nginx 已经安装完成(编译安装)，现在需要新增vts模块 ，可先通过ps -ef |grep nginx查看当前运行的nginx主进程号并记下

1、下载，执行命令如下：

git clone git://github.com/vozlt/nginx-module-vts.git

将文件夹nginx-module-vts移动到/usr/local/nginx路径下

2、编译nginx 并添加该模块， 编译前先查看当前的nginx已经安装的模块，避免重新编译时漏掉了 ，执行命令如下：

nginx -V //注意V是大写

3、进入nginx加压目录，带着原来的模块，再添加nginx-module-vts模块，进行编译 ，如图：

编译完成后，执行make命令，如图：

注意：不要执行make install ，否则就会将原来数据覆盖

4、 进入 nginx 安装目录，将 sbin 目录下的可执行文件备份为 nginx.old ，如图：

5、 进 入 nginx 源目录下的 objs 目 录 ，将 编译之 后 的 nginx 二进 制 文件 复 制到 /usr/local/nginx/sbin 目录下，替换原来的 nginx 可执行文件，如图：

6、 目前机器上有两个 nginx 进程，此时需要通过 nginx 信号控制方式将 nginx 二进制升级替换后的，通过 kill –USER2 `cat /opt/nginx/log/nginx.pid` (nginx.pid 中的内容即是旧的nginx主进程 pid，可通过 ps –ef |grep nginx 查看) ，如图：

再次执行下面命令，完全把旧的进程退出，启用新的进程，如下：

kill -WINCH 28647

kill -QUIT 28647

7、 执行完成后再次执行./nginx –V 可以看到模块已经添加成功，如图：

8、 编辑 nginx 配置文件，添加内容如下：

9、 重新执行 nginx 重载命令，./nginx –s reload ，然后通过页面访问如图：

vts页面左下角有个json数据接口，可以通过此接口来获取数据进行判断

下面的脚本通过python编写nginx监控插件，并通过夜莺实现监控，如下：

#!/usr/bin/python       #通过python2编写
#-*- coding:utf-8 -*-  #指定编码
'''
 @此脚本用来获取nginx的监控状态信息，json界面的各个参数说明如下:
   servermain:
      hostname: 主机名
      nginxVersion: nginx版本
      loadMsec: 以毫秒为单位的处理时间
      nowMsec: 以毫秒为单位的当前时间
      connections:
          active:     当前活动的客户端连接数
          reading:    读取客户端连接的总数
          writing:    写入客户端连接的总数
          waiting:    正在等待的客户端连接总数
          accepted:   接受的客户端连接总数
          handled:    已处理的客户端连接总数
          requests:   请求的客户端连接总数
          sharedZones:
          name:       配置中指定的共享内存名称
          maxSize:    配置中指定的共享内存的最大大小的限制
          usedSize:   共享内存的当前大小
          usedNode:   共享内存中当前使用的节点数
   serverZones:
      requestCounter: 从客户端接收的客户端请求总数
      inBytes:    从客户端接收的总字节数
      outBytes:   发送到客户端的总字节数
      responses: 
          1xx,2xx,3xx,4xx,5xx: 表示响应状态吗
          miss:       未命中的缓存数
          bypass:     绕过缓存旁路数
          expired:    过期的缓存数
          stale:      生效缓存的数量
          updating:   缓存更新的次数
          revalidated:重新验证的缓存数
          hit:        缓存命中数
          scarce:     未达缓存要求的请求次数
      requestMsecCounter: 累积的请求处理时间(毫秒)
      requestMsec:   请求处理时间的平均值(毫秒)
   upstreamZones:
       server: server地址
       requestCounter: 转发到此服务器的客户端连接总数
       inBytes: 从该服务器接收的总字节数
       outBytes:发送到此服务器的总字节数
       responses:
           1xx,2xx,3xx,4xx,5xx: 表示响应状态吗
   requestMsecCounter: 包括upstream在内的累计请求处理时间数(毫秒)
   requestMsec:
       time: 请求处理时间
       msecs: 包括upstream在内的请求处理时间
   responseMsecCounter: 仅upstream响应处理时间累加值(毫秒)
   responseMsecs: 仅upstream响应处理时间平均值(毫秒) 
   weight:      server的当前weight值
   maxFails:    server的当前max_fails设置
   failTimeout: server的当前的fail_timeout设置
   backup:      server的当前backup设置
   down:        服务器的当前down设置
   
'''
import requests
import json
import time
import commands
class Check_Nginx:
    ''' 此来用来检测nginx指标'''
    def __init__(self,result):
        self.result = result
        print(json.dumps(self.result)) #将列表转换为字符串类型,否则夜莺不识别
def main():
    result = []
    ip = commands.getoutput('''ifconfig `route|grep '^default'|awk '{print $NF}'`|grep inet|awk '{print $2}'|head -n 1''')
    timestamp = int(time.time())
    r = requests.get('http://10.88.10.35/vhost_status/format/json')
    dictt = json.loads(r.text)  #将json数据转换为字典
    '''
    下面三行用来获取server main中的request信息
    nginx运行时间等于nowMsec-loadMsec，结果值单位为毫秒
    '''
    nowMsec = float(dictt.get('nowMsec')) #将整形转换为浮点型
    loadMsec = float(dictt.get('loadMsec'))
    nginx_uptime = round((nowMsec-loadMsec)/3600000,2)      #nginx运行时间,单位小时
    nginx_accept = dictt.get('connections').get('accepted')
    nginx_handled = dictt.get('connections').get('handled')
    nginx_requests = dictt.get('connections').get('requests')
    nginx_active = dictt.get('connections').get('active')
    nginx_reading = dictt.get('connections').get('reading')
    nginx_writing = dictt.get('connections').get('writing')
    nginx_waiting = dictt.get('connections').get('waiting')
    nginx_uptime = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.uptime',
        'value': nginx_uptime
    }
    nginx_accept = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.accept',
        'value': nginx_accept
    }
    nginx_handled = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.handled',
        'value': nginx_handled
    }
    nginx_request = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.requests',
        'value': nginx_requests
    }
    nginx_active = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.active',
        'value': nginx_active
    }
    nginx_reading = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.reading',
        'value': nginx_reading
    }
    nginx_writing = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.writing',
        'value': nginx_writing
    }
    nginx_waiting = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.waiting',
        'value': nginx_waiting
    }
    result.append(nginx_uptime)
    result.append(nginx_accept)
    result.append(nginx_handled)
    result.append(nginx_request)
    result.append(nginx_active)
    result.append(nginx_reading)
    result.append(nginx_writing)
    result.append(nginx_waiting)
    '''
    下面用来获取共享内存的使用情况
    '''
    sharememory_maxsize = dictt.get('sharedZones').get('maxSize')
    sharememory_usedsize = dictt.get('sharedZones').get('usedSize')
    sharememory_usedNode = dictt.get('sharedZones').get('usedNode')
    server_maxsize = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.sharememory.maxsize',
        'value': sharememory_maxsize
    }
    server_usedsize = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.sharememory.usedsize',
        'value': sharememory_usedsize
    }
    server_usedNode = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.sharememory.usedNode',
        'value': sharememory_usedNode
    }
    result.append(server_maxsize)
    result.append(server_usedsize)
    result.append(server_usedNode)
    '''
    下面的用来获取server zones中的信息
    '''
    server_requestCounter = dictt.get('serverZones').get('localhost').get('requestCounter')#serverzone的requests
    server_inbytes = dictt.get('serverZones').get('localhost').get('inBytes') #traffic Rcvd
    server_outbytes = dictt.get('serverZones').get('localhost').get('outBytes') #traffic send
    server_code1 = dictt.get('serverZones').get('localhost').get('responses').get('1xx')
    server_code2 = dictt.get('serverZones').get('localhost').get('responses').get('2xx')
    server_code3 = dictt.get('serverZones').get('localhost').get('responses').get('3xx')
    server_code4 = dictt.get('serverZones').get('localhost').get('responses').get('4xx')
    server_code5 = dictt.get('serverZones').get('localhost').get('responses').get('5xx')
    server_requestCounter = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.requestCounter',
        'value': server_requestCounter
    }
    server_inbytes = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.inbytes',
        'value': server_inbytes
    }
    server_outbytes = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.outbytes',
        'value': server_outbytes
    }
    server_code1 = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.1xx',
        'value': server_code1
    }
    server_code2 = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.2xx',
        'value': server_code2
    }
    server_code3 = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.3xx',
        'value': server_code3
    }
    server_code4 = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.4xx',
        'value': server_code4
    }
    server_code5 = {
        'endpoint': ip,
        'tags': '',
        'timestamp': timestamp,
        'metric': 'nginx.server.5xx',
        'value': server_code5
    }
    result.append(server_requestCounter)
    result.append(server_inbytes)
    result.append(server_outbytes)
    result.append(server_code1)
    result.append(server_code2)
    result.append(server_code3)
    result.append(server_code4)
    result.append(server_code5)
    '''下面的用来获取upstream的信息'''
    upstreamZones = dictt.get('upstreamZones').get('schedule')
    for i in upstreamZones:  #遍历列表
         get_upstreamip = i.get('server').split(':')[0]#获取代理的ip地址
         #get_upstreamip = i.get('server')#获取代理的ip地址和端口
         get_requestCounter = i.get('requestCounter')
         get_inBytes = i.get('inBytes')
         get_outBytes = i.get('outBytes')
         get_upstream_1xx = i.get('responses').get('1xx')
         get_upstream_2xx = i.get('responses').get('2xx')
         get_upstream_3xx = i.get('responses').get('3xx')
         get_upstream_4xx = i.get('responses').get('4xx')
         get_upstream_5xx = i.get('responses').get('5xx')
         get_responseMsec = i.get('responseMsec')
         get_ip = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.ip',
             'value': None,
         }
         if get_upstreamip is not None:
             get_ip['value'] = 1
         else:
             get_ip['value'] = 0
         nginx_requestCounter = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.requestCounter',
             'value': get_requestCounter
         }
         nginx_inBytes = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.inBytes',
             'value': get_inBytes
         }
         nginx_outBytes = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.outBytes',
             'value': get_outBytes
         }
         upstream_1xx = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.1xx',
             'value': get_upstream_1xx
         }
         upstream_2xx = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.2xx',
             'value': get_upstream_2xx
         }
         upstream_3xx = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.3xx',
             'value': get_upstream_3xx
         }
         upstream_4xx = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.4xx',
             'value': get_upstream_4xx
         }
         upstream_5xx = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.5xx',
             'value': get_upstream_5xx
         }
         get_responsetime = {
             'endpoint': ip,
             'tags': 'upstreamip=%s'%get_upstreamip,
             'timestamp': timestamp,
             'metric': 'nginx.upstream.responsetime',
             'value': get_responseMsec
         } 
         result.append(get_ip)
         result.append(nginx_requestCounter)
         result.append(nginx_inBytes)
         result.append(nginx_outBytes)
         result.append(upstream_1xx)
         result.append(upstream_2xx)
         result.append(upstream_3xx)
         result.append(upstream_4xx)
         result.append(upstream_5xx)
         result.append(get_responsetime)
    Check_Nginx(result)
if __name__ == '__main__':
    main()