***场景描述***

在日常的Linux运维工作中，我们经常需要在不同的机器之间复制文件或者目录。通常情况下，我们使用scp或者rsync命令进行复制操作，但是这些命令需要手动输入用户名、密码以及目标地址等信息，繁琐且容易出错。

因此，编写一个自动化脚本来完成这些操作就显得非常必要。该脚本可以通过预设的参数，快速地完成文件或目录的复制操作，提高生产力，降低出错率。

使用脚本具有以下优势。

1、提高效率：通过使用脚本，我们可以快速地完成复制操作，无需手动输入用户名、密码等信息，大大提高了效率。

2、简化操作：脚本将复杂的命令操作封装在内部，使用者只需要输入简单的命令，就可以完成复制操作，极大地简化了操作流程。

3、减少错误：手动输入命令容易出错，而使用脚本可以规避这些错误。脚本可以通过预设参数来自动化执行操作，减少输入错误，避免不必要的麻烦和损失。

4、提高可维护性：脚本的可维护性也很高。通过将一些常用的命令和操作封装在脚本中，可以降低错误率，同时也方便了维护和更新。

***项目实施***

我们需要创建一个文件夹用于存储备份文件和日志，可以命名为“backup”。

接下来，我们可以编写一个备份脚本，命名为“backup.sh”，其基本步骤如下：

1、获取当前日期，用于命名备份文件和记录日志。

2、判断备份目录是否存在，如果不存在则创建。

3、执行备份操作，将指定文件夹下的文件复制到备份目录。

4、压缩备份文件，并将压缩文件存储到备份目录。

5、记录备份日志，包括备份日期、备份文件名、备份文件大小等信息。

上代码！

```
#!/bin/bash

# 获取当前日期
backup_date=$(date +"%Y-%m-%d")

# 备份目录
backup_dir="/home/user/backup"

# 判断备份目录是否存在，如果不存在则创建
if [ ! -d "$backup_dir" ]; then
  mkdir $backup_dir
fi

# 执行备份操作，将指定文件夹下的文件复制到备份目录
cp -R /home/user/data $backup_dir/data_$backup_date

# 压缩备份文件，并将压缩文件存储到备份目录
tar -czvf $backup_dir/data_$backup_date.tar.gz $backup_dir/data_$backup_date

# 记录备份日志，包括备份日期、备份文件名、备份文件大小等信息
backup_size=$(du -h $backup_dir/data_$backup_date.tar.gz | awk '{print $1}')
echo "$backup_date Backup Completed: data_$backup_date.tar.gz ($backup_size)" >> $backup_dir/backup.log
```

这个备份脚本假设要备份的文件夹是“/home/user/data”，备份后的文件存储在“/home/user/backup”目录中，备份日志记录在“/home/user/backup/backup.log”文件中。

我们可以将此脚本添加到计划任务中，例如每天晚上执行一次备份操作：

```
# 编辑计划任务
crontab -e

# 在计划任务中添加以下内容，表示每天晚上10点执行备份脚本
0 22 * * * /bin/bash /home/user/backup.sh
```

在Linux下完成文件的自动化备份

### 场景描述：

在一个企业级Linux服务器集群中，存在大量的日志文件需要进行定期清理，以释放磁盘空间，保证系统的正常运行。由于服务器数量众多，手动清理工作量巨大，因此需要编写一个自动化脚本来实现日志清理的任务。同时，由于日志文件可能被其他应用程序占用，需要在清理之前判断日志文件是否处于使用状态，以避免数据丢失和应用程序崩溃。

### 解决方案：

我们可以编写一个shell脚本来实现自动化日志清理的任务，具体步骤如下：

首先，获取需要清理的日志文件路径和保留时间。可以通过配置文件或命令行参数来指定。

然后，检查每个日志文件是否处于使用状态。如果正在使用，则跳过该文件，否则进行下一步操作。

接下来，判断日志文件是否过期，如果过期则将其删除。

最后，输出日志信息，记录已清理的文件数和已跳过的文件数。

### 项目实施

上代码！

```
#!/bin/bash

# 获取需要清理的日志文件路径和保留时间
log_path="/var/log"
keep_days=30

# 记录已清理和已跳过的文件数
cleaned=0
skipped=0

# 检查日志文件是否处于使用状态
function check_log_status() {
    lsof "$1" > /dev/null
    return $?
}

# 删除过期的日志文件
function clean_log_file() {
    if [ -f "$1" ] && [ ! -L "$1" ] && [ ! "$(basename "$1")" == "*.log" ]; then
        if check_log_status "$1"; then
            echo "File $1 is in use, skip cleaning."
            ((skipped++))
        elif [ $(find "$1" -type f -mtime +"$keep_days" | wc -l) -gt 0 ]; then
            echo "Cleaning file: $1"
            rm "$1"
            ((cleaned++))
        else
            echo "File $1 is not expired, skip cleaning."
            ((skipped++))
        fi
    fi
}

# 遍历日志目录，清理日志文件
for logfile in $(find "$log_path" -type f); do
    clean_log_file "$logfile"
done

# 输出日志信息
echo "Cleaned $cleaned files, skipped $skipped files."
```

该脚本首先获取需要清理的日志文件路径和保留时间，然后遍历该路径下的所有文件，逐一判断其是否处于使用状态和是否过期，并进行相应的操作。最后输出已清理和已跳过的文件数，方便用户了解清理效果。

日志文件清理脚本

对于任何一个计算机系统，数据备份都是至关重要的。无论是个人电脑、服务器还是整个数据中心，所有的数据都应该备份，以防止数据丢失或系统崩溃。在备份过程中，自动化和规范化是非常重要的。为此，我们可以使用脚本来自动化和规范化整个过程。本文将详细介绍文件备份脚本的重要性。

**为什么需要文件备份脚本？**

文件备份是一个非常耗时和费力的过程，需要花费大量的时间和精力来完成。如果备份是手动完成的，那么很容易出现人为错误，例如忘记备份某个文件或目录，或者忘记将备份数据存储在正确的位置。此外，手动备份还需要大量的时间和精力，因此可能会被拖延或忘记备份。

因此，使用文件备份脚本是非常必要的。备份脚本可以自动完成备份过程，从而减少了人为错误的风险，并提高了备份的效率。同时，脚本可以帮助我们规范化备份过程，例如定期备份和统一备份位置等。因此，备份脚本可以节省时间和精力，并提高备份的可靠性和可用性。

**备份脚本的设计**

备份脚本的设计应该根据实际情况来确定，主要包括以下几个方面：

1、备份的目标和范围

在设计备份脚本之前，我们需要确定需要备份的文件和目录。备份范围可以根据实际情况来确定，例如备份整个系统或仅备份特定目录。此外，我们还需要确定备份的目标位置，例如备份到本地硬盘、远程服务器或云存储服务。

2、备份策略

备份策略是指备份的频率和保留时间。我们需要确定备份的频率，例如每日、每周或每月备份。同时，我们需要确定备份的保留时间，例如保留最近七天的备份数据。

3、备份脚本的实现

备份脚本的实现需要根据实际情况来确定。我们可以使用Linux中的常用命令来实现备份脚本，例如cp、rsync、tar等。在实现备份脚本时，我们需要考虑以下几个方面：

(1)备份文件和目录的路径。

(2)备份文件和目录的过滤规则。

(3)备份的目标位置和命名规则。

(4)日志记录和错误处理。

**脚本示例**

某公司有一个由多个Linux服务器组成的集群，其中有一台主服务器，负责维护整个集群的状态和配置信息。为了保证集群的高可用性和可靠性，主服务器需要定期备份所有从服务器上的重要数据，并将备份文件存储在一个指定的网络共享目录中。

```
#!/bin/bash

# 定义备份目录和备份文件名
backup_dir="/backup"
backup_file="backup_$(date '+%Y%m%d').tar.gz"

# 检查备份目录是否存在，如果不存在则创建
if [ ! -d $backup_dir ]; then
    mkdir $backup_dir
fi

# 执行备份操作，将所有从服务器上的数据备份到本地的备份目录中
rsync -avz --exclude-from=/etc/rsync_exclude.txt --delete --progress user@slave1:/data $backup_dir
rsync -avz --exclude-from=/etc/rsync_exclude.txt --delete --progress user@slave2:/data $backup_dir
rsync -avz --exclude-from=/etc/rsync_exclude.txt --delete --progress user@slave3:/data $backup_dir

# 将备份文件压缩并存储到指定的网络共享目录中
tar -czf $backup_file $backup_dir
rsync -avz --progress $backup_file user@network_share:/backup
```

以上脚本实现了一个简单的备份功能，将所有从服务器上的数据备份到本地的备份目录中，然后将备份文件压缩并存储到指定的网络共享目录中。其中，rsync命令用于实现文件同步，tar命令用于实现文件压缩，最后使用rsync命令将备份文件上传到网络共享目录。在实际使用中，可以将该脚本添加到定时任务中，定期执行备份操作，保证数据的可靠性和完整性。同时，为了确保备份文件的安全性，可以对备份文件进行加密或者在存储时设置访问权限等措施。

文件备份脚本

静态IP地址是指不会随着时间和网络拓扑变化而改变的IP地址。与之相对的是动态IP地址，动态IP地址通常由DHCP服务器分配，可能在不同的时间分配给不同的设备。在某些情况下，需要使用静态IP地址，例如需要对网络设备进行访问控制，需要进行端口转发，或需要对特定设备进行远程访问等。

在Linux系统中，通过手动编辑配置文件的方式来设置静态IP地址，但这种方式往往比较繁琐，容易出错。因此，编写一个静态IP配置脚本可以大大简化这个过程，提高效率，减少错误。

下面是一个基于RHEL 9的单节点示例脚本：

```
#!/bin/bash
# 设置静态IP地址的脚本
# 修改接口和连接名为ens160
interface=ens160
connection=ens160
# 修改IP地址、子网掩码、网关和DNS
ipaddr=192.168.1.181
netmask=255.255.255.0
gateway=192.168.1.1
dns=8.8.8.8
# 使用nmcli命令修改网络配置
sudo nmcli con modify "$connection" ifname "$interface" ipv4.method manual ipv4.addresses "$ipaddr"/24 gw4 "$gateway"
sudo nmcli con modify "$connection" ipv4.dns "$dns"
# 重启连接
sudo nmcli con down "$connection"
sudo nmcli con up "$connection"
# 显示结果
echo "静态IP地址已设置为：$ipaddr"
echo "子网掩码已设置为：$netmask"
echo "网关已设置为：$gateway"
echo "DNS已设置为：$dns"
```

在脚本中，首先定义了需要修改的网络接口和连接名，以及需要配置的IP地址、子网掩码、网关和DNS。然后使用nmcli命令来修改连接配置，包括设置网络连接的IP地址、子网掩码、网关和DNS。最后重启连接，以使新的配置生效。

基于上述思路，可以写出一个多节点的脚本：

```
#!/bin/bash
# 定义多节点主机名和IP地址
nodes=(
  node1:192.168.1.181
  node2:192.168.1.182
  node3:192.168.1.183
)

# 循环遍历每个节点，执行静态IP配置脚本
for node in "${nodes[@]}"; do
    # 从节点信息中分离主机名和IP地址
    hostname=$(echo "$node" | cut -d ':' -f1)
    ipaddr=$(echo "$node" | cut -d ':' -f2)

    # 在远程节点上执行静态IP配置脚本
    ssh "$hostname" bash -s << EOF
        # 配置静态IP地址
        interface=enp0s3
        connection=enp0s3
        netmask=255.255.255.0
        gateway=192.168.1.1
        dns=4.2.2.2

        sudo nmcli con modify "\$connection" ifname "\$interface" ipv4.method manual ipv4.addresses "\$ipaddr"/24 gw4 "\$gateway"
        sudo nmcli con modify "\$connection" ipv4.dns "\$dns"

        sudo nmcli con down "\$connection"
        sudo nmcli con up "\$connection"

        echo "静态IP地址已设置为：\$ipaddr"
        echo "子网掩码已设置为：\$netmask"
        echo "网关已设置为：\$gateway"
        echo "DNS已设置为：\$dns"
EOF
done
```

上述脚本可以实现在多个节点上配置静态IP地址的自动化部署。其具体工作流程如下：

1、首先，定义了一个包含多个节点信息的数组，其中每个元素都是一个由主机名和IP地址组成的字符串。这些信息被保存在 nodes 变量中。

2、接着，使用 for 循环遍历 nodes 数组中的每个元素。在循环体内部，使用 cut 命令从节点信息字符串中分离出主机名和IP地址，并将它们保存在 $hostname 和 $ipaddr 变量中。

3、然后，使用 ssh 命令远程连接到当前节点，并在远程节点上执行脚本。在脚本中，首先定义了一些需要用到的变量，包括接口名、连接名、子网掩码、网关和 DNS 服务器的 IP 地址。

4、使用 nmcli 命令修改网络配置，将静态 IP 地址、子网掩码、网关和 DNS 服务器的 IP 地址分别设置为变量 $ipaddr、$netmask、$gateway 和 $dns 中指定的值。这里采用了静态 IP 地址分配方式，即将 IP 地址和子网掩码合并成一个 CIDR 地址，例如：192.168.1.181/24。

5、使用 nmcli 命令使配置生效，并将网络连接断开并重新连接以更新 IP 地址。

6、最后，输出配置结果，包括设置的静态 IP 地址、子网掩码、网关和 DNS 服务器的 IP 地址。

通过以上步骤，该脚本可以自动遍历多个节点，远程连接到每个节点，并执行静态 IP 地址配置脚本。这样就可以实现在多个节点上快速、自动地配置静态 IP 地址，提高部署效率和减少手动操作的错误。

静态IP自动配置脚本

