python redis连接数_redis监控zabbix自动化模板-节点状态、内存、连接数等等

首先介绍下监控redis那些信息：

Redis ping：检验ping

Redis alive：查看检查端口是否alive

Redis connections：查看连接数

Redis blockedClients：正在等待阻塞客户端数量

Redis connectionsUsage：redis的连接使用率

Redis memoryUsage：redis内存使用量

Redis memoryUsageRate：redis内存使用率

Redis evictedKeys：运行以来删除过的key的数量

Redis rejectedConnections：拒绝连接数

Redis ops：redis的OPS

Redis hitRate：redis命中率

redis自动检测端口(shell)

#!/bin/sh

REDIS_SERVER_PIDS="$(ps -ef|egrep -v 'grep|egrep|vi|vim|find|cat|tac|head|tail|more|less'|grep 'redis-server'|awk '{print $2}')"

REDIS_PORTS=""

for pid in ${REDIS_SERVER_PIDS};do

PORTS=$(sudo netstat -anlp|grep -w ${pid}|awk '{print $4}'|awk -F: '{print $2}'|grep -v "[0-9][0-9][0-9][0-9][0-9]"|grep -v "^$" |head -1)

REDIS_PORTS="${PORTS} ${REDIS_PORTS}"

done

port=(${REDIS_PORTS})

function node_port {

length=${#port[@]}

printf "{\n"

printf '\t'"\"data\":["

for ((i=0;i

printf '\n\t\t{'

printf "\"{#REDIS_PORT}\":\"${port[$i]}\"}"

if [ $i -lt $[$length-1] ];then

printf ','

fi

done

printf "\n\t]\n"

printf "}\n"

}

node_por

redis自动检测端口(python)

#!/usr/bin/env python

import os

import json

#t=os.popen("""netstat -natp|awk -F: '/redis-server/&&/LISTEN/{print $2}'|awk '{print $1}' """)

t=os.popen("""ps aux |egrep -v 'grep|egrep|vi|vim|cat|tac|head|tail|more|less'|grep 'redis-server'|awk -F '*:' '{print $2}'|awk '{print $1}' """)

ports = []

for port in t.readlines():

r = os.path.basename(port.strip())

ports += [{'{#REDIS_PORT}':r}]

print json.dumps({'data':ports},sort_keys=True,indent=4,separators=(',',':'))

检测内存、节点状态、连接数、内存使用率、连接数使用率等等

#!/usr/bin/env python

#-*- coding: utf-8 -*-

__author__ = 'chenmingle'

import sys

import subprocess

import json

try:

import redis

except Exception, e:

print 'pip install redis'

sys.exit(1)

class Redis(object):

def __init__(self, host, port, password=None):

self.host = host

self.port = port

self.password = password

if self.password:

self.rds = redis.StrictRedis(host=host, port=port, password=self.password)

else:

self.rds = redis.StrictRedis(host=host, port=port)

try:

self.info = self.rds.info()

except Exception, e:

self.info = None

def redis_connections(self):

try:

return self.info['connected_clients']

except Exception, e:

return 0

def redis_connections_usage(self):

try:

curr_connections = self.redis_connections()

max_clients = self.parse_config('maxclients')

rate = float(curr_connections) / float(max_clients)

return "%.2f" % (rate * 100)

except Exception, e:

return 0

def redis_used_memory(self):

try:

return self.info['used_memory']

except Exception, e:

return 0

def redis_memory_usage(self):

try:

used_memory = self.info['used_memory']

max_memory = self.info['maxmemory']

system_memory = self.info['total_system_memory']

if max_memory:

rate = float(used_memory) / float(max_memory)

else:

rate = float(used_memory) / float(system_memory)

return "%.2f" % (rate * 100)

except Exception, e:

return 0

def redis_ping(self):

try:

return self.rds.ping()

except Exception, e:

return False

def rejected_connections(self):

try:

return self.info['rejected_connections']

except Exception, e:

return 999

def evicted_keys(self):

try:

return self.info['evicted_keys']

except Exception, e:

return 999

def blocked_clients(self):

try:

return self.info['blocked_clients']

except Exception, e:

return 0

def ops(self):

try:

return self.info['instantaneous_ops_per_sec']

except Exception, e:

return 0

def hitRate(self):

try:

misses = self.info['keyspace_misses']

hits = self.info['keyspace_hits']

rate = float(hits) / float(int(hits) + int(misses))

return "%.2f" % (rate * 100)

except Exception, e:

return 0

def parse_config(self, type):

try:

return self.rds.config_get(type)[type]

except Exception, e:

return None

def test(self):

print 'Redis ping: %s' % self.redis_ping()

print 'Redis alive: %s ' % check_alive(self.host, self.port)

print 'Redis connections: %s' % self.redis_connections()

print 'Redis blockedClients %s' % self.blocked_clients()

print 'Redis connectionsUsage: %s%%' % self.redis_connections_usage()

print 'Redis memoryUsage: %s' % self.redis_used_memory()

print 'Redis memoryUsageRate: %s%%' % self.redis_memory_usage()

print 'Redis evictedKeys: %s' % self.evicted_keys()

print 'Redis rejectedConnections: %s' % self.rejected_connections()

print 'Redis ops: %s' % self.ops()

print 'Redis hitRate: %s%%' % self.hitRate()

def check_alive(host, port):

cmd = 'nc -z %s %s > /dev/null 2>&1' % (host, port)

return subprocess.call(cmd, shell=True)

def parse(type, host, port, password):

rds = Redis(host, port, password)

if type == 'connections':

print rds.redis_connections()

elif type == 'connectionsUsage':

print rds.redis_connections_usage()

elif type == 'blockedClients':

print rds.blocked_clients()

elif type == 'ping':

print rds.redis_ping()

elif type == 'alive':

print check_alive(host, port)

elif type == 'memoryUsage':

print rds.redis_used_memory()

elif type == 'memoryUsageRate':

print rds.redis_memory_usage()

elif type == 'rejectedConnections':

print rds.rejected_connections()

elif type == 'evictedKeys':

print rds.evicted_keys()

elif type == 'hitRate':

print rds.hitRate()

elif type == 'ops':

print rds.ops()

else:

rds.test()

if __name__ == '__main__':

try:

type = sys.argv[1]

host = sys.argv[2]

port = sys.argv[3]

if sys.argv.__len__() >=5:

password = sys.argv[4]

else:

password = None

except Exception, e:

print "Usage: python %s type 127.0.0.1 6379" % sys.argv[0]

sys.exit(1)

parse(type, host, port, password)

###python支持redis模板否则会报错

zabbix配置配置文件添加

UserParameter=redis_port.discovery-py,/app/sinova/zabbix/scripts/check_redis_port.py

UserParameter=redis.stats[*],/app/sinova/python2.7.15/bin/python /app/sinova/zabbix/scripts/check_redis.py $1 127.0.0.1 $2

###配置完重启zabbix否则不生效

zabbix模板配置

自动发现规则

###配置监控相项把以上需要监控配置即可

例子

redis.stats[memoryUsageRate,{#REDIS_PORT}]

{HOST.NAME}:{#REDIS_PORT} redis redis 连接数使用率>80%，达到{ITEM.LASTVALUE1}

{Template for redis-zabbix:redis.stats[connectionsUsage,{#REDIS_PORT}].last()}>80