Zabbix的各类服务监控

监控端口

一、创建模板，名字随意

应用集略过

二、 新建监控项

image-20210627103248271

或者 net.tcp.port[,port]： 检查是否可以将TCP链接到指定端口，0 - 不能连接，1 - 能连接。ip默认为127.0.0.1

三、创建触发器

image-20210627123858173

上面表达式意思为：1分钟内，返回2次0,即触发。

监控MySQL

简单的监控方式

修改数据库配置文件有两种方式

一、修改默认配置

也就是/etc/my.cnf尾部添加；

[mysql]
host=192.168.1.13
user=admin
password=zabbix@123

[mysqladmin]
host=192.168.1.13
user=admin
password=zabbix@123

建立MySQL可执行文件的软连接，已建立或者已经创建环境变量可忽略（MySQL yum安装忽略）：

ln -s /usr/local/mysql/bin/mysql /usr/local/bin/
ln -s /usr/local/mysql/bin/mysqladmin /usr/local/bin/

新建userparameter_mysql.conf 配置文件

# 连接数
UserParameter=mysql.max_connections,echo "show variables where Variable_name='max_connections';" | mysql -N | awk '{print $2}'
UserParameter=mysql.current_connections,echo "show global status where Variable_name='Threads_connected';" |  mysql -N | awk '{print $2}'
# 缓冲池
UserParameter=mysql.buffer_pool_size,echo "show variables where Variable_name='innodb_buffer_pool_size';" | mysql -N |awk '{printf "%.2f",$2/1024/1024/1024}'
UserParameter=mysql.buffer_pool_usage_percent,echo "show global status where Variable_name='Innodb_buffer_pool_pages_free' or Variable_name='Innodb_buffer_pool_pages_total';" | mysql -N | awk '{a[NR]=$2}END{printf "%.1f",100-((a[1]/a[2])*100)}'
# 增删改查
UserParameter=mysql.status[*],echo "show global status where Variable_name='$1';" | mysql -N | awk '{print $$2}'
# 实例状态
UserParameter=mysql.ping,mysqladmin ping | grep -c alive
UserParameter=mysql.version,mysql -V
UserParameter=mysql.size[*],bash -c 'echo "select sum($(case "$3" in both|"") echo "data_length+index_length";; data|index) echo "$3_length";; free) echo "data_free";; esac)) from information_schema.tables$([[ "$1" = "all" || ! "$1" ]] || echo " where table_schema=\"$1\"")$([[ "$2" = "all" || ! "$2" ]] || echo "and table_name=\"$2\"");" | mysql --defaults-file=/usr/local/zabbix/etc/my.cnf -N'

二、自定义新的配置文件

建议放在vim etc/zabbix/etc/.my.cnf, 直接命名my.cnf会报错,加上 "."

[client]
user=zabbix
host=localhost
password=123456

建立MySQL可执行文件的软连接，已建立或者已经创建环境变量可忽略（MySQL yum安装忽略）：

ln -s /usr/local/mysql/bin/mysql /usr/local/bin/
ln -s /usr/local/mysql/bin/mysqladmin /usr/local/bin/

新建userparameter_mysql.conf 配置文件

# 连接数
UserParameter=mysql.max_connections,echo "show variables where Variable_name='max_connections';" | HOME=/etc/zabbix/  mysql -N | awk '{print $2}'
UserParameter=mysql.current_connections,echo "show global status where Variable_name='Threads_connected';" | HOME=/etc/zabbix/  mysql -N | awk '{print $2}'
# 缓冲池
UserParameter=mysql.buffer_pool_size,echo "show variables where Variable_name='innodb_buffer_pool_size';" | HOME=/etc/zabbix/ mysql -N |awk '{printf "%.2f",$2/1024/1024/1024}'
UserParameter=mysql.buffer_pool_usage_percent, echo "show global status where Variable_name='Innodb_buffer_pool_pages_free' or Variable_name='Innodb_buffer_pool_pages_total';" | HOME=/etc/zabbix/ mysql -N | awk '{a[NR]=$2}END{printf "%.1f",100-((a[1]/a[2])*100)}'
# 增删改查
UserParameter=mysql.status[*],echo "show global status where Variable_name='$1';" | HOME=/etc/zabbix/ mysql -N | awk '{print $$2}'
# 实例状态
UserParameter=mysql.ping,HOME=/etc/zabbix  mysqladmin ping | grep -c alive
UserParameter=mysql.version,HOME=/etc/zabbix/ mysql -V

另外一种监控方式

  1. 创建一个MySQL日志生成脚本
  2. 第二个脚本根据传进来的参数对日志过滤
  3. 编写zabbix监控项文件，传参至第二个脚本

编写定期收集mysql信息脚本，并指定到对应目录

vim mysql_monitor.sh

#!/bin/bash
dbpath='/data/mysql/bin/mysql'
#mysql的用户
dbuser='root'
#mysql的密码
dbpass='123456'
#mysql的端口
dbport='3306'
#mysql的socket文件
dbsocket='/data/mysql/tmp/mysql.sock'
#mysql-status日志路径
dbstatuspath=/tmp/mysql_status_monitor.log
#mysql-engine-status日志路径
dbenginestatuspath=/tmp/mysql_engine_innodb_status.log
#self-define-script
dbselfpath=/tmp/mysql_self_status.log

#查询mysql-status信息
${dbpath} -u${dbuser} -p${dbpass} -S${dbsocket} -P${dbport} -BNe "show global status;" > ${dbstatuspath}
#查询mysql-engine-innodb信息
${dbpath} -u${dbuser} -p${dbpass} -S${dbsocket} -P${dbport} -BNe "show engine innodb status\G" > ${dbenginestatuspath}
#检查集群节点
nodecount=`export MYSQL_PWD=${dbpass};${dbpath} -u${dbuser} --socket=/data/mysql/data/mysql.sock -P${dbport} -BNe "select count(*) from performance_schema.replication_group_members where MEMBER_STATE != 'ONLINE'"`
echo -e "nodecount ${nodecount}" > ${dbselfpath}

编写获取数据脚本，对定时生成的log文件进行信息筛选

vim mysql_get_data.sh


