Shell

检测两台服务器指定目录下的文件一致性

  1. #!/bin/bash
  2. #####################################
  3. #检测两台服务器指定目录下的文件一致性
  4. #####################################
  5. #通过对比两台服务器上文件的md5值，达到检测一致性的目的
  6. dir=/data/web
  7. b_ip=192.168.88.10
  8. #将指定目录下的文件全部遍历出来并作为md5sum命令的参数，进而得到所有文件的md5值，并写入到指定文件中
  9. find $dir -type f|xargs md5sum > /tmp/md5_a.txt
  10. ssh $b_ip "find $dir -type f|xargs md5sum > /tmp/md5_b.txt"
  11. scp $b_ip:/tmp/md5_b.txt /tmp
  12. #将文件名作为遍历对象进行一一比对
  13. for f in `awk '{print 2} /tmp/md5_a.txt'`
  14. do
  15. #以a机器为标准，当b机器不存在遍历对象中的文件时直接输出不存在的结果
  16. if grep -qw "$f" /tmp/md5_b.txt
  17. then
  18. md5_a=`grep -w "$f" /tmp/md5_a.txt|awk '{print 1}'`
  19. md5_b=`grep -w "$f" /tmp/md5_b.txt|awk '{print 1}'`
  20. #当文件存在时，如果md5值不一致则输出文件改变的结果
  21. if [ $md5_a != $md5_b ]
  22. then
  23. echo "$f changed."
  24. fi
  25. else
  26. echo "$f deleted."
  27. fi
  28. done

定时清空文件内容，定时记录文件大小

  1. #!/bin/bash
  2. ################################################################
  3. #每小时执行一次脚本（任务计划），当时间为0点或12点时，将目标目录下的所有文件内
  4. #容清空，但不删除文件，其他时间则只统计各个文件的大小，一个文件一行，输出到以时#间和日期命名的文件中，需要考虑目标目录下二级、三级等子目录的文件
  5. ################################################################
  6. logfile=/tmp/`date +%H-%F`.log
  7. n=`date +%H`
  8. if [ $n -eq 00 ] || [ $n -eq 12 ]
  9. then
  10. #通过for循环，以find命令作为遍历条件，将目标目录下的所有文件进行遍历并做相应操作
  11. for i in `find /data/log/ -type f`
  12. do
  13. true > $i
  14. done
  15. else
  16. for i in `find /data/log/ -type f`
  17. do
  18. du -sh $i >> $logfile
  19. done
  20. fi

检测网卡流量，并按规定格式记录在日志中

  1. #!/bin/bash
  2. #######################################################
  3. #检测网卡流量，并按规定格式记录在日志中
  4. #规定一分钟记录一次
  5. #日志格式如下所示:
  6. #2019-08-12 20:40
  7. #ens33 input: 1234bps
  8. #ens33 output: 1235bps
  9. ######################################################3
  10. while :
  11. do
  12. #设置语言为英文，保障输出结果是英文，否则会出现bug
  13. LANG=en
  14. logfile=/tmp/`date +%d`.log
  15. #将下面执行的命令结果输出重定向到logfile日志中
  16. exec >> $logfile
  17. date +"%F %H:%M"
  18. #sar命令统计的流量单位为kb/s，日志格式为bps，因此要*1000*8
  19. sar -n DEV 1 59|grep Average|grep ens33|awk '{print $2,"\t","input:","\t",$5*1000*8,"bps","\n",$2,"\t","output:","\t",$6*1000*8,"bps"}'
  20. echo "####################"
  21. #因为执行sar命令需要59秒，因此不需要sleep
  22. done

计算文档每行出现的数字个数，并计算整个文档的数字总数

  1. #!/bin/bash
  2. #########################################################
  3. #计算文档每行出现的数字个数，并计算整个文档的数字总数
  4. ########################################################
  5. #使用awk只输出文档行数（截取第一段）
  6. n=`wc -l a.txt|awk '{print $1}'`
  7. sum=0
  8. #文档中每一行可能存在空格，因此不能直接用文档内容进行遍历
  9. for i in `seq 1 $n`
  10. do
  11. #输出的行用变量表示时，需要用双引号
  12. line=`sed -n "$i"p a.txt`
  13. #wc -L选项，统计最长行的长度
  14. n_n=`echo $line|sed s'/[^0-9]//'g|wc -L`
  15. echo $n_n
  16. sum=$[$sum+$n_n]
  17. done
  18. echo "sum:$sum"