```
#!/bin/bash

function RED(){
  echo -e "\033[31m$@\033[0m"
}

function GRE(){
  echo -e "\033[36m$@\033[0m"
}

function OS_INFO(){
  # 系统名
  local OS_NAME=`uname -n`
  # 系统版本
  local OS_VERSION=`cat /etc/.kyinfo | grep dist_id | grep -oE "Kylin.*" 2>/dev/null || echo 获取信息失败`
  # 系统类型
  local OS_TYPE=`uname`
  # 主机序列号
  local OS_NUM=`dmidecode -t system | grep 'Serial Number' | awk '{print $3}'`
  # 系统内核版本
  local OS_KERNEL=`uname -r`
  # 系统机器码
  local OS_CODE=""
  # 系统语言环境
  local OS_LANG=`echo $LANG`
  # 系统时间
  local OS_DATE=`date +"%Y-%m-%d %H:%M:%S"`
  # 系统运行时间
  local OS_UPTIME=`uptime | awk -F',' '{sub(/.*up /,"",$1);print $1'} || echo 获取信息失败`
  # 系统上次重启时间
  local OS_LAST_REBOOT=`last reboot | head -1 | awk '{print $5,$6,$7,$8,$10}'`
  # 系统上次关机时间
  local OS_LAST_SHUTDOWN=`last -x | grep shutdown | head -1 | awk '{print $5,$6,$7,$8,$10}'`

  RED "################################# [ 系统信息巡检区 ] ######################################"
  GRE "主机名：$OS_NAME"
  GRE "主机类型：$OS_TYPE"
  GRE "主机序列号：${OS_NUM:-获取信息失败}"
  GRE "系统版本：$OS_VERSION"
  GRE "系统内核版本：$OS_KERNEL"
  GRE "系统机器码：${OS_CODE:-获取信息失败}"
  GRE "系统语言环境：${OS_LANG}"
  GRE "系统时间；$OS_DATE"
  GRE "系统已运行时间：$OS_UPTIME"
  GRE "系统上次重启时间：${OS_LAST_REBOOT:-获取信息失败}"
  GRE "系统上次关机时间：${OS_LAST_SHUTDOWN:-获取信息失败}"
}

function OS_HDWARE(){
  # CPU架构
  local CPU_ARCH=`uname -m`
  # CPU型号
  local CPU_TYPE=`cat /proc/cpuinfo | grep "model name" | uniq | awk -F':' '{sub(/ /,"",$2);print $2}'`
  # CPU个数
  local CPU_NUM=`cat /proc/cpuinfo | grep "physical id" | sort | uniq | wc -l`
  # CPU 核数
  local CPU_CORE=`cat /proc/cpuinfo | grep cores | uniq | awk -F':' '{sub(/ /,"",$2);print $2}'`
  # CPU 频率
  local CPU_HZ=`cat /proc/cpuinfo | grep "cpu MHz" | uniq | awk -F':' '{sub(/ /,"",$2);printf "%s MHz\n",$2}'`

  # 内存容量
  local ME_SIZE=$(echo "scale=2;`cat /proc/meminfo | grep 'MemTotal:' | awk '{print $2}'`/1048576"|bc)
  # 空闲内存
  local ME_FREE=$(echo "scale=2;`cat /proc/meminfo | grep 'MemFree:' | awk '{print $2}'`/1048576"|bc)
  # 可用内存
  local ME_FREEE=$(echo "scale=2;`cat /proc/meminfo | grep 'MemAvailable:' | awk '{print $2}'`/1048576" | bc)
  # 内存使用率
  local ME_USE=$(awk 'BEGIN{printf "%.1f%\n",('$ME_SIZE'-'$ME_FREEE')/'$ME_SIZE'*100}')
  # SWAP大小
  local ME_SWAP_SIZE=$(echo "scale=2;`cat /proc/meminfo | grep 'SwapTotal:' | awk '{print $2}'`/1048576"|bc)
  # SWAP可用
  local ME_SWAP_FREE=$(echo "scale=2;`cat /proc/meminfo | grep 'SwapFree:' | awk '{print $2}'`/1048576"|bc)
  # SWAP使用率
  local ME_SWAP_USE=$(awk 'BEGIN{printf "%.1f%\n",('$ME_SWAP_SIZE'-'$ME_SWAP_FREE')/'$ME_SWAP_SIZE'*100}')
  # Buffer大小
  local ME_BUF=$(cat /proc/meminfo | grep 'Buffers:' | awk '{printf "%s KB",$2}')
  # 内存Cache大小
  local ME_CACHE=$(cat /proc/meminfo | grep '^Cached:' | awk '{printf "%s KB",$2}')

  # 当前系统所有网卡
  local NET_DEVICE=(`cat /proc/net/dev | awk 'NR>2 && $1 !~/lo/ {sub(/:/,"");print $1}'`)

  RED "################################# [ 系统硬件巡检区 ] ######################################"
  GRE "CPU型号：$CPU_TYPE"
  GRE "CPU架构：$CPU_ARCH"
  GRE "CPU个数：$CPU_NUM"
  GRE "CPU核数: $CPU_CORE"
  GRE "CPU频率：$CPU_HZ"
  GRE "内存容量：${ME_SIZE} GB"
  GRE "内存空闲：${ME_FREE} GB"
  GRE "内存可用：${ME_FREEE} GB"
  GRE "内存使用率：${ME_USE}"
  GRE "SWAP容量：$ME_SWAP_SIZE GB"
  GRE "SWAP可用容量：$ME_SWAP_FREE GB"
  GRE "SWAP使用率：$ME_SWAP_USE"
  GRE "内存Buffer大小：${ME_BUF}"
  GRE "内存Cache大小：${ME_CACHE}"

  for i in ${NET_DEVICE[@]}
  do
    GRE "网卡：$i  状态: $(ip link show ens33 | awk 'NR==1{print $9}') RX: $(ethtool -g ens33 | grep "RX:" | tail -1 | awk '{print $2}') TX: $(ethtool -g ens33 | grep "TX:" | tail -1 | awk '{print $2}')"
  done
}

function OS_NETWORK(){
  # 系统IP
  local IP=$(hostname -I)
  # 网关地址
  local GATEWAY=$(ip route | grep default &>/dev/null && ip route | grep default | awk '{print $3}' || echo '未设置默认网关')
  # DNS地址
  local DNS=(`cat /etc/resolv.conf | grep nameserver | uniq | awk '{print $2}'`)

  RED "################################# [ 系统网络巡检区 ] ######################################"
  GRE "IP地址：$IP"
  GRE "网关地址：$GATEWAY"
  GRE "DNS地址：${DNS[@]}"
  GRE "网关[$GATEWAY]连接情况: $(ping -t 1 -i 1 -c 5 -W 1 192.168.0.2 &>/dev/null && echo '正常通信' || echo '无法通信')"
}

function OS_RESOURCE(){
  # 系统磁盘列表
  local DISK_LIST=(`lsblk | egrep "^[a-z].*" | grep -v "^sr" | awk '{print $1}'`)
  # 系统磁盘使用率情况
  local DISK_PER=(`df -h | awk 'NR>1 && $1 !~/sr/ {gsub(/%/,"",$5);print $5}'`)

  # CPU空闲率
  local CPU_FREE=$(top -d 1 -n 1 -b | awk 'NR==3{print $8}')
  # CPU使用率
  local CPU_USE=$(awk 'BEGIN{printf "%.1f%\n",100-'$CPU_FREE'}')
  # CPU_TOP_TEN
  local CPU_TOP_TEN=$(top -d 1 -n 1 -b | column -t | awk 'NR>=7 && NR<=15')

  # 当前进程数
  local CPU_PROCESSORS=$(top -d 1 -n 1 -b | awk 'NR==2{print $2}')
  # 当前正在运行进程数
  local CPU_RUN_PROCESSORS=$(top -d 1 -n 1 -b | awk 'NR==2{print $4}')
  # 当前正在休眠进程数
  local CPU_SL_PROCESSORS=$(top -d 1 -n 1 -b | awk 'NR==2{print $6}')
  # 当前停止运行进程数
  local CPU_STOP_PROCESSORS=$(top -d 1 -n 1 -b | awk 'NR==2{print 8}')
  # 当前僵尸进程数
  local CPU_ZOM_PROCESSORS=$(top -d 1 -n 1 -b | awk 'NR==2{print $10}')
  

  RED "################################# [ 系统资源巡检区 ] ######################################"
  GRE "CPU使用率：$CPU_USE"
  GRE "CPU使用率前十进程信息:"
  GRE "$(ps -eo user,pid,pcpu,pmem,args --sort=-pcpu | head -n 10)"
  GRE "\n内存使用率前十进程信息:"
  GRE "$(ps -eo user,pid,pcpu,pmem,args --sort=-pmem | head -n 10)"
  GRE "\n磁盘IO信息:$(iotop -bon 1 &>/dev/null || echo 'io top 未安装信息获取失败')"
  GRE "$(iotop -bon 1 &>/dev/null && iotop -bon 1 | head -n 13)"
  GRE "\n磁盘分区使用率是否正常：正常"
  for i in ${DISK_LIST[@]}
  do
    if [[ -z "$(lsblk --nodeps -no serial /dev/$i)" ]]; then
      GRE "磁盘：$i  磁盘序列号：获取信息失败"  
    else
      GRE "磁盘：$i  磁盘序列号：$(lsblk --nodeps -no serial /dev/$i)"
    fi
  done
  for i in ${DISK_PER[@]}
  do
    if [ $i -gt 80 ]; then
      RED "某分区磁盘使用率为：$i% > 80% 请及时扩容"
    fi
  done
  GRE "\n系统磁盘分区inode使用情况："
  GRE "$(df -Thi)"
  GRE "\n系统当前进程数：$CPU_PROCESSORS"  
  GRE "系统当前进程运行数：$CPU_RUN_PROCESSORS"
  GRE "系统当前休眠进程数：$CPU_SL_PROCESSORS"
  GRE "系统当前停止进程数：$CPU_STOP_PROCESSORS"
  GRE "系统当前僵尸进程数：$CPU_ZOM_PROCESSORS"

  GRE "\n系统当前允许最大fd数量：$(cat /proc/sys/fs/file-nr | awk '{print $3}')"
  GRE "系统当前已打开fd数量：$(cat /proc/sys/fs/file-nr | awk '{print $1}')"
  GRE "系统单个进程运行打开fd数量：$(ulimit -n)"

  GRE "\n系统当前socket连接数：$(netstat -anp &>/dev/null && netstat -anp | wc -l || echo 'net-tools 未安装,获取信息失败')"
  GRE "系统 established socket数量: $(netstat -anp &>/dev/null && netstat -anp | grep "ESTABLISHED" | wc -l || echo 'net-tools 未安装,获取信息失败')"
  GRE "系统 sync socket数量：$(netstat -anp &>/dev/null && netstat -anp | grep "SYN" | wc -l || echo 'net-tools 未安装,获取信息失败')"
  GRE "系统当前已建立socket如下:"
  GRE "$(netstat -anp &>/dev/null && netstat -anp | grep ESTABLISHED | awk '{printf "  本地:%-20s <=>    外部:%-22s\n",$4,$5}' || echo '')"
}

function OS_SECURITY(){
  # 系统所有能登录的用户
  local OS_USER=(`cat /etc/passwd | awk -F':' '$NF !~/nologin|sync|shutdown|halt/ {print $1}'`)
  # Selinux
  local OS_SELINUX=`getenforce`
  # 防火墙状态
  local OS_FIREWALLD=`service firewalld status &>/dev/null | grep "running" && echo on || echo off`

  RED "################################# [ 系统安全巡检区 ] ######################################"
  GRE "防火墙状态: $OS_FIREWALLD"
  GRE "Selinux状态：${OS_SELINUX}\n"
  GRE "系统可登录用户数：$(cat /etc/passwd | awk -F':' '$NF !~/nologin|sync|shutdown|halt/ {print $1}' | wc -l)"
  GRE "系统可登录用户：${OS_USER[@]}"
  for i in ${OS_USER[@]}
  do
    GRE "用户 $i 最后1次登录信息: $(lastlog -u $i | awk 'NR==2')"
  done
  GRE "系统当前登录用户："
  GRE "$(who | sed 's#[()]##g' | awk '{printf "   用户: %10s 终端: %7s 登录时间: %7s %7s 登录IP: %7s\n",$1,$2,$3,$4,$5}')"
}

function OS_SERVICE(){
  RED "################################# [ 系统服务巡检区 ] ######################################"
  GRE "自行添加"
}

if [ $(id -u -n) != "root" ]; then
  ERROR "请以ROOT用户运行这个脚本"
fi

OS_INFO
OS_HDWARE
OS_NETWORK
OS_RESOURCE
OS_SECURITY
```

Linux巡检脚本

Nexopera是一个专注于Linux、网络和运维等领域的博客网站。将为读者提供广泛的相关文章，涵盖操作系统、服务器管理、网络配置、安全性等多个主题。如果你是初学者，希望这里有适合你的内容。