case $1 in
	nodecount)
       #查询集群节点存活状态
       cat /tmp/mysql_self_status.log |awk '/nodecount/ {print $2}' |head -1 
       ;;
	uptime)
       cat /tmp/mysql_status_monitor.log | awk '/Uptime/ {print $2}' |head -1
       ;;
    com_select)
       cat /tmp/mysql_status_monitor.log | awk '/Com_select/ {print $2}'
       ;;
    com_insert)
       cat /tmp/mysql_status_monitor.log | awk '/Com_insert/ {print $2}'|head -1
       ;;
    com_update)
       cat /tmp/mysql_status_monitor.log | awk '/Com_update/ {print $2}'|head -1
       ;;
    com_delete)
       cat /tmp/mysql_status_monitor.log | awk '/Com_delete/ {print $2}'|head -1
       ;;
    connections)
       cat /tmp/mysql_status_monitor.log | awk '/Connections/ {print $2}'|head -1
       ;;
    thread_cached)
       cat /tmp/mysql_status_monitor.log | awk '/Threads_cached/ {print $2}'
       ;;
    threads_connected)
       cat /tmp/mysql_status_monitor.log | awk '/Threads_connected/ {print $2}'
       ;;
    thread_created)
       cat /tmp/mysql_status_monitor.log | awk '/Threads_created/ {print $2}'            
       ;;
    Threads_running)
       cat /tmp/mysql_status_monitor.log | awk '/Threads_running/ {print $2}'
       ;;
    table_locks_immediate)
       cat /tmp/mysql_status_monitor.log | awk '/Table_locks_immediate/ {print $2}'
       ;;
    table_locks_waited)
       cat /tmp/mysql_status_monitor.log | awk '/Table_locks_waited/ {print $2}'
       ;;
    slow_launch_threads)
       cat /tmp/mysql_status_monitor.log | awk '/Slow_launch_threads/ {print $2}'
       ;;
    slow_queries)
       cat /tmp/mysql_status_monitor.log | awk '/Slow_queries/ {print $2}'
       ;;
    qps)
       uptime=`cat /tmp/mysql_status_monitor.log | awk '/Uptime/ {print $2}' |head -1`
       questions=`cat /tmp/mysql_status_monitor.log | awk '/Questions/ {print $2}'`
       echo $(printf "%.2f" `echo "scale=2;${questions}/${uptime}"|bc`)
       ;;
    tps)
       uptime=`cat /tmp/mysql_status_monitor.log | awk '/Uptime/ {print $2}' |head -1`
       com_commit=`cat /tmp/mysql_status_monitor.log | awk '/Com_commit/ {print $2}'`
       com_rollback=`cat /tmp/mysql_status_monitor.log | awk '/Com_rollback/ {print $2}'|head -1`
       com_sum=$((${com_commit}+${com_rollback}))
       echo $(printf "%.2f" `echo "scale=2;${com_sum}/${uptime}"|bc`)
       ;;
    innodb_buffer_read_hits)
       innodb_buffer_pool_reads=`cat /tmp/mysql_status_monitor.log | awk '/Innodb_buffer_pool_reads/ {print $2}'|head -1`
       innodb_buffer_pool_read_requests=`cat /tmp/mysql_status_monitor.log | awk '/Innodb_buffer_pool_read_requests/ {print $2}'|head -1`
       innodb_buffer_read_diff=$((${innodb_buffer_pool_read_requests}-${innodb_buffer_pool_reads}))
       echo $(printf "%.2f" `echo "scale=2;${innodb_buffer_read_diff}/${innodb_buffer_pool_read_requests}"|bc`)
       ;;
    table_cache_hit)
       cat /tmp/mysql_status_monitor.log | awk '/Opened_tables/ {print $2}'
       ;;
    thread_cache_hits)
       thread_created=`cat /tmp/mysql_status_monitor.log | awk '/Threads_created/ {print $2}'`
       connections=`cat /tmp/mysql_status_monitor.log | awk '/Connections/ {print $2}'|head -1`
       thread_cache_diff=$((${connections}-${thread_created}))
       echo $(printf "%.2f" `echo "scale=2;${thread_cache_diff}/${connections}"|bc`)
       ;;
    create_tmp_tables_hits)
       created_tmp_tables=`cat /tmp/mysql_status_monitor.log | awk '/Created_tmp_tables/ {print $2}'`
       created_tmp_disk_tables=`cat /tmp/mysql_status_monitor.log | awk '/Created_tmp_disk_tables/ {print $2}'`
       echo $(printf "%.2f" `echo "scale=2;${created_tmp_disk_tables}/${created_tmp_tables}"|bc`)
       ;;
    binlog_cache_disk_use)
       cat /tmp/mysql_status_monitor.log | awk '/Binlog_cache_disk_use/ {print $2}'
       ;;
    table_locks_immediate)
       cat /tmp/mysql_status_monitor.log | awk '/Table_locks_immediate/ {print $2}'
       ;;
    table_locks_waited)
       cat /tmp/mysql_status_monitor.log | awk '/Table_locks_waited/ {print $2}'
       ;;
    innodb_row_lock_waits)
       cat /tmp/mysql_status_monitor.log | awk '/Innodb_row_lock_waits/ {print $2}'
       ;;               
    *)
       ;;
esac

编写zabbix监控项文件, 通过zabbix/script/mysql_get_data.sh脚本去获取对应监控的数值

vim mysql_monitor_parameter.conf