杀死所有脚本

  1. #!/bin/bash
  2. ################################################################
  3. #有一些脚本加入到了cron之中，存在脚本尚未运行完毕又有新任务需要执行的情况，
  4. #导致系统负载升高，因此可通过编写脚本，筛选出影响负载的进程一次性全部杀死。
  5. ################################################################
  6. ps aux|grep 指定进程名|grep -v grep|awk '{print $2}'|xargs kill -9

从FTP服务器下载文件

  1. #!/bin/bash
  2. if [ $# -ne 1 ]; then
  3.     echo "Usage: $0 filename"
  4. fi
  5. dir=$(dirname $1)
  6. file=$(basename $1)
  7. ftp -n -v << EOF   # -n 自动登录
  8. open 192.168.1.10  # ftp服务器
  9. user admin password
  10. binary   # 设置ftp传输模式为二进制，避免MD5值不同或.tar.gz压缩包格式错误
  11. cd $dir
  12. get "$file"
  13. EOF

连续输入5个100以内的数字，统计和、最小和最大

  1. #!/bin/bash
  2. COUNT=1
  3. SUM=0
  4. MIN=0
  5. MAX=100
  6. while [ $COUNT -le 5 ]; do
  7.     read -p "请输入1-10个整数：" INT
  8.     if [[ ! $INT =~ ^[0-9]+$ ]]; then
  9.         echo "输入必须是整数！"
  10.         exit 1
  11.     elif [[ $INT -gt 100 ]]; then
  12.         echo "输入必须是100以内！"
  13.         exit 1
  14.     fi
  15.     SUM=$(($SUM+$INT))
  16.     [ $MIN -lt $INT ] && MIN=$INT
  17.     [ $MAX -gt $INT ] && MAX=$INT
  18.     let COUNT++
  19. done
  20. echo "SUM: $SUM"
  21. echo "MIN: $MIN"
  22. echo "MAX: $MAX"

用户猜数字

  1. #!/bin/bash  
  2. # 脚本生成一个 100 以内的随机数,提示用户猜数字,根据用户的输入,提示用户猜对了,
  3. # 猜小了或猜大了,直至用户猜对脚本结束。
  4. # RANDOM 为系统自带的系统变量,值为 0‐32767的随机数
  5. # 使用取余算法将随机数变为 1‐100 的随机数num=$[RANDOM%100+1]echo "$num" 
  6. # 使用 read 提示用户猜数字
  7. # 使用 if 判断用户猜数字的大小关系:‐eq(等于),‐ne(不等于),‐gt(大于),‐ge(大于等于),
  8. # ‐lt(小于),‐le(小于等于)
  9. while :do     
  10. read -p "计算机生成了一个 1‐100 的随机数,你猜: " cai    
  11. if [ $cai -eq $num ]    
  12. then        
  13. echo "恭喜,猜对了"           
  14. exit        
  15. elif [ $cai -gt $num ]        
  16. then            
  17. echo "Oops,猜大了"         
  18. else            
  19. echo "Oops,猜小了"     
  20. fi
  21. done

监测Nginx访问日志502情况，并做相应动作

假设服务器环境为lnmp，近期访问经常出现502现象，且502错误在重启php-fpm服务后消失，因此需要编写监控脚本，一旦出现502，则自动重启php-fpm服务。

  1. #场景：
  2. #1.访问日志文件的路径：/data/log/access.log
  3. #2.脚本死循环，每10秒检测一次，10秒的日志条数为300条，出现502的比例不低于10%（30条）则需要重启php-fpm服务
  4. #3.重启命令为：/etc/init.d/php-fpm restart
  5. #!/bin/bash
  6. ###########################################################
  7. #监测Nginx访问日志502情况，并做相应动作
  8. ###########################################################
  9. log=/data/log/access.log
  10. N=30 #设定阈值
  11. while :
  12. do
  13.  #查看访问日志的最新300条，并统计502的次数
  14.     err=`tail -n 300 $log |grep -c '502" '`
  15.  if [ $err -ge $N ]
  16.  then
  17.  /etc/init.d/php-fpm restart 2> /dev/null
  18.  #设定60s延迟防止脚本bug导致无限重启php-fpm服务
  19.      sleep 60
  20.  fi
  21.  sleep 10
  22. done

将结果分别赋值给变量

  1. 应用场景：希望将执行结果或者位置参数赋值给变量，以便后续使用。
  2. 方法1：
  3. for i in $(echo "4 5 6"); do
  4.    eval a$i=$i
  5. done
  6. echo $a4 $a5 $a6
  7. 方法2：将位置参数192.168.1.1{1,2}拆分为到每个变量
  8. num=0
  9. for i in $(eval echo $*);do   #eval将{1,2}分解为1 2
  10.    let num+=1
  11.    eval node${num}="$i"
  12. done
  13. echo $node1 $node2 $node3
  14. # bash a.sh 192.168.1.1{1,2}
  15. 192.168.1.11 192.168.1.12
  16. 方法3：
  17. arr=(4 5 6)
  18. INDEX1=$(echo ${arr[0]})
  19. INDEX2=$(echo ${arr[1]})
  20. INDEX3=$(echo ${arr[2]})

批量修改文件名

  1. 示例：
  2. # touch article_{1..3}.html
  3. # ls
  4. article_1.html  article_2.html  article_3.html
  5. 目的：把article改为bbs
  6. 方法1：
  7. for file in $(ls *html); do
  8.     mv $file bbs_${file#*_}
  9.     # mv $file $(echo $file |sed -r 's/.*(_.*)/bbs\1/')
  10.     # mv $file $(echo $file |echo bbs_$(cut -d_ -f2)
  11. done
  12. 方法2：
  13. for file in $(find . -maxdepth 1 -name "*html"); do
  14.      mv $file bbs_${file#*_}
  15. done
  16. 方法3：
  17. # rename article bbs *.html

把一个文档前五行中包含字母的行删掉，同时删除6到10行包含的所有字母

1）准备测试文件，文件名为2.txt

  1. 第1行1234567不包含字母
  2. 第2行56789BBBBBB
  3. 第3行67890CCCCCCCC
  4. 第4行78asdfDDDDDDDDD
  5. 第5行123456EEEEEEEE
  6. 第6行1234567ASDF
  7. 第7行56789ASDF
  8. 第8行67890ASDF
  9. 第9行78asdfADSF
  10. 第10行123456AAAA
  11. 第11行67890ASDF
  12. 第12行78asdfADSF
  13. 第13行123456AAAA

2）脚本如下：

  1. #!/bin/bash
  2. ##############################################################
  3. #把一个文档前五行中包含字母的行删掉，同时删除6到10行包含的所有字母
  4. ##############################################################
  5. sed -n '1,5'p 2.txt |sed '/[a-zA-Z]/'d
  6. sed -n '6,10'p 2.txt |sed s'/[a-zA-Z]//'g
  7. sed -n '11,$'p 2.txt
  8. #最终结果只是在屏幕上打印结果，如果想直接更改文件，可将输出结果写入临时文件中，再替换2.txt或者使用-i选项

统计当前目录中以.html结尾的文件总大

  1. 方法1：
  2. # find . -name "*.html" -exec du -k {} \; |awk '{sum+=$1}END{print sum}'
  3. 方法2：
  4. for size in $(ls -l *.html |awk '{print $5}'); do
  5.     sum=$(($sum+$size))
  6. done
  7. echo $sum

扫描主机端口状态

  1. #!/bin/bash
  2. HOST=$1
  3. PORT="22 25 80 8080"
  4. for PORT in $PORT; do
  5.     if echo &>/dev/null > /dev/tcp/$HOST/$PORT; then
  6.         echo "$PORT open"
  7.     else
  8.         echo "$PORT close"
  9.     fi
  10. done

用shell打印示例语句中字母数小于6的单词

  1. #示例语句：
  2. #Bash also interprets a number of multi-character options.
  3. #!/bin/bash
  4. ##############################################################
  5. #shell打印示例语句中字母数小于6的单词
  6. ##############################################################
  7. for s in Bash also interprets a number of multi-character options.
  8. do
  9.  n=`echo $s|wc -c`
  10.  if [ $n -lt 6 ]
  11.  then
  12.  echo $s
  13.  fi
  14. done

输入数字运行相应命令

  1. #!/bin/bash
  2. ##############################################################
  3. #输入数字运行相应命令
  4. ##############################################################
  5. echo "*cmd menu* 1-date 2-ls 3-who 4-pwd 0-exit "
  6. while :
  7. do
  8. #捕获用户键入值
  9.  read -p "please input number :" n
  10.  n1=`echo $n|sed s'/[0-9]//'g`
  11. #空输入检测 
  12.  if [ -z "$n" ]
  13.  then
  14.  continue
  15.  fi
  16. #非数字输入检测 
  17.  if [ -n "$n1" ]
  18.  then
  19.  exit 0
  20.  fi
  21.  break
  22. done
  23. case $n in
  24.  1)
  25.  date
  26.  ;;
  27.  2)
  28.  ls
  29.  ;;
  30.  3)
  31.  who
  32.  ;;
  33.  4)
  34.  pwd
  35.  ;;
  36.  0)
  37.  break
  38.  ;;
  39.     #输入数字非1-4的提示
  40.  *)
  41.  echo "please input number is [1-4]"
  42. esac

