Maison > base de données > tutoriel mysql > Série Mysql (12) Opération de surveillance Mysql

Série Mysql (12) Opération de surveillance Mysql

黄舟
Libérer: 2017-01-22 17:02:59
original
1364 Les gens l'ont consulté

MySQL监控属于DB监控的模块之一,包括采集、展示、监控告警。本文主要介绍Mysql监控的主要指标和采集方法。

  Mysql监控和Redis监控的逻辑类似,可参考文章《Redis监控》。

  DBA前台添加Mysql监控时系统会调用自动调度平台接口将Mysql监控的加密账户密码和ip端口等信息发送至目标,同时发送采集Agent。

  一、采集指标和命令

  1、Mysql服务运行状态

约定所有Mysql服务都必须以ip1(内网ip)来绑定,每个机器只有一个ip1,可以有多个端口,即多个Mysql Server。采集程序读取ip端口信息文件来判断server是否存在。

sockParam=`ps aux | grep -P "mysqld.*--port=${port}" | grep -oP " --socket.*\.sock"` 
 # 空则获取不到该服务器端口mysql socket配置,请检查mysql配置是否正确
MYSQL="/usr/local/mysql/bin/mysql -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
MYSQL_ADMIN="/usr/local/mysql/bin/mysqladmin -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
curStatus=`${MYSQL} -e"show global status"`  
 # 空则是获取不到该服务器mysql状态,请检查mysql是否正常运行
 if [ -z "${curStatus}" ]
 then
    portExists=0else
    echo "${curStatus}" >> ${curFile}
    portExists=1
Copier après la connexion

  2、连接数

${MYSQL_ADMIN} processlist -v | wc -l
Copier après la connexion

  3、线程数

grep 'Threads_connected' ${curFile} | awk '{print $2}'
Copier après la connexion

  4、慢查询数

grep 'Slow_queries' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的慢查询次数。上次数据保存在last.cache。

  5、打开表数

grep 'Open_tables' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

  6、每秒执行select数

grep 'Com_select' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。  

  7、每秒执行delete数

grep 'Com_delete' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。

  8、每秒执行insert数

grep 'Com_insert' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。

  9、每秒执行update数

grep 'Com_update' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。

  10、每秒钟执行replace数

grep 'Com_replace' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。 

  11、每秒钟执行的 Innodb_rows_deleted

grep 'Innodb_rows_deleted' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。  

  12、每秒钟执行的 Innodb_rows_inserted

grep 'Innodb_rows_inserted' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。  

  13、每秒钟执行的 Innodb_rows_read

grep 'Innodb_rows_read' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。

  14、每秒钟执行的 Innodb_rows_updated

grep 'Innodb_rows_updated' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量。上次数据保存在last.cache。

  15、每秒钟执行的 innodb rows total

expr ${innodbRowsDeletedPS} + ${innodbRowsInsertedPS} + ${innodbRowsReadPS} + ${innodbRowsUpdatedPS}
Copier après la connexion

等于前面四个Innodb_rows_*执行次数的总和

  16、每秒处理命令数 qps

expr ${mysqlSelectNumPS} + ${mysqlInsertNumPS} + ${mysqlUpdateNumPS} + ${mysqlDeleteNumPS} + ${mysqlReplaceNumPS}
Copier après la connexion

等于前面五个mysql命令Com_*的数量总和

  17、每秒接收字节数 KByte/s

grep 'Bytes_received' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量,除以1024得到单位KByte/s。上次数据保存在last.cache。

  18、每秒发送字节数

grep 'Bytes_sent' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值除以时间差,等于最近1分钟的执行数量,除以1024得到单位KByte/s。上次数据保存在last.cache。

  19、可立即获得锁的次数

grep 'Table_locks_immediate' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的可立即获得锁数量。上次数据保存在last.cache。

  20、不可立即获得锁的次数

grep 'Table_locks_waited' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的不可立即获得锁数量。上次数据保存在last.cache。

  21、一行锁定需等待时间

grep 'Innodb_row_lock_waits' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的一行锁定需等待时间。上次数据保存在last.cache。

  22、 当前脏页数

grep 'Innodb_buffer_pool_pages_dirty' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

  23、要求清空的缓冲池页数

grep 'Innodb_buffer_pool_pages_flushed' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的要求清空的缓冲池页数。上次数据保存在last.cache。

  24、Innodb 写入日志字节数 KByte

grep 'Innodb_os_log_written' ${curFile} | awk -F ' ' '{print $2}'
Copier après la connexion

需要计算两次的慢查询次数得到差值,等于最近1分钟的写入日志字节数,除以1024得到KByte。上次数据保存在last.cache。

  25、占用内存大小 MByte