#集群节点数量
UserParameter=nodecount[*],sh /usr/local/zabbix/script/mysql_get_data.sh nodecount
#系统运行时间
UserParameter=uptime[*],sh /usr/local/zabbix/script/mysql_get_data.sh uptime
#查看select语句的执行数
UserParameter=com_select[*],sh /usr/local/zabbix/script/mysql_get_data.sh com_select
#查看insert语句的执行数
UserParameter=com_insert[*],sh /usr/local/zabbix/script/mysql_get_data.sh com_insert
#查看update语句的执行数
UserParameter=com_update[*],sh /usr/local/zabbix/script/mysql_get_data.sh com_update
#查看delete语句的执行数
UserParameter=com_delete[*],sh /usr/local/zabbix/script/mysql_get_data.sh com_delete
#查看试图连接到MySQL(不管是否连接成功)的连接数
UserParameter=connections[*],sh /usr/local/zabbix/script/mysql_get_data.sh connections
#查看线程缓存内的线程的数量
UserParameter=thread_cached[*],sh /usr/local/zabbix/script/mysql_get_data.sh thread_cached
#当线程打开连接数
UserParameter=threads_connected[*],sh /usr/local/zabbix/script/mysql_get_data.sh threads_connected
#查看创建用来处理连接的线程数。如果Threads_created较大，你可能要增加thread_cache_size值
UserParameter=thread_created[*],sh /usr/local/zabbix/script/mysql_get_data.sh thread_created
#查看激活的(非睡眠状态)线程数
UserParameter=threads_running[*],sh /usr/local/zabbix/script/mysql_get_data.sh threads_running
#查看创建时间超过slow_launch_time秒的线程数。
UserParameter=slow_launch_threads[*],sh /usr/local/zabbix/script/mysql_get_data.sh slow_launch_threads
#查看查询时间超过long_query_time秒的查询的个数。
UserParameter=slow_queries[*],sh /usr/local/zabbix/script/mysql_get_data.sh slow_queries
#在服务器上执行语句的数量，只包括客户端发送给服务器的语句，并不包括存储项目执行的语句
UserParameter=qps[*],sh /usr/local/zabbix/script/mysql_get_data.sh qps
#事物提交数量com_commit
#事物回滚数量com_rollback
UserParameter=tps[*],sh /usr/local/zabbix/script/mysql_get_data.sh tps
#在buffer pool满足不了逻辑读的请求，而必须直接从硬盘读取的数量innodb_buffer_pool_reads
#逻辑读的请求数innodb_buffer_pool_read_requests
#buffer_read命中率
UserParameter=innodb_buffer_read_hits[*],sh /usr/local/zabbix/script/mysql_get_data.sh innodb_buffer_read_hits
#打开表的数量open_tables
#已经打开表的数量opened_tables
#table_cache命中率
UserParameter=table_cache_hit[*],sh /usr/local/zabbix/script/mysql_get_data.sh table_cache_hit
#thread_cache命中率
UserParameter=thread_cache_hits[*],sh /usr/local/zabbix/script/mysql_get_data.sh thread_cache_hits
#执行语句过程中创建的临时表created_tmp_tables
#当创建的内部临时表过大，mysql会自动将表从内存中转换为磁盘上的表created_tmp_disk_tables
#在磁盘上创建临时表的比例
UserParameter=create_tmp_tables_hits[*],sh /usr/local/zabbix/script/mysql_get_data.sh create_tmp_tables_hits
#事物使用binlog但是临时二进制日志超过binlog_cache_size，使用临时文件存储事物的语句，如果该值不为0，需要调整binlog_cache_size
UserParameter=binlog_cache_disk_use[*],sh /usr/local/zabbix/script/mysql_get_data.sh binlog_cache_disk_use
#可以立即授予表锁请求的次数
UserParameter=table_locks_immediate[*],sh /usr/local/zabbix/script/mysql_get_data.sh table_locks_immediate
#一个表锁的请求不能立即被授予，需要等待的次数,如果该值过高，说明数据库有性能问题，应该优化sql语句，表分区或者读写分离
UserParameter=table_locks_waited[*],sh /usr/local/zabbix/script/mysql_get_data.sh table_locks_waited
#操作innodb表等待行数的次数
UserParameter=innodb_row_lock_waits[*],sh /usr/local/zabbix/script/mysql_get_data.sh innodb_row_lock_waits

向 mysql_status.conf 文件中写入如下内容，用于定义 key 的名称：

UserParameter=mysql.status[*],/etc/zabbix/scripts/monitor_mysql.sh $1
UserParameter=mysql.ping,/usr/bin/mysqladmin -uzabbix -pzabbix ping|grep alive|wc -l
UserParameter=mysql.version,mysql -V | cut -f6 -d" " | sed 's/,//'

在zabbix server端使用zabbix_get测试

zabbix_get -s 192.168.1.13 -p 10050 -k mysql.buffer_pool_size

监控Nginx

zabbix默认带有两个nginx的模板，可以直接链接模板使用。本文主要介绍根据实际情况自定义一些监控选项

image-20210713220942373

修改nginx配置文件，为了不影响默认/，添加新的/status

vim /etc/nginx/nginx.conf

location /status {
    stub_status on;
    access_log off;
    allow 127.0.0.1;				#允许主机访问（同agent）
    allow 192.168.1.111;			#允许zabbix-server端访问
    allow 192.168.1.113;			#允许zabbix-agent端访问
    deny all;						#禁止其他所有
}

检查nginx配置文件，并重启服务

nginx -t  #检查配置文件
nginx -s reload		#重启Nginx服务

[root@nginx conf]# curl -I 192.168.1.113/nginx_status				
HTTP/1.1 200 OK
Server: nginx/1.8.0
Date: Sat, 15 Feb 2020 08:41:57 GMT
Content-Type: text/plain
Connection: keep-alive

[root@nginx conf]# curl 192.168.1.113/nginx_status      
Active connections: 1 
server accepts handled requests
     1191       1191    1124 
Reading: 0 Writing: 1 Waiting: 0

Nginx状态解释：

  • Activeconnections: 对后端发起的活动连接数；
  • server accepts 1191：nginx 总共处理了1191个连接；
  • handled：成功创建了1191次握手；
  • requests：总共处理了1124请求。
  • Reading：nginx读取客户端的header数；
  • Writing: nginx 返回给客户端的header数；
  • Waiting: nginx 请求处理完成，正在等待下一请求指令的连接。

添加nginx监控选项

#拷贝自带的mysql配置文件并修改为nginx
[root@nginx ~]# cd /etc/zabbix/zabbix_agentd.d/
[root@nginx zabbix_agentd.d]# cp userparameter_mysql.conf userparameter_nginx.conf
 
#删除有关mysql数据，添加nginx监控选项
[root@nginx zabbix_agentd.d]# vi userparameter_nginx.conf 
UserParameter=nginx.active,curl -s http://127.0.0.1/status  2>/dev/null| grep 'Active' | awk '{print $NF}'
UserParameter=nginx.reading,curl -s http://127.0.0.1/status 2>/dev/null| grep 'Reading' | awk '{print $2}'
UserParameter=nginx.writing,curl -s http://127.0.0.1/status 2>/dev/null| grep 'Writing' | awk '{print $4}'
UserParameter=nginx.waiting,curl -s http://127.0.0.1/status 2>/dev/null| grep 'Waiting' | awk '{print $6}'
UserParameter=nginx.accepts,curl -s http://127.0.0.1/status 2>/dev/null| awk NR==3 | awk '{print $1}'
UserParameter=nginx.handled,curl -s http://127.0.0.1/status 2>/dev/null| awk NR==3 | awk '{print $2}'
UserParameter=nginx.requests,curl -s http://127.0.0.1/status 2>/dev/null| awk NR==3 | awk '{print $3}'

添加监控选项（依次创建七个监控选项）

image-20210713221539411

image-20210713221553450

创建图形

image-20210713221627374

image-20210713221652494

image-20210713221703639

参考

https://blog.csdn.net/tladagio/article/details/103101807 Zabbix 4.4（五）zabbix监控nginx（自定义nginx监控选项）

监控Redis

创建配置文件

在 /etc/zabbix/zabbix_agentd.d/ 下新建文件 redis_status.conf,内容如下：

#!/bin/bash
REDISCLI="/usr/bin/redis-cli"
HOST="127.0.0.1"
PORT=6379
PASS=""