Expect实现SSH免交互执行命令

  1. # Expect是一个自动交互式应用程序的工具，如telnet，ftp，passwd等。
  2. # 需先安装expect软件包。
  3. # 方法1：EOF标准输出作为expect标准输入
  4. #!/bin/bash
  5. USER=root
  6. PASS=123.com
  7. IP=192.168.1.120
  8. expect << EOF
  9. set timeout 30
  10. spawn ssh $USER@$IP   
  11. expect {
  12.     "(yes/no)" {send "yes\r"; exp_continue}
  13.     "password:" {send "$PASS\r"}
  14. }
  15. expect "$USER@*"  {send "$1\r"}
  16. expect "$USER@*"  {send "exit\r"}
  17. expect eof
  18. EOF
  19. 方法2：
  20. #!/bin/bash
  21. USER=root
  22. PASS=123.com
  23. IP=192.168.1.120
  24. expect -c "
  25.     spawn ssh $USER@$IP
  26.     expect {
  27.         \"(yes/no)\" {send \"yes\r\"; exp_continue}
  28.         \"password:\" {send \"$PASS\r\"; exp_continue}
  29.         \"$USER@*\" {send \"df -h\r exit\r\"; exp_continue}
  30.     }"
  31. 方法3：将expect脚本独立出来
  32. 登录脚本：
  33. # cat login.exp
  34. #!/usr/bin/expect
  35. set ip [lindex $argv 0]
  36. set user [lindex $argv 1]
  37. set passwd [lindex $argv 2]
  38. set cmd [lindex $argv 3]
  39. if { $argc != 4 } {
  40. puts "Usage: expect login.exp ip user passwd"
  41. exit 1
  42. }
  43. set timeout 30
  44. spawn ssh $user@$ip
  45. expect {
  46.     "(yes/no)" {send "yes\r"; exp_continue}
  47.     "password:" {send "$passwd\r"}
  48. }
  49. expect "$user@*"  {send "$cmd\r"}
  50. expect "$user@*"  {send "exit\r"}
  51. expect eof
  52. 执行命令脚本：写个循环可以批量操作多台服务器
  53. #!/bin/bash
  54. HOST_INFO=user_info.txt
  55. for ip in $(awk '{print $1}' $HOST_INFO)
  56. do
  57.     user=$(awk -v I="$ip" 'I==$1{print $2}' $HOST_INFO)
  58.     pass=$(awk -v I="$ip" 'I==$1{print $3}' $HOST_INFO)
  59.     expect login.exp $ip $user $pass $1
  60. done
  61. Linux主机SSH连接信息：
  62. # cat user_info.txt
  63. 192.168.1.120 root 123456

创建10个用户，并分别设置密码，密码要求10位且包含大小写字母以及数字，最后需要把每个用户的密码存在指定文件中

  1. #!/bin/bash
  2. ##############################################################
  3. #创建10个用户，并分别设置密码，密码要求10位且包含大小写字母以及数字
  4. #最后需要把每个用户的密码存在指定文件中
  5. #前提条件：安装mkpasswd命令
  6. ##############################################################
  7. #生成10个用户的序列（00-09）
  8. for u in `seq -w 0 09`
  9. do
  10.  #创建用户
  11.  useradd user_$u
  12.  #生成密码
  13.  p=`mkpasswd -s 0 -l 10`
  14.  #从标准输入中读取密码进行修改（不安全）
  15.  echo $p|passwd --stdin user_$u
  16.  #常规修改密码
  17.  echo -e "$p\n$p"|passwd user_$u
  18.  #将创建的用户及对应的密码记录到日志文件中
  19.  echo "user_$u $p" >> /tmp/userpassword
  20. done

监控httpd的进程数，根据监控情况做相应处理

  1. #!/bin/bash
  2. ###############################################################################################################################
  3. #需求：
  4. #1.每隔10s监控httpd的进程数，若进程数大于等于500，则自动重启Apache服务，并检测服务是否重启成功
  5. #2.若未成功则需要再次启动，若重启5次依旧没有成功，则向管理员发送告警邮件，并退出检测
  6. #3.如果启动成功，则等待1分钟后再次检测httpd进程数，若进程数正常，则恢复正常检测（10s一次），否则放弃重启并向管理员发送告警邮件，并退出检测
  7. ###############################################################################################################################
  8. #计数器函数
  9. check_service()
  10. {
  11.  j=0
  12.  for i in `seq 1 5` 
  13.  do
  14.  #重启Apache的命令
  15.  /usr/local/apache2/bin/apachectl restart 2> /var/log/httpderr.log
  16.     #判断服务是否重启成功
  17.  if [ $? -eq 0 ]
  18.  then
  19.  break
  20.  else
  21.  j=$[$j+1]
  22.  fi
  23.     #判断服务是否已尝试重启5次
  24.  if [ $j -eq 5 ]
  25.  then
  26.  mail.py
  27.  exit
  28.  fi
  29.  done 
  30. }
  31. while :
  32. do
  33.  n=`pgrep -l httpd|wc -l`
  34.  #判断httpd服务进程数是否超过500
  35.  if [ $n -gt 500 ]
  36.  then
  37.  /usr/local/apache2/bin/apachectl restart
  38.  if [ $? -ne 0 ]
  39.  then
  40.  check_service
  41.  else
  42.  sleep 60
  43.  n2=`pgrep -l httpd|wc -l`
  44.  #判断重启后是否依旧超过500
  45.              if [ $n2 -gt 500 ]
  46.  then 
  47.  mail.py
  48.  exit
  49.  fi
  50.  fi
  51.  fi
  52.  #每隔10s检测一次
  53.  sleep 10
  54. done