pid=`ps aux | grep 'mysqld' | grep -Ev 'safe|grep' | awk '{print $2}' `
mem=`cat /proc/${pid}/status | grep 'VmRSS' | awk '{print $2}'`
mysqlMem=`echo "scale=2;${mem} / 1024" | bc`
Copier après la connexion

除以1024得到MByte

  26、handler socket每秒处理数

curHsTableLock=`grep 'Hs_table_lock' ${curFile} | awk '{print $2}'`
preHsTableLock=`grep 'Hs_table_lock' ${preFile} | awk '{print $2}'`if [ -n "${curHsTableLock}" ]then
    hsQPS=`echo "scale=0;(${curHsTableLock} - ${preHsTableLock}) / ${intervalTime}" | bc`else
    hsQPS=0fi
Copier après la connexion


  27、主从同步和状态

#主从信息
#是否为从服务器
slave_running=`grep 'Slave_running' ${curFile} | awk '{print $2}'`if [ "${slave_running}A" = "ONA" ]then
    slaveRunning=1
    slaveStatus=`${MYSQL} -e'show slave status\G'`    echo "${slaveStatus}" > ${slaveFile}
    
    slaveIoRunning=`grep 'Slave_IO_Running' ${slaveFile} | awk -F ':' '{print $2}'`
    slaveSqlRunning=`grep 'Slave_SQL_Running' ${slaveFile} | awk -F ':' '{print $2}'`    
    if [ "${slaveIoRunning}A" == "NoA" -o "${slaveSqlRunning}A" == "NoA" ]    then
        slaveRunning=3
    fi
    
    secondsBehindMaster=`grep 'Seconds_Behind_Master' ${slaveFile} | awk -F ':' '{print $2}'`    
    if [ "${secondsBehindMaster}A" = "NULLA" ]    then
        secondsBehindMaster=8888   # 表示主从不同步
    fi
    #是从库时 获取主库ip
    master=`grep 'Master_Host' ${slaveFile} | awk -F ':' '{print $2}'`
    masterPort=`grep 'Master_Port' ${slaveFile} | awk -F ':' '{print $2}'`else
    master=""
    masterPort=""
    slaveRunning=0
    secondsBehindMaster=10000   # 不用检测fi
Copier après la connexion


Remarque : Seconds_Behind_Master, cette valeur est utilisée comme indicateur pour juger du délai maître-esclave. Alors, comment obtient-il cette valeur ? En même temps, pourquoi est-elle remise en question par de nombreuses personnes ? (Ce paragraphe est cité de http://blog.chinaunix.NET/uid-27038861-id-3686311.html)

Seconds_Behind_Master consiste à comparer l'horodatage de l'événement exécuté par sql_thread et l'horodatage de l'événement copiés par io_thread (en abrégé ts) sont comparés, et une telle différence est obtenue. Nous savons tous que le contenu du journal relais est exactement le même que celui du journal bin de la bibliothèque principale. Lors de l'enregistrement de l'instruction SQL, le ts à ce moment-là sera enregistré, donc la valeur de référence pour la comparaison provient du journal bin. En fait, il n'est pas nécessaire que le maître-esclave communique avec NTP. La synchronisation est effectuée, ce qui signifie qu'il n'est pas nécessaire de s'assurer que les horloges maître et esclave sont cohérentes. Vous constaterez également que la comparaison se produit réellement entre io_thread et sql_thread, et que io_thread est vraiment lié à la bibliothèque principale. Ensuite, le problème survient lorsque la charge d'E/S de la bibliothèque principale est lourde ou que le réseau est bloqué, io_thread ne peut pas y accéder. Copiez le binlog (pas d'interruption, toujours en train de copier), et sql_thread peut toujours suivre le script io_thread. À l'heure actuelle, la valeur de Seconds_Behind_Master est 0, ce que nous pensons être un délai, mais en fait ce n'est pas le cas. , Vous savez. C'est pourquoi tout le monde critique l'utilisation de ce paramètre pour vérifier si le délai de la base de données est inexact, mais cette valeur n'est pas toujours inexacte. Si le io_thread et le réseau maître sont très bons, alors cette valeur est également très précise.

Avant, il a été mentionné que le paramètre Seconds_Behind_Master aura une valeur négative. Nous savons déjà que cette valeur est la différence entre le dernier ts de io_thread et le ts exécuté par le nouveau ts et sql_thread. supérieur à ce dernier, et la seule possibilité est qu'une erreur se soit produite dans le ts d'un certain événement, qui est plus petit que le précédent. Ensuite, lorsque cela se produit, il devient possible que des valeurs négatives apparaissent.

28. Détecter et collecter le battement de cœur de l'agent

Ce qui précède est le contenu de la série Mysql (12) Opération de surveillance Mysql Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www. .php.cn) !

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal