【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 "主题" dst@example.com
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="example@mail.com"

# 检查系统是否安装了 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="example@mail.com"

# 使用 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 "空间不足警告" xiaobai@cdeledu.com
done

代码的功能：

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

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="zhangsan@example.com lisi@example.com"   # 接收备份结果通知的邮件地址
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="zhangsan@example.com lisi@example.com"，设置接收备份结果通知的邮件地址，多个邮件地址之间使用空格分隔。
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 U S E R @ USER@ 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 的值，并继续计算下一个斐波那契数。