批量修改服务器用户密码

  1. Linux主机SSH连接信息：旧密码
  2. # cat old_pass.txt 
  3. 192.168.18.217  root    123456     22
  4. 192.168.18.218  root    123456     22
  5. 内容格式：IP User Password Port
  6. SSH远程修改密码脚本：新密码随机生成
  7. https://www.linuxprobe.com/books
  8. #!/bin/bash
  9. OLD_INFO=old_pass.txt
  10. NEW_INFO=new_pass.txt
  11. for IP in $(awk '/^[^#]/{print $1}' $OLD_INFO); do
  12.     USER=$(awk -v I=$IP 'I==$1{print $2}' $OLD_INFO)
  13.     PASS=$(awk -v I=$IP 'I==$1{print $3}' $OLD_INFO)
  14.     PORT=$(awk -v I=$IP 'I==$1{print $4}' $OLD_INFO)
  15.     NEW_PASS=$(mkpasswd -l 8)  # 随机密码
  16.     echo "$IP   $USER   $NEW_PASS   $PORT" >> $NEW_INFO
  17.     expect -c "
  18.     spawn ssh -p$PORT $USER@$IP
  19.     set timeout 2
  20.     expect {
  21.         \"(yes/no)\" {send \"yes\r\";exp_continue}
  22.         \"password:\" {send \"$PASS\r\";exp_continue}
  23.         \"$USER@*\" {send \"echo \'$NEW_PASS\' |passwd --stdin $USER\r exit\r\";exp_continue}
  24.     }"
  25. done
  26. 生成新密码文件：
  27. # cat new_pass.txt 
  28. 192.168.18.217  root    n8wX3mU%      22
  29. 192.168.18.218  root    c87;ZnnL      22

