【shell 常用脚本30例】

先了解下编写Shell过程中注意事项

• 开头加解释器：#!/bin/bash
• 语法缩进，使用四个空格；多加注释说明。
• 命名建议规则：全局变量名大写、局部变量小写，函数名小写，名字体现出实际作用。
• 默认变量是全局的，在函数中变量local指定为局部变量，避免污染其他作用域。
• 有两个命令能帮助我调试脚本：set -e 遇到执行非0时退出脚本，set-x 打印执行过程。
• 写脚本一定先测试再到生产上。

1、获取随机字符串或数字

获取随机8位字符串

方法1：
# echo $RANDOM |md5sum |cut -c 1-8
c9f36977
#这个命令使用$RANDOM变量生成一个随机的整数，然后将其经过MD5哈希处理，并使用cut命令截取前8个字符作为生成的随机字符串。
方法2：
# openssl rand -base64 4
f4C+pw==
#这个命令使用openssl命令生成一个长度为4的随机字节流
方法3：
# cat /proc/sys/kernel/random/uuid  | cut -c 1-8
c1268803
#只是截取了 UUID 的前8个字符，并不是生成一个随机的8位字符串

获取随机8位数字

方法1：
# echo $RANDOM | cksum |cut -c 1-8
55264714
#这个命令使用$RANDOM变量生成一个随机的整数，并通过cksum命令对其进行校验和计算，然后使用cut命令截取校验和结果的前8个字符作为生成的随机8位数字
方法2：
# openssl rand -base64 4 |cksum |cut -c 1-8
30318431
#这个命令使用openssl rand命令生成一个长度为4的随机字节流，并通过cksum命令对其进行校验和计算，然后使用cut命令截取校验和结果的前8个字符作为生成的随机8位数字
方法3：
# date +%N |cut -c 1-8
94705141
#这个命令使用date命令获取当前时间的纳秒部分，并使用cut命令截取前8个字符作为生成的随机8位数字

2、定义一个颜色输出字符串函数

方法1：

# 定义一个输出带颜色文本的函数
function echo_color() {
    # 判断参数值是否为 "green"
    if [ $1 == "green" ]; then
        # 使用绿色的前景色输出文本
        echo -e "\e[1;32m$2\e[0m"
    # 判断参数值是否为 "red"
    elif [ $1 == "red" ]; then
        # 使用红色的前景色输出文本
        echo -e "\033[31m$2\033[0m"
    fi
}
方法2：

# 定义一个输出带颜色文本的函数
function echo_color() {
    # 根据参数值进行匹配
    case $1 in
        # 如果参数值为 "green"
        green)
            # 使用绿色的前景色输出文本
            echo -e "\e[1;32m$2\e[0m"
            ;;
        # 如果参数值为 "red"
        red)
            # 使用红色的前景色输出文本
            echo -e "\033[31m$2\033[0m"
            ;;
        *) 
            # 参数值不在以上两种情况，则输出提示信息
            echo "Example: echo_color red string"
    esac
}
echo_color green "This is a green text"  #这行代码会输出绿色的文本 “This is a green text”。
echo_color red "This is a red text"   #这行代码会输出红色的文本 “This is a red text”。

3、批量创建用户

#!/bin/bash
DATE=$(date +%F_%T)  # 当前日期和时间，用于备份文件的命名
USER_FILE=user.txt  # 用户文件名

# 定义一个输出带颜色文本的函数
echo_color(){
    if [ $1 == "green" ]; then
        echo -e "\e[1;32m$2\e[0m"  # 输出绿色文本
    elif [ $1 == "red" ]; then
        echo -e "\033[31m$2\033[0m"  # 输出红色文本
    fi
}

# 如果用户文件存在并且大小大于0就备份
if [ -s $USER_FILE ]; then
    mv $USER_FILE ${USER_FILE}-${DATE}.bak  # 备份用户文件
    echo_color green "$USER_FILE exist, rename ${USER_FILE}-${DATE}.bak"  # 输出提示信息，绿色文本
fi

echo -e "User\tPassword" >> $USER_FILE  # 在用户文件中添加表头
echo "----------------" >> $USER_FILE  # 在用户文件中添加分隔线

# 创建用户，并记录到用户文件中
for USER in user{1..10}; do
    if ! id $USER &>/dev/null; then
        PASS=$(echo $RANDOM |md5sum |cut -c 1-8)  # 生成随机密码
        useradd $USER  # 创建用户
        echo $PASS |passwd --stdin $USER &>/dev/null  # 设置用户密码
        echo -e "$USER\t$PASS" >> $USER_FILE  # 在用户文件中添加用户名和密码
        echo "$USER User create successful."  # 输出创建用户成功的提示信息
    else
        echo_color red "$USER User already exists!"  # 输出用户已存在的提示信息，红色文本
    fi
done

主要流程

• 获取当前日期和时间作为备份文件的命名。
• 定义了一个echo_color函数，用于输出带颜色的文本。
• 如果用户文件存在且文件大小大于0，则将用户文件进行备份，并输出相应提示信息（绿色文本）。
• 向用户文件中添加表头和分隔线。
• 使用循环创建10个用户，并记录到用户文件中。
• 如果用户不存在，则生成随机密码并创建用户，并将用户名和密码记录到用户文件中，同时输出创建用户成功的提示信息。
• 如果用户已经存在，则输出用户已存在的提示信息（红色文本）。

4、检查软件包是否安装

#!/bin/bash

# 检查 sysstat 软件包是否已安装
if rpm -q sysstat &>/dev/null; then
    echo "sysstat is already installed."  # 输出已安装的提示信息
else
    echo "sysstat is not installed!"  # 输出未安装的提示信息
fi

• rpm -q sysstat命令用于查询系统中sysstat软件包的安装情况
• &>/dev/null用于将标准输出和标准错误输出重定向到空设备，即不显示输出信息
• 如果sysstat软件包已安装，则输出"sysstat is already installed."，表示已经存在且已安装
• 如果sysstat软件包未安装，则输出"sysstat is not installed!"，表示尚未安装

5、检查服务状态

#!/bin/bash

# 使用 ss 命令查找所有 UDP 连接，并使用 grep 统计包含 "123" 字符串的个数
PORT_C=$(ss -anu | grep -c 123)

# 使用 ps 命令查找所有 ntpd 进程，并使用 grep 过滤掉 grep 进程本身，再统计过滤后的行数
PS_C=$(ps -ef | grep ntpd | grep -vc grep)

# 如果统计到的端口数为 0 或统计到的进程数为 0，则执行下面的操作
if [ $PORT_C -eq 0 -o $PS_C -eq 0 ]; then
    # 通过 echo 命令输出邮件内容，然后使用 mail 命令发送邮件给指定的邮箱
    echo "内容" | mail -s "主题" [email protected]
fi

• ss -anu命令用于查看系统中所有的UDP连接
• rep -c 123用于统计结果中包含"123"字符串的行数
• ps -ef命令用于查看系统中的所有进程
• grep ntpd用于过滤出包含"ntpd"字符串的行
• grep -vc grep用于过滤掉包含"grep"字符串的行，并统计过滤后的行数

6、检查主机存活状态

方法1：将错误IP放到数组里面判断是否ping失败三次

#!/bin/bash

IP_LIST="192.168.18.1 192.168.1.1 192.168.18.2"