if [[ $# == 1 ]];then
    case $1 in
        version)
            # 返回redis版本
            result=`$REDISCLI -h $HOST  -p $PORT info server | grep -w "redis_version" | awk -F':' '{print $2}'`
            echo $result
        ;;
        uptime)
            # redis服务启动时长
            result=`$REDISCLI -h $HOST  -p $PORT info server | grep -w "uptime_in_seconds" | awk -F':' '{print $2}'`
            echo $result
        ;;
        connected_clients)
            # 已连接的客户端数(不包括通过slave连接的客户端)
            result=`$REDISCLI -h $HOST  -p $PORT info clients | grep -w "connected_clients" | awk -F':' '{print $2}'`
            echo $result
        ;;
        blocked_clients)
            # 正在等待阻塞命令(BLPOP、BRPOP、BRPOPLPUSH)的客户端的数量 
            result=`$REDISCLI -h $HOST  -p $PORT info clients | grep -w "blocked_clients" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_memory)
            # 由redis分配器分配的内存总量，以字节为单位
            result=`$REDISCLI -h $HOST  -p $PORT info memory | grep -w "used_memory" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_memory_rss)
            # 返回redis已分配的内存总量
            result=`$REDISCLI -h $HOST  -p $PORT info memory | grep -w "used_memory_rss" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_memory_peak)
            #redis的内存消耗峰值(以字节为单位)
            result=`$REDISCLI -h $HOST  -p $PORT info memory | grep -w "used_memory_peak" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_memory_lua)
            #Lua引擎使用的字节量
            result=`$REDISCLI -h $HOST  -p $PORT info memory | grep -w "used_memory_lua" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_cpu_sys)
            #Redis服务消耗的系统cpu
            result=`$REDISCLI -h $HOST  -p $PORT info cpu | grep -w "used_cpu_sys" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_cpu_user)
            #Redis服务消耗的用户cpu
            result=`$REDISCLI -h $HOST  -p $PORT info cpu | grep -w "used_cpu_user" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_cpu_sys_children)
            #后台进程占用的系统cpu
            result=`$REDISCLI -h $HOST  -p $PORT info cpu | grep -w "used_cpu_sys_children" | awk -F':' '{print $2}'`
            echo $result
        ;;
        used_cpu_user_children)
            #后台进程占用的用户cpu
            result=`$REDISCLI -h $HOST  -p $PORT info cpu | grep -w "used_cpu_user_children" | awk -F':' '{print $2}'`
            echo $result
        ;;
        rdb_last_bgsave_status)
            #最后一次rdb持久化是否成功
            result=`$REDISCLI -h $HOST  -p $PORT info Persistence | grep -w "rdb_last_bgsave_status" | awk -F':' '{print $2}' | grep -c ok`
            echo $result
        ;;
        aof_last_bgrewrite_status)
            #最后一次bgrewrite是否成功
            result=`$REDISCLI -h $HOST  -p $PORT info Persistence | grep -w "aof_last_bgrewrite_status" | awk -F':' '{print $2}' | grep -c ok`
            echo $result
        ;;
        aof_last_write_status)
            #上次aof写入状态
            result=`$REDISCLI -h $HOST  -p $PORT info Persistence | grep -w "aof_last_write_status" | awk -F':' '{print $2}' | grep -c ok`
            echo $result
        ;;
        *)
            echo -e "\033[33mUsage: $0 {connected_clients|blocked_clients|used_memory|used_memory_rss|used_memory_peak|used_memory_lua|used_cpu_sys|used_cpu_user|used_cpu_sys_children|used_cpu_user_children|rdb_last_bgsave_status|aof_last_bgrewrite_status|aof_last_write_status}\033[0m"
        ;;
    esac
elif [[ $# == 2 ]];then
    case $2 in
        keys)
            result=`$REDISCLI -h $HOST  -p $PORT info | grep -w "$1" | grep -w "keys" | awk -F'=|,' '{print $2}'`
            echo $result
        ;;
        expires)
            result=`$REDISCLI -h $HOST  -p $PORT info | grep -w "$1" | grep -w "keys" | awk -F'=|,' '{print $4}'`
            echo $result
        ;;
        avg_ttl)
            result=`$REDISCLI -h $HOST  -p $PORT info | grep -w "$1" | grep -w "avg_ttl" | awk -F'=|,' '{print $6}'`
            echo $result
        ;;
        *)
            echo -e "\033[33mUsage: $0 {db0 keys|db0 expires|db0 avg_ttl}\033[0m" 
        ;;
    esac
fi

注意：若 redis 有密码，则需要在 $HOST 后加上 -a $PASS 参数。

4、脚本授权

[root@localhost scripts]# chmod +x auto_detection_redis_state.sh

5、验证server端验证是否能获取agent端的key值

使用zabbix_get命令获取key值

Zabbix监控Redis性能状态

参数说明

Server

参数 说明
redis_version:5.0.4 #redis版本
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:964fe9af98041665
redis_mode:standalone #运行模式，单机或集群
os:Linux 3.10.0-693.21.1.el7.x86_64 x86_64 #系统版本
arch_bits:64 #架构，32位或64位
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:4.8.5 #编译redis时所使用的gcc版本
process_id:2939 #redis服务器的进程id
run_id:11b5694d024d8c728c1448ec4163fb0c22b86375 #redis服务器的随机标识符(用于sentinel和集群)
tcp_port:6379 #redis服务监听端口
uptime_in_seconds:18316 #redis服务启动时长，单位为秒
uptime_in_days:0 #redis服务启动时长，单位为天
hz:10 #redis内部调度（进行关闭timeout的客户端，删除过期key等等）频率
configured_hz:10
lru_clock:4564768
executable:/usr/local/redis/redis-server #执行文件位置
config_file:/usr/local/redis/./redis.conf #配置文件位置

Clients

参数 说明
connected_clients:2 #已连接的客户端数(不包括通过slave连接的客户端)
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0 #正在等待阻塞命令(BLPOP、BRPOP、BRPOPLPUSH)的客户端的数量

Memory

参数 说明
used_memory:8985032 #由redis分配器分配的内存总量，以字节为单位
used_memory_human:8.57M #易读方式
used_memory_rss:15175680 #从操作系统的角度，返回redis已分配的内存总量(俗称常驻集大小)
used_memory_rss_human:14.47M
used_memory_peak:14859000 #redis的内存消耗峰值(以字节为单位)
used_memory_peak_human:14.17M
used_memory_peak_perc:60.47% #峰值内存超出分配内存（used_memory）的百分比
used_memory_overhead:5407864 #服务器为管理其内部数据结构而分配的所有开销的字节总和
used_memory_startup:862032 #Redis在启动时消耗的初始内存量（以字节为单位）
used_memory_dataset:3577168
used_memory_dataset_perc:44.04%
allocator_allocated:8951208
allocator_active:15137792
allocator_resident:15137792
total_system_memory:512077824 #系统内存总量
total_system_memory_human:488.36M
used_memory_lua:37888 #Lua引擎使用的字节量
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0 #配置设置的最大可使用内存值
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.69
allocator_frag_bytes:6186584
allocator_rss_ratio:1.00
allocator_rss_bytes:0
rss_overhead_ratio:1.00
rss_overhead_bytes:37888
mem_fragmentation_ratio:1.70 #used_memory_rss和used_memory之间的比率
mem_fragmentation_bytes:6224472 #used_memory_rss和used_memory之间的差值，单位字节
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:66616
mem_aof_buffer:0
mem_allocator:libc #内存分配器，在编译时选择
active_defrag_running:0 #指示活动碎片整理是否处于活动状态的标志
lazyfree_pending_objects:0

Persistence

参数 说明
loading:0 #服务器是否正在载入持久化rdb文件
rdb_changes_since_last_save:0 #自上次rdb持久化以来发生改变的数值
rdb_bgsave_in_progress:0 #服务器是否正在创建rdb文件
rdb_last_save_time:1564845192 #最后一次成功rdb持久化的时间戳
rdb_last_bgsave_status:ok #最后一次rdb持久化是否成功
rdb_last_bgsave_time_sec:0 #最后一次成功生成rdb文件耗时秒数
rdb_current_bgsave_time_sec:-1 #当前bgsave已耗费的时间（如果有）
rdb_last_cow_size:438272 #上次rbd保存操作期间写时复制分配的字节大小
aof_enabled:0 #aof功能是否开启
aof_rewrite_in_progress:0 #标识aof的rewrite操作是否在进行中
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1 #最后一次aof rewrite耗费的时长
aof_current_rewrite_time_sec:-1 #当前rewrite已耗费的时间（如果有）
aof_last_bgrewrite_status:ok #最后一次bgrewrite是否成功
aof_last_write_status:ok #上次aof写入状态
aof_last_cow_size:0 #上次AOF重写操作期间写时复制分配的大小（以字节为单位）

如果激活了AOF，则会添加以下附加字段：
aof_current_size:4201740 #aof当前尺寸
aof_base_size:4201687 #服务器启动时或者aof重写最近一次执行之后aof文件的大小
aof_pending_rewrite:0 #是否有aof重写操作在等待rdb文件创建完毕之后执行?
aof_buffer_length:0 #aof buffer的大小
aof_rewrite_buffer_length:0 #aof rewrite buffer的大小
aof_pending_bio_fsync:0 #后台I/O队列里面，等待执行的fsync调用数量
aof_delayed_fsync:0 #被延迟的fsync调用数量

如果正在进行加载操作，则会添加以下附加字段：
loading_start_time #加载操作开始的基于纪元的时间戳
loading_total_bytes #文件总大小
loading_loaded_bytes #已加载的字节数
loading_loaded_perc #加载进度表示为百分比
loading_eta_seconds #ETA在几秒钟内完成负载

Stats

参数 说明
total_connections_received:7212 #服务接受的总连接数
total_commands_processed:2341631 #服务器处理的总命令数
instantaneous_ops_per_sec:0 #每秒处理的命令数
total_net_input_bytes:125344667 #从网络读取的总字节数
total_net_output_bytes:1712517025 #写入网络的总字节数
instantaneous_input_kbps:0.00 #网络读取速率KB/sec
instantaneous_output_kbps:0.00 #网络写入速率KB/sec
rejected_connections:0 #因达到最大连接数而拒绝的连接
sync_full:1 #给从节点完全同步的数量
sync_partial_ok:0 #接受的同步请求数量
sync_partial_err:0 #拒绝的同步请求数量
expired_keys:0 #键到期的总数
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0 #因达到maxmemory限制而被驱逐的键的数量
keyspace_hits:641037 #Number of successful lookup of keys in the main dictionary
keyspace_misses:9002 #Number of failed lookup of keys in the main dictionary
pubsub_channels:1
pubsub_patterns:0
latest_fork_usec:326 #最新fork操作的持续时间（以微秒为单位）
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0

Replication

参数 说明
role:master #master or slave
connected_slaves:0 #已建立连接的从节点数
master_replid:fe1bb6f5cfef91b36603d8e57081cc02890705c8 #复制ID
master_replid2:0000000000000000000000000000000000000000 #第二个复制ID，用于failover的PSYNC
master_repl_offset:86270959 #服务当前的复制偏移量
second_repl_offset:-1 #The offset up to which replication IDs are accepted
repl_backlog_active:0
repl_backlog_size:1048576 #复制积压缓冲区的总大小（B）
repl_backlog_first_byte_offset:85222384 #复制积压缓冲区的主偏移量
repl_backlog_histlen:1048576 #复制积压缓冲区中数据的大小

CPU

参数 说明
used_cpu_sys:24.941282 #Redis服务消耗的系统cpu
used_cpu_user:18.820039 #Redis服务消耗的用户cpu
used_cpu_sys_children:0.050757 #后台进程占用的系统cpu
used_cpu_user_children:0.259980 #后台进程占用的用户cpu

Cluster 集群信息

cluster_enabled:0

Keyspace #数据库的统计信息

db0:keys=85766,expires=0,avg_ttl=0

参考

https://www.jianshu.com/p/a323877f80db

监控JAVA

JMX（Java Management Extensions，即Java管理扩展）是java平台上为应用程序、设备、系统等植入管理功能的框架。

监控原理

当Zabbix-Server需要知道java应用程序的某项性能的时候，会启动自身的一个Zabbix-JavaPollers进程去连接Zabbix-JavaGateway请求数据，而ZabbixJavagateway收到请求后使用"JMXmanagementAPI"去查询特定的应用程序，而前提是应用程序这端在开启时需要"-Dcom.sun.management.jmxremote"参数来开启JMX远程查询就行。Java程序会启动自身的一个简单的小程序端口12345向Zabbix-JavaGateway提供请求数据。

从上面的原理图中可以看出，配置Zabbix监控Java应用程序的关键点在于：配置Zabbix-JavaGateway、让Zabbix-Server能够连接Zabbix-JavaGateway、Tomcat开启JVM远程监控功能等。

JMX API

从 JVM 运行时获取GC行为数据, 最简单的办法是使用标准 JMX API 接口. JMX是获取 JVM内部运行时状态信息 的标准API. 可以编写程序代码, 通过 JMX API 来访问本程序所在的JVM，也可以通过JMX客户端执行(远程)访问。

最常见的 JMX客户端是 JConsole 和 JVisualVM (可以安装各种插件,十分强大)。两个工具都是标准JDK的一部分, 而且很容易使用. 如果使用的是 JDK 7u40 及更高版本, 还可以使用另一个工具: Java Mission Control( 大致翻译为 Java控制中心, jmc.exe)。

本文监控jvm内容如下：

  • 内存使用状态：堆内存（Heap memory）和非堆内存（No Heap memory），包括已用值、最大值、已提交；
  • 堆内存内存池：新生代（eden space），survivor space,老年代（old gen）的内存使用状态；
  • 非堆内存内存池：代码缓存（Code cache），元空间（meta space），压缩类空间（compressed class space）；
  • 类加载：加载总数，已加载，已卸载。
  • Java线程：总开启线程，活动线程，线程峰值。

本文监控tomcat内容如下：

  • Tomcat请求数：包括每秒请求数，每秒出错数；
  • Tomcat网络流量统计：包括进流量统计，出流量统计；
  • Tomcat线程：包括最大线程数，当前线程数，当前繁忙线程数。

我没有在zabbix中添加垃圾回收（gc）的监控，而是在catalina配置里面添加gc日输入来给开发进行分析，设置方式如下:
CATALINA_OPTS=”-XX:ParallelGCThreads=4 -XX:+PrintGCDetails -Xloggc:日志存放路径”

配置JMX监控步骤：

1、安装Zabbix-Java-Gateway

2、配置zabbix_java_gateway.conf参数

3、配置zabbix_server.conf参数

4、Java应用开启JMX协议

5、Zabbix Web配置JMX监控的Java应用

监控环境搭建

Server端配置

1、Zabbix server端安装java jdk环境并开启javaGateway支持java监控。

javaGateway 启用方式如下：

  • Zabbix通过rpm包安装：只需要安装zabbix-java-gateway包即可。
  • Zabbix通过编译安装：在编译时需要加上—enable-java以支持jmx监控，如果之前没加需要重新编译。

2、安装 Zabbix-Java-Gateway

# 阿里 Zabbix yum 源
rpm -ivh http://mirrors.aliyun.com/zabbix/zabbix/3.0/rhel/7/x86_64/zabbix-release-3.0-1.el7.noarch.rpm

# 安装 java 环境
yum install java
yum install zabbix-java-gateway

3、配置 zabbix_java_gateway.conf

修改配置如下：

[root@linux-node2 ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_java_gateway.conf 
LISTEN_IP="0.0.0.0"
LISTEN_PORT=10052
PID_FILE="/var/run/zabbix/zabbix_java.pid"
START_POLLERS=5
TIMEOUT=3

4、配置 zabbix_server.conf

修改配置如下(关注 Java 相关参数)：

[root@linux-node1 ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_server.conf
LogFile=/var/log/zabbix/zabbix_server.log
LogFileSize=0
PidFile=/var/run/zabbix/zabbix_server.pid
DBHost=localhost
DBName=zabbix
DBUser=zabbix
DBPassword=zabbix
JavaGateway=192.168.56.12
JavaGatewayPort=10052
StartJavaPollers=5
SNMPTrapperFile=/var/log/snmptrap/snmptrap.log
Timeout=4
AlertScriptsPath=/usr/lib/zabbix/alertscripts
ExternalScripts=/usr/lib/zabbix/externalscripts
LogSlowQueries=3000

agent端配置

1、下载catalina-jmx-remote.jar包，到tomcat安装目录下的lib目录

wget -O /usr/local/tomcat/lib/catalina-jmx-remote.jar http://archive.apache.org/dist/tomcat/tomcat-8/v8.0.23/bin/extras/catalina-jmx-remote.jar

2、修改catalina.sh添加如下内容，最后两行参数可以不配置

CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote \
-Dcom.sun.management.jmxremote.port=10053 \
-Dcom.sun.management.jmxremote.ssl=false \
-Dcom.sun.management.jmxremote.authenticate=true \
-Djava.rmi.server.hostname=192.168.56.12 \
- com.sun.management.jmxremote.access.file:/mnt/tomcatpolicyweb/conf/jmxremote.access\
- com.sun.management.jmxremote.password.file:/mnt/tomcatpolicyweb/conf/jmxremote.password"
  • Djava.rmi.server.hostname: 主机ip
  • Dcom.sun.management.jmxremote.port：server端获取数据的端口
  • Dcom.sun.management.jmxremote.authenticate：是否使用密码，如果使用则需要配置账号密码文件

参考文档：https://docs.oracle.com/javase/1.5.0/docs/guide/management/agent.html

3、可以参考jdk提供的官方文档 /usr/local/java/jdk1.8/jre/lib/management

jmxremote.access 文件示例：

monitorRoleUser   readonly
controlRoleUser   readwrite \
              create javax.management.monitor.*,javax.management.timer.* \
              unregister

jmxremote.password 文件示例：

monitorRoleUser  pass1
controlRoleUser  pass2

修改权限

chmod 600 /mnt/tomcatpolicyweb/conf/jmxremote.access 
chmod 600 /mnt/tomcatpolicyweb/conf/jmxremote.password 
chown root:root /mnt/tomcatpolicyweb/conf/jmxremote.access 
chown root:root /mnt/tomcatpolicyweb/conf/jmxremote.password

重启tomcat

测试

在 Zabbix Server上通过 cmdline-jmxclient 验证，下载地址http://crawler.archive.org/cm...

wget http://crawler.archive.org/cmdline-jmxclient/cmdline-jmxclient-0.10.3.jar

jar包用法：java -jar cmdline-jmxclient.jar USER:PASS HOST:PORT [BEAN] [COMMAND]

命令顺序：java -jar cmdline-jmxclient.jar java.lang:type=Threading,name Operations/Attributes

（2）本地执行如下命令查看tomcat的堆内存信息

[root@linux-node1 ~]# java -jar cmdline-jmxclient-0.10.3.jar - 192.168.56.12:10053 java.lang:type=Memory NonHeapMemoryUsage
06/20/2016 12:05:20 +0800 org.archive.jmx.Client NonHeapMemoryUsage: 
committed: 30015488
init: 2555904
max: -1
used: 28761904

#如果有账号密码
java -jar cmdline-jmxclient-0.10.3.jar - monitorRoleUser:*qZ6nUlNcsg0w3Ut 172.21.21.85:10054 java.lang:type-Memory NonHeapMemoryUsage

参考文档：http://crawler.archive.org/cmdline-jmxclient/

本文监控jvm内容如下：

  • 内存使用状态：堆内存（Heap memory）和非堆内存（No Heap memory），包括已用值、最大值、已提交；
  • 堆内存内存池：新生代（eden space），survivor space,老年代（old gen）的内存使用状态；

非堆内存内存池：代码缓存（Code cache），元空间（meta space），压缩类空间（compressed class space）；
类加载：加载总数，已加载，已卸载。
Java线程：总开启线程，活动线程，线程峰值。

垃圾收集器（PS MarkSweep）

本文监控tomcat内容如下：

  • Tomcat请求数：包括每秒请求数，每秒出错数；
  • Tomcat网络流量统计：包括进流量统计，出流量统计；
  • Tomcat线程：包括最大线程数，当前线程数，当前繁忙线程数。

我没有在zabbix中添加垃圾回收（gc）的监控，而是在catalina配置里面添加gc日输入来给开发进行分析，设置方式如下。
CATALINA_OPTS=”-XX:ParallelGCThreads=4 -XX:+PrintGCDetails -Xloggc:日志存放路径”

监控数据采集

查看所有Mbean类型

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:10054

堆内存

Tomcat本地查看堆内存信息：

[root@tomcat-01 ~]# java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=Memory HeapMemoryUsage
11/04/2016 15:36:58 +0800 org.archive.jmx.Client HeapMemoryUsage:
committed: 2145910784
init: 2147483648
max: 2145910784
used: 741540536

zabbix监控堆内存键值：

堆内存最大值：jmx["java.lang:type=Memory","HeapMemoryUsage.max"]
已用堆内存：jmx["java.lang:type=Memory","HeapMemoryUsage.used"]
已提交堆内存：jmx["java.lang:type=Memory","HeapMemoryUsage.committed"]

一个完整的zabbix item填写方式如下,不同内容填写不同的键值即可：

image-20211220161255670

image-20211220161301909

创建图形的步骤本文就忽略了，添加图形步骤可以参考

低级别发现

jmx.discovery[beans,"*:type=GarbageCollector,name=*"]   #检索所有的垃圾收集器
jmx.discovery[attributes,"*:type=GarbageCollector,name=*"]   #检索所有垃圾收集器属性
jmx.discovery[beans]  #检索所有 JMX MBeans
jmx.discovery  #检索所有 JMX MBean 属性

https://www.zabbix.com/documentation/4.4/en/manual/discovery/low_level_discovery/jmx

更多配置请参考官网：

https://www.zabbix.com/documentation/4.4/en/manual/config/items/itemtypes/jmx_monitoring

Zabbix监控项键值

配置项 值
Tomcat请求总数监控 jmx["Catalina:type=GlobalRequestProcessor,name="http-nio-8080"",requestCount]
JVM老年代已使用内存监控 jmx["java.lang:type=MemoryPool,name=Tenured Gen", "Usage.used"]
JVM老年代总内存监控 jmx["java.lang:type=MemoryPool,name=Tenured Gen", "Usage.committed"]
eden区域最大空间 jmx["java.lang:type=MemoryPool,name=PS Eden Space",Usage.max]
eden区域已用空间 jmx["java.lang:type=MemoryPool,name=PS Eden Space",Usage.used]
eden区域提交空间 jmx["java.lang:type=MemoryPool,name=PS Eden Space",Usage.committed]
Survivor 提交 jmx["java.lang:type=MemoryPool,name=PS Survivor Space",Usage.committed]
Survivor 最大 jmx["java.lang:type=MemoryPool,name=PS Survivor Space",Usage.max]
Survivor 已使用 jmx["java.lang:type=MemoryPool,name=PS Survivor Space",Usage.used]
old gen 提交 jmx["java.lang:type=MemoryPool,name=PS Old Gen",Usage.committed]
old gen 最大 jmx["java.lang:type=MemoryPool,name=PS Old Gen",Usage.max]
old gen 已使用 jmx["java.lang:type=MemoryPool,name=PS Old Gen",Usage.used]
非堆内存提交 jmx["java.lang:type=Memory","NonHeapMemoryUsag.committed"]
非堆内存使用 jmx["java.lang:type=Memory","NonHeapMemoryUsage.used"]
堆内存使用值 jmx["java.lang:type=Memory",HeapMemoryUsage.used]
mete space区域 jmx["java.lang:type=MemoryPool,name=Metaspace",Usage.committed]
mete space区域 jmx["java.lang:type=MemoryPool,name=Metaspace",Usage.used]
code cache区域使用 jmx["java.lang:type=MemoryPool,name=Code Cache",Usage.used]
compressed class space区域使用 jmx["java.lang:type=MemoryPool,name=Compressed Class Space",Usage.used]
类加载信息 加载总数 jmx["java.lang:type=ClassLoading","TotalLoadedClassCount"]
类加载信息 已加载 jmx["java.lang:type=ClassLoading","LoadedClassCount"]
类加载信息 已卸载 jmx["java.lang:type=ClassLoading","UnloadedClassCount"]
java线程 总开启线程 jmx["java.lang:type=Threading","TotalStartedThreadCount"]
java活动线程数 jmx["java.lang:type=Threading","ThreadCount"]
java线程峰值数 jmx["java.lang:type=Threading","PeakThreadCount"]
tomcat最大线程 jmx["Catalina:type=ThreadPool,name="http-nio-8080"",maxThreads]
tomcat当前线程 jmx["Catalina:type=ThreadPool,name="http-nio-8080"",currentThreadCount]
tomcat繁忙线程 jmx["Catalina:type=ThreadPool,name="http-nio-8080"",currentThreadsBusy]
接收的字节 jmx["Catalina:type=GlobalRequestProcessor,name="http-nio-8080"",bytesReceived]
发送的字节 jmx["Catalina:type=GlobalRequestProcessor,name="http-nio-8080"",bytesSent]
jmx正常工作时间 jmx["java.lang:type=Runtime",Uptime]
系统打开文件描述符数量 jmx["java.lang:type=OperatingSystem",OpenFileDescriptorCount]
操作系统最大文件描述符数量 jmx["java.lang:type=OperatingSystem",MaxFileDescriptorCount]
gc新生内存每秒收集累计时间 jmx["java.lang:type=GarbageCollector,name=PS Scavenge",CollectionTime]
gc新生内存每秒收集数 jmx["java.lang:type=GarbageCollector,name=PS Scavenge",CollectionCount]
gc持久内存每秒收集累计时间 jmx["java.lang:type=GarbageCollector,name=PS MarkSweep",CollectionTime]
gc持久内存每秒收集数 jmx["java.lang:type=GarbageCollector,name=PS MarkSweep",CollectionCount]

JVM区域总体分两类，heap区和非heap区。

heap区又分为：

Eden Space（伊甸园):

Eden Space字面意思是伊甸园，对象被创建的时候首先放到这个区域，进行垃圾回收后，不能被回收的对象被放入到空的survivor区域。

Survivor Space幸存者区

用于保存在eden space内存区域中经过垃圾回收后没有被回收的对象。Survivor有两个，分别为To Survivor、 From Survivor，这个两个区域的空间大小是一样的。执行垃圾回收的时候Eden区域不能被回收的对象被放入到空的survivor（也就是To Survivor，同时Eden区域的内存会在垃圾回收的过程中全部释放），另一个survivor（即From Survivor）里不能被回收的对象也会被放入这个survivor（即To Survivor），然后To Survivor 和 From Survivor的标记会互换，始终保证一个survivor是空的。

Old Gen（老年代）

用于存放新生代中经过多次垃圾回收仍然存活的对象，也有可能是新生代分配不了内存的大对象会直接进入老年代。经过多次垃圾回收都没有被回收的对象，这些对象的年代已经足够old了，就会放入到老年代。

非heap区又分：

Code Cache(代码缓存区)；

代码缓存区，它主要用于存放JIT所编译的代码。CodeCache代码缓冲区的大小在client模式下默认最大是32m，在server模式下默认是48m，这个值也是可以设置的，它所对应的JVM参数为ReservedCodeCacheSize 和 InitialCodeCacheSize

Perm Gen（永久代）；

Perm Gen全称是Permanent Generation space，是指内存的永久保存区域，因而称之为永久代。这个内存区域用于存放Class和Meta的信息，Class在被 Load的时候被放入这个区域。因为Perm里存储的东西永远不会被JVM垃圾回收的，所以如果你的应用程序LOAD很多CLASS的话，就很可能出现PermGen space错误。默认大小为物理内存的1/64。

Jvm Stack(java虚拟机栈)；
Local Method Statck(本地方法栈)；

Tomcat 本地查看code cache区域使用：

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:type=MemoryPool,name=Code\ Cache Usage

Tomcat 内存池compressed class space*

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:type=MemoryPool,name=Compressed\ Class\ Space Usage

Tomcat本地查看类加载信息：

加载总数： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=ClassLoading TotalLoadedClassCoun
已加载： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=ClassLoading LoadedClassCount
已卸载： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=ClassLoading UnloadedClassCount

tomcat本地查看java线程：

总开启线程： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=Threading TotalStartedThreadCount
活动线程： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=Threading PeakThreadCount
线程峰值： java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=Threading PeakThreadCount

Tomcat线程

本地查看tomcat线程信息：

最大线程：java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 Catalina:name=\"http-nio-8080\",type=ThreadPool maxThreads
当前线程：java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 Catalina:name=\"http-nio-8080\",type=ThreadPool currentThreadCount
繁忙线程：java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 Catalina:name=\"http-nio-8080\",type=ThreadPool currentThreadsBusy

网络流量

Tomcat本地查看接收的字节：

接收的字节：
java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 Catalina:name=\"http-nio-8080\",type=GlobalRequestProcessor bytesReceived

发送的字节：
java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 Catalina:name=\"http-nio-8080\",type=GlobalRequestProcessor bytesSent

tomcat请求，出错请求

#查看tomcat请求数：
java -jar cmdline-jmxclient-0.10.3.jar - 192.168.10.46:8090 Catalina:name=\"http-nio-8080\",type=GlobalRequestProcessor requestCount

#tomcat出错请求： 
java -jar cmdline-jmxclient-0.10.3.jar - 192.168.10.46:8090 Catalina:name=\"http-nio-8080\",type=GlobalRequestProcessor errorCount

GC信息

java -jar cmdline-jmxclient-0.10.3.jar - 172.21.21.85:10054 java.lang:type=GarbageCollector,name=*

内存池eden space

Tomcat本地查看eden space：

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:type=MemoryPool,name=PS\ Eden\ Space Usage

内存池survivor space

Tomcat本地查看Survivor space区域：

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:type=MemoryPool,name=PS\ Survivor\ Space Usage

内存池old gen

Tomcat本地查看old gen区域使用：

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:name=PS\ Old\ Gen,type=MemoryPool Usage

非堆内存

Tomcat 本地查看非堆内存使用：

java -jar cmdline-jmxclient-0.10.3.jar controlRole:tomcat 127.0.0.1:8090 java.lang:type=Memory NonHeapMemoryUsag1

内存池meta space

Tomcat 本地查看meta space区域使用：

java -jar cmdline-jmxclient-0.10.3.jar - 127.0.0.1:8090 java.lang:type=MemoryPool,name=Metaspace Usage

踩坑

获取不到数据，报错如下：

# java -jar /root/cmdline-jmxclient-0.10.3.jar - 127.0.0.1:9080 java.lang:type=MemoryPool,name=PS\ Eden\ Space Usag
11/11/2016 10:03:37 +0800
org.archive.jmx.Client java.lang:name=PS Eden Space,type=MemoryPool is not a registered bean

解决思路

  • 如果你使用命令行监控获取不到数据，那么就先使用jconsole看看有没有数据，
  • 如果jconsole有数据，那么就往下看，反之检查你的环境。
  • 如果jconsole有数据，但是命令行没有数据，那么就是Mbean的Object Name或者属性有问题

参考

使用 zabbix 监控 tomcat（包含jvm监控）

选项 2：在不使用 SSL 的情况下设置 JMX 以进行客户机认证

https://jaminzhang.github.io/monitoring/Zabbix-config-JMX/ Zabbix 配置 JMX 监控

https://zabbix-manual-in-chinese.readthedocs.io/en/latest/concepts/java/ 5 Java gateway

https://zhuanlan.zhihu.com/p/26214242 jmx监控之Generic

监控

相关

应用监控利器：Pinpoint 全链路监控部署实践

如何用时序数据库 CTSDB 与 TARS 结合，解决海量监控数据难题

基于组态软件的分布式站点数据监控方案——厦门物通博联

TSINGSEE青犀视频边缘计算网关EasyNVR在视频整体监控解决方案中的应用分析

Prometheus（三）：Prometheus监控交换机（snmp）

grafana 监控 kafka 消息参数描述

QT QFileSystemWatcher 文件监控

Zabbix+Orabbix监控oracle数据库表空间

【系统监控】性能监测 vmstat,mpstat,iostat

nagios监控报错 It appears as though you do not have permission to view...

springboot高级(条件注解 Enable*注解 自动配置 事件监听 监控actuator)

苹果Mac硬件温度监控软件：TG Pro

标签