iptables自动屏蔽访问网站频繁的IP

  1. 场景：恶意访问,安全防范
  2. 1）屏蔽每分钟访问超过200的IP
  3. 方法1：根据访问日志（Nginx为例）
  4. #!/bin/bash
  5. DATE=$(date +%d/%b/%Y:%H:%M)
  6. ABNORMAL_IP=$(tail -n5000 access.log |grep $DATE |awk '{a[$1]++}END{for(i in a)if(a[i]>100)print i}')
  7. #先tail防止文件过大，读取慢，数字可调整每分钟最大的访问量。awk不能直接过滤日志，因为包含特殊字符。
  8. for IP in $ABNORMAL_IP; do
  9.     if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
  10.         iptables -I INPUT -s $IP -j DROP
  11.     fi
  12. done
  13. 方法2：通过TCP建立的连接
  14. #!/bin/bash
  15. ABNORMAL_IP=$(netstat -an |awk '$4~/:80$/ && $6~/ESTABLISHED/{gsub(/:[0-9]+/,"",$5);{a[$5]++}}END{for(i in a)if(a[i]>100)print i}')
  16. #gsub是将第五列（客户端IP）的冒号和端口去掉
  17. for IP in $ABNORMAL_IP; do
  18.     if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
  19.         iptables -I INPUT -s $IP -j DROP
  20.     fi
  21. done
  22. 2）屏蔽每分钟SSH尝试登录超过10次的IP
  23. 方法1：通过lastb获取登录状态:
  24. #!/bin/bash
  25. DATE=$(date +"%a %b %e %H:%M") #星期月天时分  %e单数字时显示7，而%d显示07
  26. ABNORMAL_IP=$(lastb |grep "$DATE" |awk '{a[$3]++}END{for(i in a)if(a[i]>10)print i}')
  27. for IP in $ABNORMAL_IP; do
  28.     if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
  29.         iptables -I INPUT -s $IP -j DROP
  30.     fi
  31. done
  32. 方法2：通过日志获取登录状态
  33. #!/bin/bash
  34. DATE=$(date +"%b %d %H")
  35. ABNORMAL_IP="$(tail -n10000 /var/log/auth.log |grep "$DATE" |awk '/Failed/{a[$(NF-3)]++}END{for(i in a)if(a[i]>5)print i}')"
  36. for IP in $ABNORMAL_IP; do
  37.     if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
  38.         iptables -A INPUT -s $IP -j DROP
  39.         echo "$(date +"%F %T") - iptables -A INPUT -s $IP -j DROP" >>~/ssh-login-limit.log
  40.     fi
  41. done

根据web访问日志，封禁请求量异常的IP，如IP在半小时后恢复正常，则解除封禁

  1. #!/bin/bash
  2. ####################################################################################
  3. #根据web访问日志，封禁请求量异常的IP，如IP在半小时后恢复正常，则解除封禁
  4. ####################################################################################
  5. logfile=/data/log/access.log
  6. #显示一分钟前的小时和分钟
  7. d1=`date -d "-1 minute" +%H%M`
  8. d2=`date +%M`
  9. ipt=/sbin/iptables
  10. ips=/tmp/ips.txt
  11. block()
  12. {
  13.  #将一分钟前的日志全部过滤出来并提取IP以及统计访问次数
  14.  grep '$d1:' $logfile|awk '{print $1}'|sort -n|uniq -c|sort -n > $ips
  15.  #利用for循环将次数超过100的IP依次遍历出来并予以封禁
  16.  for i in `awk '$1>100 {print $2}' $ips`
  17.  do
  18.  $ipt -I INPUT -p tcp --dport 80 -s $i -j REJECT
  19.  echo "`date +%F-%T` $i" >> /tmp/badip.log
  20.  done
  21. }
  22. unblock()
  23. {
  24.  #将封禁后所产生的pkts数量小于10的IP依次遍历予以解封
  25.  for a in `$ipt -nvL INPUT --line-numbers |grep '0.0.0.0/0'|awk '$2<10 {print $1}'|sort -nr`
  26.  do 
  27.  $ipt -D INPUT $a
  28.  done
  29.  $ipt -Z
  30. }
  31. #当时间在00分以及30分时执行解封函数
  32. if [ $d2 -eq "00" ] || [ $d2 -eq "30" ]
  33.  then
  34.  #要先解再封，因为刚刚封禁时产生的pkts数量很少
  35.  unblock
  36.  block
  37.  else
  38.  block
  39. fi