# 循环处理 IP_LIST 中的每个 IP 地址
for IP in $IP_LIST; do
    NUM=1  # 用于记录当前重试次数的变量

    # 使用 while 循环，最多重试 3 次
    while [ $NUM -le 3 ]; do
        # 检测指定 IP 地址是否可以通过 ping 命令连通
        if ping -c 1 $IP > /dev/null; then
            echo "$IP Ping is successful."  # 输出提示信息，表示 Ping 成功
            break  # 跳出当前循环，继续处理下一个 IP 地址
        else
            # 如果 ping 失败，记录失败次数和相应的 IP 地址
            FAIL_COUNT[$NUM]=$IP
            let NUM++
        fi
    done

    # 如果连续失败次数达到 3 次，则输出错误信息并清空 FAIL_COUNT 数组
    if [ ${#FAIL_COUNT[*]} -eq 3 ];then
        echo "${FAIL_COUNT[1]} Ping is failure!"  # 输出提示信息，表示 Ping 失败
        unset FAIL_COUNT[*]  # 清空 FAIL_COUNT 数组的内容
    fi
done

• IP_LIST 字符串包含要检测的多个 IP 地址。
• 使用 for 循环遍历每个 IP 地址。
• NUM 变量记录每个 IP 地址的重试次数。
  代码的功能：
• 对于 IP_LIST 中的每个 IP 地址
  • 使用 while 循环尝试最多 3 次进行 ping 命令检测。
  • 如果 ping 成功，则输出提示信息表示 Ping 成功，并跳出循环继续处理下一个 IP 地址。
  • 如果 ping 失败，则记录失败次数和相应的 IP 地址。
  • 如果连续失败次数达到 3 次，则输出错误信息并清空 FAIL_COUNT 数组。

方法2：将错误次数放到FAIL_COUNT变量里面判断是否ping失败三次

#!/bin/bash

IP_LIST="192.168.18.1 192.168.1.1 192.168.18.2"

# 循环处理 IP_LIST 中的每个 IP 地址
for IP in $IP_LIST; do
    FAIL_COUNT=0  # 用于记录失败次数的变量

    # 使用 for 循环尝试最多 3 次 ping 命令
    for ((i=1;i<=3;i++)); do
        # 检测指定 IP 地址是否可以通过 ping 命令连通
        if ping -c 1 $IP >/dev/null; then
            echo "$IP Ping is successful."  # 输出提示信息，表示 Ping 成功
            break  # 跳出当前循环，继续处理下一个 IP 地址
        else
            let FAIL_COUNT++  # 失败次数加 1
        fi
    done

    # 如果连续失败次数达到 3 次，则输出错误信息
    if [ $FAIL_COUNT -eq 3 ]; then
        echo "$IP Ping is failure!"  # 输出提示信息，表示 Ping 失败
    fi
done

• IP_LIST 字符串包含要检测的多个 IP 地址。
• 使用 for 循环遍历每个 IP 地址。
• FAIL_COUNT 变量用于记录每个 IP 地址的失败次数。
  代码的功能：
• 对于 IP_LIST 中的每个 IP 地址
  • 使用 for 循环尝试最多 3 次 ping 命令检测。
  • 如果 ping 成功，则输出提示信息表示 Ping 成功，并跳出循环继续处理下一个 IP 地址。
  • 如果 ping 失败，则增加失败次数。
  • 如果连续失败次数达到 3 次，则输出错误信息表示 Ping 失败。

方法3：利用for循环将ping通就跳出循环继续，如果不跳出就会走到打印ping失败

#!/bin/bash

# 定义函数用于检测 Ping 状态并输出结果
ping_success_status() {
    if ping -c 1 $IP >/dev/null; then
        echo "$IP Ping is successful."  # 输出提示信息，表示 Ping 成功
        continue  # 继续循环处理下一个 IP 地址
    fi
}

IP_LIST="192.168.18.1 192.168.1.1 192.168.18.2"

# 循环处理 IP_LIST 中的每个 IP 地址
for IP in $IP_LIST; do
    ping_success_status
    ping_success_status
    ping_success_status

    echo "$IP Ping is failure!"  # 输出提示信息，表示 Ping 失败
done

• ping_success_status() 函数用于检测指定IP地址的Ping状态并输出结果。

• IP_LIST 字符串包含要检测的多个 IP 地址。

• 使用 for 循环遍历每个 IP 地址，对每个 IP 地址调用 ping_success_status() 函数进行 Ping 测试。
  代码的功能：

• 定义了一个名为 ping_success_status 的函数用于检测 Ping 状态并输出结果。

• 对于 IP_LIST 中的每个 IP 地址

  • 分别调用 ping_success_status() 函数三次，进行 Ping 测试。
  • 如果三次中有任意一次 Ping 成功，则输出提示信息表示 Ping 成功，并继续处理下一个 IP 地址。
  • 如果三次都 Ping 失败，则输出提示信息表示 Ping 失败。

7、监控CPU、内存利用率

1）CPU
借助vmstat工具来分析CPU统计信息。

#!/bin/bash

DATE=$(date +%F" "%H:%M)  # 获取当前日期和时间
IP=$(ifconfig eth0 | awk -F"[ :]+" '/inet addr/{print $4}')  # 获取 eth0 网卡的 IP 地址（在 CentOS 6 中）
MAIL="[email protected]"

# 检查系统是否安装了 vmstat 命令，如果没有找到，则输出错误信息并退出脚本
if ! which vmstat &>/dev/null; then
    echo "vmstat command not found. Please install the procps package."
    exit 1
fi

# 使用 vmstat 命令获取 CPU 相关的统计数据
US=$(vmstat 1 3 | awk 'NR==5{print $13}')  # 用户CPU时间占用百分比
SY=$(vmstat 1 3 | awk 'NR==5{print $14}')  # 系统CPU时间占用百分比
IDLE=$(vmstat 1 3 | awk 'NR==5{print $15}')  # 空闲CPU时间百分比
WAIT=$(vmstat 1 3 | awk 'NR==5{print $16}')  # IO等待百分比

USE=$(($US+$SY))  # 计算用户CPU时间占用和系统CPU时间占用的总和

# 检查 CPU 使用率是否超过阈值（80%），如果超过则发送电子邮件通知
if [ $USE -ge 80 ]; then
    echo "
    Date: $DATE
    Host: $IP
    Problem: CPU utilization $USE
    " | mail -s "CPU Monitor" $MAIL
fi

代码的功能：

• 声明并初始化了 DATE 变量，用于存储当前的日期和时间。
• 使用 ifconfig 命令获取 eth0 网卡的 IP 地址（在 CentOS 6 中）。
• 设置邮件接收地址 MAIL。
• 检查系统是否安装了 vmstat 命令，如果没有找到，则输出错误信息并退出脚本。、使用 vmstat 命令获取 CPU 相关的统计数据，包括用户 CPU 时间占用、系统 CPU 时间占用、空闲 CPU 时间和 IO 等待时间。
• 计算用户 CPU 时间占用和系统 CPU 时间占用的总和，并存储在 USE 变量中。
• 检查 CPU 使用率是否超过阈值（80%），如果超过，则发送电子邮件通知，包括日期、主机名和问题描述。

2）内存

#!/bin/bash

DATE=$(date +%F" "%H:%M)  # 获取当前日期和时间
IP=$(ifconfig eth0 | awk -F"[ :]+" '/inet addr/{print $4}')  # 获取 eth0 网卡的 IP 地址（在 CentOS 6 中）
MAIL="[email protected]"

# 使用 free 命令获取内存相关的统计数据
TOTAL=$(free -m | awk '/Mem/{print $2}')  # 内存总量
USE=$(free -m | awk '/Mem/{print $3-$6-$7}')  # 已使用的内存量
FREE=$(($TOTAL-$USE))  # 剩余内存量

# 如果剩余内存小于 1G，则发送电子邮件通知
if [ $FREE -lt 1024 ]; then
    echo "
    Date: $DATE
    Host: $IP
    Problem: Total=$TOTAL, Use=$USE, Free=$FREE
    " | mail -s "Memory Monitor" $MAIL
fi

代码的功能：

• 声明并初始化了 DATE 变量，用于存储当前的日期和时间。
• 使用 ifconfig 命令获取 eth0 网卡的 IP 地址（在 CentOS 6 中）。
• 设置邮件接收地址 MAIL。
• 使用 free 命令获取内存相关的统计数据，包括内存总量、已使用的内存量和剩余的内存量。
• 计算剩余内存量（Total - Use）并存储在 FREE 变量中。
• 检查剩余内存量是否小于 1G（1024MB），如果小于则发送电子邮件通知，包括日期、主机名和问题描述。

8、批量主机磁盘利用率监控

前提监控端和被监控端SSH免交互登录或者密钥登录。

写一个配置文件保存被监控主机SSH连接信息，文件内容格式：IP User Port

#!/bin/bash

HOST_INFO=host.info  # 主机信息保存的文件路径
rm -f mail.txt  # 删除已存在的邮件内容文件

# 遍历主机信息文件中的每个 IP 地址
for IP in $(awk '/^[^#]/{print $1}' $HOST_INFO); do
    # 获取用户名和端口信息
    USER=$(awk -v ip=$IP 'ip==$1{print $2}' $HOST_INFO)
    PORT=$(awk -v ip=$IP 'ip==$1{print $3}' $HOST_INFO)

    TMP_FILE=/tmp/disk.tmp  # 临时文件路径，用于保存磁盘信息

    # 通过公钥登录到远程主机，获取磁盘信息，并保存到临时文件中
    ssh -p $PORT $USER@$IP 'df -h' > $TMP_FILE

    # 从临时文件中提取磁盘利用率信息，并保存到变量 USE_RATE_LIST 中
    USE_RATE_LIST=$(awk 'BEGIN{OFS="="}/^\/dev/{print $NF,int($5)}' $TMP_FILE)

    # 对磁盘利用率进行循环判断
    for USE_RATE in $USE_RATE_LIST; do
        PART_NAME=${USE_RATE%=*}  # 获取挂载点部分，即等号（=）左边的值
        USE_RATE=${USE_RATE#*=}  # 获取磁盘利用率部分，即等号（=）右边的值

        # 判断磁盘利用率是否超过阈值（80%），如果超过则将警告信息添加到邮件内容文件中
        if [ $USE_RATE -ge 80 ]; then
            echo "Warning: $PART_NAME Partition usage $USE_RATE%!" >> mail.txt
        else
            echo "服务器$IP的$PART_NAME目录空间良好"
        fi
    done

    # 发送邮件，将邮件内容文件作为内容，邮件主题为 "空间不足警告"
    cat mail.txt | mail -s "空间不足警告" [email protected]
done

代码的功能：

• 定义 HOST_INFO 变量，表示保存主机信息的文件路径。
• 删除已存在的邮件内容文件 mail.txt。
• 使用 awk 从主机信息文件中提取非注释行的 IP 地址，并依次处理每个 IP。
• 从主机信息文件中获取用户名和端口信息。
• 定义临时文件路径 TMP_FILE，用于保存远程主机的磁盘信息。
• 使用 ssh 命令通过公钥登录到远程主机，在远程主机上执行 df -h 命令，并将输出重定向到临时文件中。
• 从临时文件中提取磁盘利用率信息，并保存到 USE_RATE_LIST 变量中。
• 使用循环遍历磁盘利用率列表，并进行判断。
• 获取挂载点部分和磁盘利用率部分。
• 如果磁盘利用率超过阈值（80%），将警告信息添加到邮件内容文件 mail.txt 中。
• 如果磁盘利用率未超过阈值，则输出相应信息表示磁盘空间良好。
• 使用 cat 命令将邮件内容文件作为邮件内容，向 [email protected] 发送邮件，邮件主题为 “空间不足警告”。

9、检查网站可用性

1）检查URL可用性

# 方法1：使用 curl 命令检查 URL 的访问状态
check_url() {
    HTTP_CODE=$(curl -o /dev/null --connect-timeout 3 -s -w "%{http_code}" $1)
    # 使用 curl 命令测试 HTTP 头以检查 URL 的访问状态，超时时间为 3 秒，并将 HTTP 状态码保存到变量 HTTP_CODE 中

    if [ $HTTP_CODE -ne 200 ]; then
        echo "Warning: $1 Access failure!"
        # 如果 HTTP 状态码不等于 200（即不成功），则输出警告信息，表示 URL 访问失败
    fi
}

# 方法2：使用 wget 命令检查 URL 的访问状态
check_url() {
    if ! wget -T 10 --tries=1 --spider $1 >/dev/null 2>&1; then  
    # 使用 wget 命令以爬虫模式检查 URL 的访问状态，超时时间为 10 秒，并尝试访问 1 次，将输出重定向到 /dev/null，将错误输出重定向到标准输出并丢弃
        echo "Warning: $1 Access failure!"
        # 如果 wget 命令返回非零退出码，则输出警告信息，表示 URL 访问失败
    fi
}

代码的功能：

• 方法1：使用 curl 命令。通过设置选项 -o /dev/null，–connect-timeout 3，-s 和 -w “%{http_code}”，来测试 HTTP 头，并将 HTTP 状态码保存到变量 HTTP_CODE 中。然后，检查 HTTP 状态码是否等于 200，如果不等于，则输出警告信息，表示 URL 访问失败。
• 方法2：使用 wget 命令。通过设置选项 -T 10，–tries=1 和 --spider，以爬虫模式测试URL的访问状态，并设置超时时间为10秒，尝试访问1次。使用重定向将输出和错误信息都丢弃。然后，检查 wget 命令的返回值，如果返回非零退出码，则输出警告信息，表示 URL 访问失败。

2）判断三次URL可用性
方法1：利用循环技巧，如果成功就跳出当前循环，否则执行到最后一行

#!/bin/bash

# 检查URL的访问状态
check_url() {
    HTTP_CODE=$(curl -o /dev/null --connect-timeout 3 -s -w "%{http_code}" $1)
    # 使用 curl 命令测试 HTTP 头以检查 URL 的访问状态，超时时间为 3 秒，并将 HTTP 状态码保存到变量 HTTP_CODE 中

    if [ $HTTP_CODE -eq 200 ]; then
        continue
        # 如果 HTTP 状态码等于 200（即成功），则继续循环，不执行后续操作
    fi
}

URL_LIST="www.baidu.com www.agasgf.com"
# 存储待检查的 URL 列表

for URL in $URL_LIST; do
    check_url $URL
    # 依次遍历 URL 列表，调用 check_url 函数检查每个 URL 的访问状态
    # 如果返回的 HTTP 状态码等于 200，则继续循环，不执行后续操作

    check_url $URL
    check_url $URL
    # 连续调用 check_url 函数，最多尝试三次

    echo "Warning: $URL Access failure!"
    # 输出警告信息，表示 URL 访问失败
done

代码的功能：

• 定义了函数 check_url()，用于检查 URL 的访问状态。通过设置选项 -o /dev/null，–connect-timeout 3，-s 和 -w “%{http_code}”，使用 curl 命令测试 HTTP 头，并将返回的 HTTP 状态码保存到变量 HTTP_CODE 中。
• 在函数中，如果返回的 HTTP 状态码等于 200，那么继续循环，不执行后续操作。
• 定义了一个字符串变量 URL_LIST，用于存储待检查的 URL 列表。
• 使用 for 循环遍历 URL_LIST 中的每个 URL，依次调用 check_url 函数来检查 URL 的访问状态。
• 在每次循环中，连续调用 check_url 函数，最多尝试三次。
• 如果访问失败（即返回的 HTTP 状态码不等于 200），则输出警告信息，表示 URL 访问失败。

方法2：错误次数保存到变量

#!/bin/bash

URL_LIST="www.baidu.com www.agasgf.com"
# 存储待检查的 URL 列表

for URL in $URL_LIST; do
    FAIL_COUNT=0
    # 用于统计 URL 访问失败的次数的变量

    for ((i=1;i<=3;i++)); do
        # 进行最多三次的访问尝试
        HTTP_CODE=$(curl -o /dev/null --connect-timeout 3 -s -w "%{http_code}" $URL)
        # 使用 curl 命令测试 HTTP 头以检查 URL 的访问状态，超时时间为 3 秒，并将 HTTP 状态码保存到变量 HTTP_CODE 中

        if [ $HTTP_CODE -ne 200 ]; then
            let FAIL_COUNT++
            # 如果 HTTP 状态码不等于 200（即访问失败），则将失败次数加一
        else
            break
            # 如果 HTTP 状态码等于 200（即访问成功），则跳出循环，不执行后续尝试
        fi
    done

    if [ $FAIL_COUNT -eq 3 ]; then
        echo "Warning: $URL Access failure!"
        # 如果 URL 访问失败的次数等于 3，即尝试了三次都失败，则输出警告信息，表示 URL 访问失败
    fi
done

代码的功能：

• 定义了一个字符串变量 URL_LIST，用于存储待检查的 URL 列表。
• 使用 for 循环遍历 URL_LIST 中的每个 URL。
• 在每次循环中，初始化变量 FAIL_COUNT 为 0，用于统计 URL 访问失败的次数。
• 使用 for 循环进行最多三次的访问尝试。
• 在每次尝试中，使用 curl 命令测试 URL 的 HTTP 头，超时时间为 3 秒，并将返回的 HTTP 状态码保存到变量 HTTP_CODE 中
• 如果 HTTP 状态码不等于 200（即访问失败），则将 FAIL_COUNT 的值加一。
• 如果 HTTP 状态码等于 200（即访问成功），则跳出循环，不执行后续尝试。
• 在完成三次访问尝试后，如果失败次数等于 3，则输出警告信息，表示 URL 访问失败。

方法3：错误次数保存到数组

#!/bin/bash

URL_LIST="www.baidu.com www.agasgf.com"
# 存储待检查的 URL 列表

for URL in $URL_LIST; do
    NUM=1
    # 用于计数的变量 NUM，初始值为 1

    while [ $NUM -le 3 ]; do
        # 进行最多三次的访问尝试
        HTTP_CODE=$(curl -o /dev/null --connect-timeout 3 -s -w "%{http_code}" $URL)
        # 使用 curl 命令测试 HTTP 头以检查 URL 的访问状态，超时时间为 3 秒，并将 HTTP 状态码保存到变量 HTTP_CODE 中

        if [ $HTTP_CODE -ne 200 ]; then
            FAIL_COUNT[$NUM]=$IP
            # 如果 HTTP 状态码不等于 200（即访问失败），则将失败的 URL 存储到数组 FAIL_COUNT 中，以 NUM 作为下标，IP 作为元素
            let NUM++
            # 数量加一，进行下一次尝试
        else
            break
            # 如果 HTTP 状态码等于 200（即访问成功），则跳出循环，不再进行尝试
        fi
    done

    if [ ${#FAIL_COUNT[*]} -eq 3 ]; then
        echo "Warning: $URL Access failure!"
        unset FAIL_COUNT[*]
        # 如果 FAIL_COUNT 数组中有三个元素，即进行了三次尝试都失败，则输出警告信息，表示 URL 访问失败，并清空 FAIL_COUNT 数组
    fi
done

代码的功能：

• 定义了一个字符串变量 URL_LIST，用于存储待检查的 URL 列表。
• 使用 for 循环遍历 URL_LIST 中的每个 URL。
• 在每次循环中，初始化变量 NUM 为 1，用于计数访问尝试的次数。
• 使用 while 循环进行最多三次的访问尝试。
• 在每次尝试中，使用 curl 命令测试 URL 的 HTTP 头，超时时间为 3 秒，并将返回的 HTTP 状态码保存到变量 HTTP_CODE 中。
• 如果 HTTP 状态码不等于 200（即访问失败），则将失败的 URL 存储到 FAIL_COUNT 数组中，以 NUM 作为下标，IP 作为元素。然后，NUM 加一，进行下一次尝试。
• 如果 HTTP 状态码等于 200（即访问成功），则跳出循环，不再进行尝试。
  使用 for 循环遍历 URL_LIST 中的每个 URL。
• 在完成三次访问尝试后，如果 FAIL_COUNT 数组中有三个元素（即进行了三次尝试都失败），则输出警告信息，表示 URL 访问失败，并清空 FAIL_COUNT 数组。

10、检查MySQL主从同步状态

#!/bin/bash

USER=bak
PASSWD=123456

IO_SQL_STATUS=$(mysql -u$USER -p$PASSWD -e show slave statusG | awk -F: /Slave_.*_Running/{gsub(": ",":");print $0})
# 执行 mysql 命令获取 MySQL 主从状态，并使用 awk 命令根据关键字 "Slave_.*_Running" 解析出对应的行，并去除冒号后的空格

for i in $IO_SQL_STATUS; do
    THREAD_STATUS_NAME=${i%:*}
    # 通过 %:* 取 THREAD_STATUS_NAME 字符串变量，获取冒号前的部分
    THREAD_STATUS=${i#*:}
    # 通过 #*: 取 THREAD_STATUS 字符串变量，获取冒号后的部分

    if [ "$THREAD_STATUS" != "Yes" ]; then
        echo "Error: MySQL Master-Slave $THREAD_STATUS_NAME status is $THREAD_STATUS!"
        # 如果 THREAD_STATUS 不等于 "Yes"，则输出错误信息，表示 MySQL 主从状态异常
    fi
done

代码的功能：

• 定义了字符串变量 USER 和 PASSWD，分别存储登录 MySQL 的用户名和密码。
• 使用 mysql 命令执行查询语句 show slave statusG，获取 MySQL 主从复制的状态。-u$ USER 指定用户名，-p$PASSWD 指定密码，-e 后面跟查询语句，G 匹配 show slave status 的输出格式。
• 使用 awk 命令根据关键字 “Slave_.*_Running” 解析出对应的行，并去除冒号后的空格。
• 使用 for 循环遍历 $IO_SQL_STATUS 中的每个值。
• 在每次循环中，通过 %：* 取出冒号前的部分，赋值给 THREAD_STATUS_NAME 变量。
• 通过 #*: 取出冒号后的部分，赋值给 THREAD_STATUS 变量。
• 如果 THREAD_STATUS 不等于 “Yes”，则输出错误信息，表示 MySQL 主从状态异常。

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

场景：恶意访问,安全防范
1）屏蔽每分钟访问超过200的IP
方法1：根据访问日志（Nginx为例）

#!/bin/bash

DATE=$(date +%d/%b/%Y:%H:%M)
# 获取当前日期和时间，并格式化为 "%d/%b/%Y:%H:%M" 的形式，赋值给变量 DATE

ABNORMAL_IP=$(tail -n 5000 access.log | grep $DATE | awk '{a[$1]++}END{for(key in a)if(a[key]>100)print key}')
# 使用 tail 命令读取文件 access.log 的最后 5000 行日志，然后通过 grep 过滤出包含当前日期的行，最后使用 awk 命令统计 IP 地址出现的次数，如果次数大于 100，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP

for IP in $ABNORMAL_IP; do
    # 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址
    if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
        # 使用 iptables 命令查看当前防火墙规则，并使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量
        # 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中
        iptables -I INPUT -s $IP -j DROP
        # 在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量
    fi
done

这段代码的功能是根据 access.log 中的日志数据，检测发起请求次数超过设定阈值的 IP 地址，并将这些 IP 地址加入防火墙规则，拒绝其输入流量。
代码的功能：

• 定义了字符串变量 DATE，使用 date 命令获取当前日期和时间，并使用 %d/%b/%Y:%H:%M 格式化。
• 使用 tail 命令读取文件 access.log 的最后 5000 行日志。
• 使用 grep 过滤出包含当前日期的行。
• 使用 awk 命令统计 IP 地址出现的次数，将出现次数大于 100 的 IP 地址打印出来，赋值给变量 ABNORMAL_IP。
• 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址。
• 使用 iptables 命令查看当前防火墙规则，使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量。
• 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中。
• 使用 iptables 命令在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量。

方法2：通过TCP建立的连接

#!/bin/bash

ABNORMAL_IP=$(netstat -an | awk '$4~/:80$/ && $6~/ESTABLISHED/{gsub(/:[0-9]+/,"",$5);{a[$5]++}}END{for(key in a)if(a[key]>100)print key}')
# 使用 netstat 命令获取网络连接状态，通过 awk 过滤出本地端口为 80 的已建立连接（ESTABLISHED）的行，并使用 gsub 函数去除客户端 IP 地址中的冒号和端口号，然后统计每个 IP 地址的出现次数，如果次数大于 100，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP

for IP in $ABNORMAL_IP; do
    # 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址
    if [ $(iptables -vnL |grep -c "$IP") -eq 0 ]; then
        # 使用 iptables 命令查看当前防火墙规则，并使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量
        # 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中
        iptables -I INPUT -s $IP -j DROP
        # 在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量
    fi
done

这段代码的功能是通过 netstat 命令检测当前与本地端口 80 建立的连接，并统计每个客户端 IP 地址的连接次数，如果连接次数超过设定阈值，就将对应 IP 地址加入防火墙规则。
代码的功能：

• 使用 netstat 命令获取当前的网络连接状态。
• 使用 awk 过滤出本地端口为 80 的已建立连接（ESTABLISHED）的行，并使用 gsub 函数将客户端 IP 地址中的冒号和端口号去除。
• 统计每个 IP 地址的出现次数，如果次数大于 100，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP。
• 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址。
• 使用 iptables 命令查看当前防火墙规则，使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量。
• 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中。
• 使用 iptables 命令在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量。

2）屏蔽每分钟SSH尝试登录超过10次的IP
方法1：通过lastb获取登录状态

#!/bin/bash

DATE=$(date +"%a %b %e %H:%M")
# 获取当前日期和时间，并使用格式化字符串 "%a %b %e %H:%M" 赋值给变量 DATE
# %a: 星期几的缩写（例如：Mon、Tue）
# %b: 月份的缩写（例如：Jan、Feb）
# %e: 月份中的天数（仅用一个数字表示，如：7）
# %H: 小时（24小时制）
# %M: 分钟

ABNORMAL_IP=$(lastb | grep "$DATE" | awk '{a[$3]++}END{for(key in a)if(a[key]>10)print key}')
# 使用 lastb 命令获取登录失败的记录，通过 grep 过滤出包含当前日期的行，然后使用 awk 命令统计每个 IP 地址出现的次数，如果次数大于 10，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP

for IP in $ABNORMAL_IP; do
    # 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址
    if [ $(iptables -vnL | grep -c "$IP") -eq 0 ]; then
        # 使用 iptables 命令查看当前防火墙规则，并使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量
        # 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中
        iptables -I INPUT -s $IP -j DROP
        # 在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量
    fi
done

这段代码的功能是检测最近登录失败的记录（使用 lastb 命令），并统计每个 IP 地址的登录失败次数。如果登录失败次数超过设定阈值，就将对应 IP 地址加入防火墙规则，禁止其输入流量。
代码的功能：

• 使用 date 命令获取当前日期和时间，并使用格式化字符串 “%a %b %e %H:%M” 格式化成星期几、月份、日期、小时和分钟的形式，赋值给变量 DATE。
• 使用 lastb 命令获取登录失败的记录。
• 使用 grep 过滤出包含当前日期的行。
• 使用 awk 命令统计每个 IP 地址出现的次数，如果次数大于 10，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP。
• 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址。
• 使用 iptables 命令查看当前防火墙规则，使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量。
• 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中。
• 使用 iptables 命令在 INPUT 链的开头插入一条规则，拒绝指定 IP 地址的所有输入流量。

方法2：通过日志获取登录状态

#!/bin/bash

DATE=$(date +"%b %d %H")
# 获取当前日期和时间，并使用格式化字符串 "%b %d %H" 格式化成月份、日期、小时的形式，赋值给变量 DATE
# %b: 月份的缩写（例如：Jan、Feb）
# %d: 月份中的天数（例如：07）
# %H: 小时（24小时制）

ABNORMAL_IP="$(tail -n10000 /var/log/auth.log | grep "$DATE" | awk '/Failed/{a[$(NF-3)]++}END{for(key in a)if(a[key]>5)print key}')"
# 使用 tail 命令读取文件 /var/log/auth.log 的最后10000行日志
# 通过 grep 过滤出包含当前日期的行
# 使用 awk 命令找出包含 "Failed" 关键词的行，并以行中倒数第 3 个字段（即 IP 地址）为 key，统计出现次数
# 如果次数大于 5，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP

for IP in $ABNORMAL_IP; do
    # 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址
    if [ $(iptables -vnL | grep -c "$IP") -eq 0 ]; then
        # 使用 iptables 命令查看当前防火墙规则，并使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量
        # 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中
        iptables -A INPUT -s $IP -j DROP
        # 在 INPUT 链的末尾追加一条规则，拒绝指定 IP 地址的所有输入流量
        echo "$(date +"%F %T") - iptables -A INPUT -s $IP -j DROP" >> ~/ssh-login-limit.log
        # 将执行的 iptables 命令和时间记录到 ~/ssh-login-limit.log 日志文件中
    fi
done

这段代码的功能是检测 /var/log/auth.log 文件中最近出现的登录失败记录，并统计每个 IP 地址的登录失败次数。如果登录失败次数超过设定阈值，就将对应 IP 地址加入防火墙规则，禁止其输入流量，并将执行的 iptables 命令和时间记录到 ~/ssh-login-limit.log 日志文件中。
代码的功能：

• 使用 date 命令获取当前日期和时间，并使用格式化字符串 “%b %d %H” 格式化成月份、日期、小时的形式，赋值给变量 DATE。
• 使用 tail 命令读取文件 /var/log/auth.log 的最后10000行日志。
• 使用 grep 过滤出包含当前日期的行。
• 使用 awk 命令找出包含 “Failed” 关键词的行，并以行中倒数第 3 个字段（即 IP 地址）为 key，统计出现次数。
• 如果次数大于 5，则将 IP 地址打印出来，赋值给变量 ABNORMAL_IP。
• 使用 for 循环遍历 ABNORMAL_IP 中的每个 IP 地址。
• 使用 iptables 命令查看当前防火墙规则，使用 grep 过滤出包含指定 IP 地址的行，并使用 -c 参数统计匹配行的数量。
• 如果匹配行的数量等于 0，表示当前 IP 地址不在防火墙规则中。
• 使用 iptables 命令在 INPUT 链的末尾追加一条规则，拒绝指定 IP 地址的所有输入流量。
• 使用 echo 命令将执行的 iptables 命令和时间记录到 ~/ssh-login-limit.log 日志文件中。

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

方法1:

#!/bin/bash

# 定义函数 check_ip，用于检查输入的 IP 地址是否合法
function check_ip(){
    local IP=$1
    VALID_CHECK=$(echo $IP | awk -F"." '{if($1<=255&&$2<=255&&$3<=255&&$4<=255) print "yes"; else print "no"}')
    # 将 IP 地址按照 "." 分隔成四个字段，并使用 awk 判断每个字段的取值范围是否合法（0-255）
    
    if echo $IP | grep -E "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$" > /dev/null; then
        # 使用正则表达式验证 IP 地址的格式，必须为 1-3 位数字 + "." + 1-3 位数字 + "." + 1-3 位数字 + "." + 1-3 位数字
        # 将匹配结果重定向到 /dev/null，即丢弃匹配结果
        if [[ "$VALID_CHECK" == "yes" ]]; then
            echo "$IP available."
            return 0
        else
            echo "$IP not available!"
            return 1
        fi
    else
        echo "Format error!"
        return 1
    fi
}

while true; do
    read -p "Please enter IP: " ip
    # 提示用户输入 IP 地址，并将输入保存到变量 ip 中
    check_ip $ip
    # 调用函数 check_ip，传入用户输入的 IP 地址作为参数进行检查

    # 如果函数返回值为 0，表示 IP 地址合法，跳出循环
    # 如果函数返回值为 1，表示 IP 地址不合法，继续循环
done

这段代码实现了一个循环，提示用户输入 IP 地址，并通过调用函数 check_ip 对输入的 IP 地址进行检查，直到用户输入合法的 IP 地址为止。
代码的功能：

• 定义了一个函数 check_ip，用于检查输入的 IP 地址是否合法。
• 在函数内部，首先将 IP 地址按照 “.” 分隔成四个字段，并使用 awk 判断每个字段的取值范围是否合法（0-255）。
• 使用正则表达式验证 IP 地址的格式，必须为 1-3 位数字 + “.” + 1-3 位数字 + “.” + 1-3 位数字 + “.” + 1-3 位数字。
• 如果 IP 地址格式合法并且每个字段的取值也合法，输出 “IP available.”。
• 如果 IP 地址格式合法但有字段取值不合法，输出 “IP not available!”。
• 如果 IP 地址格式不合法，输出 “Format error!”。
• 在 while 循环中，使用 read 命令提示用户输入 IP 地址，并将输入保存到变量 ip 中。
• 调用 check_ip 函数，传入用户输入的 IP 地址作为参数进行检查。
• 如果函数返回值为 0，表示 IP 地址合法，跳出循环。
• 如果函数返回值为 1，表示 IP 地址不合法，继续循环。

方法2：

#!/bin/bash

# 定义函数 check_ip，用于检查输入的 IP 地址是否合法
function check_ip(){
    IP=$1
    if [[ $IP =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
        # 使用正则表达式验证 IP 地址的格式，必须为 1-3 位数字 + "." + 1-3 位数字 + "." + 1-3 位数字 + "." + 1-3 位数字
        FIELD1=$(echo $IP|cut -d. -f1)
        FIELD2=$(echo $IP|cut -d. -f2)
        FIELD3=$(echo $IP|cut -d. -f3)
        FIELD4=$(echo $IP|cut -d. -f4)
        # 使用 cut 命令按照 "." 分割 IP 地址，并分别将每个字段赋值给对应的变量
        if [ $FIELD1 -le 255 -a $FIELD2 -le 255 -a $FIELD3 -le 255 -a $FIELD4 -le 255 ]; then
            # 判断每个字段的取值是否都小于等于 255
            echo "$IP available."
            # 输出 IP 地址合法
        else
            echo "$IP not available!"
            # 输出 IP 地址不合法，至少有一个字段的取值大于 255
        fi
    else
        echo "Format error!"
        # 输出 IP 地址格式错误
    fi
}

check_ip 192.168.1.1
# 调用 check_ip 函数，传入参数 192.168.1.1 进行检查

check_ip 256.1.1.1
# 调用 check_ip 函数，传入参数 256.1.1.1 进行检查

这段代码定义了一个函数 check_ip，用于检查输入的 IP 地址是否合法，并对两个 IP 地址进行了检查。
代码的功能：

• 定义了一个函数 check_ip，用于检查输入的 IP 地址是否合法。
• 使用正则表达式验证 IP 地址的格式，必须为 1-3 位数字 + “.” + 1-3 位数字 + “.” + 1-3 位数字 + “.” + 1-3 位数字。
• 使用 cut 命令按照 “.” 分割 IP 地址，并分别将每个字段赋值给对应的变量。
• 判断每个字段的取值是否都小于等于 255。
• 如果 IP 地址合法且每个字段的取值都小于等于 255，输出 “IP available.”。
• 如果 IP 地址合法但至少有一个字段的取值大于 255，输出 “IP not available!”。
• 如果 IP 地址不合法，输出 “Format error!”。

在主程序中，调用 check_ip 函数进行两次检查：

• 第一次传入参数 192.168.1.1 进行检查，输出 “192.168.1.1 available.”，表示该 IP 地址合法。
• 第二次传入参数 256.1.1.1 进行检查，输出 “256.1.1.1 not available!”，表示该 IP 地址不合法，有一个字段的取值大于 255。

13、判断用户输入的是否为数字

方法1：

#!/bin/bash

# 使用正则表达式判断参数是否为数字
if [[ $1 =~ ^[0-9]+$ ]]; then
    echo "Is Number."
    # 如果参数是由一个或多个数字组成，输出 "Is Number."
else
    echo "No Number."
    # 如果参数不是由一个或多个数字组成，输出 "No Number."
fi

段代码使用正则表达式判断参数是否为数字。
代码的功能：

• 使用正则表达式 ^ [0-9]+$ 判断参数是否由一个或多个数字组成。
  • ^ 表示匹配字符串的起始位置。
  • [0-9] 表示匹配数字字符的范围，即 0 到 9。
  • +表示匹配前面的元素一次或多次。
  • $表示匹配字符串的结束位置。
• 如果参数是由一个或多个数字组成，即满足正则表达式的匹配条件，输出 “Is Number.”。
• 如果参数不是由一个或多个数字组成，即不满足正则表达式的匹配条件，输出 “No Number.”。

方法2：

#!/bin/bash

# 判断参数是否为一个数字
if [ $1 -gt 0 ] 2>/dev/null; then
    echo "Is Number."
    # 如果参数大于 0，即参数是一个数字，输出 "Is Number."
else
    echo "No Number."
    # 如果参数不是一个数字，输出 "No Number."
fi

这段代码使用条件判断语句判断参数是否为一个数字。
代码的功能：

• 使用条件判断语句 [ … ] 判断 $1 是否大于 0。
  • $1 表示脚本或函数的第一个参数，用于接收命令行传入的参数。
  • -gt 是一个数值比较操作符，表示大于。
• 2>/dev/null 表示将标准错误输出重定向到 /dev/null，即丢弃错误输出。
  • 这是为了避免在参数不是一个数字时生成不必要的错误输出。
• 如果参数大于 0，即满足条件判断，输出 “Is Number.”。
• 如果参数不是一个数字，即不满足条件判断，输出 “No Number.”。

方法3：

#!/bin/bash

echo $1 | awk '{print $0~/^[0-9]+$/?"Is Number.":"No Number."}'
# 使用 awk 命令打印判断结果，使用三元运算符进行条件判断

# 解释：
# - `echo $1` 打印第一个参数
# - `awk` 命令用于处理文本数据
# - `{print $0~/^[0-9]+$/?"Is Number.":"No Number."}` 是 awk 的脚本部分，用于判断参数是否为一个数字并进行打印
#     - `$0` 表示当前行的文本内容，即传入的参数
#     - `~` 是 awk 的匹配操作符
#     - `/^[0-9]+$/` 是正则表达式，用于匹配一个或多个数字的字符串
#     - `?` 是三元运算符的条件部分，即判断参数是否匹配正则表达式
#     - 如果参数匹配正则表达式，返回 "Is Number."，否则返回 "No Number."

这段代码使用了 awk 命令和三元运算符来判断参数是否是一个数字，并进行相应的输出。

14、给定目录找出包含关键字的文件

#!/bin/bash

DIR=$1  # 存储目录路径
KEY=$2  # 存储要搜索的关键词

# 使用循环逐个遍历目录下的文件
for FILE in $(find $DIR -type f); do
    # 在文件中搜索关键词，并将输出重定向到 `/dev/null`，即丢弃匹配结果
    if grep $KEY $FILE &>/dev/null; then
        echo "--> $FILE"
        # 如果搜索到关键词，输出文件路径
    fi
done

这段代码的功能是在给定的目录中搜索包含指定关键词的文件，并输出文件的路径。
代码的功能：

• DIR=$1，将第一个命令行参数赋值给变量 DIR，用于存储目录路径。
• KEY=$2，将第二个命令行参数赋值给变量 KEY，用于存储要搜索的关键词。
• for FILE in $(find $DIR -type f); do … done，使用循环逐个遍历目录下的文件。
• find $DIR -type f，使用 find 命令在目录 $DIR 中搜索所有类型为文件的项，并将结果以空格分隔输出。
• grep $KEY $FILE &>/dev/null，在文件 $FILE 中搜索关键词 $KEY，并将匹配结果重定向到 /dev/null，即丢弃匹配结果。
  • grep 命令用于在文本中搜索指定的模式，这里用于搜索关键词。
  • &> 是重定向的语法，将标准输出和标准错误输出都重定向到同一个地方，这里是 /dev/null，即丢弃匹配结果。
• if grep $KEY $FILE &>/dev/null; then … fi，如果搜索到关键词，则进入条件判断语句。
• echo “–> $FILE”，在终端输出带有 --> 前缀的文件路径，即输出搜索到的文件路径。

15、监控目录，将新创建的文件名追加到日志中

场景：记录目录下文件操作。

需先安装inotify-tools软件包。

-m  #持续监听
-r  #使用递归形式监控目录
-q  #减少冗余信息，只打印出需要的信息
-e  #指定要监控的事件，多个事件使用逗号隔开
        access  #访问，读取文件
        modify  #修改，文件内容被修改
        attrib  #属性，文件元数据被修改
        move    #移动，对文件进行移动操作 move_to  move_from
        create  #创建，生成新文件
        open    #打开，对文件进行打开操作
        close   #关闭，对文件进行关闭操作 close_write close_nowrite
        delete  #删除，文件被删除 delete_self
        unmount #卸载文件或目录的文件系统
--timefmt   #时间格式  y 年  m月  d日  H小时  M分钟
--format    #监控事件发生后的信息输出格式
    %w  #表示发生事件的目录
    %f  #表示发生事件的文件
    %e  #表示发生的事件
    %Xe #事件以“X”分隔
    %T  #使用由  --timefmt定义的时间格式
--exclude   #排除文件或目录时，大小写敏感
    # --exclude="(.*.swp)|(.*~$)|(.*.swx)"使用正则匹配排除文件
# inotifywait +  rsync 同步，放在后台跑

#!/bin/bash
MON_DIR=/tmp  # 要监视的目录
# 使用 inotifywait 监视 $MON_DIR 目录中的文件创建事件，并输出文件名
inotifywait -mq --format %f -e create $MON_DIR | \
while read files; do
    # 对每个文件执行 rsync 命令
    echo rsync -avz $files admin@ip:/tmp
done

这段代码的功能是使用 inotifywait 监视指定目录中的文件创建事件，并在有文件创建时执行 rsync 命令。
代码的功能：

• MON_DIR=/tmp，将 /tmp 目录路径赋值给变量 MON_DIR，表示要监视的目录。
• inotifywait -mq --format %f -e create $MON_DIR，使用 inotifywait 命令监视目录 $MON_DIR 中的文件创建事件，并以简洁的格式输出文件名。
• while read files; do … done，使用 while 循环逐行读取输出的文件名。
• echo rsync -avz $files admin@ip:/tmp，对于每个读取的文件名，输出 rsync 命令。
  • rsync 命令用于文件同步和传输。
  • -avz 表示启用归档模式并压缩传输。
  • $files 表示读取到的文件名，即待同步的文件。
  • admin@ip:/tmp 表示目标地址，具体的 IP 地址和目录可以根据实际情况进行修改。

16、给用户提供多个网卡选择

场景：服务器多个网卡时，获取指定网卡，例如网卡流量

#!/bin/bash

function local_nic() {
    local NUM ARRAY_LENGTH

    NUM=0
    for NIC_NAME in $(ls /sys/class/net | grep -vE "lo|docker0"); do
        NIC_IP=$(ifconfig $NIC_NAME | awk -F'[: ]+' '/inet addr/{print $4}')
        if [ -n "$NIC_IP" ]; then
            NIC_IP_ARRAY[$NUM]="$NIC_NAME:$NIC_IP"
            # 将网卡名和对应IP放到数组
            let NUM++
        fi
    done

    ARRAY_LENGTH=${#NIC_IP_ARRAY[*]}
    # 获取数组长度

    if [ $ARRAY_LENGTH -eq 1 ]; then
        # 如果数组里面只有一条记录，说明只有一个网卡
        NIC=${NIC_IP_ARRAY[0]%:*}
        # 获取网卡名称（去除IP地址部分）
        return 0
    elif [ $ARRAY_LENGTH -eq 0 ]; then
        # 如果没有记录，说明没有可用的网卡
        echo "No available network card!"
        exit 1
    else
        # 如果有多条记录，则提醒输入选择
        for NIC in ${NIC_IP_ARRAY[*]}; do
            echo $NIC
            # 输出所有网卡名称和对应的IP地址
        done

        while true; do
            read -p "Please enter the name of the network card to use: " INPUT_NIC_NAME
            # 提示用户输入要使用的网卡名称
            COUNT=0
            for NIC in ${NIC_IP_ARRAY[*]}; do
                NIC_NAME=${NIC%:*}
                if [ $NIC_NAME == "$INPUT_NIC_NAME" ]; then
                    NIC=${NIC_IP_ARRAY[$COUNT]%:*}
                    # 获取用户输入网卡名称对应的IP地址
                    return 0
                else
                    COUNT+=1
                fi
            done
            echo "Not match! Please input again."
            # 如果输入不匹配，要求用户重新输入
        done
    fi
}

local_nic

这段代码的功能是获取本地可用的网卡和对应的IP地址，并要求用户选择要使用的网卡。
代码的功能：

• function local_nic()，定义了一个名为 local_nic 的函数。
• NUM=0，设置一个变量 NUM 为 0，用于记录数组的索引。
• for NIC_NAME in $(ls /sys/class/net | grep -vE “lo|docker0”); do … done，循环遍历 /sys/class/net 目录下的网卡名称，排除 lo（本地回环接口）和 docker0（Docker 网络接口）。
• NIC_IP=$(ifconfig $NIC_NAME | awk -F’[: ]+’ ‘/inet addr/{print $4}’)，获取每个网卡的 IP 地址，并将结果赋值给 NIC_IP。
• if [ -n “$NIC_IP” ]; then … fi，如果 NIC_IP 不为空（即获取到了 IP 地址），则执行条件判断的代码块。
• NIC_IP_ARRAY[$ NUM]=“$ NIC_NAME:$NIC_IP”，将网卡名称和对应的 IP 地址放入数组 NIC_IP_ARRAY 中，索引为 $NUM。
• let NUM++，将 NUM 的值加 1，用于下次循环时的数组索引。
• ARRAY_LENGTH=${#NIC_IP_ARRAY[*]}，获取数组 NIC_IP_ARRAY 的长度。
• if [ $ARRAY_LENGTH -eq 1 ]; then … fi，如果数组长度为 1，说明只有一个可用网卡。
• NIC=${NIC_IP_ARRAY[0]%：*}，将数组中的第一个元素赋值给变量 NIC，并去除末尾的 IP 地址部分。
• return 0，函数执行成功，返回 0。
• elif [ $ARRAY_LENGTH -eq 0 ]; then … fi，如果数组长度为 0，说明没有可用的网卡。
• echo “No available network card!”，输出提示信息 “No available network card!”。
• exit 1，正常退出脚本并返回状态码 1。
• else，如果有多条可用网卡，则要求用户选择要使用的网卡。
• for NIC in ${NIC_IP_ARRAY[*]}; do … done，循环遍历数组 NIC_IP_ARRAY 中的每个元素，即每个网卡名称和对应的 IP 地址。
• echo $NIC，输出每个网卡的名称和对应的 IP 地址。
• while true; do … done，使用无限循环，要求用户输入网卡名称并进行匹配。
• read -p "Please enter the name of the network card to use: " INPUT_NIC_NAME，提示用户输入要使用的网卡名称，将其保存在变量 INPUT_NIC_NAME 中。
• COUNT=0，设置一个变量 COUNT 为 0，用于记录数组的索引。
• for NIC in ${NIC_IP_ARRAY[*]}; do … done，循环遍历数组 NIC_IP_ARRAY 中的每个元素，即每个网卡名称和对应的 IP 地址。
• NIC_NAME=${NIC%: *}，将数组元素中的 IP 地址部分截取掉，只保留网卡名称。
• if [ $ NIC_NAME == “$INPUT_NIC_NAME” ]; then … fi，如果网卡名称与用户输入的名称匹配。
• NIC=$ {NIC_IP_ARRAY[$COUNT]%: *}，将数组元素中的 IP 地址部分截取掉，只保留网卡名称，赋值给变量 NIC。
• return 0，函数执行成功，返回 0。
• else，如果输入不匹配，输出提示信息并要求用户重新输入。
• done，结束内层循环。
• done，结束函数的整体逻辑。
• local_nic，调用 local_nic 函数。

17、查看网卡实时流量

适用于CentOS操作系统。

#!/bin/bash

# Description: Only CentOS

# traffic_unit_conv函数将流量转换为合适的单位（KB/s或MB/s）
traffic_unit_conv() {
    local traffic=$1

    if [ $traffic -gt 1024000 ]; then
        printf "%.1f%s" "$(($traffic/1024/1024))" "MB/s"
        # 如果流量大于1024000（1024KB），将流量转换为MB/s并保留1位小数
    elif [ $traffic -lt 1024000 ]; then
        printf "%.1f%s" "$(($traffic/1024))" "KB/s"
        # 如果流量小于1024000（1024KB），将流量转换为KB/s并保留1位小数
    fi
}

NIC=$1    # 获取用户传入的参数作为要监测的网卡名称

echo -e " In ------ Out"
# 打印标题 "In ------ Out"

while true; do
    # 进入无限循环，监测流量变化
    OLD_IN=$(awk -F'[: ]+' '$0~"'$NIC'"{print $3}' /proc/net/dev)
    # 获取旧的接收流量（使用awk命令从/proc/net/dev中提取）
    OLD_OUT=$(awk -F'[: ]+' '$0~"'$NIC'"{print $11}' /proc/net/dev)
    # 获取旧的发送流量（使用awk命令从/proc/net/dev中提取）
    sleep 1
    # 等待1秒，以便获取新的流量数据
    NEW_IN=$(awk -F'[: ]+' '$0~"'$NIC'"{print $3}' /proc/net/dev)
    # 获取新的接收流量
    NEW_OUT=$(awk -F'[: ]+' '$0~"'$NIC'"{print $11}' /proc/net/dev)
    # 获取新的发送流量
    IN=$(($NEW_IN-$OLD_IN))
    # 计算接收的流量差值
    OUT=$(($NEW_OUT-$OLD_OUT))
    # 计算发送的流量差值
    echo "$(traffic_unit_conv $IN) $(traffic_unit_conv $OUT)"
    # 调用traffic_unit_conv函数将流量差值转换为合适的单位并打印
    sleep 1
    # 等待1秒，以便下一次获取流量数据
done
# 结束循环

这段代码的功能是监测指定网卡的接收和发送流量，并每秒打印一次流量值。
代码的功能：

• #Description: Only CentOS6，描述脚本的作用，限定适用于 CentOS 系统。
• traffic_unit_conv()，定义了一个名为 traffic_unit_conv 的函数，用于将流量转换为合适的单位（KB/s或MB/s）。
• local traffic=$1，将传入的第一个参数赋值给变量 traffic，表示要转换的流量值。
  if [ $traffic -gt 1024000 ]; then … fi，如果流量值大于 1024000（1024KB），执行条件判断的代码块。
• printf “%.1f%s” “$ (($traffic/1024/1024))” “MB/s”，将流量值除以1024再除以1024，并保留1位小数，表示为 MB/s。
• elif [ $ traffic -lt 1024000 ]; then … fi，如果流量值小于 1024000（1024KB），执行条件判断的代码块。
• printf “%.1f%s” “$ (($ traffic/1024))” “KB/s”，将流量值除以1024，保留1位小数，表示为 KB/s。
• NIC=$ 1，将传入的第一个参数赋值给变量 NIC，表示要监测的网卡名称。
• echo -e " In ------ Out"，打印标题 “In ------ Out”，使用 -e 选项表示支持特殊字符的解释。
• while true; do … done，进入无限循环，用于持续监测流量变化。
• OLD_IN=$ (awk -F’[: ]+’ ‘$ 0~"’$ NIC’"{print $ 3}’ /proc/net/dev)，使用 awk 命令获取当前网卡的旧的接收流量值。
• OLD_OUT=$ (awk -F’[: ]+’ ‘$ 0~"’$ NIC’"{print $ 11}’ /proc/net/dev)，使用 awk 命令获取当前网卡的旧的发送流量值。
• sleep 1，等待1秒，以便获取新的流量数据。
• NEW_IN=$ (awk -F’[: ]+’ ‘$ 0~"’$ NIC’"{print $ 3}’ /proc/net/dev)，使用 awk 命令获取当前网卡的新的接收流量值。
• NEW_OUT=$ (awk -F’[: ]+’ ‘$ 0~"’$NIC’"{print $11}’ /proc/net/dev)，使用 awk 命令获取当前网卡的新的发送流量值。
• IN=$ (($ NEW_IN-$ OLD_IN))，计算接收的流量差值。
• OUT=$ (($ NEW_OUT-$ OLD_OUT))，计算发送的流量差值。
• echo “$(traffic_unit_conv $IN) $(traffic_unit_conv $OUT)”，调用 traffic_unit_conv 函数将流量差值转换为合适的单位，并打印接收和发送流量。
• sleep 1，等待1秒，以便下一次获取流量数据。
• done，结束内层循环。

使用：./traffic.sh eth0

18、MySQL数据库备份

#!/bin/bash

DATE=$(date +%F_%H-%M-%S)   # 获取当前日期和时间，用于备份文件名
HOST=192.168.1.120   # 数据库主机地址
DB=test   # 数据库名称
USER=bak   # 数据库用户名
PASS=123456   # 数据库密码
MAIL="[email protected] [email protected]"   # 接收备份结果通知的邮件地址
BACKUP_DIR=/data/db_backup   # 备份文件存储路径
SQL_FILE=${DB}_full_$DATE.sql   # 生成的 SQL 备份文件名
BAK_FILE=${DB}_full_$DATE.zip   # 生成的压缩备份文件名

cd $BACKUP_DIR   # 切换到备份文件存储路径

# 使用 mysqldump 命令备份数据库，并将结果输出到 SQL 备份文件中
if mysqldump -h$HOST -u$USER -p$PASS --single-transaction --routines --triggers -B $DB > $SQL_FILE; then
    # 如果备份成功，则将 SQL 备份文件压缩为压缩备份文件，并删除原始 SQL 备份文件
    zip $BAK_FILE $SQL_FILE && rm -f $SQL_FILE
    # 如果压缩备份文件为空，则表示备份数据可能出错，发送邮件通知
    if [ ! -s $BAK_FILE ]; then
        echo "$DATE 内容" | mail -s "主题" $MAIL
    fi
else
    # 如果备份失败，发送邮件通知
    echo "$DATE 内容" | mail -s "主题" $MAIL
fi

# 删除14天前的压缩备份文件
find $BACKUP_DIR -name '*.zip' -ctime +14 -exec rm {} \;

这段代码的功能是备份指定数据库，并将备份文件压缩，最后删除过期的备份文件。
代码的功能：

• DATE=$ (date +%F_%H-%M-%S)，使用 date 命令获取当前的日期和时间，并赋值给变量 DATE，用于生成备份文件名。
• HOST=192.168.1.120，设置数据库主机地址。
• DB=test，设置要备份的数据库名称。
• USER=bak，设置连接数据库所使用的用户名。
• PASS=123456，设置连接数据库所使用的密码。
• MAIL=“[email protected] [email protected]”，设置接收备份结果通知的邮件地址，多个邮件地址之间使用空格分隔。
• BACKUP_DIR=/data/db_backup，设置备份文件存储路径。
• SQL_FILE=$ {DB}full$ DATE.sql，生成 SQL 备份文件的文件名。
• BAK_FILE=$ {DB}full$ DATE.zip，生成的压缩备份文件名。
• cd $ BACKUP_DIR，切换到备份文件存储路径。
• if mysqldump -h$ HOST -u$ USER -p$ PASS --single-transaction --routines --triggers -B $ DB > $ SQL_FILE; then … fi，使用 mysqldump 命令备份指定数据库，并将结果输出到 SQL 备份文件中。如果备份成功，则执行条件判断的代码块。
• zip $ BAK_FILE $ SQL_FILE && rm -f $ SQL_FILE，将 SQL 备份文件压缩为压缩备份文件，并删除原始 SQL 备份文件。
• if [ ! -s $ BAK_FILE ]; then … fi，如果压缩备份文件为空（没有内容），执行条件判断的代码块。
• echo “$DATE 内容” | mail -s “主题” $MAIL，使用 mail 命令发送邮件通知，邮件主题为 “主题”，邮件内容包含当前的日期和时间。
• else … fi，如果备份失败，执行条件判断的代码块。
• find $BACKUP_DIR -name ‘*.zip’ -ctime +14 -exec rm {} ;，使用 find 命令查找指定路径下14天前的所有压缩备份文件，并删除它们。

19、Nginx服务管理脚本

场景：使用源码包安装Nginx不含带服务管理脚本，也就是不能使用"service nginx start"或"/etc/init.d/nginx start"，所以写了以下的服务管理脚本。

#!/bin/bash
# Description: Only support RedHat system

. /etc/init.d/functions

WORD_DIR=/usr/local/nginx   # Nginx安装目录
DAEMON=$WORD_DIR/sbin/nginx   # Nginx可执行文件路径
CONF=$WORD_DIR/conf/nginx.conf   # Nginx配置文件路径
NAME=nginx   # 进程名称
PID=$(awk -F'[; ]+' '/^[^#]/{if($0~/pid;/)print $2}' $CONF)   # 获取配置文件中定义的PID文件路径

# 如果配置文件中未定义PID文件路径，设置默认的PID文件路径
if [ -z "$PID" ]; then
    PID=$WORD_DIR/logs/nginx.pid
else
    PID=$WORD_DIR/$PID
fi

stop() {
    $DAEMON -s stop   # 发送信号停止Nginx进程
    sleep 1
    # 判断PID文件是否存在，根据结果输出不同的操作提示
    [ ! -f $PID ] && action "* Stopping $NAME"  /bin/true || action "* Stopping $NAME" /bin/false
}

start() {
    $DAEMON   # 启动Nginx进程
    sleep 1
    # 判断PID文件是否存在，根据结果输出不同的操作提示
    [ -f $PID ] && action "* Starting $NAME"  /bin/true || action "* Starting $NAME" /bin/false
}

reload() {
    $DAEMON -s reload   # 发送信号重新加载Nginx配置
}

test_config() {
    $DAEMON -t   # 检查Nginx配置文件语法是否正确
}

case "$1" in
    start)
        # 如果PID文件不存在，启动Nginx进程；否则输出进程正在运行的提示
        if [ ! -f $PID ]; then
            start
        else
            echo "$NAME is running..."
            exit 0
        fi
        ;;
    stop)
        # 如果PID文件存在，停止Nginx进程；否则输出进程未运行的提示
        if [ -f $PID ]; then
            stop
        else
            echo "$NAME not running!"
            exit 0
        fi
        ;;
    restart)
        # 如果PID文件不存在，输出进程未运行的提示并启动Nginx进程；否则先停止再启动
        if [ ! -f $PID ]; then
            echo "$NAME not running!" 
            start
        else
            stop
            start
        fi
        ;;
    reload)
        # 发送信号重新加载Nginx配置
        reload
        ;;
    testconfig)
        # 检查Nginx配置文件语法是否正确
        test_config
        ;;
    status)
        # 根据PID文件是否存在输出不同的状态提示
        [ -f $PID ] && echo "$NAME is running..." || echo "$NAME not running!"
        ;;
    *)
        # 输出脚本的使用方法，并退出脚本（返回退出码3）
        echo "Usage: $0 {start|stop|restart|reload|testconfig|status}"
        exit 3
        ;;
esac

这段脚本实现了对 Nginx 服务的启停、重启、重新加载配置文件以及检查配置文件语法的功能。
代码的功能：

• . /etc/init.d/functions，引入 /etc/init.d/functions 文件，该文件包含用于输出提示信息的函数。
• WORD_DIR=/usr/local/nginx，设置 Nginx 的安装目录。
• DAEMON=$WORD_DIR/sbin/nginx，设置 Nginx 可执行文件的路径。
• CONF=$ WORD_DIR/conf/nginx.conf，设置 Nginx 的配置文件路径。
• NAME=nginx，设置进程名称为 “nginx”。
• PID=$ (awk -F’[; ]+’ ‘/^ [ ^#]/{if($ 0~/pid;/)print $ 2}’ $ CONF)，使用 awk 命令从配置文件中提取 PID 文件路径。
• if [ -z “$ PID” ]; then … else … fi，如果 PID 文件路径为空，则设置默认的 PID 文件路径为 $ WORD_DIR/logs/nginx.pid。
• stop() { … }，定义一个函数 stop，用于停止 Nginx 进程。
• start() { … }，定义一个函数 start，用于启动 Nginx 进程。
• reload() { … }，定义一个函数 reload，用于重新加载 Nginx 配置文件。
• test_config() { … }，定义一个函数 test_config，用于检查 Nginx 配置文件的语法是否正确。
• case “$1” in … esac，根据脚本传入的参数执行不同的操作。
• action “* Stopping $NAME” /bin/true，输出停止进程的操作提示，后面的 /bin/true 表示操作成功。
• action “* Starting $NAME” /bin/true，输出启动进程的操作提示，后面的 /bin/true 表示操作成功。
• action “* Stopping $NAME” /bin/false，输出停止进程的操作提示，后面的 /bin/false 表示操作失败。
• action “* Starting $NAME” /bin/false，输出启动进程的操作提示，后面的 /bin/false 表示操作失败。
• if [ ! -f $PID ]; then … else … fi，如果 PID 文件不存在，则启动 Nginx 进程；否则输出进程正在运行的提示。
• if [ -f $PID ]; then … else … fi，如果 PID 文件存在，则停止 Nginx 进程；否则输出进程未运行的提示。
• if [ ! -f $PID ]; then … else … fi，如果 PID 文件不存在，则输出进程未运行的提示并启动 Nginx - ；否则先停止再启动。
• reload，发送信号重新加载 Nginx 配置。
• test_config，检查 Nginx 配置文件的语法是否正确。
• [ -f $ PID ] && echo “$ NAME is running…” || echo “$NAME not running!”，根据 PID 文件是否存在输出不同的状态提示。
• echo “Usage: $0 {start|stop|restart|reload|testconfig|status}”，输出脚本的使用方法。
• exit 3，退出脚本，返回退出码 3。

20、用户根据菜单选择要连接的Linux主机

Linux主机SSH连接信息：

# cat host.txt
Web 192.168.1.10 root 22
DB 192.168.1.11 root 22

内容格式：主机名 IP User Port

#!/bin/bash

PS3="Please input number: "   # 设置 select 命令的提示信息

HOST_FILE=host.txt   # 存储主机连接信息的文件路径

# 无限循环，用于不断提供主机选择菜单
while true; do
    # 使用 select 命令选择主机名（从 host.txt 文件中获取）
    select NAME in $(awk '{print $1}' $HOST_FILE) quit; do
        # 如果选择的主机名为 "quit"，退出脚本
        [ ${NAME:=empty} == "quit" ] && exit 0

        # 根据选择的主机名从 host.txt 文件中获取对应的 IP、用户名和端口号
        IP=$(awk -v NAME=${NAME} '$1==NAME{print $2}' $HOST_FILE)
        USER=$(awk -v NAME=${NAME} '$1==NAME{print $3}' $HOST_FILE)
        PORT=$(awk -v NAME=${NAME} '$1==NAME{print $4}' $HOST_FILE)

        if [ $IP ]; then
            echo "Name: $NAME, IP: $IP"
            # 使用 ssh 命令连接远程主机，使用密钥免交互登录
            ssh -o StrictHostKeyChecking=no -p $PORT -i id_rsa $USER@$IP
            break
        else
            echo "Input error, Please enter again!"
            break
        fi
    done
done

这段脚本实现了根据主机名从 host.txt 文件中获取主机的连接信息，并使用 SSH 命令连接远程主机的功能。
代码的功能：

• PS3="Please input number: "，设置 select 命令的提示信息，用于用户选择主机时显示。
• HOST_FILE=host.txt，设置存储主机连接信息的文件路径为 host.txt。
• while true; do … done，无限循环，用于不断提供主机选择菜单。
• select NAME in $(awk ‘{print $1}’ $HOST_FILE) quit; do … done，使用 select 命令选择主机名（从 host.txt 文件中获取），并加上 quit 选项用于退出脚本。
• [ ${NAME:=empty} == “quit” ] && exit 0，如果选择的主机名为 quit，则退出脚本。
• IP=$ (awk -v NAME=${NAME} ‘$1==NAME{print $2}’ $HOST_FILE)，根据选择的主机名从 host.txt 文件中获取对应的 IP 地址。
• USER=$ (awk -v NAME=${NAME} ‘$1==NAME{print $3}’ $HOST_FILE)，根据选择的主机名从 - host.txt 文件中获取对应的用户名。
• PORT=$ (awk -v NAME=${NAME} ‘$1==NAME{print $4}’ $HOST_FILE)，根据选择的主机名从 host.txt 文件中获取对应的端口号。
• if [ $IP ]; then … else … fi，如果 IP 地址存在，则输出主机名和 IP 地址，并使用 SSH 命令连接远程主机；否则输出输入错误的提示信息。
• echo “Name: $NAME, IP: $IP”，输出选择的主机名和对应的 IP 地址。
• ssh -o StrictHostKeyChecking=no -p $ PORT -i id_rsa $ USER@$IP，使用 SSH 命令连接远程主机，其中使用 -o StrictHostKeyChecking=no 参数禁止严格的主机密钥检查，-p $PORT 指定连接的端口号，-i id_rsa 指定使用密钥文件进行免交互登录。
• break，结束当前循环，回到外层的无限循环，等待下一次主机选择。
• echo “Input error, Please enter again!”，输出输入错误的提示信息。
• exit 0，退出脚本，返回退出码 0。

21、从FTP服务器下载文件

#!/bin/bash

# 检查参数数量是否为1
if [ $# -ne 1 ]; then
    echo "Usage: $0 filename"
fi

# 获取指定文件的目录和文件名
dir=$(dirname $1)
file=$(basename $1)

# 使用 ftp 命令连接 FTP 服务器并执行操作
ftp -n -v << EOF   # -n 自动登录
open 192.168.1.10  # ftp服务器
user admin password   # 使用指定的用户名和密码登录
binary   # 设置ftp传输模式为二进制，避免MD5值不同或.tar.gz压缩包格式错误
cd $dir   # 切换到指定的目录
get "$file"   # 下载指定的文件
EOF

这段脚本实现了通过 FTP 下载指定文件的功能。
代码的功能：

• if [ $# -ne 1 ]; then … fi，检查传入的参数数量是否为1，如果不是1个参数，输出用法提示信息。
• echo “Usage: $0 filename”，输出用法提示信息，告知用户正确的参数输入格式。
• dir=$(dirname $1)，获取指定文件的目录路径。
• file=$(basename $1)，获取指定文件的文件名。
• ftp -n -v << EOF，使用 ftp 命令连接 FTP 服务器并执行操作，-n 参数表示在连接后不执行任何自动登录操作，-v 参数表示输出详细的执行过程信息。
• open 192.168.1.10，使用 ftp 命令连接到指定的 FTP 服务器，其中 192.168.1.10 是 FTP 服务器的 IP 地址。
• user admin password，使用指定的用户名 admin 和密码 password 进行登录。
• binary，设置 FTP 传输模式为二进制，以确保传输的文件保持原样，避免出现 MD5 值不同或 .tar.gz 压缩包格式错误的问题。
• cd $dir，切换到指定的目录。
• get “$ file”，下载指定的文件，其中 $ 用于获取变量的值，“$file” 使用双引号包围变量值，以处理文件名中可能包含的特殊字符。
• EOF，表示结束 ftp 命令的输入。

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

#!/bin/bash

# 初始化计数器、和、最小值、最大值
COUNT=1
SUM=0
MIN=0
MAX=100

# 循环5次，读取用户输入的整数并进行相关操作
while [ $COUNT -le 5 ]; do
    read -p "请输入1-10个整数：" INT   # 提示用户输入1-10个整数
    if [[ ! $INT =~ ^[0-9]+$ ]]; then   # 判断输入是否为整数
        echo "输入必须是整数！"
        exit 1   # 若输入不是整数，退出脚本，返回退出码 1
    elif [[ $INT -gt 100 ]]; then   # 判断输入是否小于等于100
        echo "输入必须是100以内！"
        exit 1   # 若输入大于100，退出脚本，返回退出码 1
    fi
    SUM=$(($SUM+$INT))   # 累加输入的整数到和变量
    [ $MIN -lt $INT ] && MIN=$INT   # 更新最小值变量
    [ $MAX -gt $INT ] && MAX=$INT   # 更新最大值变量
    let COUNT++   # 计数器自增
done

# 输出计算结果
echo "SUM: $SUM"   # 输出和
echo "MIN: $MIN"   # 输出最小值
echo "MAX: $MAX"   # 输出最大值

这段脚本实现了读取用户输入的整数，计算输入的整数的和、最小值和最大值，并输出结果。
代码的功能：

• COUNT=1，初始化计数器变量为1。
• SUM=0，初始化和变量为0。
• MIN=0，初始化最小值变量为0。
• MAX=100，初始化最大值变量为100。
• while [ $COUNT -le 5 ]; do … done，循环5次，用于接收和处理用户输入的整数。
• read -p “请输入1-10个整数：” INT，提示用户输入1-10个整数，并将输入的值保存到变量 INT。
• if [[ ! $ INT =~ ^ [0-9]+$ ]]; then … fi，如果输入的值不是整数，则提示错误并退出脚本。
• echo “输入必须是整数！”，输出提示信息，告知用户输入必须是整数。
• exit 1，退出脚本，返回退出码 1。
• elif [[ $INT -gt 100 ]]; then … fi，如果输入的值大于100，则提示错误并退出脚本。
• echo “输入必须是100以内！”，输出提示信息，告知用户输入必须是100以内的整数。
• SUM=$ (($ SUM+$INT))，将输入的整数累加到和变量。
• [ $ MIN -lt $ INT ] && MIN=$INT，更新最小值变量，如果新输入的整数大于最小值，则更新最小值。
• [ $ MAX -gt $ INT ] && MAX=$INT，更新最大值变量，如果新输入的整数小于最大值，则更新最大值。
• let COUNT++，将计数器自增。
• echo “SUM: $SUM”，输出计算的和。
• echo “MIN: $MIN”，输出计算的最小值。
• echo “MAX: $MAX”，输出计算的最大值。

23、将结果分别赋值给变量

应用场景：希望将执行结果或者位置参数赋值给变量，以便后续使用。

方法1：

for i in $(echo "4 5 6"); do   # 循环遍历 "4 5 6"
   eval a$i=$i   # 为变量 a4、a5、a6 赋值，变量名由 $i 决定，值为 $i 的值
done
echo $a4 $a5 $a6   # 输出变量 a4、a5、a6 的值

# 这段代码的目的是创建变量 a4、a5、a6，并将其赋值为 4、5、6

这段代码使用 for 循环遍历列表 “4 5 6”，对于每个列表中的元素，使用 eval 命令动态创建变量 a4、a5、a6，并赋值为相应的值。最后通过 echo 命令输出变量 a4、a5、a6 的值。

方法2：将位置参数192.168.1.1{1,2}拆分为到每个变量

num=0   # 初始化计数器变量为0
for i in $(eval echo $*); do   # 循环遍历命令行参数，并使用 eval 命令展开参数中的花括号拓展表达式
   let num+=1   # 计数器自增
   eval node${num}="$i"   # 动态创建变量 node1、node2、node3，并赋值为相应的参数值
done
echo $node1 $node2 $node3   # 输出变量 node1、node2、node3 的值

# 示例运行命令：bash a.sh 192.168.1.1{1,2}
# 输出：192.168.1.11 192.168.1.12

# 这段代码的目的是根据命令行参数动态创建变量，并赋予相应的值

这段代码通过 for 循环遍历命令行参数（使用 $* 获取所有参数），使用 eval 命令将参数中的花括号拓展表达式展开（如 192.168.1.1{1,2} 拓展为 192.168.1.11 192.168.1.12），然后在循环中，计数器 num 自增，然后使用 eval 命令动态创建变量 node1、node2、node3，并赋值为相应的参数值。最后通过 echo 命令输出变量 node1、node2、node3 的值。

方法3：

arr=(4 5 6)   # 创建包含元素 4、5、6 的数组 arr

INDEX1=$(echo ${arr[0]})   # 获取数组 arr 中的第一个元素，并将其赋值给变量 INDEX1
INDEX2=$(echo ${arr[1]})   # 获取数组 arr 中的第二个元素，并将其赋值给变量 INDEX2
INDEX3=$(echo ${arr[2]})   # 获取数组 arr 中的第三个元素，并将其赋值给变量 INDEX3

# 这段代码的目的是从数组 arr 中提取元素，并赋值给相应的变量

这段代码创建了一个名为 arr 的数组，其中包含了元素 4、5、6。

然后，使用 ${arr[index]} 的形式从数组 arr 中提取特定索引位置的元素，并使用 echo 命令将其输出。通过将提取的元素赋值给相应的变量（INDEX1、INDEX2、INDEX3），来存储和使用这些值。

• INDEX1=$(echo ${arr[0]})，将数组 arr 的第一个元素（索引为 0）赋值给变量 INDEX1。
• INDEX2=$(echo ${arr[1]})，将数组 arr 的第二个元素（索引为 1）赋值给变量 INDEX2。
• INDEX3=$(echo ${arr[2]})，将数组 arr 的第三个元素（索引为 2）赋值给变量 INDEX3。

通过这种方式，变量 INDEX1、INDEX2 和 INDEX3 将分别包含数组 arr 中对应索引位置的值。

24、批量修改文件名

示例：

# touch article_{1..3}.html
# ls
article_1.html  article_2.html  article_3.html

目的：把article改为bbs

方法1：

for file in $(ls *html); do   # 循环遍历当前目录下以 html 结尾的文件
    mv $file bbs_${file#*_}   # 将文件名修改为 bbs_ 后加上原文件名中第一个下划线后的部分

    # 同等效果的替代方法1:
    # mv $file $(echo $file |sed -r 's/.*(_.*)/bbs\1/')

    # 同等效果的替代方法2:
    # mv $file $(echo $file |echo bbs_$(cut -d_ -f2)
done

这段代码的作用是遍历当前目录下以 .html 结尾的文件，并将文件名进行修改。

• for file in $(ls *html)，使用 *html 通配符来查找当前目录下以 .html 结尾的文件，并逐个进行处理。
• mv $ file bbs_$ {file#}，使用 mv 命令将文件名修改为 bbs 后再加上原文件名第一个下划线后的部分。${file#_} 是一种字符串截取的方式，表示获取变量 file 中第一个下划线后的部分。

• 替代方法1：mv $file $(echo $file |sed -r 's/*(_.* )/bbs\1/')，使用 sed 命令进行正则表达式的替换操作，将文件名中的第一个下划线及其后的部分替换为 bbs_ 加上对应的部分。
  

• 替代方法2：mv $ file $ (echo $ file |echo bbs_$(cut -d_ -f2)，使用 cut 命令提取文件名中第一个下划线后的部分，然后将其拼接为 bbs_ 加上对应的部分。
  

这段代码的目的是对当前目录下以 .html 结尾的文件进行批量重命名，将文件名修改为以 bbs_ 开头并保留原文件名中第一个下划线后的部分。

方法2：

for file in $(find . -maxdepth 1 -name "*html"); do   # 使用 find 命令查找当前目录下的以 html 结尾的文件
    mv $file bbs_${file#*_}   # 将文件名修改为 bbs_ 后加上原文件名中第一个下划线后的部分
done

这段代码的作用是在当前目录下查找以 .html 结尾的文件，并将这些文件的文件名进行修改。

• . -maxdepth 1 -name “*html”，使用 find 命令在当前目录下查找满足以下条件的文件：
  • -maxdepth 1：仅在当前目录进行查找，不递归查找子目录。
  • -name “*html”：文件名以 .html 结尾。
• for file in $(find . -maxdepth 1 -name “*html”)，将查找到的文件列表循环处理。
• mv $ file bbs_$ {file#}，使用 mv 命令将文件名修改为 bbs 后再加上原文件名中第一个下划线后的部分。${file#_} 是一种字符串截取的方式，表示获取变量 file 中第一个下划线后的部分。
  • 例如文件名为 prefix_filename.html，那么 ${file#*_} 的值就是 filename.html，然后将文件名修改为 bbs_filename.html。

这段代码的目的是在当前目录下查找以 .html 结尾的文件，并将这些文件的文件名批量修改为以 bbs_ 开头并保留原文件名中第一个下划线后的部分。

方法3：

# rename article bbs *.html

这段代码使用了 rename 命令，对当前目录下以 .html 结尾的文件进行批量重命名。

• rename 命令用于批量重命名文件名中的指定部分。
• article 是要被替换的部分，bbs 是替换后的部分。
• *.html 是要进行重命名操作的文件匹配模式，表示当前目录下所有以 .html 结尾的文件。

这段代码的目的是将当前目录下以 .html 结尾的文件名中的 article 替换为 bbs，实现文件名的批量重命名操作。

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

方法1：

# find . -name "*.html" -exec du -k {} \; |awk '{sum+=$1}END{print sum}'

这段代码使用了find命令、du命令和awk命令来计算当前目录下以.html结尾的文件的总大小（以KB为单位）。

• find . -name “*.html”：使用find命令在当前目录及其子目录下查找文件名以.html结尾的文件。
• -exec du -k {} ;：对于每个找到的文件，使用du -k命令以KB为单位显示文件大小。通过-exec选项和{}占位符将找到的文件传递给du命令进行处理。
• |：使用管道（pipe）将du命令的输出传递给下一个命令。
• awk ‘{sum+=$1}END{print sum}’：使用awk命令对du命令的输出进行处理，计算文件大小的总和。awk命令中的代码逐行读取du命令的输出，并将每一行的第一个字段（文件大小）累加到变量sum中。最后，在处理完所有行后，在END部分使用print sum打印出总和。

这段代码的目的是计算当前目录下以.html结尾的文件的总大小（以KB为单位）。

方法2：

for size in $(ls -l *.html | awk '{print $5}'); do   # 获取当前目录下以 .html 结尾的文件的大小列表
    sum=$(($sum+$size))   # 对每个文件的大小进行累加
done
echo $sum   # 打印所有文件大小的总和

这段代码的作用是计算当前目录下以 .html 结尾的文件的总大小（以字节为单位）。

• ls -l *.html | awk ‘{print $5}’：使用 ls -l 命令获取当前目录下以 .html 结尾的文件的详细列表，并通过管道将结果传递给 awk 命令。awk ‘{print $5}’ 表示只输出每行的第五个字段（文件大小）。
• for size in $(ls -l *.html | awk ‘{print $5}’)：将获取到的文件大小列表逐个赋值给变量 size 进行循环处理。
• sum=$ (($ sum+$ size))：将每个文件的大小累加到变量 sum 中。$ sum+$ size 表示将变量 sum 和 size 的值相加。$((…)) 是一种算术表达式的写法。
• echo $sum：打印所有文件大小的总和。

这段代码的目的是计算当前目录下以 .html 结尾的文件的总大小（以字节为单位），将每个文件的大小累加到变量 sum 中，并最后打印出总和。

26、扫描主机端口状态

#!/bin/bash
HOST=$1   # 获取第一个命令行参数，作为主机名或 IP 地址
PORT="22 25 80 8080"   # 定义要检测的端口列表

for PORT in $PORT; do   # 遍历端口列表
    if echo &>/dev/null > /dev/tcp/$HOST/$PORT; then   # 使用 /dev/tcp 文件系统，尝试与指定的主机和端口建立 TCP 连接
        echo "$PORT open"   # 如果 TCP 连接成功，则输出端口为开放状态
    else
        echo "$PORT close"   # 如果 TCP 连接失败，则输出端口为关闭状态
    fi
done

这段代码的作用是检测指定主机的一些常见端口是否开放。

• #!/bin/bash：指定该脚本以 Bash 解释器运行。
• HOST=$1：将第一个命令行参数赋值给变量 HOST，表示要检测的主机名或 IP 地址。
• PORT=“22 25 80 8080”：定义要检测的端口列表，包括 22、25、80 和 8080。
• for PORT in $PORT; do：遍历端口列表。
• if echo &>/dev/null > /dev/tcp/$ HOST/$PORT; then：使用 /dev/tcp 文件系统，尝试与指定的主机和端口建立 TCP 连接。通过重定向输入输出到 /dev/null 来实现静默连接的效果。
• echo “$PORT open”：如果 TCP 连接成功，则输出该端口为开放状态。
• echo “$PORT close”：如果 TCP 连接失败，则输出该端口为关闭状态。

这段代码的目的是遍历指定主机的端口列表，并尝试与每个端口建立 TCP 连接，通过输出端口状态来告知该端口是否开放。

27、Expect实现SSH免交互执行命令

Expect是一个自动交互式应用程序的工具，如telnet，ftp，passwd等。

需先安装expect软件包。

方法1：EOF标准输出作为expect标准输入

#!/bin/bash
USER=root               # 设置要登录的远程主机的用户名
PASS=123.com            # 设置远程主机用户的登录密码
IP=192.168.1.120        # 设置远程主机的 IP 地址

expect << EOF           # 使用 expect 来编写自动化交互脚本
set timeout 30          # 设置超时时间为 30 秒

spawn ssh $USER@$IP     # 使用 spawn 命令启动 ssh 进行远程登录连接

expect {
    "(yes/no)" {send "yes\r"; exp_continue}   # 如果出现 "(yes/no)" 提示，自动发送 "yes" 并继续等待
    "password:" {send "$PASS\r"}               # 如果出现 "password:" 提示，自动发送密码进行登录
}

expect "$USER@*"  {send "$1\r"}         # 在成功登录后，根据需要执行的操作，这里发送了一个 $1 变量
expect "$USER@*"  {send "exit\r"}       # 执行完操作后，发送 "exit" 命令退出登录
expect eof                             # 等待所有交互完成后，终止 expect 脚本
EOF

这段代码使用了 expect 工具编写了一个自动化交互脚本，用于实现通过 SSH 远程登录到指定主机，并执行一些操作。

• USER=root：将要登录的远程主机的用户名设置为 root。
• PASS=123.com：将远程主机用户的登录密码设置为 123.com。
• IP=192.168.1.120：设置远程主机的 IP 地址为 192.168.1.120。

在 expect 命令的使用过程中：

• set timeout 30：设置超时时间为 30 秒，用于控制登录的等待时间。
• spawn ssh $USER@$IP：使用 spawn 命令启动 ssh 进程进行远程登录连接。
• expect 块中使用模式匹配来等待特定的交互信息，并根据不同的提示进行相应的操作。
• send 命令用于向程序发送输入信息，完成自动化交互。
• $1 是一个变量，它被发送给远程主机以执行特定操作。
• expect eof：等待所有交互完成后，终止 expect 脚本。

这段代码的目的是使用 expect 实现自动化登录远程主机，并在登录后执行指定的操作。

方法2：

#!/bin/bash
USER=root             # 设置要登录的远程主机的用户名
PASS=123.com          # 设置远程主机的登录密码
IP=192.168.1.120      # 设置远程主机的 IP 地址

expect -c "            # 使用 expect 命令编写内联脚本
    spawn ssh $USER@$IP    # 使用 spawn 命令启动 ssh 进程进行远程登录连接

    expect {
        \"(yes/no)\" {send \"yes\r\"; exp_continue}   # 如果出现 "(yes/no)" 提示，自动发送 "yes" 并继续等待
        \"password:\" {send \"$PASS\r\"; exp_continue}   # 如果出现 "password:" 提示，自动发送密码并继续等待
        \"$USER@*\" {send \"df -h\r exit\r\"; exp_continue}   # 如果成功登录，发送 "df -h" 命令查看磁盘使用情况，并发送 "exit" 命令退出登录
    }"

这段代码使用了 expect 工具以内联脚本的方式编写，实现了通过 SSH 登录到指定主机，并执行特定命令的自动化操作。

• USER=root：将要登录的远程主机的用户名设置为 root。
• PASS=123.com：将远程主机的登录密码设置为 123.com。
• IP=192.168.1.120：设置远程主机的 IP 地址为 192.168.1.120。

在 expect -c 命令中：

• spawn ssh $ USER@$IP：使用 spawn 命令启动 ssh 进程进行远程登录连接。
• expect 块中使用模式匹配来等待特定的交互信息，并根据不同的提示进行相应的操作。
• send 命令用于向程序发送输入信息，完成自动化交互。
• “(yes/no)” {send “yes\r”; exp_continue}：如果出现 “(yes/no)” 提示，自动发送 “yes” 并继续等待。
• “password:” {send “$PASS\r”; exp_continue}：如果出现 “password:” 提示，自动发送密码并继续等待。
• “$USER@*” {send “df -h\r exit\r”; exp_continue}：如果成功登录，则发送 “df -h” 命令查看磁盘使用情况，并发送 “exit” 命令退出登录。
• exp_continue：使 expect 继续等待下一个匹配。

这段代码的目的是通过 expect 实现自动化登录远程主机，并在登录后执行特定命令，如查看磁盘使用情况，并最后退出登录。

28、批量修改服务器用户密码

Linux主机SSH连接信息：旧密码

# cat old_pass.txt 
192.168.18.217  root    123456     22
192.168.18.218  root    123456     22

内容格式：IP User Password Port

SSH远程修改密码脚本：新密码随机生成

#!/bin/bash
OLD_INFO=old_pass.txt    # 存储旧密码信息的文件路径
NEW_INFO=new_pass.txt    # 存储新密码信息的文件路径

for IP in $(awk '/^[^#]/{print $1}' $OLD_INFO); do     # 使用 awk 命令遍历获取每行的 IP 地址
    USER=$(awk -v I=$IP 'I==$1{print $2}' $OLD_INFO)   # 根据 IP 地址获取对应的用户名
    PASS=$(awk -v I=$IP 'I==$1{print $3}' $OLD_INFO)   # 根据 IP 地址获取对应的密码
    PORT=$(awk -v I=$IP 'I==$1{print $4}' $OLD_INFO)   # 根据 IP 地址获取对应的端口号
    NEW_PASS=$(mkpasswd -l 8)   # 使用 mkpasswd 命令生成一个具有 8 个字符长度的随机密码

    echo "$IP   $USER   $NEW_PASS   $PORT" >> $NEW_INFO    # 将新的密码信息追加到新密码文件中

    expect -c "
    spawn ssh -p$PORT $USER@$IP    # 使用 spawn 命令启动 ssh 进程进行远程登录连接
    set timeout 2    # 设置超时时间为 2 秒

    expect {
        \"(yes/no)\" {send \"yes\r\"; exp_continue}    # 如果出现 "(yes/no)" 提示，自动发送 "yes" 并继续等待
        \"password:\" {send \"$PASS\r\"; exp_continue}    # 如果出现 "password:" 提示，自动发送旧密码并继续等待
        \"$USER@*\" {send \"echo \'$NEW_PASS\' | passwd --stdin $USER\r exit\r\"; exp_continue}    # 如果成功登录，发送命令将新密码设置为随机生成的新密码，并发送 "exit" 命令退出登录
    }"
done

生成新密码文件：

# cat new_pass.txt 
192.168.18.217  root    n8wX3mU%      22
192.168.18.218  root    c87;ZnnL      22

29、打印九九乘法口诀

for ((i=1;i<=9;i++)); do      # 外层循环，控制行数，从 1 到 9
   for ((j=1;j<=i;j++)); do   # 内层循环，控制每行的乘法表达式，从 1 到当前行数
     result=$(($i*$j))        # 计算乘法结果
     echo -n "$j*$i=$result " # 打印乘法表达式和结果，不换行
   done
   echo                       # 内层循环结束后换行
done

这段代码的作用是打印一个简单的乘法表，从 1 到 9，按行输出。

在外层循环中，i 控制当前行数，从 1 到 9 逐渐增加。

在内层循环中，j 控制每行的乘法表达式，从 1 到当前行数 逐渐增加。

在每次内层循环中，计算乘法结果 result 的值，并使用 echo -n 打印乘法表达式和结果，不换行。

内层循环结束后，使用 echo 单独打印一个换行符，换行后进入下一行的循环。

这段代码的输出结果是一个九九乘法表。

30、斐波那契数列

#!/bin/bash

echo "请输入斐波那契数列的长度："
read length   # 获取用户输入的斐波那契数列长度

# 初始化前两个斐波那契数
num1=0   # 第一个斐波那契数为 0
num2=1   # 第二个斐波那契数为 1

# 输出前两个数
echo "斐波那契数列的前 $length 个数为："
echo -n "$num1 $num2"   # 输出第一个和第二个斐波那契数

# 循环计算并输出斐波那契数列
for ((i=2;i<$length;i++))
do
    sum=$(($num1 + $num2))   # 计算下一个斐波那契数
    echo -n " $sum"   # 输出计算得到的斐波那契数
    num1=$num2   # 更新第一个斐波那契数为当前的第二个斐波那契数
    num2=$sum   # 更新第一个斐波那契数为当前的计算结果
done

echo ""   # 输出换行符，使结果美观

这段代码的作用是根据用户输入的长度，生成并输出相应长度的斐波那契数列。

• echo “请输入斐波那契数列的长度：”：提示用户输入斐波那契数列的长度。
• read length：将用户输入的长度保存到变量 length 中。

通过循环计算斐波那契数列，并输出结果：

• num1 和 num2 分别用于保存当前计算的斐波那契数列的前两个数。
• 使用 echo -n 输出前两个数。
• 利用循环计算出剩余的斐波那契数，并使用 echo -n 输出结果。
• 在每次循环中，更新 num1 和 num2 的值，并继续计算下一个斐波那契数。