Skip to content
KARINKARIN
博客主页
项目总览
知识要点
捣鼓折腾
Git笔记
Excel修炼秘籍
github icon
  • 博客主页
    • 项目总览
          • Shell脚本笔记
            • Shell脚本介绍
              • Shell语法
                • Shell格式化输出
                  • Shell格式化输入
                    • Shell变量
                      • Shell数组
                        • Shell运算
                          • Shell流程控制---if判断语句
                            • Shell流程控制---for循环语句
                              • Shell流程控制---while循环语句
                                • Shell流程控制---until循环语句
                                  • Shell流程控制---case分支语句
                                    • Shell函数
                                      • Shell正则表达式
                                        • Shell对文本的搜索---grep命令
                                          • Shell对文件的操作---sed命令
                                            • Shell对输出流的处理---awk命令
                                              • Shell监控脚本
                                                • 脚本目的
                                                  • 试写脚本
                                                    • 监控一个机器的存活状态
                                                      • 监控一个端口的开启状态
                                                        • 监控内存使用率脚本
                                                          • 监控使用 CPU 或内存前十名的进程
                                                            • 监控硬盘 IO 脚本
                                                              • 监控脚本的总结
                                                            • Shell脚本---lamp环境安装

                                                          Shell监控脚本

                                                          author iconkarincalendar icon2021年4月9日category icon
                                                          • 教程
                                                          tag icon
                                                          • shell
                                                          timer icon大约 4 分钟

                                                          此页内容
                                                          • 脚本目的
                                                          • 试写脚本
                                                            • 监控一个机器的存活状态
                                                            • 监控一个端口的开启状态
                                                            • 监控内存使用率脚本
                                                            • 监控使用 CPU 或内存前十名的进程
                                                            • 监控硬盘 IO 脚本
                                                            • 监控脚本的总结

                                                          # 脚本目的

                                                          • 监控一个机器的存活状态
                                                          • 监控一个端口的开启状态
                                                          • 监控内存使用率脚本
                                                          • 找出使用 CPU 或 memory 前十的进程
                                                          • 监控硬盘 IO 脚本

                                                          # 试写脚本

                                                          下面的几个脚本实例中,脚本的开头信息省略,大致内容如下:

                                                          #Description: xxx
                                                          #Author: xxx
                                                          #Created Time: yyyy/mm/dd hh:mm
                                                          
                                                          1
                                                          2
                                                          3

                                                          脚本如何写,需要一个思路框架,比如:

                                                          需要用什么命令,命令的具体用法;

                                                          需要循环时如何去循环,匹配时如何去匹配;

                                                          如何一步一步的接近脚本的目的;

                                                          ……

                                                          不同的脚本需要不同的思路方法,就需要具体情况具体对待;当然,同一个脚本可以有不同的写法,前期只要能达目的就好,后期则需要慢慢去优化脚本,毕竟效率高能节省很多系统资源和时间。

                                                          # 监控一个机器的存活状态

                                                          思路:

                                                          • 监控方法:ping

                                                            • ping 得通:host up

                                                            • ping 不通:host down

                                                          • 问题:关于禁 ping,禁的是陌生人(禁止所有,允许你的)

                                                          • 条件:网络延迟,假报警问题

                                                          • ping 的取值,ping 几次,间隔几秒,ping 都失败判断机器状态为 down

                                                          代码:

                                                          [root@localhost~ ]# vim host_status.sh
                                                          #!/bin/bash
                                                          #测试代码,ping3次
                                                          for ((i=1;i<4;i++));do
                                                          	if ping -c1 $1 &>/dev/null;then
                                                          		export ping_count"$i"=1
                                                          	else	
                                                          		export ping_count"$i"=0
                                                          	fi
                                                          #每次ping的时间间隔(秒)
                                                          	sleep 3
                                                          done
                                                          #如果3次ping都失败则报警机器存活状态为down
                                                          if [ $ping_count -eq $ping_count2 ] && [ $ping_count2 -eq $ping_count3 ] && [$ping_count1 -eq 0 ];then
                                                          	echo "$1 is down"
                                                          else	
                                                          	echo "$1 is up"
                                                          fi
                                                          unset ping_count1
                                                          unset ping_count2
                                                          unset ping_count3
                                                          [root@localhost ~ ]# bash host_status.sh 192.168.2.88
                                                          192.168.2.88 is up
                                                          [root@localhost ~ ]# bash host_status.sh 192.168.2.99
                                                          192.168.2.99 is down
                                                          
                                                          1
                                                          2
                                                          3
                                                          4
                                                          5
                                                          6
                                                          7
                                                          8
                                                          9
                                                          10
                                                          11
                                                          12
                                                          13
                                                          14
                                                          15
                                                          16
                                                          17
                                                          18
                                                          19
                                                          20
                                                          21
                                                          22
                                                          23
                                                          24
                                                          25

                                                          # 监控一个端口的开启状态

                                                          思路:

                                                          • 监控方法:当系统压力过大或服务 donw 了,a、b、c 方法也还可能监测到,不推荐 a. systemctl、service 服务启动状态 b. lsof 查看端口是否存在 c. ps 查看进程是否存在 d. telnet 测试端口是否有响应------推荐
                                                          • telnet 工具是否存在,没有的话需要安装

                                                          代码:

                                                          [root@localhost ~ ]# vim port_status.sh
                                                          #!/bin/bash
                                                          port_status(){
                                                          temp_file=`mktemp port_status.XXX`
                                                          #判断依赖命令telnet是否存在
                                                          [ ! -x /usr/bin/telnet ] && echo "telnet: not found command" && exit 1
                                                          #测试端口 $1 :IP	  $2:port
                                                          ( telnet $1 $2 << EOF
                                                          quit
                                                          EOF
                                                          ) &> $temp_file
                                                          
                                                          #分析文件中的内容,判断结果
                                                          if egrep "\^]" $temp_file &> /dev/null;then
                                                          	echo "$1 :$2 is open"
                                                          else
                                                          	echo "$1:$2 is close"
                                                          fi
                                                          rm -f $temp_file
                                                          }
                                                          #调用函数,别忘带参数
                                                          port_status $1 $2
                                                          [root@localhost ~ ]# bash port_status.sh 192.168.2.88 22
                                                          192.168.2.88:22 is open
                                                          [root@localhost ~ ]# bash port_status.sh 192.168.2.88 23
                                                          192.168.2.88:23 is close
                                                          
                                                          1
                                                          2
                                                          3
                                                          4
                                                          5
                                                          6
                                                          7
                                                          8
                                                          9
                                                          10
                                                          11
                                                          12
                                                          13
                                                          14
                                                          15
                                                          16
                                                          17
                                                          18
                                                          19
                                                          20
                                                          21
                                                          22
                                                          23
                                                          24
                                                          25
                                                          26

                                                          # 监控内存使用率脚本

                                                          思路:

                                                          • 监控方法: a. free b. cat /proc/meminfo
                                                          • 知识:内存的申请顺序 free--->cache--->buffer--->swap

                                                          代码:

                                                          [root@localhost ~ ]# vim memory_use.sh
                                                          #!/bin/bash
                                                          memory_use{
                                                          memory_used=`head -2 /proc/meminfo | awk 'NR==1{t=$2}NR==2{f=$2;print (t-f)*100/t"%"}'`
                                                          memory_cache=`head -5 /proc/meminfo | awk 'NR==1{t=$2}NR==5{c=$2;print c*100/t"%"}'`
                                                          memory_buffer=`head -4 /proc/meminfo | awk 'NR==1{t=$2}NR==2{b=$2;print b*100/t"%"}'`
                                                          echo -e "memory_used: $memory_used\tcache: $memory_cache\tbuffer: $memory_buffer"
                                                          }
                                                          memory_use
                                                          [root@localhost ~ ]# bash memory_use.sh
                                                          memory_used: 8.83752%		cache: 0.03784%		buffer: 5.74635%
                                                          
                                                          1
                                                          2
                                                          3
                                                          4
                                                          5
                                                          6
                                                          7
                                                          8
                                                          9
                                                          10
                                                          11

                                                          # 监控使用 CPU 或内存前十名的进程

                                                          思路:

                                                          监控方法: ps 命令 top 命令 整合:对任务管理器的进程进行排序、整合(按 CPU 或内存)

                                                          代码:

                                                          [root@localhost ~ ]# vim cpu_memory_use.sh
                                                          memory(){
                                                          #收集任务管理器进程信息
                                                          temp_file=`mktemp memory.XXX`
                                                          top -b -n 1 > $temp_file
                                                          #按进程统计内存使用大小
                                                          tail -n +8 $temp_file | awk '{array[$NF]+=$6}END{for (i in array) print array[i],i}' | sort -k 1 -n -r | head -10
                                                          rm -f $temp_file
                                                          }
                                                          cpu(){
                                                          #收集任务管理器进程信息
                                                          temp_file=`mktemp cpu.XXX`
                                                          top -b -n 1 > $temp_file
                                                          #按进程统计cpu使用大小
                                                          tail -n +8 $temp_file | awk '{array[$NF]+=$9}END{for (i in array) print array[i],i}' | sort -k 1 -n -r | head -10
                                                          rm -f $temp_file
                                                          }
                                                          echo 占用memory前十进程:
                                                          memory
                                                          echo 占用cpu前十进程:
                                                          cpu
                                                          [root@localhost ~ ]# bash cpu_memory_use.sh
                                                          占用memory前十进程:
                                                          614380 Content
                                                          363520 gnome-shell
                                                          324108 firefox
                                                          158612 Xorg
                                                          154868 gnome-software
                                                          151000 Cont
                                                          131300 evolution-calen
                                                          114968 WebExtensions
                                                          62176 nautilus-deskto
                                                          55484 evolution-addre
                                                          占用cpu前十进程:
                                                          23.5 top
                                                          11.8 gnome-shell
                                                          11.8 Content
                                                          5.9 Xorg
                                                          5.9 firefox
                                                          0 xdg-permission-
                                                          0 writeback
                                                          0 wpa_supplicant
                                                          0 whoopsie
                                                          0 WebExtensions
                                                          
                                                          1
                                                          2
                                                          3
                                                          4
                                                          5
                                                          6
                                                          7
                                                          8
                                                          9
                                                          10
                                                          11
                                                          12
                                                          13
                                                          14
                                                          15
                                                          16
                                                          17
                                                          18
                                                          19
                                                          20
                                                          21
                                                          22
                                                          23
                                                          24
                                                          25
                                                          26
                                                          27
                                                          28
                                                          29
                                                          30
                                                          31
                                                          32
                                                          33
                                                          34
                                                          35
                                                          36
                                                          37
                                                          38
                                                          39
                                                          40
                                                          41
                                                          42
                                                          43
                                                          44

                                                          # 监控硬盘 IO 脚本

                                                          思路:

                                                          监控命令: iostat(详解) iozone(第三方提供) 监控指标:IO 队列长度、IOPS、磁盘吞吐量

                                                          • iostat 命令详解 用法:iostat [选项] [<时间间隔> [次数]]
                                                            • 选项说明: -c:只显示系统 CPU 统计信息 -d:只显示 Device 结果 -k/-m:输出结果以 kB/mB 为单位 -x:输出更详细的 io 设备统计信息 interval/count:每次输出间隔时间/输出次数(不带 count 则循环输出)

                                                          代码:

                                                          [root@localhost ~ ]# vim io.sh
                                                          #!/bin/bash
                                                          io(){
                                                          decice_num=`iostat -x | egrep "^sd[a-z]" | wc -l`
                                                          iostat -x 1 3 | egrep "^sd[a-z]" | tail -n +$((device_num+1)) | awk '{io_long[$1]+=$9}END{for (i in io_long)print io_long[i],i}'
                                                          }
                                                          io
                                                          [root@localhost ~ ]# bash io.sh
                                                          72.28  sda
                                                          
                                                          1
                                                          2
                                                          3
                                                          4
                                                          5
                                                          6
                                                          7
                                                          8
                                                          9

                                                          # 监控脚本的总结

                                                          • 监控项:机器、服务、资源、进程、端口……
                                                          • 阈值:根据预设监控项的阈值,分多种情况
                                                          • 监控方法:命令、思路、定义函数、运行方法、调用方法……
                                                          • 返回值:根据监控项的阈值,来返回对应的值

                                                          上面的几个脚本都是常见的监控脚本写法,以后遇到监控脚步要会举一反三。当然具体如何监控的细节,需要自己去思考。

                                                          edit icon编辑此页open in new window
                                                          上一页
                                                          Shell对输出流的处理---awk命令
                                                          下一页
                                                          Shell脚本---lamp环境安装
                                                          MIT Licensed
                                                          Copyright © 2022 karin