判断用户输入的是否为IP地址

  1. 方法1:
  2. #!/bin/bash
  3. function check_ip(){
  4.     IP=$1
  5.     VALID_CHECK=$(echo $IP|awk -F. '$1< =255&&$2<=255&&$3<=255&&$4<=255{print "yes"}')
  6.     if echo $IP|grep -E "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$">/dev/null; then
  7.         if [ $VALID_CHECK == "yes" ]; then
  8.             echo "$IP available."
  9.         else
  10.             echo "$IP not available!"
  11.         fi
  12.     else
  13.         echo "Format error!"
  14.     fi
  15. }
  16. check_ip 192.168.1.1
  17. check_ip 256.1.1.1
  18. 方法2：
  19. #!/bin/bash
  20. function check_ip(){
  21.     IP=$1
  22.     if [[ $IP =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
  23.         FIELD1=$(echo $IP|cut -d. -f1)
  24.         FIELD2=$(echo $IP|cut -d. -f2)
  25.         FIELD3=$(echo $IP|cut -d. -f3)
  26.         FIELD4=$(echo $IP|cut -d. -f4)
  27.         if [ $FIELD1 -le 255 -a $FIELD2 -le 255 -a $FIELD3 -le 255 -a $FIELD4 -le 255 ]; then
  28.             echo "$IP available."
  29.         else
  30.             echo "$IP not available!"
  31.         fi
  32.     else
  33.         echo "Format error!"
  34.     fi
  35. }
  36. check_ip 192.168.1.1
  37. check_ip 256.1.1.1
  38. 增加版：
  39. 加个死循环，如果IP可用就退出，不可用提示继续输入，并使用awk判断。
  40. #!/bin/bash
  41. function check_ip(){
  42.     local IP=$1
  43.     VALID_CHECK=$(echo $IP|awk -F. '$1< =255&&$2<=255&&$3<=255&&$4<=255{print "yes"}')
  44.     if echo $IP|grep -E "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$" >/dev/null; then
  45.         if [ $VALID_CHECK == "yes" ]; then
  46.             return 0
  47.         else
  48.             echo "$IP not available!"
  49.             return 1
  50.         fi
  51.     else
  52.         echo "Format error! Please input again."
  53.         return 1
  54.     fi
  55. }
  56. while true; do
  57.     read -p "Please enter IP: " IP
  58.     check_ip $IP
  59.     [ $? -eq 0 ] && break || continue
  60. done

并发从数台机器中获取 hostname，并记录返回信息花费的时长，重定向到一个文件 hostname.txt 中，在全部完成后输出花费时长最短的那台机器的 CPU 信息。

  1. #!bin/bash  
  2. # 所有主机，以空格分隔
  3. ALL_HOSTS=(IP 地址 IP 地址)
  4. for host in ${ALL_HOSTS[*]}
  5. do
  6. {
  7.     start_time=$(date +'%s')
  8.     ssh $host "hostname" &>/dev/null
  9.     sleep 2
  10.     stop_time=$(date +'%s')
  11.     time_consuming=$((stop_time-start_time))
  12.     echo "$host: $time_consuming" >>hostname.txt
  13. }&
  14. done
  15. wait
  16. host=$(sort -n -k 2 hostname.txt | head -1 | awk -F':' '{print $1}')
  17. ssh $host "top -b -n 1"

统计 /proc 目类下 Linux 进程相关数量信息，输出总进程数，running 进程数，stoped 进程数，sleeing 进程数，zombie 进程数。

输出所有 zombie 的进程到 zombie.txt 杀死所有 zombie 进程。

  1. #!/bin/bash
  2. ALL_PROCESS=$(ls /proc/ | egrep '[0-9]+')
  3. running_count=0
  4. stoped_count=0
  5. sleeping_count=0
  6. zombie_count=0
  7. for pid in ${ALL_PROCESS[*]}
  8. do
  9.     test -f /proc/$pid/status && state=$(egrep "State" /proc/$pid/status | awk '{print $2}')
  10.     case "$state" in
  11.         R)
  12.             running_count=$((running_count+1))
  13.         ;;
  14.         T)
  15.             stoped_count=$((stoped_count+1))
  16.         ;;
  17.         S)
  18.             sleeping_count=$((sleeping_count+1))
  19.         ;;
  20.         Z)
  21.             zombie_count=$((zombie_count+1))
  22.             echo "$pid" >>zombie.txt
  23.             kill -9 "$pid"
  24.         ;;
  25.     esac
  26. done
  27. echo -e "total: $((running_count+stoped_count+sleeping_count+zombie_count))\nrunning: $running_count\nstoped: $stoped_count\nsleeping: $sleeping_count\nzombie: $zombie_count"

把当前目录（包含子目录）下所有后缀为 “.sh” 的文件后缀变更为 “.shell”，之后删除每个文件的第二行。

  1. #!/bin/bash
  2. ALL_SH_FILE=$(find . -type f -name "*.sh")
  3. for file in ${ALL_SH_FILE[*]}
  4. do
  5.     filename=$(echo $file | awk -F'.sh' '{print $1}')
  6.     new_filename="${filename}.shell"
  7.     mv "$file" "$new_filename"
  8.     sed -i '2d' "$new_filename"
  9. done

判断目录 /tmp/jstack 是否存在，不存在则新建一个目录，若存在则删除目录下所有内容。

每隔 1 小时打印 inceptor server 的 jstack 信息，并以 jstack_${当前时间} 命名文件，每当目录下超过 10 个文件后，删除最旧的文件。

  1. #!/bin/bash
  2. DIRPATH='/tmp/jstack'
  3. CURRENT_TIME=$(date +'%F'-'%H:%M:%S')
  4. if [ ! -d "$DIRPATH" ];then
  5.     mkdir "$DIRPATH"
  6. else
  7.     rm -rf "$DIRPATH"/*
  8. fi
  9. cd "$DIRPATH"
  10. while true
  11. do
  12.     sleep 3600
  13.     # 这里需要将inceptor改后自己的java进程名称
  14.     pid=$(ps -ef | grep 'inceptor' | grep -v grep | awk '{print $2}')
  15.     jstack $pid >> "jstack_${CURRENT_TIME}"
  16.     dir_count=$(ls | wc -l)
  17.     if [ "$dir_count" -gt 10 ];then
  18.        rm -f $(ls -tr | head -1)
  19.     fi
  20. done

从 test.log 中截取当天的所有 gc 信息日志，并统计 gc 时间的平均值和时长最长的时间。

  1. #!/bin/bash
  2. awk '{print $2}' hive-server2.log | tr -d ':' | awk '{sum+=$1} END {print "avg: ", sum/NR}' >>capture_hive_log.log
  3. awk '{print $2}' hive-server2.log | tr -d ':' | awk '{max = 0} {if ($1+0 > max+0) max=$1} END {print "Max: ", max}'>>capture_hive_log.log

查找 80 端口请求数最高的前 20 个 IP 地址，判断中间最小的请求数是否大于 500，如大于 500，则输出系统活动情况报告到 alert.txt，如果没有，则在 600s 后重试，直到有输出为止。

  1. #!/bin/bash
  2. state="true"
  3. while $state
  4. do
  5.     SMALL_REQUESTS=$(netstat -ant | awk -F'[ :]+' '/:22/{count[$4]++} END {for(ip in count) print count[ip]}' | sort -n | head -20 | head -1)
  6.     if [ "$SMALL_REQUESTS" -gt 500 ];then
  7.         sar -A > alert.txt
  8.         state="false"
  9.     else
  10.         sleep 6
  11.         continue
  12.     fi
  13. done

将当前目录下大于 10K 的文件转移到 /tmp 目录，再按照文件大小顺序，从大到小输出文件名。

  1. #!/bin/bash
  2. # 目标目录
  3. DIRPATH='/tmp'
  4. # 查看目录
  5. FILEPATH='.'
  6. find "$FILEPATH" -size +10k -type f | xargs -i mv {} "$DIRPATH"
  7. ls -lS "$DIRPATH" | awk '{if(NR>1) print $NF}'